WebSVN – HelenOS-historic – Diff – /kernel/trunk/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.
 */
 
#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  {
    __address 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);
 
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
 
/** Print table of active breakpoints */
int cmd_print_breakpoints(cmd_arg_t *argv)
{
    int i;
    char *symbol;
 
    printf("Breakpoint table.\n");
    for (i=0; i < BKPOINTS_MAX; i++)
        if (breakpoints[i].address) {
            symbol = get_symtab_entry(breakpoints[i].address);
            printf("%d. %p in %s\n",i,
                   breakpoints[i].address, symbol);
            printf("     Count(%d) ", breakpoints[i].counter);
            printf("\n");
        }
    return 1;
}
 
/* Setup DR register according to table */
static void setup_dr(int curidx)
{
    __native 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 {
            if (sizeof(int) == 4)
                dr7 |= ((__native) 0x3) << (18 + 4*curidx);
            else /* 8 */
                dr7 |= ((__native) 0x2) << (18 + 4*curidx);
           
            if ((flags & BKPOINT_WRITE))
                dr7 |= ((__native) 0x1) << (16 + 4*curidx);
            else if ((flags & BKPOINT_READ_WRITE))
                dr7 |= ((__native) 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(void * where, 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 = (__address) 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 amd64
# 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 (*((__native *) breakpoints[slot].address) != 0)
                return;
            printf("**** Found ZERO on address %p ****\n",
                   slot, breakpoints[slot].address);
        } else {
            printf("Data watchpoint - new data: %p\n",
                   *((__native *) breakpoints[slot].address));
        }
    }
    printf("Reached breakpoint %d:%p(%s)\n", slot, getip(istate),
           get_symtab_entry(getip(istate)));
    printf("***Type 'exit' to exit kconsole.\n");
    atomic_set(&haltstate,1);
    kconsole("debug");
    atomic_set(&haltstate,0);
}
 
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
}
 
#ifndef CONFIG_DEBUG_AS_WATCHPOINT
 
/** Remove breakpoint from table */
int cmd_del_breakpoint(cmd_arg_t *argv)
{
    if (argv->intval < 0 || argv->intval > 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
 
static void debug_exception(int n, istate_t *istate)
{
    __native dr6;
    int i;
   
    /* Set RF to restart the instruction  */
#ifdef amd64       
    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, istate_t *istate)
{
    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;
   
    cmd_initialize(&bkpts_info);
    if (!cmd_register(&bkpts_info))
        panic("could not register command %s\n", bkpts_info.name);
 
#ifndef CONFIG_DEBUG_AS_WATCHPOINT
    cmd_initialize(&delbkpt_info);
    if (!cmd_register(&delbkpt_info))
        panic("could not register command %s\n", delbkpt_info.name);
 
    cmd_initialize(&addbkpt_info);
    if (!cmd_register(&addbkpt_info))
        panic("could not register command %s\n", addbkpt_info.name);
 
    cmd_initialize(&addwatchp_info);
    if (!cmd_register(&addwatchp_info))
        panic("could not register command %s\n", addwatchp_info.name);
#endif
   
    exc_register(VECTOR_DEBUG, "debugger",
             debug_exception);
#ifdef CONFIG_SMP
    exc_register(VECTOR_DEBUG_IPI, "debugger_smp",
             debug_ipi);
#endif
}
 

Rev 1196	Rev 1221
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	#include <arch/debugger.h>	29	#include <arch/debugger.h>
30	#include <console/kconsole.h>	30	#include <console/kconsole.h>
31	#include <console/cmd.h>	31	#include <console/cmd.h>
32	#include <symtab.h>	32	#include <symtab.h>
33	#include <print.h>	33	#include <print.h>
34	#include <panic.h>	34	#include <panic.h>
35	#include <interrupt.h>	35	#include <interrupt.h>
36	#include <arch/asm.h>	36	#include <arch/asm.h>
37	#include <arch/cpu.h>	37	#include <arch/cpu.h>
38	#include <debug.h>	38	#include <debug.h>
39	#include <func.h>	39	#include <func.h>
40	#include <smp/ipi.h>	40	#include <smp/ipi.h>
41		41
42	typedef struct {	42	typedef struct {
43	__address address; /*< Breakpoint address /	43	__address address; /*< Breakpoint address /
44	int flags; /*< Flags regarding breakpoint /	44	int flags; /*< Flags regarding breakpoint /
45	int counter; /*< How many times the exception occured /	45	int counter; /*< How many times the exception occured /
46	} bpinfo_t;	46	} bpinfo_t;
47		47
48	static bpinfo_t breakpoints[BKPOINTS_MAX];	48	static bpinfo_t breakpoints[BKPOINTS_MAX];
49	SPINLOCK_INITIALIZE(bkpoint_lock);	49	SPINLOCK_INITIALIZE(bkpoint_lock);
50		50
51	static int cmd_print_breakpoints(cmd_arg_t *argv);	51	static int cmd_print_breakpoints(cmd_arg_t *argv);
52	static cmd_info_t bkpts_info = {	52	static cmd_info_t bkpts_info = {
53	.name = "bkpts",	53	.name = "bkpts",
54	.description = "Print breakpoint table.",	54	.description = "Print breakpoint table.",
55	.func = cmd_print_breakpoints,	55	.func = cmd_print_breakpoints,
56	.argc = 0,	56	.argc = 0,
57	};	57	};
58		58
59	#ifndef CONFIG_DEBUG_AS_WATCHPOINT	59	#ifndef CONFIG_DEBUG_AS_WATCHPOINT
60		60
61	static int cmd_del_breakpoint(cmd_arg_t *argv);	61	static int cmd_del_breakpoint(cmd_arg_t *argv);
62	static cmd_arg_t del_argv = {	62	static cmd_arg_t del_argv = {
63	.type = ARG_TYPE_INT	63	.type = ARG_TYPE_INT
64	};	64	};
65	static cmd_info_t delbkpt_info = {	65	static cmd_info_t delbkpt_info = {
66	.name = "delbkpt",	66	.name = "delbkpt",
67	.description = "delbkpt <number> - Delete breakpoint.",	67	.description = "delbkpt <number> - Delete breakpoint.",
68	.func = cmd_del_breakpoint,	68	.func = cmd_del_breakpoint,
69	.argc = 1,	69	.argc = 1,
70	.argv = &del_argv	70	.argv = &del_argv
71	};	71	};
72		72
73	static int cmd_add_breakpoint(cmd_arg_t *argv);	73	static int cmd_add_breakpoint(cmd_arg_t *argv);
74	static cmd_arg_t add_argv = {	74	static cmd_arg_t add_argv = {
75	.type = ARG_TYPE_INT	75	.type = ARG_TYPE_INT
76	};	76	};
77	static cmd_info_t addbkpt_info = {	77	static cmd_info_t addbkpt_info = {
78	.name = "addbkpt",	78	.name = "addbkpt",
79	.description = "addbkpt <&symbol> - new breakpoint.",	79	.description = "addbkpt <&symbol> - new breakpoint.",
80	.func = cmd_add_breakpoint,	80	.func = cmd_add_breakpoint,
81	.argc = 1,	81	.argc = 1,
82	.argv = &add_argv	82	.argv = &add_argv
83	};	83	};
84		84
85	static cmd_arg_t addw_argv = {	85	static cmd_arg_t addw_argv = {
86	.type = ARG_TYPE_INT	86	.type = ARG_TYPE_INT
87	};	87	};
88	static cmd_info_t addwatchp_info = {	88	static cmd_info_t addwatchp_info = {
89	.name = "addwatchp",	89	.name = "addwatchp",
90	.description = "addbwatchp <&symbol> - new write watchpoint.",	90	.description = "addbwatchp <&symbol> - new write watchpoint.",
91	.func = cmd_add_breakpoint,	91	.func = cmd_add_breakpoint,
92	.argc = 1,	92	.argc = 1,
93	.argv = &addw_argv	93	.argv = &addw_argv
94	};	94	};
95		95
96	#endif	96	#endif
97		97
98	/** Print table of active breakpoints */	98	/** Print table of active breakpoints */
99	int cmd_print_breakpoints(cmd_arg_t *argv)	99	int cmd_print_breakpoints(cmd_arg_t *argv)
100	{	100	{
101	int i;	101	int i;
102	char *symbol;	102	char *symbol;
103		103
104	printf("Breakpoint table.\n");	104	printf("Breakpoint table.\n");
105	for (i=0; i < BKPOINTS_MAX; i++)	105	for (i=0; i < BKPOINTS_MAX; i++)
106	if (breakpoints[i].address) {	106	if (breakpoints[i].address) {
107	symbol = get_symtab_entry(breakpoints[i].address);	107	symbol = get_symtab_entry(breakpoints[i].address);
108	printf("%d. %p in %s\n",i,	108	printf("%d. %p in %s\n",i,
109	breakpoints[i].address, symbol);	109	breakpoints[i].address, symbol);
110	printf(" Count(%d) ", breakpoints[i].counter);	110	printf(" Count(%d) ", breakpoints[i].counter);
111	printf("\n");	111	printf("\n");
112	}	112	}
113	return 1;	113	return 1;
114	}	114	}
115		115
116	/* Setup DR register according to table */	116	/* Setup DR register according to table */
117	static void setup_dr(int curidx)	117	static void setup_dr(int curidx)
118	{	118	{
119	__native dr7;	119	__native dr7;
120	bpinfo_t *cur = &breakpoints[curidx];	120	bpinfo_t *cur = &breakpoints[curidx];
121	int flags = breakpoints[curidx].flags;	121	int flags = breakpoints[curidx].flags;
122		122
123	/* Disable breakpoint in DR7 */	123	/* Disable breakpoint in DR7 */
124	dr7 = read_dr7();	124	dr7 = read_dr7();
125	dr7 &= ~(0x2 << (curidx*2));	125	dr7 &= ~(0x2 << (curidx*2));
126		126
127	if (cur->address) { /* Setup DR register */	127	if (cur->address) { /* Setup DR register */
128	/* Set breakpoint to debug registers */	128	/* Set breakpoint to debug registers */
129	switch (curidx) {	129	switch (curidx) {
130	case 0:	130	case 0:
131	write_dr0(cur->address);	131	write_dr0(cur->address);
132	break;	132	break;
133	case 1:	133	case 1:
134	write_dr1(cur->address);	134	write_dr1(cur->address);
135	break;	135	break;
136	case 2:	136	case 2:
137	write_dr2(cur->address);	137	write_dr2(cur->address);
138	break;	138	break;
139	case 3:	139	case 3:
140	write_dr3(cur->address);	140	write_dr3(cur->address);
141	break;	141	break;
142	}	142	}
143	/* Set type to requested breakpoint & length*/	143	/* Set type to requested breakpoint & length*/
144	dr7 &= ~ (0x3 << (16 + 4*curidx));	144	dr7 &= ~ (0x3 << (16 + 4*curidx));
145	dr7 &= ~ (0x3 << (18 + 4*curidx));	145	dr7 &= ~ (0x3 << (18 + 4*curidx));
146	if ((flags & BKPOINT_INSTR)) {	146	if ((flags & BKPOINT_INSTR)) {
147	;	147	;
148	} else {	148	} else {
149	if (sizeof(int) == 4)	149	if (sizeof(int) == 4)
150	dr7 \|= ((__native) 0x3) << (18 + 4*curidx);	150	dr7 \|= ((__native) 0x3) << (18 + 4*curidx);
151	else /* 8 */	151	else /* 8 */
152	dr7 \|= ((__native) 0x2) << (18 + 4*curidx);	152	dr7 \|= ((__native) 0x2) << (18 + 4*curidx);
153		153
154	if ((flags & BKPOINT_WRITE))	154	if ((flags & BKPOINT_WRITE))
155	dr7 \|= ((__native) 0x1) << (16 + 4*curidx);	155	dr7 \|= ((__native) 0x1) << (16 + 4*curidx);
156	else if ((flags & BKPOINT_READ_WRITE))	156	else if ((flags & BKPOINT_READ_WRITE))
157	dr7 \|= ((__native) 0x3) << (16 + 4*curidx);	157	dr7 \|= ((__native) 0x3) << (16 + 4*curidx);
158	}	158	}
159		159
160	/* Enable global breakpoint */	160	/* Enable global breakpoint */
161	dr7 \|= 0x2 << (curidx*2);	161	dr7 \|= 0x2 << (curidx*2);
162		162
163	write_dr7(dr7);	163	write_dr7(dr7);
164		164
165	}	165	}
166	}	166	}
167		167
168	/** Enable hardware breakpoint	168	/** Enable hardware breakpoint
169	*	169	*
170	*	170	*
171	* @param where Address of HW breakpoint	171	* @param where Address of HW breakpoint
172	* @param flags Type of breakpoint (EXECUTE, WRITE)	172	* @param flags Type of breakpoint (EXECUTE, WRITE)
173	* @return Debug slot on success, -1 - no available HW breakpoint	173	* @return Debug slot on success, -1 - no available HW breakpoint
174	*/	174	*/
175	int breakpoint_add(void * where, int flags, int curidx)	175	int breakpoint_add(void * where, int flags, int curidx)
176	{	176	{
177	ipl_t ipl;	177	ipl_t ipl;
178	int i;	178	int i;
179	bpinfo_t *cur;	179	bpinfo_t *cur;
180		180
181	ASSERT( flags & (BKPOINT_INSTR \| BKPOINT_WRITE \| BKPOINT_READ_WRITE));	181	ASSERT( flags & (BKPOINT_INSTR \| BKPOINT_WRITE \| BKPOINT_READ_WRITE));
182		182
183	ipl = interrupts_disable();	183	ipl = interrupts_disable();
184	spinlock_lock(&bkpoint_lock);	184	spinlock_lock(&bkpoint_lock);
185		185
186	if (curidx == -1) {	186	if (curidx == -1) {
187	/* Find free space in slots */	187	/* Find free space in slots */
188	for (i=0; i<BKPOINTS_MAX; i++)	188	for (i=0; i<BKPOINTS_MAX; i++)
189	if (!breakpoints[i].address) {	189	if (!breakpoints[i].address) {
190	curidx = i;	190	curidx = i;
191	break;	191	break;
192	}	192	}
193	if (curidx == -1) {	193	if (curidx == -1) {
194	/* Too many breakpoints */	194	/* Too many breakpoints */
195	spinlock_unlock(&bkpoint_lock);	195	spinlock_unlock(&bkpoint_lock);
196	interrupts_restore(ipl);	196	interrupts_restore(ipl);
197	return -1;	197	return -1;
198	}	198	}
199	}	199	}
200	cur = &breakpoints[curidx];	200	cur = &breakpoints[curidx];
201		201
202	cur->address = (__address) where;	202	cur->address = (__address) where;
203	cur->flags = flags;	203	cur->flags = flags;
204	cur->counter = 0;	204	cur->counter = 0;
205		205
206	setup_dr(curidx);	206	setup_dr(curidx);
207		207
208	spinlock_unlock(&bkpoint_lock);	208	spinlock_unlock(&bkpoint_lock);
209	interrupts_restore(ipl);	209	interrupts_restore(ipl);
210		210
211	/* Send IPI */	211	/* Send IPI */
212	#ifdef CONFIG_SMP	212	#ifdef CONFIG_SMP
213	// ipi_broadcast(VECTOR_DEBUG_IPI);	213	// ipi_broadcast(VECTOR_DEBUG_IPI);
214	#endif	214	#endif
215		215
216	return curidx;	216	return curidx;
217	}	217	}
218		218
219	#ifdef amd64	219	#ifdef amd64
220	# define getip(x) ((x)->rip)	220	# define getip(x) ((x)->rip)
221	#else	221	#else
222	# define getip(x) ((x)->eip)	222	# define getip(x) ((x)->eip)
223	#endif	223	#endif
224		224
225	static void handle_exception(int slot, istate_t *istate)	225	static void handle_exception(int slot, istate_t *istate)
226	{	226	{
227	ASSERT(breakpoints[slot].address);	227	ASSERT(breakpoints[slot].address);
228		228
229	/* Handle zero checker */	229	/* Handle zero checker */
230	if (! (breakpoints[slot].flags & BKPOINT_INSTR)) {	230	if (! (breakpoints[slot].flags & BKPOINT_INSTR)) {
231	if ((breakpoints[slot].flags & BKPOINT_CHECK_ZERO)) {	231	if ((breakpoints[slot].flags & BKPOINT_CHECK_ZERO)) {
232	if (((__native ) breakpoints[slot].address) != 0)	232	if (((__native ) breakpoints[slot].address) != 0)
233	return;	233	return;
234	printf("** Found ZERO on address %P **\n",	234	printf("** Found ZERO on address %p **\n",
235	slot, breakpoints[slot].address);	235	slot, breakpoints[slot].address);
236	} else {	236	} else {
237	printf("Data watchpoint - new data: %P\n",	237	printf("Data watchpoint - new data: %p\n",
238	((__native ) breakpoints[slot].address));	238	((__native ) breakpoints[slot].address));
239	}	239	}
240	}	240	}
241	printf("Reached breakpoint %d:%P(%s)\n", slot, getip(istate),	241	printf("Reached breakpoint %d:%p(%s)\n", slot, getip(istate),
242	get_symtab_entry(getip(istate)));	242	get_symtab_entry(getip(istate)));
243	printf("***Type 'exit' to exit kconsole.\n");	243	printf("***Type 'exit' to exit kconsole.\n");
244	atomic_set(&haltstate,1);	244	atomic_set(&haltstate,1);
245	kconsole("debug");	245	kconsole("debug");
246	atomic_set(&haltstate,0);	246	atomic_set(&haltstate,0);
247	}	247	}
248		248
249	void breakpoint_del(int slot)	249	void breakpoint_del(int slot)
250	{	250	{
251	bpinfo_t *cur;	251	bpinfo_t *cur;
252	ipl_t ipl;	252	ipl_t ipl;
253		253
254	ipl = interrupts_disable();	254	ipl = interrupts_disable();
255	spinlock_lock(&bkpoint_lock);	255	spinlock_lock(&bkpoint_lock);
256		256
257	cur = &breakpoints[slot];	257	cur = &breakpoints[slot];
258	if (!cur->address) {	258	if (!cur->address) {
259	spinlock_unlock(&bkpoint_lock);	259	spinlock_unlock(&bkpoint_lock);
260	interrupts_restore(ipl);	260	interrupts_restore(ipl);
261	return;	261	return;
262	}	262	}
263		263
264	cur->address = NULL;	264	cur->address = NULL;
265		265
266	setup_dr(slot);	266	setup_dr(slot);
267		267
268	spinlock_unlock(&bkpoint_lock);	268	spinlock_unlock(&bkpoint_lock);
269	interrupts_restore(ipl);	269	interrupts_restore(ipl);
270	#ifdef CONFIG_SMP	270	#ifdef CONFIG_SMP
271	// ipi_broadcast(VECTOR_DEBUG_IPI);	271	// ipi_broadcast(VECTOR_DEBUG_IPI);
272	#endif	272	#endif
273	}	273	}
274		274
275	#ifndef CONFIG_DEBUG_AS_WATCHPOINT	275	#ifndef CONFIG_DEBUG_AS_WATCHPOINT
276		276
277	/** Remove breakpoint from table */	277	/** Remove breakpoint from table */
278	int cmd_del_breakpoint(cmd_arg_t *argv)	278	int cmd_del_breakpoint(cmd_arg_t *argv)
279	{	279	{
280	if (argv->intval < 0 \|\| argv->intval > BKPOINTS_MAX) {	280	if (argv->intval < 0 \|\| argv->intval > BKPOINTS_MAX) {
281	printf("Invalid breakpoint number.\n");	281	printf("Invalid breakpoint number.\n");
282	return 0;	282	return 0;
283	}	283	}
284	breakpoint_del(argv->intval);	284	breakpoint_del(argv->intval);
285	return 1;	285	return 1;
286	}	286	}
287		287
288	/** Add new breakpoint to table */	288	/** Add new breakpoint to table */
289	static int cmd_add_breakpoint(cmd_arg_t *argv)	289	static int cmd_add_breakpoint(cmd_arg_t *argv)
290	{	290	{
291	int flags;	291	int flags;
292	int id;	292	int id;
293		293
294	if (argv == &add_argv) {	294	if (argv == &add_argv) {
295	flags = BKPOINT_INSTR;	295	flags = BKPOINT_INSTR;
296	} else { /* addwatchp */	296	} else { /* addwatchp */
297	flags = BKPOINT_WRITE;	297	flags = BKPOINT_WRITE;
298	}	298	}
299	printf("Adding breakpoint on address: %p\n", argv->intval);	299	printf("Adding breakpoint on address: %p\n", argv->intval);
300	id = breakpoint_add((void *)argv->intval, flags, -1);	300	id = breakpoint_add((void *)argv->intval, flags, -1);
301	if (id < 0)	301	if (id < 0)
302	printf("Add breakpoint failed.\n");	302	printf("Add breakpoint failed.\n");
303	else	303	else
304	printf("Added breakpoint %d.\n", id);	304	printf("Added breakpoint %d.\n", id);
305		305
306	return 1;	306	return 1;
307	}	307	}
308	#endif	308	#endif
309		309
310	static void debug_exception(int n, istate_t *istate)	310	static void debug_exception(int n, istate_t *istate)
311	{	311	{
312	__native dr6;	312	__native dr6;
313	int i;	313	int i;
314		314
315	/* Set RF to restart the instruction */	315	/* Set RF to restart the instruction */
316	#ifdef amd64	316	#ifdef amd64
317	istate->rflags \|= RFLAGS_RF;	317	istate->rflags \|= RFLAGS_RF;
318	#else	318	#else
319	istate->eflags \|= EFLAGS_RF;	319	istate->eflags \|= EFLAGS_RF;
320	#endif	320	#endif
321		321
322	dr6 = read_dr6();	322	dr6 = read_dr6();
323	for (i=0; i < BKPOINTS_MAX; i++) {	323	for (i=0; i < BKPOINTS_MAX; i++) {
324	if (dr6 & (1 << i)) {	324	if (dr6 & (1 << i)) {
325	dr6 &= ~ (1 << i);	325	dr6 &= ~ (1 << i);
326	write_dr6(dr6);	326	write_dr6(dr6);
327		327
328	handle_exception(i, istate);	328	handle_exception(i, istate);
329	}	329	}
330	}	330	}
331	}	331	}
332		332
333	#ifdef CONFIG_SMP	333	#ifdef CONFIG_SMP
334	static void debug_ipi(int n, istate_t *istate)	334	static void debug_ipi(int n, istate_t *istate)
335	{	335	{
336	int i;	336	int i;
337		337
338	spinlock_lock(&bkpoint_lock);	338	spinlock_lock(&bkpoint_lock);
339	for (i=0; i < BKPOINTS_MAX; i++)	339	for (i=0; i < BKPOINTS_MAX; i++)
340	setup_dr(i);	340	setup_dr(i);
341	spinlock_unlock(&bkpoint_lock);	341	spinlock_unlock(&bkpoint_lock);
342	}	342	}
343	#endif	343	#endif
344		344
345	/** Initialize debugger */	345	/** Initialize debugger */
346	void debugger_init()	346	void debugger_init()
347	{	347	{
348	int i;	348	int i;
349		349
350	for (i=0; i<BKPOINTS_MAX; i++)	350	for (i=0; i<BKPOINTS_MAX; i++)
351	breakpoints[i].address = NULL;	351	breakpoints[i].address = NULL;
352		352
353	cmd_initialize(&bkpts_info);	353	cmd_initialize(&bkpts_info);
354	if (!cmd_register(&bkpts_info))	354	if (!cmd_register(&bkpts_info))
355	panic("could not register command %s\n", bkpts_info.name);	355	panic("could not register command %s\n", bkpts_info.name);
356		356
357	#ifndef CONFIG_DEBUG_AS_WATCHPOINT	357	#ifndef CONFIG_DEBUG_AS_WATCHPOINT
358	cmd_initialize(&delbkpt_info);	358	cmd_initialize(&delbkpt_info);
359	if (!cmd_register(&delbkpt_info))	359	if (!cmd_register(&delbkpt_info))
360	panic("could not register command %s\n", delbkpt_info.name);	360	panic("could not register command %s\n", delbkpt_info.name);
361		361
362	cmd_initialize(&addbkpt_info);	362	cmd_initialize(&addbkpt_info);
363	if (!cmd_register(&addbkpt_info))	363	if (!cmd_register(&addbkpt_info))
364	panic("could not register command %s\n", addbkpt_info.name);	364	panic("could not register command %s\n", addbkpt_info.name);
365		365
366	cmd_initialize(&addwatchp_info);	366	cmd_initialize(&addwatchp_info);
367	if (!cmd_register(&addwatchp_info))	367	if (!cmd_register(&addwatchp_info))
368	panic("could not register command %s\n", addwatchp_info.name);	368	panic("could not register command %s\n", addwatchp_info.name);
369	#endif	369	#endif
370		370
371	exc_register(VECTOR_DEBUG, "debugger",	371	exc_register(VECTOR_DEBUG, "debugger",
372	debug_exception);	372	debug_exception);
373	#ifdef CONFIG_SMP	373	#ifdef CONFIG_SMP
374	exc_register(VECTOR_DEBUG_IPI, "debugger_smp",	374	exc_register(VECTOR_DEBUG_IPI, "debugger_smp",
375	debug_ipi);	375	debug_ipi);
376	#endif	376	#endif
377	}	377	}
378		378

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/arch/amd64/src/debugger.c @ 1671 – Rev 1196 → 1221