thread_solaris.h 4.37 KB
Newer Older
1 2 3 4

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
5
#include <errno.h>
6
#include </usr/include/thread.h>
7
#undef _POSIX_THREADS
8 9 10 11 12


/*
 * Initialization.
 */
13
static void PyThread__init_thread(void)
14 15 16 17 18 19 20
{
}

/*
 * Thread support.
 */
struct func_arg {
21
	void (*func)(void *);
22 23 24
	void *arg;
};

25 26
static void *
new_func(void *funcarg)
27
{
28
	void (*func)(void *);
29 30 31 32 33 34 35 36 37 38
	void *arg;

	func = ((struct func_arg *) funcarg)->func;
	arg = ((struct func_arg *) funcarg)->arg;
	free(funcarg);
	(*func)(arg);
	return 0;
}


39 40
int 
PyThread_start_new_thread(void (*func)(void *), void *arg)
41 42 43 44 45
{
	struct func_arg *funcarg;
	int success = 0;	/* init not needed when SOLARIS_THREADS and */
				/* C_THREADS implemented properly */

46
	dprintf(("PyThread_start_new_thread called\n"));
47
	if (!initialized)
48
		PyThread_init_thread();
49 50 51
	funcarg = (struct func_arg *) malloc(sizeof(struct func_arg));
	funcarg->func = func;
	funcarg->arg = arg;
52 53
	if (thr_create(0, 0, new_func, funcarg,
		       THR_DETACHED | THR_NEW_LWP, 0)) {
54 55 56 57 58 59 60
		perror("thr_create");
		free((void *) funcarg);
		success = -1;
	}
	return success < 0 ? 0 : 1;
}

61 62
long
PyThread_get_thread_ident(void)
63 64
{
	if (!initialized)
65
		PyThread_init_thread();
66 67 68
	return thr_self();
}

69 70
static void 
do_PyThread_exit_thread(int no_cleanup)
71
{
72
	dprintf(("PyThread_exit_thread called\n"));
73 74 75 76 77 78 79 80
	if (!initialized)
		if (no_cleanup)
			_exit(0);
		else
			exit(0);
	thr_exit(0);
}

81 82
void 
PyThread_exit_thread(void)
83
{
84
	do_PyThread_exit_thread(0);
85 86
}

87 88
void 
PyThread__exit_thread(void)
89
{
90
	do_PyThread_exit_thread(1);
91 92 93
}

#ifndef NO_EXIT_PROG
94 95
static void 
do_PyThread_exit_prog(int status, int no_cleanup)
96
{
97
	dprintf(("PyThread_exit_prog(%d) called\n", status));
98 99 100 101 102 103 104 105 106 107 108
	if (!initialized)
		if (no_cleanup)
			_exit(status);
		else
			exit(status);
	if (no_cleanup)
		_exit(status);
	else
		exit(status);
}

109 110
void 
PyThread_exit_prog(int status)
111
{
112
	do_PyThread_exit_prog(status, 0);
113 114
}

115 116
void 
PyThread__exit_prog(int status)
117
{
118
	do_PyThread_exit_prog(status, 1);
119 120 121 122 123 124
}
#endif /* NO_EXIT_PROG */

/*
 * Lock support.
 */
125 126
PyThread_type_lock 
PyThread_allocate_lock(void)
127 128 129
{
	mutex_t *lock;

130
	dprintf(("PyThread_allocate_lock called\n"));
131
	if (!initialized)
132
		PyThread_init_thread();
133 134 135 136 137 138 139

	lock = (mutex_t *) malloc(sizeof(mutex_t));
	if (mutex_init(lock, USYNC_THREAD, 0)) {
		perror("mutex_init");
		free((void *) lock);
		lock = 0;
	}
140
	dprintf(("PyThread_allocate_lock() -> %p\n", lock));
141
	return (PyThread_type_lock) lock;
142 143
}

144 145
void 
PyThread_free_lock(PyThread_type_lock lock)
146
{
147
	dprintf(("PyThread_free_lock(%p) called\n", lock));
148 149 150 151
	mutex_destroy((mutex_t *) lock);
	free((void *) lock);
}

152 153
int 
PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
154 155 156
{
	int success;

157
	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
158 159 160 161 162 163 164 165
	if (waitflag)
		success = mutex_lock((mutex_t *) lock);
	else
		success = mutex_trylock((mutex_t *) lock);
	if (success < 0)
		perror(waitflag ? "mutex_lock" : "mutex_trylock");
	else
		success = !success; /* solaris does it the other way round */
166
	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
167 168 169
	return success;
}

170 171
void 
PyThread_release_lock(PyThread_type_lock lock)
172
{
173
	dprintf(("PyThread_release_lock(%p) called\n", lock));
174 175 176 177 178 179 180
	if (mutex_unlock((mutex_t *) lock))
		perror("mutex_unlock");
}

/*
 * Semaphore support.
 */
181 182
PyThread_type_sema 
PyThread_allocate_sema(int value)
183 184
{
	sema_t *sema;
185
	dprintf(("PyThread_allocate_sema called\n"));
186
	if (!initialized)
187
		PyThread_init_thread();
188 189 190 191 192 193 194

	sema = (sema_t *) malloc(sizeof(sema_t));
	if (sema_init(sema, value, USYNC_THREAD, 0)) {
		perror("sema_init");
		free((void *) sema);
		sema = 0;
	}
195
	dprintf(("PyThread_allocate_sema() -> %p\n",  sema));
196
	return (PyThread_type_sema) sema;
197 198
}

199 200
void 
PyThread_free_sema(PyThread_type_sema sema)
201
{
202
	dprintf(("PyThread_free_sema(%p) called\n",  sema));
203 204 205 206 207
	if (sema_destroy((sema_t *) sema))
		perror("sema_destroy");
	free((void *) sema);
}

208 209
int 
PyThread_down_sema(PyThread_type_sema sema, int waitflag)
210
{
211 212
	int success;

213
	dprintf(("PyThread_down_sema(%p) called\n",  sema));
214 215 216 217 218 219 220 221 222 223 224 225
	if (waitflag)
		success = sema_wait((sema_t *) sema);
	else
		success = sema_trywait((sema_t *) sema);
	if (success < 0) {
		if (errno == EBUSY)
			success = 0;
		else
			perror("sema_wait");
	}
	else
		success = !success;
226
	dprintf(("PyThread_down_sema(%p) return %d\n",  sema, success));
227
	return success;
228 229
}

230 231
void 
PyThread_up_sema(PyThread_type_sema sema)
232
{
233
	dprintf(("PyThread_up_sema(%p)\n",  sema));
234 235 236
	if (sema_post((sema_t *) sema))
		perror("sema_post");
}