xref: /openbmc/linux/arch/x86/kernel/kgdb.c (revision 2cf1c348)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  */
4 
5 /*
6  * Copyright (C) 2004 Amit S. Kale <amitkale@linsyssoft.com>
7  * Copyright (C) 2000-2001 VERITAS Software Corporation.
8  * Copyright (C) 2002 Andi Kleen, SuSE Labs
9  * Copyright (C) 2004 LinSysSoft Technologies Pvt. Ltd.
10  * Copyright (C) 2007 MontaVista Software, Inc.
11  * Copyright (C) 2007-2008 Jason Wessel, Wind River Systems, Inc.
12  */
13 /****************************************************************************
14  *  Contributor:     Lake Stevens Instrument Division$
15  *  Written by:      Glenn Engel $
16  *  Updated by:	     Amit Kale<akale@veritas.com>
17  *  Updated by:	     Tom Rini <trini@kernel.crashing.org>
18  *  Updated by:	     Jason Wessel <jason.wessel@windriver.com>
19  *  Modified for 386 by Jim Kingdon, Cygnus Support.
20  *  Original kgdb, compatibility with 2.1.xx kernel by
21  *  David Grothe <dave@gcom.com>
22  *  Integrated into 2.2.5 kernel by Tigran Aivazian <tigran@sco.com>
23  *  X86_64 changes from Andi Kleen's patch merged by Jim Houston
24  */
25 #include <linux/spinlock.h>
26 #include <linux/kdebug.h>
27 #include <linux/string.h>
28 #include <linux/kernel.h>
29 #include <linux/ptrace.h>
30 #include <linux/sched.h>
31 #include <linux/delay.h>
32 #include <linux/kgdb.h>
33 #include <linux/smp.h>
34 #include <linux/nmi.h>
35 #include <linux/hw_breakpoint.h>
36 #include <linux/uaccess.h>
37 #include <linux/memory.h>
38 
39 #include <asm/text-patching.h>
40 #include <asm/debugreg.h>
41 #include <asm/apicdef.h>
42 #include <asm/apic.h>
43 #include <asm/nmi.h>
44 #include <asm/switch_to.h>
45 
46 struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] =
47 {
48 #ifdef CONFIG_X86_32
49 	{ "ax", 4, offsetof(struct pt_regs, ax) },
50 	{ "cx", 4, offsetof(struct pt_regs, cx) },
51 	{ "dx", 4, offsetof(struct pt_regs, dx) },
52 	{ "bx", 4, offsetof(struct pt_regs, bx) },
53 	{ "sp", 4, offsetof(struct pt_regs, sp) },
54 	{ "bp", 4, offsetof(struct pt_regs, bp) },
55 	{ "si", 4, offsetof(struct pt_regs, si) },
56 	{ "di", 4, offsetof(struct pt_regs, di) },
57 	{ "ip", 4, offsetof(struct pt_regs, ip) },
58 	{ "flags", 4, offsetof(struct pt_regs, flags) },
59 	{ "cs", 4, offsetof(struct pt_regs, cs) },
60 	{ "ss", 4, offsetof(struct pt_regs, ss) },
61 	{ "ds", 4, offsetof(struct pt_regs, ds) },
62 	{ "es", 4, offsetof(struct pt_regs, es) },
63 #else
64 	{ "ax", 8, offsetof(struct pt_regs, ax) },
65 	{ "bx", 8, offsetof(struct pt_regs, bx) },
66 	{ "cx", 8, offsetof(struct pt_regs, cx) },
67 	{ "dx", 8, offsetof(struct pt_regs, dx) },
68 	{ "si", 8, offsetof(struct pt_regs, si) },
69 	{ "di", 8, offsetof(struct pt_regs, di) },
70 	{ "bp", 8, offsetof(struct pt_regs, bp) },
71 	{ "sp", 8, offsetof(struct pt_regs, sp) },
72 	{ "r8", 8, offsetof(struct pt_regs, r8) },
73 	{ "r9", 8, offsetof(struct pt_regs, r9) },
74 	{ "r10", 8, offsetof(struct pt_regs, r10) },
75 	{ "r11", 8, offsetof(struct pt_regs, r11) },
76 	{ "r12", 8, offsetof(struct pt_regs, r12) },
77 	{ "r13", 8, offsetof(struct pt_regs, r13) },
78 	{ "r14", 8, offsetof(struct pt_regs, r14) },
79 	{ "r15", 8, offsetof(struct pt_regs, r15) },
80 	{ "ip", 8, offsetof(struct pt_regs, ip) },
81 	{ "flags", 4, offsetof(struct pt_regs, flags) },
82 	{ "cs", 4, offsetof(struct pt_regs, cs) },
83 	{ "ss", 4, offsetof(struct pt_regs, ss) },
84 	{ "ds", 4, -1 },
85 	{ "es", 4, -1 },
86 #endif
87 	{ "fs", 4, -1 },
88 	{ "gs", 4, -1 },
89 };
90 
91 int dbg_set_reg(int regno, void *mem, struct pt_regs *regs)
92 {
93 	if (
94 #ifdef CONFIG_X86_32
95 	    regno == GDB_SS || regno == GDB_FS || regno == GDB_GS ||
96 #endif
97 	    regno == GDB_SP || regno == GDB_ORIG_AX)
98 		return 0;
99 
100 	if (dbg_reg_def[regno].offset != -1)
101 		memcpy((void *)regs + dbg_reg_def[regno].offset, mem,
102 		       dbg_reg_def[regno].size);
103 	return 0;
104 }
105 
106 char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs)
107 {
108 	if (regno == GDB_ORIG_AX) {
109 		memcpy(mem, &regs->orig_ax, sizeof(regs->orig_ax));
110 		return "orig_ax";
111 	}
112 	if (regno >= DBG_MAX_REG_NUM || regno < 0)
113 		return NULL;
114 
115 	if (dbg_reg_def[regno].offset != -1)
116 		memcpy(mem, (void *)regs + dbg_reg_def[regno].offset,
117 		       dbg_reg_def[regno].size);
118 
119 #ifdef CONFIG_X86_32
120 	switch (regno) {
121 	case GDB_GS:
122 	case GDB_FS:
123 		*(unsigned long *)mem = 0xFFFF;
124 		break;
125 	}
126 #endif
127 	return dbg_reg_def[regno].name;
128 }
129 
130 /**
131  *	sleeping_thread_to_gdb_regs - Convert ptrace regs to GDB regs
132  *	@gdb_regs: A pointer to hold the registers in the order GDB wants.
133  *	@p: The &struct task_struct of the desired process.
134  *
135  *	Convert the register values of the sleeping process in @p to
136  *	the format that GDB expects.
137  *	This function is called when kgdb does not have access to the
138  *	&struct pt_regs and therefore it should fill the gdb registers
139  *	@gdb_regs with what has	been saved in &struct thread_struct
140  *	thread field during switch_to.
141  */
142 void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p)
143 {
144 #ifndef CONFIG_X86_32
145 	u32 *gdb_regs32 = (u32 *)gdb_regs;
146 #endif
147 	gdb_regs[GDB_AX]	= 0;
148 	gdb_regs[GDB_BX]	= 0;
149 	gdb_regs[GDB_CX]	= 0;
150 	gdb_regs[GDB_DX]	= 0;
151 	gdb_regs[GDB_SI]	= 0;
152 	gdb_regs[GDB_DI]	= 0;
153 	gdb_regs[GDB_BP]	= ((struct inactive_task_frame *)p->thread.sp)->bp;
154 #ifdef CONFIG_X86_32
155 	gdb_regs[GDB_DS]	= __KERNEL_DS;
156 	gdb_regs[GDB_ES]	= __KERNEL_DS;
157 	gdb_regs[GDB_PS]	= 0;
158 	gdb_regs[GDB_CS]	= __KERNEL_CS;
159 	gdb_regs[GDB_SS]	= __KERNEL_DS;
160 	gdb_regs[GDB_FS]	= 0xFFFF;
161 	gdb_regs[GDB_GS]	= 0xFFFF;
162 #else
163 	gdb_regs32[GDB_PS]	= 0;
164 	gdb_regs32[GDB_CS]	= __KERNEL_CS;
165 	gdb_regs32[GDB_SS]	= __KERNEL_DS;
166 	gdb_regs[GDB_R8]	= 0;
167 	gdb_regs[GDB_R9]	= 0;
168 	gdb_regs[GDB_R10]	= 0;
169 	gdb_regs[GDB_R11]	= 0;
170 	gdb_regs[GDB_R12]	= 0;
171 	gdb_regs[GDB_R13]	= 0;
172 	gdb_regs[GDB_R14]	= 0;
173 	gdb_regs[GDB_R15]	= 0;
174 #endif
175 	gdb_regs[GDB_PC]	= 0;
176 	gdb_regs[GDB_SP]	= p->thread.sp;
177 }
178 
179 static struct hw_breakpoint {
180 	unsigned		enabled;
181 	unsigned long		addr;
182 	int			len;
183 	int			type;
184 	struct perf_event	* __percpu *pev;
185 } breakinfo[HBP_NUM];
186 
187 static unsigned long early_dr7;
188 
189 static void kgdb_correct_hw_break(void)
190 {
191 	int breakno;
192 
193 	for (breakno = 0; breakno < HBP_NUM; breakno++) {
194 		struct perf_event *bp;
195 		struct arch_hw_breakpoint *info;
196 		int val;
197 		int cpu = raw_smp_processor_id();
198 		if (!breakinfo[breakno].enabled)
199 			continue;
200 		if (dbg_is_early) {
201 			set_debugreg(breakinfo[breakno].addr, breakno);
202 			early_dr7 |= encode_dr7(breakno,
203 						breakinfo[breakno].len,
204 						breakinfo[breakno].type);
205 			set_debugreg(early_dr7, 7);
206 			continue;
207 		}
208 		bp = *per_cpu_ptr(breakinfo[breakno].pev, cpu);
209 		info = counter_arch_bp(bp);
210 		if (bp->attr.disabled != 1)
211 			continue;
212 		bp->attr.bp_addr = breakinfo[breakno].addr;
213 		bp->attr.bp_len = breakinfo[breakno].len;
214 		bp->attr.bp_type = breakinfo[breakno].type;
215 		info->address = breakinfo[breakno].addr;
216 		info->len = breakinfo[breakno].len;
217 		info->type = breakinfo[breakno].type;
218 		val = arch_install_hw_breakpoint(bp);
219 		if (!val)
220 			bp->attr.disabled = 0;
221 	}
222 	if (!dbg_is_early)
223 		hw_breakpoint_restore();
224 }
225 
226 static int hw_break_reserve_slot(int breakno)
227 {
228 	int cpu;
229 	int cnt = 0;
230 	struct perf_event **pevent;
231 
232 	if (dbg_is_early)
233 		return 0;
234 
235 	for_each_online_cpu(cpu) {
236 		cnt++;
237 		pevent = per_cpu_ptr(breakinfo[breakno].pev, cpu);
238 		if (dbg_reserve_bp_slot(*pevent))
239 			goto fail;
240 	}
241 
242 	return 0;
243 
244 fail:
245 	for_each_online_cpu(cpu) {
246 		cnt--;
247 		if (!cnt)
248 			break;
249 		pevent = per_cpu_ptr(breakinfo[breakno].pev, cpu);
250 		dbg_release_bp_slot(*pevent);
251 	}
252 	return -1;
253 }
254 
255 static int hw_break_release_slot(int breakno)
256 {
257 	struct perf_event **pevent;
258 	int cpu;
259 
260 	if (dbg_is_early)
261 		return 0;
262 
263 	for_each_online_cpu(cpu) {
264 		pevent = per_cpu_ptr(breakinfo[breakno].pev, cpu);
265 		if (dbg_release_bp_slot(*pevent))
266 			/*
267 			 * The debugger is responsible for handing the retry on
268 			 * remove failure.
269 			 */
270 			return -1;
271 	}
272 	return 0;
273 }
274 
275 static int
276 kgdb_remove_hw_break(unsigned long addr, int len, enum kgdb_bptype bptype)
277 {
278 	int i;
279 
280 	for (i = 0; i < HBP_NUM; i++)
281 		if (breakinfo[i].addr == addr && breakinfo[i].enabled)
282 			break;
283 	if (i == HBP_NUM)
284 		return -1;
285 
286 	if (hw_break_release_slot(i)) {
287 		printk(KERN_ERR "Cannot remove hw breakpoint at %lx\n", addr);
288 		return -1;
289 	}
290 	breakinfo[i].enabled = 0;
291 
292 	return 0;
293 }
294 
295 static void kgdb_remove_all_hw_break(void)
296 {
297 	int i;
298 	int cpu = raw_smp_processor_id();
299 	struct perf_event *bp;
300 
301 	for (i = 0; i < HBP_NUM; i++) {
302 		if (!breakinfo[i].enabled)
303 			continue;
304 		bp = *per_cpu_ptr(breakinfo[i].pev, cpu);
305 		if (!bp->attr.disabled) {
306 			arch_uninstall_hw_breakpoint(bp);
307 			bp->attr.disabled = 1;
308 			continue;
309 		}
310 		if (dbg_is_early)
311 			early_dr7 &= ~encode_dr7(i, breakinfo[i].len,
312 						 breakinfo[i].type);
313 		else if (hw_break_release_slot(i))
314 			printk(KERN_ERR "KGDB: hw bpt remove failed %lx\n",
315 			       breakinfo[i].addr);
316 		breakinfo[i].enabled = 0;
317 	}
318 }
319 
320 static int
321 kgdb_set_hw_break(unsigned long addr, int len, enum kgdb_bptype bptype)
322 {
323 	int i;
324 
325 	for (i = 0; i < HBP_NUM; i++)
326 		if (!breakinfo[i].enabled)
327 			break;
328 	if (i == HBP_NUM)
329 		return -1;
330 
331 	switch (bptype) {
332 	case BP_HARDWARE_BREAKPOINT:
333 		len = 1;
334 		breakinfo[i].type = X86_BREAKPOINT_EXECUTE;
335 		break;
336 	case BP_WRITE_WATCHPOINT:
337 		breakinfo[i].type = X86_BREAKPOINT_WRITE;
338 		break;
339 	case BP_ACCESS_WATCHPOINT:
340 		breakinfo[i].type = X86_BREAKPOINT_RW;
341 		break;
342 	default:
343 		return -1;
344 	}
345 	switch (len) {
346 	case 1:
347 		breakinfo[i].len = X86_BREAKPOINT_LEN_1;
348 		break;
349 	case 2:
350 		breakinfo[i].len = X86_BREAKPOINT_LEN_2;
351 		break;
352 	case 4:
353 		breakinfo[i].len = X86_BREAKPOINT_LEN_4;
354 		break;
355 #ifdef CONFIG_X86_64
356 	case 8:
357 		breakinfo[i].len = X86_BREAKPOINT_LEN_8;
358 		break;
359 #endif
360 	default:
361 		return -1;
362 	}
363 	breakinfo[i].addr = addr;
364 	if (hw_break_reserve_slot(i)) {
365 		breakinfo[i].addr = 0;
366 		return -1;
367 	}
368 	breakinfo[i].enabled = 1;
369 
370 	return 0;
371 }
372 
373 /**
374  *	kgdb_disable_hw_debug - Disable hardware debugging while we in kgdb.
375  *	@regs: Current &struct pt_regs.
376  *
377  *	This function will be called if the particular architecture must
378  *	disable hardware debugging while it is processing gdb packets or
379  *	handling exception.
380  */
381 static void kgdb_disable_hw_debug(struct pt_regs *regs)
382 {
383 	int i;
384 	int cpu = raw_smp_processor_id();
385 	struct perf_event *bp;
386 
387 	/* Disable hardware debugging while we are in kgdb: */
388 	set_debugreg(0UL, 7);
389 	for (i = 0; i < HBP_NUM; i++) {
390 		if (!breakinfo[i].enabled)
391 			continue;
392 		if (dbg_is_early) {
393 			early_dr7 &= ~encode_dr7(i, breakinfo[i].len,
394 						 breakinfo[i].type);
395 			continue;
396 		}
397 		bp = *per_cpu_ptr(breakinfo[i].pev, cpu);
398 		if (bp->attr.disabled == 1)
399 			continue;
400 		arch_uninstall_hw_breakpoint(bp);
401 		bp->attr.disabled = 1;
402 	}
403 }
404 
405 #ifdef CONFIG_SMP
406 /**
407  *	kgdb_roundup_cpus - Get other CPUs into a holding pattern
408  *
409  *	On SMP systems, we need to get the attention of the other CPUs
410  *	and get them be in a known state.  This should do what is needed
411  *	to get the other CPUs to call kgdb_wait(). Note that on some arches,
412  *	the NMI approach is not used for rounding up all the CPUs. For example,
413  *	in case of MIPS, smp_call_function() is used to roundup CPUs.
414  *
415  *	On non-SMP systems, this is not called.
416  */
417 void kgdb_roundup_cpus(void)
418 {
419 	apic_send_IPI_allbutself(NMI_VECTOR);
420 }
421 #endif
422 
423 /**
424  *	kgdb_arch_handle_exception - Handle architecture specific GDB packets.
425  *	@e_vector: The error vector of the exception that happened.
426  *	@signo: The signal number of the exception that happened.
427  *	@err_code: The error code of the exception that happened.
428  *	@remcomInBuffer: The buffer of the packet we have read.
429  *	@remcomOutBuffer: The buffer of %BUFMAX bytes to write a packet into.
430  *	@linux_regs: The &struct pt_regs of the current process.
431  *
432  *	This function MUST handle the 'c' and 's' command packets,
433  *	as well packets to set / remove a hardware breakpoint, if used.
434  *	If there are additional packets which the hardware needs to handle,
435  *	they are handled here.  The code should return -1 if it wants to
436  *	process more packets, and a %0 or %1 if it wants to exit from the
437  *	kgdb callback.
438  */
439 int kgdb_arch_handle_exception(int e_vector, int signo, int err_code,
440 			       char *remcomInBuffer, char *remcomOutBuffer,
441 			       struct pt_regs *linux_regs)
442 {
443 	unsigned long addr;
444 	char *ptr;
445 
446 	switch (remcomInBuffer[0]) {
447 	case 'c':
448 	case 's':
449 		/* try to read optional parameter, pc unchanged if no parm */
450 		ptr = &remcomInBuffer[1];
451 		if (kgdb_hex2long(&ptr, &addr))
452 			linux_regs->ip = addr;
453 		fallthrough;
454 	case 'D':
455 	case 'k':
456 		/* clear the trace bit */
457 		linux_regs->flags &= ~X86_EFLAGS_TF;
458 		atomic_set(&kgdb_cpu_doing_single_step, -1);
459 
460 		/* set the trace bit if we're stepping */
461 		if (remcomInBuffer[0] == 's') {
462 			linux_regs->flags |= X86_EFLAGS_TF;
463 			atomic_set(&kgdb_cpu_doing_single_step,
464 				   raw_smp_processor_id());
465 		}
466 
467 		return 0;
468 	}
469 
470 	/* this means that we do not want to exit from the handler: */
471 	return -1;
472 }
473 
474 static inline int
475 single_step_cont(struct pt_regs *regs, struct die_args *args)
476 {
477 	/*
478 	 * Single step exception from kernel space to user space so
479 	 * eat the exception and continue the process:
480 	 */
481 	printk(KERN_ERR "KGDB: trap/step from kernel to user space, "
482 			"resuming...\n");
483 	kgdb_arch_handle_exception(args->trapnr, args->signr,
484 				   args->err, "c", "", regs);
485 	/*
486 	 * Reset the BS bit in dr6 (pointed by args->err) to
487 	 * denote completion of processing
488 	 */
489 	(*(unsigned long *)ERR_PTR(args->err)) &= ~DR_STEP;
490 
491 	return NOTIFY_STOP;
492 }
493 
494 static DECLARE_BITMAP(was_in_debug_nmi, NR_CPUS);
495 
496 static int kgdb_nmi_handler(unsigned int cmd, struct pt_regs *regs)
497 {
498 	int cpu;
499 
500 	switch (cmd) {
501 	case NMI_LOCAL:
502 		if (atomic_read(&kgdb_active) != -1) {
503 			/* KGDB CPU roundup */
504 			cpu = raw_smp_processor_id();
505 			kgdb_nmicallback(cpu, regs);
506 			set_bit(cpu, was_in_debug_nmi);
507 			touch_nmi_watchdog();
508 
509 			return NMI_HANDLED;
510 		}
511 		break;
512 
513 	case NMI_UNKNOWN:
514 		cpu = raw_smp_processor_id();
515 
516 		if (__test_and_clear_bit(cpu, was_in_debug_nmi))
517 			return NMI_HANDLED;
518 
519 		break;
520 	default:
521 		/* do nothing */
522 		break;
523 	}
524 	return NMI_DONE;
525 }
526 
527 static int __kgdb_notify(struct die_args *args, unsigned long cmd)
528 {
529 	struct pt_regs *regs = args->regs;
530 
531 	switch (cmd) {
532 	case DIE_DEBUG:
533 		if (atomic_read(&kgdb_cpu_doing_single_step) != -1) {
534 			if (user_mode(regs))
535 				return single_step_cont(regs, args);
536 			break;
537 		} else if (test_thread_flag(TIF_SINGLESTEP))
538 			/* This means a user thread is single stepping
539 			 * a system call which should be ignored
540 			 */
541 			return NOTIFY_DONE;
542 		fallthrough;
543 	default:
544 		if (user_mode(regs))
545 			return NOTIFY_DONE;
546 	}
547 
548 	if (kgdb_handle_exception(args->trapnr, args->signr, cmd, regs))
549 		return NOTIFY_DONE;
550 
551 	/* Must touch watchdog before return to normal operation */
552 	touch_nmi_watchdog();
553 	return NOTIFY_STOP;
554 }
555 
556 int kgdb_ll_trap(int cmd, const char *str,
557 		 struct pt_regs *regs, long err, int trap, int sig)
558 {
559 	struct die_args args = {
560 		.regs	= regs,
561 		.str	= str,
562 		.err	= err,
563 		.trapnr	= trap,
564 		.signr	= sig,
565 
566 	};
567 
568 	if (!kgdb_io_module_registered)
569 		return NOTIFY_DONE;
570 
571 	return __kgdb_notify(&args, cmd);
572 }
573 
574 static int
575 kgdb_notify(struct notifier_block *self, unsigned long cmd, void *ptr)
576 {
577 	unsigned long flags;
578 	int ret;
579 
580 	local_irq_save(flags);
581 	ret = __kgdb_notify(ptr, cmd);
582 	local_irq_restore(flags);
583 
584 	return ret;
585 }
586 
587 static struct notifier_block kgdb_notifier = {
588 	.notifier_call	= kgdb_notify,
589 };
590 
591 /**
592  *	kgdb_arch_init - Perform any architecture specific initialization.
593  *
594  *	This function will handle the initialization of any architecture
595  *	specific callbacks.
596  */
597 int kgdb_arch_init(void)
598 {
599 	int retval;
600 
601 	retval = register_die_notifier(&kgdb_notifier);
602 	if (retval)
603 		goto out;
604 
605 	retval = register_nmi_handler(NMI_LOCAL, kgdb_nmi_handler,
606 					0, "kgdb");
607 	if (retval)
608 		goto out1;
609 
610 	retval = register_nmi_handler(NMI_UNKNOWN, kgdb_nmi_handler,
611 					0, "kgdb");
612 
613 	if (retval)
614 		goto out2;
615 
616 	return retval;
617 
618 out2:
619 	unregister_nmi_handler(NMI_LOCAL, "kgdb");
620 out1:
621 	unregister_die_notifier(&kgdb_notifier);
622 out:
623 	return retval;
624 }
625 
626 static void kgdb_hw_overflow_handler(struct perf_event *event,
627 		struct perf_sample_data *data, struct pt_regs *regs)
628 {
629 	struct task_struct *tsk = current;
630 	int i;
631 
632 	for (i = 0; i < 4; i++) {
633 		if (breakinfo[i].enabled)
634 			tsk->thread.virtual_dr6 |= (DR_TRAP0 << i);
635 	}
636 }
637 
638 void kgdb_arch_late(void)
639 {
640 	int i, cpu;
641 	struct perf_event_attr attr;
642 	struct perf_event **pevent;
643 
644 	/*
645 	 * Pre-allocate the hw breakpoint instructions in the non-atomic
646 	 * portion of kgdb because this operation requires mutexs to
647 	 * complete.
648 	 */
649 	hw_breakpoint_init(&attr);
650 	attr.bp_addr = (unsigned long)kgdb_arch_init;
651 	attr.bp_len = HW_BREAKPOINT_LEN_1;
652 	attr.bp_type = HW_BREAKPOINT_W;
653 	attr.disabled = 1;
654 	for (i = 0; i < HBP_NUM; i++) {
655 		if (breakinfo[i].pev)
656 			continue;
657 		breakinfo[i].pev = register_wide_hw_breakpoint(&attr, NULL, NULL);
658 		if (IS_ERR((void * __force)breakinfo[i].pev)) {
659 			printk(KERN_ERR "kgdb: Could not allocate hw"
660 			       "breakpoints\nDisabling the kernel debugger\n");
661 			breakinfo[i].pev = NULL;
662 			kgdb_arch_exit();
663 			return;
664 		}
665 		for_each_online_cpu(cpu) {
666 			pevent = per_cpu_ptr(breakinfo[i].pev, cpu);
667 			pevent[0]->hw.sample_period = 1;
668 			pevent[0]->overflow_handler = kgdb_hw_overflow_handler;
669 			if (pevent[0]->destroy != NULL) {
670 				pevent[0]->destroy = NULL;
671 				release_bp_slot(*pevent);
672 			}
673 		}
674 	}
675 }
676 
677 /**
678  *	kgdb_arch_exit - Perform any architecture specific uninitalization.
679  *
680  *	This function will handle the uninitalization of any architecture
681  *	specific callbacks, for dynamic registration and unregistration.
682  */
683 void kgdb_arch_exit(void)
684 {
685 	int i;
686 	for (i = 0; i < 4; i++) {
687 		if (breakinfo[i].pev) {
688 			unregister_wide_hw_breakpoint(breakinfo[i].pev);
689 			breakinfo[i].pev = NULL;
690 		}
691 	}
692 	unregister_nmi_handler(NMI_UNKNOWN, "kgdb");
693 	unregister_nmi_handler(NMI_LOCAL, "kgdb");
694 	unregister_die_notifier(&kgdb_notifier);
695 }
696 
697 /**
698  *
699  *	kgdb_skipexception - Bail out of KGDB when we've been triggered.
700  *	@exception: Exception vector number
701  *	@regs: Current &struct pt_regs.
702  *
703  *	On some architectures we need to skip a breakpoint exception when
704  *	it occurs after a breakpoint has been removed.
705  *
706  * Skip an int3 exception when it occurs after a breakpoint has been
707  * removed. Backtrack eip by 1 since the int3 would have caused it to
708  * increment by 1.
709  */
710 int kgdb_skipexception(int exception, struct pt_regs *regs)
711 {
712 	if (exception == 3 && kgdb_isremovedbreak(regs->ip - 1)) {
713 		regs->ip -= 1;
714 		return 1;
715 	}
716 	return 0;
717 }
718 
719 unsigned long kgdb_arch_pc(int exception, struct pt_regs *regs)
720 {
721 	if (exception == 3)
722 		return instruction_pointer(regs) - 1;
723 	return instruction_pointer(regs);
724 }
725 
726 void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long ip)
727 {
728 	regs->ip = ip;
729 }
730 
731 int kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
732 {
733 	int err;
734 
735 	bpt->type = BP_BREAKPOINT;
736 	err = copy_from_kernel_nofault(bpt->saved_instr, (char *)bpt->bpt_addr,
737 				BREAK_INSTR_SIZE);
738 	if (err)
739 		return err;
740 	err = copy_to_kernel_nofault((char *)bpt->bpt_addr,
741 				 arch_kgdb_ops.gdb_bpt_instr, BREAK_INSTR_SIZE);
742 	if (!err)
743 		return err;
744 	/*
745 	 * It is safe to call text_poke_kgdb() because normal kernel execution
746 	 * is stopped on all cores, so long as the text_mutex is not locked.
747 	 */
748 	if (mutex_is_locked(&text_mutex))
749 		return -EBUSY;
750 	text_poke_kgdb((void *)bpt->bpt_addr, arch_kgdb_ops.gdb_bpt_instr,
751 		       BREAK_INSTR_SIZE);
752 	bpt->type = BP_POKE_BREAKPOINT;
753 
754 	return 0;
755 }
756 
757 int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
758 {
759 	if (bpt->type != BP_POKE_BREAKPOINT)
760 		goto knl_write;
761 	/*
762 	 * It is safe to call text_poke_kgdb() because normal kernel execution
763 	 * is stopped on all cores, so long as the text_mutex is not locked.
764 	 */
765 	if (mutex_is_locked(&text_mutex))
766 		goto knl_write;
767 	text_poke_kgdb((void *)bpt->bpt_addr, bpt->saved_instr,
768 		       BREAK_INSTR_SIZE);
769 	return 0;
770 
771 knl_write:
772 	return copy_to_kernel_nofault((char *)bpt->bpt_addr,
773 				  (char *)bpt->saved_instr, BREAK_INSTR_SIZE);
774 }
775 
776 const struct kgdb_arch arch_kgdb_ops = {
777 	/* Breakpoint instruction: */
778 	.gdb_bpt_instr		= { 0xcc },
779 	.flags			= KGDB_HW_BREAKPOINT,
780 	.set_hw_breakpoint	= kgdb_set_hw_break,
781 	.remove_hw_breakpoint	= kgdb_remove_hw_break,
782 	.disable_hw_break	= kgdb_disable_hw_debug,
783 	.remove_all_hw_break	= kgdb_remove_all_hw_break,
784 	.correct_hw_break	= kgdb_correct_hw_break,
785 };
786