Return to ngx_event_posted.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / event

Annotation of embedaddon/nginx/src/event/ngx_event_posted.c, revision 1.1.1.1

1.1       misho       1: 
                      2: /*
                      3:  * Copyright (C) Igor Sysoev
                      4:  * Copyright (C) Nginx, Inc.
                      5:  */
                      6: 
                      7: 
                      8: #include <ngx_config.h>
                      9: #include <ngx_core.h>
                     10: #include <ngx_event.h>
                     11: 
                     12: 
                     13: ngx_thread_volatile ngx_event_t  *ngx_posted_accept_events;
                     14: ngx_thread_volatile ngx_event_t  *ngx_posted_events;
                     15: 
                     16: #if (NGX_THREADS)
                     17: ngx_mutex_t                      *ngx_posted_events_mutex;
                     18: #endif
                     19: 
                     20: 
                     21: void
                     22: ngx_event_process_posted(ngx_cycle_t *cycle,
                     23:     ngx_thread_volatile ngx_event_t **posted)
                     24: {
                     25:     ngx_event_t  *ev;
                     26: 
                     27:     for ( ;; ) {
                     28: 
                     29:         ev = (ngx_event_t *) *posted;
                     30: 
                     31:         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                     32:                       "posted event %p", ev);
                     33: 
                     34:         if (ev == NULL) {
                     35:             return;
                     36:         }
                     37: 
                     38:         ngx_delete_posted_event(ev);
                     39: 
                     40:         ev->handler(ev);
                     41:     }
                     42: }
                     43: 
                     44: 
                     45: #if (NGX_THREADS) && !(NGX_WIN32)
                     46: 
                     47: void
                     48: ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
                     49: {
                     50:     ngx_int_t     i;
                     51: #if 0
                     52:     ngx_uint_t    busy;
                     53:     ngx_event_t  *ev;
                     54: 
                     55:     busy = 1;
                     56: 
                     57:     if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
                     58:         return;
                     59:     }
                     60: 
                     61:     for (ev = (ngx_event_t *) ngx_posted_events; ev; ev = ev->next) {
                     62:         if (*(ev->lock) == 0) {
                     63:             busy = 0;
                     64:             break;
                     65:         }
                     66:     }
                     67: 
                     68:     ngx_mutex_unlock(ngx_posted_events_mutex);
                     69: 
                     70:     if (busy) {
                     71:         return;
                     72:     }
                     73: #endif
                     74: 
                     75:     for (i = 0; i < ngx_threads_n; i++) {
                     76:         if (ngx_threads[i].state == NGX_THREAD_FREE) {
                     77:             ngx_cond_signal(ngx_threads[i].cv);
                     78:             return;
                     79:         }
                     80:     }
                     81: }
                     82: 
                     83: 
                     84: ngx_int_t
                     85: ngx_event_thread_process_posted(ngx_cycle_t *cycle)
                     86: {
                     87:     ngx_event_t  *ev;
                     88: 
                     89:     for ( ;; ) {
                     90: 
                     91:         ev = (ngx_event_t *) ngx_posted_events;
                     92: 
                     93:         for ( ;; ) {
                     94: 
                     95:             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                     96:                           "posted event %p", ev);
                     97: 
                     98:             if (ev == NULL) {
                     99:                 return NGX_OK;
                    100:             }
                    101: 
                    102:             if (ngx_trylock(ev->lock) == 0) {
                    103: 
                    104:                 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                    105:                                "posted event %p is busy", ev);
                    106: 
                    107:                 ev = ev->next;
                    108:                 continue;
                    109:             }
                    110: 
                    111:             if (ev->lock != ev->own_lock) {
                    112:                 if (*(ev->own_lock)) {
                    113:                     ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
                    114:                              "the own lock of the posted event %p is busy", ev);
                    115:                     ngx_unlock(ev->lock);
                    116:                     ev = ev->next;
                    117:                     continue;
                    118:                 }
                    119:                 *(ev->own_lock) = 1;
                    120:             }
                    121: 
                    122:             ngx_delete_posted_event(ev);
                    123: 
                    124:             ev->locked = 1;
                    125: 
                    126:             ev->ready |= ev->posted_ready;
                    127:             ev->timedout |= ev->posted_timedout;
                    128:             ev->pending_eof |= ev->posted_eof;
                    129: #if (NGX_HAVE_KQUEUE)
                    130:             ev->kq_errno |= ev->posted_errno;
                    131: #endif
                    132:             if (ev->posted_available) {
                    133:                 ev->available = ev->posted_available;
                    134:             }
                    135: 
                    136:             ev->posted_ready = 0;
                    137:             ev->posted_timedout = 0;
                    138:             ev->posted_eof = 0;
                    139: #if (NGX_HAVE_KQUEUE)
                    140:             ev->posted_errno = 0;
                    141: #endif
                    142:             ev->posted_available = 0;
                    143: 
                    144:             ngx_mutex_unlock(ngx_posted_events_mutex);
                    145: 
                    146:             ev->handler(ev);
                    147: 
                    148:             ngx_mutex_lock(ngx_posted_events_mutex);
                    149: 
                    150:             if (ev->locked) {
                    151:                 ngx_unlock(ev->lock);
                    152: 
                    153:                 if (ev->lock != ev->own_lock) {
                    154:                     ngx_unlock(ev->own_lock);
                    155:                 }
                    156:             }
                    157: 
                    158:             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                    159:                            "posted event %p is done", ev);
                    160: 
                    161:             break;
                    162:         }
                    163:     }
                    164: }
                    165: 
                    166: #else
                    167: 
                    168: void
                    169: ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
                    170: {
                    171: }
                    172: 
                    173: #endif