diff --git a/config b/config index 74b5366d..aa10e9b2 100644 --- a/config +++ b/config @@ -452,7 +452,6 @@ ngx_feature_test='struct sigaction act; if [ $PCRE != NO -a $PCRE != YES ]; then # force pcre_version symbol to be undefined when PCRE is statically linked - ngx_feature="force undefined symbols (--undefined)" ngx_feature_libs="-Wl,--undefined=printf" ngx_feature_name= @@ -466,6 +465,21 @@ if [ $PCRE != NO -a $PCRE != YES ]; then if [ $ngx_found = yes ]; then CORE_LIBS="$CORE_LIBS -Wl,--undefined=pcre_version" fi + + # for LLVM ld (Darwin) + ngx_feature="force undefined symbols (-all_load -U)" + ngx_feature_libs="-all_load -U printf" + ngx_feature_name= + ngx_feature_run=no + ngx_feature_incs="#include " + ngx_feature_path= + ngx_feature_test='printf("hello");' + + . auto/feature + + if [ $ngx_found = yes ]; then + CORE_LIBS="$CORE_LIBS -all_load -U pcre_version" + fi fi #CFLAGS=$"$CFLAGS -DLUA_DEFAULT_PATH='\"/usr/local/openresty/lualib/?.lua\"'" diff --git a/src/ngx_stream_lua_shdict.c b/src/ngx_stream_lua_shdict.c index e1029561..b4762cf9 100644 --- a/src/ngx_stream_lua_shdict.c +++ b/src/ngx_stream_lua_shdict.c @@ -24,7 +24,9 @@ static int ngx_stream_lua_shdict_set(lua_State *L); +static int ngx_stream_lua_shdict_set_when(lua_State *L); static int ngx_stream_lua_shdict_safe_set(lua_State *L); +static int ngx_stream_lua_shdict_safe_set_when(lua_State *L); static int ngx_stream_lua_shdict_get(lua_State *L); static int ngx_stream_lua_shdict_get_stale(lua_State *L); static int ngx_stream_lua_shdict_get_helper(lua_State *L, int get_stale); @@ -34,6 +36,7 @@ static ngx_int_t ngx_stream_lua_shdict_lookup(ngx_shm_zone_t *shm_zone, ngx_uint_t hash, u_char *kdata, size_t klen, ngx_stream_lua_shdict_node_t **sdp); static int ngx_stream_lua_shdict_set_helper(lua_State *L, int flags); +static int ngx_stream_lua_shdict_set_when_helper(lua_State *L, int flags); static int ngx_stream_lua_shdict_add(lua_State *L); static int ngx_stream_lua_shdict_safe_add(lua_State *L); static int ngx_stream_lua_shdict_replace(lua_State *L); @@ -357,9 +360,15 @@ ngx_stream_lua_inject_shdict_api(ngx_stream_lua_main_conf_t *lmcf, lua_State *L) lua_pushcfunction(L, ngx_stream_lua_shdict_set); lua_setfield(L, -2, "set"); + lua_pushcfunction(L, ngx_stream_lua_shdict_set_when); + lua_setfield(L, -2, "set_when"); + lua_pushcfunction(L, ngx_stream_lua_shdict_safe_set); lua_setfield(L, -2, "safe_set"); + lua_pushcfunction(L, ngx_stream_lua_shdict_safe_set_when); + lua_setfield(L, -2, "safe_set_when"); + lua_pushcfunction(L, ngx_stream_lua_shdict_add); lua_setfield(L, -2, "add"); @@ -1280,21 +1289,40 @@ ngx_stream_lua_shdict_set_helper(lua_State *L, int flags) static int -ngx_stream_lua_shdict_incr(lua_State *L) +ngx_stream_lua_shdict_set_when(lua_State *L) +{ + return ngx_stream_lua_shdict_set_when_helper(L, 0); +} + + +static int +ngx_stream_lua_shdict_safe_set_when(lua_State *L) +{ + return ngx_stream_lua_shdict_set_when_helper(L, + NGX_STREAM_LUA_SHDICT_SAFE_STORE); +} + + +static int +ngx_stream_lua_shdict_set_when_helper(lua_State *L, int flags) { int i, n; ngx_str_t key; uint32_t hash; ngx_int_t rc; - double num; - double init = 0; + ngx_str_t old_value, value; + int old_value_type, value_type; + double old_num, num; + u_char old_c, c; + lua_Number exptime = 0; u_char *p; - ngx_shm_zone_t *zone; - double value; ngx_rbtree_node_t *node; + ngx_time_t *tp; + ngx_shm_zone_t *zone; + int forcible = 0; /* indicates whether to foricibly override other * valid entries */ - int forcible = 0; + int32_t user_flags = 0; ngx_queue_t *queue, *q; ngx_stream_lua_shdict_ctx_t *ctx; @@ -1302,8 +1330,9 @@ ngx_stream_lua_shdict_incr(lua_State *L) n = lua_gettop(L); - if (n != 3 && n != 4) { - return luaL_error(L, "expecting 3 or 4 arguments, but only seen %d", n); + if (n != 4 && n != 5 && n != 6) { + return luaL_error(L, "expecting 4, 5 or 6 arguments, " + "but only seen %d", n); } if (lua_type(L, 1) != LUA_TTABLE) { @@ -1312,7 +1341,7 @@ ngx_stream_lua_shdict_incr(lua_State *L) zone = ngx_stream_lua_shdict_get_zone(L, 1); if (zone == NULL) { - return luaL_error(L, "bad user data for the ngx_shm_zone_t pointer"); + return luaL_error(L, "bad \"zone\" argument"); } ctx = zone->data; @@ -1339,14 +1368,82 @@ ngx_stream_lua_shdict_incr(lua_State *L) hash = ngx_crc32_short(key.data, key.len); - value = luaL_checknumber(L, 3); + old_value_type = lua_type(L, 3); - if (n == 4) { - init = luaL_checknumber(L, 4); + switch (old_value_type) { + + case SHDICT_TSTRING: + old_value.data = (u_char *) lua_tolstring(L, 3, &old_value.len); + break; + + case SHDICT_TNUMBER: + old_value.len = sizeof(double); + old_num = lua_tonumber(L, 3); + old_value.data = (u_char *) &old_num; + break; + + case SHDICT_TBOOLEAN: + old_value.len = sizeof(u_char); + old_c = lua_toboolean(L, 3) ? 1 : 0; + old_value.data = &old_c; + break; + + case LUA_TNIL: + ngx_str_null(&old_value); + break; + + default: + lua_pushnil(L); + lua_pushliteral(L, "bad old_value type"); + return 2; } - dd("looking up key %.*s in shared dict %.*s", (int) key.len, key.data, - (int) ctx->name.len, ctx->name.data); + value_type = lua_type(L, 4); + + switch (value_type) { + + case SHDICT_TSTRING: + value.data = (u_char *) lua_tolstring(L, 4, &value.len); + break; + + case SHDICT_TNUMBER: + value.len = sizeof(double); + num = lua_tonumber(L, 4); + value.data = (u_char *) # + break; + + case SHDICT_TBOOLEAN: + value.len = sizeof(u_char); + c = lua_toboolean(L, 4) ? 1 : 0; + value.data = &c; + break; + + case LUA_TNIL: + if (flags & (NGX_STREAM_LUA_SHDICT_ADD|NGX_STREAM_LUA_SHDICT_REPLACE)) { + lua_pushnil(L); + lua_pushliteral(L, "attempt to add or replace nil values"); + return 2; + } + + ngx_str_null(&value); + break; + + default: + lua_pushnil(L); + lua_pushliteral(L, "bad value type"); + return 2; + } + + if (n >= 5) { + exptime = luaL_checknumber(L, 5); + if (exptime < 0) { + return luaL_error(L, "bad \"exptime\" argument"); + } + } + + if (n == 6) { + user_flags = (uint32_t) luaL_checkinteger(L, 6); + } ngx_shmtx_lock(&ctx->shpool->mutex); @@ -1358,135 +1455,449 @@ ngx_stream_lua_shdict_incr(lua_State *L) dd("shdict lookup returned %d", (int) rc); - if (rc == NGX_DECLINED || rc == NGX_DONE) { + if (flags & NGX_STREAM_LUA_SHDICT_REPLACE) { - if (n == 3) { + if (rc == NGX_DECLINED || rc == NGX_DONE) { ngx_shmtx_unlock(&ctx->shpool->mutex); - lua_pushnil(L); + lua_pushboolean(L, 0); lua_pushliteral(L, "not found"); - return 2; + lua_pushboolean(L, forcible); + return 3; } - /* add value */ - num = value + init; + /* rc == NGX_OK */ - if (rc == NGX_DONE) { + goto replace; + } - /* found an expired item */ + if (flags & NGX_STREAM_LUA_SHDICT_ADD) { - if ((size_t) sd->value_len == sizeof(double) - && sd->value_type != SHDICT_TLIST) - { - ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0, - "lua shared dict incr: found old entry and " - "value size matched, reusing it"); + if (rc == NGX_OK) { + ngx_shmtx_unlock(&ctx->shpool->mutex); - ngx_queue_remove(&sd->queue); - ngx_queue_insert_head(&ctx->sh->lru_queue, &sd->queue); + lua_pushboolean(L, 0); + lua_pushliteral(L, "exists"); + lua_pushboolean(L, forcible); + return 3; + } - dd("go to setvalue"); - goto setvalue; - } + if (rc == NGX_DONE) { + /* exists but expired */ - dd("go to remove"); - goto remove; + dd("go to replace"); + goto replace; } + /* rc == NGX_DECLINED */ + dd("go to insert"); goto insert; } - /* rc == NGX_OK */ + if (rc == NGX_OK || rc == NGX_DONE) { - if (sd->value_type != SHDICT_TNUMBER || sd->value_len != sizeof(double)) { - ngx_shmtx_unlock(&ctx->shpool->mutex); + if (sd->value_type != old_value_type + || (size_t) sd->value_len != old_value.len + || memcmp(sd->data + sd->key_len, old_value.data, sd->value_len) != 0) + { + ngx_shmtx_unlock(&ctx->shpool->mutex); - lua_pushnil(L); - lua_pushliteral(L, "not a number"); - return 2; - } + lua_pushboolean(L, 0); + lua_pushliteral(L, "already modified"); + lua_pushboolean(L, forcible); + return 3; + } - ngx_queue_remove(&sd->queue); - ngx_queue_insert_head(&ctx->sh->lru_queue, &sd->queue); + if (value_type == LUA_TNIL) { + goto remove; + } - dd("setting value type to %d", (int) sd->value_type); +replace: - p = sd->data + key.len; + if (value.data + && value.len == (size_t) sd->value_len + && sd->value_type != SHDICT_TLIST) + { - ngx_memcpy(&num, p, sizeof(double)); - num += value; + ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0, + "lua shared dict set: found old entry and value " + "size matched, reusing it"); - ngx_memcpy(p, (double *) &num, sizeof(double)); + ngx_queue_remove(&sd->queue); + ngx_queue_insert_head(&ctx->sh->lru_queue, &sd->queue); - ngx_shmtx_unlock(&ctx->shpool->mutex); + sd->key_len = (u_short) key.len; - lua_pushnumber(L, num); - lua_pushnil(L); - return 2; + if (exptime > 0) { + tp = ngx_timeofday(); + sd->expires = (uint64_t) tp->sec * 1000 + tp->msec + + (uint64_t) (exptime * 1000); -remove: + } else { + sd->expires = 0; + } - ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0, - "lua shared dict incr: found old entry but value size " - "NOT matched, removing it first"); + sd->user_flags = user_flags; - if (sd->value_type == SHDICT_TLIST) { - queue = ngx_stream_lua_shdict_get_list_head(sd, key.len); + sd->value_len = (uint32_t) value.len; - for (q = ngx_queue_head(queue); - q != ngx_queue_sentinel(queue); - q = ngx_queue_next(q)) - { - p = (u_char *) ngx_queue_data(q, - ngx_stream_lua_shdict_list_node_t, - queue); + dd("setting value type to %d", value_type); - ngx_slab_free_locked(ctx->shpool, p); - } - } + sd->value_type = (uint8_t) value_type; - ngx_queue_remove(&sd->queue); + p = ngx_copy(sd->data, key.data, key.len); + ngx_memcpy(p, value.data, value.len); - node = (ngx_rbtree_node_t *) - ((u_char *) sd - offsetof(ngx_rbtree_node_t, color)); + ngx_shmtx_unlock(&ctx->shpool->mutex); - ngx_rbtree_delete(&ctx->sh->rbtree, node); + lua_pushboolean(L, 1); + lua_pushnil(L); + lua_pushboolean(L, forcible); + return 3; + } - ngx_slab_free_locked(ctx->shpool, node); + ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0, + "lua shared dict set: found old entry but value size " + "NOT matched, removing it first"); -insert: +remove: - ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0, - "lua shared dict incr: creating a new entry"); + if (sd->value_type == SHDICT_TLIST) { + queue = ngx_stream_lua_shdict_get_list_head(sd, key.len); - n = offsetof(ngx_rbtree_node_t, color) - + offsetof(ngx_stream_lua_shdict_node_t, data) - + key.len - + sizeof(double); + for (q = ngx_queue_head(queue); + q != ngx_queue_sentinel(queue); + q = ngx_queue_next(q)) + { + p = (u_char *) ngx_queue_data(q, + ngx_stream_lua_shdict_list_node_t, + queue); - node = ngx_slab_alloc_locked(ctx->shpool, n); + ngx_slab_free_locked(ctx->shpool, p); + } + } - if (node == NULL) { + ngx_queue_remove(&sd->queue); - ngx_log_debug1(NGX_LOG_DEBUG_STREAM, ctx->log, 0, - "lua shared dict incr: overriding non-expired items " - "due to memory shortage for entry \"%V\"", &key); + node = (ngx_rbtree_node_t *) + ((u_char *) sd - offsetof(ngx_rbtree_node_t, color)); - for (i = 0; i < 30; i++) { - if (ngx_stream_lua_shdict_expire(ctx, 0) == 0) { - break; - } + ngx_rbtree_delete(&ctx->sh->rbtree, node); - forcible = 1; + ngx_slab_free_locked(ctx->shpool, node); - node = ngx_slab_alloc_locked(ctx->shpool, n); - if (node != NULL) { - goto allocated; - } - } + } - ngx_shmtx_unlock(&ctx->shpool->mutex); +insert: + + /* rc == NGX_DECLINED or value size unmatch */ + + if (value.data == NULL) { + ngx_shmtx_unlock(&ctx->shpool->mutex); + + lua_pushboolean(L, 1); + lua_pushnil(L); + lua_pushboolean(L, 0); + return 3; + } + + ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0, + "lua shared dict set: creating a new entry"); + + n = offsetof(ngx_rbtree_node_t, color) + + offsetof(ngx_stream_lua_shdict_node_t, data) + + key.len + + value.len; + + dd("overhead = %d", (int) (offsetof(ngx_rbtree_node_t, color) + + offsetof(ngx_stream_lua_shdict_node_t, data))); + + node = ngx_slab_alloc_locked(ctx->shpool, n); + + if (node == NULL) { + + if (flags & NGX_STREAM_LUA_SHDICT_SAFE_STORE) { + ngx_shmtx_unlock(&ctx->shpool->mutex); + + lua_pushboolean(L, 0); + lua_pushliteral(L, "no memory"); + return 2; + } + + ngx_log_debug1(NGX_LOG_DEBUG_STREAM, ctx->log, 0, + "lua shared dict set: overriding non-expired items " + "due to memory shortage for entry \"%V\"", &key); + + for (i = 0; i < 30; i++) { + if (ngx_stream_lua_shdict_expire(ctx, 0) == 0) { + break; + } + + forcible = 1; + + node = ngx_slab_alloc_locked(ctx->shpool, n); + if (node != NULL) { + goto allocated; + } + } + + ngx_shmtx_unlock(&ctx->shpool->mutex); + + lua_pushboolean(L, 0); + lua_pushliteral(L, "no memory"); + lua_pushboolean(L, forcible); + return 3; + } + +allocated: + + sd = (ngx_stream_lua_shdict_node_t *) &node->color; + + node->key = hash; + sd->key_len = (u_short) key.len; + + if (exptime > 0) { + tp = ngx_timeofday(); + sd->expires = (uint64_t) tp->sec * 1000 + tp->msec + + (uint64_t) (exptime * 1000); + + } else { + sd->expires = 0; + } + + sd->user_flags = user_flags; + + sd->value_len = (uint32_t) value.len; + + dd("setting value type to %d", value_type); + + sd->value_type = (uint8_t) value_type; + + p = ngx_copy(sd->data, key.data, key.len); + ngx_memcpy(p, value.data, value.len); + + ngx_rbtree_insert(&ctx->sh->rbtree, node); + + ngx_queue_insert_head(&ctx->sh->lru_queue, &sd->queue); + + ngx_shmtx_unlock(&ctx->shpool->mutex); + + lua_pushboolean(L, 1); + lua_pushnil(L); + lua_pushboolean(L, forcible); + return 3; +} + + +static int +ngx_stream_lua_shdict_incr(lua_State *L) +{ + int i, n; + ngx_str_t key; + uint32_t hash; + ngx_int_t rc; + double num; + double init = 0; + u_char *p; + ngx_shm_zone_t *zone; + double value; + ngx_rbtree_node_t *node; + /* indicates whether to foricibly override other + * valid entries */ + int forcible = 0; + ngx_queue_t *queue, *q; + + ngx_stream_lua_shdict_ctx_t *ctx; + ngx_stream_lua_shdict_node_t *sd; + + n = lua_gettop(L); + + if (n != 3 && n != 4) { + return luaL_error(L, "expecting 3 or 4 arguments, but only seen %d", n); + } + + if (lua_type(L, 1) != LUA_TTABLE) { + return luaL_error(L, "bad \"zone\" argument"); + } + + zone = ngx_stream_lua_shdict_get_zone(L, 1); + if (zone == NULL) { + return luaL_error(L, "bad user data for the ngx_shm_zone_t pointer"); + } + + ctx = zone->data; + + if (lua_isnil(L, 2)) { + lua_pushnil(L); + lua_pushliteral(L, "nil key"); + return 2; + } + + key.data = (u_char *) luaL_checklstring(L, 2, &key.len); + + if (key.len == 0) { + lua_pushnil(L); + lua_pushliteral(L, "empty key"); + return 2; + } + + if (key.len > 65535) { + lua_pushnil(L); + lua_pushliteral(L, "key too long"); + return 2; + } + + hash = ngx_crc32_short(key.data, key.len); + + value = luaL_checknumber(L, 3); + + if (n == 4) { + init = luaL_checknumber(L, 4); + } + + dd("looking up key %.*s in shared dict %.*s", (int) key.len, key.data, + (int) ctx->name.len, ctx->name.data); + + ngx_shmtx_lock(&ctx->shpool->mutex); + +#if 1 + ngx_stream_lua_shdict_expire(ctx, 1); +#endif + + rc = ngx_stream_lua_shdict_lookup(zone, hash, key.data, key.len, &sd); + + dd("shdict lookup returned %d", (int) rc); + + if (rc == NGX_DECLINED || rc == NGX_DONE) { + + if (n == 3) { + ngx_shmtx_unlock(&ctx->shpool->mutex); + + lua_pushnil(L); + lua_pushliteral(L, "not found"); + return 2; + } + + /* add value */ + num = value + init; + + if (rc == NGX_DONE) { + + /* found an expired item */ + + if ((size_t) sd->value_len == sizeof(double) + && sd->value_type != SHDICT_TLIST) + { + ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0, + "lua shared dict incr: found old entry and " + "value size matched, reusing it"); + + ngx_queue_remove(&sd->queue); + ngx_queue_insert_head(&ctx->sh->lru_queue, &sd->queue); + + dd("go to setvalue"); + goto setvalue; + } + + dd("go to remove"); + goto remove; + } + + dd("go to insert"); + goto insert; + } + + /* rc == NGX_OK */ + + if (sd->value_type != SHDICT_TNUMBER || sd->value_len != sizeof(double)) { + ngx_shmtx_unlock(&ctx->shpool->mutex); + + lua_pushnil(L); + lua_pushliteral(L, "not a number"); + return 2; + } + + ngx_queue_remove(&sd->queue); + ngx_queue_insert_head(&ctx->sh->lru_queue, &sd->queue); + + dd("setting value type to %d", (int) sd->value_type); + + p = sd->data + key.len; + + ngx_memcpy(&num, p, sizeof(double)); + num += value; + + ngx_memcpy(p, (double *) &num, sizeof(double)); + + ngx_shmtx_unlock(&ctx->shpool->mutex); + + lua_pushnumber(L, num); + lua_pushnil(L); + return 2; + +remove: + + ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0, + "lua shared dict incr: found old entry but value size " + "NOT matched, removing it first"); + + if (sd->value_type == SHDICT_TLIST) { + queue = ngx_stream_lua_shdict_get_list_head(sd, key.len); + + for (q = ngx_queue_head(queue); + q != ngx_queue_sentinel(queue); + q = ngx_queue_next(q)) + { + p = (u_char *) ngx_queue_data(q, + ngx_stream_lua_shdict_list_node_t, + queue); + + ngx_slab_free_locked(ctx->shpool, p); + } + } + + ngx_queue_remove(&sd->queue); + + node = (ngx_rbtree_node_t *) + ((u_char *) sd - offsetof(ngx_rbtree_node_t, color)); + + ngx_rbtree_delete(&ctx->sh->rbtree, node); + + ngx_slab_free_locked(ctx->shpool, node); + +insert: + + ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0, + "lua shared dict incr: creating a new entry"); + + n = offsetof(ngx_rbtree_node_t, color) + + offsetof(ngx_stream_lua_shdict_node_t, data) + + key.len + + sizeof(double); + + node = ngx_slab_alloc_locked(ctx->shpool, n); + + if (node == NULL) { + + ngx_log_debug1(NGX_LOG_DEBUG_STREAM, ctx->log, 0, + "lua shared dict incr: overriding non-expired items " + "due to memory shortage for entry \"%V\"", &key); + + for (i = 0; i < 30; i++) { + if (ngx_stream_lua_shdict_expire(ctx, 0) == 0) { + break; + } + + forcible = 1; + + node = ngx_slab_alloc_locked(ctx->shpool, n); + if (node != NULL) { + goto allocated; + } + } + + ngx_shmtx_unlock(&ctx->shpool->mutex); lua_pushboolean(L, 0); lua_pushliteral(L, "no memory"); @@ -1886,78 +2297,248 @@ ngx_stream_lua_shdict_push_helper(lua_State *L, int flags) node = (ngx_rbtree_node_t *) ((u_char *) sd - offsetof(ngx_rbtree_node_t, color)); - ngx_rbtree_delete(&ctx->sh->rbtree, node); + ngx_rbtree_delete(&ctx->sh->rbtree, node); + + ngx_slab_free_locked(ctx->shpool, node); + } + + ngx_shmtx_unlock(&ctx->shpool->mutex); + + lua_pushboolean(L, 0); + lua_pushliteral(L, "no memory"); + return 2; + } + + dd("setting list length to %d", sd->value_len + 1); + + sd->value_len = sd->value_len + 1; + + dd("setting list node value length to %d", (int) value.len); + + lnode->value_len = (uint32_t) value.len; + + dd("setting list node value type to %d", value_type); + + lnode->value_type = (uint8_t) value_type; + + ngx_memcpy(lnode->data, value.data, value.len); + + if (flags == NGX_STREAM_LUA_SHDICT_LEFT) { + ngx_queue_insert_head(queue, &lnode->queue); + + } else { + ngx_queue_insert_tail(queue, &lnode->queue); + } + + ngx_shmtx_unlock(&ctx->shpool->mutex); + + lua_pushnumber(L, sd->value_len); + return 1; +} + + +static int +ngx_stream_lua_shdict_lpop(lua_State *L) +{ + return ngx_stream_lua_shdict_pop_helper(L, NGX_STREAM_LUA_SHDICT_LEFT); +} + + +static int +ngx_stream_lua_shdict_rpop(lua_State *L) +{ + return ngx_stream_lua_shdict_pop_helper(L, NGX_STREAM_LUA_SHDICT_RIGHT); +} + + +static int +ngx_stream_lua_shdict_pop_helper(lua_State *L, int flags) +{ + int n; + ngx_str_t name; + ngx_str_t key; + uint32_t hash; + ngx_int_t rc; + ngx_str_t value; + int value_type; + double num; + ngx_rbtree_node_t *node; + ngx_shm_zone_t *zone; + ngx_queue_t *queue; + + ngx_stream_lua_shdict_ctx_t *ctx; + ngx_stream_lua_shdict_node_t *sd; + ngx_stream_lua_shdict_list_node_t *lnode; + + n = lua_gettop(L); + + if (n != 2) { + return luaL_error(L, "expecting 2 arguments, " + "but only seen %d", n); + } + + if (lua_type(L, 1) != LUA_TTABLE) { + return luaL_error(L, "bad \"zone\" argument"); + } + + zone = ngx_stream_lua_shdict_get_zone(L, 1); + if (zone == NULL) { + return luaL_error(L, "bad \"zone\" argument"); + } + + ctx = zone->data; + name = ctx->name; + + if (lua_isnil(L, 2)) { + lua_pushnil(L); + lua_pushliteral(L, "nil key"); + return 2; + } + + key.data = (u_char *) luaL_checklstring(L, 2, &key.len); + + if (key.len == 0) { + lua_pushnil(L); + lua_pushliteral(L, "empty key"); + return 2; + } + + if (key.len > 65535) { + lua_pushnil(L); + lua_pushliteral(L, "key too long"); + return 2; + } + + hash = ngx_crc32_short(key.data, key.len); + + ngx_shmtx_lock(&ctx->shpool->mutex); + +#if 1 + ngx_stream_lua_shdict_expire(ctx, 1); +#endif + + rc = ngx_stream_lua_shdict_lookup(zone, hash, key.data, key.len, &sd); + + dd("shdict lookup returned %d", (int) rc); + + if (rc == NGX_DECLINED || rc == NGX_DONE) { + ngx_shmtx_unlock(&ctx->shpool->mutex); + lua_pushnil(L); + return 1; + } + + /* rc == NGX_OK */ + + if (sd->value_type != SHDICT_TLIST) { + ngx_shmtx_unlock(&ctx->shpool->mutex); + + lua_pushnil(L); + lua_pushliteral(L, "value not a list"); + return 2; + } + + if (sd->value_len <= 0) { + ngx_shmtx_unlock(&ctx->shpool->mutex); + + return luaL_error(L, "bad lua list length found for key %s " + "in shared_dict %s: %lu", key.data, name.data, + (unsigned long) sd->value_len); + } + + queue = ngx_stream_lua_shdict_get_list_head(sd, key.len); + + if (flags == NGX_STREAM_LUA_SHDICT_LEFT) { + queue = ngx_queue_head(queue); + + } else { + queue = ngx_queue_last(queue); + } + + lnode = ngx_queue_data(queue, ngx_stream_lua_shdict_list_node_t, queue); + + value_type = lnode->value_type; + + dd("data: %p", lnode->data); + dd("value len: %d", (int) sd->value_len); + + value.data = lnode->data; + value.len = (size_t) lnode->value_len; + + switch (value_type) { + + case SHDICT_TSTRING: + + lua_pushlstring(L, (char *) value.data, value.len); + break; + + case SHDICT_TNUMBER: + + if (value.len != sizeof(double)) { + + ngx_shmtx_unlock(&ctx->shpool->mutex); + + return luaL_error(L, "bad lua list node number value size found " + "for key %s in shared_dict %s: %lu", key.data, + name.data, (unsigned long) value.len); + } + + ngx_memcpy(&num, value.data, sizeof(double)); - ngx_slab_free_locked(ctx->shpool, node); - } + lua_pushnumber(L, num); + break; + + default: ngx_shmtx_unlock(&ctx->shpool->mutex); - lua_pushboolean(L, 0); - lua_pushliteral(L, "no memory"); - return 2; + return luaL_error(L, "bad list node value type found for key %s in " + "shared_dict %s: %d", key.data, name.data, + value_type); } - dd("setting list length to %d", sd->value_len + 1); + ngx_queue_remove(queue); - sd->value_len = sd->value_len + 1; + ngx_slab_free_locked(ctx->shpool, lnode); - dd("setting list node value length to %d", (int) value.len); + if (sd->value_len == 1) { - lnode->value_len = (uint32_t) value.len; + ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0, + "lua shared dict list: empty node after pop, " + "remove it"); - dd("setting list node value type to %d", value_type); + ngx_queue_remove(&sd->queue); - lnode->value_type = (uint8_t) value_type; + node = (ngx_rbtree_node_t *) + ((u_char *) sd - offsetof(ngx_rbtree_node_t, color)); - ngx_memcpy(lnode->data, value.data, value.len); + ngx_rbtree_delete(&ctx->sh->rbtree, node); - if (flags == NGX_STREAM_LUA_SHDICT_LEFT) { - ngx_queue_insert_head(queue, &lnode->queue); + ngx_slab_free_locked(ctx->shpool, node); } else { - ngx_queue_insert_tail(queue, &lnode->queue); + sd->value_len = sd->value_len - 1; + + ngx_queue_remove(&sd->queue); + ngx_queue_insert_head(&ctx->sh->lru_queue, &sd->queue); } ngx_shmtx_unlock(&ctx->shpool->mutex); - lua_pushnumber(L, sd->value_len); return 1; } static int -ngx_stream_lua_shdict_lpop(lua_State *L) -{ - return ngx_stream_lua_shdict_pop_helper(L, NGX_STREAM_LUA_SHDICT_LEFT); -} - - -static int -ngx_stream_lua_shdict_rpop(lua_State *L) -{ - return ngx_stream_lua_shdict_pop_helper(L, NGX_STREAM_LUA_SHDICT_RIGHT); -} - - -static int -ngx_stream_lua_shdict_pop_helper(lua_State *L, int flags) +ngx_stream_lua_shdict_llen(lua_State *L) { - int n; - ngx_str_t name; - ngx_str_t key; - uint32_t hash; - ngx_int_t rc; - ngx_str_t value; - int value_type; - double num; - ngx_rbtree_node_t *node; - ngx_shm_zone_t *zone; - ngx_queue_t *queue; + int n; + ngx_str_t key; + uint32_t hash; + ngx_int_t rc; + ngx_shm_zone_t *zone; - ngx_stream_lua_shdict_ctx_t *ctx; - ngx_stream_lua_shdict_node_t *sd; - ngx_stream_lua_shdict_list_node_t *lnode; + ngx_stream_lua_shdict_ctx_t *ctx; + ngx_stream_lua_shdict_node_t *sd; n = lua_gettop(L); @@ -1976,7 +2557,6 @@ ngx_stream_lua_shdict_pop_helper(lua_State *L, int flags) } ctx = zone->data; - name = ctx->name; if (lua_isnil(L, 2)) { lua_pushnil(L); @@ -2010,262 +2590,359 @@ ngx_stream_lua_shdict_pop_helper(lua_State *L, int flags) dd("shdict lookup returned %d", (int) rc); - if (rc == NGX_DECLINED || rc == NGX_DONE) { + if (rc == NGX_OK) { + + if (sd->value_type != SHDICT_TLIST) { + ngx_shmtx_unlock(&ctx->shpool->mutex); + + lua_pushnil(L); + lua_pushliteral(L, "value not a list"); + return 2; + } + + ngx_queue_remove(&sd->queue); + ngx_queue_insert_head(&ctx->sh->lru_queue, &sd->queue); + ngx_shmtx_unlock(&ctx->shpool->mutex); - lua_pushnil(L); + + lua_pushnumber(L, (lua_Number) sd->value_len); return 1; } - /* rc == NGX_OK */ + ngx_shmtx_unlock(&ctx->shpool->mutex); - if (sd->value_type != SHDICT_TLIST) { - ngx_shmtx_unlock(&ctx->shpool->mutex); + lua_pushnumber(L, 0); + return 1; +} - lua_pushnil(L); - lua_pushliteral(L, "value not a list"); - return 2; - } - if (sd->value_len <= 0) { - ngx_shmtx_unlock(&ctx->shpool->mutex); +ngx_shm_zone_t * +ngx_stream_lua_find_zone(u_char *name_data, size_t name_len) +{ + ngx_str_t *name; + ngx_uint_t i; + ngx_shm_zone_t *zone; + volatile ngx_list_part_t *part; - return luaL_error(L, "bad lua list length found for key %s " - "in shared_dict %s: %lu", key.data, name.data, - (unsigned long) sd->value_len); + ngx_stream_lua_shm_zone_ctx_t *ctx; + + part = &ngx_cycle->shared_memory.part; + zone = part->elts; + + for (i = 0; /* void */ ; i++) { + + if (i >= part->nelts) { + if (part->next == NULL) { + break; + } + + part = part->next; + zone = part->elts; + i = 0; + } + + name = &zone[i].shm.name; + + dd("name: [%.*s] %d", (int) name->len, name->data, (int) name->len); + dd("name2: [%.*s] %d", (int) name_len, name_data, (int) name_len); + + if (name->len == name_len + && ngx_strncmp(name->data, name_data, name_len) == 0) + { + ctx = (ngx_stream_lua_shm_zone_ctx_t *) zone[i].data; + return &ctx->zone; + } } - queue = ngx_stream_lua_shdict_get_list_head(sd, key.len); + return NULL; +} - if (flags == NGX_STREAM_LUA_SHDICT_LEFT) { - queue = ngx_queue_head(queue); - } else { - queue = ngx_queue_last(queue); +ngx_shm_zone_t * +ngx_stream_lua_ffi_shdict_udata_to_zone(void *zone_udata) +{ + if (zone_udata == NULL) { + return NULL; } - lnode = ngx_queue_data(queue, ngx_stream_lua_shdict_list_node_t, queue); + return *(ngx_shm_zone_t **) zone_udata; +} - value_type = lnode->value_type; - dd("data: %p", lnode->data); - dd("value len: %d", (int) sd->value_len); +int +ngx_stream_lua_ffi_shdict_store(ngx_shm_zone_t *zone, int op, u_char *key, + size_t key_len, int value_type, u_char *str_value_buf, + size_t str_value_len, double num_value, long exptime, int user_flags, + char **errmsg, int *forcible) +{ + int i, n; + u_char c, *p; + uint32_t hash; + ngx_int_t rc; + ngx_time_t *tp; + ngx_queue_t *queue, *q; + ngx_rbtree_node_t *node; - value.data = lnode->data; - value.len = (size_t) lnode->value_len; + ngx_stream_lua_shdict_ctx_t *ctx; + ngx_stream_lua_shdict_node_t *sd; + + dd("exptime: %ld", exptime); + + ctx = zone->data; + + *forcible = 0; + + hash = ngx_crc32_short(key, key_len); switch (value_type) { case SHDICT_TSTRING: - - lua_pushlstring(L, (char *) value.data, value.len); + /* do nothing */ break; case SHDICT_TNUMBER: + dd("num value: %lf", num_value); + str_value_buf = (u_char *) &num_value; + str_value_len = sizeof(double); + break; - if (value.len != sizeof(double)) { - - ngx_shmtx_unlock(&ctx->shpool->mutex); + case SHDICT_TBOOLEAN: + c = num_value ? 1 : 0; + str_value_buf = &c; + str_value_len = sizeof(u_char); + break; - return luaL_error(L, "bad lua list node number value size found " - "for key %s in shared_dict %s: %lu", key.data, - name.data, (unsigned long) value.len); + case LUA_TNIL: + if (op & (NGX_STREAM_LUA_SHDICT_ADD|NGX_STREAM_LUA_SHDICT_REPLACE)) { + *errmsg = "attempt to add or replace nil values"; + return NGX_ERROR; } - ngx_memcpy(&num, value.data, sizeof(double)); - - lua_pushnumber(L, num); + str_value_buf = NULL; + str_value_len = 0; break; default: + *errmsg = "unsupported value type"; + return NGX_ERROR; + } - ngx_shmtx_unlock(&ctx->shpool->mutex); + ngx_shmtx_lock(&ctx->shpool->mutex); - return luaL_error(L, "bad list node value type found for key %s in " - "shared_dict %s: %d", key.data, name.data, - value_type); +#if 1 + ngx_stream_lua_shdict_expire(ctx, 1); +#endif + + rc = ngx_stream_lua_shdict_lookup(zone, hash, key, key_len, &sd); + + dd("lookup returns %d", (int) rc); + + if (op & NGX_STREAM_LUA_SHDICT_REPLACE) { + + if (rc == NGX_DECLINED || rc == NGX_DONE) { + ngx_shmtx_unlock(&ctx->shpool->mutex); + *errmsg = "not found"; + return NGX_DECLINED; + } + + /* rc == NGX_OK */ + + goto replace; } - ngx_queue_remove(queue); + if (op & NGX_STREAM_LUA_SHDICT_ADD) { - ngx_slab_free_locked(ctx->shpool, lnode); + if (rc == NGX_OK) { + ngx_shmtx_unlock(&ctx->shpool->mutex); + *errmsg = "exists"; + return NGX_DECLINED; + } - if (sd->value_len == 1) { + if (rc == NGX_DONE) { + /* exists but expired */ + + dd("go to replace"); + goto replace; + } - ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0, - "lua shared dict list: empty node after pop, " - "remove it"); + /* rc == NGX_DECLINED */ - ngx_queue_remove(&sd->queue); + dd("go to insert"); + goto insert; + } - node = (ngx_rbtree_node_t *) - ((u_char *) sd - offsetof(ngx_rbtree_node_t, color)); + if (rc == NGX_OK || rc == NGX_DONE) { - ngx_rbtree_delete(&ctx->sh->rbtree, node); + if (value_type == LUA_TNIL) { + goto remove; + } - ngx_slab_free_locked(ctx->shpool, node); +replace: - } else { - sd->value_len = sd->value_len - 1; + if (str_value_buf + && str_value_len == (size_t) sd->value_len + && sd->value_type != SHDICT_TLIST) + { - ngx_queue_remove(&sd->queue); - ngx_queue_insert_head(&ctx->sh->lru_queue, &sd->queue); - } + ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0, + "lua shared dict set: found old entry and value " + "size matched, reusing it"); - ngx_shmtx_unlock(&ctx->shpool->mutex); + ngx_queue_remove(&sd->queue); + ngx_queue_insert_head(&ctx->sh->lru_queue, &sd->queue); - return 1; -} + sd->key_len = (u_short) key_len; + if (exptime > 0) { + tp = ngx_timeofday(); + sd->expires = (uint64_t) tp->sec * 1000 + tp->msec + + (uint64_t) exptime; -static int -ngx_stream_lua_shdict_llen(lua_State *L) -{ - int n; - ngx_str_t key; - uint32_t hash; - ngx_int_t rc; - ngx_shm_zone_t *zone; + } else { + sd->expires = 0; + } - ngx_stream_lua_shdict_ctx_t *ctx; - ngx_stream_lua_shdict_node_t *sd; + sd->user_flags = user_flags; - n = lua_gettop(L); + sd->value_len = (uint32_t) str_value_len; - if (n != 2) { - return luaL_error(L, "expecting 2 arguments, " - "but only seen %d", n); - } + dd("setting value type to %d", value_type); - if (lua_type(L, 1) != LUA_TTABLE) { - return luaL_error(L, "bad \"zone\" argument"); - } + sd->value_type = (uint8_t) value_type; - zone = ngx_stream_lua_shdict_get_zone(L, 1); - if (zone == NULL) { - return luaL_error(L, "bad \"zone\" argument"); - } + p = ngx_copy(sd->data, key, key_len); + ngx_memcpy(p, str_value_buf, str_value_len); - ctx = zone->data; + ngx_shmtx_unlock(&ctx->shpool->mutex); - if (lua_isnil(L, 2)) { - lua_pushnil(L); - lua_pushliteral(L, "nil key"); - return 2; - } + return NGX_OK; + } - key.data = (u_char *) luaL_checklstring(L, 2, &key.len); + ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0, + "lua shared dict set: found old entry but value size " + "NOT matched, removing it first"); - if (key.len == 0) { - lua_pushnil(L); - lua_pushliteral(L, "empty key"); - return 2; - } +remove: - if (key.len > 65535) { - lua_pushnil(L); - lua_pushliteral(L, "key too long"); - return 2; - } + if (sd->value_type == SHDICT_TLIST) { + queue = ngx_stream_lua_shdict_get_list_head(sd, key_len); - hash = ngx_crc32_short(key.data, key.len); + for (q = ngx_queue_head(queue); + q != ngx_queue_sentinel(queue); + q = ngx_queue_next(q)) + { + p = (u_char *) ngx_queue_data(q, + ngx_stream_lua_shdict_list_node_t, + queue); - ngx_shmtx_lock(&ctx->shpool->mutex); + ngx_slab_free_locked(ctx->shpool, p); + } + } -#if 1 - ngx_stream_lua_shdict_expire(ctx, 1); -#endif + ngx_queue_remove(&sd->queue); - rc = ngx_stream_lua_shdict_lookup(zone, hash, key.data, key.len, &sd); + node = (ngx_rbtree_node_t *) + ((u_char *) sd - offsetof(ngx_rbtree_node_t, color)); - dd("shdict lookup returned %d", (int) rc); + ngx_rbtree_delete(&ctx->sh->rbtree, node); - if (rc == NGX_OK) { + ngx_slab_free_locked(ctx->shpool, node); - if (sd->value_type != SHDICT_TLIST) { - ngx_shmtx_unlock(&ctx->shpool->mutex); + } - lua_pushnil(L); - lua_pushliteral(L, "value not a list"); - return 2; - } +insert: - ngx_queue_remove(&sd->queue); - ngx_queue_insert_head(&ctx->sh->lru_queue, &sd->queue); + /* rc == NGX_DECLINED or value size unmatch */ + if (str_value_buf == NULL) { ngx_shmtx_unlock(&ctx->shpool->mutex); - - lua_pushnumber(L, (lua_Number) sd->value_len); - return 1; + return NGX_OK; } - ngx_shmtx_unlock(&ctx->shpool->mutex); + ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0, + "lua shared dict set: creating a new entry"); - lua_pushnumber(L, 0); - return 1; -} + n = offsetof(ngx_rbtree_node_t, color) + + offsetof(ngx_stream_lua_shdict_node_t, data) + + key_len + + str_value_len; + node = ngx_slab_alloc_locked(ctx->shpool, n); -ngx_shm_zone_t * -ngx_stream_lua_find_zone(u_char *name_data, size_t name_len) -{ - ngx_str_t *name; - ngx_uint_t i; - ngx_shm_zone_t *zone; - volatile ngx_list_part_t *part; + if (node == NULL) { - ngx_stream_lua_shm_zone_ctx_t *ctx; + if (op & NGX_STREAM_LUA_SHDICT_SAFE_STORE) { + ngx_shmtx_unlock(&ctx->shpool->mutex); - part = &ngx_cycle->shared_memory.part; - zone = part->elts; + *errmsg = "no memory"; + return NGX_ERROR; + } - for (i = 0; /* void */ ; i++) { + ngx_log_debug2(NGX_LOG_DEBUG_STREAM, ctx->log, 0, + "lua shared dict set: overriding non-expired items " + "due to memory shortage for entry \"%*s\"", key_len, + key); - if (i >= part->nelts) { - if (part->next == NULL) { + for (i = 0; i < 30; i++) { + if (ngx_stream_lua_shdict_expire(ctx, 0) == 0) { break; } - part = part->next; - zone = part->elts; - i = 0; - } + *forcible = 1; - name = &zone[i].shm.name; + node = ngx_slab_alloc_locked(ctx->shpool, n); + if (node != NULL) { + goto allocated; + } + } - dd("name: [%.*s] %d", (int) name->len, name->data, (int) name->len); - dd("name2: [%.*s] %d", (int) name_len, name_data, (int) name_len); + ngx_shmtx_unlock(&ctx->shpool->mutex); - if (name->len == name_len - && ngx_strncmp(name->data, name_data, name_len) == 0) - { - ctx = (ngx_stream_lua_shm_zone_ctx_t *) zone[i].data; - return &ctx->zone; - } + *errmsg = "no memory"; + return NGX_ERROR; } - return NULL; -} +allocated: + sd = (ngx_stream_lua_shdict_node_t *) &node->color; -ngx_shm_zone_t * -ngx_stream_lua_ffi_shdict_udata_to_zone(void *zone_udata) -{ - if (zone_udata == NULL) { - return NULL; + node->key = hash; + sd->key_len = (u_short) key_len; + + if (exptime > 0) { + tp = ngx_timeofday(); + sd->expires = (uint64_t) tp->sec * 1000 + tp->msec + + (uint64_t) exptime; + + } else { + sd->expires = 0; } - return *(ngx_shm_zone_t **) zone_udata; + sd->user_flags = user_flags; + sd->value_len = (uint32_t) str_value_len; + dd("setting value type to %d", value_type); + sd->value_type = (uint8_t) value_type; + + p = ngx_copy(sd->data, key, key_len); + ngx_memcpy(p, str_value_buf, str_value_len); + + ngx_rbtree_insert(&ctx->sh->rbtree, node); + ngx_queue_insert_head(&ctx->sh->lru_queue, &sd->queue); + ngx_shmtx_unlock(&ctx->shpool->mutex); + + return NGX_OK; } int -ngx_stream_lua_ffi_shdict_store(ngx_shm_zone_t *zone, int op, u_char *key, - size_t key_len, int value_type, u_char *str_value_buf, - size_t str_value_len, double num_value, long exptime, int user_flags, - char **errmsg, int *forcible) +ngx_stream_lua_ffi_shdict_store_when(ngx_shm_zone_t *zone, int op, u_char *key, + size_t key_len, int old_value_type, u_char *old_str_value_buf, + size_t old_str_value_len, double old_num_value, int value_type, + u_char *str_value_buf, size_t str_value_len, double num_value, + long exptime, int user_flags, char **errmsg, int *forcible) { int i, n; - u_char c, *p; + u_char c, old_c, *p; uint32_t hash; ngx_int_t rc; ngx_time_t *tp; @@ -2283,6 +2960,34 @@ ngx_stream_lua_ffi_shdict_store(ngx_shm_zone_t *zone, int op, u_char *key, hash = ngx_crc32_short(key, key_len); + switch (old_value_type) { + + case SHDICT_TSTRING: + /* do nothing */ + break; + + case SHDICT_TNUMBER: + dd("old num value: %lf", old_num_value); + old_str_value_buf = (u_char *) &old_num_value; + old_str_value_len = sizeof(double); + break; + + case SHDICT_TBOOLEAN: + old_c = old_num_value ? 1 : 0; + old_str_value_buf = &old_c; + old_str_value_len = sizeof(u_char); + break; + + case LUA_TNIL: + old_str_value_buf = NULL; + old_str_value_len = 0; + break; + + default: + *errmsg = "unsupported old_value type"; + return NGX_ERROR; + } + switch (value_type) { case SHDICT_TSTRING: @@ -2362,6 +3067,15 @@ ngx_stream_lua_ffi_shdict_store(ngx_shm_zone_t *zone, int op, u_char *key, if (rc == NGX_OK || rc == NGX_DONE) { + if (sd->value_type != old_value_type + || (size_t) sd->value_len != old_str_value_len + || memcmp(sd->data + sd->key_len, old_str_value_buf, sd->value_len) != 0) + { + ngx_shmtx_unlock(&ctx->shpool->mutex); + *errmsg = "already modified"; + return NGX_ERROR; + } + if (value_type == LUA_TNIL) { goto remove; } diff --git a/t/062-count.t b/t/062-count.t index 288c28e6..70212440 100644 --- a/t/062-count.t +++ b/t/062-count.t @@ -121,7 +121,7 @@ n = 8 ngx.say("n = ", n) } --- stream_response -n = 22 +n = 24 --- no_error_log [error]