Subversion Repositories HelenOS

Rev

Rev 3623 | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 3623 Rev 4377
1
/*
1
/*
2
 * Copyright (c) 2001-2004 Jakub Jermar
2
 * Copyright (c) 2001-2004 Jakub Jermar
3
 * All rights reserved.
3
 * All rights reserved.
4
 *
4
 *
5
 * Redistribution and use in source and binary forms, with or without
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
6
 * modification, are permitted provided that the following conditions
7
 * are met:
7
 * are met:
8
 *
8
 *
9
 * - Redistributions of source code must retain the above copyright
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
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
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.
15
 *   derived from this software without specific prior written permission.
16
 *
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
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
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
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
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
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
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.
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
27
 */
28
 
28
 
29
/** @addtogroup genericproc
29
/** @addtogroup genericproc
30
 * @{
30
 * @{
31
 */
31
 */
32
 
32
 
33
/**
33
/**
34
 * @file
34
 * @file
35
 * @brief   Thread management functions.
35
 * @brief   Thread management functions.
36
 */
36
 */
37
 
37
 
38
#include <proc/scheduler.h>
38
#include <proc/scheduler.h>
39
#include <proc/thread.h>
39
#include <proc/thread.h>
40
#include <proc/task.h>
40
#include <proc/task.h>
41
#include <proc/uarg.h>
41
#include <proc/uarg.h>
42
#include <mm/frame.h>
42
#include <mm/frame.h>
43
#include <mm/page.h>
43
#include <mm/page.h>
44
#include <arch/asm.h>
44
#include <arch/asm.h>
45
#include <arch/cycle.h>
45
#include <arch/cycle.h>
46
#include <arch.h>
46
#include <arch.h>
47
#include <synch/synch.h>
47
#include <synch/synch.h>
48
#include <synch/spinlock.h>
48
#include <synch/spinlock.h>
49
#include <synch/waitq.h>
49
#include <synch/waitq.h>
50
#include <synch/rwlock.h>
50
#include <synch/rwlock.h>
51
#include <cpu.h>
51
#include <cpu.h>
52
#include <func.h>
52
#include <func.h>
53
#include <context.h>
53
#include <context.h>
54
#include <adt/avl.h>
54
#include <adt/avl.h>
55
#include <adt/list.h>
55
#include <adt/list.h>
56
#include <time/clock.h>
56
#include <time/clock.h>
57
#include <time/timeout.h>
57
#include <time/timeout.h>
58
#include <config.h>
58
#include <config.h>
59
#include <arch/interrupt.h>
59
#include <arch/interrupt.h>
60
#include <smp/ipi.h>
60
#include <smp/ipi.h>
61
#include <arch/faddr.h>
61
#include <arch/faddr.h>
62
#include <atomic.h>
62
#include <atomic.h>
63
#include <memstr.h>
63
#include <memstr.h>
64
#include <print.h>
64
#include <print.h>
65
#include <mm/slab.h>
65
#include <mm/slab.h>
66
#include <debug.h>
66
#include <debug.h>
67
#include <main/uinit.h>
67
#include <main/uinit.h>
68
#include <syscall/copy.h>
68
#include <syscall/copy.h>
69
#include <errno.h>
69
#include <errno.h>
70
 
70
 
71
 
71
 
72
#ifndef LOADED_PROG_STACK_PAGES_NO
72
#ifndef LOADED_PROG_STACK_PAGES_NO
73
#define LOADED_PROG_STACK_PAGES_NO 1
73
#define LOADED_PROG_STACK_PAGES_NO 1
74
#endif
74
#endif
75
 
75
 
76
 
76
 
77
/** Thread states */
77
/** Thread states */
78
char *thread_states[] = {
78
char *thread_states[] = {
79
    "Invalid",
79
    "Invalid",
80
    "Running",
80
    "Running",
81
    "Sleeping",
81
    "Sleeping",
82
    "Ready",
82
    "Ready",
83
    "Entering",
83
    "Entering",
84
    "Exiting",
84
    "Exiting",
85
    "Lingering"
85
    "Lingering"
86
};
86
};
87
 
87
 
88
/** Lock protecting the threads_tree AVL tree.
88
/** Lock protecting the threads_tree AVL tree.
89
 *
89
 *
90
 * For locking rules, see declaration thereof.
90
 * For locking rules, see declaration thereof.
91
 */
91
 */
92
SPINLOCK_INITIALIZE(threads_lock);
92
SPINLOCK_INITIALIZE(threads_lock);
93
 
93
 
94
/** AVL tree of all threads.
94
/** AVL tree of all threads.
95
 *
95
 *
96
 * When a thread is found in the threads_tree AVL tree, it is guaranteed to
96
 * When a thread is found in the threads_tree AVL tree, it is guaranteed to
97
 * exist as long as the threads_lock is held.
97
 * exist as long as the threads_lock is held.
98
 */
98
 */
99
avltree_t threads_tree;    
99
avltree_t threads_tree;    
100
 
100
 
101
SPINLOCK_INITIALIZE(tidlock);
101
SPINLOCK_INITIALIZE(tidlock);
102
thread_id_t last_tid = 0;
102
thread_id_t last_tid = 0;
103
 
103
 
104
static slab_cache_t *thread_slab;
104
static slab_cache_t *thread_slab;
105
#ifdef ARCH_HAS_FPU
105
#ifdef CONFIG_FPU
106
slab_cache_t *fpu_context_slab;
106
slab_cache_t *fpu_context_slab;
107
#endif
107
#endif
108
 
108
 
109
/** Thread wrapper.
109
/** Thread wrapper.
110
 *
110
 *
111
 * This wrapper is provided to ensure that every thread makes a call to
111
 * This wrapper is provided to ensure that every thread makes a call to
112
 * thread_exit() when its implementing function returns.
112
 * thread_exit() when its implementing function returns.
113
 *
113
 *
114
 * interrupts_disable() is assumed.
114
 * interrupts_disable() is assumed.
115
 *
115
 *
116
 */
116
 */
117
static void cushion(void)
117
static void cushion(void)
118
{
118
{
119
    void (*f)(void *) = THREAD->thread_code;
119
    void (*f)(void *) = THREAD->thread_code;
120
    void *arg = THREAD->thread_arg;
120
    void *arg = THREAD->thread_arg;
121
    THREAD->last_cycle = get_cycle();
121
    THREAD->last_cycle = get_cycle();
122
 
122
 
123
    /* This is where each thread wakes up after its creation */
123
    /* This is where each thread wakes up after its creation */
124
    spinlock_unlock(&THREAD->lock);
124
    spinlock_unlock(&THREAD->lock);
125
    interrupts_enable();
125
    interrupts_enable();
126
 
126
 
127
    f(arg);
127
    f(arg);
128
   
128
   
129
    /* Accumulate accounting to the task */
129
    /* Accumulate accounting to the task */
130
    ipl_t ipl = interrupts_disable();
130
    ipl_t ipl = interrupts_disable();
131
   
131
   
132
    spinlock_lock(&THREAD->lock);
132
    spinlock_lock(&THREAD->lock);
133
    if (!THREAD->uncounted) {
133
    if (!THREAD->uncounted) {
134
        thread_update_accounting();
134
        thread_update_accounting();
135
        uint64_t cycles = THREAD->cycles;
135
        uint64_t cycles = THREAD->cycles;
136
        THREAD->cycles = 0;
136
        THREAD->cycles = 0;
137
        spinlock_unlock(&THREAD->lock);
137
        spinlock_unlock(&THREAD->lock);
138
       
138
       
139
        spinlock_lock(&TASK->lock);
139
        spinlock_lock(&TASK->lock);
140
        TASK->cycles += cycles;
140
        TASK->cycles += cycles;
141
        spinlock_unlock(&TASK->lock);
141
        spinlock_unlock(&TASK->lock);
142
    } else
142
    } else
143
        spinlock_unlock(&THREAD->lock);
143
        spinlock_unlock(&THREAD->lock);
144
   
144
   
145
    interrupts_restore(ipl);
145
    interrupts_restore(ipl);
146
   
146
   
147
    thread_exit();
147
    thread_exit();
148
    /* not reached */
148
    /* not reached */
149
}
149
}
150
 
150
 
151
/** Initialization and allocation for thread_t structure */
151
/** Initialization and allocation for thread_t structure */
152
static int thr_constructor(void *obj, int kmflags)
152
static int thr_constructor(void *obj, int kmflags)
153
{
153
{
154
    thread_t *t = (thread_t *) obj;
154
    thread_t *t = (thread_t *) obj;
155
 
155
 
156
    spinlock_initialize(&t->lock, "thread_t_lock");
156
    spinlock_initialize(&t->lock, "thread_t_lock");
157
    link_initialize(&t->rq_link);
157
    link_initialize(&t->rq_link);
158
    link_initialize(&t->wq_link);
158
    link_initialize(&t->wq_link);
159
    link_initialize(&t->th_link);
159
    link_initialize(&t->th_link);
160
 
160
 
161
    /* call the architecture-specific part of the constructor */
161
    /* call the architecture-specific part of the constructor */
162
    thr_constructor_arch(t);
162
    thr_constructor_arch(t);
163
   
163
   
164
#ifdef ARCH_HAS_FPU
164
#ifdef CONFIG_FPU
165
#ifdef CONFIG_FPU_LAZY
165
#ifdef CONFIG_FPU_LAZY
166
    t->saved_fpu_context = NULL;
166
    t->saved_fpu_context = NULL;
167
#else
167
#else
168
    t->saved_fpu_context = slab_alloc(fpu_context_slab, kmflags);
168
    t->saved_fpu_context = slab_alloc(fpu_context_slab, kmflags);
169
    if (!t->saved_fpu_context)
169
    if (!t->saved_fpu_context)
170
        return -1;
170
        return -1;
171
#endif
171
#endif
172
#endif  
172
#endif
173
 
173
 
174
    t->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags);
174
    t->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags);
175
    if (!t->kstack) {
175
    if (!t->kstack) {
176
#ifdef ARCH_HAS_FPU
176
#ifdef CONFIG_FPU
177
        if (t->saved_fpu_context)
177
        if (t->saved_fpu_context)
178
            slab_free(fpu_context_slab, t->saved_fpu_context);
178
            slab_free(fpu_context_slab, t->saved_fpu_context);
179
#endif
179
#endif
180
        return -1;
180
        return -1;
181
    }
181
    }
182
 
182
 
183
#ifdef CONFIG_UDEBUG
183
#ifdef CONFIG_UDEBUG
184
    mutex_initialize(&t->udebug.lock, MUTEX_PASSIVE);
184
    mutex_initialize(&t->udebug.lock, MUTEX_PASSIVE);
185
#endif
185
#endif
186
 
186
 
187
    return 0;
187
    return 0;
188
}
188
}
189
 
189
 
190
/** Destruction of thread_t object */
190
/** Destruction of thread_t object */
191
static int thr_destructor(void *obj)
191
static int thr_destructor(void *obj)
192
{
192
{
193
    thread_t *t = (thread_t *) obj;
193
    thread_t *t = (thread_t *) obj;
194
 
194
 
195
    /* call the architecture-specific part of the destructor */
195
    /* call the architecture-specific part of the destructor */
196
    thr_destructor_arch(t);
196
    thr_destructor_arch(t);
197
 
197
 
198
    frame_free(KA2PA(t->kstack));
198
    frame_free(KA2PA(t->kstack));
199
#ifdef ARCH_HAS_FPU
199
#ifdef CONFIG_FPU
200
    if (t->saved_fpu_context)
200
    if (t->saved_fpu_context)
201
        slab_free(fpu_context_slab, t->saved_fpu_context);
201
        slab_free(fpu_context_slab, t->saved_fpu_context);
202
#endif
202
#endif
203
    return 1; /* One page freed */
203
    return 1; /* One page freed */
204
}
204
}
205
 
205
 
206
/** Initialize threads
206
/** Initialize threads
207
 *
207
 *
208
 * Initialize kernel threads support.
208
 * Initialize kernel threads support.
209
 *
209
 *
210
 */
210
 */
211
void thread_init(void)
211
void thread_init(void)
212
{
212
{
213
    THREAD = NULL;
213
    THREAD = NULL;
214
    atomic_set(&nrdy,0);
214
    atomic_set(&nrdy, 0);
215
    thread_slab = slab_cache_create("thread_slab", sizeof(thread_t), 0,
215
    thread_slab = slab_cache_create("thread_slab", sizeof(thread_t), 0,
216
        thr_constructor, thr_destructor, 0);
216
        thr_constructor, thr_destructor, 0);
217
 
217
 
218
#ifdef ARCH_HAS_FPU
218
#ifdef CONFIG_FPU
219
    fpu_context_slab = slab_cache_create("fpu_slab", sizeof(fpu_context_t),
219
    fpu_context_slab = slab_cache_create("fpu_slab", sizeof(fpu_context_t),
220
        FPU_CONTEXT_ALIGN, NULL, NULL, 0);
220
        FPU_CONTEXT_ALIGN, NULL, NULL, 0);
221
#endif
221
#endif
222
 
222
 
223
    avltree_create(&threads_tree);
223
    avltree_create(&threads_tree);
224
}
224
}
225
 
225
 
226
/** Make thread ready
226
/** Make thread ready
227
 *
227
 *
228
 * Switch thread t to the ready state.
228
 * Switch thread t to the ready state.
229
 *
229
 *
230
 * @param t Thread to make ready.
230
 * @param t Thread to make ready.
231
 *
231
 *
232
 */
232
 */
233
void thread_ready(thread_t *t)
233
void thread_ready(thread_t *t)
234
{
234
{
235
    cpu_t *cpu;
235
    cpu_t *cpu;
236
    runq_t *r;
236
    runq_t *r;
237
    ipl_t ipl;
237
    ipl_t ipl;
238
    int i, avg;
238
    int i, avg;
239
 
239
 
240
    ipl = interrupts_disable();
240
    ipl = interrupts_disable();
241
 
241
 
242
    spinlock_lock(&t->lock);
242
    spinlock_lock(&t->lock);
243
 
243
 
244
    ASSERT(!(t->state == Ready));
244
    ASSERT(!(t->state == Ready));
245
 
245
 
246
    i = (t->priority < RQ_COUNT - 1) ? ++t->priority : t->priority;
246
    i = (t->priority < RQ_COUNT - 1) ? ++t->priority : t->priority;
247
   
247
   
248
    cpu = CPU;
248
    cpu = CPU;
249
    if (t->flags & THREAD_FLAG_WIRED) {
249
    if (t->flags & THREAD_FLAG_WIRED) {
250
        ASSERT(t->cpu != NULL);
250
        ASSERT(t->cpu != NULL);
251
        cpu = t->cpu;
251
        cpu = t->cpu;
252
    }
252
    }
253
    t->state = Ready;
253
    t->state = Ready;
254
    spinlock_unlock(&t->lock);
254
    spinlock_unlock(&t->lock);
255
   
255
   
256
    /*
256
    /*
257
     * Append t to respective ready queue on respective processor.
257
     * Append t to respective ready queue on respective processor.
258
     */
258
     */
259
    r = &cpu->rq[i];
259
    r = &cpu->rq[i];
260
    spinlock_lock(&r->lock);
260
    spinlock_lock(&r->lock);
261
    list_append(&t->rq_link, &r->rq_head);
261
    list_append(&t->rq_link, &r->rq_head);
262
    r->n++;
262
    r->n++;
263
    spinlock_unlock(&r->lock);
263
    spinlock_unlock(&r->lock);
264
 
264
 
265
    atomic_inc(&nrdy);
265
    atomic_inc(&nrdy);
266
    avg = atomic_get(&nrdy) / config.cpu_active;
266
    avg = atomic_get(&nrdy) / config.cpu_active;
267
    atomic_inc(&cpu->nrdy);
267
    atomic_inc(&cpu->nrdy);
268
 
268
 
269
    interrupts_restore(ipl);
269
    interrupts_restore(ipl);
270
}
270
}
271
 
271
 
272
/** Create new thread
272
/** Create new thread
273
 *
273
 *
274
 * Create a new thread.
274
 * Create a new thread.
275
 *
275
 *
276
 * @param func      Thread's implementing function.
276
 * @param func      Thread's implementing function.
277
 * @param arg       Thread's implementing function argument.
277
 * @param arg       Thread's implementing function argument.
278
 * @param task      Task to which the thread belongs. The caller must
278
 * @param task      Task to which the thread belongs. The caller must
279
 *          guarantee that the task won't cease to exist during the
279
 *          guarantee that the task won't cease to exist during the
280
 *          call. The task's lock may not be held.
280
 *          call. The task's lock may not be held.
281
 * @param flags     Thread flags.
281
 * @param flags     Thread flags.
282
 * @param name      Symbolic name (a copy is made).
282
 * @param name      Symbolic name (a copy is made).
283
 * @param uncounted Thread's accounting doesn't affect accumulated task
283
 * @param uncounted Thread's accounting doesn't affect accumulated task
284
 *          accounting.
284
 *          accounting.
285
 *
285
 *
286
 * @return      New thread's structure on success, NULL on failure.
286
 * @return      New thread's structure on success, NULL on failure.
287
 *
287
 *
288
 */
288
 */
289
thread_t *thread_create(void (* func)(void *), void *arg, task_t *task,
289
thread_t *thread_create(void (* func)(void *), void *arg, task_t *task,
290
    int flags, char *name, bool uncounted)
290
    int flags, char *name, bool uncounted)
291
{
291
{
292
    thread_t *t;
292
    thread_t *t;
293
    ipl_t ipl;
293
    ipl_t ipl;
294
   
294
   
295
    t = (thread_t *) slab_alloc(thread_slab, 0);
295
    t = (thread_t *) slab_alloc(thread_slab, 0);
296
    if (!t)
296
    if (!t)
297
        return NULL;
297
        return NULL;
298
   
298
   
299
    /* Not needed, but good for debugging */
299
    /* Not needed, but good for debugging */
300
    memsetb(t->kstack, THREAD_STACK_SIZE * 1 << STACK_FRAMES, 0);
300
    memsetb(t->kstack, THREAD_STACK_SIZE * 1 << STACK_FRAMES, 0);
301
   
301
   
302
    ipl = interrupts_disable();
302
    ipl = interrupts_disable();
303
    spinlock_lock(&tidlock);
303
    spinlock_lock(&tidlock);
304
    t->tid = ++last_tid;
304
    t->tid = ++last_tid;
305
    spinlock_unlock(&tidlock);
305
    spinlock_unlock(&tidlock);
306
    interrupts_restore(ipl);
306
    interrupts_restore(ipl);
307
   
307
   
308
    context_save(&t->saved_context);
308
    context_save(&t->saved_context);
309
    context_set(&t->saved_context, FADDR(cushion), (uintptr_t) t->kstack,
309
    context_set(&t->saved_context, FADDR(cushion), (uintptr_t) t->kstack,
310
        THREAD_STACK_SIZE);
310
        THREAD_STACK_SIZE);
311
   
311
   
312
    the_initialize((the_t *) t->kstack);
312
    the_initialize((the_t *) t->kstack);
313
   
313
   
314
    ipl = interrupts_disable();
314
    ipl = interrupts_disable();
315
    t->saved_context.ipl = interrupts_read();
315
    t->saved_context.ipl = interrupts_read();
316
    interrupts_restore(ipl);
316
    interrupts_restore(ipl);
317
   
317
   
318
    memcpy(t->name, name, THREAD_NAME_BUFLEN);
318
    memcpy(t->name, name, THREAD_NAME_BUFLEN);
319
    t->name[THREAD_NAME_BUFLEN - 1] = '\0';
319
    t->name[THREAD_NAME_BUFLEN - 1] = 0;
320
   
320
   
321
    t->thread_code = func;
321
    t->thread_code = func;
322
    t->thread_arg = arg;
322
    t->thread_arg = arg;
323
    t->ticks = -1;
323
    t->ticks = -1;
324
    t->cycles = 0;
324
    t->cycles = 0;
325
    t->uncounted = uncounted;
325
    t->uncounted = uncounted;
326
    t->priority = -1;       /* start in rq[0] */
326
    t->priority = -1;       /* start in rq[0] */
327
    t->cpu = NULL;
327
    t->cpu = NULL;
328
    t->flags = flags;
328
    t->flags = flags;
329
    t->state = Entering;
329
    t->state = Entering;
330
    t->call_me = NULL;
330
    t->call_me = NULL;
331
    t->call_me_with = NULL;
331
    t->call_me_with = NULL;
332
   
332
   
333
    timeout_initialize(&t->sleep_timeout);
333
    timeout_initialize(&t->sleep_timeout);
334
    t->sleep_interruptible = false;
334
    t->sleep_interruptible = false;
335
    t->sleep_queue = NULL;
335
    t->sleep_queue = NULL;
336
    t->timeout_pending = 0;
336
    t->timeout_pending = 0;
337
 
337
 
338
    t->in_copy_from_uspace = false;
338
    t->in_copy_from_uspace = false;
339
    t->in_copy_to_uspace = false;
339
    t->in_copy_to_uspace = false;
340
 
340
 
341
    t->interrupted = false;
341
    t->interrupted = false;
342
    t->detached = false;
342
    t->detached = false;
343
    waitq_initialize(&t->join_wq);
343
    waitq_initialize(&t->join_wq);
344
   
344
   
345
    t->rwlock_holder_type = RWLOCK_NONE;
345
    t->rwlock_holder_type = RWLOCK_NONE;
346
       
346
       
347
    t->task = task;
347
    t->task = task;
348
   
348
   
349
    t->fpu_context_exists = 0;
349
    t->fpu_context_exists = 0;
350
    t->fpu_context_engaged = 0;
350
    t->fpu_context_engaged = 0;
351
 
351
 
352
    avltree_node_initialize(&t->threads_tree_node);
352
    avltree_node_initialize(&t->threads_tree_node);
353
    t->threads_tree_node.key = (uintptr_t) t;
353
    t->threads_tree_node.key = (uintptr_t) t;
354
 
354
 
355
#ifdef CONFIG_UDEBUG
355
#ifdef CONFIG_UDEBUG
356
    /* Init debugging stuff */
356
    /* Init debugging stuff */
357
    udebug_thread_initialize(&t->udebug);
357
    udebug_thread_initialize(&t->udebug);
358
#endif
358
#endif
359
 
359
 
360
    /* might depend on previous initialization */
360
    /* might depend on previous initialization */
361
    thread_create_arch(t); 
361
    thread_create_arch(t); 
362
 
362
 
363
    if (!(flags & THREAD_FLAG_NOATTACH))
363
    if (!(flags & THREAD_FLAG_NOATTACH))
364
        thread_attach(t, task);
364
        thread_attach(t, task);
365
 
365
 
366
    return t;
366
    return t;
367
}
367
}
368
 
368
 
369
/** Destroy thread memory structure
369
/** Destroy thread memory structure
370
 *
370
 *
371
 * Detach thread from all queues, cpus etc. and destroy it.
371
 * Detach thread from all queues, cpus etc. and destroy it.
372
 *
372
 *
373
 * Assume thread->lock is held!!
373
 * Assume thread->lock is held!!
374
 */
374
 */
375
void thread_destroy(thread_t *t)
375
void thread_destroy(thread_t *t)
376
{
376
{
377
    ASSERT(t->state == Exiting || t->state == Lingering);
377
    ASSERT(t->state == Exiting || t->state == Lingering);
378
    ASSERT(t->task);
378
    ASSERT(t->task);
379
    ASSERT(t->cpu);
379
    ASSERT(t->cpu);
380
 
380
 
381
    spinlock_lock(&t->cpu->lock);
381
    spinlock_lock(&t->cpu->lock);
382
    if (t->cpu->fpu_owner == t)
382
    if (t->cpu->fpu_owner == t)
383
        t->cpu->fpu_owner = NULL;
383
        t->cpu->fpu_owner = NULL;
384
    spinlock_unlock(&t->cpu->lock);
384
    spinlock_unlock(&t->cpu->lock);
385
 
385
 
386
    spinlock_unlock(&t->lock);
386
    spinlock_unlock(&t->lock);
387
 
387
 
388
    spinlock_lock(&threads_lock);
388
    spinlock_lock(&threads_lock);
389
    avltree_delete(&threads_tree, &t->threads_tree_node);
389
    avltree_delete(&threads_tree, &t->threads_tree_node);
390
    spinlock_unlock(&threads_lock);
390
    spinlock_unlock(&threads_lock);
391
 
391
 
392
    /*
392
    /*
393
     * Detach from the containing task.
393
     * Detach from the containing task.
394
     */
394
     */
395
    spinlock_lock(&t->task->lock);
395
    spinlock_lock(&t->task->lock);
396
    list_remove(&t->th_link);
396
    list_remove(&t->th_link);
397
    spinlock_unlock(&t->task->lock);   
397
    spinlock_unlock(&t->task->lock);   
398
 
398
 
399
    /*
399
    /*
400
     * t is guaranteed to be the very last thread of its task.
400
     * t is guaranteed to be the very last thread of its task.
401
     * It is safe to destroy the task.
401
     * It is safe to destroy the task.
402
     */
402
     */
403
    if (atomic_predec(&t->task->refcount) == 0)
403
    if (atomic_predec(&t->task->refcount) == 0)
404
        task_destroy(t->task);
404
        task_destroy(t->task);
405
   
405
   
406
    slab_free(thread_slab, t);
406
    slab_free(thread_slab, t);
407
}
407
}
408
 
408
 
409
/** Make the thread visible to the system.
409
/** Make the thread visible to the system.
410
 *
410
 *
411
 * Attach the thread structure to the current task and make it visible in the
411
 * Attach the thread structure to the current task and make it visible in the
412
 * threads_tree.
412
 * threads_tree.
413
 *
413
 *
414
 * @param t Thread to be attached to the task.
414
 * @param t Thread to be attached to the task.
415
 * @param task  Task to which the thread is to be attached.
415
 * @param task  Task to which the thread is to be attached.
416
 */
416
 */
417
void thread_attach(thread_t *t, task_t *task)
417
void thread_attach(thread_t *t, task_t *task)
418
{
418
{
419
    ipl_t ipl;
419
    ipl_t ipl;
420
 
420
 
421
    /*
421
    /*
422
     * Attach to the specified task.
422
     * Attach to the specified task.
423
     */
423
     */
424
    ipl = interrupts_disable();
424
    ipl = interrupts_disable();
425
    spinlock_lock(&task->lock);
425
    spinlock_lock(&task->lock);
426
 
426
 
427
    atomic_inc(&task->refcount);
427
    atomic_inc(&task->refcount);
428
 
428
 
429
    /* Must not count kbox thread into lifecount */
429
    /* Must not count kbox thread into lifecount */
430
    if (t->flags & THREAD_FLAG_USPACE)
430
    if (t->flags & THREAD_FLAG_USPACE)
431
        atomic_inc(&task->lifecount);
431
        atomic_inc(&task->lifecount);
432
 
432
 
433
    list_append(&t->th_link, &task->th_head);
433
    list_append(&t->th_link, &task->th_head);
434
    spinlock_unlock(&task->lock);
434
    spinlock_unlock(&task->lock);
435
 
435
 
436
    /*
436
    /*
437
     * Register this thread in the system-wide list.
437
     * Register this thread in the system-wide list.
438
     */
438
     */
439
    spinlock_lock(&threads_lock);
439
    spinlock_lock(&threads_lock);
440
    avltree_insert(&threads_tree, &t->threads_tree_node);
440
    avltree_insert(&threads_tree, &t->threads_tree_node);
441
    spinlock_unlock(&threads_lock);
441
    spinlock_unlock(&threads_lock);
442
   
442
   
443
    interrupts_restore(ipl);
443
    interrupts_restore(ipl);
444
}
444
}
445
 
445
 
446
/** Terminate thread.
446
/** Terminate thread.
447
 *
447
 *
448
 * End current thread execution and switch it to the exiting state. All pending
448
 * End current thread execution and switch it to the exiting state. All pending
449
 * timeouts are executed.
449
 * timeouts are executed.
450
 */
450
 */
451
void thread_exit(void)
451
void thread_exit(void)
452
{
452
{
453
    ipl_t ipl;
453
    ipl_t ipl;
454
 
454
 
455
    if (THREAD->flags & THREAD_FLAG_USPACE) {
455
    if (THREAD->flags & THREAD_FLAG_USPACE) {
456
#ifdef CONFIG_UDEBUG
456
#ifdef CONFIG_UDEBUG
457
        /* Generate udebug THREAD_E event */
457
        /* Generate udebug THREAD_E event */
458
        udebug_thread_e_event();
458
        udebug_thread_e_event();
459
#endif
459
#endif
460
        if (atomic_predec(&TASK->lifecount) == 0) {
460
        if (atomic_predec(&TASK->lifecount) == 0) {
461
            /*
461
            /*
462
             * We are the last userspace thread in the task that
462
             * We are the last userspace thread in the task that
463
             * still has not exited. With the exception of the
463
             * still has not exited. With the exception of the
464
             * moment the task was created, new userspace threads
464
             * moment the task was created, new userspace threads
465
             * can only be created by threads of the same task.
465
             * can only be created by threads of the same task.
466
             * We are safe to perform cleanup.
466
             * We are safe to perform cleanup.
467
             */
467
             */
468
            ipc_cleanup();
468
            ipc_cleanup();
469
            futex_cleanup();
469
            futex_cleanup();
470
            LOG("Cleanup of task %" PRIu64" completed.", TASK->taskid);
470
            LOG("Cleanup of task %" PRIu64" completed.", TASK->taskid);
471
        }
471
        }
472
    }
472
    }
473
 
473
 
474
restart:
474
restart:
475
    ipl = interrupts_disable();
475
    ipl = interrupts_disable();
476
    spinlock_lock(&THREAD->lock);
476
    spinlock_lock(&THREAD->lock);
477
    if (THREAD->timeout_pending) {
477
    if (THREAD->timeout_pending) {
478
        /* busy waiting for timeouts in progress */
478
        /* busy waiting for timeouts in progress */
479
        spinlock_unlock(&THREAD->lock);
479
        spinlock_unlock(&THREAD->lock);
480
        interrupts_restore(ipl);
480
        interrupts_restore(ipl);
481
        goto restart;
481
        goto restart;
482
    }
482
    }
483
   
483
   
484
    THREAD->state = Exiting;
484
    THREAD->state = Exiting;
485
    spinlock_unlock(&THREAD->lock);
485
    spinlock_unlock(&THREAD->lock);
486
    scheduler();
486
    scheduler();
487
 
487
 
488
    /* Not reached */
488
    /* Not reached */
489
    while (1)
489
    while (1)
490
        ;
490
        ;
491
}
491
}
492
 
492
 
493
 
493
 
494
/** Thread sleep
494
/** Thread sleep
495
 *
495
 *
496
 * Suspend execution of the current thread.
496
 * Suspend execution of the current thread.
497
 *
497
 *
498
 * @param sec Number of seconds to sleep.
498
 * @param sec Number of seconds to sleep.
499
 *
499
 *
500
 */
500
 */
501
void thread_sleep(uint32_t sec)
501
void thread_sleep(uint32_t sec)
502
{
502
{
503
    thread_usleep(sec * 1000000);
503
    thread_usleep(sec * 1000000);
504
}
504
}
505
 
505
 
506
/** Wait for another thread to exit.
506
/** Wait for another thread to exit.
507
 *
507
 *
508
 * @param t Thread to join on exit.
508
 * @param t Thread to join on exit.
509
 * @param usec Timeout in microseconds.
509
 * @param usec Timeout in microseconds.
510
 * @param flags Mode of operation.
510
 * @param flags Mode of operation.
511
 *
511
 *
512
 * @return An error code from errno.h or an error code from synch.h.
512
 * @return An error code from errno.h or an error code from synch.h.
513
 */
513
 */
514
int thread_join_timeout(thread_t *t, uint32_t usec, int flags)
514
int thread_join_timeout(thread_t *t, uint32_t usec, int flags)
515
{
515
{
516
    ipl_t ipl;
516
    ipl_t ipl;
517
    int rc;
517
    int rc;
518
 
518
 
519
    if (t == THREAD)
519
    if (t == THREAD)
520
        return EINVAL;
520
        return EINVAL;
521
 
521
 
522
    /*
522
    /*
523
     * Since thread join can only be called once on an undetached thread,
523
     * Since thread join can only be called once on an undetached thread,
524
     * the thread pointer is guaranteed to be still valid.
524
     * the thread pointer is guaranteed to be still valid.
525
     */
525
     */
526
   
526
   
527
    ipl = interrupts_disable();
527
    ipl = interrupts_disable();
528
    spinlock_lock(&t->lock);
528
    spinlock_lock(&t->lock);
529
    ASSERT(!t->detached);
529
    ASSERT(!t->detached);
530
    spinlock_unlock(&t->lock);
530
    spinlock_unlock(&t->lock);
531
    interrupts_restore(ipl);
531
    interrupts_restore(ipl);
532
   
532
   
533
    rc = waitq_sleep_timeout(&t->join_wq, usec, flags);
533
    rc = waitq_sleep_timeout(&t->join_wq, usec, flags);
534
   
534
   
535
    return rc; 
535
    return rc; 
536
}
536
}
537
 
537
 
538
/** Detach thread.
538
/** Detach thread.
539
 *
539
 *
540
 * Mark the thread as detached, if the thread is already in the Lingering
540
 * Mark the thread as detached, if the thread is already in the Lingering
541
 * state, deallocate its resources.
541
 * state, deallocate its resources.
542
 *
542
 *
543
 * @param t Thread to be detached.
543
 * @param t Thread to be detached.
544
 */
544
 */
545
void thread_detach(thread_t *t)
545
void thread_detach(thread_t *t)
546
{
546
{
547
    ipl_t ipl;
547
    ipl_t ipl;
548
 
548
 
549
    /*
549
    /*
550
     * Since the thread is expected not to be already detached,
550
     * Since the thread is expected not to be already detached,
551
     * pointer to it must be still valid.
551
     * pointer to it must be still valid.
552
     */
552
     */
553
    ipl = interrupts_disable();
553
    ipl = interrupts_disable();
554
    spinlock_lock(&t->lock);
554
    spinlock_lock(&t->lock);
555
    ASSERT(!t->detached);
555
    ASSERT(!t->detached);
556
    if (t->state == Lingering) {
556
    if (t->state == Lingering) {
557
        thread_destroy(t);  /* unlocks &t->lock */
557
        thread_destroy(t);  /* unlocks &t->lock */
558
        interrupts_restore(ipl);
558
        interrupts_restore(ipl);
559
        return;
559
        return;
560
    } else {
560
    } else {
561
        t->detached = true;
561
        t->detached = true;
562
    }
562
    }
563
    spinlock_unlock(&t->lock);
563
    spinlock_unlock(&t->lock);
564
    interrupts_restore(ipl);
564
    interrupts_restore(ipl);
565
}
565
}
566
 
566
 
567
/** Thread usleep
567
/** Thread usleep
568
 *
568
 *
569
 * Suspend execution of the current thread.
569
 * Suspend execution of the current thread.
570
 *
570
 *
571
 * @param usec Number of microseconds to sleep.
571
 * @param usec Number of microseconds to sleep.
572
 *
572
 *
573
 */
573
 */
574
void thread_usleep(uint32_t usec)
574
void thread_usleep(uint32_t usec)
575
{
575
{
576
    waitq_t wq;
576
    waitq_t wq;
577
                 
577
                 
578
    waitq_initialize(&wq);
578
    waitq_initialize(&wq);
579
 
579
 
580
    (void) waitq_sleep_timeout(&wq, usec, SYNCH_FLAGS_NON_BLOCKING);
580
    (void) waitq_sleep_timeout(&wq, usec, SYNCH_FLAGS_NON_BLOCKING);
581
}
581
}
582
 
582
 
583
/** Register thread out-of-context invocation
583
/** Register thread out-of-context invocation
584
 *
584
 *
585
 * Register a function and its argument to be executed
585
 * Register a function and its argument to be executed
586
 * on next context switch to the current thread.
586
 * on next context switch to the current thread.
587
 *
587
 *
588
 * @param call_me      Out-of-context function.
588
 * @param call_me      Out-of-context function.
589
 * @param call_me_with Out-of-context function argument.
589
 * @param call_me_with Out-of-context function argument.
590
 *
590
 *
591
 */
591
 */
592
void thread_register_call_me(void (* call_me)(void *), void *call_me_with)
592
void thread_register_call_me(void (* call_me)(void *), void *call_me_with)
593
{
593
{
594
    ipl_t ipl;
594
    ipl_t ipl;
595
   
595
   
596
    ipl = interrupts_disable();
596
    ipl = interrupts_disable();
597
    spinlock_lock(&THREAD->lock);
597
    spinlock_lock(&THREAD->lock);
598
    THREAD->call_me = call_me;
598
    THREAD->call_me = call_me;
599
    THREAD->call_me_with = call_me_with;
599
    THREAD->call_me_with = call_me_with;
600
    spinlock_unlock(&THREAD->lock);
600
    spinlock_unlock(&THREAD->lock);
601
    interrupts_restore(ipl);
601
    interrupts_restore(ipl);
602
}
602
}
603
 
603
 
604
static bool thread_walker(avltree_node_t *node, void *arg)
604
static bool thread_walker(avltree_node_t *node, void *arg)
605
{
605
{
606
    thread_t *t = avltree_get_instance(node, thread_t, threads_tree_node);
606
    thread_t *t = avltree_get_instance(node, thread_t, threads_tree_node);
607
   
607
   
608
    uint64_t cycles;
608
    uint64_t cycles;
609
    char suffix;
609
    char suffix;
610
    order(t->cycles, &cycles, &suffix);
610
    order(t->cycles, &cycles, &suffix);
611
 
611
 
612
#ifdef __32_BITS__
612
#ifdef __32_BITS__
613
    printf("%-6" PRIu64" %-10s %10p %-8s %10p %-3" PRIu32 " %10p %10p %9" PRIu64 "%c ",
613
    printf("%-6" PRIu64" %-10s %10p %-8s %10p %-3" PRIu32 " %10p %10p %9" PRIu64 "%c ",
614
        t->tid, t->name, t, thread_states[t->state], t->task,
614
        t->tid, t->name, t, thread_states[t->state], t->task,
615
        t->task->context, t->thread_code, t->kstack, cycles, suffix);
615
        t->task->context, t->thread_code, t->kstack, cycles, suffix);
616
#endif
616
#endif
617
 
617
 
618
#ifdef __64_BITS__
618
#ifdef __64_BITS__
619
    printf("%-6" PRIu64" %-10s %18p %-8s %18p %-3" PRIu32 " %18p %18p %9" PRIu64 "%c ",
619
    printf("%-6" PRIu64" %-10s %18p %-8s %18p %-3" PRIu32 " %18p %18p %9" PRIu64 "%c ",
620
        t->tid, t->name, t, thread_states[t->state], t->task,
620
        t->tid, t->name, t, thread_states[t->state], t->task,
621
        t->task->context, t->thread_code, t->kstack, cycles, suffix);
621
        t->task->context, t->thread_code, t->kstack, cycles, suffix);
622
#endif
622
#endif
623
           
623
           
624
    if (t->cpu)
624
    if (t->cpu)
625
        printf("%-4u", t->cpu->id);
625
        printf("%-4u", t->cpu->id);
626
    else
626
    else
627
        printf("none");
627
        printf("none");
628
           
628
           
629
    if (t->state == Sleeping) {
629
    if (t->state == Sleeping) {
630
#ifdef __32_BITS__
630
#ifdef __32_BITS__
631
        printf(" %10p", t->sleep_queue);
631
        printf(" %10p", t->sleep_queue);
632
#endif
632
#endif
633
 
633
 
634
#ifdef __64_BITS__
634
#ifdef __64_BITS__
635
        printf(" %18p", t->sleep_queue);
635
        printf(" %18p", t->sleep_queue);
636
#endif
636
#endif
637
    }
637
    }
638
           
638
           
639
    printf("\n");
639
    printf("\n");
640
 
640
 
641
    return true;
641
    return true;
642
}
642
}
643
 
643
 
644
/** Print list of threads debug info */
644
/** Print list of threads debug info */
645
void thread_print_list(void)
645
void thread_print_list(void)
646
{
646
{
647
    ipl_t ipl;
647
    ipl_t ipl;
648
   
648
   
649
    /* Messing with thread structures, avoid deadlock */
649
    /* Messing with thread structures, avoid deadlock */
650
    ipl = interrupts_disable();
650
    ipl = interrupts_disable();
651
    spinlock_lock(&threads_lock);
651
    spinlock_lock(&threads_lock);
652
 
652
 
653
#ifdef __32_BITS__  
653
#ifdef __32_BITS__  
654
    printf("tid    name       address    state    task       "
654
    printf("tid    name       address    state    task       "
655
        "ctx code       stack      cycles     cpu  "
655
        "ctx code       stack      cycles     cpu  "
656
        "waitqueue\n");
656
        "waitqueue\n");
657
    printf("------ ---------- ---------- -------- ---------- "
657
    printf("------ ---------- ---------- -------- ---------- "
658
        "--- ---------- ---------- ---------- ---- "
658
        "--- ---------- ---------- ---------- ---- "
659
        "----------\n");
659
        "----------\n");
660
#endif
660
#endif
661
 
661
 
662
#ifdef __64_BITS__
662
#ifdef __64_BITS__
663
    printf("tid    name       address            state    task               "
663
    printf("tid    name       address            state    task               "
664
        "ctx code               stack              cycles     cpu  "
664
        "ctx code               stack              cycles     cpu  "
665
        "waitqueue\n");
665
        "waitqueue\n");
666
    printf("------ ---------- ------------------ -------- ------------------ "
666
    printf("------ ---------- ------------------ -------- ------------------ "
667
        "--- ------------------ ------------------ ---------- ---- "
667
        "--- ------------------ ------------------ ---------- ---- "
668
        "------------------\n");
668
        "------------------\n");
669
#endif
669
#endif
670
 
670
 
671
    avltree_walk(&threads_tree, thread_walker, NULL);
671
    avltree_walk(&threads_tree, thread_walker, NULL);
672
 
672
 
673
    spinlock_unlock(&threads_lock);
673
    spinlock_unlock(&threads_lock);
674
    interrupts_restore(ipl);
674
    interrupts_restore(ipl);
675
}
675
}
676
 
676
 
677
/** Check whether thread exists.
677
/** Check whether thread exists.
678
 *
678
 *
679
 * Note that threads_lock must be already held and
679
 * Note that threads_lock must be already held and
680
 * interrupts must be already disabled.
680
 * interrupts must be already disabled.
681
 *
681
 *
682
 * @param t Pointer to thread.
682
 * @param t Pointer to thread.
683
 *
683
 *
684
 * @return True if thread t is known to the system, false otherwise.
684
 * @return True if thread t is known to the system, false otherwise.
685
 */
685
 */
686
bool thread_exists(thread_t *t)
686
bool thread_exists(thread_t *t)
687
{
687
{
688
    avltree_node_t *node;
688
    avltree_node_t *node;
689
 
689
 
690
    node = avltree_search(&threads_tree, (avltree_key_t) ((uintptr_t) t));
690
    node = avltree_search(&threads_tree, (avltree_key_t) ((uintptr_t) t));
691
   
691
   
692
    return node != NULL;
692
    return node != NULL;
693
}
693
}
694
 
694
 
695
/** Update accounting of current thread.
695
/** Update accounting of current thread.
696
 *
696
 *
697
 * Note that thread_lock on THREAD must be already held and
697
 * Note that thread_lock on THREAD must be already held and
698
 * interrupts must be already disabled.
698
 * interrupts must be already disabled.
699
 *
699
 *
700
 */
700
 */
701
void thread_update_accounting(void)
701
void thread_update_accounting(void)
702
{
702
{
703
    uint64_t time = get_cycle();
703
    uint64_t time = get_cycle();
704
    THREAD->cycles += time - THREAD->last_cycle;
704
    THREAD->cycles += time - THREAD->last_cycle;
705
    THREAD->last_cycle = time;
705
    THREAD->last_cycle = time;
706
}
706
}
707
 
707
 
708
/** Process syscall to create new thread.
708
/** Process syscall to create new thread.
709
 *
709
 *
710
 */
710
 */
711
unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
711
unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
712
    size_t name_len, thread_id_t *uspace_thread_id)
712
    size_t name_len, thread_id_t *uspace_thread_id)
713
{
713
{
714
    thread_t *t;
714
    thread_t *t;
715
    char namebuf[THREAD_NAME_BUFLEN];
715
    char namebuf[THREAD_NAME_BUFLEN];
716
    uspace_arg_t *kernel_uarg;
716
    uspace_arg_t *kernel_uarg;
717
    int rc;
717
    int rc;
718
 
718
 
719
    if (name_len > THREAD_NAME_BUFLEN - 1)
719
    if (name_len > THREAD_NAME_BUFLEN - 1)
720
        name_len = THREAD_NAME_BUFLEN - 1;
720
        name_len = THREAD_NAME_BUFLEN - 1;
721
 
721
 
722
    rc = copy_from_uspace(namebuf, uspace_name, name_len);
722
    rc = copy_from_uspace(namebuf, uspace_name, name_len);
723
    if (rc != 0)
723
    if (rc != 0)
724
        return (unative_t) rc;
724
        return (unative_t) rc;
725
 
725
 
726
    namebuf[name_len] = '\0';
726
    namebuf[name_len] = 0;
727
 
727
 
728
    /*
728
    /*
729
     * In case of failure, kernel_uarg will be deallocated in this function.
729
     * In case of failure, kernel_uarg will be deallocated in this function.
730
     * In case of success, kernel_uarg will be freed in uinit().
730
     * In case of success, kernel_uarg will be freed in uinit().
731
     */
731
     */
732
    kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
732
    kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
733
   
733
   
734
    rc = copy_from_uspace(kernel_uarg, uspace_uarg, sizeof(uspace_arg_t));
734
    rc = copy_from_uspace(kernel_uarg, uspace_uarg, sizeof(uspace_arg_t));
735
    if (rc != 0) {
735
    if (rc != 0) {
736
        free(kernel_uarg);
736
        free(kernel_uarg);
737
        return (unative_t) rc;
737
        return (unative_t) rc;
738
    }
738
    }
739
 
739
 
740
    t = thread_create(uinit, kernel_uarg, TASK,
740
    t = thread_create(uinit, kernel_uarg, TASK,
741
        THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf, false);
741
        THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf, false);
742
    if (t) {
742
    if (t) {
743
        if (uspace_thread_id != NULL) {
743
        if (uspace_thread_id != NULL) {
744
            int rc;
744
            int rc;
745
 
745
 
746
            rc = copy_to_uspace(uspace_thread_id, &t->tid,
746
            rc = copy_to_uspace(uspace_thread_id, &t->tid,
747
                sizeof(t->tid));
747
                sizeof(t->tid));
748
            if (rc != 0) {
748
            if (rc != 0) {
749
                /*
749
                /*
750
                 * We have encountered a failure, but the thread
750
                 * We have encountered a failure, but the thread
751
                 * has already been created. We need to undo its
751
                 * has already been created. We need to undo its
752
                 * creation now.
752
                 * creation now.
753
                 */
753
                 */
754
 
754
 
755
                /*
755
                /*
756
                 * The new thread structure is initialized, but
756
                 * The new thread structure is initialized, but
757
                 * is still not visible to the system.
757
                 * is still not visible to the system.
758
                 * We can safely deallocate it.
758
                 * We can safely deallocate it.
759
                 */
759
                 */
760
                slab_free(thread_slab, t);
760
                slab_free(thread_slab, t);
761
                free(kernel_uarg);
761
                free(kernel_uarg);
762
 
762
 
763
                return (unative_t) rc;
763
                return (unative_t) rc;
764
             }
764
             }
765
        }
765
        }
766
#ifdef CONFIG_UDEBUG
766
#ifdef CONFIG_UDEBUG
767
        /*
767
        /*
768
         * Generate udebug THREAD_B event and attach the thread.
768
         * Generate udebug THREAD_B event and attach the thread.
769
         * This must be done atomically (with the debug locks held),
769
         * This must be done atomically (with the debug locks held),
770
         * otherwise we would either miss some thread or receive
770
         * otherwise we would either miss some thread or receive
771
         * THREAD_B events for threads that already existed
771
         * THREAD_B events for threads that already existed
772
         * and could be detected with THREAD_READ before.
772
         * and could be detected with THREAD_READ before.
773
         */
773
         */
774
        udebug_thread_b_event_attach(t, TASK);
774
        udebug_thread_b_event_attach(t, TASK);
775
#else
775
#else
776
        thread_attach(t, TASK);
776
        thread_attach(t, TASK);
777
#endif
777
#endif
778
        thread_ready(t);
778
        thread_ready(t);
779
 
779
 
780
        return 0;
780
        return 0;
781
    } else
781
    } else
782
        free(kernel_uarg);
782
        free(kernel_uarg);
783
 
783
 
784
    return (unative_t) ENOMEM;
784
    return (unative_t) ENOMEM;
785
}
785
}
786
 
786
 
787
/** Process syscall to terminate thread.
787
/** Process syscall to terminate thread.
788
 *
788
 *
789
 */
789
 */
790
unative_t sys_thread_exit(int uspace_status)
790
unative_t sys_thread_exit(int uspace_status)
791
{
791
{
792
    thread_exit();
792
    thread_exit();
793
    /* Unreachable */
793
    /* Unreachable */
794
    return 0;
794
    return 0;
795
}
795
}
796
 
796
 
797
/** Syscall for getting TID.
797
/** Syscall for getting TID.
798
 *
798
 *
799
 * @param uspace_thread_id Userspace address of 8-byte buffer where to store
799
 * @param uspace_thread_id Userspace address of 8-byte buffer where to store
800
 * current thread ID.
800
 * current thread ID.
801
 *
801
 *
802
 * @return 0 on success or an error code from @ref errno.h.
802
 * @return 0 on success or an error code from @ref errno.h.
803
 */
803
 */
804
unative_t sys_thread_get_id(thread_id_t *uspace_thread_id)
804
unative_t sys_thread_get_id(thread_id_t *uspace_thread_id)
805
{
805
{
806
    /*
806
    /*
807
     * No need to acquire lock on THREAD because tid
807
     * No need to acquire lock on THREAD because tid
808
     * remains constant for the lifespan of the thread.
808
     * remains constant for the lifespan of the thread.
809
     */
809
     */
810
    return (unative_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,
810
    return (unative_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,
811
        sizeof(THREAD->tid));
811
        sizeof(THREAD->tid));
812
}
812
}
813
 
813
 
814
/** @}
814
/** @}
815
 */
815
 */
816
 
816