Mercurial > hg > nginx-quic

comparison src/event/modules/ngx_kqueue_module.c @ 385:79050a10aacb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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