WebSVN – HelenOS – Diff – /tags/0.2.0.5/kernel/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.
 */
 
/** @addtogroup genericproc
 * @{
 */
 
/**
 * @file
 * @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 <atomic.h>
#include <synch/spinlock.h>
#include <synch/waitq.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 <lib/elf.h>
#include <errno.h>
#include <func.h>
#include <syscall/copy.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 greater than 0
 *
 */
btree_t tasks_btree;
 
static task_id_t task_counter = 0;
 
/** Initialize tasks
 *
 * Initialize kernel tasks support.
 *
 */
void task_init(void)
{
    TASK = NULL;
    btree_create(&tasks_btree);
}
 
/** Kill all tasks except the current task.
 *
 */
void task_done(void)
{
    task_t *t;
    do { /* Repeat until there are any tasks except TASK */
       
        /* Messing with task structures, avoid deadlock */
        ipl_t ipl = interrupts_disable();
        spinlock_lock(&tasks_lock);
       
        t = NULL;
        link_t *cur;
        for (cur = tasks_btree.leaf_head.next;
            cur != &tasks_btree.leaf_head; cur = cur->next) {
            btree_node_t *node;
           
            node = list_get_instance(cur, btree_node_t, leaf_link);
           
            unsigned int i;
            for (i = 0; i < node->keys; i++) {
                if ((task_t *) node->value[i] != TASK) {
                    t = (task_t *) node->value[i];
                    break;
                }
            }
        }
       
        if (t != NULL) {
            task_id_t id = t->taskid;
           
            spinlock_unlock(&tasks_lock);
            interrupts_restore(ipl);
           
#ifdef CONFIG_DEBUG
            printf("Killing task %llu\n", id);
#endif          
            task_kill(id);
        } else {
            spinlock_unlock(&tasks_lock);
            interrupts_restore(ipl);
        }
       
    } while (t != NULL);
}
 
/** 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;
    atomic_set(&ta->refcount, 0);
    atomic_set(&ta->lifecount, 0);
    ta->context = CONTEXT;
 
    ta->capabilities = 0;
    ta->cycles = 0;
   
    ipc_answerbox_init(&ta->answerbox);
    for (i = 0; i < IPC_MAX_PHONES; i++)
        ipc_phone_init(&ta->phones[i]);
    if ((ipc_phone_0) && (context_check(ipc_phone_0->task->context,
        ta->context)))
        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.
     */
    atomic_inc(&as->refcount);
 
    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)
{
    /*
     * Remove the task from the task B+tree.
     */
    spinlock_lock(&tasks_lock);
    btree_remove(&tasks_btree, t->taskid, NULL);
    spinlock_unlock(&tasks_lock);
 
    /*
     * Perform architecture specific task destruction.
     */
    task_destroy_arch(t);
 
    /*
     * Free up dynamically allocated state.
     */
    btree_destroy(&t->futexes);
 
    /*
     * Drop our reference to the address space.
     */
    if (atomic_predec(&t->as->refcount) == 0)
        as_destroy(t->as);
   
    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 *t;
    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.
     */
    t = thread_create(uinit, kernel_uarg, task, THREAD_FLAG_USPACE,
        "uinit", false);
    ASSERT(t);
   
    thread_ready(t);
 
    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.
 */
unative_t 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 (unative_t) 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);
}
 
/** Get accounting data of given task.
 *
 * Note that task lock of 't' must be already held and
 * interrupts must be already disabled.
 *
 * @param t Pointer to thread.
 *
 */
uint64_t task_get_accounting(task_t *t)
{
    /* Accumulated value of task */
    uint64_t ret = t->cycles;
   
    /* Current values of threads */
    link_t *cur;
    for (cur = t->th_head.next; cur != &t->th_head; cur = cur->next) {
        thread_t *thr = list_get_instance(cur, thread_t, th_link);
       
        spinlock_lock(&thr->lock);
        /* Process only counted threads */
        if (!thr->uncounted) {
            if (thr == THREAD) {
                /* Update accounting of current thread */
                thread_update_accounting();
            }
            ret += thr->cycles;
        }
        spinlock_unlock(&thr->lock);
    }
   
    return ret;
}
 
/** Kill task.
 *
 * This function is idempotent.
 * It signals all the task's threads to bail it out.
 *
 * @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;
    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_unlock(&tasks_lock);
   
    /*
     * Interrupt all threads except ktaskclnp.
     */
    spinlock_lock(&ta->lock);
    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);
           
        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);
   
    return 0;
}
 
/** Print task list */
void task_print_list(void)
{
    link_t *cur;
    ipl_t ipl;
   
    /* Messing with task structures, avoid deadlock */
    ipl = interrupts_disable();
    spinlock_lock(&tasks_lock);
   
    printf("taskid name       ctx address    as         cycles     threads "
        "calls  callee\n");
    printf("------ ---------- --- ---------- ---------- ---------- ------- "
        "------ ------>\n");
 
    for (cur = tasks_btree.leaf_head.next; cur != &tasks_btree.leaf_head;
        cur = cur->next) {
        btree_node_t *node;
        unsigned 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);
           
            uint64_t cycles;
            char suffix;
            order(task_get_accounting(t), &cycles, &suffix);
           
            printf("%-6llu %-10s %-3ld %#10zx %#10zx %9llu%c %7zd "
                "%6zd", t->taskid, t->name, t->context, t, t->as,
                cycles, suffix, t->refcount,
                atomic_get(&t->active_calls));
            for (j = 0; j < IPC_MAX_PHONES; j++) {
                if (t->phones[j].callee)
                    printf(" %zd:%#zx", j,
                        t->phones[j].callee);
            }
            printf("\n");
           
            spinlock_unlock(&t->lock);
        }
    }
 
    spinlock_unlock(&tasks_lock);
    interrupts_restore(ipl);
}
 
/** @}
 */
 

Rev 2446	Rev 2474
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 Task management.	35	* @brief Task management.
36	*/	36	*/
37		37
38	#include <main/uinit.h>	38	#include <main/uinit.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/as.h>	42	#include <mm/as.h>
43	#include <mm/slab.h>	43	#include <mm/slab.h>
44	#include <atomic.h>	44	#include <atomic.h>
45	#include <synch/spinlock.h>	45	#include <synch/spinlock.h>
46	#include <synch/waitq.h>	46	#include <synch/waitq.h>
47	#include <arch.h>	47	#include <arch.h>
48	#include <panic.h>	48	#include <panic.h>
49	#include <adt/btree.h>	49	#include <adt/btree.h>
50	#include <adt/list.h>	50	#include <adt/list.h>
51	#include <ipc/ipc.h>	51	#include <ipc/ipc.h>
52	#include <security/cap.h>	52	#include <security/cap.h>
53	#include <memstr.h>	53	#include <memstr.h>
54	#include <print.h>	54	#include <print.h>
55	#include <lib/elf.h>	55	#include <lib/elf.h>
56	#include <errno.h>	56	#include <errno.h>
57	#include <func.h>	57	#include <func.h>
58	#include <syscall/copy.h>	58	#include <syscall/copy.h>
59		59
60	#ifndef LOADED_PROG_STACK_PAGES_NO	60	#ifndef LOADED_PROG_STACK_PAGES_NO
61	#define LOADED_PROG_STACK_PAGES_NO 1	61	#define LOADED_PROG_STACK_PAGES_NO 1
62	#endif	62	#endif
63		63
64	/** Spinlock protecting the tasks_btree B+tree. */	64	/** Spinlock protecting the tasks_btree B+tree. */
65	SPINLOCK_INITIALIZE(tasks_lock);	65	SPINLOCK_INITIALIZE(tasks_lock);
66		66
67	/** B+tree of active tasks.	67	/** B+tree of active tasks.
68	*	68	*
69	* The task is guaranteed to exist after it was found in the tasks_btree as	69	* The task is guaranteed to exist after it was found in the tasks_btree as
70	* long as:	70	* long as:
71	* @li the tasks_lock is held,	71	* @li the tasks_lock is held,
72	* @li the task's lock is held when task's lock is acquired before releasing	72	* @li the task's lock is held when task's lock is acquired before releasing
73	* tasks_lock or	73	* tasks_lock or
74	* @li the task's refcount is greater than 0	74	* @li the task's refcount is greater than 0
75	*	75	*
76	*/	76	*/
77	btree_t tasks_btree;	77	btree_t tasks_btree;
78		78
79	static task_id_t task_counter = 0;	79	static task_id_t task_counter = 0;
80		80
81	/** Initialize tasks	81	/** Initialize tasks
82	*	82	*
83	* Initialize kernel tasks support.	83	* Initialize kernel tasks support.
84	*	84	*
85	*/	85	*/
86	void task_init(void)	86	void task_init(void)
87	{	87	{
88	TASK = NULL;	88	TASK = NULL;
89	btree_create(&tasks_btree);	89	btree_create(&tasks_btree);
90	}	90	}
91		91
92	/** Kill all tasks except the current task.	92	/** Kill all tasks except the current task.
93	*	93	*
94	*/	94	*/
95	void task_done(void)	95	void task_done(void)
96	{	96	{
97	task_t *t;	97	task_t *t;
98	do { /* Repeat until there are any tasks except TASK */	98	do { /* Repeat until there are any tasks except TASK */
99		99
100	/* Messing with task structures, avoid deadlock */	100	/* Messing with task structures, avoid deadlock */
101	ipl_t ipl = interrupts_disable();	101	ipl_t ipl = interrupts_disable();
102	spinlock_lock(&tasks_lock);	102	spinlock_lock(&tasks_lock);
103		103
104	t = NULL;	104	t = NULL;
105	link_t *cur;	105	link_t *cur;
106	for (cur = tasks_btree.leaf_head.next;	106	for (cur = tasks_btree.leaf_head.next;
107	cur != &tasks_btree.leaf_head; cur = cur->next) {	107	cur != &tasks_btree.leaf_head; cur = cur->next) {
108	btree_node_t *node;	108	btree_node_t *node;
109		109
110	node = list_get_instance(cur, btree_node_t, leaf_link);	110	node = list_get_instance(cur, btree_node_t, leaf_link);
111		111
112	unsigned int i;	112	unsigned int i;
113	for (i = 0; i < node->keys; i++) {	113	for (i = 0; i < node->keys; i++) {
114	if ((task_t *) node->value[i] != TASK) {	114	if ((task_t *) node->value[i] != TASK) {
115	t = (task_t *) node->value[i];	115	t = (task_t *) node->value[i];
116	break;	116	break;
117	}	117	}
118	}	118	}
119	}	119	}
120		120
121	if (t != NULL) {	121	if (t != NULL) {
122	task_id_t id = t->taskid;	122	task_id_t id = t->taskid;
123		123
124	spinlock_unlock(&tasks_lock);	124	spinlock_unlock(&tasks_lock);
125	interrupts_restore(ipl);	125	interrupts_restore(ipl);
126		126
127	#ifdef CONFIG_DEBUG	127	#ifdef CONFIG_DEBUG
128	printf("Killing task %llu\n", id);	128	printf("Killing task %llu\n", id);
129	#endif	129	#endif
130	task_kill(id);	130	task_kill(id);
131	} else {	131	} else {
132	spinlock_unlock(&tasks_lock);	132	spinlock_unlock(&tasks_lock);
133	interrupts_restore(ipl);	133	interrupts_restore(ipl);
134	}	134	}
135		135
136	} while (t != NULL);	136	} while (t != NULL);
137	}	137	}
138		138
139	/** Create new task	139	/** Create new task
140	*	140	*
141	* Create new task with no threads.	141	* Create new task with no threads.
142	*	142	*
143	* @param as Task's address space.	143	* @param as Task's address space.
144	* @param name Symbolic name.	144	* @param name Symbolic name.
145	*	145	*
146	* @return New task's structure	146	* @return New task's structure
147	*	147	*
148	*/	148	*/
149	task_t task_create(as_t as, char *name)	149	task_t task_create(as_t as, char *name)
150	{	150	{
151	ipl_t ipl;	151	ipl_t ipl;
152	task_t *ta;	152	task_t *ta;
153	int i;	153	int i;
154		154
155	ta = (task_t *) malloc(sizeof(task_t), 0);	155	ta = (task_t *) malloc(sizeof(task_t), 0);
156		156
157	task_create_arch(ta);	157	task_create_arch(ta);
158		158
159	spinlock_initialize(&ta->lock, "task_ta_lock");	159	spinlock_initialize(&ta->lock, "task_ta_lock");
160	list_initialize(&ta->th_head);	160	list_initialize(&ta->th_head);
161	ta->as = as;	161	ta->as = as;
162	ta->name = name;	162	ta->name = name;
163	atomic_set(&ta->refcount, 0);	163	atomic_set(&ta->refcount, 0);
164	atomic_set(&ta->lifecount, 0);	164	atomic_set(&ta->lifecount, 0);
165	ta->context = CONTEXT;	165	ta->context = CONTEXT;
166		166
167	ta->capabilities = 0;	167	ta->capabilities = 0;
168	ta->cycles = 0;	168	ta->cycles = 0;
169		169
170	ipc_answerbox_init(&ta->answerbox);	170	ipc_answerbox_init(&ta->answerbox);
171	for (i = 0; i < IPC_MAX_PHONES; i++)	171	for (i = 0; i < IPC_MAX_PHONES; i++)
172	ipc_phone_init(&ta->phones[i]);	172	ipc_phone_init(&ta->phones[i]);
173	if ((ipc_phone_0) && (context_check(ipc_phone_0->task->context,	173	if ((ipc_phone_0) && (context_check(ipc_phone_0->task->context,
174	ta->context)))	174	ta->context)))
175	ipc_phone_connect(&ta->phones[0], ipc_phone_0);	175	ipc_phone_connect(&ta->phones[0], ipc_phone_0);
176	atomic_set(&ta->active_calls, 0);	176	atomic_set(&ta->active_calls, 0);
177		177
178	mutex_initialize(&ta->futexes_lock);	178	mutex_initialize(&ta->futexes_lock);
179	btree_create(&ta->futexes);	179	btree_create(&ta->futexes);
180		180
181	ipl = interrupts_disable();	181	ipl = interrupts_disable();
182		182
183	/*	183	/*
184	* Increment address space reference count.	184	* Increment address space reference count.
185	*/	185	*/
186	atomic_inc(&as->refcount);	186	atomic_inc(&as->refcount);
187		187
188	spinlock_lock(&tasks_lock);	188	spinlock_lock(&tasks_lock);
189	ta->taskid = ++task_counter;	189	ta->taskid = ++task_counter;
190	btree_insert(&tasks_btree, (btree_key_t) ta->taskid, (void *) ta, NULL);	190	btree_insert(&tasks_btree, (btree_key_t) ta->taskid, (void *) ta, NULL);
191	spinlock_unlock(&tasks_lock);	191	spinlock_unlock(&tasks_lock);
192	interrupts_restore(ipl);	192	interrupts_restore(ipl);
193		193
194	return ta;	194	return ta;
195	}	195	}
196		196
197	/** Destroy task.	197	/** Destroy task.
198	*	198	*
199	* @param t Task to be destroyed.	199	* @param t Task to be destroyed.
200	*/	200	*/
201	void task_destroy(task_t *t)	201	void task_destroy(task_t *t)
202	{	202	{
203	/*	203	/*
204	* Remove the task from the task B+tree.	204	* Remove the task from the task B+tree.
205	*/	205	*/
206	spinlock_lock(&tasks_lock);	206	spinlock_lock(&tasks_lock);
207	btree_remove(&tasks_btree, t->taskid, NULL);	207	btree_remove(&tasks_btree, t->taskid, NULL);
208	spinlock_unlock(&tasks_lock);	208	spinlock_unlock(&tasks_lock);
209		209
210	/*	210	/*
211	* Perform architecture specific task destruction.	211	* Perform architecture specific task destruction.
212	*/	212	*/
213	task_destroy_arch(t);	213	task_destroy_arch(t);
214		214
215	/*	215	/*
216	* Free up dynamically allocated state.	216	* Free up dynamically allocated state.
217	*/	217	*/
218	btree_destroy(&t->futexes);	218	btree_destroy(&t->futexes);
219		219
220	/*	220	/*
221	* Drop our reference to the address space.	221	* Drop our reference to the address space.
222	*/	222	*/
223	if (atomic_predec(&t->as->refcount) == 0)	223	if (atomic_predec(&t->as->refcount) == 0)
224	as_destroy(t->as);	224	as_destroy(t->as);
225		225
226	free(t);	226	free(t);
227	TASK = NULL;	227	TASK = NULL;
228	}	228	}
229		229
230	/** Create new task with 1 thread and run it	230	/** Create new task with 1 thread and run it
231	*	231	*
232	* @param program_addr Address of program executable image.	232	* @param program_addr Address of program executable image.
233	* @param name Program name.	233	* @param name Program name.
234	*	234	*
235	* @return Task of the running program or NULL on error.	235	* @return Task of the running program or NULL on error.
236	*/	236	*/
237	task_t task_run_program(void program_addr, char *name)	237	task_t task_run_program(void program_addr, char *name)
238	{	238	{
239	as_t *as;	239	as_t *as;
240	as_area_t *a;	240	as_area_t *a;
241	int rc;	241	int rc;
242	thread_t *t;	242	thread_t *t;
243	task_t *task;	243	task_t *task;
244	uspace_arg_t *kernel_uarg;	244	uspace_arg_t *kernel_uarg;
245		245
246	as = as_create(0);	246	as = as_create(0);
247	ASSERT(as);	247	ASSERT(as);
248		248
249	rc = elf_load((elf_header_t *) program_addr, as);	249	rc = elf_load((elf_header_t *) program_addr, as);
250	if (rc != EE_OK) {	250	if (rc != EE_OK) {
251	as_destroy(as);	251	as_destroy(as);
252	return NULL;	252	return NULL;
253	}	253	}
254		254
255	kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);	255	kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
256	kernel_uarg->uspace_entry =	256	kernel_uarg->uspace_entry =
257	(void ) ((elf_header_t ) program_addr)->e_entry;	257	(void ) ((elf_header_t ) program_addr)->e_entry;
258	kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;	258	kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
259	kernel_uarg->uspace_thread_function = NULL;	259	kernel_uarg->uspace_thread_function = NULL;
260	kernel_uarg->uspace_thread_arg = NULL;	260	kernel_uarg->uspace_thread_arg = NULL;
261	kernel_uarg->uspace_uarg = NULL;	261	kernel_uarg->uspace_uarg = NULL;
262		262
263	task = task_create(as, name);	263	task = task_create(as, name);
264	ASSERT(task);	264	ASSERT(task);
265		265
266	/*	266	/*
267	* Create the data as_area.	267	* Create the data as_area.
268	*/	268	*/
269	a = as_area_create(as, AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE,	269	a = as_area_create(as, AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE,
270	LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,	270	LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
271	AS_AREA_ATTR_NONE, &anon_backend, NULL);	271	AS_AREA_ATTR_NONE, &anon_backend, NULL);
272		272
273	/*	273	/*
274	* Create the main thread.	274	* Create the main thread.
275	*/	275	*/
276	t = thread_create(uinit, kernel_uarg, task, THREAD_FLAG_USPACE,	276	t = thread_create(uinit, kernel_uarg, task, THREAD_FLAG_USPACE,
277	"uinit", false);	277	"uinit", false);
278	ASSERT(t);	278	ASSERT(t);
279		279
280	thread_ready(t);	280	thread_ready(t);
281		281
282	return task;	282	return task;
283	}	283	}
284		284
285	/** Syscall for reading task ID from userspace.	285	/** Syscall for reading task ID from userspace.
286	*	286	*
287	* @param uspace_task_id Userspace address of 8-byte buffer where to store	287	* @param uspace_task_id Userspace address of 8-byte buffer where to store
288	* current task ID.	288	* current task ID.
289	*	289	*
290	* @return 0 on success or an error code from @ref errno.h.	290	* @return 0 on success or an error code from @ref errno.h.
291	*/	291	*/
292	unative_t sys_task_get_id(task_id_t *uspace_task_id)	292	unative_t sys_task_get_id(task_id_t *uspace_task_id)
293	{	293	{
294	/*	294	/*
295	* No need to acquire lock on TASK because taskid	295	* No need to acquire lock on TASK because taskid
296	* remains constant for the lifespan of the task.	296	* remains constant for the lifespan of the task.
297	*/	297	*/
298	return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid,	298	return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid,
299	sizeof(TASK->taskid));	299	sizeof(TASK->taskid));
300	}	300	}
301		301
302	/** Find task structure corresponding to task ID.	302	/** Find task structure corresponding to task ID.
303	*	303	*
304	* The tasks_lock must be already held by the caller of this function	304	* The tasks_lock must be already held by the caller of this function
305	* and interrupts must be disabled.	305	* and interrupts must be disabled.
306	*	306	*
307	* @param id Task ID.	307	* @param id Task ID.
308	*	308	*
309	* @return Task structure address or NULL if there is no such task ID.	309	* @return Task structure address or NULL if there is no such task ID.
310	*/	310	*/
311	task_t *task_find_by_id(task_id_t id)	311	task_t *task_find_by_id(task_id_t id)
312	{	312	{
313	btree_node_t *leaf;	313	btree_node_t *leaf;
314		314
315	return (task_t *) btree_search(&tasks_btree, (btree_key_t) id, &leaf);	315	return (task_t *) btree_search(&tasks_btree, (btree_key_t) id, &leaf);
316	}	316	}
317		317
318	/** Get accounting data of given task.	318	/** Get accounting data of given task.
319	*	319	*
320	* Note that task lock of 't' must be already held and	320	* Note that task lock of 't' must be already held and
321	* interrupts must be already disabled.	321	* interrupts must be already disabled.
322	*	322	*
323	* @param t Pointer to thread.	323	* @param t Pointer to thread.
324	*	324	*
325	*/	325	*/
326	uint64_t task_get_accounting(task_t *t)	326	uint64_t task_get_accounting(task_t *t)
327	{	327	{
328	/* Accumulated value of task */	328	/* Accumulated value of task */
329	uint64_t ret = t->cycles;	329	uint64_t ret = t->cycles;
330		330
331	/* Current values of threads */	331	/* Current values of threads */
332	link_t *cur;	332	link_t *cur;
333	for (cur = t->th_head.next; cur != &t->th_head; cur = cur->next) {	333	for (cur = t->th_head.next; cur != &t->th_head; cur = cur->next) {
334	thread_t *thr = list_get_instance(cur, thread_t, th_link);	334	thread_t *thr = list_get_instance(cur, thread_t, th_link);
335		335
336	spinlock_lock(&thr->lock);	336	spinlock_lock(&thr->lock);
337	/* Process only counted threads */	337	/* Process only counted threads */
338	if (!thr->uncounted) {	338	if (!thr->uncounted) {
339	if (thr == THREAD) {	339	if (thr == THREAD) {
340	/* Update accounting of current thread */	340	/* Update accounting of current thread */
341	thread_update_accounting();	341	thread_update_accounting();
342	}	342	}
343	ret += thr->cycles;	343	ret += thr->cycles;
344	}	344	}
345	spinlock_unlock(&thr->lock);	345	spinlock_unlock(&thr->lock);
346	}	346	}
347		347
348	return ret;	348	return ret;
349	}	349	}
350		350
351	/** Kill task.	351	/** Kill task.
352	*	352	*
353	* This function is idempotent.	353	* This function is idempotent.
354	* It signals all the task's threads to bail it out.	354	* It signals all the task's threads to bail it out.
355	*	355	*
356	* @param id ID of the task to be killed.	356	* @param id ID of the task to be killed.
357	*	357	*
358	* @return 0 on success or an error code from errno.h	358	* @return 0 on success or an error code from errno.h
359	*/	359	*/
360	int task_kill(task_id_t id)	360	int task_kill(task_id_t id)
361	{	361	{
362	ipl_t ipl;	362	ipl_t ipl;
363	task_t *ta;	363	task_t *ta;
364	link_t *cur;	364	link_t *cur;
365		365
366	if (id == 1)	366	if (id == 1)
367	return EPERM;	367	return EPERM;
368		368
369	ipl = interrupts_disable();	369	ipl = interrupts_disable();
370	spinlock_lock(&tasks_lock);	370	spinlock_lock(&tasks_lock);
371	if (!(ta = task_find_by_id(id))) {	371	if (!(ta = task_find_by_id(id))) {
372	spinlock_unlock(&tasks_lock);	372	spinlock_unlock(&tasks_lock);
373	interrupts_restore(ipl);	373	interrupts_restore(ipl);
374	return ENOENT;	374	return ENOENT;
375	}	375	}
376	spinlock_unlock(&tasks_lock);	376	spinlock_unlock(&tasks_lock);
377		377
378	/*	378	/*
379	* Interrupt all threads except ktaskclnp.	379	* Interrupt all threads except ktaskclnp.
380	*/	380	*/
381	spinlock_lock(&ta->lock);	381	spinlock_lock(&ta->lock);
382	for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {	382	for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {
383	thread_t *thr;	383	thread_t *thr;
384	bool sleeping = false;	384	bool sleeping = false;
385		385
386	thr = list_get_instance(cur, thread_t, th_link);	386	thr = list_get_instance(cur, thread_t, th_link);
387		387
388	spinlock_lock(&thr->lock);	388	spinlock_lock(&thr->lock);
389	thr->interrupted = true;	389	thr->interrupted = true;
390	if (thr->state == Sleeping)	390	if (thr->state == Sleeping)
391	sleeping = true;	391	sleeping = true;
392	spinlock_unlock(&thr->lock);	392	spinlock_unlock(&thr->lock);
393		393
394	if (sleeping)	394	if (sleeping)
395	waitq_interrupt_sleep(thr);	395	waitq_interrupt_sleep(thr);
396	}	396	}
397	spinlock_unlock(&ta->lock);	397	spinlock_unlock(&ta->lock);
398	interrupts_restore(ipl);	398	interrupts_restore(ipl);
399		399
400	return 0;	400	return 0;
401	}	401	}
402		402
403	/** Print task list */	403	/** Print task list */
404	void task_print_list(void)	404	void task_print_list(void)
405	{	405	{
406	link_t *cur;	406	link_t *cur;
407	ipl_t ipl;	407	ipl_t ipl;
408		408
409	/* Messing with task structures, avoid deadlock */	409	/* Messing with task structures, avoid deadlock */
410	ipl = interrupts_disable();	410	ipl = interrupts_disable();
411	spinlock_lock(&tasks_lock);	411	spinlock_lock(&tasks_lock);
412		412
413	printf("taskid name ctx address as cycles threads "	413	printf("taskid name ctx address as cycles threads "
414	"calls callee\n");	414	"calls callee\n");
415	printf("------ ---------- --- ---------- ---------- ---------- ------- "	415	printf("------ ---------- --- ---------- ---------- ---------- ------- "
416	"------ ------>\n");	416	"------ ------>\n");
417		417
418	for (cur = tasks_btree.leaf_head.next; cur != &tasks_btree.leaf_head;	418	for (cur = tasks_btree.leaf_head.next; cur != &tasks_btree.leaf_head;
419	cur = cur->next) {	419	cur = cur->next) {
420	btree_node_t *node;	420	btree_node_t *node;
421	unsigned int i;	421	unsigned int i;
422		422
423	node = list_get_instance(cur, btree_node_t, leaf_link);	423	node = list_get_instance(cur, btree_node_t, leaf_link);
424	for (i = 0; i < node->keys; i++) {	424	for (i = 0; i < node->keys; i++) {
425	task_t *t;	425	task_t *t;
426	int j;	426	int j;
427		427
428	t = (task_t *) node->value[i];	428	t = (task_t *) node->value[i];
429		429
430	spinlock_lock(&t->lock);	430	spinlock_lock(&t->lock);
431		431
432	uint64_t cycles;	432	uint64_t cycles;
433	char suffix;	433	char suffix;
434	order(task_get_accounting(t), &cycles, &suffix);	434	order(task_get_accounting(t), &cycles, &suffix);
435		435
436	printf("%-6llu %-10s %-3ld %#10zx %#10zx %9llu%c %7zd "	436	printf("%-6llu %-10s %-3ld %#10zx %#10zx %9llu%c %7zd "
437	"%6zd", t->taskid, t->name, t->context, t, t->as,	437	"%6zd", t->taskid, t->name, t->context, t, t->as,
438	cycles, suffix, t->refcount,	438	cycles, suffix, t->refcount,
439	atomic_get(&t->active_calls));	439	atomic_get(&t->active_calls));
440	for (j = 0; j < IPC_MAX_PHONES; j++) {	440	for (j = 0; j < IPC_MAX_PHONES; j++) {
441	if (t->phones[j].callee)	441	if (t->phones[j].callee)
442	printf(" %zd:%#zx", j,	442	printf(" %zd:%#zx", j,
443	t->phones[j].callee);	443	t->phones[j].callee);
444	}	444	}
445	printf("\n");	445	printf("\n");
446		446
447	spinlock_unlock(&t->lock);	447	spinlock_unlock(&t->lock);
448	}	448	}
449	}	449	}
450		450
451	spinlock_unlock(&tasks_lock);	451	spinlock_unlock(&tasks_lock);
452	interrupts_restore(ipl);	452	interrupts_restore(ipl);
453	}	453	}
454		454
455	/** @}	455	/** @}
456	*/	456	*/
457		457

Subversion Repositories HelenOS

(root)/tags/0.2.0.5/kernel/generic/src/proc/task.c – Rev 2446 → 2474