Subversion Repositories HelenOS

Rev

Rev 3870 | Rev 4386 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3438 svoboda 1
/*
2
 * Copyright (c) 2008 Jiri Svoboda
3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
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
15
 *   derived from this software without specific prior written permission.
16
 *
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
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
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
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
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
29
/** @addtogroup generic
30
 * @{
31
 */
32
 
33
/**
34
 * @file
3457 svoboda 35
 * @brief   Udebug hooks and data structure management.
3438 svoboda 36
 *
3457 svoboda 37
 * Udebug is an interface that makes userspace debuggers possible.
3438 svoboda 38
 */
39
 
40
#include <synch/waitq.h>
3441 svoboda 41
#include <debug.h>
3438 svoboda 42
#include <udebug/udebug.h>
43
#include <errno.h>
3870 decky 44
#include <print.h>
3438 svoboda 45
#include <arch.h>
46
 
47
 
3457 svoboda 48
/** Initialize udebug part of task structure.
49
 *
50
 * Called as part of task structure initialization.
51
 * @param ut    Pointer to the structure to initialize.
52
 */
3438 svoboda 53
void udebug_task_init(udebug_task_t *ut)
54
{
55
    mutex_initialize(&ut->lock, MUTEX_PASSIVE);
56
    ut->dt_state = UDEBUG_TS_INACTIVE;
57
    ut->begin_call = NULL;
58
    ut->not_stoppable_count = 0;
59
    ut->evmask = 0;
60
}
61
 
3457 svoboda 62
/** Initialize udebug part of thread structure.
63
 *
64
 * Called as part of thread structure initialization.
65
 * @param ut    Pointer to the structure to initialize.
66
 */
3438 svoboda 67
void udebug_thread_initialize(udebug_thread_t *ut)
68
{
69
    mutex_initialize(&ut->lock, MUTEX_PASSIVE);
70
    waitq_initialize(&ut->go_wq);
71
 
72
    ut->go_call = NULL;
3613 svoboda 73
    ut->uspace_state = NULL;
3601 svoboda 74
    ut->go = false;
3438 svoboda 75
    ut->stoppable = true;
3683 svoboda 76
    ut->active = false;
3438 svoboda 77
    ut->cur_event = 0; /* none */
78
}
79
 
3457 svoboda 80
/** Wait for a GO message.
81
 *
82
 * When a debugging event occurs in a thread or the thread is stopped,
83
 * this function is called to block the thread until a GO message
84
 * is received.
85
 *
86
 * @param wq    The wait queue used by the thread to wait for GO messages.
87
 */
3438 svoboda 88
static void udebug_wait_for_go(waitq_t *wq)
89
{
90
    int rc;
91
    ipl_t ipl;
92
 
93
    ipl = waitq_sleep_prepare(wq);
94
 
95
    wq->missed_wakeups = 0; /* Enforce blocking. */
96
    rc = waitq_sleep_timeout_unsafe(wq, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
97
 
98
    waitq_sleep_finish(wq, rc, ipl);
99
}
100
 
101
/** Do a preliminary check that a debugging session is in progress.
102
 *
3457 svoboda 103
 * This only requires the THREAD->udebug.lock mutex (and not TASK->udebug.lock
104
 * mutex). For an undebugged task, this will never block (while there could be
105
 * collisions by different threads on the TASK mutex), thus improving SMP
106
 * perormance for undebugged tasks.
107
 *
108
 * @return  True if the thread was in a debugging session when the function
109
 *      checked, false otherwise.
3438 svoboda 110
 */
111
static bool udebug_thread_precheck(void)
112
{
113
    bool res;
114
 
115
    mutex_lock(&THREAD->udebug.lock);
3683 svoboda 116
    res = THREAD->udebug.active;
3438 svoboda 117
    mutex_unlock(&THREAD->udebug.lock);
118
 
119
    return res;
120
}
121
 
3457 svoboda 122
/** Start of stoppable section.
123
 *
124
 * A stoppable section is a section of code where if the thread can be stoped. In other words,
125
 * if a STOP operation is issued, the thread is guaranteed not to execute
126
 * any userspace instructions until the thread is resumed.
127
 *
128
 * Having stoppable sections is better than having stopping points, since
129
 * a thread can be stopped even when it is blocked indefinitely in a system
130
 * call (whereas it would not reach any stopping point).
131
 */
3438 svoboda 132
void udebug_stoppable_begin(void)
133
{
134
    int nsc;
135
    call_t *db_call, *go_call;
136
 
137
    ASSERT(THREAD);
138
    ASSERT(TASK);
139
 
140
    /* Early check for undebugged tasks */
141
    if (!udebug_thread_precheck()) {
142
        return;
143
    }
144
 
145
    mutex_lock(&TASK->udebug.lock);
146
 
147
    nsc = --TASK->udebug.not_stoppable_count;
148
 
149
    /* Lock order OK, THREAD->udebug.lock is after TASK->udebug.lock */
150
    mutex_lock(&THREAD->udebug.lock);
151
    ASSERT(THREAD->udebug.stoppable == false);
152
    THREAD->udebug.stoppable = true;
153
 
154
    if (TASK->udebug.dt_state == UDEBUG_TS_BEGINNING && nsc == 0) {
155
        /*
156
         * This was the last non-stoppable thread. Reply to
157
         * DEBUG_BEGIN call.
158
         */
159
 
160
        db_call = TASK->udebug.begin_call;
161
        ASSERT(db_call);
162
 
163
        TASK->udebug.dt_state = UDEBUG_TS_ACTIVE;
164
        TASK->udebug.begin_call = NULL;
165
 
166
        IPC_SET_RETVAL(db_call->data, 0);
167
        ipc_answer(&TASK->answerbox, db_call);     
168
 
169
    } else if (TASK->udebug.dt_state == UDEBUG_TS_ACTIVE) {
170
        /*
171
         * Active debugging session
172
         */
173
 
3683 svoboda 174
        if (THREAD->udebug.active == true &&
3601 svoboda 175
            THREAD->udebug.go == false) {
3438 svoboda 176
            /*
177
             * Thread was requested to stop - answer go call
178
             */
179
 
180
            /* Make sure nobody takes this call away from us */
181
            go_call = THREAD->udebug.go_call;
182
            THREAD->udebug.go_call = NULL;
183
            ASSERT(go_call);
184
 
185
            IPC_SET_RETVAL(go_call->data, 0);
186
            IPC_SET_ARG1(go_call->data, UDEBUG_EVENT_STOP);
187
 
188
            THREAD->udebug.cur_event = UDEBUG_EVENT_STOP;
189
 
190
                ipc_answer(&TASK->answerbox, go_call);
191
        }
192
    }
193
 
194
    mutex_unlock(&THREAD->udebug.lock);
195
        mutex_unlock(&TASK->udebug.lock);
196
}
197
 
3457 svoboda 198
/** End of a stoppable section.
199
 *
200
 * This is the point where the thread will block if it is stopped.
201
 * (As, by definition, a stopped thread must not leave its stoppable section).
202
 */
3438 svoboda 203
void udebug_stoppable_end(void)
204
{
205
    /* Early check for undebugged tasks */
206
    if (!udebug_thread_precheck()) {
207
        return;
208
    }
209
 
210
restart:
211
    mutex_lock(&TASK->udebug.lock);
212
    mutex_lock(&THREAD->udebug.lock);
213
 
3683 svoboda 214
    if (THREAD->udebug.active && THREAD->udebug.go == false) {
3438 svoboda 215
        TASK->udebug.begin_call = NULL;
216
        mutex_unlock(&THREAD->udebug.lock);
217
        mutex_unlock(&TASK->udebug.lock);
218
 
219
        udebug_wait_for_go(&THREAD->udebug.go_wq);
220
 
221
        goto restart;
3600 svoboda 222
        /* Must try again - have to lose stoppability atomically. */
3438 svoboda 223
    } else {
224
        ++TASK->udebug.not_stoppable_count;
225
        ASSERT(THREAD->udebug.stoppable == true);
226
        THREAD->udebug.stoppable = false;
227
 
228
        mutex_unlock(&THREAD->udebug.lock);
229
        mutex_unlock(&TASK->udebug.lock);
230
    }
231
}
232
 
233
/** Upon being scheduled to run, check if the current thread should stop.
234
 *
3613 svoboda 235
 * This function is called from clock().
3438 svoboda 236
 */
237
void udebug_before_thread_runs(void)
238
{
239
    /* Check if we're supposed to stop */
240
    udebug_stoppable_begin();
241
    udebug_stoppable_end();
242
}
243
 
3457 svoboda 244
/** Syscall event hook.
245
 *
246
 * Must be called before and after servicing a system call. This generates
247
 * a SYSCALL_B or SYSCALL_E event, depending on the value of @a end_variant.
248
 */
3438 svoboda 249
void udebug_syscall_event(unative_t a1, unative_t a2, unative_t a3,
250
    unative_t a4, unative_t a5, unative_t a6, unative_t id, unative_t rc,
251
    bool end_variant)
252
{
253
    call_t *call;
254
    udebug_event_t etype;
255
 
256
    etype = end_variant ? UDEBUG_EVENT_SYSCALL_E : UDEBUG_EVENT_SYSCALL_B;
257
 
258
    /* Early check for undebugged tasks */
259
    if (!udebug_thread_precheck()) {
260
        return;
261
    }
262
 
263
    mutex_lock(&TASK->udebug.lock);
264
    mutex_lock(&THREAD->udebug.lock);
265
 
3600 svoboda 266
    /* Must only generate events when in debugging session and is go. */
3683 svoboda 267
    if (THREAD->udebug.active != true || THREAD->udebug.go == false ||
3438 svoboda 268
        (TASK->udebug.evmask & UDEBUG_EVMASK(etype)) == 0) {
269
        mutex_unlock(&THREAD->udebug.lock);
270
        mutex_unlock(&TASK->udebug.lock);
271
        return;
272
    }
273
 
4384 svoboda 274
    /* Fill in the GO response. */
3438 svoboda 275
    call = THREAD->udebug.go_call;
276
    THREAD->udebug.go_call = NULL;
277
 
278
    IPC_SET_RETVAL(call->data, 0);
279
    IPC_SET_ARG1(call->data, etype);
280
    IPC_SET_ARG2(call->data, id);
281
    IPC_SET_ARG3(call->data, rc);
282
 
283
    THREAD->udebug.syscall_args[0] = a1;
284
    THREAD->udebug.syscall_args[1] = a2;
285
    THREAD->udebug.syscall_args[2] = a3;
286
    THREAD->udebug.syscall_args[3] = a4;
287
    THREAD->udebug.syscall_args[4] = a5;
288
    THREAD->udebug.syscall_args[5] = a6;
289
 
290
    /*
3601 svoboda 291
     * Make sure udebug.go is false when going to sleep
3438 svoboda 292
     * in case we get woken up by DEBUG_END. (At which
293
     * point it must be back to the initial true value).
294
     */
3601 svoboda 295
    THREAD->udebug.go = false;
3438 svoboda 296
    THREAD->udebug.cur_event = etype;
297
 
298
    ipc_answer(&TASK->answerbox, call);
299
 
300
    mutex_unlock(&THREAD->udebug.lock);
301
    mutex_unlock(&TASK->udebug.lock);
302
 
303
    udebug_wait_for_go(&THREAD->udebug.go_wq);
304
}
305
 
3617 svoboda 306
/** Thread-creation event hook combined with attaching the thread.
3457 svoboda 307
 *
308
 * Must be called when a new userspace thread is created in the debugged
3617 svoboda 309
 * task. Generates a THREAD_B event. Also attaches the thread @a t
310
 * to the task @a ta.
3457 svoboda 311
 *
3617 svoboda 312
 * This is necessary to avoid a race condition where the BEGIN and THREAD_READ
313
 * requests would be handled inbetween attaching the thread and checking it
314
 * for being in a debugging session to send the THREAD_B event. We could then
315
 * either miss threads or get some threads both in the thread list
316
 * and get a THREAD_B event for them.
317
 *
3457 svoboda 318
 * @param t Structure of the thread being created. Not locked, as the
319
 *      thread is not executing yet.
3617 svoboda 320
 * @param ta    Task to which the thread should be attached.
3457 svoboda 321
 */
3617 svoboda 322
void udebug_thread_b_event_attach(struct thread *t, struct task *ta)
3438 svoboda 323
{
324
    call_t *call;
325
 
326
    mutex_lock(&TASK->udebug.lock);
327
    mutex_lock(&THREAD->udebug.lock);
328
 
3617 svoboda 329
    thread_attach(t, ta);
330
 
4384 svoboda 331
    LOG("Check state");
3438 svoboda 332
 
333
    /* Must only generate events when in debugging session */
3683 svoboda 334
    if (THREAD->udebug.active != true) {
4384 svoboda 335
        LOG("udebug.active: %s, udebug.go: %s",
336
            THREAD->udebug.active ? "Yes(+)" : "No",
337
            THREAD->udebug.go ? "Yes(-)" : "No");
3438 svoboda 338
        mutex_unlock(&THREAD->udebug.lock);
339
        mutex_unlock(&TASK->udebug.lock);
340
        return;
341
    }
342
 
4384 svoboda 343
    LOG("Trigger event");
3438 svoboda 344
    call = THREAD->udebug.go_call;
345
    THREAD->udebug.go_call = NULL;
346
    IPC_SET_RETVAL(call->data, 0);
347
    IPC_SET_ARG1(call->data, UDEBUG_EVENT_THREAD_B);
348
    IPC_SET_ARG2(call->data, (unative_t)t);
349
 
350
    /*
3601 svoboda 351
     * Make sure udebug.go is false when going to sleep
3438 svoboda 352
     * in case we get woken up by DEBUG_END. (At which
353
     * point it must be back to the initial true value).
354
     */
3601 svoboda 355
    THREAD->udebug.go = false;
3438 svoboda 356
    THREAD->udebug.cur_event = UDEBUG_EVENT_THREAD_B;
357
 
358
    ipc_answer(&TASK->answerbox, call);
359
 
360
    mutex_unlock(&THREAD->udebug.lock);
361
    mutex_unlock(&TASK->udebug.lock);
362
 
4384 svoboda 363
    LOG("Wait for Go");
3438 svoboda 364
    udebug_wait_for_go(&THREAD->udebug.go_wq);
365
}
366
 
3457 svoboda 367
/** Thread-termination event hook.
368
 *
369
 * Must be called when the current thread is terminating.
370
 * Generates a THREAD_E event.
371
 */
3438 svoboda 372
void udebug_thread_e_event(void)
373
{
374
    call_t *call;
375
 
376
    mutex_lock(&TASK->udebug.lock);
377
    mutex_lock(&THREAD->udebug.lock);
378
 
4384 svoboda 379
    LOG("Check state");
3438 svoboda 380
 
3600 svoboda 381
    /* Must only generate events when in debugging session. */
3683 svoboda 382
    if (THREAD->udebug.active != true) {
4384 svoboda 383
        LOG("udebug.active: %s, udebug.go: %s",
384
            THREAD->udebug.active ? "Yes" : "No",
385
            THREAD->udebug.go ? "Yes" : "No");
3438 svoboda 386
        mutex_unlock(&THREAD->udebug.lock);
387
        mutex_unlock(&TASK->udebug.lock);
388
        return;
389
    }
390
 
4384 svoboda 391
    LOG("Trigger event");
3438 svoboda 392
    call = THREAD->udebug.go_call;
393
    THREAD->udebug.go_call = NULL;
394
    IPC_SET_RETVAL(call->data, 0);
395
    IPC_SET_ARG1(call->data, UDEBUG_EVENT_THREAD_E);
396
 
3600 svoboda 397
    /* Prevent any further debug activity in thread. */
3683 svoboda 398
    THREAD->udebug.active = false;
3438 svoboda 399
    THREAD->udebug.cur_event = 0;       /* none */
3601 svoboda 400
    THREAD->udebug.go = false;  /* set to initial value */
3438 svoboda 401
 
402
    ipc_answer(&TASK->answerbox, call);
403
 
404
    mutex_unlock(&THREAD->udebug.lock);
405
    mutex_unlock(&TASK->udebug.lock);
406
 
3604 svoboda 407
    /*
408
     * This event does not sleep - debugging has finished
409
     * in this thread.
410
     */
3438 svoboda 411
}
412
 
413
/**
414
 * Terminate task debugging session.
415
 *
3457 svoboda 416
 * Gracefully terminates the debugging session for a task. If the debugger
417
 * is still waiting for events on some threads, it will receive a
418
 * FINISHED event for each of them.
419
 *
420
 * @param ta    Task structure. ta->udebug.lock must be already locked.
421
 * @return  Zero on success or negative error code.
3438 svoboda 422
 */
423
int udebug_task_cleanup(struct task *ta)
424
{
425
    thread_t *t;
426
    link_t *cur;
427
    int flags;
428
    ipl_t ipl;
429
 
430
    if (ta->udebug.dt_state != UDEBUG_TS_BEGINNING &&
431
        ta->udebug.dt_state != UDEBUG_TS_ACTIVE) {
432
        return EINVAL;
433
    }
434
 
4384 svoboda 435
    LOG("Task %" PRIu64, ta->taskid);
436
 
3438 svoboda 437
    /* Finish debugging of all userspace threads */
438
    for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {
439
        t = list_get_instance(cur, thread_t, th_link);
440
 
441
        mutex_lock(&t->udebug.lock);
442
 
443
        ipl = interrupts_disable();
444
        spinlock_lock(&t->lock);
445
 
446
        flags = t->flags;
447
 
448
        spinlock_unlock(&t->lock);
449
        interrupts_restore(ipl);
450
 
3600 svoboda 451
        /* Only process userspace threads. */
3438 svoboda 452
        if ((flags & THREAD_FLAG_USPACE) != 0) {
3600 svoboda 453
            /* Prevent any further debug activity in thread. */
3683 svoboda 454
            t->udebug.active = false;
3438 svoboda 455
            t->udebug.cur_event = 0;    /* none */
456
 
3600 svoboda 457
            /* Is the thread still go? */
3601 svoboda 458
            if (t->udebug.go == true) {
3438 svoboda 459
                /*
3683 svoboda 460
                * Yes, so clear go. As active == false,
3438 svoboda 461
                 * this doesn't affect anything.
462
                 */
3601 svoboda 463
                t->udebug.go = false;  
3438 svoboda 464
 
465
                /* Answer GO call */
4384 svoboda 466
                LOG("Answer GO call with EVENT_FINISHED.");
3438 svoboda 467
                IPC_SET_RETVAL(t->udebug.go_call->data, 0);
3468 svoboda 468
                IPC_SET_ARG1(t->udebug.go_call->data,
469
                    UDEBUG_EVENT_FINISHED);
3438 svoboda 470
 
471
                ipc_answer(&ta->answerbox, t->udebug.go_call);
472
                t->udebug.go_call = NULL;
473
            } else {
474
                /*
475
                 * Debug_stop is already at initial value.
476
                 * Yet this means the thread needs waking up.
477
                 */
478
 
479
                /*
480
                 * t's lock must not be held when calling
481
                 * waitq_wakeup.
482
                 */
483
                waitq_wakeup(&t->udebug.go_wq, WAKEUP_FIRST);
484
            }
485
        }
486
        mutex_unlock(&t->udebug.lock);
487
    }
488
 
489
    ta->udebug.dt_state = UDEBUG_TS_INACTIVE;
490
    ta->udebug.debugger = NULL;
491
 
492
    return 0;
493
}
494
 
495
 
496
/** @}
497
 */