WebSVN – HelenOS – Diff – /branches/snapshot/kernel/generic/include/udebug/udebug.h


/*
 * Copyright (c) 2008 Jiri Svoboda
 * 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 generic
 * @{
 */
/** @file
 */
 
#ifndef KERN_UDEBUG_H_
#define KERN_UDEBUG_H_
 
#include <ipc/ipc.h>
 
typedef enum { /* udebug_method_t */
 
/** Start debugging the recipient.
 * Causes all threads in the receiving task to stop. When they
 * are all stoped, an answer with retval 0 is generated.
 */
UDEBUG_M_BEGIN = 1,
 
/** Finish debugging the recipient.
 * Answers all pending GO and GUARD messages.
 */
UDEBUG_M_END,
 
/** Set which events should be captured.
 */
UDEBUG_M_SET_EVMASK,
 
/** Make sure the debugged task is still there.
 * This message is answered when the debugged task dies
 * or the debugging session ends.
 */
UDEBUG_M_GUARD,
 
/** Run a thread until a debugging event occurs.
 * This message is answered when the thread stops
 * in a debugging event.
 *
 * - ARG2 - id of the thread to run
 */
UDEBUG_M_GO,
 
/** Stop a thread being debugged.
 * Creates a special STOP event in the thread, causing
 * it to answer a pending GO message (if any).
 */
UDEBUG_M_STOP,
 
/** Read arguments of a syscall.
 *
 * - ARG2 - thread identification
 * - ARG3 - destination address in the caller's address space
 *
 */
UDEBUG_M_ARGS_READ,
 
/** Read the list of the debugged tasks's threads.
 *
 * - ARG2 - destination address in the caller's address space
 * - ARG3 - size of receiving buffer in bytes
 *
 * The kernel fills the buffer with a series of sysarg_t values
 * (thread ids). On answer, the kernel will set:
 *
 * - ARG2 - number of bytes that were actually copied
 * - ARG3 - number of bytes of the complete data
 *
 */
UDEBUG_M_THREAD_READ,
 
/** Read the debugged tasks's memory.
 *
 * - ARG2 - destination address in the caller's address space
 * - ARG3 - source address in the recipient's address space
 * - ARG4 - size of receiving buffer in bytes
 *
 */
UDEBUG_M_MEM_READ,
 
UDEBUG_M_TASK_MEM_AREAS_READ,
 
UDEBUG_M_THREAD_COPY_KSTACK,
 
UDEBUG_M_THREAD_GET_THREAD_STRUCT,
 
UDEBUG_M_MEM_WRITE,
 
UDEBUG_M_THREAD_RESTORE_THREAD_STRUCT,
 
UDEBUG_M_RESTORE_KSTACK,
 
} udebug_method_t;
 
               
typedef enum {
    UDEBUG_EVENT_FINISHED = 1,  /**< Debuging session has finished */
    UDEBUG_EVENT_STOP,      /**< Stopped on DEBUG_STOP request */
    UDEBUG_EVENT_SYSCALL_B,     /**< Before beginning syscall execution */
    UDEBUG_EVENT_SYSCALL_E,     /**< After finishing syscall execution */
    UDEBUG_EVENT_THREAD_B,      /**< The task created a new thread */
    UDEBUG_EVENT_THREAD_E       /**< A thread exited */
} udebug_event_t;
 
#define UDEBUG_EVMASK(event) (1 << ((event) - 1))
 
typedef enum {
    UDEBUG_EM_FINISHED  = UDEBUG_EVMASK(UDEBUG_EVENT_FINISHED),
    UDEBUG_EM_STOP      = UDEBUG_EVMASK(UDEBUG_EVENT_STOP),
    UDEBUG_EM_SYSCALL_B = UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_B),
    UDEBUG_EM_SYSCALL_E = UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_E),
    UDEBUG_EM_THREAD_B  = UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_B),
    UDEBUG_EM_THREAD_E  = UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_E),
    UDEBUG_EM_ALL       =
        UDEBUG_EVMASK(UDEBUG_EVENT_FINISHED) |
        UDEBUG_EVMASK(UDEBUG_EVENT_STOP) |
        UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_B) |
        UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_E) |
        UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_B) |
        UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_E)
} udebug_evmask_t;
 
#ifdef KERNEL
 
#include <synch/mutex.h>
#include <arch/interrupt.h>
#include <atomic.h>
 
typedef enum {
    /** Task is not being debugged */
    UDEBUG_TS_INACTIVE,
    /** BEGIN operation in progress (waiting for threads to stop) */
    UDEBUG_TS_BEGINNING,
    /** Debugger fully connected */
    UDEBUG_TS_ACTIVE
} udebug_task_state_t;
 
/** Debugging part of task_t structure.
 */
typedef struct {
    /** Synchronize debug ops on this task / access to this structure */
    mutex_t lock;
    char *lock_owner;
 
    udebug_task_state_t dt_state;
    call_t *begin_call;
    int not_stoppable_count;
    struct task *debugger;
    udebug_evmask_t evmask;
} udebug_task_t;
 
/** Debugging part of thread_t structure.
 */
typedef struct {
    /** Synchronize debug ops on this thread / access to this structure. */
    mutex_t lock;
 
    waitq_t go_wq;
    call_t *go_call;
    unative_t syscall_args[6];
    istate_t *uspace_state;
 
    /** What type of event are we stopped in or 0 if none. */
    udebug_event_t cur_event;
    bool go;        /**< thread is GO */
    bool stoppable;     /**< thread is stoppable */
    bool active;        /**< thread is in a debugging session */
} udebug_thread_t;
 
struct task;
struct thread;
 
void udebug_task_init(udebug_task_t *ut);
void udebug_thread_initialize(udebug_thread_t *ut);
 
void udebug_syscall_event(unative_t a1, unative_t a2, unative_t a3,
    unative_t a4, unative_t a5, unative_t a6, unative_t id, unative_t rc,
    bool end_variant);
 
void udebug_thread_b_event_attach(struct thread *t, struct task *ta);
void udebug_thread_e_event(void);
 
void udebug_stoppable_begin(void);
void udebug_stoppable_end(void);
 
void udebug_before_thread_runs(void);
 
int udebug_task_cleanup(struct task *ta);
 
#endif
 
#endif
 
/** @}
 */
 

Rev 4605	Rev 4616
1	/*	1	/*
2	* Copyright (c) 2008 Jiri Svoboda	2	* Copyright (c) 2008 Jiri Svoboda
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 generic	29	/** @addtogroup generic
30	* @{	30	* @{
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#ifndef KERN_UDEBUG_H_	35	#ifndef KERN_UDEBUG_H_
36	#define KERN_UDEBUG_H_	36	#define KERN_UDEBUG_H_
37		37
38	#include <ipc/ipc.h>	38	#include <ipc/ipc.h>
39		39
40	typedef enum { /* udebug_method_t */	40	typedef enum { /* udebug_method_t */
41		41
42	/** Start debugging the recipient.	42	/** Start debugging the recipient.
43	* Causes all threads in the receiving task to stop. When they	43	* Causes all threads in the receiving task to stop. When they
44	* are all stoped, an answer with retval 0 is generated.	44	* are all stoped, an answer with retval 0 is generated.
45	*/	45	*/
46	UDEBUG_M_BEGIN = 1,	46	UDEBUG_M_BEGIN = 1,
47		47
48	/** Finish debugging the recipient.	48	/** Finish debugging the recipient.
49	* Answers all pending GO and GUARD messages.	49	* Answers all pending GO and GUARD messages.
50	*/	50	*/
51	UDEBUG_M_END,	51	UDEBUG_M_END,
52		52
53	/** Set which events should be captured.	53	/** Set which events should be captured.
54	*/	54	*/
55	UDEBUG_M_SET_EVMASK,	55	UDEBUG_M_SET_EVMASK,
56		56
57	/** Make sure the debugged task is still there.	57	/** Make sure the debugged task is still there.
58	* This message is answered when the debugged task dies	58	* This message is answered when the debugged task dies
59	* or the debugging session ends.	59	* or the debugging session ends.
60	*/	60	*/
61	UDEBUG_M_GUARD,	61	UDEBUG_M_GUARD,
62		62
63	/** Run a thread until a debugging event occurs.	63	/** Run a thread until a debugging event occurs.
64	* This message is answered when the thread stops	64	* This message is answered when the thread stops
65	* in a debugging event.	65	* in a debugging event.
66	*	66	*
67	* - ARG2 - id of the thread to run	67	* - ARG2 - id of the thread to run
68	*/	68	*/
69	UDEBUG_M_GO,	69	UDEBUG_M_GO,
70		70
71	/** Stop a thread being debugged.	71	/** Stop a thread being debugged.
72	* Creates a special STOP event in the thread, causing	72	* Creates a special STOP event in the thread, causing
73	* it to answer a pending GO message (if any).	73	* it to answer a pending GO message (if any).
74	*/	74	*/
75	UDEBUG_M_STOP,	75	UDEBUG_M_STOP,
76		76
77	/** Read arguments of a syscall.	77	/** Read arguments of a syscall.
78	*	78	*
79	* - ARG2 - thread identification	79	* - ARG2 - thread identification
80	* - ARG3 - destination address in the caller's address space	80	* - ARG3 - destination address in the caller's address space
81	*	81	*
82	*/	82	*/
83	UDEBUG_M_ARGS_READ,	83	UDEBUG_M_ARGS_READ,
84		84
85	/** Read the list of the debugged tasks's threads.	85	/** Read the list of the debugged tasks's threads.
86	*	86	*
87	* - ARG2 - destination address in the caller's address space	87	* - ARG2 - destination address in the caller's address space
88	* - ARG3 - size of receiving buffer in bytes	88	* - ARG3 - size of receiving buffer in bytes
89	*	89	*
90	* The kernel fills the buffer with a series of sysarg_t values	90	* The kernel fills the buffer with a series of sysarg_t values
91	* (thread ids). On answer, the kernel will set:	91	* (thread ids). On answer, the kernel will set:
92	*	92	*
93	* - ARG2 - number of bytes that were actually copied	93	* - ARG2 - number of bytes that were actually copied
94	* - ARG3 - number of bytes of the complete data	94	* - ARG3 - number of bytes of the complete data
95	*	95	*
96	*/	96	*/
97	UDEBUG_M_THREAD_READ,	97	UDEBUG_M_THREAD_READ,
98		98
99	/** Read the debugged tasks's memory.	99	/** Read the debugged tasks's memory.
100	*	100	*
101	* - ARG2 - destination address in the caller's address space	101	* - ARG2 - destination address in the caller's address space
102	* - ARG3 - source address in the recipient's address space	102	* - ARG3 - source address in the recipient's address space
103	* - ARG4 - size of receiving buffer in bytes	103	* - ARG4 - size of receiving buffer in bytes
104	*	104	*
105	*/	105	*/
106	UDEBUG_M_MEM_READ,	106	UDEBUG_M_MEM_READ,
107		107
-		108	UDEBUG_M_TASK_MEM_AREAS_READ,
-		109
-		110	UDEBUG_M_THREAD_COPY_KSTACK,
-		111
-		112	UDEBUG_M_THREAD_GET_THREAD_STRUCT,
-		113
-		114	UDEBUG_M_MEM_WRITE,
-		115
-		116	UDEBUG_M_THREAD_RESTORE_THREAD_STRUCT,
-		117
-		118	UDEBUG_M_RESTORE_KSTACK,
-		119
108	} udebug_method_t;	120	} udebug_method_t;
109		121
110		122
111	typedef enum {	123	typedef enum {
112	UDEBUG_EVENT_FINISHED = 1, /*< Debuging session has finished /	124	UDEBUG_EVENT_FINISHED = 1, /*< Debuging session has finished /
113	UDEBUG_EVENT_STOP, /*< Stopped on DEBUG_STOP request /	125	UDEBUG_EVENT_STOP, /*< Stopped on DEBUG_STOP request /
114	UDEBUG_EVENT_SYSCALL_B, /*< Before beginning syscall execution /	126	UDEBUG_EVENT_SYSCALL_B, /*< Before beginning syscall execution /
115	UDEBUG_EVENT_SYSCALL_E, /*< After finishing syscall execution /	127	UDEBUG_EVENT_SYSCALL_E, /*< After finishing syscall execution /
116	UDEBUG_EVENT_THREAD_B, /*< The task created a new thread /	128	UDEBUG_EVENT_THREAD_B, /*< The task created a new thread /
117	UDEBUG_EVENT_THREAD_E /*< A thread exited /	129	UDEBUG_EVENT_THREAD_E /*< A thread exited /
118	} udebug_event_t;	130	} udebug_event_t;
119		131
120	#define UDEBUG_EVMASK(event) (1 << ((event) - 1))	132	#define UDEBUG_EVMASK(event) (1 << ((event) - 1))
121		133
122	typedef enum {	134	typedef enum {
123	UDEBUG_EM_FINISHED = UDEBUG_EVMASK(UDEBUG_EVENT_FINISHED),	135	UDEBUG_EM_FINISHED = UDEBUG_EVMASK(UDEBUG_EVENT_FINISHED),
124	UDEBUG_EM_STOP = UDEBUG_EVMASK(UDEBUG_EVENT_STOP),	136	UDEBUG_EM_STOP = UDEBUG_EVMASK(UDEBUG_EVENT_STOP),
125	UDEBUG_EM_SYSCALL_B = UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_B),	137	UDEBUG_EM_SYSCALL_B = UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_B),
126	UDEBUG_EM_SYSCALL_E = UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_E),	138	UDEBUG_EM_SYSCALL_E = UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_E),
127	UDEBUG_EM_THREAD_B = UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_B),	139	UDEBUG_EM_THREAD_B = UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_B),
128	UDEBUG_EM_THREAD_E = UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_E),	140	UDEBUG_EM_THREAD_E = UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_E),
129	UDEBUG_EM_ALL =	141	UDEBUG_EM_ALL =
130	UDEBUG_EVMASK(UDEBUG_EVENT_FINISHED) \|	142	UDEBUG_EVMASK(UDEBUG_EVENT_FINISHED) \|
131	UDEBUG_EVMASK(UDEBUG_EVENT_STOP) \|	143	UDEBUG_EVMASK(UDEBUG_EVENT_STOP) \|
132	UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_B) \|	144	UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_B) \|
133	UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_E) \|	145	UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_E) \|
134	UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_B) \|	146	UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_B) \|
135	UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_E)	147	UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_E)
136	} udebug_evmask_t;	148	} udebug_evmask_t;
137		149
138	#ifdef KERNEL	150	#ifdef KERNEL
139		151
140	#include <synch/mutex.h>	152	#include <synch/mutex.h>
141	#include <arch/interrupt.h>	153	#include <arch/interrupt.h>
142	#include <atomic.h>	154	#include <atomic.h>
143		155
144	typedef enum {	156	typedef enum {
145	/** Task is not being debugged */	157	/** Task is not being debugged */
146	UDEBUG_TS_INACTIVE,	158	UDEBUG_TS_INACTIVE,
147	/** BEGIN operation in progress (waiting for threads to stop) */	159	/** BEGIN operation in progress (waiting for threads to stop) */
148	UDEBUG_TS_BEGINNING,	160	UDEBUG_TS_BEGINNING,
149	/** Debugger fully connected */	161	/** Debugger fully connected */
150	UDEBUG_TS_ACTIVE	162	UDEBUG_TS_ACTIVE
151	} udebug_task_state_t;	163	} udebug_task_state_t;
152		164
153	/** Debugging part of task_t structure.	165	/** Debugging part of task_t structure.
154	*/	166	*/
155	typedef struct {	167	typedef struct {
156	/** Synchronize debug ops on this task / access to this structure */	168	/** Synchronize debug ops on this task / access to this structure */
157	mutex_t lock;	169	mutex_t lock;
158	char *lock_owner;	170	char *lock_owner;
159		171
160	udebug_task_state_t dt_state;	172	udebug_task_state_t dt_state;
161	call_t *begin_call;	173	call_t *begin_call;
162	int not_stoppable_count;	174	int not_stoppable_count;
163	struct task *debugger;	175	struct task *debugger;
164	udebug_evmask_t evmask;	176	udebug_evmask_t evmask;
165	} udebug_task_t;	177	} udebug_task_t;
166		178
167	/** Debugging part of thread_t structure.	179	/** Debugging part of thread_t structure.
168	*/	180	*/
169	typedef struct {	181	typedef struct {
170	/** Synchronize debug ops on this thread / access to this structure. */	182	/** Synchronize debug ops on this thread / access to this structure. */
171	mutex_t lock;	183	mutex_t lock;
172		184
173	waitq_t go_wq;	185	waitq_t go_wq;
174	call_t *go_call;	186	call_t *go_call;
175	unative_t syscall_args[6];	187	unative_t syscall_args[6];
176	istate_t *uspace_state;	188	istate_t *uspace_state;
177		189
178	/** What type of event are we stopped in or 0 if none. */	190	/** What type of event are we stopped in or 0 if none. */
179	udebug_event_t cur_event;	191	udebug_event_t cur_event;
180	bool go; /*< thread is GO /	192	bool go; /*< thread is GO /
181	bool stoppable; /*< thread is stoppable /	193	bool stoppable; /*< thread is stoppable /
182	bool active; /*< thread is in a debugging session /	194	bool active; /*< thread is in a debugging session /
183	} udebug_thread_t;	195	} udebug_thread_t;
184		196
185	struct task;	197	struct task;
186	struct thread;	198	struct thread;
187		199
188	void udebug_task_init(udebug_task_t *ut);	200	void udebug_task_init(udebug_task_t *ut);
189	void udebug_thread_initialize(udebug_thread_t *ut);	201	void udebug_thread_initialize(udebug_thread_t *ut);
190		202
191	void udebug_syscall_event(unative_t a1, unative_t a2, unative_t a3,	203	void udebug_syscall_event(unative_t a1, unative_t a2, unative_t a3,
192	unative_t a4, unative_t a5, unative_t a6, unative_t id, unative_t rc,	204	unative_t a4, unative_t a5, unative_t a6, unative_t id, unative_t rc,
193	bool end_variant);	205	bool end_variant);
194		206
195	void udebug_thread_b_event_attach(struct thread t, struct task ta);	207	void udebug_thread_b_event_attach(struct thread t, struct task ta);
196	void udebug_thread_e_event(void);	208	void udebug_thread_e_event(void);
197		209
198	void udebug_stoppable_begin(void);	210	void udebug_stoppable_begin(void);
199	void udebug_stoppable_end(void);	211	void udebug_stoppable_end(void);
200		212
201	void udebug_before_thread_runs(void);	213	void udebug_before_thread_runs(void);
202		214
203	int udebug_task_cleanup(struct task *ta);	215	int udebug_task_cleanup(struct task *ta);
204		216
205	#endif	217	#endif
206		218
207	#endif	219	#endif
208		220
209	/** @}	221	/** @}
210	*/	222	*/
211		223

Subversion Repositories HelenOS

(root)/branches/snapshot/kernel/generic/include/udebug/udebug.h – Rev 4605 → 4616