Subversion Repositories HelenOS

Rev

Rev 3870 | 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
 
274
    //printf("udebug_syscall_event\n");
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
    //printf("udebug_syscall_event/ipc_answer\n");
283
 
284
    THREAD->udebug.syscall_args[0] = a1;
285
    THREAD->udebug.syscall_args[1] = a2;
286
    THREAD->udebug.syscall_args[2] = a3;
287
    THREAD->udebug.syscall_args[3] = a4;
288
    THREAD->udebug.syscall_args[4] = a5;
289
    THREAD->udebug.syscall_args[5] = a6;
290
 
291
    /*
3601 svoboda 292
     * Make sure udebug.go is false when going to sleep
3438 svoboda 293
     * in case we get woken up by DEBUG_END. (At which
294
     * point it must be back to the initial true value).
295
     */
3601 svoboda 296
    THREAD->udebug.go = false;
3438 svoboda 297
    THREAD->udebug.cur_event = etype;
298
 
299
    ipc_answer(&TASK->answerbox, call);
300
 
301
    mutex_unlock(&THREAD->udebug.lock);
302
    mutex_unlock(&TASK->udebug.lock);
303
 
304
    udebug_wait_for_go(&THREAD->udebug.go_wq);
305
}
306
 
3617 svoboda 307
/** Thread-creation event hook combined with attaching the thread.
3457 svoboda 308
 *
309
 * Must be called when a new userspace thread is created in the debugged
3617 svoboda 310
 * task. Generates a THREAD_B event. Also attaches the thread @a t
311
 * to the task @a ta.
3457 svoboda 312
 *
3617 svoboda 313
 * This is necessary to avoid a race condition where the BEGIN and THREAD_READ
314
 * requests would be handled inbetween attaching the thread and checking it
315
 * for being in a debugging session to send the THREAD_B event. We could then
316
 * either miss threads or get some threads both in the thread list
317
 * and get a THREAD_B event for them.
318
 *
3457 svoboda 319
 * @param t Structure of the thread being created. Not locked, as the
320
 *      thread is not executing yet.
3617 svoboda 321
 * @param ta    Task to which the thread should be attached.
3457 svoboda 322
 */
3617 svoboda 323
void udebug_thread_b_event_attach(struct thread *t, struct task *ta)
3438 svoboda 324
{
325
    call_t *call;
326
 
327
    mutex_lock(&TASK->udebug.lock);
328
    mutex_lock(&THREAD->udebug.lock);
329
 
3617 svoboda 330
    thread_attach(t, ta);
331
 
3441 svoboda 332
    LOG("udebug_thread_b_event\n");
333
    LOG("- check state\n");
3438 svoboda 334
 
335
    /* Must only generate events when in debugging session */
3683 svoboda 336
    if (THREAD->udebug.active != true) {
337
        LOG("- udebug.active: %s, udebug.go: %s\n",
338
            THREAD->udebug.active ? "yes(+)" : "no(-)",
3601 svoboda 339
            THREAD->udebug.go ? "yes(-)" : "no(+)");
3438 svoboda 340
        mutex_unlock(&THREAD->udebug.lock);
341
        mutex_unlock(&TASK->udebug.lock);
342
        return;
343
    }
344
 
3441 svoboda 345
    LOG("- trigger event\n");
3438 svoboda 346
 
347
    call = THREAD->udebug.go_call;
348
    THREAD->udebug.go_call = NULL;
349
    IPC_SET_RETVAL(call->data, 0);
350
    IPC_SET_ARG1(call->data, UDEBUG_EVENT_THREAD_B);
351
    IPC_SET_ARG2(call->data, (unative_t)t);
352
 
353
    /*
3601 svoboda 354
     * Make sure udebug.go is false when going to sleep
3438 svoboda 355
     * in case we get woken up by DEBUG_END. (At which
356
     * point it must be back to the initial true value).
357
     */
3601 svoboda 358
    THREAD->udebug.go = false;
3438 svoboda 359
    THREAD->udebug.cur_event = UDEBUG_EVENT_THREAD_B;
360
 
361
    ipc_answer(&TASK->answerbox, call);
362
 
363
    mutex_unlock(&THREAD->udebug.lock);
364
    mutex_unlock(&TASK->udebug.lock);
365
 
3441 svoboda 366
    LOG("- sleep\n");
3438 svoboda 367
    udebug_wait_for_go(&THREAD->udebug.go_wq);
368
}
369
 
3457 svoboda 370
/** Thread-termination event hook.
371
 *
372
 * Must be called when the current thread is terminating.
373
 * Generates a THREAD_E event.
374
 */
3438 svoboda 375
void udebug_thread_e_event(void)
376
{
377
    call_t *call;
378
 
379
    mutex_lock(&TASK->udebug.lock);
380
    mutex_lock(&THREAD->udebug.lock);
381
 
3441 svoboda 382
    LOG("udebug_thread_e_event\n");
383
    LOG("- check state\n");
3438 svoboda 384
 
3600 svoboda 385
    /* Must only generate events when in debugging session. */
3683 svoboda 386
    if (THREAD->udebug.active != true) {
387
/*      printf("- udebug.active: %s, udebug.go: %s\n",
388
            THREAD->udebug.active ? "yes(+)" : "no(-)",
3601 svoboda 389
            THREAD->udebug.go ? "yes(-)" : "no(+)");*/
3438 svoboda 390
        mutex_unlock(&THREAD->udebug.lock);
391
        mutex_unlock(&TASK->udebug.lock);
392
        return;
393
    }
394
 
3441 svoboda 395
    LOG("- trigger event\n");
3438 svoboda 396
 
397
    call = THREAD->udebug.go_call;
398
    THREAD->udebug.go_call = NULL;
399
    IPC_SET_RETVAL(call->data, 0);
400
    IPC_SET_ARG1(call->data, UDEBUG_EVENT_THREAD_E);
401
 
3600 svoboda 402
    /* Prevent any further debug activity in thread. */
3683 svoboda 403
    THREAD->udebug.active = false;
3438 svoboda 404
    THREAD->udebug.cur_event = 0;       /* none */
3601 svoboda 405
    THREAD->udebug.go = false;  /* set to initial value */
3438 svoboda 406
 
407
    ipc_answer(&TASK->answerbox, call);
408
 
409
    mutex_unlock(&THREAD->udebug.lock);
410
    mutex_unlock(&TASK->udebug.lock);
411
 
3604 svoboda 412
    /*
413
     * This event does not sleep - debugging has finished
414
     * in this thread.
415
     */
3438 svoboda 416
}
417
 
418
/**
419
 * Terminate task debugging session.
420
 *
3457 svoboda 421
 * Gracefully terminates the debugging session for a task. If the debugger
422
 * is still waiting for events on some threads, it will receive a
423
 * FINISHED event for each of them.
424
 *
425
 * @param ta    Task structure. ta->udebug.lock must be already locked.
426
 * @return  Zero on success or negative error code.
3438 svoboda 427
 */
428
int udebug_task_cleanup(struct task *ta)
429
{
430
    thread_t *t;
431
    link_t *cur;
432
    int flags;
433
    ipl_t ipl;
434
 
3441 svoboda 435
    LOG("udebug_task_cleanup()\n");
436
    LOG("task %" PRIu64 "\n", ta->taskid);
3438 svoboda 437
 
438
    if (ta->udebug.dt_state != UDEBUG_TS_BEGINNING &&
439
        ta->udebug.dt_state != UDEBUG_TS_ACTIVE) {
3441 svoboda 440
        LOG("udebug_task_cleanup(): task not being debugged\n");
3438 svoboda 441
        return EINVAL;
442
    }
443
 
444
    /* Finish debugging of all userspace threads */
445
    for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {
446
        t = list_get_instance(cur, thread_t, th_link);
447
 
448
        mutex_lock(&t->udebug.lock);
449
 
450
        ipl = interrupts_disable();
451
        spinlock_lock(&t->lock);
452
 
453
        flags = t->flags;
454
 
455
        spinlock_unlock(&t->lock);
456
        interrupts_restore(ipl);
457
 
3600 svoboda 458
        /* Only process userspace threads. */
3438 svoboda 459
        if ((flags & THREAD_FLAG_USPACE) != 0) {
3600 svoboda 460
            /* Prevent any further debug activity in thread. */
3683 svoboda 461
            t->udebug.active = false;
3438 svoboda 462
            t->udebug.cur_event = 0;    /* none */
463
 
3600 svoboda 464
            /* Is the thread still go? */
3601 svoboda 465
            if (t->udebug.go == true) {
3438 svoboda 466
                /*
3683 svoboda 467
                * Yes, so clear go. As active == false,
3438 svoboda 468
                 * this doesn't affect anything.
469
                 */
3601 svoboda 470
                t->udebug.go = false;  
3438 svoboda 471
 
472
                /* Answer GO call */
3441 svoboda 473
                LOG("answer GO call with EVENT_FINISHED\n");
3438 svoboda 474
                IPC_SET_RETVAL(t->udebug.go_call->data, 0);
3468 svoboda 475
                IPC_SET_ARG1(t->udebug.go_call->data,
476
                    UDEBUG_EVENT_FINISHED);
3438 svoboda 477
 
478
                ipc_answer(&ta->answerbox, t->udebug.go_call);
479
                t->udebug.go_call = NULL;
480
            } else {
481
                /*
482
                 * Debug_stop is already at initial value.
483
                 * Yet this means the thread needs waking up.
484
                 */
485
 
486
                /*
487
                 * t's lock must not be held when calling
488
                 * waitq_wakeup.
489
                 */
490
                waitq_wakeup(&t->udebug.go_wq, WAKEUP_FIRST);
491
            }
492
        }
493
        mutex_unlock(&t->udebug.lock);
494
    }
495
 
496
    ta->udebug.dt_state = UDEBUG_TS_INACTIVE;
497
    ta->udebug.debugger = NULL;
498
 
499
    return 0;
500
}
501
 
502
 
503
/** @}
504
 */