WebSVN – HelenOS – Diff – /branches/sparc/kernel/generic/include/proc/thread.h


/*
 * Copyright (c) 2001-2007 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_THREAD_H_
#define KERN_THREAD_H_
 
#include <synch/waitq.h>
#include <proc/task.h>
#include <time/timeout.h>
#include <cpu.h>
#include <synch/rwlock.h>
#include <synch/spinlock.h>
#include <adt/avl.h>
#include <mm/slab.h>
#include <arch/cpu.h>
#include <mm/tlb.h>
#include <proc/uarg.h>
#include <udebug/udebug.h>
 
#define THREAD_STACK_SIZE   STACK_SIZE
#define THREAD_NAME_BUFLEN  20
 
extern char *thread_states[];
 
/* Thread flags */
 
/** Thread cannot be migrated to another CPU.
 *
 * When using this flag, the caller must set cpu in the thread_t
 * structure manually before calling thread_ready (even on uniprocessor).
 */
#define THREAD_FLAG_WIRED   (1 << 0)
/** Thread was migrated to another CPU and has not run yet. */
#define THREAD_FLAG_STOLEN  (1 << 1)
/** Thread executes in userspace. */
#define THREAD_FLAG_USPACE  (1 << 2)
/** Thread will be attached by the caller. */
#define THREAD_FLAG_NOATTACH    (1 << 3)
 
/** Thread states. */
typedef enum {
    /** It is an error, if thread is found in this state. */
    Invalid,
    /** State of a thread that is currently executing on some CPU. */
    Running,
    /** Thread in this state is waiting for an event. */
    Sleeping,
    /** State of threads in a run queue. */
    Ready,
    /** Threads are in this state before they are first readied. */
    Entering,
    /** After a thread calls thread_exit(), it is put into Exiting state. */
    Exiting,
    /** Threads that were not detached but exited are Lingering. */
    Lingering
} state_t;
 
/** Thread structure. There is one per thread. */
typedef struct thread {
    link_t rq_link;     /**< Run queue link. */
    link_t wq_link;     /**< Wait queue link. */
    link_t th_link;     /**< Links to threads within containing task. */
 
    /** Threads linkage to the threads_tree. */
    avltree_node_t threads_tree_node;
   
    /** Lock protecting thread structure.
     *
     * Protects the whole thread structure except list links above.
     */
    SPINLOCK_DECLARE(lock);
 
    char name[THREAD_NAME_BUFLEN];
 
    /** Function implementing the thread. */
    void (* thread_code)(void *);
    /** Argument passed to thread_code() function. */
    void *thread_arg;
 
    /**
     * From here, the stored context is restored when the thread is
     * scheduled.
     */
    context_t saved_context;
    /**
     * From here, the stored timeout context is restored when sleep times
     * out.
     */
    context_t sleep_timeout_context;
    /**
     * From here, the stored interruption context is restored when sleep is
     * interrupted.
     */
    context_t sleep_interruption_context;
 
    /** If true, the thread can be interrupted from sleep. */
    bool sleep_interruptible;
    /** Wait queue in which this thread sleeps. */
    waitq_t *sleep_queue;
    /** Timeout used for timeoutable sleeping.  */
    timeout_t sleep_timeout;
    /** Flag signalling sleep timeout in progress. */
    volatile int timeout_pending;
 
    /**
     * True if this thread is executing copy_from_uspace().
     * False otherwise.
     */
    bool in_copy_from_uspace;
    /**
     * True if this thread is executing copy_to_uspace().
     * False otherwise.
     */
    bool in_copy_to_uspace;
   
    /**
     * If true, the thread will not go to sleep at all and will call
     * thread_exit() before returning to userspace.
     */
    bool interrupted;          
   
    /** If true, thread_join_timeout() cannot be used on this thread. */
    bool detached;
    /** Waitq for thread_join_timeout(). */
    waitq_t join_wq;
    /** Link used in the joiner_head list. */
    link_t joiner_link;
 
    fpu_context_t *saved_fpu_context;
    int fpu_context_exists;
 
    /*
     * Defined only if thread doesn't run.
     * It means that fpu context is in CPU that last time executes this
     * thread. This disables migration.
     */
    int fpu_context_engaged;
 
    rwlock_type_t rwlock_holder_type;
 
    /** Callback fired in scheduler before the thread is put asleep. */
    void (* call_me)(void *);
    /** Argument passed to call_me(). */
    void *call_me_with;
 
    /** Thread's state. */
    state_t state;
    /** Thread's flags. */
    int flags;
   
    /** Thread's CPU. */
    cpu_t *cpu;
    /** Containing task. */
    task_t *task;
 
    /** Ticks before preemption. */
    uint64_t ticks;
   
    /** Thread accounting. */
    uint64_t cycles;
    /** Last sampled cycle. */
    uint64_t last_cycle;
    /** Thread doesn't affect accumulated accounting. */   
    bool uncounted;
 
    /** Thread's priority. Implemented as index to CPU->rq */
    int priority;
    /** Thread ID. */
    thread_id_t tid;
   
    /** Architecture-specific data. */
    thread_arch_t arch;
 
    /** Thread's kernel stack. */
    uint8_t *kstack;
 
#ifdef CONFIG_UDEBUG
    /** Debugging stuff */
    udebug_thread_t udebug;
#endif
 
} thread_t;
 
/** Thread list lock.
 *
 * This lock protects the threads_tree.
 * Must be acquired before T.lock for each T of type thread_t.
 *
 */
SPINLOCK_EXTERN(threads_lock);
 
/** AVL tree containing all threads. */
extern avltree_t threads_tree;
 
extern void thread_init(void);
extern thread_t *thread_create(void (* func)(void *), void *arg, task_t *task,
    int flags, char *name, bool uncounted);
extern void thread_attach(thread_t *t, task_t *task);
extern void thread_ready(thread_t *t);
extern void thread_exit(void) __attribute__((noreturn));
 
#ifndef thread_create_arch
extern void thread_create_arch(thread_t *t);
#endif
#ifndef thr_constructor_arch
extern void thr_constructor_arch(thread_t *t);
#endif
#ifndef thr_destructor_arch
extern void thr_destructor_arch(thread_t *t);
#endif
 
extern void thread_sleep(uint32_t sec);
extern void thread_usleep(uint32_t usec);
 
#define thread_join(t) \
    thread_join_timeout((t), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE)
extern int thread_join_timeout(thread_t *t, uint32_t usec, int flags);
extern void thread_detach(thread_t *t);
 
extern void thread_register_call_me(void (* call_me)(void *),
    void *call_me_with);
extern void thread_print_list(void);
extern void thread_destroy(thread_t *t);
extern void thread_update_accounting(void);
extern bool thread_exists(thread_t *t);
 
/** Fpu context slab cache. */
extern slab_cache_t *fpu_context_slab;
 
/* Thread syscall prototypes. */
extern unative_t sys_thread_create(uspace_arg_t *uspace_uarg,
    char *uspace_name, size_t name_len, thread_id_t *uspace_thread_id);
extern unative_t sys_thread_exit(int uspace_status);
extern unative_t sys_thread_get_id(thread_id_t *uspace_thread_id);
 
#endif
 
/** @}
 */
 

Rev 3492	Rev 3593
1	/*	1	/*
2	* Copyright (c) 2001-2007 Jakub Jermar	2	* Copyright (c) 2001-2007 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_THREAD_H_	35	#ifndef KERN_THREAD_H_
36	#define KERN_THREAD_H_	36	#define KERN_THREAD_H_
37		37
38	#include <synch/waitq.h>	38	#include <synch/waitq.h>
39	#include <proc/task.h>	39	#include <proc/task.h>
40	#include <time/timeout.h>	40	#include <time/timeout.h>
41	#include <cpu.h>	41	#include <cpu.h>
42	#include <synch/rwlock.h>	42	#include <synch/rwlock.h>
43	#include <synch/spinlock.h>	43	#include <synch/spinlock.h>
44	#include <adt/avl.h>	44	#include <adt/avl.h>
45	#include <mm/slab.h>	45	#include <mm/slab.h>
46	#include <arch/cpu.h>	46	#include <arch/cpu.h>
47	#include <mm/tlb.h>	47	#include <mm/tlb.h>
48	#include <proc/uarg.h>	48	#include <proc/uarg.h>
49	#include <udebug/udebug.h>	49	#include <udebug/udebug.h>
50		50
51	#define THREAD_STACK_SIZE STACK_SIZE	51	#define THREAD_STACK_SIZE STACK_SIZE
52	#define THREAD_NAME_BUFLEN 20	52	#define THREAD_NAME_BUFLEN 20
53		53
54	extern char *thread_states[];	54	extern char *thread_states[];
55		55
56	/* Thread flags */	56	/* Thread flags */
57		57
58	/** Thread cannot be migrated to another CPU.	58	/** Thread cannot be migrated to another CPU.
59	*	59	*
60	* When using this flag, the caller must set cpu in the thread_t	60	* When using this flag, the caller must set cpu in the thread_t
61	* structure manually before calling thread_ready (even on uniprocessor).	61	* structure manually before calling thread_ready (even on uniprocessor).
62	*/	62	*/
63	#define THREAD_FLAG_WIRED (1 << 0)	63	#define THREAD_FLAG_WIRED (1 << 0)
64	/** Thread was migrated to another CPU and has not run yet. */	64	/** Thread was migrated to another CPU and has not run yet. */
65	#define THREAD_FLAG_STOLEN (1 << 1)	65	#define THREAD_FLAG_STOLEN (1 << 1)
66	/** Thread executes in userspace. */	66	/** Thread executes in userspace. */
67	#define THREAD_FLAG_USPACE (1 << 2)	67	#define THREAD_FLAG_USPACE (1 << 2)
68	/** Thread will be attached by the caller. */	68	/** Thread will be attached by the caller. */
69	#define THREAD_FLAG_NOATTACH (1 << 3)	69	#define THREAD_FLAG_NOATTACH (1 << 3)
70		70
71	/** Thread states. */	71	/** Thread states. */
72	typedef enum {	72	typedef enum {
73	/** It is an error, if thread is found in this state. */	73	/** It is an error, if thread is found in this state. */
74	Invalid,	74	Invalid,
75	/** State of a thread that is currently executing on some CPU. */	75	/** State of a thread that is currently executing on some CPU. */
76	Running,	76	Running,
77	/** Thread in this state is waiting for an event. */	77	/** Thread in this state is waiting for an event. */
78	Sleeping,	78	Sleeping,
79	/** State of threads in a run queue. */	79	/** State of threads in a run queue. */
80	Ready,	80	Ready,
81	/** Threads are in this state before they are first readied. */	81	/** Threads are in this state before they are first readied. */
82	Entering,	82	Entering,
83	/** After a thread calls thread_exit(), it is put into Exiting state. */	83	/** After a thread calls thread_exit(), it is put into Exiting state. */
84	Exiting,	84	Exiting,
85	/** Threads that were not detached but exited are Lingering. */	85	/** Threads that were not detached but exited are Lingering. */
86	Lingering	86	Lingering
87	} state_t;	87	} state_t;
88		88
89	/** Thread structure. There is one per thread. */	89	/** Thread structure. There is one per thread. */
90	typedef struct thread {	90	typedef struct thread {
91	link_t rq_link; /*< Run queue link. /	91	link_t rq_link; /*< Run queue link. /
92	link_t wq_link; /*< Wait queue link. /	92	link_t wq_link; /*< Wait queue link. /
93	link_t th_link; /*< Links to threads within containing task. /	93	link_t th_link; /*< Links to threads within containing task. /
94		94
95	/** Threads linkage to the threads_tree. */	95	/** Threads linkage to the threads_tree. */
96	avltree_node_t threads_tree_node;	96	avltree_node_t threads_tree_node;
97		97
98	/** Lock protecting thread structure.	98	/** Lock protecting thread structure.
99	*	99	*
100	* Protects the whole thread structure except list links above.	100	* Protects the whole thread structure except list links above.
101	*/	101	*/
102	SPINLOCK_DECLARE(lock);	102	SPINLOCK_DECLARE(lock);
103		103
104	char name[THREAD_NAME_BUFLEN];	104	char name[THREAD_NAME_BUFLEN];
105		105
106	/** Function implementing the thread. */	106	/** Function implementing the thread. */
107	void (* thread_code)(void *);	107	void (* thread_code)(void *);
108	/** Argument passed to thread_code() function. */	108	/** Argument passed to thread_code() function. */
109	void *thread_arg;	109	void *thread_arg;
110		110
111	/**	111	/**
112	* From here, the stored context is restored when the thread is	112	* From here, the stored context is restored when the thread is
113	* scheduled.	113	* scheduled.
114	*/	114	*/
115	context_t saved_context;	115	context_t saved_context;
116	/**	116	/**
117	* From here, the stored timeout context is restored when sleep times	117	* From here, the stored timeout context is restored when sleep times
118	* out.	118	* out.
119	*/	119	*/
120	context_t sleep_timeout_context;	120	context_t sleep_timeout_context;
121	/**	121	/**
122	* From here, the stored interruption context is restored when sleep is	122	* From here, the stored interruption context is restored when sleep is
123	* interrupted.	123	* interrupted.
124	*/	124	*/
125	context_t sleep_interruption_context;	125	context_t sleep_interruption_context;
126		126
127	/** If true, the thread can be interrupted from sleep. */	127	/** If true, the thread can be interrupted from sleep. */
128	bool sleep_interruptible;	128	bool sleep_interruptible;
129	/** Wait queue in which this thread sleeps. */	129	/** Wait queue in which this thread sleeps. */
130	waitq_t *sleep_queue;	130	waitq_t *sleep_queue;
131	/** Timeout used for timeoutable sleeping. */	131	/** Timeout used for timeoutable sleeping. */
132	timeout_t sleep_timeout;	132	timeout_t sleep_timeout;
133	/** Flag signalling sleep timeout in progress. */	133	/** Flag signalling sleep timeout in progress. */
134	volatile int timeout_pending;	134	volatile int timeout_pending;
135		135
136	/**	136	/**
137	* True if this thread is executing copy_from_uspace().	137	* True if this thread is executing copy_from_uspace().
138	* False otherwise.	138	* False otherwise.
139	*/	139	*/
140	bool in_copy_from_uspace;	140	bool in_copy_from_uspace;
141	/**	141	/**
142	* True if this thread is executing copy_to_uspace().	142	* True if this thread is executing copy_to_uspace().
143	* False otherwise.	143	* False otherwise.
144	*/	144	*/
145	bool in_copy_to_uspace;	145	bool in_copy_to_uspace;
146		146
147	/**	147	/**
148	* If true, the thread will not go to sleep at all and will call	148	* If true, the thread will not go to sleep at all and will call
149	* thread_exit() before returning to userspace.	149	* thread_exit() before returning to userspace.
150	*/	150	*/
151	bool interrupted;	151	bool interrupted;
152		152
153	/** If true, thread_join_timeout() cannot be used on this thread. */	153	/** If true, thread_join_timeout() cannot be used on this thread. */
154	bool detached;	154	bool detached;
155	/** Waitq for thread_join_timeout(). */	155	/** Waitq for thread_join_timeout(). */
156	waitq_t join_wq;	156	waitq_t join_wq;
157	/** Link used in the joiner_head list. */	157	/** Link used in the joiner_head list. */
158	link_t joiner_link;	158	link_t joiner_link;
159		159
160	fpu_context_t *saved_fpu_context;	160	fpu_context_t *saved_fpu_context;
161	int fpu_context_exists;	161	int fpu_context_exists;
162		162
163	/*	163	/*
164	* Defined only if thread doesn't run.	164	* Defined only if thread doesn't run.
165	* It means that fpu context is in CPU that last time executes this	165	* It means that fpu context is in CPU that last time executes this
166	* thread. This disables migration.	166	* thread. This disables migration.
167	*/	167	*/
168	int fpu_context_engaged;	168	int fpu_context_engaged;
169		169
170	rwlock_type_t rwlock_holder_type;	170	rwlock_type_t rwlock_holder_type;
171		171
172	/** Callback fired in scheduler before the thread is put asleep. */	172	/** Callback fired in scheduler before the thread is put asleep. */
173	void (* call_me)(void *);	173	void (* call_me)(void *);
174	/** Argument passed to call_me(). */	174	/** Argument passed to call_me(). */
175	void *call_me_with;	175	void *call_me_with;
176		176
177	/** Thread's state. */	177	/** Thread's state. */
178	state_t state;	178	state_t state;
179	/** Thread's flags. */	179	/** Thread's flags. */
180	int flags;	180	int flags;
181		181
182	/** Thread's CPU. */	182	/** Thread's CPU. */
183	cpu_t *cpu;	183	cpu_t *cpu;
184	/** Containing task. */	184	/** Containing task. */
185	task_t *task;	185	task_t *task;
186		186
187	/** Ticks before preemption. */	187	/** Ticks before preemption. */
188	uint64_t ticks;	188	uint64_t ticks;
189		189
190	/** Thread accounting. */	190	/** Thread accounting. */
191	uint64_t cycles;	191	uint64_t cycles;
192	/** Last sampled cycle. */	192	/** Last sampled cycle. */
193	uint64_t last_cycle;	193	uint64_t last_cycle;
194	/** Thread doesn't affect accumulated accounting. */	194	/** Thread doesn't affect accumulated accounting. */
195	bool uncounted;	195	bool uncounted;
196		196
197	/** Thread's priority. Implemented as index to CPU->rq */	197	/** Thread's priority. Implemented as index to CPU->rq */
198	int priority;	198	int priority;
199	/** Thread ID. */	199	/** Thread ID. */
200	thread_id_t tid;	200	thread_id_t tid;
201		201
202	/** Architecture-specific data. */	202	/** Architecture-specific data. */
203	thread_arch_t arch;	203	thread_arch_t arch;
204		204
205	/** Thread's kernel stack. */	205	/** Thread's kernel stack. */
206	uint8_t *kstack;	206	uint8_t *kstack;
207		207
208	#ifdef CONFIG_UDEBUG	208	#ifdef CONFIG_UDEBUG
209	/** Debugging stuff */	209	/** Debugging stuff */
210	udebug_thread_t udebug;	210	udebug_thread_t udebug;
211	#endif	211	#endif
212		212
213	} thread_t;	213	} thread_t;
214		214
215	/** Thread list lock.	215	/** Thread list lock.
216	*	216	*
217	* This lock protects the threads_tree.	217	* This lock protects the threads_tree.
218	* Must be acquired before T.lock for each T of type thread_t.	218	* Must be acquired before T.lock for each T of type thread_t.
219	*	219	*
220	*/	220	*/
221	SPINLOCK_EXTERN(threads_lock);	221	SPINLOCK_EXTERN(threads_lock);
222		222
223	/** AVL tree containing all threads. */	223	/** AVL tree containing all threads. */
224	extern avltree_t threads_tree;	224	extern avltree_t threads_tree;
225		225
226	extern void thread_init(void);	226	extern void thread_init(void);
227	extern thread_t thread_create(void ( func)(void ), void arg, task_t *task,	227	extern thread_t thread_create(void ( func)(void ), void arg, task_t *task,
228	int flags, char *name, bool uncounted);	228	int flags, char *name, bool uncounted);
229	extern void thread_attach(thread_t t, task_t task);	229	extern void thread_attach(thread_t t, task_t task);
230	extern void thread_ready(thread_t *t);	230	extern void thread_ready(thread_t *t);
231	extern void thread_exit(void) __attribute__((noreturn));	231	extern void thread_exit(void) __attribute__((noreturn));
232		232
233	#ifndef thread_create_arch	233	#ifndef thread_create_arch
234	extern void thread_create_arch(thread_t *t);	234	extern void thread_create_arch(thread_t *t);
235	#endif	235	#endif
236	#ifndef thr_constructor_arch	236	#ifndef thr_constructor_arch
237	extern void thr_constructor_arch(thread_t *t);	237	extern void thr_constructor_arch(thread_t *t);
238	#endif	238	#endif
239	#ifndef thr_destructor_arch	239	#ifndef thr_destructor_arch
240	extern void thr_destructor_arch(thread_t *t);	240	extern void thr_destructor_arch(thread_t *t);
241	#endif	241	#endif
242		242
243	extern void thread_sleep(uint32_t sec);	243	extern void thread_sleep(uint32_t sec);
244	extern void thread_usleep(uint32_t usec);	244	extern void thread_usleep(uint32_t usec);
245		245
246	#define thread_join(t) \	246	#define thread_join(t) \
247	thread_join_timeout((t), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE)	247	thread_join_timeout((t), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE)
248	extern int thread_join_timeout(thread_t *t, uint32_t usec, int flags);	248	extern int thread_join_timeout(thread_t *t, uint32_t usec, int flags);
249	extern void thread_detach(thread_t *t);	249	extern void thread_detach(thread_t *t);
250		250
251	extern void thread_register_call_me(void (* call_me)(void *),	251	extern void thread_register_call_me(void (* call_me)(void *),
252	void *call_me_with);	252	void *call_me_with);
253	extern void thread_print_list(void);	253	extern void thread_print_list(void);
254	extern void thread_destroy(thread_t *t);	254	extern void thread_destroy(thread_t *t);
255	extern void thread_update_accounting(void);	255	extern void thread_update_accounting(void);
256	extern bool thread_exists(thread_t *t);	256	extern bool thread_exists(thread_t *t);
257		257
258	/** Fpu context slab cache. */	258	/** Fpu context slab cache. */
259	extern slab_cache_t *fpu_context_slab;	259	extern slab_cache_t *fpu_context_slab;
260		260
261	/* Thread syscall prototypes. */	261	/* Thread syscall prototypes. */
262	extern unative_t sys_thread_create(uspace_arg_t uspace_uarg, char uspace_name, thread_id_t *uspace_thread_id);	262	extern unative_t sys_thread_create(uspace_arg_t *uspace_uarg,
-		263	char uspace_name, size_t name_len, thread_id_t uspace_thread_id);
263	extern unative_t sys_thread_exit(int uspace_status);	264	extern unative_t sys_thread_exit(int uspace_status);
264	extern unative_t sys_thread_get_id(thread_id_t *uspace_thread_id);	265	extern unative_t sys_thread_get_id(thread_id_t *uspace_thread_id);
265		266
266	#endif	267	#endif
267		268
268	/** @}	269	/** @}
269	*/	270	*/
270		271

Subversion Repositories HelenOS

(root)/branches/sparc/kernel/generic/include/proc/thread.h – Rev 3492 → 3593