| |
| /* |
| * Copyright (C) Igor Sysoev |
| */ |
| |
| |
| #include <ngx_config.h> |
| #include <ngx_core.h> |
| #include <ngx_http.h> |
| |
| |
| |
| static int ngx_http_busy_lock_look_cacheable(ngx_http_busy_lock_t *bl, |
| ngx_http_busy_lock_ctx_t *bc, |
| int lock); |
| |
| |
| int ngx_http_busy_lock(ngx_http_busy_lock_t *bl, ngx_http_busy_lock_ctx_t *bc) |
| { |
| if (bl->busy < bl->max_busy) { |
| bl->busy++; |
| |
| if (bc->time) { |
| bc->time = 0; |
| bl->waiting--; |
| } |
| |
| return NGX_OK; |
| } |
| |
| if (bc->time) { |
| if (bc->time < bl->timeout) { |
| ngx_add_timer(bc->event, 1000); |
| return NGX_AGAIN; |
| } |
| |
| bl->waiting--; |
| return NGX_DONE; |
| |
| } |
| |
| if (bl->timeout == 0) { |
| return NGX_DONE; |
| } |
| |
| if (bl->waiting < bl->max_waiting) { |
| bl->waiting++; |
| |
| #if 0 |
| ngx_add_timer(bc->event, 1000); |
| bc->event->event_handler = bc->event_handler; |
| #endif |
| |
| /* TODO: ngx_handle_level_read_event() */ |
| |
| return NGX_AGAIN; |
| } |
| |
| return NGX_ERROR; |
| } |
| |
| |
| int ngx_http_busy_lock_cacheable(ngx_http_busy_lock_t *bl, |
| ngx_http_busy_lock_ctx_t *bc, int lock) |
| { |
| int rc; |
| |
| rc = ngx_http_busy_lock_look_cacheable(bl, bc, lock); |
| |
| ngx_log_debug3(NGX_LOG_DEBUG_HTTP, bc->event->log, 0, |
| "http busylock: %d w:%d mw::%d", |
| rc, bl->waiting, bl->max_waiting); |
| |
| if (rc == NGX_OK) { /* no the same request, there's free slot */ |
| return NGX_OK; |
| } |
| |
| if (rc == NGX_ERROR && !lock) { /* no the same request, no free slot */ |
| return NGX_OK; |
| } |
| |
| /* rc == NGX_AGAIN: the same request */ |
| |
| if (bc->time) { |
| if (bc->time < bl->timeout) { |
| ngx_add_timer(bc->event, 1000); |
| return NGX_AGAIN; |
| } |
| |
| bl->waiting--; |
| return NGX_DONE; |
| |
| } |
| |
| if (bl->timeout == 0) { |
| return NGX_DONE; |
| } |
| |
| if (bl->waiting < bl->max_waiting) { |
| #if 0 |
| bl->waiting++; |
| ngx_add_timer(bc->event, 1000); |
| bc->event->event_handler = bc->event_handler; |
| #endif |
| |
| /* TODO: ngx_handle_level_read_event() */ |
| |
| return NGX_AGAIN; |
| } |
| |
| return NGX_ERROR; |
| } |
| |
| |
| void ngx_http_busy_unlock(ngx_http_busy_lock_t *bl, |
| ngx_http_busy_lock_ctx_t *bc) |
| { |
| if (bl == NULL) { |
| return; |
| } |
| |
| if (bl->md5) { |
| bl->md5_mask[bc->slot / 8] &= ~(1 << (bc->slot & 7)); |
| bl->cacheable--; |
| } |
| |
| bl->busy--; |
| } |
| |
| |
| static int ngx_http_busy_lock_look_cacheable(ngx_http_busy_lock_t *bl, |
| ngx_http_busy_lock_ctx_t *bc, |
| int lock) |
| { |
| int i, b, cacheable, free; |
| u_int mask; |
| |
| b = 0; |
| cacheable = 0; |
| free = -1; |
| |
| #if (NGX_SUPPRESS_WARN) |
| mask = 0; |
| #endif |
| |
| for (i = 0; i < bl->max_busy; i++) { |
| |
| if ((b & 7) == 0) { |
| mask = bl->md5_mask[i / 8]; |
| } |
| |
| if (mask & 1) { |
| if (ngx_memcmp(&bl->md5[i * 16], bc->md5, 16) == 0) { |
| return NGX_AGAIN; |
| } |
| cacheable++; |
| |
| } else if (free == -1) { |
| free = i; |
| } |
| |
| #if 1 |
| if (cacheable == bl->cacheable) { |
| if (free == -1 && cacheable < bl->max_busy) { |
| free = i + 1; |
| } |
| |
| break; |
| } |
| #endif |
| |
| mask >>= 1; |
| b++; |
| } |
| |
| if (free == -1) { |
| return NGX_ERROR; |
| } |
| |
| if (lock) { |
| if (bl->busy == bl->max_busy) { |
| return NGX_ERROR; |
| } |
| |
| ngx_memcpy(&bl->md5[free * 16], bc->md5, 16); |
| bl->md5_mask[free / 8] |= 1 << (free & 7); |
| bc->slot = free; |
| |
| bl->cacheable++; |
| bl->busy++; |
| } |
| |
| return NGX_OK; |
| } |
| |
| |
| char *ngx_http_set_busy_lock_slot(ngx_conf_t *cf, ngx_command_t *cmd, |
| void *conf) |
| { |
| char *p = conf; |
| |
| ngx_uint_t i, dup, invalid; |
| ngx_str_t *value, line; |
| ngx_http_busy_lock_t *bl, **blp; |
| |
| blp = (ngx_http_busy_lock_t **) (p + cmd->offset); |
| if (*blp) { |
| return "is duplicate"; |
| } |
| |
| /* ngx_calloc_shared() */ |
| bl = ngx_pcalloc(cf->pool, sizeof(ngx_http_busy_lock_t)); |
| if (bl == NULL) { |
| return NGX_CONF_ERROR; |
| } |
| *blp = bl; |
| |
| /* ngx_calloc_shared() */ |
| bl->mutex = ngx_pcalloc(cf->pool, sizeof(ngx_event_mutex_t)); |
| if (bl->mutex == NULL) { |
| return NGX_CONF_ERROR; |
| } |
| |
| dup = 0; |
| invalid = 0; |
| value = cf->args->elts; |
| |
| for (i = 1; i < cf->args->nelts; i++) { |
| |
| if (value[i].data[1] != '=') { |
| ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, |
| "invalid value \"%s\"", value[i].data); |
| return NGX_CONF_ERROR; |
| } |
| |
| switch (value[i].data[0]) { |
| |
| case 'b': |
| if (bl->max_busy) { |
| dup = 1; |
| break; |
| } |
| |
| bl->max_busy = ngx_atoi(value[i].data + 2, value[i].len - 2); |
| if (bl->max_busy == NGX_ERROR) { |
| invalid = 1; |
| break; |
| } |
| |
| continue; |
| |
| case 'w': |
| if (bl->max_waiting) { |
| dup = 1; |
| break; |
| } |
| |
| bl->max_waiting = ngx_atoi(value[i].data + 2, value[i].len - 2); |
| if (bl->max_waiting == NGX_ERROR) { |
| invalid = 1; |
| break; |
| } |
| |
| continue; |
| |
| case 't': |
| if (bl->timeout) { |
| dup = 1; |
| break; |
| } |
| |
| line.len = value[i].len - 2; |
| line.data = value[i].data + 2; |
| |
| bl->timeout = ngx_parse_time(&line, 1); |
| if (bl->timeout == NGX_ERROR) { |
| invalid = 1; |
| break; |
| } |
| |
| continue; |
| |
| default: |
| invalid = 1; |
| } |
| |
| if (dup) { |
| ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, |
| "duplicate value \"%s\"", value[i].data); |
| return NGX_CONF_ERROR; |
| } |
| |
| if (invalid) { |
| ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, |
| "invalid value \"%s\"", value[i].data); |
| return NGX_CONF_ERROR; |
| } |
| } |
| |
| if (bl->timeout == 0 && bl->max_waiting) { |
| ngx_conf_log_error(NGX_LOG_WARN, cf, 0, |
| "busy lock waiting is useless with zero timeout, ignoring"); |
| } |
| |
| return NGX_CONF_OK; |
| } |