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     ! 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