WebSVN – HelenOS – Diff – /kernel/trunk/generic/src/proc/task.c


/*
 * Copyright (C) 2001-2004 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/**
 * @file    task.c
 * @brief   Task management.
 */
 
#include <main/uinit.h>
#include <proc/thread.h>
#include <proc/task.h>
#include <proc/uarg.h>
#include <mm/as.h>
#include <mm/slab.h>
#include <synch/spinlock.h>
#include <arch.h>
#include <panic.h>
#include <adt/btree.h>
#include <adt/list.h>
#include <ipc/ipc.h>
#include <security/cap.h>
#include <memstr.h>
#include <print.h>
#include <elf.h>
#include <errno.h>
#include <syscall/copy.h>
#include <console/klog.h>
 
#ifndef LOADED_PROG_STACK_PAGES_NO
#define LOADED_PROG_STACK_PAGES_NO 1
#endif
 
/** Spinlock protecting the tasks_btree B+tree. */
SPINLOCK_INITIALIZE(tasks_lock);
 
/** B+tree of active tasks.
 *
 * The task is guaranteed to exist after it was found in the tasks_btree as long as:
 * @li the tasks_lock is held,
 * @li the task's lock is held when task's lock is acquired before releasing tasks_lock or
 * @li the task's refcount is grater than 0
 *
 */
btree_t tasks_btree;
 
static task_id_t task_counter = 0;
 
static void ktaskclnp(void *arg);
static void ktaskgc(void *arg);
 
/** Initialize tasks
 *
 * Initialize kernel tasks support.
 *
 */
void task_init(void)
{
    TASK = NULL;
    btree_create(&tasks_btree);
}
 
 
/** Create new task
 *
 * Create new task with no threads.
 *
 * @param as Task's address space.
 * @param name Symbolic name.
 *
 * @return New task's structure
 *
 */
task_t *task_create(as_t *as, char *name)
{
    ipl_t ipl;
    task_t *ta;
    int i;
   
    ta = (task_t *) malloc(sizeof(task_t), 0);
 
    task_create_arch(ta);
 
    spinlock_initialize(&ta->lock, "task_ta_lock");
    list_initialize(&ta->th_head);
    ta->as = as;
    ta->name = name;
    ta->main_thread = NULL;
    ta->refcount = 0;
 
    ta->capabilities = 0;
    ta->accept_new_threads = true;
   
    ipc_answerbox_init(&ta->answerbox);
    for (i=0; i < IPC_MAX_PHONES;i++)
        ipc_phone_init(&ta->phones[i]);
    if (ipc_phone_0)
        ipc_phone_connect(&ta->phones[0], ipc_phone_0);
    atomic_set(&ta->active_calls, 0);
 
    mutex_initialize(&ta->futexes_lock);
    btree_create(&ta->futexes);
   
    ipl = interrupts_disable();
 
    /*
     * Increment address space reference count.
     * TODO: Reconsider the locking scheme.
     */
    mutex_lock(&as->lock);
    as->refcount++;
    mutex_unlock(&as->lock);
 
    spinlock_lock(&tasks_lock);
 
    ta->taskid = ++task_counter;
    btree_insert(&tasks_btree, (btree_key_t) ta->taskid, (void *) ta, NULL);
 
    spinlock_unlock(&tasks_lock);
    interrupts_restore(ipl);
 
    return ta;
}
 
/** Destroy task.
 *
 * @param t Task to be destroyed.
 */
void task_destroy(task_t *t)
{
    task_destroy_arch(t);
    btree_destroy(&t->futexes);
 
    mutex_lock_active(&t->as->lock);
    if (--t->as->refcount == 0) {
        mutex_unlock(&t->as->lock);
        as_destroy(t->as);
        /*
         * t->as is destroyed.
         */
    } else {
        mutex_unlock(&t->as->lock);
    }
   
    free(t);
    TASK = NULL;
}
 
/** Create new task with 1 thread and run it
 *
 * @param program_addr Address of program executable image.
 * @param name Program name.
 *
 * @return Task of the running program or NULL on error.
 */
task_t * task_run_program(void *program_addr, char *name)
{
    as_t *as;
    as_area_t *a;
    int rc;
    thread_t *t1, *t2;
    task_t *task;
    uspace_arg_t *kernel_uarg;
 
    as = as_create(0);
    ASSERT(as);
 
    rc = elf_load((elf_header_t *) program_addr, as);
    if (rc != EE_OK) {
        as_destroy(as);
        return NULL;
    }
   
    kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
    kernel_uarg->uspace_entry = (void *) ((elf_header_t *) program_addr)->e_entry;
    kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
    kernel_uarg->uspace_thread_function = NULL;
    kernel_uarg->uspace_thread_arg = NULL;
    kernel_uarg->uspace_uarg = NULL;
   
    task = task_create(as, name);
    ASSERT(task);
 
    /*
     * Create the data as_area.
     */
    a = as_area_create(as, AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
        LOADED_PROG_STACK_PAGES_NO*PAGE_SIZE,
        USTACK_ADDRESS, AS_AREA_ATTR_NONE, &anon_backend, NULL);
 
    /*
     * Create the main thread.
     */
    t1 = thread_create(uinit, kernel_uarg, task, 0, "uinit");
    ASSERT(t1);
   
    /*
     * Create killer thread for the new task.
     */
    t2 = thread_create(ktaskgc, t1, task, 0, "ktaskgc");
    ASSERT(t2);
    thread_ready(t2);
 
    thread_ready(t1);
 
    return task;
}
 
/** Syscall for reading task ID from userspace.
 *
 * @param uspace_task_id Userspace address of 8-byte buffer where to store current task ID.
 *
 * @return 0 on success or an error code from @ref errno.h.
 */
__native sys_task_get_id(task_id_t *uspace_task_id)
{
    /*
     * No need to acquire lock on TASK because taskid
     * remains constant for the lifespan of the task.
     */
    return (__native) copy_to_uspace(uspace_task_id, &TASK->taskid, sizeof(TASK->taskid));
}
 
/** Find task structure corresponding to task ID.
 *
 * The tasks_lock must be already held by the caller of this function
 * and interrupts must be disabled.
 *
 * @param id Task ID.
 *
 * @return Task structure address or NULL if there is no such task ID.
 */
task_t *task_find_by_id(task_id_t id)
{
    btree_node_t *leaf;
   
    return (task_t *) btree_search(&tasks_btree, (btree_key_t) id, &leaf);
}
 
/** Kill task.
 *
 * @param id ID of the task to be killed.
 *
 * @return 0 on success or an error code from errno.h
 */
int task_kill(task_id_t id)
{
    ipl_t ipl;
    task_t *ta;
    thread_t *t;
    link_t *cur;
 
    if (id == 1)
        return EPERM;
   
    ipl = interrupts_disable();
    spinlock_lock(&tasks_lock);
 
    if (!(ta = task_find_by_id(id))) {
        spinlock_unlock(&tasks_lock);
        interrupts_restore(ipl);
        return ENOENT;
    }
 
    spinlock_lock(&ta->lock);
    ta->refcount++;
    spinlock_unlock(&ta->lock);
 
    btree_remove(&tasks_btree, ta->taskid, NULL);
    spinlock_unlock(&tasks_lock);
   
    t = thread_create(ktaskclnp, NULL, ta, 0, "ktaskclnp");
   
    spinlock_lock(&ta->lock);
    ta->accept_new_threads = false;
    ta->refcount--;
 
    /*
     * Interrupt all threads except ktaskclnp.
     */
    for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {
        thread_t *thr;
        bool  sleeping = false;
       
        thr = list_get_instance(cur, thread_t, th_link);
        if (thr == t)
            continue;
           
        spinlock_lock(&thr->lock);
        thr->interrupted = true;
        if (thr->state == Sleeping)
            sleeping = true;
        spinlock_unlock(&thr->lock);
       
        if (sleeping)
            waitq_interrupt_sleep(thr);
    }
   
    spinlock_unlock(&ta->lock);
    interrupts_restore(ipl);
   
    if (t)
        thread_ready(t);
 
    return 0;
}
 
/** Print task list */
void task_print_list(void)
{
    link_t *cur;
    ipl_t ipl;
   
    /* Messing with thread structures, avoid deadlock */
    ipl = interrupts_disable();
    spinlock_lock(&tasks_lock);
 
    for (cur = tasks_btree.leaf_head.next; cur != &tasks_btree.leaf_head; cur = cur->next) {
        btree_node_t *node;
        int i;
       
        node = list_get_instance(cur, btree_node_t, leaf_link);
        for (i = 0; i < node->keys; i++) {
            task_t *t;
            int j;
 
            t = (task_t *) node->value[i];
       
            spinlock_lock(&t->lock);
            printf("%s(%lld): address=%#zX, as=%#zX, ActiveCalls: %zd",
                t->name, t->taskid, t, t->as, atomic_get(&t->active_calls));
            for (j=0; j < IPC_MAX_PHONES; j++) {
                if (t->phones[j].callee)
                    printf(" Ph(%zd): %#zX ", j, t->phones[j].callee);
            }
            printf("\n");
            spinlock_unlock(&t->lock);
        }
    }
 
    spinlock_unlock(&tasks_lock);
    interrupts_restore(ipl);
}
 
/** Kernel thread used to cleanup the task after it is killed. */
void ktaskclnp(void *arg)
{
    ipl_t ipl;
    thread_t *t = NULL, *main_thread;
    link_t *cur;
    bool again;
 
    thread_detach(THREAD);
 
loop:
    ipl = interrupts_disable();
    spinlock_lock(&TASK->lock);
   
    main_thread = TASK->main_thread;
   
    /*
     * Find a thread to join.
     */
    again = false;
    for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
        t = list_get_instance(cur, thread_t, th_link);
 
        spinlock_lock(&t->lock);
        if (t == THREAD) {
            spinlock_unlock(&t->lock);
            continue;
        } else if (t == main_thread) {
            spinlock_unlock(&t->lock);
            continue;
        } else if (t->join_type != None) {
            spinlock_unlock(&t->lock);
            again = true;
            continue;
        } else {
            t->join_type = TaskClnp;
            spinlock_unlock(&t->lock);
            again = false;
            break;
        }
    }
   
    spinlock_unlock(&TASK->lock);
    interrupts_restore(ipl);
   
    if (again) {
        /*
         * Other cleanup (e.g. ktaskgc) is in progress.
         */
        scheduler();
        goto loop;
    }
   
    if (t != THREAD) {
        ASSERT(t != main_thread);   /* uninit is joined and detached in ktaskgc */
        thread_join(t);
        thread_detach(t);
        goto loop;  /* go for another thread */
    }
   
    /*
     * Now there are no other threads in this task
     * and no new threads can be created.
     */
   
    ipc_cleanup();
    futex_cleanup();
    klog_printf("Cleanup of task %lld completed.", TASK->taskid);
}
 
/** Kernel thread used to kill the userspace task when its main thread exits.
 *
 * This thread waits until the main userspace thread (i.e. uninit) exits.
 * When this happens, the task is killed. In the meantime, exited threads
 * are garbage collected.
 *
 * @param arg Pointer to the thread structure of the task's main thread.
 */
void ktaskgc(void *arg)
{
    thread_t *t = (thread_t *) arg;
loop:  
    /*
     * Userspace threads cannot detach themselves,
     * therefore the thread pointer is guaranteed to be valid.
     */
    if (thread_join_timeout(t, 1000000, SYNCH_FLAGS_NONE) == ESYNCH_TIMEOUT) {  /* sleep uninterruptibly here! */
        ipl_t ipl;
        link_t *cur;
        thread_t *thr = NULL;
   
        /*
         * The join timed out. Try to do some garbage collection of Undead threads.
         */
more_gc:       
        ipl = interrupts_disable();
        spinlock_lock(&TASK->lock);
       
        for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
            thr = list_get_instance(cur, thread_t, th_link);
            spinlock_lock(&thr->lock);
            if (thr != t && thr->state == Undead && thr->join_type == None) {
                thr->join_type = TaskGC;
                spinlock_unlock(&thr->lock);
                break;
            }
            spinlock_unlock(&thr->lock);
            thr = NULL;
        }
        spinlock_unlock(&TASK->lock);
        interrupts_restore(ipl);
       
        if (thr) {
            thread_join(thr);
            thread_detach(thr);
            scheduler();
            goto more_gc;
        }
           
        goto loop;
    }
    thread_detach(t);
    task_kill(TASK->taskid);
}
 

Rev 1684	Rev 1687
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	/**	29	/**
30	* @file task.c	30	* @file task.c
31	* @brief Task management.	31	* @brief Task management.
32	*/	32	*/
33		33
34	#include <main/uinit.h>	34	#include <main/uinit.h>
35	#include <proc/thread.h>	35	#include <proc/thread.h>
36	#include <proc/task.h>	36	#include <proc/task.h>
37	#include <proc/uarg.h>	37	#include <proc/uarg.h>
38	#include <mm/as.h>	38	#include <mm/as.h>
39	#include <mm/slab.h>	39	#include <mm/slab.h>
40	#include <synch/spinlock.h>	40	#include <synch/spinlock.h>
41	#include <arch.h>	41	#include <arch.h>
42	#include <panic.h>	42	#include <panic.h>
43	#include <adt/btree.h>	43	#include <adt/btree.h>
44	#include <adt/list.h>	44	#include <adt/list.h>
45	#include <ipc/ipc.h>	45	#include <ipc/ipc.h>
46	#include <security/cap.h>	46	#include <security/cap.h>
47	#include <memstr.h>	47	#include <memstr.h>
48	#include <print.h>	48	#include <print.h>
49	#include <elf.h>	49	#include <elf.h>
50	#include <errno.h>	50	#include <errno.h>
51	#include <syscall/copy.h>	51	#include <syscall/copy.h>
52	#include <console/klog.h>	52	#include <console/klog.h>
53		53
54	#ifndef LOADED_PROG_STACK_PAGES_NO	54	#ifndef LOADED_PROG_STACK_PAGES_NO
55	#define LOADED_PROG_STACK_PAGES_NO 1	55	#define LOADED_PROG_STACK_PAGES_NO 1
56	#endif	56	#endif
57		57
58	/** Spinlock protecting the tasks_btree B+tree. */	58	/** Spinlock protecting the tasks_btree B+tree. */
59	SPINLOCK_INITIALIZE(tasks_lock);	59	SPINLOCK_INITIALIZE(tasks_lock);
60		60
61	/** B+tree of active tasks.	61	/** B+tree of active tasks.
62	*	62	*
63	* The task is guaranteed to exist after it was found in the tasks_btree as long as:	63	* The task is guaranteed to exist after it was found in the tasks_btree as long as:
64	* @li the tasks_lock is held,	64	* @li the tasks_lock is held,
65	* @li the task's lock is held when task's lock is acquired before releasing tasks_lock or	65	* @li the task's lock is held when task's lock is acquired before releasing tasks_lock or
66	* @li the task's refcount is grater than 0	66	* @li the task's refcount is grater than 0
67	*	67	*
68	*/	68	*/
69	btree_t tasks_btree;	69	btree_t tasks_btree;
70		70
71	static task_id_t task_counter = 0;	71	static task_id_t task_counter = 0;
72		72
73	static void ktaskclnp(void *arg);	73	static void ktaskclnp(void *arg);
74	static void ktaskgc(void *arg);	74	static void ktaskgc(void *arg);
75		75
76	/** Initialize tasks	76	/** Initialize tasks
77	*	77	*
78	* Initialize kernel tasks support.	78	* Initialize kernel tasks support.
79	*	79	*
80	*/	80	*/
81	void task_init(void)	81	void task_init(void)
82	{	82	{
83	TASK = NULL;	83	TASK = NULL;
84	btree_create(&tasks_btree);	84	btree_create(&tasks_btree);
85	}	85	}
86		86
87		87
88	/** Create new task	88	/** Create new task
89	*	89	*
90	* Create new task with no threads.	90	* Create new task with no threads.
91	*	91	*
92	* @param as Task's address space.	92	* @param as Task's address space.
93	* @param name Symbolic name.	93	* @param name Symbolic name.
94	*	94	*
95	* @return New task's structure	95	* @return New task's structure
96	*	96	*
97	*/	97	*/
98	task_t task_create(as_t as, char *name)	98	task_t task_create(as_t as, char *name)
99	{	99	{
100	ipl_t ipl;	100	ipl_t ipl;
101	task_t *ta;	101	task_t *ta;
102	int i;	102	int i;
103		103
104	ta = (task_t *) malloc(sizeof(task_t), 0);	104	ta = (task_t *) malloc(sizeof(task_t), 0);
105		105
106	task_create_arch(ta);	106	task_create_arch(ta);
107		107
108	spinlock_initialize(&ta->lock, "task_ta_lock");	108	spinlock_initialize(&ta->lock, "task_ta_lock");
109	list_initialize(&ta->th_head);	109	list_initialize(&ta->th_head);
110	ta->as = as;	110	ta->as = as;
111	ta->name = name;	111	ta->name = name;
112	ta->main_thread = NULL;	112	ta->main_thread = NULL;
113	ta->refcount = 0;	113	ta->refcount = 0;
114		114
115	ta->capabilities = 0;	115	ta->capabilities = 0;
116	ta->accept_new_threads = true;	116	ta->accept_new_threads = true;
117		117
118	ipc_answerbox_init(&ta->answerbox);	118	ipc_answerbox_init(&ta->answerbox);
119	for (i=0; i < IPC_MAX_PHONES;i++)	119	for (i=0; i < IPC_MAX_PHONES;i++)
120	ipc_phone_init(&ta->phones[i]);	120	ipc_phone_init(&ta->phones[i]);
121	if (ipc_phone_0)	121	if (ipc_phone_0)
122	ipc_phone_connect(&ta->phones[0], ipc_phone_0);	122	ipc_phone_connect(&ta->phones[0], ipc_phone_0);
123	atomic_set(&ta->active_calls, 0);	123	atomic_set(&ta->active_calls, 0);
124		124
125	mutex_initialize(&ta->futexes_lock);	125	mutex_initialize(&ta->futexes_lock);
126	btree_create(&ta->futexes);	126	btree_create(&ta->futexes);
127		127
128	ipl = interrupts_disable();	128	ipl = interrupts_disable();
129		129
130	/*	130	/*
131	* Increment address space reference count.	131	* Increment address space reference count.
132	* TODO: Reconsider the locking scheme.	132	* TODO: Reconsider the locking scheme.
133	*/	133	*/
134	mutex_lock(&as->lock);	134	mutex_lock(&as->lock);
135	as->refcount++;	135	as->refcount++;
136	mutex_unlock(&as->lock);	136	mutex_unlock(&as->lock);
137		137
138	spinlock_lock(&tasks_lock);	138	spinlock_lock(&tasks_lock);
139		139
140	ta->taskid = ++task_counter;	140	ta->taskid = ++task_counter;
141	btree_insert(&tasks_btree, (btree_key_t) ta->taskid, (void *) ta, NULL);	141	btree_insert(&tasks_btree, (btree_key_t) ta->taskid, (void *) ta, NULL);
142		142
143	spinlock_unlock(&tasks_lock);	143	spinlock_unlock(&tasks_lock);
144	interrupts_restore(ipl);	144	interrupts_restore(ipl);
145		145
146	return ta;	146	return ta;
147	}	147	}
148		148
149	/** Destroy task.	149	/** Destroy task.
150	*	150	*
151	* @param t Task to be destroyed.	151	* @param t Task to be destroyed.
152	*/	152	*/
153	void task_destroy(task_t *t)	153	void task_destroy(task_t *t)
154	{	154	{
155	task_destroy_arch(t);	155	task_destroy_arch(t);
156	btree_destroy(&t->futexes);	156	btree_destroy(&t->futexes);
157		157
158	mutex_lock_active(&t->as->lock);	158	mutex_lock_active(&t->as->lock);
159	if (--t->as->refcount == 0) {	159	if (--t->as->refcount == 0) {
160	mutex_unlock(&t->as->lock);	160	mutex_unlock(&t->as->lock);
161	as_destroy(t->as);	161	as_destroy(t->as);
162	/*	162	/*
163	* t->as is destroyed.	163	* t->as is destroyed.
164	*/	164	*/
165	} else {	165	} else {
166	mutex_unlock(&t->as->lock);	166	mutex_unlock(&t->as->lock);
167	}	167	}
168		168
169	free(t);	169	free(t);
170	TASK = NULL;	170	TASK = NULL;
171	}	171	}
172		172
173	/** Create new task with 1 thread and run it	173	/** Create new task with 1 thread and run it
174	*	174	*
175	* @param program_addr Address of program executable image.	175	* @param program_addr Address of program executable image.
176	* @param name Program name.	176	* @param name Program name.
177	*	177	*
178	* @return Task of the running program or NULL on error.	178	* @return Task of the running program or NULL on error.
179	*/	179	*/
180	task_t * task_run_program(void program_addr, char name)	180	task_t * task_run_program(void program_addr, char name)
181	{	181	{
182	as_t *as;	182	as_t *as;
183	as_area_t *a;	183	as_area_t *a;
184	int rc;	184	int rc;
185	thread_t t1, t2;	185	thread_t t1, t2;
186	task_t *task;	186	task_t *task;
187	uspace_arg_t *kernel_uarg;	187	uspace_arg_t *kernel_uarg;
188		188
189	as = as_create(0);	189	as = as_create(0);
190	ASSERT(as);	190	ASSERT(as);
191		191
192	rc = elf_load((elf_header_t *) program_addr, as);	192	rc = elf_load((elf_header_t *) program_addr, as);
193	if (rc != EE_OK) {	193	if (rc != EE_OK) {
194	as_destroy(as);	194	as_destroy(as);
195	return NULL;	195	return NULL;
196	}	196	}
197		197
198	kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);	198	kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
199	kernel_uarg->uspace_entry = (void ) ((elf_header_t ) program_addr)->e_entry;	199	kernel_uarg->uspace_entry = (void ) ((elf_header_t ) program_addr)->e_entry;
200	kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;	200	kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
201	kernel_uarg->uspace_thread_function = NULL;	201	kernel_uarg->uspace_thread_function = NULL;
202	kernel_uarg->uspace_thread_arg = NULL;	202	kernel_uarg->uspace_thread_arg = NULL;
203	kernel_uarg->uspace_uarg = NULL;	203	kernel_uarg->uspace_uarg = NULL;
204		204
205	task = task_create(as, name);	205	task = task_create(as, name);
206	ASSERT(task);	206	ASSERT(task);
207		207
208	/*	208	/*
209	* Create the data as_area.	209	* Create the data as_area.
210	*/	210	*/
211	a = as_area_create(as, AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE,	211	a = as_area_create(as, AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE,
212	LOADED_PROG_STACK_PAGES_NO*PAGE_SIZE,	212	LOADED_PROG_STACK_PAGES_NO*PAGE_SIZE,
213	USTACK_ADDRESS, AS_AREA_ATTR_NONE, &anon_backend, NULL);	213	USTACK_ADDRESS, AS_AREA_ATTR_NONE, &anon_backend, NULL);
214		214
215	/*	215	/*
216	* Create the main thread.	216	* Create the main thread.
217	*/	217	*/
218	t1 = thread_create(uinit, kernel_uarg, task, 0, "uinit");	218	t1 = thread_create(uinit, kernel_uarg, task, 0, "uinit");
219	ASSERT(t1);	219	ASSERT(t1);
220		220
221	/*	221	/*
222	* Create killer thread for the new task.	222	* Create killer thread for the new task.
223	*/	223	*/
224	t2 = thread_create(ktaskgc, t1, task, 0, "ktaskgc");	224	t2 = thread_create(ktaskgc, t1, task, 0, "ktaskgc");
225	ASSERT(t2);	225	ASSERT(t2);
226	thread_ready(t2);	226	thread_ready(t2);
227		227
228	thread_ready(t1);	228	thread_ready(t1);
229		229
230	return task;	230	return task;
231	}	231	}
232		232
233	/** Syscall for reading task ID from userspace.	233	/** Syscall for reading task ID from userspace.
234	*	234	*
235	* @param uspace_task_id Userspace address of 8-byte buffer where to store current task ID.	235	* @param uspace_task_id Userspace address of 8-byte buffer where to store current task ID.
236	*	236	*
237	* @return 0 on success or an error code from @ref errno.h.	237	* @return 0 on success or an error code from @ref errno.h.
238	*/	238	*/
239	__native sys_task_get_id(task_id_t *uspace_task_id)	239	__native sys_task_get_id(task_id_t *uspace_task_id)
240	{	240	{
241	/*	241	/*
242	* No need to acquire lock on TASK because taskid	242	* No need to acquire lock on TASK because taskid
243	* remains constant for the lifespan of the task.	243	* remains constant for the lifespan of the task.
244	*/	244	*/
245	return (__native) copy_to_uspace(uspace_task_id, &TASK->taskid, sizeof(TASK->taskid));	245	return (__native) copy_to_uspace(uspace_task_id, &TASK->taskid, sizeof(TASK->taskid));
246	}	246	}
247		247
248	/** Find task structure corresponding to task ID.	248	/** Find task structure corresponding to task ID.
249	*	249	*
250	* The tasks_lock must be already held by the caller of this function	250	* The tasks_lock must be already held by the caller of this function
251	* and interrupts must be disabled.	251	* and interrupts must be disabled.
252	*	252	*
253	* @param id Task ID.	253	* @param id Task ID.
254	*	254	*
255	* @return Task structure address or NULL if there is no such task ID.	255	* @return Task structure address or NULL if there is no such task ID.
256	*/	256	*/
257	task_t *task_find_by_id(task_id_t id)	257	task_t *task_find_by_id(task_id_t id)
258	{	258	{
259	btree_node_t *leaf;	259	btree_node_t *leaf;
260		260
261	return (task_t *) btree_search(&tasks_btree, (btree_key_t) id, &leaf);	261	return (task_t *) btree_search(&tasks_btree, (btree_key_t) id, &leaf);
262	}	262	}
263		263
264	/** Kill task.	264	/** Kill task.
265	*	265	*
266	* @param id ID of the task to be killed.	266	* @param id ID of the task to be killed.
267	*	267	*
268	* @return 0 on success or an error code from errno.h	268	* @return 0 on success or an error code from errno.h
269	*/	269	*/
270	int task_kill(task_id_t id)	270	int task_kill(task_id_t id)
271	{	271	{
272	ipl_t ipl;	272	ipl_t ipl;
273	task_t *ta;	273	task_t *ta;
274	thread_t *t;	274	thread_t *t;
275	link_t *cur;	275	link_t *cur;
276		276
277	if (id == 1)	277	if (id == 1)
278	return EPERM;	278	return EPERM;
279		279
280	ipl = interrupts_disable();	280	ipl = interrupts_disable();
281	spinlock_lock(&tasks_lock);	281	spinlock_lock(&tasks_lock);
282		282
283	if (!(ta = task_find_by_id(id))) {	283	if (!(ta = task_find_by_id(id))) {
284	spinlock_unlock(&tasks_lock);	284	spinlock_unlock(&tasks_lock);
285	interrupts_restore(ipl);	285	interrupts_restore(ipl);
286	return ENOENT;	286	return ENOENT;
287	}	287	}
288		288
289	spinlock_lock(&ta->lock);	289	spinlock_lock(&ta->lock);
290	ta->refcount++;	290	ta->refcount++;
291	spinlock_unlock(&ta->lock);	291	spinlock_unlock(&ta->lock);
292		292
293	btree_remove(&tasks_btree, ta->taskid, NULL);	293	btree_remove(&tasks_btree, ta->taskid, NULL);
294	spinlock_unlock(&tasks_lock);	294	spinlock_unlock(&tasks_lock);
295		295
296	t = thread_create(ktaskclnp, NULL, ta, 0, "ktaskclnp");	296	t = thread_create(ktaskclnp, NULL, ta, 0, "ktaskclnp");
297		297
298	spinlock_lock(&ta->lock);	298	spinlock_lock(&ta->lock);
299	ta->accept_new_threads = false;	299	ta->accept_new_threads = false;
300	ta->refcount--;	300	ta->refcount--;
301		301
302	/*	302	/*
303	* Interrupt all threads except this one.	303	* Interrupt all threads except ktaskclnp.
304	*/	304	*/
305	for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {	305	for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {
306	thread_t *thr;	306	thread_t *thr;
307	bool sleeping = false;	307	bool sleeping = false;
308		308
309	thr = list_get_instance(cur, thread_t, th_link);	309	thr = list_get_instance(cur, thread_t, th_link);
310	if (thr == t)	310	if (thr == t)
311	continue;	311	continue;
312		312
313	spinlock_lock(&thr->lock);	313	spinlock_lock(&thr->lock);
314	thr->interrupted = true;	314	thr->interrupted = true;
315	if (thr->state == Sleeping)	315	if (thr->state == Sleeping)
316	sleeping = true;	316	sleeping = true;
317	spinlock_unlock(&thr->lock);	317	spinlock_unlock(&thr->lock);
318		318
319	if (sleeping)	319	if (sleeping)
320	waitq_interrupt_sleep(thr);	320	waitq_interrupt_sleep(thr);
321	}	321	}
322		322
323	spinlock_unlock(&ta->lock);	323	spinlock_unlock(&ta->lock);
324	interrupts_restore(ipl);	324	interrupts_restore(ipl);
325		325
326	if (t)	326	if (t)
327	thread_ready(t);	327	thread_ready(t);
328		328
329	return 0;	329	return 0;
330	}	330	}
331		331
332	/** Print task list */	332	/** Print task list */
333	void task_print_list(void)	333	void task_print_list(void)
334	{	334	{
335	link_t *cur;	335	link_t *cur;
336	ipl_t ipl;	336	ipl_t ipl;
337		337
338	/* Messing with thread structures, avoid deadlock */	338	/* Messing with thread structures, avoid deadlock */
339	ipl = interrupts_disable();	339	ipl = interrupts_disable();
340	spinlock_lock(&tasks_lock);	340	spinlock_lock(&tasks_lock);
341		341
342	for (cur = tasks_btree.leaf_head.next; cur != &tasks_btree.leaf_head; cur = cur->next) {	342	for (cur = tasks_btree.leaf_head.next; cur != &tasks_btree.leaf_head; cur = cur->next) {
343	btree_node_t *node;	343	btree_node_t *node;
344	int i;	344	int i;
345		345
346	node = list_get_instance(cur, btree_node_t, leaf_link);	346	node = list_get_instance(cur, btree_node_t, leaf_link);
347	for (i = 0; i < node->keys; i++) {	347	for (i = 0; i < node->keys; i++) {
348	task_t *t;	348	task_t *t;
349	int j;	349	int j;
350		350
351	t = (task_t *) node->value[i];	351	t = (task_t *) node->value[i];
352		352
353	spinlock_lock(&t->lock);	353	spinlock_lock(&t->lock);
354	printf("%s(%lld): address=%#zX, as=%#zX, ActiveCalls: %zd",	354	printf("%s(%lld): address=%#zX, as=%#zX, ActiveCalls: %zd",
355	t->name, t->taskid, t, t->as, atomic_get(&t->active_calls));	355	t->name, t->taskid, t, t->as, atomic_get(&t->active_calls));
356	for (j=0; j < IPC_MAX_PHONES; j++) {	356	for (j=0; j < IPC_MAX_PHONES; j++) {
357	if (t->phones[j].callee)	357	if (t->phones[j].callee)
358	printf(" Ph(%zd): %#zX ", j, t->phones[j].callee);	358	printf(" Ph(%zd): %#zX ", j, t->phones[j].callee);
359	}	359	}
360	printf("\n");	360	printf("\n");
361	spinlock_unlock(&t->lock);	361	spinlock_unlock(&t->lock);
362	}	362	}
363	}	363	}
364		364
365	spinlock_unlock(&tasks_lock);	365	spinlock_unlock(&tasks_lock);
366	interrupts_restore(ipl);	366	interrupts_restore(ipl);
367	}	367	}
368		368
369	/** Kernel thread used to cleanup the task after it is killed. */	369	/** Kernel thread used to cleanup the task after it is killed. */
370	void ktaskclnp(void *arg)	370	void ktaskclnp(void *arg)
371	{	371	{
372	ipl_t ipl;	372	ipl_t ipl;
373	thread_t t = NULL, main_thread;	373	thread_t t = NULL, main_thread;
374	link_t *cur;	374	link_t *cur;
375	bool again;	375	bool again;
376		376
377	thread_detach(THREAD);	377	thread_detach(THREAD);
378		378
379	loop:	379	loop:
380	ipl = interrupts_disable();	380	ipl = interrupts_disable();
381	spinlock_lock(&TASK->lock);	381	spinlock_lock(&TASK->lock);
382		382
383	main_thread = TASK->main_thread;	383	main_thread = TASK->main_thread;
384		384
385	/*	385	/*
386	* Find a thread to join.	386	* Find a thread to join.
387	*/	387	*/
388	again = false;	388	again = false;
389	for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {	389	for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
390	t = list_get_instance(cur, thread_t, th_link);	390	t = list_get_instance(cur, thread_t, th_link);
391		391
392	spinlock_lock(&t->lock);	392	spinlock_lock(&t->lock);
393	if (t == THREAD) {	393	if (t == THREAD) {
394	spinlock_unlock(&t->lock);	394	spinlock_unlock(&t->lock);
395	continue;	395	continue;
396	} else if (t == main_thread) {	396	} else if (t == main_thread) {
397	spinlock_unlock(&t->lock);	397	spinlock_unlock(&t->lock);
398	continue;	398	continue;
399	} else if (t->join_type != None) {	399	} else if (t->join_type != None) {
400	spinlock_unlock(&t->lock);	400	spinlock_unlock(&t->lock);
401	again = true;	401	again = true;
402	continue;	402	continue;
403	} else {	403	} else {
404	t->join_type = TaskClnp;	404	t->join_type = TaskClnp;
405	spinlock_unlock(&t->lock);	405	spinlock_unlock(&t->lock);
406	again = false;	406	again = false;
407	break;	407	break;
408	}	408	}
409	}	409	}
410		410
411	spinlock_unlock(&TASK->lock);	411	spinlock_unlock(&TASK->lock);
412	interrupts_restore(ipl);	412	interrupts_restore(ipl);
413		413
414	if (again) {	414	if (again) {
415	/*	415	/*
416	* Other cleanup (e.g. ktaskgc) is in progress.	416	* Other cleanup (e.g. ktaskgc) is in progress.
417	*/	417	*/
418	scheduler();	418	scheduler();
419	goto loop;	419	goto loop;
420	}	420	}
421		421
422	if (t != THREAD) {	422	if (t != THREAD) {
423	ASSERT(t != main_thread); /* uninit is joined and detached in ktaskgc */	423	ASSERT(t != main_thread); /* uninit is joined and detached in ktaskgc */
424	thread_join(t);	424	thread_join(t);
425	thread_detach(t);	425	thread_detach(t);
426	goto loop; /* go for another thread */	426	goto loop; /* go for another thread */
427	}	427	}
428		428
429	/*	429	/*
430	* Now there are no other threads in this task	430	* Now there are no other threads in this task
431	* and no new threads can be created.	431	* and no new threads can be created.
432	*/	432	*/
433		433
434	ipc_cleanup();	434	ipc_cleanup();
435	futex_cleanup();	435	futex_cleanup();
436	klog_printf("Cleanup of task %lld completed.", TASK->taskid);	436	klog_printf("Cleanup of task %lld completed.", TASK->taskid);
437	}	437	}
438		438
439	/** Kernel thread used to kill the userspace task when its main thread exits.	439	/** Kernel thread used to kill the userspace task when its main thread exits.
440	*	440	*
441	* This thread waits until the main userspace thread (i.e. uninit) exits.	441	* This thread waits until the main userspace thread (i.e. uninit) exits.
442	* When this happens, the task is killed. In the meantime, exited threads	442	* When this happens, the task is killed. In the meantime, exited threads
443	* are garbage collected.	443	* are garbage collected.
444	*	444	*
445	* @param arg Pointer to the thread structure of the task's main thread.	445	* @param arg Pointer to the thread structure of the task's main thread.
446	*/	446	*/
447	void ktaskgc(void *arg)	447	void ktaskgc(void *arg)
448	{	448	{
449	thread_t t = (thread_t ) arg;	449	thread_t t = (thread_t ) arg;
450	loop:	450	loop:
451	/*	451	/*
452	* Userspace threads cannot detach themselves,	452	* Userspace threads cannot detach themselves,
453	* therefore the thread pointer is guaranteed to be valid.	453	* therefore the thread pointer is guaranteed to be valid.
454	*/	454	*/
455	if (thread_join_timeout(t, 1000000, SYNCH_FLAGS_NONE) == ESYNCH_TIMEOUT) { /* sleep uninterruptibly here! */	455	if (thread_join_timeout(t, 1000000, SYNCH_FLAGS_NONE) == ESYNCH_TIMEOUT) { /* sleep uninterruptibly here! */
456	ipl_t ipl;	456	ipl_t ipl;
457	link_t *cur;	457	link_t *cur;
458	thread_t *thr = NULL;	458	thread_t *thr = NULL;
459		459
460	/*	460	/*
461	* The join timed out. Try to do some garbage collection of Undead threads.	461	* The join timed out. Try to do some garbage collection of Undead threads.
462	*/	462	*/
463	more_gc:	463	more_gc:
464	ipl = interrupts_disable();	464	ipl = interrupts_disable();
465	spinlock_lock(&TASK->lock);	465	spinlock_lock(&TASK->lock);
466		466
467	for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {	467	for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
468	thr = list_get_instance(cur, thread_t, th_link);	468	thr = list_get_instance(cur, thread_t, th_link);
469	spinlock_lock(&thr->lock);	469	spinlock_lock(&thr->lock);
470	if (thr->state == Undead && thr->join_type == None) {	470	if (thr != t && thr->state == Undead && thr->join_type == None) {
471	thr->join_type = TaskGC;	471	thr->join_type = TaskGC;
472	spinlock_unlock(&thr->lock);	472	spinlock_unlock(&thr->lock);
473	break;	473	break;
474	}	474	}
475	spinlock_unlock(&thr->lock);	475	spinlock_unlock(&thr->lock);
476	thr = NULL;	476	thr = NULL;
477	}	477	}
478	spinlock_unlock(&TASK->lock);	478	spinlock_unlock(&TASK->lock);
479	interrupts_restore(ipl);	479	interrupts_restore(ipl);
480		480
481	if (thr) {	481	if (thr) {
482	thread_join(thr);	482	thread_join(thr);
483	thread_detach(thr);	483	thread_detach(thr);
484	scheduler();	484	scheduler();
485	goto more_gc;	485	goto more_gc;
486	}	486	}
487		487
488	goto loop;	488	goto loop;
489	}	489	}
490	thread_detach(t);	490	thread_detach(t);
491	task_kill(TASK->taskid);	491	task_kill(TASK->taskid);
492	}	492	}
493		493

Subversion Repositories HelenOS

(root)/kernel/trunk/generic/src/proc/task.c – Rev 1684 → 1687