Mercurial > hg > nginx-quic
comparison src/event/modules/ngx_kqueue_module.c @ 385:79050a10aacb
nginx-0.0.7-2004-07-09-19:37:31 import
author | Igor Sysoev <igor@sysoev.ru> |
---|---|
date | Fri, 09 Jul 2004 15:37:31 +0000 |
parents | c05876036128 |
children | 80e72c428b39 |
comparison
equal
deleted
inserted
replaced
384:e7054aaedf68 | 385:79050a10aacb |
---|---|
43 static struct kevent *change_list, *change_list0, *change_list1; | 43 static struct kevent *change_list, *change_list0, *change_list1; |
44 static struct kevent *event_list; | 44 static struct kevent *event_list; |
45 static int max_changes, nchanges, nevents; | 45 static int max_changes, nchanges, nevents; |
46 | 46 |
47 #if (NGX_THREADS) | 47 #if (NGX_THREADS) |
48 static ngx_mutex_t *ngx_kqueue_mutex; | 48 static ngx_mutex_t *list_mutex; |
49 static ngx_mutex_t *kevent_mutex; | |
49 #endif | 50 #endif |
50 | 51 |
51 | 52 |
52 | 53 |
53 static ngx_str_t kqueue_name = ngx_string("kqueue"); | 54 static ngx_str_t kqueue_name = ngx_string("kqueue"); |
118 "kqueue() failed"); | 119 "kqueue() failed"); |
119 return NGX_ERROR; | 120 return NGX_ERROR; |
120 } | 121 } |
121 | 122 |
122 #if (NGX_THREADS) | 123 #if (NGX_THREADS) |
123 if (!(ngx_kqueue_mutex = ngx_mutex_init(cycle->log, 0))) { | 124 |
124 return NGX_ERROR; | 125 if (!(list_mutex = ngx_mutex_init(cycle->log, 0))) { |
125 } | 126 return NGX_ERROR; |
127 } | |
128 | |
129 if (!(kevent_mutex = ngx_mutex_init(cycle->log, 0))) { | |
130 return NGX_ERROR; | |
131 } | |
132 | |
126 #endif | 133 #endif |
127 } | 134 } |
128 | 135 |
129 if (max_changes < kcf->changes) { | 136 if (max_changes < kcf->changes) { |
130 if (nchanges) { | 137 if (nchanges) { |
204 } | 211 } |
205 | 212 |
206 ngx_kqueue = -1; | 213 ngx_kqueue = -1; |
207 | 214 |
208 #if (NGX_THREADS) | 215 #if (NGX_THREADS) |
209 ngx_mutex_destroy(ngx_kqueue_mutex); | 216 ngx_mutex_destroy(kevent_mutex); |
217 ngx_mutex_destroy(list_mutex); | |
210 #endif | 218 #endif |
211 | 219 |
212 ngx_free(change_list1); | 220 ngx_free(change_list1); |
213 ngx_free(change_list0); | 221 ngx_free(change_list0); |
214 ngx_free(event_list); | 222 ngx_free(event_list); |
231 | 239 |
232 ev->active = 1; | 240 ev->active = 1; |
233 ev->disabled = 0; | 241 ev->disabled = 0; |
234 ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1 : 0; | 242 ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1 : 0; |
235 | 243 |
236 if (ngx_mutex_lock(ngx_kqueue_mutex) == NGX_ERROR) { | 244 if (ngx_mutex_lock(list_mutex) == NGX_ERROR) { |
237 return NGX_ERROR; | 245 return NGX_ERROR; |
238 } | 246 } |
239 | 247 |
240 if (nchanges > 0 | 248 if (nchanges > 0 |
241 && ev->index < (u_int) nchanges | 249 && ev->index < (u_int) nchanges |
257 e = (ngx_event_t *) change_list[nchanges].udata; | 265 e = (ngx_event_t *) change_list[nchanges].udata; |
258 change_list[ev->index] = change_list[nchanges]; | 266 change_list[ev->index] = change_list[nchanges]; |
259 e->index = ev->index; | 267 e->index = ev->index; |
260 } | 268 } |
261 | 269 |
262 ngx_mutex_unlock(ngx_kqueue_mutex); | 270 ngx_mutex_unlock(list_mutex); |
263 | 271 |
264 return NGX_OK; | 272 return NGX_OK; |
265 } | 273 } |
266 | 274 |
267 c = ev->data; | 275 c = ev->data; |
268 | 276 |
269 ngx_log_error(NGX_LOG_ALERT, ev->log, 0, | 277 ngx_log_error(NGX_LOG_ALERT, ev->log, 0, |
270 "previous event on #%d were not passed in kernel", c->fd); | 278 "previous event on #%d were not passed in kernel", c->fd); |
271 | 279 |
272 ngx_mutex_unlock(ngx_kqueue_mutex); | 280 ngx_mutex_unlock(list_mutex); |
273 | 281 |
274 return NGX_ERROR; | 282 return NGX_ERROR; |
275 } | 283 } |
276 | 284 |
277 rc = ngx_kqueue_set_event(ev, event, EV_ADD|EV_ENABLE|flags); | 285 rc = ngx_kqueue_set_event(ev, event, EV_ADD|EV_ENABLE|flags); |
278 | 286 |
279 ngx_mutex_unlock(ngx_kqueue_mutex); | 287 ngx_mutex_unlock(list_mutex); |
280 | 288 |
281 return rc; | 289 return rc; |
282 } | 290 } |
283 | 291 |
284 | 292 |
288 ngx_event_t *e; | 296 ngx_event_t *e; |
289 | 297 |
290 ev->active = 0; | 298 ev->active = 0; |
291 ev->disabled = 0; | 299 ev->disabled = 0; |
292 | 300 |
293 if (ngx_mutex_lock(ngx_kqueue_mutex) == NGX_ERROR) { | 301 if (ngx_mutex_lock(list_mutex) == NGX_ERROR) { |
294 return NGX_ERROR; | 302 return NGX_ERROR; |
295 } | 303 } |
296 | 304 |
297 if (nchanges > 0 | 305 if (nchanges > 0 |
298 && ev->index < (u_int) nchanges | 306 && ev->index < (u_int) nchanges |
309 e = (ngx_event_t *) change_list[nchanges].udata; | 317 e = (ngx_event_t *) change_list[nchanges].udata; |
310 change_list[ev->index] = change_list[nchanges]; | 318 change_list[ev->index] = change_list[nchanges]; |
311 e->index = ev->index; | 319 e->index = ev->index; |
312 } | 320 } |
313 | 321 |
314 ngx_mutex_unlock(ngx_kqueue_mutex); | 322 ngx_mutex_unlock(list_mutex); |
315 | 323 |
316 return NGX_OK; | 324 return NGX_OK; |
317 } | 325 } |
318 | 326 |
319 /* | 327 /* |
321 * its filters so we do not need to delete explicity the event | 329 * its filters so we do not need to delete explicity the event |
322 * before the closing the file descriptor. | 330 * before the closing the file descriptor. |
323 */ | 331 */ |
324 | 332 |
325 if (flags & NGX_CLOSE_EVENT) { | 333 if (flags & NGX_CLOSE_EVENT) { |
326 ngx_mutex_unlock(ngx_kqueue_mutex); | 334 ngx_mutex_unlock(list_mutex); |
327 return NGX_OK; | 335 return NGX_OK; |
328 } | 336 } |
329 | 337 |
330 if (flags & NGX_DISABLE_EVENT) { | 338 if (flags & NGX_DISABLE_EVENT) { |
331 ev->disabled = 1; | 339 ev->disabled = 1; |
332 } | 340 } |
333 | 341 |
334 rc = ngx_kqueue_set_event(ev, event, | 342 rc = ngx_kqueue_set_event(ev, event, |
335 flags & NGX_DISABLE_EVENT ? EV_DISABLE : EV_DELETE); | 343 flags & NGX_DISABLE_EVENT ? EV_DISABLE : EV_DELETE); |
336 | 344 |
337 ngx_mutex_unlock(ngx_kqueue_mutex); | 345 ngx_mutex_unlock(list_mutex); |
338 | 346 |
339 return rc; | 347 return rc; |
340 } | 348 } |
341 | 349 |
342 | 350 |
702 ngx_int_t rc; | 710 ngx_int_t rc; |
703 ngx_err_t err; | 711 ngx_err_t err; |
704 struct timespec ts; | 712 struct timespec ts; |
705 struct kevent *changes; | 713 struct kevent *changes; |
706 | 714 |
707 if (try) { | 715 if (ngx_mutex_lock(kevent_mutex) == NGX_ERROR) { |
708 rc = ngx_mutex_trylock(ngx_kqueue_mutex); | 716 return NGX_ERROR; |
709 if (rc != NGX_OK) { | 717 } |
710 return rc; | 718 |
711 } | 719 if (ngx_mutex_lock(list_mutex) == NGX_ERROR) { |
712 | 720 ngx_mutex_unlock(kevent_mutex); |
713 } else { | 721 return NGX_ERROR; |
714 if (ngx_mutex_lock(ngx_kqueue_mutex) == NGX_ERROR) { | |
715 return NGX_ERROR; | |
716 } | |
717 } | 722 } |
718 | 723 |
719 if (nchanges == 0) { | 724 if (nchanges == 0) { |
720 ngx_mutex_unlock(ngx_kqueue_mutex); | 725 ngx_mutex_unlock(list_mutex); |
726 ngx_mutex_unlock(kevent_mutex); | |
721 return NGX_OK; | 727 return NGX_OK; |
722 } | 728 } |
723 | 729 |
724 changes = (struct kevent *) change_list; | 730 changes = change_list; |
725 if (change_list == change_list0) { | 731 if (change_list == change_list0) { |
726 change_list = change_list1; | 732 change_list = change_list1; |
727 } else { | 733 } else { |
728 change_list = change_list0; | 734 change_list = change_list0; |
729 } | 735 } |
730 | 736 |
731 n = nchanges; | 737 n = nchanges; |
732 nchanges = 0; | 738 nchanges = 0; |
739 | |
740 ngx_mutex_unlock(list_mutex); | |
733 | 741 |
734 ts.tv_sec = 0; | 742 ts.tv_sec = 0; |
735 ts.tv_nsec = 0; | 743 ts.tv_nsec = 0; |
736 | 744 |
737 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, | 745 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, |
745 | 753 |
746 } else { | 754 } else { |
747 rc = NGX_OK; | 755 rc = NGX_OK; |
748 } | 756 } |
749 | 757 |
750 ngx_mutex_unlock(ngx_kqueue_mutex); | 758 ngx_mutex_unlock(kevent_mutex); |
751 | 759 |
752 return rc; | 760 return rc; |
753 } | 761 } |
754 | 762 |
755 | 763 |