Subversion Repositories HelenOS

Rev

Rev 3457 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 3457 Rev 3468
Line 57... Line 57...
57 
    }
 57 
    }
58 
 
 58 
 
59 
    return 0;
 59 
    return 0;
60 
}
 60 
}
61 
 
 61 
 
- 
 
 62 
/** Process a BEGIN call.
- 
 
 63 
 *
- 
 
 64 
 * Initiates a debugging session for the current task. The reply
- 
 
 65 
 * to this call may or may not be sent before this function returns.
- 
 
 66 
 *
- 
 
 67 
 * @param call  The call structure.
- 
 
 68 
 */
62 
static void udebug_receive_begin(call_t *call)
 69 
static void udebug_receive_begin(call_t *call)
63 
{
 70 
{
64 
    int rc;
 71 
    int rc;
65 
 
 72 
 
66 
    rc = udebug_begin(call);
 73 
    rc = udebug_begin(call);
Line 68... Line 75...
68 
        IPC_SET_RETVAL(call->data, rc);
 75 
        IPC_SET_RETVAL(call->data, rc);
69 
        ipc_answer(&TASK->kernel_box, call);
 76 
        ipc_answer(&TASK->kernel_box, call);
70 
        return;
 77 
        return;
71 
    }
 78 
    }
72 
 
 79 
 
- 
 
 80 
    /*
- 
 
 81 
     * If the initialization of the debugging session has finished,
- 
 
 82 
     * send a reply.
- 
 
 83 
     */
73 
    if (rc != 0) {
 84 
    if (rc != 0) {
74 
        IPC_SET_RETVAL(call->data, 0);
 85 
        IPC_SET_RETVAL(call->data, 0);
75 
        ipc_answer(&TASK->kernel_box, call);
 86 
        ipc_answer(&TASK->kernel_box, call);
76 
    }
 87 
    }
77 
}
 88 
}
78 
 
 89 
 
- 
 
 90 
/** Process an END call.
- 
 
 91 
 *
- 
 
 92 
 * Terminates the debugging session for the current task.
- 
 
 93 
 * @param call  The call structure.
- 
 
 94 
 */
79 
static void udebug_receive_end(call_t *call)
 95 
static void udebug_receive_end(call_t *call)
80 
{
 96 
{
81 
    int rc;
 97 
    int rc;
82 
 
 98 
 
83 
    rc = udebug_end();
 99 
    rc = udebug_end();
84 
 
 100 
 
85 
    IPC_SET_RETVAL(call->data, rc);
 101 
    IPC_SET_RETVAL(call->data, rc);
86 
    ipc_answer(&TASK->kernel_box, call);
 102 
    ipc_answer(&TASK->kernel_box, call);
87 
}
 103 
}
88 
 
 104 
 
- 
 
 105 
/** Process a SET_EVMASK call.
- 
 
 106 
 *
- 
 
 107 
 * Sets an event mask for the current debugging session.
- 
 
 108 
 * @param call  The call structure.
- 
 
 109 
 */
89 
static void udebug_receive_set_evmask(call_t *call)
 110 
static void udebug_receive_set_evmask(call_t *call)
90 
{
 111 
{
91 
    int rc;
 112 
    int rc;
92 
    udebug_evmask_t mask;
 113 
    udebug_evmask_t mask;
93 
 
 114 
 
Line 97... Line 118...
97 
    IPC_SET_RETVAL(call->data, rc);
 118 
    IPC_SET_RETVAL(call->data, rc);
98 
    ipc_answer(&TASK->kernel_box, call);
 119 
    ipc_answer(&TASK->kernel_box, call);
99 
}
 120 
}
100 
 
 121 
 
101 
 
 122 
 
- 
 
 123 
/** Process a GO call.
- 
 
 124 
 *
- 
 
 125 
 * Resumes execution of the specified thread.
- 
 
 126 
 * @param call  The call structure.
- 
 
 127 
 */
102 
static void udebug_receive_go(call_t *call)
 128 
static void udebug_receive_go(call_t *call)
103 
{
 129 
{
104 
    thread_t *t;
 130 
    thread_t *t;
105 
    int rc;
 131 
    int rc;
106 
 
 132 
 
Line 112... Line 138...
112 
        ipc_answer(&TASK->kernel_box, call);
 138 
        ipc_answer(&TASK->kernel_box, call);
113 
        return;
 139 
        return;
114 
    }
 140 
    }
115 
}
 141 
}
116 
 
 142 
 
- 
 
 143 
/** Process a STOP call.
- 
 
 144 
 *
- 
 
 145 
 * Suspends execution of the specified thread.
- 
 
 146 
 * @param call  The call structure.
- 
 
 147 
 */
117 
static void udebug_receive_stop(call_t *call)
 148 
static void udebug_receive_stop(call_t *call)
118 
{
 149 
{
119 
    thread_t *t;
 150 
    thread_t *t;
120 
    int rc;
 151 
    int rc;
121 
 
 152 
 
Line 124... Line 155...
124 
    rc = udebug_stop(t, call);
 155 
    rc = udebug_stop(t, call);
125 
    IPC_SET_RETVAL(call->data, rc);
 156 
    IPC_SET_RETVAL(call->data, rc);
126 
    ipc_answer(&TASK->kernel_box, call);
 157 
    ipc_answer(&TASK->kernel_box, call);
127 
}
 158 
}
128 
 
 159 
 
- 
 
 160 
/** Process a THREAD_READ call.
- 
 
 161 
 *
- 
 
 162 
 * Reads the list of hashes of the (userspace) threads in the current task.
- 
 
 163 
 * @param call  The call structure.
- 
 
 164 
 */
129 
static void udebug_receive_thread_read(call_t *call)
 165 
static void udebug_receive_thread_read(call_t *call)
130 
{
 166 
{
131 
    unative_t uspace_addr;
 167 
    unative_t uspace_addr;
132 
    unative_t to_copy;
 168 
    unative_t to_copy;
133 
    unsigned total_bytes;
 169 
    unsigned total_bytes;
Line 174... Line 210...
174 
    call->buffer = buffer;
 210 
    call->buffer = buffer;
175 
 
 211 
 
176 
    ipc_answer(&TASK->kernel_box, call);
 212 
    ipc_answer(&TASK->kernel_box, call);
177 
}
 213 
}
178 
 
 214 
 
- 
 
 215 
/** Process an ARGS_READ call.
- 
 
 216 
 *
- 
 
 217 
 * Reads the argument of a current syscall event (SYSCALL_B or SYSCALL_E).
- 
 
 218 
 * @param call  The call structure.
- 
 
 219 
 */
179 
static void udebug_receive_args_read(call_t *call)
 220 
static void udebug_receive_args_read(call_t *call)
180 
{
 221 
{
181 
    thread_t *t;
 222 
    thread_t *t;
182 
    unative_t uspace_addr;
 223 
    unative_t uspace_addr;
183 
    int rc;
 224 
    int rc;
Line 207... Line 248...
207 
    call->buffer = buffer;
 248 
    call->buffer = buffer;
208 
 
 249 
 
209 
    ipc_answer(&TASK->kernel_box, call);
 250 
    ipc_answer(&TASK->kernel_box, call);
210 
}
 251 
}
211 
 
 252 
 
- 
 
 253 
/** Process an MEM_READ call.
- 
 
 254 
 *
- 
 
 255 
 * Reads memory of the current (debugged) task.
- 
 
 256 
 * @param call  The call structure.
- 
 
 257 
 */
212 
static void udebug_receive_mem_read(call_t *call)
 258 
static void udebug_receive_mem_read(call_t *call)
213 
{
 259 
{
214 
    unative_t uspace_dst;
 260 
    unative_t uspace_dst;
215 
    unative_t uspace_src;
 261 
    unative_t uspace_src;
216 
    unsigned size;
 262 
    unsigned size;
Line 237... Line 283...
237 
    call->buffer = buffer;
 283 
    call->buffer = buffer;
238 
 
 284 
 
239 
    ipc_answer(&TASK->kernel_box, call);
 285 
    ipc_answer(&TASK->kernel_box, call);
240 
}
 286 
}
241 
 
 287 
 
242 
/**
 - 
 
243 
 * Handle a debug call received on the kernel answerbox.
 288 
/** Handle a debug call received on the kernel answerbox.
244 
 *
 289 
 *
245 
 * This is called by the kbox servicing thread.
 290 
 * This is called by the kbox servicing thread. Verifies that the sender
- 
 
 291 
 * is indeed the debugger and calls the appropriate processing function.
246 
 */
 292 
 */
247 
void udebug_call_receive(call_t *call)
 293 
void udebug_call_receive(call_t *call)
248 
{
 294 
{
249 
    int debug_method;
 295 
    int debug_method;
250 
 
 296