WebSVN – HelenOS – Diff – /branches/tracing/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 <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>
#include <symtab.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,
};
 
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_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),
        symtab_fmt_name_lookup(getip(istate)));
 
#ifdef CONFIG_KCONSOLE
    atomic_set(&haltstate, 1);
    kconsole("debug", "Debug console ready.\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;
   
    dr6 = read_dr6();
 
#ifdef CONFIG_UDEBUG
    if (dr6 & DR6_BS) {
        if (THREAD && istate_from_uspace(istate)) {
            /*
             * The userspace thread has TF set and executed
             * an instruction
             */
            udebug_trap_event(getip(istate));
            return;
        }
    }
#endif
 
    /* Set RF to restart the instruction  */
#ifdef __64_BITS__
    istate->rflags |= RFLAGS_RF;
#else
    istate->eflags |= EFLAGS_RF;
#endif
 
    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);
 
    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_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 = symtab_fmt_name_lookup(
                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;
}
 
/** 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_KCONSOLE */
 
/** @}
 */
 

Rev 4377	Rev 4390
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 <print.h>	38	#include <print.h>
39	#include <panic.h>	39	#include <panic.h>
40	#include <interrupt.h>	40	#include <interrupt.h>
41	#include <arch/asm.h>	41	#include <arch/asm.h>
42	#include <arch/cpu.h>	42	#include <arch/cpu.h>
43	#include <debug.h>	43	#include <debug.h>
44	#include <func.h>	44	#include <func.h>
45	#include <smp/ipi.h>	45	#include <smp/ipi.h>
46	#include <symtab.h>	46	#include <symtab.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	static int cmd_del_breakpoint(cmd_arg_t *argv);	67	static int cmd_del_breakpoint(cmd_arg_t *argv);
68	static cmd_arg_t del_argv = {	68	static cmd_arg_t del_argv = {
69	.type = ARG_TYPE_INT	69	.type = ARG_TYPE_INT
70	};	70	};
71	static cmd_info_t delbkpt_info = {	71	static cmd_info_t delbkpt_info = {
72	.name = "delbkpt",	72	.name = "delbkpt",
73	.description = "delbkpt <number> - Delete breakpoint.",	73	.description = "delbkpt <number> - Delete breakpoint.",
74	.func = cmd_del_breakpoint,	74	.func = cmd_del_breakpoint,
75	.argc = 1,	75	.argc = 1,
76	.argv = &del_argv	76	.argv = &del_argv
77	};	77	};
78		78
79	static int cmd_add_breakpoint(cmd_arg_t *argv);	79	static int cmd_add_breakpoint(cmd_arg_t *argv);
80	static cmd_arg_t add_argv = {	80	static cmd_arg_t add_argv = {
81	.type = ARG_TYPE_INT	81	.type = ARG_TYPE_INT
82	};	82	};
83	static cmd_info_t addbkpt_info = {	83	static cmd_info_t addbkpt_info = {
84	.name = "addbkpt",	84	.name = "addbkpt",
85	.description = "addbkpt <&symbol> - new breakpoint.",	85	.description = "addbkpt <&symbol> - new breakpoint.",
86	.func = cmd_add_breakpoint,	86	.func = cmd_add_breakpoint,
87	.argc = 1,	87	.argc = 1,
88	.argv = &add_argv	88	.argv = &add_argv
89	};	89	};
90		90
91	static cmd_arg_t addw_argv = {	91	static cmd_arg_t addw_argv = {
92	.type = ARG_TYPE_INT	92	.type = ARG_TYPE_INT
93	};	93	};
94	static cmd_info_t addwatchp_info = {	94	static cmd_info_t addwatchp_info = {
95	.name = "addwatchp",	95	.name = "addwatchp",
96	.description = "addbwatchp <&symbol> - new write watchpoint.",	96	.description = "addbwatchp <&symbol> - new write watchpoint.",
97	.func = cmd_add_breakpoint,	97	.func = cmd_add_breakpoint,
98	.argc = 1,	98	.argc = 1,
99	.argv = &addw_argv	99	.argv = &addw_argv
100	};	100	};
101		101
102	#endif /* CONFIG_KCONSOLE */	102	#endif /* CONFIG_KCONSOLE */
103		103
104	/* Setup DR register according to table */	104	/* Setup DR register according to table */
105	static void setup_dr(int curidx)	105	static void setup_dr(int curidx)
106	{	106	{
107	unative_t dr7;	107	unative_t dr7;
108	bpinfo_t *cur = &breakpoints[curidx];	108	bpinfo_t *cur = &breakpoints[curidx];
109	int flags = breakpoints[curidx].flags;	109	int flags = breakpoints[curidx].flags;
110		110
111	/* Disable breakpoint in DR7 */	111	/* Disable breakpoint in DR7 */
112	dr7 = read_dr7();	112	dr7 = read_dr7();
113	dr7 &= ~(0x2 << (curidx*2));	113	dr7 &= ~(0x2 << (curidx*2));
114		114
115	if (cur->address) { /* Setup DR register */	115	if (cur->address) { /* Setup DR register */
116	/* Set breakpoint to debug registers */	116	/* Set breakpoint to debug registers */
117	switch (curidx) {	117	switch (curidx) {
118	case 0:	118	case 0:
119	write_dr0(cur->address);	119	write_dr0(cur->address);
120	break;	120	break;
121	case 1:	121	case 1:
122	write_dr1(cur->address);	122	write_dr1(cur->address);
123	break;	123	break;
124	case 2:	124	case 2:
125	write_dr2(cur->address);	125	write_dr2(cur->address);
126	break;	126	break;
127	case 3:	127	case 3:
128	write_dr3(cur->address);	128	write_dr3(cur->address);
129	break;	129	break;
130	}	130	}
131	/* Set type to requested breakpoint & length*/	131	/* Set type to requested breakpoint & length*/
132	dr7 &= ~ (0x3 << (16 + 4*curidx));	132	dr7 &= ~ (0x3 << (16 + 4*curidx));
133	dr7 &= ~ (0x3 << (18 + 4*curidx));	133	dr7 &= ~ (0x3 << (18 + 4*curidx));
134	if ((flags & BKPOINT_INSTR)) {	134	if ((flags & BKPOINT_INSTR)) {
135	;	135	;
136	} else {	136	} else {
137		137
138	#ifdef __32_BITS__	138	#ifdef __32_BITS__
139	dr7 \|= ((unative_t) 0x3) << (18 + 4 * curidx);	139	dr7 \|= ((unative_t) 0x3) << (18 + 4 * curidx);
140	#endif	140	#endif
141		141
142	#ifdef __64_BITS__	142	#ifdef __64_BITS__
143	dr7 \|= ((unative_t) 0x2) << (18 + 4 * curidx);	143	dr7 \|= ((unative_t) 0x2) << (18 + 4 * curidx);
144	#endif	144	#endif
145		145
146	if ((flags & BKPOINT_WRITE))	146	if ((flags & BKPOINT_WRITE))
147	dr7 \|= ((unative_t) 0x1) << (16 + 4 * curidx);	147	dr7 \|= ((unative_t) 0x1) << (16 + 4 * curidx);
148	else if ((flags & BKPOINT_READ_WRITE))	148	else if ((flags & BKPOINT_READ_WRITE))
149	dr7 \|= ((unative_t) 0x3) << (16 + 4 * curidx);	149	dr7 \|= ((unative_t) 0x3) << (16 + 4 * curidx);
150	}	150	}
151		151
152	/* Enable global breakpoint */	152	/* Enable global breakpoint */
153	dr7 \|= 0x2 << (curidx * 2);	153	dr7 \|= 0x2 << (curidx * 2);
154		154
155	write_dr7(dr7);	155	write_dr7(dr7);
156		156
157	}	157	}
158	}	158	}
159		159
160	/** Enable hardware breakpoint	160	/** Enable hardware breakpoint
161	*	161	*
162	* @param where Address of HW breakpoint	162	* @param where Address of HW breakpoint
163	* @param flags Type of breakpoint (EXECUTE, WRITE)	163	* @param flags Type of breakpoint (EXECUTE, WRITE)
164	* @return Debug slot on success, -1 - no available HW breakpoint	164	* @return Debug slot on success, -1 - no available HW breakpoint
165	*/	165	*/
166	int breakpoint_add(const void *where, const int flags, int curidx)	166	int breakpoint_add(const void *where, const int flags, int curidx)
167	{	167	{
168	ipl_t ipl;	168	ipl_t ipl;
169	int i;	169	int i;
170	bpinfo_t *cur;	170	bpinfo_t *cur;
171		171
172	ASSERT(flags & (BKPOINT_INSTR \| BKPOINT_WRITE \| BKPOINT_READ_WRITE));	172	ASSERT(flags & (BKPOINT_INSTR \| BKPOINT_WRITE \| BKPOINT_READ_WRITE));
173		173
174	ipl = interrupts_disable();	174	ipl = interrupts_disable();
175	spinlock_lock(&bkpoint_lock);	175	spinlock_lock(&bkpoint_lock);
176		176
177	if (curidx == -1) {	177	if (curidx == -1) {
178	/* Find free space in slots */	178	/* Find free space in slots */
179	for (i = 0; i < BKPOINTS_MAX; i++)	179	for (i = 0; i < BKPOINTS_MAX; i++)
180	if (!breakpoints[i].address) {	180	if (!breakpoints[i].address) {
181	curidx = i;	181	curidx = i;
182	break;	182	break;
183	}	183	}
184	if (curidx == -1) {	184	if (curidx == -1) {
185	/* Too many breakpoints */	185	/* Too many breakpoints */
186	spinlock_unlock(&bkpoint_lock);	186	spinlock_unlock(&bkpoint_lock);
187	interrupts_restore(ipl);	187	interrupts_restore(ipl);
188	return -1;	188	return -1;
189	}	189	}
190	}	190	}
191	cur = &breakpoints[curidx];	191	cur = &breakpoints[curidx];
192		192
193	cur->address = (uintptr_t) where;	193	cur->address = (uintptr_t) where;
194	cur->flags = flags;	194	cur->flags = flags;
195	cur->counter = 0;	195	cur->counter = 0;
196		196
197	setup_dr(curidx);	197	setup_dr(curidx);
198		198
199	spinlock_unlock(&bkpoint_lock);	199	spinlock_unlock(&bkpoint_lock);
200	interrupts_restore(ipl);	200	interrupts_restore(ipl);
201		201
202	/* Send IPI */	202	/* Send IPI */
203	#ifdef CONFIG_SMP	203	#ifdef CONFIG_SMP
204	// ipi_broadcast(VECTOR_DEBUG_IPI);	204	// ipi_broadcast(VECTOR_DEBUG_IPI);
205	#endif	205	#endif
206		206
207	return curidx;	207	return curidx;
208	}	208	}
209		209
210	#ifdef __64_BITS__	210	#ifdef __64_BITS__
211	#define getip(x) ((x)->rip)	211	#define getip(x) ((x)->rip)
212	#else	212	#else
213	#define getip(x) ((x)->eip)	213	#define getip(x) ((x)->eip)
214	#endif	214	#endif
215		215
216	static void handle_exception(int slot, istate_t *istate)	216	static void handle_exception(int slot, istate_t *istate)
217	{	217	{
218	ASSERT(breakpoints[slot].address);	218	ASSERT(breakpoints[slot].address);
219		219
220	/* Handle zero checker */	220	/* Handle zero checker */
221	if (! (breakpoints[slot].flags & BKPOINT_INSTR)) {	221	if (! (breakpoints[slot].flags & BKPOINT_INSTR)) {
222	if ((breakpoints[slot].flags & BKPOINT_CHECK_ZERO)) {	222	if ((breakpoints[slot].flags & BKPOINT_CHECK_ZERO)) {
223	if (((unative_t ) breakpoints[slot].address) != 0)	223	if (((unative_t ) breakpoints[slot].address) != 0)
224	return;	224	return;
225	printf("* Found ZERO on address %lx (slot %d) *\n",	225	printf("* Found ZERO on address %lx (slot %d) *\n",
226	breakpoints[slot].address, slot);	226	breakpoints[slot].address, slot);
227	} else {	227	} else {
228	printf("Data watchpoint - new data: %lx\n",	228	printf("Data watchpoint - new data: %lx\n",
229	((unative_t ) breakpoints[slot].address));	229	((unative_t ) breakpoints[slot].address));
230	}	230	}
231	}	231	}
232		232
233	printf("Reached breakpoint %d:%lx (%s)\n", slot, getip(istate),	233	printf("Reached breakpoint %d:%lx (%s)\n", slot, getip(istate),
234	symtab_fmt_name_lookup(getip(istate)));	234	symtab_fmt_name_lookup(getip(istate)));
235		235
236	#ifdef CONFIG_KCONSOLE	236	#ifdef CONFIG_KCONSOLE
237	atomic_set(&haltstate, 1);	237	atomic_set(&haltstate, 1);
238	kconsole("debug", "Debug console ready.\n", false);	238	kconsole("debug", "Debug console ready.\n", false);
239	atomic_set(&haltstate, 0);	239	atomic_set(&haltstate, 0);
240	#endif	240	#endif
241	}	241	}
242		242
243	void breakpoint_del(int slot)	243	void breakpoint_del(int slot)
244	{	244	{
245	bpinfo_t *cur;	245	bpinfo_t *cur;
246	ipl_t ipl;	246	ipl_t ipl;
247		247
248	ipl = interrupts_disable();	248	ipl = interrupts_disable();
249	spinlock_lock(&bkpoint_lock);	249	spinlock_lock(&bkpoint_lock);
250		250
251	cur = &breakpoints[slot];	251	cur = &breakpoints[slot];
252	if (!cur->address) {	252	if (!cur->address) {
253	spinlock_unlock(&bkpoint_lock);	253	spinlock_unlock(&bkpoint_lock);
254	interrupts_restore(ipl);	254	interrupts_restore(ipl);
255	return;	255	return;
256	}	256	}
257		257
258	cur->address = NULL;	258	cur->address = NULL;
259		259
260	setup_dr(slot);	260	setup_dr(slot);
261		261
262	spinlock_unlock(&bkpoint_lock);	262	spinlock_unlock(&bkpoint_lock);
263	interrupts_restore(ipl);	263	interrupts_restore(ipl);
264	#ifdef CONFIG_SMP	264	#ifdef CONFIG_SMP
265	// ipi_broadcast(VECTOR_DEBUG_IPI);	265	// ipi_broadcast(VECTOR_DEBUG_IPI);
266	#endif	266	#endif
267	}	267	}
268		268
269		269
270		270
271	static void debug_exception(int n __attribute__((unused)), istate_t *istate)	271	static void debug_exception(int n __attribute__((unused)), istate_t *istate)
272	{	272	{
273	unative_t dr6;	273	unative_t dr6;
274	int i;	274	int i;
275		275
276	dr6 = read_dr6();	276	dr6 = read_dr6();
277		277
278	#ifdef CONFIG_UDEBUG	278	#ifdef CONFIG_UDEBUG
279	if (dr6 & DR6_BS) {	279	if (dr6 & DR6_BS) {
280	if (THREAD && istate_from_uspace(istate)) {	280	if (THREAD && istate_from_uspace(istate)) {
281	/*	281	/*
282	* The userspace thread has TF set and executed	282	* The userspace thread has TF set and executed
283	* an instruction	283	* an instruction
284	*/	284	*/
285	udebug_trap_event(istate->eip);	285	udebug_trap_event(getip(istate));
286	return;	286	return;
287	}	287	}
288	}	288	}
289	#endif	289	#endif
290		290
291	/* Set RF to restart the instruction */	291	/* Set RF to restart the instruction */
292	#ifdef __64_BITS__	292	#ifdef __64_BITS__
293	istate->rflags \|= RFLAGS_RF;	293	istate->rflags \|= RFLAGS_RF;
294	#else	294	#else
295	istate->eflags \|= EFLAGS_RF;	295	istate->eflags \|= EFLAGS_RF;
296	#endif	296	#endif
297		297
298	for (i=0; i < BKPOINTS_MAX; i++) {	298	for (i=0; i < BKPOINTS_MAX; i++) {
299	if (dr6 & (1 << i)) {	299	if (dr6 & (1 << i)) {
300	dr6 &= ~ (1 << i);	300	dr6 &= ~ (1 << i);
301	write_dr6(dr6);	301	write_dr6(dr6);
302		302
303	handle_exception(i, istate);	303	handle_exception(i, istate);
304	}	304	}
305	}	305	}
306	}	306	}
307		307
308	#ifdef CONFIG_SMP	308	#ifdef CONFIG_SMP
309	static void	309	static void
310	debug_ipi(int n __attribute__((unused)),	310	debug_ipi(int n __attribute__((unused)),
311	istate_t *istate __attribute__((unused)))	311	istate_t *istate __attribute__((unused)))
312	{	312	{
313	int i;	313	int i;
314		314
315	spinlock_lock(&bkpoint_lock);	315	spinlock_lock(&bkpoint_lock);
316	for (i = 0; i < BKPOINTS_MAX; i++)	316	for (i = 0; i < BKPOINTS_MAX; i++)
317	setup_dr(i);	317	setup_dr(i);
318	spinlock_unlock(&bkpoint_lock);	318	spinlock_unlock(&bkpoint_lock);
319	}	319	}
320	#endif	320	#endif
321		321
322	/** Initialize debugger */	322	/** Initialize debugger */
323	void debugger_init()	323	void debugger_init()
324	{	324	{
325	int i;	325	int i;
326		326
327	for (i = 0; i < BKPOINTS_MAX; i++)	327	for (i = 0; i < BKPOINTS_MAX; i++)
328	breakpoints[i].address = NULL;	328	breakpoints[i].address = NULL;
329		329
330	#ifdef CONFIG_KCONSOLE	330	#ifdef CONFIG_KCONSOLE
331	cmd_initialize(&bkpts_info);	331	cmd_initialize(&bkpts_info);
332	if (!cmd_register(&bkpts_info))	332	if (!cmd_register(&bkpts_info))
333	printf("Cannot register command %s\n", bkpts_info.name);	333	printf("Cannot register command %s\n", bkpts_info.name);
334		334
335	cmd_initialize(&delbkpt_info);	335	cmd_initialize(&delbkpt_info);
336	if (!cmd_register(&delbkpt_info))	336	if (!cmd_register(&delbkpt_info))
337	printf("Cannot register command %s\n", delbkpt_info.name);	337	printf("Cannot register command %s\n", delbkpt_info.name);
338		338
339	cmd_initialize(&addbkpt_info);	339	cmd_initialize(&addbkpt_info);
340	if (!cmd_register(&addbkpt_info))	340	if (!cmd_register(&addbkpt_info))
341	printf("Cannot register command %s\n", addbkpt_info.name);	341	printf("Cannot register command %s\n", addbkpt_info.name);
342		342
343	cmd_initialize(&addwatchp_info);	343	cmd_initialize(&addwatchp_info);
344	if (!cmd_register(&addwatchp_info))	344	if (!cmd_register(&addwatchp_info))
345	printf("Cannot register command %s\n", addwatchp_info.name);	345	printf("Cannot register command %s\n", addwatchp_info.name);
346	#endif /* CONFIG_KCONSOLE */	346	#endif /* CONFIG_KCONSOLE */
347		347
348	exc_register(VECTOR_DEBUG, "debugger", debug_exception);	348	exc_register(VECTOR_DEBUG, "debugger", debug_exception);
349	#ifdef CONFIG_SMP	349	#ifdef CONFIG_SMP
350	exc_register(VECTOR_DEBUG_IPI, "debugger_smp", debug_ipi);	350	exc_register(VECTOR_DEBUG_IPI, "debugger_smp", debug_ipi);
351	#endif	351	#endif
352	}	352	}
353		353
354	#ifdef CONFIG_KCONSOLE	354	#ifdef CONFIG_KCONSOLE
355	/** Print table of active breakpoints */	355	/** Print table of active breakpoints */
356	int cmd_print_breakpoints(cmd_arg_t *argv __attribute__((unused)))	356	int cmd_print_breakpoints(cmd_arg_t *argv __attribute__((unused)))
357	{	357	{
358	unsigned int i;	358	unsigned int i;
359	char *symbol;	359	char *symbol;
360		360
361	#ifdef __32_BITS__	361	#ifdef __32_BITS__
362	printf("# Count Address In symbol\n");	362	printf("# Count Address In symbol\n");
363	printf("-- ----- ---------- ---------\n");	363	printf("-- ----- ---------- ---------\n");
364	#endif	364	#endif
365		365
366	#ifdef __64_BITS__	366	#ifdef __64_BITS__
367	printf("# Count Address In symbol\n");	367	printf("# Count Address In symbol\n");
368	printf("-- ----- ------------------ ---------\n");	368	printf("-- ----- ------------------ ---------\n");
369	#endif	369	#endif
370		370
371	for (i = 0; i < BKPOINTS_MAX; i++)	371	for (i = 0; i < BKPOINTS_MAX; i++)
372	if (breakpoints[i].address) {	372	if (breakpoints[i].address) {
373	symbol = symtab_fmt_name_lookup(	373	symbol = symtab_fmt_name_lookup(
374	breakpoints[i].address);	374	breakpoints[i].address);
375		375
376	#ifdef __32_BITS__	376	#ifdef __32_BITS__
377	printf("%-2u %-5d %#10zx %s\n", i,	377	printf("%-2u %-5d %#10zx %s\n", i,
378	breakpoints[i].counter, breakpoints[i].address,	378	breakpoints[i].counter, breakpoints[i].address,
379	symbol);	379	symbol);
380	#endif	380	#endif
381		381
382	#ifdef __64_BITS__	382	#ifdef __64_BITS__
383	printf("%-2u %-5d %#18zx %s\n", i,	383	printf("%-2u %-5d %#18zx %s\n", i,
384	breakpoints[i].counter, breakpoints[i].address,	384	breakpoints[i].counter, breakpoints[i].address,
385	symbol);	385	symbol);
386	#endif	386	#endif
387		387
388	}	388	}
389	return 1;	389	return 1;
390	}	390	}
391		391
392	/** Remove breakpoint from table */	392	/** Remove breakpoint from table */
393	int cmd_del_breakpoint(cmd_arg_t *argv)	393	int cmd_del_breakpoint(cmd_arg_t *argv)
394	{	394	{
395	unative_t bpno = argv->intval;	395	unative_t bpno = argv->intval;
396	if (bpno > BKPOINTS_MAX) {	396	if (bpno > BKPOINTS_MAX) {
397	printf("Invalid breakpoint number.\n");	397	printf("Invalid breakpoint number.\n");
398	return 0;	398	return 0;
399	}	399	}
400	breakpoint_del(argv->intval);	400	breakpoint_del(argv->intval);
401	return 1;	401	return 1;
402	}	402	}
403		403
404	/** Add new breakpoint to table */	404	/** Add new breakpoint to table */
405	static int cmd_add_breakpoint(cmd_arg_t *argv)	405	static int cmd_add_breakpoint(cmd_arg_t *argv)
406	{	406	{
407	int flags;	407	int flags;
408	int id;	408	int id;
409		409
410	if (argv == &add_argv) {	410	if (argv == &add_argv) {
411	flags = BKPOINT_INSTR;	411	flags = BKPOINT_INSTR;
412	} else { /* addwatchp */	412	} else { /* addwatchp */
413	flags = BKPOINT_WRITE;	413	flags = BKPOINT_WRITE;
414	}	414	}
415	printf("Adding breakpoint on address: %p\n", argv->intval);	415	printf("Adding breakpoint on address: %p\n", argv->intval);
416	id = breakpoint_add((void *)argv->intval, flags, -1);	416	id = breakpoint_add((void *)argv->intval, flags, -1);
417	if (id < 0)	417	if (id < 0)
418	printf("Add breakpoint failed.\n");	418	printf("Add breakpoint failed.\n");
419	else	419	else
420	printf("Added breakpoint %d.\n", id);	420	printf("Added breakpoint %d.\n", id);
421		421
422	return 1;	422	return 1;
423	}	423	}
424	#endif /* CONFIG_KCONSOLE */	424	#endif /* CONFIG_KCONSOLE */
425		425
426	/** @}	426	/** @}
427	*/	427	*/
428		428

Subversion Repositories HelenOS

(root)/branches/tracing/kernel/arch/amd64/src/debugger.c – Rev 4377 → 4390