1
2 /*
3 * Copyright (C) Igor Sysoev
4 */
5
6
7 #include <ngx_config.h>
8 #include <ngx_core.h>
9
10
11 static ngx_uint_t nthreads;
12 static ngx_uint_t max_threads;
13
14
15 static pthread_attr_t thr_attr;
16
17
18 ngx_err_t
19 ngx_create_thread(ngx_tid_t *tid, ngx_thread_value_t (*func)(void *arg),
20 void *arg, ngx_log_t *log)
21 {
22 int err;
23
24 if (nthreads >= max_threads) {
25 ngx_log_error(NGX_LOG_CRIT, log, 0,
26 "no more than %ui threads can be created", max_threads);
27 return NGX_ERROR;
28 }
29
30 err = pthread_create(tid, &thr_attr, func, arg);
31
32 if (err != 0) {
33 ngx_log_error(NGX_LOG_ALERT, log, err, "pthread_create() failed");
34 return err;
35 }
36
37 ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0,
38 "thread is created: " NGX_TID_T_FMT, *tid);
39
40 nthreads++;
41
42 return err;
43 }
44
45
46 ngx_int_t
47 ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
48 {
49 int err;
50
51 max_threads = n;
52
53 err = pthread_attr_init(&thr_attr);
54
55 if (err != 0) {
56 ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
57 "pthread_attr_init() failed");
58 return NGX_ERROR;
59 }
60
61 err = pthread_attr_setstacksize(&thr_attr, size);
62
63 if (err != 0) {
64 ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
65 "pthread_attr_setstacksize() failed");
66 return NGX_ERROR;
67 }
68
69 ngx_threaded = 1;
70
71 return NGX_OK;
72 }
73
74
75 ngx_mutex_t *
76 ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
77 {
78 int err;
79 ngx_mutex_t *m;
80
81 m = ngx_alloc(sizeof(ngx_mutex_t), log);
82 if (m == NULL) {
83 return NULL;
84 }
85
86 m->log = log;
87
88 err = pthread_mutex_init(&m->mutex, NULL);
89
90 if (err != 0) {
91 ngx_log_error(NGX_LOG_ALERT, m->log, err,
92 "pthread_mutex_init() failed");
93 return NULL;
94 }
95
96 return m;
97 }
98
99
100 void
101 ngx_mutex_destroy(ngx_mutex_t *m)
102 {
103 int err;
104
105 err = pthread_mutex_destroy(&m->mutex);
106
107 if (err != 0) {
108 ngx_log_error(NGX_LOG_ALERT, m->log, err,
109 "pthread_mutex_destroy(%p) failed", m);
110 }
111
112 ngx_free(m);
113 }
114
115
116 void
117 ngx_mutex_lock(ngx_mutex_t *m)
118 {
119 int err;
120
121 if (!ngx_threaded) {
122 return;
123 }
124
125 ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "lock mutex %p", m);
126
127 err = pthread_mutex_lock(&m->mutex);
128
129 if (err != 0) {
130 ngx_log_error(NGX_LOG_ALERT, m->log, err,
131 "pthread_mutex_lock(%p) failed", m);
132 ngx_abort();
133 }
134
135 ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "mutex %p is locked", m);
136
137 return;
138 }
139
140
141 ngx_int_t
142 ngx_mutex_trylock(ngx_mutex_t *m)
143 {
144 int err;
145
146 if (!ngx_threaded) {
147 return NGX_OK;
148 }
149
150 ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "try lock mutex %p", m);
151
152 err = pthread_mutex_trylock(&m->mutex);
153
154 if (err == NGX_EBUSY) {
155 return NGX_AGAIN;
156 }
157
158 if (err != 0) {
159 ngx_log_error(NGX_LOG_ALERT, m->log, err,
160 "pthread_mutex_trylock(%p) failed", m);
161 ngx_abort();
162 }
163
164 ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "mutex %p is locked", m);
165
166 return NGX_OK;
167 }
168
169
170 void
171 ngx_mutex_unlock(ngx_mutex_t *m)
172 {
173 int err;
174
175 if (!ngx_threaded) {
176 return;
177 }
178
179 ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "unlock mutex %p", m);
180
181 err = pthread_mutex_unlock(&m->mutex);
182
183 if (err != 0) {
184 ngx_log_error(NGX_LOG_ALERT, m->log, err,
185 "pthread_mutex_unlock(%p) failed", m);
186 ngx_abort();
187 }
188
189 ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "mutex %p is unlocked", m);
190
191 return;
192 }
193
194
195 ngx_cond_t *
196 ngx_cond_init(ngx_log_t *log)
197 {
198 int err;
199 ngx_cond_t *cv;
200
201 cv = ngx_alloc(sizeof(ngx_cond_t), log);
202 if (cv == NULL) {
203 return NULL;
204 }
205
206 cv->log = log;
207
208 err = pthread_cond_init(&cv->cond, NULL);
209
210 if (err != 0) {
211 ngx_log_error(NGX_LOG_ALERT, cv->log, err,
212 "pthread_cond_init() failed");
213 return NULL;
214 }
215
216 return cv;
217 }
218
219
220 void
221 ngx_cond_destroy(ngx_cond_t *cv)
222 {
223 int err;
224
225 err = pthread_cond_destroy(&cv->cond);
226
227 if (err != 0) {
228 ngx_log_error(NGX_LOG_ALERT, cv->log, err,
229 "pthread_cond_destroy(%p) failed", cv);
230 }
231
232 ngx_free(cv);
233 }
234
235
236 ngx_int_t
237 ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
238 {
239 int err;
240
241 ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0, "cv %p wait", cv);
242
243 err = pthread_cond_wait(&cv->cond, &m->mutex);
244
245 if (err != 0) {
246 ngx_log_error(NGX_LOG_ALERT, cv->log, err,
247 "pthread_cond_wait(%p) failed", cv);
248 return NGX_ERROR;
249 }
250
251 ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0, "cv %p is waked up", cv);
252
253 ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "mutex %p is locked", m);
254
255 return NGX_OK;
256 }
257
258
259 ngx_int_t
260 ngx_cond_signal(ngx_cond_t *cv)
261 {
262 int err;
263
264 ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0, "cv %p to signal", cv);
265
266 err = pthread_cond_signal(&cv->cond);
267
268 if (err != 0) {
269 ngx_log_error(NGX_LOG_ALERT, cv->log, err,
270 "pthread_cond_signal(%p) failed", cv);
271 return NGX_ERROR;
272 }
273
274 ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0, "cv %p is signaled", cv);
275
276 return NGX_OK;
277 }
278
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.