Subversion Repositories HelenOS

Rev

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

Rev 3448 Rev 3535
Line 43... Line 43...
43
#include <udebug/udebug_ipc.h>
43
#include <udebug/udebug_ipc.h>
44
#include <ipc/kbox.h>
44
#include <ipc/kbox.h>
45
 
45
 
46
void ipc_kbox_cleanup(void)
46
void ipc_kbox_cleanup(void)
47
{
47
{
-
 
48
    ipl_t ipl;
48
    bool have_kb_thread;
49
    bool have_kb_thread;
49
 
50
 
50
    /* Only hold kb_cleanup_lock while setting kb_finished - this is enough */
51
    /* Only hold kb_cleanup_lock while setting kb_finished - this is enough */
51
    mutex_lock(&TASK->kb_cleanup_lock);
52
    mutex_lock(&TASK->kb_cleanup_lock);
52
    TASK->kb_finished = true;
53
    TASK->kb_finished = true;
Line 61... Line 62...
61
     * notify_box causes a HANGUP message to be inserted for each
62
     * notify_box causes a HANGUP message to be inserted for each
62
     * disconnected phone. This ensures the kbox thread is going to
63
     * disconnected phone. This ensures the kbox thread is going to
63
     * wake up and terminate.
64
     * wake up and terminate.
64
     */
65
     */
65
    ipc_answerbox_slam_phones(&TASK->kernel_box, have_kb_thread);
66
    ipc_answerbox_slam_phones(&TASK->kernel_box, have_kb_thread);
-
 
67
 
-
 
68
    /*
-
 
69
     * If the task was being debugged, clean up debugging session.
-
 
70
     * This is necessarry as slamming the phones won't force
-
 
71
     * kbox thread to clean it up since sender != debugger.
-
 
72
     */
-
 
73
    ipl = interrupts_disable();
-
 
74
    spinlock_lock(&TASK->lock);
-
 
75
    udebug_task_cleanup(TASK);
-
 
76
    spinlock_unlock(&TASK->lock);
-
 
77
    interrupts_restore(ipl);
66
   
78
   
67
    if (have_kb_thread) {
79
    if (have_kb_thread) {
68
        LOG("join kb_thread..\n");
80
        LOG("join kb_thread..\n");
69
        thread_join(TASK->kb_thread);
81
        thread_join(TASK->kb_thread);
70
        thread_detach(TASK->kb_thread);
82
        thread_detach(TASK->kb_thread);
Line 77... Line 89...
77
    ipc_cleanup_call_list(&TASK->kernel_box.dispatched_calls);
89
    ipc_cleanup_call_list(&TASK->kernel_box.dispatched_calls);
78
    ipc_cleanup_call_list(&TASK->kernel_box.calls);
90
    ipc_cleanup_call_list(&TASK->kernel_box.calls);
79
    spinlock_unlock(&TASK->kernel_box.lock);
91
    spinlock_unlock(&TASK->kernel_box.lock);
80
}
92
}
81
 
93
 
-
 
94
/** Handle hangup message in kbox.
-
 
95
 *
-
 
96
 * @param call  The IPC_M_PHONE_HUNGUP call structure.
-
 
97
 * @param last  Output, the function stores @c true here if
-
 
98
 *      this was the last phone, @c false otherwise.
-
 
99
 **/
-
 
100
static void kbox_proc_phone_hungup(call_t *call, bool *last)
-
 
101
{
-
 
102
    ipl_t ipl;
-
 
103
 
-
 
104
    LOG("kbox_proc_phone_hungup()\n");
-
 
105
 
-
 
106
    /* Was it our debugger, who hung up? */
-
 
107
    if (call->sender == TASK->udebug.debugger) {
-
 
108
        /* Terminate debugging session (if any) */
-
 
109
        LOG("kbox: terminate debug session\n");
-
 
110
        ipl = interrupts_disable();
-
 
111
        spinlock_lock(&TASK->lock);
-
 
112
        udebug_task_cleanup(TASK);
-
 
113
        spinlock_unlock(&TASK->lock);
-
 
114
        interrupts_restore(ipl);
-
 
115
    } else {
-
 
116
        LOG("kbox: was not debugger\n");
-
 
117
    }
-
 
118
 
-
 
119
    LOG("kbox: continue with hangup message\n");
-
 
120
    IPC_SET_RETVAL(call->data, 0);
-
 
121
    ipc_answer(&TASK->kernel_box, call);
-
 
122
 
-
 
123
    ipl = interrupts_disable();
-
 
124
    spinlock_lock(&TASK->lock);
-
 
125
    spinlock_lock(&TASK->answerbox.lock);
-
 
126
    if (list_empty(&TASK->answerbox.connected_phones)) {
-
 
127
        /*
-
 
128
         * Last phone has been disconnected. Detach this thread so it
-
 
129
         * gets freed and signal to the caller.
-
 
130
         */
-
 
131
 
-
 
132
        /* Only detach kbox thread unless already terminating. */
-
 
133
        mutex_lock(&TASK->kb_cleanup_lock);
-
 
134
        if (&TASK->kb_finished == false) {
-
 
135
            /* Detach kbox thread so it gets freed from memory. */
-
 
136
            thread_detach(TASK->kb_thread);
-
 
137
            TASK->kb_thread = NULL;
-
 
138
        }
-
 
139
        mutex_unlock(&TASK->kb_cleanup_lock);
-
 
140
 
-
 
141
        LOG("phone list is empty\n");
-
 
142
        *last = true;
-
 
143
    } else {
-
 
144
        *last = false;
-
 
145
    }
-
 
146
 
-
 
147
    spinlock_unlock(&TASK->answerbox.lock);
-
 
148
    spinlock_unlock(&TASK->lock);
-
 
149
    interrupts_restore(ipl);
-
 
150
}
82
 
151
 
-
 
152
/** Implementing function for the kbox thread.
-
 
153
 *
-
 
154
 * This function listens for debug requests. It terminates
-
 
155
 * when all phones are disconnected from the kbox.
-
 
156
 *
-
 
157
 * @param arg   Ignored.
-
 
158
 */
83
static void kbox_thread_proc(void *arg)
159
static void kbox_thread_proc(void *arg)
84
{
160
{
85
    call_t *call;
161
    call_t *call;
86
    int method;
-
 
87
    bool done;
162
    bool done;
88
    ipl_t ipl;
-
 
89
 
163
 
90
    (void)arg;
164
    (void)arg;
91
    LOG("kbox_thread_proc()\n");
165
    LOG("kbox_thread_proc()\n");
92
    done = false;
166
    done = false;
93
 
167
 
94
    while (!done) {
168
    while (!done) {
95
        call = ipc_wait_for_call(&TASK->kernel_box, SYNCH_NO_TIMEOUT,
169
        call = ipc_wait_for_call(&TASK->kernel_box, SYNCH_NO_TIMEOUT,
96
            SYNCH_FLAGS_NONE);
170
            SYNCH_FLAGS_NONE);
97
 
171
 
98
        if (call != NULL) {
172
        if (call == NULL)
-
 
173
            continue;   /* Try again. */
-
 
174
 
99
            method = IPC_GET_METHOD(call->data);
175
        switch (IPC_GET_METHOD(call->data)) {
100
 
176
 
101
            if (method == IPC_M_DEBUG_ALL) {
177
        case IPC_M_DEBUG_ALL:
-
 
178
            /* Handle debug call. */
102
                udebug_call_receive(call);
179
            udebug_call_receive(call);
103
            }
180
            break;
104
 
181
 
105
            if (method == IPC_M_PHONE_HUNGUP) {
182
        case IPC_M_PHONE_HUNGUP:
106
                LOG("kbox: handle hangup message\n");
-
 
107
 
183
            /*
108
                /* Was it our debugger, who hung up? */
184
             * Process the hangup call. If this was the last
109
                if (call->sender == TASK->udebug.debugger) {
-
 
110
                    /* Terminate debugging session (if any) */
185
             * phone, done will be set to true and the
111
                    LOG("kbox: terminate debug session\n");
-
 
112
                    ipl = interrupts_disable();
186
             * while loop will terminate.
113
                    spinlock_lock(&TASK->lock);
-
 
114
                    udebug_task_cleanup(TASK);
-
 
115
                    spinlock_unlock(&TASK->lock);
-
 
116
                    interrupts_restore(ipl);
-
 
117
                } else {
187
             */
118
                    LOG("kbox: was not debugger\n");
188
            kbox_proc_phone_hungup(call, &done);
119
                }
189
            break;
120
 
-
 
121
                LOG("kbox: continue with hangup message\n");
-
 
122
                IPC_SET_RETVAL(call->data, 0);
-
 
123
                ipc_answer(&TASK->kernel_box, call);
-
 
124
 
190
 
125
                ipl = interrupts_disable();
-
 
126
                spinlock_lock(&TASK->lock);
-
 
127
                spinlock_lock(&TASK->answerbox.lock);
-
 
128
                if (list_empty(&TASK->answerbox.connected_phones)) {
-
 
129
                    /* Last phone has been disconnected */
-
 
130
                    TASK->kb_thread = NULL;
-
 
131
                    done = true;
191
        default:
132
                    LOG("phone list is empty\n");
-
 
133
                }
-
 
134
                spinlock_unlock(&TASK->answerbox.lock);
-
 
135
                spinlock_unlock(&TASK->lock);
-
 
136
                interrupts_restore(ipl);
192
            /* Ignore */
137
            }
193
            break;
138
        }
194
        }
139
    }
195
    }
140
 
196
 
141
    LOG("kbox: finished\n");
197
    LOG("kbox: finished\n");
142
}
198
}