release/src/router/nginx/src/event/ngx_event_posted.c

   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