WebSVN – HelenOS – Diff – /trunk/kernel/generic/include/proc/task.h


/*
 * 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
 */
 
#ifndef KERN_TASK_H_
#define KERN_TASK_H_
 
#include <cpu.h>
#include <synch/spinlock.h>
#include <synch/mutex.h>
#include <synch/rwlock.h>
#include <synch/futex.h>
#include <adt/btree.h>
#include <adt/list.h>
#include <security/cap.h>
#include <arch/proc/task.h>
#include <arch/proc/thread.h>
#include <arch/context.h>
#include <arch/fpu_context.h>
#include <arch/cpu.h>
#include <mm/tlb.h>
#include <proc/scheduler.h>
 
#define IPC_MAX_PHONES  16
 
struct answerbox;
struct task;
struct thread;
 
typedef enum {
    IPC_PHONE_FREE = 0,     /**< Phone is free and can be allocated */
    IPC_PHONE_CONNECTING,   /**< Phone is connecting somewhere */
    IPC_PHONE_CONNECTED,    /**< Phone is connected */
    IPC_PHONE_HUNGUP,   /**< Phone is hung up, waiting for answers to come */
    IPC_PHONE_SLAMMED       /**< Phone was hungup from server */
} ipc_phone_state_t;
 
/** Structure identifying phone (in TASK structure) */
typedef struct {
    SPINLOCK_DECLARE(lock);
    link_t link;
    struct answerbox *callee;
    ipc_phone_state_t state;
    atomic_t active_calls;
} phone_t;
 
typedef struct answerbox {
    SPINLOCK_DECLARE(lock);
 
    struct task *task;
 
    waitq_t wq;
 
    link_t connected_phones;    /**< Phones connected to this answerbox */
    link_t calls;           /**< Received calls */
    link_t dispatched_calls;    /* Should be hash table in the future */
 
    link_t answers;         /**< Answered calls */
 
    SPINLOCK_DECLARE(irq_lock);
    link_t irq_notifs;          /**< Notifications from IRQ handlers */
    link_t irq_head;        /**< IRQs with notifications to this answerbox. */
} answerbox_t;
 
/** Task structure. */
typedef struct task {
    /** Task lock.
     *
     * Must be acquired before threads_lock and thread lock of any of its threads.
     */
    SPINLOCK_DECLARE(lock);
   
    char *name;
    struct thread *main_thread; /**< Pointer to the main thread. */
    link_t th_head;     /**< List of threads contained in this task. */
    as_t *as;       /**< Address space. */
    task_id_t taskid;   /**< Unique identity of task */
    context_id_t context;   /**< Task security context */
 
    /** If this is true, new threads can become part of the task. */
    bool accept_new_threads;
 
    count_t refcount;   /**< Number of references (i.e. threads). */
 
    cap_t capabilities; /**< Task capabilities. */
 
    /* IPC stuff */
    answerbox_t answerbox;  /**< Communication endpoint */
    phone_t phones[IPC_MAX_PHONES];
    atomic_t active_calls;  /**< Active asynchronous messages.
                 *   It is used for limiting uspace to
                 *   certain extent. */
   
    task_arch_t arch;   /**< Architecture specific task data. */
   
    /**
     * Serializes access to the B+tree of task's futexes. This mutex is
     * independent on the task spinlock.
     */
    mutex_t futexes_lock;
    btree_t futexes;    /**< B+tree of futexes referenced by this task. */
   
    uint64_t cycles;    /**< Accumulated accounting. */
} task_t;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
SPINLOCK_EXTERN(tasks_lock);
extern btree_t tasks_btree;
 
extern void task_init(void);
extern task_t *task_create(as_t *as, char *name);
extern void task_destroy(task_t *t);
extern task_t *task_run_program(void *program_addr, char *name);
extern task_t *task_find_by_id(task_id_t id);
extern int task_kill(task_id_t id);
extern uint64_t task_get_accounting(task_t *t);
 
extern void cap_set(task_t *t, cap_t caps);
extern cap_t cap_get(task_t *t);
 
 
#ifndef task_create_arch
extern void task_create_arch(task_t *t);
#endif
 
#ifndef task_destroy_arch
extern void task_destroy_arch(task_t *t);
#endif
 
extern unative_t sys_task_get_id(task_id_t *uspace_task_id);
 
#endif
 
/** @}
 */
 

Rev 2096	Rev 2103
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	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#ifndef KERN_TASK_H_	35	#ifndef KERN_TASK_H_
36	#define KERN_TASK_H_	36	#define KERN_TASK_H_
37		37
38	#include <cpu.h>	38	#include <cpu.h>
39	#include <synch/spinlock.h>	39	#include <synch/spinlock.h>
40	#include <synch/mutex.h>	40	#include <synch/mutex.h>
41	#include <synch/rwlock.h>	41	#include <synch/rwlock.h>
42	#include <synch/futex.h>	42	#include <synch/futex.h>
43	#include <adt/btree.h>	43	#include <adt/btree.h>
44	#include <adt/list.h>	44	#include <adt/list.h>
45	#include <security/cap.h>	45	#include <security/cap.h>
46	#include <arch/proc/task.h>	46	#include <arch/proc/task.h>
47	#include <arch/proc/thread.h>	47	#include <arch/proc/thread.h>
48	#include <arch/context.h>	48	#include <arch/context.h>
49	#include <arch/fpu_context.h>	49	#include <arch/fpu_context.h>
50	#include <arch/cpu.h>	50	#include <arch/cpu.h>
51	#include <mm/tlb.h>	51	#include <mm/tlb.h>
52	#include <proc/scheduler.h>	52	#include <proc/scheduler.h>
53		53
54	#define IPC_MAX_PHONES 16	54	#define IPC_MAX_PHONES 16
55		55
56	struct answerbox;	56	struct answerbox;
57	struct task;	57	struct task;
58	struct thread;	58	struct thread;
59		59
60	typedef enum {	60	typedef enum {
61	IPC_PHONE_FREE = 0, /*< Phone is free and can be allocated /	61	IPC_PHONE_FREE = 0, /*< Phone is free and can be allocated /
62	IPC_PHONE_CONNECTING, /*< Phone is connecting somewhere /	62	IPC_PHONE_CONNECTING, /*< Phone is connecting somewhere /
63	IPC_PHONE_CONNECTED, /*< Phone is connected /	63	IPC_PHONE_CONNECTED, /*< Phone is connected /
64	IPC_PHONE_HUNGUP, /*< Phone is hung up, waiting for answers to come /	64	IPC_PHONE_HUNGUP, /*< Phone is hung up, waiting for answers to come /
65	IPC_PHONE_SLAMMED /*< Phone was hungup from server /	65	IPC_PHONE_SLAMMED /*< Phone was hungup from server /
66	} ipc_phone_state_t;	66	} ipc_phone_state_t;
67		67
68	/** Structure identifying phone (in TASK structure) */	68	/** Structure identifying phone (in TASK structure) */
69	typedef struct {	69	typedef struct {
70	SPINLOCK_DECLARE(lock);	70	SPINLOCK_DECLARE(lock);
71	link_t link;	71	link_t link;
72	struct answerbox *callee;	72	struct answerbox *callee;
73	ipc_phone_state_t state;	73	ipc_phone_state_t state;
74	atomic_t active_calls;	74	atomic_t active_calls;
75	} phone_t;	75	} phone_t;
76		76
77	typedef struct answerbox {	77	typedef struct answerbox {
78	SPINLOCK_DECLARE(lock);	78	SPINLOCK_DECLARE(lock);
79		79
80	struct task *task;	80	struct task *task;
81		81
82	waitq_t wq;	82	waitq_t wq;
83		83
84	link_t connected_phones; /*< Phones connected to this answerbox /	84	link_t connected_phones; /*< Phones connected to this answerbox /
85	link_t calls; /*< Received calls /	85	link_t calls; /*< Received calls /
86	link_t dispatched_calls; /* Should be hash table in the future */	86	link_t dispatched_calls; /* Should be hash table in the future */
87		87
88	link_t answers; /*< Answered calls /	88	link_t answers; /*< Answered calls /
89		89
90	SPINLOCK_DECLARE(irq_lock);	90	SPINLOCK_DECLARE(irq_lock);
91	link_t irq_notifs; /*< Notifications from IRQ handlers /	91	link_t irq_notifs; /*< Notifications from IRQ handlers /
92	link_t irq_head; /*< IRQs with notifications to this answerbox. /	92	link_t irq_head; /*< IRQs with notifications to this answerbox. /
93	} answerbox_t;	93	} answerbox_t;
94		94
95	/** Task structure. */	95	/** Task structure. */
96	typedef struct task {	96	typedef struct task {
97	/** Task lock.	97	/** Task lock.
98	*	98	*
99	* Must be acquired before threads_lock and thread lock of any of its threads.	99	* Must be acquired before threads_lock and thread lock of any of its threads.
100	*/	100	*/
101	SPINLOCK_DECLARE(lock);	101	SPINLOCK_DECLARE(lock);
102		102
103	char *name;	103	char *name;
104	struct thread main_thread; /< Pointer to the main thread. /	104	struct thread main_thread; /< Pointer to the main thread. /
105	link_t th_head; /*< List of threads contained in this task. /	105	link_t th_head; /*< List of threads contained in this task. /
106	as_t as; /< Address space. /	106	as_t as; /< Address space. /
107	task_id_t taskid; /*< Unique identity of task /	107	task_id_t taskid; /*< Unique identity of task /
108	context_id_t context; /*< Task security context /	108	context_id_t context; /*< Task security context /
109		109
110	/** If this is true, new threads can become part of the task. */	110	/** If this is true, new threads can become part of the task. */
111	bool accept_new_threads;	111	bool accept_new_threads;
112		112
113	count_t refcount; /*< Number of references (i.e. threads). /	113	count_t refcount; /*< Number of references (i.e. threads). /
114		114
115	cap_t capabilities; /*< Task capabilities. /	115	cap_t capabilities; /*< Task capabilities. /
116		116
117	/* IPC stuff */	117	/* IPC stuff */
118	answerbox_t answerbox; /*< Communication endpoint /	118	answerbox_t answerbox; /*< Communication endpoint /
119	phone_t phones[IPC_MAX_PHONES];	119	phone_t phones[IPC_MAX_PHONES];
120	atomic_t active_calls; /**< Active asynchronous messages.	120	atomic_t active_calls; /**< Active asynchronous messages.
121	* It is used for limiting uspace to	121	* It is used for limiting uspace to
122	* certain extent. */	122	* certain extent. */
123		123
124	task_arch_t arch; /*< Architecture specific task data. /	124	task_arch_t arch; /*< Architecture specific task data. /
125		125
126	/**	126	/**
127	* Serializes access to the B+tree of task's futexes. This mutex is	127	* Serializes access to the B+tree of task's futexes. This mutex is
128	* independent on the task spinlock.	128	* independent on the task spinlock.
129	*/	129	*/
130	mutex_t futexes_lock;	130	mutex_t futexes_lock;
131	btree_t futexes; /*< B+tree of futexes referenced by this task. /	131	btree_t futexes; /*< B+tree of futexes referenced by this task. /
132		132
133	uint64_t cycles; /*< Accumulated accounting. /	133	uint64_t cycles; /*< Accumulated accounting. /
134	} task_t;	134	} task_t;
135		135
136	typedef void (* timeout_handler_t)(void *arg);	-
137		-
138	typedef struct {	-
139	SPINLOCK_DECLARE(lock);	-
140		-
141	link_t link; /*< Link to the list of active timeouts on THE->cpu /	-
142		-
143	uint64_t ticks; /*< Timeout will be activated in this amount of clock() ticks. /	-
144		-
145	timeout_handler_t handler; /*< Function that will be called on timeout activation. /	-
146	void arg; /< Argument to be passed to handler() function. /	-
147		-
148	cpu_t cpu; /< On which processor is this timeout registered. /	-
149	} timeout_t;	-
150		-
151	/** Thread states. */	-
152	typedef enum {	-
153	Invalid, /*< It is an error, if thread is found in this state. /	-
154	Running, /*< State of a thread that is currently executing on some CPU. /	-
155	Sleeping, /*< Thread in this state is waiting for an event. /	-
156	Ready, /*< State of threads in a run queue. /	-
157	Entering, /*< Threads are in this state before they are first readied. /	-
158	Exiting, /*< After a thread calls thread_exit(), it is put into Exiting state. /	-
159	Undead /*< Threads that were not detached but exited are in the Undead state. /	-
160	} state_t;	-
161		-
162	/** Join types. */	-
163	typedef enum {	-
164	None,	-
165	TaskClnp, /*< The thread will be joined by ktaskclnp thread. /	-
166	TaskGC /*< The thread will be joined by ktaskgc thread. /	-
167	} thread_join_type_t;	-
168		-
169	SPINLOCK_EXTERN(tasks_lock);	136	SPINLOCK_EXTERN(tasks_lock);
170	extern btree_t tasks_btree;	137	extern btree_t tasks_btree;
171		138
172	extern void task_init(void);	139	extern void task_init(void);
173	extern task_t task_create(as_t as, char *name);	140	extern task_t task_create(as_t as, char *name);
174	extern void task_destroy(task_t *t);	141	extern void task_destroy(task_t *t);
175	extern task_t task_run_program(void program_addr, char *name);	142	extern task_t task_run_program(void program_addr, char *name);
176	extern task_t *task_find_by_id(task_id_t id);	143	extern task_t *task_find_by_id(task_id_t id);
177	extern int task_kill(task_id_t id);	144	extern int task_kill(task_id_t id);
178	extern uint64_t task_get_accounting(task_t *t);	145	extern uint64_t task_get_accounting(task_t *t);
179		146
180	extern void cap_set(task_t *t, cap_t caps);	147	extern void cap_set(task_t *t, cap_t caps);
181	extern cap_t cap_get(task_t *t);	148	extern cap_t cap_get(task_t *t);
182		149
183		150
184	#ifndef task_create_arch	151	#ifndef task_create_arch
185	extern void task_create_arch(task_t *t);	152	extern void task_create_arch(task_t *t);
186	#endif	153	#endif
187		154
188	#ifndef task_destroy_arch	155	#ifndef task_destroy_arch
189	extern void task_destroy_arch(task_t *t);	156	extern void task_destroy_arch(task_t *t);
190	#endif	157	#endif
191		158
192	extern unative_t sys_task_get_id(task_id_t *uspace_task_id);	159	extern unative_t sys_task_get_id(task_id_t *uspace_task_id);
193		160
194	#endif	161	#endif
195		162
196	/** @}	163	/** @}
197	*/	164	*/
198		165

Subversion Repositories HelenOS

(root)/trunk/kernel/generic/include/proc/task.h – Rev 2096 → 2103