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

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/arch/amd64/src/debugger.c @ 1222 – Rev 1702 → 1705