Subversion Repositories HelenOS-historic

Rev

Rev 1720 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1113 palkovsky 1
/*
2
 * Copyright (C) 2006 Ondrej Palkovsky
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
 
1719 decky 29
/** @addtogroup libc
1653 cejka 30
 * @{
31
 */
32
/** @file
33
 */
34
 
1113 palkovsky 35
#include <libadt/list.h>
36
#include <psthread.h>
37
#include <malloc.h>
38
#include <unistd.h>
39
#include <thread.h>
40
#include <stdio.h>
1781 jermar 41
#include <libarch/faddr.h>
1392 palkovsky 42
#include <futex.h>
43
#include <assert.h>
1407 palkovsky 44
#include <async.h>
1113 palkovsky 45
 
1155 vana 46
#ifndef PSTHREAD_INITIAL_STACK_PAGES_NO
47
#define PSTHREAD_INITIAL_STACK_PAGES_NO 1
48
#endif
49
 
1113 palkovsky 50
static LIST_INITIALIZE(ready_list);
1610 palkovsky 51
static LIST_INITIALIZE(serialized_list);
1392 palkovsky 52
static LIST_INITIALIZE(manager_list);
1113 palkovsky 53
 
1128 jermar 54
static void psthread_main(void);
1125 jermar 55
 
1392 palkovsky 56
static atomic_t psthread_futex = FUTEX_INITIALIZER;
1610 palkovsky 57
/** Count of real threads that are in async_serialized mode */
58
static int serialized_threads; /* Protected by async_futex */
59
/** Thread-local count of serialization. If >0, we must not preempt */
1614 palkovsky 60
static __thread int serialization_count;
1610 palkovsky 61
/** Counter of threads residing in async_manager */
62
static int threads_in_manager;
1392 palkovsky 63
 
1129 palkovsky 64
/** Setup PSthread information into TCB structure */
1392 palkovsky 65
psthread_data_t * psthread_setup()
1129 palkovsky 66
{
67
    psthread_data_t *pt;
1392 palkovsky 68
    tcb_t *tcb;
1129 palkovsky 69
 
1392 palkovsky 70
    tcb = __make_tls();
71
    if (!tcb)
72
        return NULL;
73
 
1129 palkovsky 74
    pt = malloc(sizeof(*pt));
75
    if (!pt) {
1392 palkovsky 76
        __free_tls(tcb);
1129 palkovsky 77
        return NULL;
78
    }
79
 
80
    tcb->pst_data = pt;
81
    pt->tcb = tcb;
82
 
83
    return pt;
84
}
85
 
86
void psthread_teardown(psthread_data_t *pt)
87
{
1392 palkovsky 88
    __free_tls(pt->tcb);
1129 palkovsky 89
    free(pt);
90
}
91
 
1113 palkovsky 92
/** Function that is called on entry to new uspace thread */
1128 jermar 93
void psthread_main(void)
1113 palkovsky 94
{
1129 palkovsky 95
    psthread_data_t *pt = __tcb_get()->pst_data;
96
 
1113 palkovsky 97
    pt->retval = pt->func(pt->arg);
98
 
99
    pt->finished = 1;
100
    if (pt->waiter)
1128 jermar 101
        list_append(&pt->waiter->link, &ready_list);
1113 palkovsky 102
 
1610 palkovsky 103
    psthread_schedule_next_adv(PS_FROM_DEAD);
1113 palkovsky 104
}
105
 
1128 jermar 106
/** Schedule next userspace pseudo thread.
107
 *
1427 palkovsky 108
 * If calling with PS_TO_MANAGER parameter, the async_futex should be
109
 * held.
110
 *
1709 jermar 111
 * @param ctype Type of switch.
1128 jermar 112
 * @return 0 if there is no ready pseudo thread, 1 otherwise.
113
 */
1392 palkovsky 114
int psthread_schedule_next_adv(pschange_type ctype)
1113 palkovsky 115
{
1610 palkovsky 116
    psthread_data_t *srcpt, *dstpt;
1392 palkovsky 117
    int retval = 0;
118
 
119
    futex_down(&psthread_futex);
1113 palkovsky 120
 
1392 palkovsky 121
    if (ctype == PS_PREEMPT && list_empty(&ready_list))
122
        goto ret_0;
1113 palkovsky 123
 
1610 palkovsky 124
    if (ctype == PS_FROM_MANAGER) {
125
        if (list_empty(&ready_list) && list_empty(&serialized_list))
126
            goto ret_0;
127
        /* Do not preempt if there is not sufficient count of thread managers */
128
        if (list_empty(&serialized_list) && threads_in_manager <= serialized_threads) {
129
            goto ret_0;
130
        }
1392 palkovsky 131
    }
1407 palkovsky 132
    /* If we are going to manager and none exists, create it */
1610 palkovsky 133
    if (ctype == PS_TO_MANAGER || ctype == PS_FROM_DEAD) {
134
        while (list_empty(&manager_list)) {
135
            futex_up(&psthread_futex);
136
            async_create_manager();
137
            futex_down(&psthread_futex);
138
        }
1427 palkovsky 139
    }
1610 palkovsky 140
 
141
    if (ctype != PS_FROM_DEAD) {
142
        /* Save current state */
143
        srcpt = __tcb_get()->pst_data;
144
        if (!context_save(&srcpt->ctx)) {
145
            if (serialization_count)
146
                srcpt->flags &= ~PSTHREAD_SERIALIZED;
147
            return 1; // futex_up already done here
148
        }
1392 palkovsky 149
 
1610 palkovsky 150
        /* Save myself to correct run list */
151
        if (ctype == PS_PREEMPT)
152
            list_append(&srcpt->link, &ready_list);
153
        else if (ctype == PS_FROM_MANAGER) {
154
            list_append(&srcpt->link, &manager_list);
155
            threads_in_manager--;
156
        } /* If ctype == PS_TO_MANAGER, don't save ourselves to any list, we should
157
           * already be somewhere, or we will be lost */
1720 palkovsky 158
    } else
159
        srcpt = NULL; /* Avoid GCC warning, if ctype == PS_FROM_DEAD, srcpt is not used */
1392 palkovsky 160
 
1610 palkovsky 161
    /* Choose new thread to run */
162
    if (ctype == PS_TO_MANAGER || ctype == PS_FROM_DEAD) {
163
        dstpt = list_get_instance(manager_list.next,psthread_data_t, link);
164
        if (serialization_count && ctype == PS_TO_MANAGER) {
165
            serialized_threads++;
166
            srcpt->flags |= PSTHREAD_SERIALIZED;
167
        }
168
        threads_in_manager++;
169
    } else {
170
        if (!list_empty(&serialized_list)) {
171
            dstpt = list_get_instance(serialized_list.next, psthread_data_t, link);
172
            serialized_threads--;
173
        } else
174
            dstpt = list_get_instance(ready_list.next, psthread_data_t, link);
175
    }
176
    list_remove(&dstpt->link);
1113 palkovsky 177
 
1392 palkovsky 178
    futex_up(&psthread_futex);
1610 palkovsky 179
    context_restore(&dstpt->ctx);
1392 palkovsky 180
 
181
ret_0:
182
    futex_up(&psthread_futex);
183
    return retval;
1113 palkovsky 184
}
185
 
1128 jermar 186
/** Wait for uspace pseudo thread to finish.
187
 *
188
 * @param psthrid Pseudo thread to wait for.
189
 *
190
 * @return Value returned by the finished thread.
191
 */
192
int psthread_join(pstid_t psthrid)
1113 palkovsky 193
{
1719 decky 194
    volatile psthread_data_t *pt;
1125 jermar 195
    volatile int retval;
1113 palkovsky 196
 
197
    /* Handle psthrid = Kernel address -> it is wait for call */
198
    pt = (psthread_data_t *) psthrid;
199
 
1610 palkovsky 200
    /* TODO */
201
    printf("join unsupported\n");
202
    _exit(1);
203
 
1113 palkovsky 204
    retval = pt->retval;
205
 
206
    free(pt->stack);
1129 palkovsky 207
    psthread_teardown((void *)pt);
1113 palkovsky 208
 
209
    return retval;
210
}
211
 
212
/**
1392 palkovsky 213
 * Create a userspace thread
1113 palkovsky 214
 *
1128 jermar 215
 * @param func Pseudo thread function.
216
 * @param arg Argument to pass to func.
217
 *
218
 * @return 0 on failure, TLS of the new pseudo thread.
1113 palkovsky 219
 */
220
pstid_t psthread_create(int (*func)(void *), void *arg)
221
{
222
    psthread_data_t *pt;
223
 
1392 palkovsky 224
    pt = psthread_setup();
225
    if (!pt)
1129 palkovsky 226
        return 0;
1155 vana 227
    pt->stack = (char *) malloc(PSTHREAD_INITIAL_STACK_PAGES_NO*getpagesize());
1113 palkovsky 228
 
229
    if (!pt->stack) {
1129 palkovsky 230
        psthread_teardown(pt);
1113 palkovsky 231
        return 0;
232
    }
233
 
234
    pt->arg= arg;
235
    pt->func = func;
236
    pt->finished = 0;
237
    pt->waiter = NULL;
1610 palkovsky 238
    pt->flags = 0;
1113 palkovsky 239
 
240
    context_save(&pt->ctx);
1719 decky 241
    context_set(&pt->ctx, FADDR(psthread_main), pt->stack, PSTHREAD_INITIAL_STACK_PAGES_NO*getpagesize(), pt->tcb);
1113 palkovsky 242
 
1392 palkovsky 243
    return (pstid_t )pt;
244
}
245
 
246
/** Add a thread to ready list */
247
void psthread_add_ready(pstid_t psthrid)
248
{
249
    psthread_data_t *pt;
250
 
251
    pt = (psthread_data_t *) psthrid;
252
    futex_down(&psthread_futex);
1610 palkovsky 253
    if ((pt->flags & PSTHREAD_SERIALIZED))
254
        list_append(&pt->link, &serialized_list);
255
    else
256
        list_append(&pt->link, &ready_list);
1392 palkovsky 257
    futex_up(&psthread_futex);
258
}
1113 palkovsky 259
 
1392 palkovsky 260
/** Add a thread to manager list */
261
void psthread_add_manager(pstid_t psthrid)
262
{
263
    psthread_data_t *pt;
264
 
265
    pt = (psthread_data_t *) psthrid;
266
 
267
    futex_down(&psthread_futex);
268
    list_append(&pt->link, &manager_list);
269
    futex_up(&psthread_futex);
1113 palkovsky 270
}
1392 palkovsky 271
 
272
/** Remove one manager from manager list */
273
void psthread_remove_manager()
274
{
275
    futex_down(&psthread_futex);
276
    if (list_empty(&manager_list)) {
277
        futex_up(&psthread_futex);
278
        return;
279
    }
280
    list_remove(manager_list.next);
281
    futex_up(&psthread_futex);
282
}
1427 palkovsky 283
 
284
/** Return thread id of current running thread */
285
pstid_t psthread_get_id(void)
286
{
287
    return (pstid_t)__tcb_get()->pst_data;
288
}
1610 palkovsky 289
 
290
/** Disable preemption
291
 *
292
 * If the thread wants to send several message in row and does not want
293
 * to be preempted, it should start async_serialize_start() in the beginning
294
 * of communication and async_serialize_end() in the end. If it is a
295
 * true multithreaded application, it should protect the communication channel
296
 * by a futex as well. Interrupt messages will can still be preempted.
297
 */
298
void psthread_inc_sercount(void)
299
{
300
    serialization_count++;
301
}
302
 
303
void psthread_dec_sercount(void)
304
{
305
    serialization_count--;
306
}
1653 cejka 307
 
308
 
1719 decky 309
/** @}
1653 cejka 310
 */