osapi/beos/systhread.cc

/*
 *      HT Editor
 *      systhread.cc
 *
 *      Copyright (C) 2003 Sebastian Biallas (sb@biallas.net)
 *      Copyright (C) 2004 Francois Revol (revol@free.fr)
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License version 2 as
 *      published by the Free Software Foundation.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <cstdlib>
#include <OS.h>
#include "system/systhread.h"
#include <stdio.h>
#include "system/types.h"
#include "tools/snprintf.h"

//#define DEBUG_VERBOSE
//#define DEBUG_ASSERTS

#ifdef DEBUG_VERBOSE
#define PPC_BTH_TRACE(msg...) ht_printf("[BEOS/THREAD] "msg)
#else
#define PPC_BTH_TRACE(msg...)
#endif

#ifdef DEBUG_ASSERTS
#define ASSERT_SEM(s) assert_sem(s)
#define ASSERT_THREAD(t) assert_thread(t)
#else
#define ASSERT_SEM(s)
#define ASSERT_THREAD(t)
#endif

struct sys_beos_mutex {
        thread_id thread;
        sem_id sem;
};

struct sys_beos_semaphore {
        sem_id sem;
        sem_id mutex;
};

void assert_sem(sem_id s)
{
        int32 cookie = 0;
        sem_info si;
        while (get_next_sem_info(0, &cookie, &si) == B_OK) {
                if (si.sem == s)
                        return; /* it belongs to the team, ok */
        }
        debugger("trying to use a sem we don't own!!!");
}

void assert_thread(thread_id t)
{
        int32 cookie = 0;
        thread_info ti;
        while (get_next_thread_info(0, &cookie, &ti) == B_OK) {
                if (ti.thread == t)
                        return; /* it belongs to the team, ok */
        }
        debugger("trying to use a thread we don't own!!!");
}

int sys_create_mutex(sys_mutex *m)
{
        sys_beos_mutex *bm;
        PPC_BTH_TRACE("%s(%p)\n", __FUNCTION__, m);
        bm = (sys_beos_mutex *)malloc(sizeof (sys_beos_mutex));
        bm->thread = 0;
        bm->sem = create_sem(1, "a PearPC mutex");
        PPC_BTH_TRACE("%s: {T:%d, S:%d})\n", __FUNCTION__, bm->thread, bm->sem);
        if (bm->sem < B_OK) {
                free(bm);
                return bm->sem;
        }
        *m = bm;
        return B_OK;
}

int sys_create_semaphore(sys_semaphore *s)
{
        sys_beos_semaphore *bs;
        status_t err;
        PPC_BTH_TRACE("%s(%p)\n", __FUNCTION__, s);
        bs = (sys_beos_semaphore *)malloc(sizeof (sys_beos_semaphore));
        if (!bs)
                return B_NO_MEMORY;
        err = bs->sem = create_sem(0, "a PearPC sem.sem");
        if (err < B_OK) {
                free(bs);
                return err;
        }
        err = bs->mutex = create_sem(1, "a PearPC sem.mutex");
        if (err < B_OK) {
                delete_sem(bs->sem);
                free(bs);
                return err;
        }
        PPC_BTH_TRACE("%s: {S:%d, M:%d})\n", __FUNCTION__, bs->sem, bs->mutex);
        *s = bs;
        return B_OK;
}

int sys_create_thread(sys_thread *t, int flags, sys_thread_function start_routine, void *arg)
{
        thread_id th;
        status_t err;
        PPC_BTH_TRACE("%s(%p, 0x%08x, %p, %p)\n", __FUNCTION__, t, flags, start_routine, arg);
        th = spawn_thread((thread_func)start_routine, "a PearPC thread", B_NORMAL_PRIORITY, arg);
        if (th < B_OK)
                return th;
        err = resume_thread(th);
        if (!err)
                *(thread_id *)t = th;
        PPC_BTH_TRACE("%s: T:%d\n", __FUNCTION__, th);
        return err;
}

void sys_destroy_mutex(sys_mutex m)
{
        sys_beos_mutex *bm = (sys_beos_mutex *)m;
        PPC_BTH_TRACE("%s(%p {T:%d, S:%d})\n", __FUNCTION__, m, bm->thread, bm->sem);
        ASSERT_SEM(bm->sem);
        delete_sem(bm->sem);
        free(m);
}

void sys_destroy_semaphore(sys_semaphore s)
{
        sys_beos_semaphore *bs = (sys_beos_semaphore *)s;
        PPC_BTH_TRACE("%s(%p {S:%d, M:%d})\n", __FUNCTION__, s, bs->sem, bs->mutex);
        ASSERT_SEM(bs->sem);
        delete_sem(bs->sem);
        ASSERT_SEM(bs->mutex);
        delete_sem(bs->mutex);
        free(s);
}

void sys_destroy_thread(sys_thread t)
{
        status_t err;
        thread_id th = (thread_id)t;
        PPC_BTH_TRACE("%s(T:%d)\n", __FUNCTION__, th);
        ASSERT_THREAD(th);
        //kill_thread(th); // just to make sure
        //wait_for_thread(th, &err);
}

int sys_lock_mutex(sys_mutex m)
{
        status_t err;
        sys_beos_mutex *bm = (sys_beos_mutex *)m;
        PPC_BTH_TRACE("%s(%p {T:%d, S:%d})\n", __FUNCTION__, m, bm->thread, bm->sem);
        if (bm->thread == find_thread(NULL))
                return B_OK;
        ASSERT_SEM(bm->sem);
        err = acquire_sem(bm->sem);
        if (err)
                return err;
        bm->thread = find_thread(NULL);
        return B_OK;
}

int sys_trylock_mutex(sys_mutex m)
{
        status_t err;
        sys_beos_mutex *bm = (sys_beos_mutex *)m;
        PPC_BTH_TRACE("%s(%p {T:%d, S:%d})\n", __FUNCTION__, m, bm->thread, bm->sem);
        if (bm->thread == find_thread(NULL))
                return B_OK;
        ASSERT_SEM(bm->sem);
        err = acquire_sem_etc(bm->sem, 1, B_RELATIVE_TIMEOUT, 0LL);
        if (err)
                return err;
        bm->thread = find_thread(NULL);
        return B_OK;
}

void sys_unlock_mutex(sys_mutex m)
{
        sys_beos_mutex *bm = (sys_beos_mutex *)m;
        PPC_BTH_TRACE("%s(%p {T:%d, S:%d})\n", __FUNCTION__, m, bm->thread, bm->sem);
        bm->thread = 0;
        ASSERT_SEM(bm->sem);
        release_sem(bm->sem);
}

void sys_signal_semaphore(sys_semaphore s)
{
        sys_beos_semaphore *bs = (sys_beos_semaphore *)s;
        PPC_BTH_TRACE("%s(%p {S:%d, M:%d})\n", __FUNCTION__, s, bs->sem, bs->mutex);
        ASSERT_SEM(bs->sem);
        release_sem(bs->sem);
}

void sys_signal_all_semaphore(sys_semaphore s)
{
        int32 count;
        sys_beos_semaphore *bs = (sys_beos_semaphore *)s;
        PPC_BTH_TRACE("%s(%p {S:%d, M:%d})\n", __FUNCTION__, s, bs->sem, bs->mutex);
        ASSERT_SEM(bs->sem);
        // XXX that's not safe! that should be a kernel atomic op!
        if (get_sem_count(bs->sem, &count) < B_OK)
                return;
        release_sem_etc(bs->sem, count, 0L);
}

void sys_wait_semaphore(sys_semaphore s)
{
        sys_beos_semaphore *bs = (sys_beos_semaphore *)s;
        PPC_BTH_TRACE("%s(%p {S:%d, M:%d})\n", __FUNCTION__, s, bs->sem, bs->mutex);
        ASSERT_SEM(bs->mutex);
        ASSERT_SEM(bs->sem);
        release_sem(bs->mutex);
        acquire_sem(bs->sem);
        acquire_sem(bs->mutex);
}

void sys_wait_semaphore_bounded(sys_semaphore s, int ms)
{
        sys_beos_semaphore *bs = (sys_beos_semaphore *)s;
        PPC_BTH_TRACE("%s(%p {S:%d, M:%d}, %dms)\n", __FUNCTION__, s, bs->sem, bs->mutex, ms);
        ASSERT_SEM(bs->mutex);
        ASSERT_SEM(bs->sem);
        release_sem(bs->mutex);
        acquire_sem_etc(bs->sem, 1, B_RELATIVE_TIMEOUT, (bigtime_t)ms*1000);
        acquire_sem(bs->mutex);
}

void sys_lock_semaphore(sys_semaphore s)
{
        sys_beos_semaphore *bs = (sys_beos_semaphore *)s;
        PPC_BTH_TRACE("%s(%p {S:%d, M:%d})\n", __FUNCTION__, s, bs->sem, bs->mutex);
        ASSERT_SEM(bs->mutex);
        acquire_sem(bs->mutex);
}

void sys_unlock_semaphore(sys_semaphore s)
{
        sys_beos_semaphore *bs = (sys_beos_semaphore *)s;
        PPC_BTH_TRACE("%s(%p {S:%d, M:%d})\n", __FUNCTION__, s, bs->sem, bs->mutex);
        ASSERT_SEM(bs->mutex);
        release_sem(bs->mutex);
}

void sys_exit_thread(void *ret)
{
        PPC_BTH_TRACE("%s(%p)\n", __FUNCTION__, ret);
        // in BeOS the exit code is supposed to be a success/errno
        // code, but that shouldn't matter, it's just an int32.
        // (as long as it can be casted to a void* (beware 64 bits...))
        exit_thread((status_t)ret);
}

void *sys_join_thread(sys_thread t)
{
        void *ret = NULL;
        thread_id th = (thread_id)t;
        PPC_BTH_TRACE("%s(%d)\n", __FUNCTION__, th);
        ASSERT_THREAD(th);
        //kill_thread(th); // just to make sure
        wait_for_thread(th, (status_t *)&ret);
        return ret;
}
1	/*
2	* HT Editor
3	* systhread.cc
4	*
5	* Copyright (C) 2003 Sebastian Biallas (sb@biallas.net)
6	* Copyright (C) 2004 Francois Revol (revol@free.fr)
7	*
8	* This program is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License version 2 as
10	* published by the Free Software Foundation.
11	*
12	* This program is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software
19	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20	*/
21
22	#include <cstdlib>
23	#include <OS.h>
24	#include "system/systhread.h"
25	#include <stdio.h>
26	#include "system/types.h"
27	#include "tools/snprintf.h"
28
29	//#define DEBUG_VERBOSE
30	//#define DEBUG_ASSERTS
31
32	#ifdef DEBUG_VERBOSE
33	#define PPC_BTH_TRACE(msg...) ht_printf("[BEOS/THREAD] "msg)
34	#else
35	#define PPC_BTH_TRACE(msg...)
36	#endif
37
38	#ifdef DEBUG_ASSERTS
39	#define ASSERT_SEM(s) assert_sem(s)
40	#define ASSERT_THREAD(t) assert_thread(t)
41	#else
42	#define ASSERT_SEM(s)
43	#define ASSERT_THREAD(t)
44	#endif
45
46	struct sys_beos_mutex {
47	thread_id thread;
48	sem_id sem;
49	};
50
51	struct sys_beos_semaphore {
52	sem_id sem;
53	sem_id mutex;
54	};
55
56	void assert_sem(sem_id s)
57	{
58	int32 cookie = 0;
59	sem_info si;
60	while (get_next_sem_info(0, &cookie, &si) == B_OK) {
61	if (si.sem == s)
62	return; /* it belongs to the team, ok */
63	}
64	debugger("trying to use a sem we don't own!!!");
65	}
66
67	void assert_thread(thread_id t)
68	{
69	int32 cookie = 0;
70	thread_info ti;
71	while (get_next_thread_info(0, &cookie, &ti) == B_OK) {
72	if (ti.thread == t)
73	return; /* it belongs to the team, ok */
74	}
75	debugger("trying to use a thread we don't own!!!");
76	}
77
78	int sys_create_mutex(sys_mutex *m)
79	{
80	sys_beos_mutex *bm;
81	PPC_BTH_TRACE("%s(%p)\n", __FUNCTION__, m);
82	bm = (sys_beos_mutex *)malloc(sizeof (sys_beos_mutex));
83	bm->thread = 0;
84	bm->sem = create_sem(1, "a PearPC mutex");
85	PPC_BTH_TRACE("%s: {T:%d, S:%d})\n", __FUNCTION__, bm->thread, bm->sem);
86	if (bm->sem < B_OK) {
87	free(bm);
88	return bm->sem;
89	}
90	*m = bm;
91	return B_OK;
92	}
93
94	int sys_create_semaphore(sys_semaphore *s)
95	{
96	sys_beos_semaphore *bs;
97	status_t err;
98	PPC_BTH_TRACE("%s(%p)\n", __FUNCTION__, s);
99	bs = (sys_beos_semaphore *)malloc(sizeof (sys_beos_semaphore));
100	if (!bs)
101	return B_NO_MEMORY;
102	err = bs->sem = create_sem(0, "a PearPC sem.sem");
103	if (err < B_OK) {
104	free(bs);
105	return err;
106	}
107	err = bs->mutex = create_sem(1, "a PearPC sem.mutex");
108	if (err < B_OK) {
109	delete_sem(bs->sem);
110	free(bs);
111	return err;
112	}
113	PPC_BTH_TRACE("%s: {S:%d, M:%d})\n", __FUNCTION__, bs->sem, bs->mutex);
114	*s = bs;
115	return B_OK;
116	}
117
118	int sys_create_thread(sys_thread t, int flags, sys_thread_function start_routine, void arg)
119	{
120	thread_id th;
121	status_t err;
122	PPC_BTH_TRACE("%s(%p, 0x%08x, %p, %p)\n", __FUNCTION__, t, flags, start_routine, arg);
123	th = spawn_thread((thread_func)start_routine, "a PearPC thread", B_NORMAL_PRIORITY, arg);
124	if (th < B_OK)
125	return th;
126	err = resume_thread(th);
127	if (!err)
128	(thread_id )t = th;
129	PPC_BTH_TRACE("%s: T:%d\n", __FUNCTION__, th);
130	return err;
131	}
132
133	void sys_destroy_mutex(sys_mutex m)
134	{
135	sys_beos_mutex bm = (sys_beos_mutex )m;
136	PPC_BTH_TRACE("%s(%p {T:%d, S:%d})\n", __FUNCTION__, m, bm->thread, bm->sem);
137	ASSERT_SEM(bm->sem);
138	delete_sem(bm->sem);
139	free(m);
140	}
141
142	void sys_destroy_semaphore(sys_semaphore s)
143	{
144	sys_beos_semaphore bs = (sys_beos_semaphore )s;
145	PPC_BTH_TRACE("%s(%p {S:%d, M:%d})\n", __FUNCTION__, s, bs->sem, bs->mutex);
146	ASSERT_SEM(bs->sem);
147	delete_sem(bs->sem);
148	ASSERT_SEM(bs->mutex);
149	delete_sem(bs->mutex);
150	free(s);
151	}
152
153	void sys_destroy_thread(sys_thread t)
154	{
155	status_t err;
156	thread_id th = (thread_id)t;
157	PPC_BTH_TRACE("%s(T:%d)\n", __FUNCTION__, th);
158	ASSERT_THREAD(th);
159	//kill_thread(th); // just to make sure
160	//wait_for_thread(th, &err);
161	}
162
163	int sys_lock_mutex(sys_mutex m)
164	{
165	status_t err;
166	sys_beos_mutex bm = (sys_beos_mutex )m;
167	PPC_BTH_TRACE("%s(%p {T:%d, S:%d})\n", __FUNCTION__, m, bm->thread, bm->sem);
168	if (bm->thread == find_thread(NULL))
169	return B_OK;
170	ASSERT_SEM(bm->sem);
171	err = acquire_sem(bm->sem);
172	if (err)
173	return err;
174	bm->thread = find_thread(NULL);
175	return B_OK;
176	}
177
178	int sys_trylock_mutex(sys_mutex m)
179	{
180	status_t err;
181	sys_beos_mutex bm = (sys_beos_mutex )m;
182	PPC_BTH_TRACE("%s(%p {T:%d, S:%d})\n", __FUNCTION__, m, bm->thread, bm->sem);
183	if (bm->thread == find_thread(NULL))
184	return B_OK;
185	ASSERT_SEM(bm->sem);
186	err = acquire_sem_etc(bm->sem, 1, B_RELATIVE_TIMEOUT, 0LL);
187	if (err)
188	return err;
189	bm->thread = find_thread(NULL);
190	return B_OK;
191	}
192
193	void sys_unlock_mutex(sys_mutex m)
194	{
195	sys_beos_mutex bm = (sys_beos_mutex )m;
196	PPC_BTH_TRACE("%s(%p {T:%d, S:%d})\n", __FUNCTION__, m, bm->thread, bm->sem);
197	bm->thread = 0;
198	ASSERT_SEM(bm->sem);
199	release_sem(bm->sem);
200	}
201
202	void sys_signal_semaphore(sys_semaphore s)
203	{
204	sys_beos_semaphore bs = (sys_beos_semaphore )s;
205	PPC_BTH_TRACE("%s(%p {S:%d, M:%d})\n", __FUNCTION__, s, bs->sem, bs->mutex);
206	ASSERT_SEM(bs->sem);
207	release_sem(bs->sem);
208	}
209
210	void sys_signal_all_semaphore(sys_semaphore s)
211	{
212	int32 count;
213	sys_beos_semaphore bs = (sys_beos_semaphore )s;
214	PPC_BTH_TRACE("%s(%p {S:%d, M:%d})\n", __FUNCTION__, s, bs->sem, bs->mutex);
215	ASSERT_SEM(bs->sem);
216	// XXX that's not safe! that should be a kernel atomic op!
217	if (get_sem_count(bs->sem, &count) < B_OK)
218	return;
219	release_sem_etc(bs->sem, count, 0L);
220	}
221
222	void sys_wait_semaphore(sys_semaphore s)
223	{
224	sys_beos_semaphore bs = (sys_beos_semaphore )s;
225	PPC_BTH_TRACE("%s(%p {S:%d, M:%d})\n", __FUNCTION__, s, bs->sem, bs->mutex);
226	ASSERT_SEM(bs->mutex);
227	ASSERT_SEM(bs->sem);
228	release_sem(bs->mutex);
229	acquire_sem(bs->sem);
230	acquire_sem(bs->mutex);
231	}
232
233	void sys_wait_semaphore_bounded(sys_semaphore s, int ms)
234	{
235	sys_beos_semaphore bs = (sys_beos_semaphore )s;
236	PPC_BTH_TRACE("%s(%p {S:%d, M:%d}, %dms)\n", __FUNCTION__, s, bs->sem, bs->mutex, ms);
237	ASSERT_SEM(bs->mutex);
238	ASSERT_SEM(bs->sem);
239	release_sem(bs->mutex);
240	acquire_sem_etc(bs->sem, 1, B_RELATIVE_TIMEOUT, (bigtime_t)ms*1000);
241	acquire_sem(bs->mutex);
242	}
243
244	void sys_lock_semaphore(sys_semaphore s)
245	{
246	sys_beos_semaphore bs = (sys_beos_semaphore )s;
247	PPC_BTH_TRACE("%s(%p {S:%d, M:%d})\n", __FUNCTION__, s, bs->sem, bs->mutex);
248	ASSERT_SEM(bs->mutex);
249	acquire_sem(bs->mutex);
250	}
251
252	void sys_unlock_semaphore(sys_semaphore s)
253	{
254	sys_beos_semaphore bs = (sys_beos_semaphore )s;
255	PPC_BTH_TRACE("%s(%p {S:%d, M:%d})\n", __FUNCTION__, s, bs->sem, bs->mutex);
256	ASSERT_SEM(bs->mutex);
257	release_sem(bs->mutex);
258	}
259
260	void sys_exit_thread(void *ret)
261	{
262	PPC_BTH_TRACE("%s(%p)\n", __FUNCTION__, ret);
263	// in BeOS the exit code is supposed to be a success/errno
264	// code, but that shouldn't matter, it's just an int32.
265	// (as long as it can be casted to a void* (beware 64 bits...))
266	exit_thread((status_t)ret);
267	}
268
269	void *sys_join_thread(sys_thread t)
270	{
271	void *ret = NULL;
272	thread_id th = (thread_id)t;
273	PPC_BTH_TRACE("%s(%d)\n", __FUNCTION__, th);
274	ASSERT_THREAD(th);
275	//kill_thread(th); // just to make sure
276	wait_for_thread(th, (status_t *)&ret);
277	return ret;
278	}