WebSVN – HelenOS – Diff – /trunk/kernel/arch/amd64/src/debugger.c


/*
 * Copyright (c) 2006 Ondrej Palkovsky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup amd64debug
 * @{
 */
/** @file
 */
 
#include <arch/debugger.h>
#include <console/kconsole.h>
#include <console/cmd.h>
#include <symtab.h>
#include <print.h>
#include <panic.h>
#include <interrupt.h>
#include <arch/asm.h>
#include <arch/cpu.h>
#include <debug.h>
#include <func.h>
#include <smp/ipi.h>
 
typedef struct  {
    uintptr_t address;      /**< Breakpoint address */
    int flags;              /**< Flags regarding breakpoint */
    int counter;            /**< How many times the exception occured */
} bpinfo_t;
 
static bpinfo_t breakpoints[BKPOINTS_MAX];
SPINLOCK_INITIALIZE(bkpoint_lock);
 
#ifdef CONFIG_KCONSOLE
 
static int cmd_print_breakpoints(cmd_arg_t *argv);
static cmd_info_t bkpts_info = {
    .name = "bkpts",
    .description = "Print breakpoint table.",
    .func = cmd_print_breakpoints,
    .argc = 0,
};
 
#ifndef CONFIG_DEBUG_AS_WATCHPOINT
 
static int cmd_del_breakpoint(cmd_arg_t *argv);
static cmd_arg_t del_argv = {
    .type = ARG_TYPE_INT
};
static cmd_info_t delbkpt_info = {
    .name = "delbkpt",
    .description = "delbkpt <number> - Delete breakpoint.",
    .func = cmd_del_breakpoint,
    .argc = 1,
    .argv = &del_argv
};
 
static int cmd_add_breakpoint(cmd_arg_t *argv);
static cmd_arg_t add_argv = {
    .type = ARG_TYPE_INT
};
static cmd_info_t addbkpt_info = {
    .name = "addbkpt",
    .description = "addbkpt <&symbol> - new breakpoint.",
    .func = cmd_add_breakpoint,
    .argc = 1,
    .argv = &add_argv
};
 
static cmd_arg_t addw_argv = {
    .type = ARG_TYPE_INT
};
static cmd_info_t addwatchp_info = {
    .name = "addwatchp",
    .description = "addbwatchp <&symbol> - new write watchpoint.",
    .func = cmd_add_breakpoint,
    .argc = 1,
    .argv = &addw_argv
};
 
#endif /* CONFIG_DEBUG_AS_WATCHPOINT */
#endif /* CONFIG_KCONSOLE */
 
/* Setup DR register according to table */
static void setup_dr(int curidx)
{
    unative_t dr7;
    bpinfo_t *cur = &breakpoints[curidx];
    int flags = breakpoints[curidx].flags;
 
    /* Disable breakpoint in DR7 */
    dr7 = read_dr7();
    dr7 &= ~(0x2 << (curidx*2));
 
    if (cur->address) { /* Setup DR register */
        /* Set breakpoint to debug registers */
        switch (curidx) {
        case 0:
            write_dr0(cur->address);
            break;
        case 1:
            write_dr1(cur->address);
            break;
        case 2:
            write_dr2(cur->address);
            break;
        case 3:
            write_dr3(cur->address);
            break;
        }
        /* Set type to requested breakpoint & length*/
        dr7 &= ~ (0x3 << (16 + 4*curidx));
        dr7 &= ~ (0x3 << (18 + 4*curidx));
        if ((flags & BKPOINT_INSTR)) {
            ;
        } else {
       
#ifdef __32_BITS__
            dr7 |= ((unative_t) 0x3) << (18 + 4 * curidx);
#endif
 
#ifdef __64_BITS__
            dr7 |= ((unative_t) 0x2) << (18 + 4 * curidx);
#endif
           
            if ((flags & BKPOINT_WRITE))
                dr7 |= ((unative_t) 0x1) << (16 + 4 * curidx);
            else if ((flags & BKPOINT_READ_WRITE))
                dr7 |= ((unative_t) 0x3) << (16 + 4 * curidx);
        }
 
        /* Enable global breakpoint */
        dr7 |= 0x2 << (curidx * 2);
 
        write_dr7(dr7);
       
    }
}
   
/** Enable hardware breakpoint
 *
 * @param where Address of HW breakpoint
 * @param flags Type of breakpoint (EXECUTE, WRITE)
 * @return Debug slot on success, -1 - no available HW breakpoint
 */
int breakpoint_add(const void *where, const int flags, int curidx)
{
    ipl_t ipl;
    int i;
    bpinfo_t *cur;
 
    ASSERT(flags & (BKPOINT_INSTR | BKPOINT_WRITE | BKPOINT_READ_WRITE));
 
    ipl = interrupts_disable();
    spinlock_lock(&bkpoint_lock);
   
    if (curidx == -1) {
        /* Find free space in slots */
        for (i = 0; i < BKPOINTS_MAX; i++)
            if (!breakpoints[i].address) {
                curidx = i;
                break;
            }
        if (curidx == -1) {
            /* Too many breakpoints */
            spinlock_unlock(&bkpoint_lock);
            interrupts_restore(ipl);
            return -1;
        }
    }
    cur = &breakpoints[curidx];
 
    cur->address = (uintptr_t) where;
    cur->flags = flags;
    cur->counter = 0;
 
    setup_dr(curidx);
 
    spinlock_unlock(&bkpoint_lock);
    interrupts_restore(ipl);
 
    /* Send IPI */
#ifdef CONFIG_SMP
//  ipi_broadcast(VECTOR_DEBUG_IPI);
#endif  
 
    return curidx;
}
 
#ifdef __64_BITS__
    #define getip(x)  ((x)->rip)
#else
    #define getip(x)  ((x)->eip)
#endif
 
static void handle_exception(int slot, istate_t *istate)
{
    ASSERT(breakpoints[slot].address);
 
    /* Handle zero checker */
    if (! (breakpoints[slot].flags & BKPOINT_INSTR)) {
        if ((breakpoints[slot].flags & BKPOINT_CHECK_ZERO)) {
            if (*((unative_t *) breakpoints[slot].address) != 0)
                return;
            printf("*** Found ZERO on address %lx (slot %d) ***\n",
                breakpoints[slot].address, slot);
        } else {
            printf("Data watchpoint - new data: %lx\n",
                *((unative_t *) breakpoints[slot].address));
        }
    }
    printf("Reached breakpoint %d:%lx(%s)\n", slot, getip(istate),
        get_symtab_entry(getip(istate)));
 
#ifdef CONFIG_KCONSOLE
    atomic_set(&haltstate, 1);
    kconsole("debug", "Debug console ready (type 'exit' to continue)\n", false);
    atomic_set(&haltstate, 0);
#endif
}
 
void breakpoint_del(int slot)
{
    bpinfo_t *cur;
    ipl_t ipl;
 
    ipl = interrupts_disable();
    spinlock_lock(&bkpoint_lock);
 
    cur = &breakpoints[slot];
    if (!cur->address) {
        spinlock_unlock(&bkpoint_lock);
        interrupts_restore(ipl);
        return;
    }
 
    cur->address = NULL;
 
    setup_dr(slot);
 
    spinlock_unlock(&bkpoint_lock);
    interrupts_restore(ipl);
#ifdef CONFIG_SMP
//  ipi_broadcast(VECTOR_DEBUG_IPI);    
#endif
}
 
 
 
static void debug_exception(int n __attribute__((unused)), istate_t *istate)
{
    unative_t dr6;
    int i;
   
    /* Set RF to restart the instruction  */
#ifdef __64_BITS__
    istate->rflags |= RFLAGS_RF;
#else
    istate->eflags |= EFLAGS_RF;
#endif
 
    dr6 = read_dr6();
    for (i=0; i < BKPOINTS_MAX; i++) {
        if (dr6 & (1 << i)) {
            dr6 &= ~ (1 << i);
            write_dr6(dr6);
           
            handle_exception(i, istate);
        }
    }
}
 
#ifdef CONFIG_SMP
static void
debug_ipi(int n __attribute__((unused)),
    istate_t *istate __attribute__((unused)))
{
    int i;
 
    spinlock_lock(&bkpoint_lock);
    for (i = 0; i < BKPOINTS_MAX; i++)
        setup_dr(i);
    spinlock_unlock(&bkpoint_lock);
}
#endif
 
/** Initialize debugger */
void debugger_init()
{
    int i;
 
    for (i = 0; i < BKPOINTS_MAX; i++)
        breakpoints[i].address = NULL;
 
#ifdef CONFIG_KCONSOLE
    cmd_initialize(&bkpts_info);
    if (!cmd_register(&bkpts_info))
        printf("Cannot register command %s\n", bkpts_info.name);
 
#ifndef CONFIG_DEBUG_AS_WATCHPOINT
    cmd_initialize(&delbkpt_info);
    if (!cmd_register(&delbkpt_info))
        printf("Cannot register command %s\n", delbkpt_info.name);
 
    cmd_initialize(&addbkpt_info);
    if (!cmd_register(&addbkpt_info))
        printf("Cannot register command %s\n", addbkpt_info.name);
 
    cmd_initialize(&addwatchp_info);
    if (!cmd_register(&addwatchp_info))
        printf("Cannot register command %s\n", addwatchp_info.name);
#endif /* CONFIG_DEBUG_AS_WATCHPOINT */
#endif /* CONFIG_KCONSOLE */
   
    exc_register(VECTOR_DEBUG, "debugger", debug_exception);
#ifdef CONFIG_SMP
    exc_register(VECTOR_DEBUG_IPI, "debugger_smp", debug_ipi);
#endif
}
 
#ifdef CONFIG_KCONSOLE
/** Print table of active breakpoints */
int cmd_print_breakpoints(cmd_arg_t *argv __attribute__((unused)))
{
    unsigned int i;
    char *symbol;
 
#ifdef __32_BITS__
    printf("#  Count Address    In symbol\n");
    printf("-- ----- ---------- ---------\n");
#endif
 
#ifdef __64_BITS__
    printf("#  Count Address            In symbol\n");
    printf("-- ----- ------------------ ---------\n");
#endif
   
    for (i = 0; i < BKPOINTS_MAX; i++)
        if (breakpoints[i].address) {
            symbol = get_symtab_entry(breakpoints[i].address);
 
#ifdef __32_BITS__
            printf("%-2u %-5d %#10zx %s\n", i,
                breakpoints[i].counter, breakpoints[i].address,
                symbol);
#endif
 
#ifdef __64_BITS__
            printf("%-2u %-5d %#18zx %s\n", i,
                breakpoints[i].counter, breakpoints[i].address,
                symbol);
#endif
 
        }
    return 1;
}
 
#ifndef CONFIG_DEBUG_AS_WATCHPOINT
 
/** Remove breakpoint from table */
int cmd_del_breakpoint(cmd_arg_t *argv)
{
    unative_t bpno = argv->intval;
    if (bpno > BKPOINTS_MAX) {
        printf("Invalid breakpoint number.\n");
        return 0;
    }
    breakpoint_del(argv->intval);
    return 1;
}
 
/** Add new breakpoint to table */
static int cmd_add_breakpoint(cmd_arg_t *argv)
{
    int flags;
    int id;
 
    if (argv == &add_argv) {
        flags = BKPOINT_INSTR;
    } else { /* addwatchp */
        flags = BKPOINT_WRITE;
    }
    printf("Adding breakpoint on address: %p\n", argv->intval);
    id = breakpoint_add((void *)argv->intval, flags, -1);
    if (id < 0)
        printf("Add breakpoint failed.\n");
    else
        printf("Added breakpoint %d.\n", id);
   
    return 1;
}
#endif /* CONFIG_DEBUG_AS_WATCHPOINT */
#endif /* CONFIG_KCONSOLE */
 
/** @}
 */
 

Rev 3707	Rev 3880
1	/*	1	/*
2	* Copyright (c) 2006 Ondrej Palkovsky	2	* Copyright (c) 2006 Ondrej Palkovsky
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup amd64debug	29	/** @addtogroup amd64debug
30	* @{	30	* @{
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#include <arch/debugger.h>	35	#include <arch/debugger.h>
36	#include <console/kconsole.h>	36	#include <console/kconsole.h>
37	#include <console/cmd.h>	37	#include <console/cmd.h>
38	#include <symtab.h>	38	#include <symtab.h>
39	#include <print.h>	39	#include <print.h>
40	#include <panic.h>	40	#include <panic.h>
41	#include <interrupt.h>	41	#include <interrupt.h>
42	#include <arch/asm.h>	42	#include <arch/asm.h>
43	#include <arch/cpu.h>	43	#include <arch/cpu.h>
44	#include <debug.h>	44	#include <debug.h>
45	#include <func.h>	45	#include <func.h>
46	#include <smp/ipi.h>	46	#include <smp/ipi.h>
47		47
48	typedef struct {	48	typedef struct {
49	uintptr_t address; /*< Breakpoint address /	49	uintptr_t address; /*< Breakpoint address /
50	int flags; /*< Flags regarding breakpoint /	50	int flags; /*< Flags regarding breakpoint /
51	int counter; /*< How many times the exception occured /	51	int counter; /*< How many times the exception occured /
52	} bpinfo_t;	52	} bpinfo_t;
53		53
54	static bpinfo_t breakpoints[BKPOINTS_MAX];	54	static bpinfo_t breakpoints[BKPOINTS_MAX];
55	SPINLOCK_INITIALIZE(bkpoint_lock);	55	SPINLOCK_INITIALIZE(bkpoint_lock);
56		56
57	#ifdef CONFIG_KCONSOLE	57	#ifdef CONFIG_KCONSOLE
58		58
59	static int cmd_print_breakpoints(cmd_arg_t *argv);	59	static int cmd_print_breakpoints(cmd_arg_t *argv);
60	static cmd_info_t bkpts_info = {	60	static cmd_info_t bkpts_info = {
61	.name = "bkpts",	61	.name = "bkpts",
62	.description = "Print breakpoint table.",	62	.description = "Print breakpoint table.",
63	.func = cmd_print_breakpoints,	63	.func = cmd_print_breakpoints,
64	.argc = 0,	64	.argc = 0,
65	};	65	};
66		66
67	#ifndef CONFIG_DEBUG_AS_WATCHPOINT	67	#ifndef CONFIG_DEBUG_AS_WATCHPOINT
68		68
69	static int cmd_del_breakpoint(cmd_arg_t *argv);	69	static int cmd_del_breakpoint(cmd_arg_t *argv);
70	static cmd_arg_t del_argv = {	70	static cmd_arg_t del_argv = {
71	.type = ARG_TYPE_INT	71	.type = ARG_TYPE_INT
72	};	72	};
73	static cmd_info_t delbkpt_info = {	73	static cmd_info_t delbkpt_info = {
74	.name = "delbkpt",	74	.name = "delbkpt",
75	.description = "delbkpt <number> - Delete breakpoint.",	75	.description = "delbkpt <number> - Delete breakpoint.",
76	.func = cmd_del_breakpoint,	76	.func = cmd_del_breakpoint,
77	.argc = 1,	77	.argc = 1,
78	.argv = &del_argv	78	.argv = &del_argv
79	};	79	};
80		80
81	static int cmd_add_breakpoint(cmd_arg_t *argv);	81	static int cmd_add_breakpoint(cmd_arg_t *argv);
82	static cmd_arg_t add_argv = {	82	static cmd_arg_t add_argv = {
83	.type = ARG_TYPE_INT	83	.type = ARG_TYPE_INT
84	};	84	};
85	static cmd_info_t addbkpt_info = {	85	static cmd_info_t addbkpt_info = {
86	.name = "addbkpt",	86	.name = "addbkpt",
87	.description = "addbkpt <&symbol> - new breakpoint.",	87	.description = "addbkpt <&symbol> - new breakpoint.",
88	.func = cmd_add_breakpoint,	88	.func = cmd_add_breakpoint,
89	.argc = 1,	89	.argc = 1,
90	.argv = &add_argv	90	.argv = &add_argv
91	};	91	};
92		92
93	static cmd_arg_t addw_argv = {	93	static cmd_arg_t addw_argv = {
94	.type = ARG_TYPE_INT	94	.type = ARG_TYPE_INT
95	};	95	};
96	static cmd_info_t addwatchp_info = {	96	static cmd_info_t addwatchp_info = {
97	.name = "addwatchp",	97	.name = "addwatchp",
98	.description = "addbwatchp <&symbol> - new write watchpoint.",	98	.description = "addbwatchp <&symbol> - new write watchpoint.",
99	.func = cmd_add_breakpoint,	99	.func = cmd_add_breakpoint,
100	.argc = 1,	100	.argc = 1,
101	.argv = &addw_argv	101	.argv = &addw_argv
102	};	102	};
103		103
104	#endif /* CONFIG_DEBUG_AS_WATCHPOINT */	104	#endif /* CONFIG_DEBUG_AS_WATCHPOINT */
105	#endif /* CONFIG_KCONSOLE */	105	#endif /* CONFIG_KCONSOLE */
106		106
107	/* Setup DR register according to table */	107	/* Setup DR register according to table */
108	static void setup_dr(int curidx)	108	static void setup_dr(int curidx)
109	{	109	{
110	unative_t dr7;	110	unative_t dr7;
111	bpinfo_t *cur = &breakpoints[curidx];	111	bpinfo_t *cur = &breakpoints[curidx];
112	int flags = breakpoints[curidx].flags;	112	int flags = breakpoints[curidx].flags;
113		113
114	/* Disable breakpoint in DR7 */	114	/* Disable breakpoint in DR7 */
115	dr7 = read_dr7();	115	dr7 = read_dr7();
116	dr7 &= ~(0x2 << (curidx*2));	116	dr7 &= ~(0x2 << (curidx*2));
117		117
118	if (cur->address) { /* Setup DR register */	118	if (cur->address) { /* Setup DR register */
119	/* Set breakpoint to debug registers */	119	/* Set breakpoint to debug registers */
120	switch (curidx) {	120	switch (curidx) {
121	case 0:	121	case 0:
122	write_dr0(cur->address);	122	write_dr0(cur->address);
123	break;	123	break;
124	case 1:	124	case 1:
125	write_dr1(cur->address);	125	write_dr1(cur->address);
126	break;	126	break;
127	case 2:	127	case 2:
128	write_dr2(cur->address);	128	write_dr2(cur->address);
129	break;	129	break;
130	case 3:	130	case 3:
131	write_dr3(cur->address);	131	write_dr3(cur->address);
132	break;	132	break;
133	}	133	}
134	/* Set type to requested breakpoint & length*/	134	/* Set type to requested breakpoint & length*/
135	dr7 &= ~ (0x3 << (16 + 4*curidx));	135	dr7 &= ~ (0x3 << (16 + 4*curidx));
136	dr7 &= ~ (0x3 << (18 + 4*curidx));	136	dr7 &= ~ (0x3 << (18 + 4*curidx));
137	if ((flags & BKPOINT_INSTR)) {	137	if ((flags & BKPOINT_INSTR)) {
138	;	138	;
139	} else {	139	} else {
140		140
141	#ifdef __32_BITS__	141	#ifdef __32_BITS__
142	dr7 \|= ((unative_t) 0x3) << (18 + 4 * curidx);	142	dr7 \|= ((unative_t) 0x3) << (18 + 4 * curidx);
143	#endif	143	#endif
144		144
145	#ifdef __64_BITS__	145	#ifdef __64_BITS__
146	dr7 \|= ((unative_t) 0x2) << (18 + 4 * curidx);	146	dr7 \|= ((unative_t) 0x2) << (18 + 4 * curidx);
147	#endif	147	#endif
148		148
149	if ((flags & BKPOINT_WRITE))	149	if ((flags & BKPOINT_WRITE))
150	dr7 \|= ((unative_t) 0x1) << (16 + 4 * curidx);	150	dr7 \|= ((unative_t) 0x1) << (16 + 4 * curidx);
151	else if ((flags & BKPOINT_READ_WRITE))	151	else if ((flags & BKPOINT_READ_WRITE))
152	dr7 \|= ((unative_t) 0x3) << (16 + 4 * curidx);	152	dr7 \|= ((unative_t) 0x3) << (16 + 4 * curidx);
153	}	153	}
154		154
155	/* Enable global breakpoint */	155	/* Enable global breakpoint */
156	dr7 \|= 0x2 << (curidx * 2);	156	dr7 \|= 0x2 << (curidx * 2);
157		157
158	write_dr7(dr7);	158	write_dr7(dr7);
159		159
160	}	160	}
161	}	161	}
162		162
163	/** Enable hardware breakpoint	163	/** Enable hardware breakpoint
164	*	164	*
165	* @param where Address of HW breakpoint	165	* @param where Address of HW breakpoint
166	* @param flags Type of breakpoint (EXECUTE, WRITE)	166	* @param flags Type of breakpoint (EXECUTE, WRITE)
167	* @return Debug slot on success, -1 - no available HW breakpoint	167	* @return Debug slot on success, -1 - no available HW breakpoint
168	*/	168	*/
169	int breakpoint_add(const void *where, const int flags, int curidx)	169	int breakpoint_add(const void *where, const int flags, int curidx)
170	{	170	{
171	ipl_t ipl;	171	ipl_t ipl;
172	int i;	172	int i;
173	bpinfo_t *cur;	173	bpinfo_t *cur;
174		174
175	ASSERT(flags & (BKPOINT_INSTR \| BKPOINT_WRITE \| BKPOINT_READ_WRITE));	175	ASSERT(flags & (BKPOINT_INSTR \| BKPOINT_WRITE \| BKPOINT_READ_WRITE));
176		176
177	ipl = interrupts_disable();	177	ipl = interrupts_disable();
178	spinlock_lock(&bkpoint_lock);	178	spinlock_lock(&bkpoint_lock);
179		179
180	if (curidx == -1) {	180	if (curidx == -1) {
181	/* Find free space in slots */	181	/* Find free space in slots */
182	for (i = 0; i < BKPOINTS_MAX; i++)	182	for (i = 0; i < BKPOINTS_MAX; i++)
183	if (!breakpoints[i].address) {	183	if (!breakpoints[i].address) {
184	curidx = i;	184	curidx = i;
185	break;	185	break;
186	}	186	}
187	if (curidx == -1) {	187	if (curidx == -1) {
188	/* Too many breakpoints */	188	/* Too many breakpoints */
189	spinlock_unlock(&bkpoint_lock);	189	spinlock_unlock(&bkpoint_lock);
190	interrupts_restore(ipl);	190	interrupts_restore(ipl);
191	return -1;	191	return -1;
192	}	192	}
193	}	193	}
194	cur = &breakpoints[curidx];	194	cur = &breakpoints[curidx];
195		195
196	cur->address = (uintptr_t) where;	196	cur->address = (uintptr_t) where;
197	cur->flags = flags;	197	cur->flags = flags;
198	cur->counter = 0;	198	cur->counter = 0;
199		199
200	setup_dr(curidx);	200	setup_dr(curidx);
201		201
202	spinlock_unlock(&bkpoint_lock);	202	spinlock_unlock(&bkpoint_lock);
203	interrupts_restore(ipl);	203	interrupts_restore(ipl);
204		204
205	/* Send IPI */	205	/* Send IPI */
206	#ifdef CONFIG_SMP	206	#ifdef CONFIG_SMP
207	// ipi_broadcast(VECTOR_DEBUG_IPI);	207	// ipi_broadcast(VECTOR_DEBUG_IPI);
208	#endif	208	#endif
209		209
210	return curidx;	210	return curidx;
211	}	211	}
212		212
213	#ifdef amd64	213	#ifdef __64_BITS__
214	# define getip(x) ((x)->rip)	214	#define getip(x) ((x)->rip)
215	#else	215	#else
216	# define getip(x) ((x)->eip)	216	#define getip(x) ((x)->eip)
217	#endif	217	#endif
218		218
219	static void handle_exception(int slot, istate_t *istate)	219	static void handle_exception(int slot, istate_t *istate)
220	{	220	{
221	ASSERT(breakpoints[slot].address);	221	ASSERT(breakpoints[slot].address);
222		222
223	/* Handle zero checker */	223	/* Handle zero checker */
224	if (! (breakpoints[slot].flags & BKPOINT_INSTR)) {	224	if (! (breakpoints[slot].flags & BKPOINT_INSTR)) {
225	if ((breakpoints[slot].flags & BKPOINT_CHECK_ZERO)) {	225	if ((breakpoints[slot].flags & BKPOINT_CHECK_ZERO)) {
226	if (((unative_t ) breakpoints[slot].address) != 0)	226	if (((unative_t ) breakpoints[slot].address) != 0)
227	return;	227	return;
228	printf("* Found ZERO on address %lx (slot %d) *\n",	228	printf("* Found ZERO on address %lx (slot %d) *\n",
229	breakpoints[slot].address, slot);	229	breakpoints[slot].address, slot);
230	} else {	230	} else {
231	printf("Data watchpoint - new data: %lx\n",	231	printf("Data watchpoint - new data: %lx\n",
232	((unative_t ) breakpoints[slot].address));	232	((unative_t ) breakpoints[slot].address));
233	}	233	}
234	}	234	}
235	printf("Reached breakpoint %d:%lx(%s)\n", slot, getip(istate),	235	printf("Reached breakpoint %d:%lx(%s)\n", slot, getip(istate),
236	get_symtab_entry(getip(istate)));	236	get_symtab_entry(getip(istate)));
237		237
238	#ifdef CONFIG_KCONSOLE	238	#ifdef CONFIG_KCONSOLE
239	atomic_set(&haltstate, 1);	239	atomic_set(&haltstate, 1);
240	kconsole("debug", "Debug console ready (type 'exit' to continue)\n", false);	240	kconsole("debug", "Debug console ready (type 'exit' to continue)\n", false);
241	atomic_set(&haltstate, 0);	241	atomic_set(&haltstate, 0);
242	#endif	242	#endif
243	}	243	}
244		244
245	void breakpoint_del(int slot)	245	void breakpoint_del(int slot)
246	{	246	{
247	bpinfo_t *cur;	247	bpinfo_t *cur;
248	ipl_t ipl;	248	ipl_t ipl;
249		249
250	ipl = interrupts_disable();	250	ipl = interrupts_disable();
251	spinlock_lock(&bkpoint_lock);	251	spinlock_lock(&bkpoint_lock);
252		252
253	cur = &breakpoints[slot];	253	cur = &breakpoints[slot];
254	if (!cur->address) {	254	if (!cur->address) {
255	spinlock_unlock(&bkpoint_lock);	255	spinlock_unlock(&bkpoint_lock);
256	interrupts_restore(ipl);	256	interrupts_restore(ipl);
257	return;	257	return;
258	}	258	}
259		259
260	cur->address = NULL;	260	cur->address = NULL;
261		261
262	setup_dr(slot);	262	setup_dr(slot);
263		263
264	spinlock_unlock(&bkpoint_lock);	264	spinlock_unlock(&bkpoint_lock);
265	interrupts_restore(ipl);	265	interrupts_restore(ipl);
266	#ifdef CONFIG_SMP	266	#ifdef CONFIG_SMP
267	// ipi_broadcast(VECTOR_DEBUG_IPI);	267	// ipi_broadcast(VECTOR_DEBUG_IPI);
268	#endif	268	#endif
269	}	269	}
270		270
271		271
272		272
273	static void debug_exception(int n __attribute__((unused)), istate_t *istate)	273	static void debug_exception(int n __attribute__((unused)), istate_t *istate)
274	{	274	{
275	unative_t dr6;	275	unative_t dr6;
276	int i;	276	int i;
277		277
278	/* Set RF to restart the instruction */	278	/* Set RF to restart the instruction */
279	#ifdef amd64	279	#ifdef __64_BITS__
280	istate->rflags \|= RFLAGS_RF;	280	istate->rflags \|= RFLAGS_RF;
281	#else	281	#else
282	istate->eflags \|= EFLAGS_RF;	282	istate->eflags \|= EFLAGS_RF;
283	#endif	283	#endif
284		284
285	dr6 = read_dr6();	285	dr6 = read_dr6();
286	for (i=0; i < BKPOINTS_MAX; i++) {	286	for (i=0; i < BKPOINTS_MAX; i++) {
287	if (dr6 & (1 << i)) {	287	if (dr6 & (1 << i)) {
288	dr6 &= ~ (1 << i);	288	dr6 &= ~ (1 << i);
289	write_dr6(dr6);	289	write_dr6(dr6);
290		290
291	handle_exception(i, istate);	291	handle_exception(i, istate);
292	}	292	}
293	}	293	}
294	}	294	}
295		295
296	#ifdef CONFIG_SMP	296	#ifdef CONFIG_SMP
297	static void	297	static void
298	debug_ipi(int n __attribute__((unused)),	298	debug_ipi(int n __attribute__((unused)),
299	istate_t *istate __attribute__((unused)))	299	istate_t *istate __attribute__((unused)))
300	{	300	{
301	int i;	301	int i;
302		302
303	spinlock_lock(&bkpoint_lock);	303	spinlock_lock(&bkpoint_lock);
304	for (i = 0; i < BKPOINTS_MAX; i++)	304	for (i = 0; i < BKPOINTS_MAX; i++)
305	setup_dr(i);	305	setup_dr(i);
306	spinlock_unlock(&bkpoint_lock);	306	spinlock_unlock(&bkpoint_lock);
307	}	307	}
308	#endif	308	#endif
309		309
310	/** Initialize debugger */	310	/** Initialize debugger */
311	void debugger_init()	311	void debugger_init()
312	{	312	{
313	int i;	313	int i;
314		314
315	for (i = 0; i < BKPOINTS_MAX; i++)	315	for (i = 0; i < BKPOINTS_MAX; i++)
316	breakpoints[i].address = NULL;	316	breakpoints[i].address = NULL;
317		317
318	#ifdef CONFIG_KCONSOLE	318	#ifdef CONFIG_KCONSOLE
319	cmd_initialize(&bkpts_info);	319	cmd_initialize(&bkpts_info);
320	if (!cmd_register(&bkpts_info))	320	if (!cmd_register(&bkpts_info))
321	printf("Cannot register command %s\n", bkpts_info.name);	321	printf("Cannot register command %s\n", bkpts_info.name);
322		322
323	#ifndef CONFIG_DEBUG_AS_WATCHPOINT	323	#ifndef CONFIG_DEBUG_AS_WATCHPOINT
324	cmd_initialize(&delbkpt_info);	324	cmd_initialize(&delbkpt_info);
325	if (!cmd_register(&delbkpt_info))	325	if (!cmd_register(&delbkpt_info))
326	printf("Cannot register command %s\n", delbkpt_info.name);	326	printf("Cannot register command %s\n", delbkpt_info.name);
327		327
328	cmd_initialize(&addbkpt_info);	328	cmd_initialize(&addbkpt_info);
329	if (!cmd_register(&addbkpt_info))	329	if (!cmd_register(&addbkpt_info))
330	printf("Cannot register command %s\n", addbkpt_info.name);	330	printf("Cannot register command %s\n", addbkpt_info.name);
331		331
332	cmd_initialize(&addwatchp_info);	332	cmd_initialize(&addwatchp_info);
333	if (!cmd_register(&addwatchp_info))	333	if (!cmd_register(&addwatchp_info))
334	printf("Cannot register command %s\n", addwatchp_info.name);	334	printf("Cannot register command %s\n", addwatchp_info.name);
335	#endif /* CONFIG_DEBUG_AS_WATCHPOINT */	335	#endif /* CONFIG_DEBUG_AS_WATCHPOINT */
336	#endif /* CONFIG_KCONSOLE */	336	#endif /* CONFIG_KCONSOLE */
337		337
338	exc_register(VECTOR_DEBUG, "debugger", debug_exception);	338	exc_register(VECTOR_DEBUG, "debugger", debug_exception);
339	#ifdef CONFIG_SMP	339	#ifdef CONFIG_SMP
340	exc_register(VECTOR_DEBUG_IPI, "debugger_smp", debug_ipi);	340	exc_register(VECTOR_DEBUG_IPI, "debugger_smp", debug_ipi);
341	#endif	341	#endif
342	}	342	}
343		343
344	#ifdef CONFIG_KCONSOLE	344	#ifdef CONFIG_KCONSOLE
345	/** Print table of active breakpoints */	345	/** Print table of active breakpoints */
346	int cmd_print_breakpoints(cmd_arg_t *argv __attribute__((unused)))	346	int cmd_print_breakpoints(cmd_arg_t *argv __attribute__((unused)))
347	{	347	{
348	unsigned int i;	348	unsigned int i;
349	char *symbol;	349	char *symbol;
350		350
351	#ifdef __32_BITS__	351	#ifdef __32_BITS__
352	printf("# Count Address In symbol\n");	352	printf("# Count Address In symbol\n");
353	printf("-- ----- ---------- ---------\n");	353	printf("-- ----- ---------- ---------\n");
354	#endif	354	#endif
355		355
356	#ifdef __64_BITS__	356	#ifdef __64_BITS__
357	printf("# Count Address In symbol\n");	357	printf("# Count Address In symbol\n");
358	printf("-- ----- ------------------ ---------\n");	358	printf("-- ----- ------------------ ---------\n");
359	#endif	359	#endif
360		360
361	for (i = 0; i < BKPOINTS_MAX; i++)	361	for (i = 0; i < BKPOINTS_MAX; i++)
362	if (breakpoints[i].address) {	362	if (breakpoints[i].address) {
363	symbol = get_symtab_entry(breakpoints[i].address);	363	symbol = get_symtab_entry(breakpoints[i].address);
364		364
365	#ifdef __32_BITS__	365	#ifdef __32_BITS__
366	printf("%-2u %-5d %#10zx %s\n", i,	366	printf("%-2u %-5d %#10zx %s\n", i,
367	breakpoints[i].counter, breakpoints[i].address,	367	breakpoints[i].counter, breakpoints[i].address,
368	symbol);	368	symbol);
369	#endif	369	#endif
370		370
371	#ifdef __64_BITS__	371	#ifdef __64_BITS__
372	printf("%-2u %-5d %#18zx %s\n", i,	372	printf("%-2u %-5d %#18zx %s\n", i,
373	breakpoints[i].counter, breakpoints[i].address,	373	breakpoints[i].counter, breakpoints[i].address,
374	symbol);	374	symbol);
375	#endif	375	#endif
376		376
377	}	377	}
378	return 1;	378	return 1;
379	}	379	}
380		380
381	#ifndef CONFIG_DEBUG_AS_WATCHPOINT	381	#ifndef CONFIG_DEBUG_AS_WATCHPOINT
382		382
383	/** Remove breakpoint from table */	383	/** Remove breakpoint from table */
384	int cmd_del_breakpoint(cmd_arg_t *argv)	384	int cmd_del_breakpoint(cmd_arg_t *argv)
385	{	385	{
386	unative_t bpno = argv->intval;	386	unative_t bpno = argv->intval;
387	if (bpno > BKPOINTS_MAX) {	387	if (bpno > BKPOINTS_MAX) {
388	printf("Invalid breakpoint number.\n");	388	printf("Invalid breakpoint number.\n");
389	return 0;	389	return 0;
390	}	390	}
391	breakpoint_del(argv->intval);	391	breakpoint_del(argv->intval);
392	return 1;	392	return 1;
393	}	393	}
394		394
395	/** Add new breakpoint to table */	395	/** Add new breakpoint to table */
396	static int cmd_add_breakpoint(cmd_arg_t *argv)	396	static int cmd_add_breakpoint(cmd_arg_t *argv)
397	{	397	{
398	int flags;	398	int flags;
399	int id;	399	int id;
400		400
401	if (argv == &add_argv) {	401	if (argv == &add_argv) {
402	flags = BKPOINT_INSTR;	402	flags = BKPOINT_INSTR;
403	} else { /* addwatchp */	403	} else { /* addwatchp */
404	flags = BKPOINT_WRITE;	404	flags = BKPOINT_WRITE;
405	}	405	}
406	printf("Adding breakpoint on address: %p\n", argv->intval);	406	printf("Adding breakpoint on address: %p\n", argv->intval);
407	id = breakpoint_add((void *)argv->intval, flags, -1);	407	id = breakpoint_add((void *)argv->intval, flags, -1);
408	if (id < 0)	408	if (id < 0)
409	printf("Add breakpoint failed.\n");	409	printf("Add breakpoint failed.\n");
410	else	410	else
411	printf("Added breakpoint %d.\n", id);	411	printf("Added breakpoint %d.\n", id);
412		412
413	return 1;	413	return 1;
414	}	414	}
415	#endif /* CONFIG_DEBUG_AS_WATCHPOINT */	415	#endif /* CONFIG_DEBUG_AS_WATCHPOINT */
416	#endif /* CONFIG_KCONSOLE */	416	#endif /* CONFIG_KCONSOLE */
417		417
418	/** @}	418	/** @}
419	*/	419	*/
420		420

Subversion Repositories HelenOS

(root)/trunk/kernel/arch/amd64/src/debugger.c – Rev 3707 → 3880