lib-dict: Moved/removed explicit stack frames in dict drivers.

Added them back to dict_set/unset/atomic_inc() in dict.c. Others are
unlikely to be called many times.

diff --git a/src/lib-dict/dict-memcached-ascii.c b/src/lib-dict/dict-memcached-ascii.c
index b794702606a5063f2e5fe673d44ac66675bcfd1d..eeae6838475a51077ef9923f7393f776c85197e5 100644 (file)
--- a/src/lib-dict/dict-memcached-ascii.c
+++ b/src/lib-dict/dict-memcached-ascii.c
@@ -483,11 +483,12 @@ memcached_ascii_dict_get_full_key(struct memcached_ascii_dict *dict,
 }
 
 static int
-memcached_ascii_dict_lookup_real(struct memcached_ascii_dict *dict, pool_t pool,
-                                const char *key, const char **value_r)
+memcached_ascii_dict_lookup(struct dict *_dict, pool_t pool,
+                           const char *key, const char **value_r)
 {
-       enum memcached_ascii_input_state state = MEMCACHED_INPUT_STATE_GET;
+       struct memcached_ascii_dict *dict = (struct memcached_ascii_dict *)_dict;
        struct memcached_ascii_dict_reply *reply;
+       enum memcached_ascii_input_state state = MEMCACHED_INPUT_STATE_GET;
 
        if (memcached_ascii_connect(dict) < 0)
                return -1;
@@ -507,21 +508,6 @@ memcached_ascii_dict_lookup_real(struct memcached_ascii_dict *dict, pool_t pool,
        return dict->conn.value_received ? 1 : 0;
 }
 
-static int
-memcached_ascii_dict_lookup(struct dict *_dict, pool_t pool,
-                           const char *key, const char **value_r)
-{
-       struct memcached_ascii_dict *dict = (struct memcached_ascii_dict *)_dict;
-       int ret;
-
-       if (pool->datastack_pool)
-               ret = memcached_ascii_dict_lookup_real(dict, pool, key, value_r);
-       else T_BEGIN {
-               ret = memcached_ascii_dict_lookup_real(dict, pool, key, value_r);
-       } T_END;
-       return ret;
-}
-
 static struct dict_transaction_context *
 memcached_ascii_transaction_init(struct dict *_dict)
 {

diff --git a/src/lib-dict/dict-memcached.c b/src/lib-dict/dict-memcached.c
index b0fda97dde7793f1cdd2caa3e9f438cc2f360f7b..6749fbba65af98b9807f7f47508ee229d18b3028 100644 (file)
--- a/src/lib-dict/dict-memcached.c
+++ b/src/lib-dict/dict-memcached.c
@@ -271,10 +271,10 @@ static void memcached_add_header(buffer_t *buf, unsigned int key_len)
        i_assert(buf->used == MEMCACHED_REQUEST_HDR_LENGTH);
 }
 
-static int
-memcached_dict_lookup_real(struct memcached_dict *dict, pool_t pool,
-                          const char *key, const char **value_r)
+static int memcached_dict_lookup(struct dict *_dict, pool_t pool,
+                                const char *key, const char **value_r)
 {
+       struct memcached_dict *dict = (struct memcached_dict *)_dict;
        struct ioloop *prev_ioloop = current_ioloop;
        struct timeout *to;
        size_t key_len;
@@ -360,20 +360,6 @@ memcached_dict_lookup_real(struct memcached_dict *dict, pool_t pool,
        return -1;
 }
 
-static int memcached_dict_lookup(struct dict *_dict, pool_t pool,
-                                const char *key, const char **value_r)
-{
-       struct memcached_dict *dict = (struct memcached_dict *)_dict;
-       int ret;
-
-       if (pool->datastack_pool)
-               ret = memcached_dict_lookup_real(dict, pool, key, value_r);
-       else T_BEGIN {
-               ret = memcached_dict_lookup_real(dict, pool, key, value_r);
-       } T_END;
-       return ret;
-}
-
 struct dict dict_driver_memcached = {
        .name = "memcached",
        {

diff --git a/src/lib-dict/dict-redis.c b/src/lib-dict/dict-redis.c
index 18c97cccaa5d497e229ab3ae83ad5b19c5c027a9..7b43ffd8d6dac9ea9f01d500e2cbfd7d9fedddac 100644 (file)
--- a/src/lib-dict/dict-redis.c
+++ b/src/lib-dict/dict-redis.c
@@ -488,10 +488,10 @@ static void redis_dict_select_db(struct redis_dict *dict)
        redis_input_state_add(dict, REDIS_INPUT_STATE_SELECT);
 }
 
-static int
-redis_dict_lookup_real(struct redis_dict *dict, pool_t pool,
-                      const char *key, const char **value_r)
+static int redis_dict_lookup(struct dict *_dict, pool_t pool,
+                            const char *key, const char **value_r)
 {
+       struct redis_dict *dict = (struct redis_dict *)_dict;
        struct timeout *to;
        const char *cmd;
 
@@ -551,22 +551,6 @@ redis_dict_lookup_real(struct redis_dict *dict, pool_t pool,
        return 1;
 }
 
-static int redis_dict_lookup(struct dict *_dict, pool_t pool,
-                            const char *key, const char **value_r)
-{
-       struct redis_dict *dict = (struct redis_dict *)_dict;
-       int ret;
-
-       i_assert(!dict->transaction_open);
-
-       if (pool->datastack_pool)
-               ret = redis_dict_lookup_real(dict, pool, key, value_r);
-       else T_BEGIN {
-               ret = redis_dict_lookup_real(dict, pool, key, value_r);
-       } T_END;
-       return ret;
-}
-
 static struct dict_transaction_context *
 redis_transaction_init(struct dict *_dict)
 {

diff --git a/src/lib-dict/dict-sql.c b/src/lib-dict/dict-sql.c
index bf7c2fa5e32d92594225a292d357c9e6ee3cdb73..38ecf67853aa183ec49aace8b84598b9bfb87a5d 100644 (file)
--- a/src/lib-dict/dict-sql.c
+++ b/src/lib-dict/dict-sql.c
@@ -437,23 +437,17 @@ static int sql_dict_lookup(struct dict *_dict, pool_t pool,
        struct sql_dict *dict = (struct sql_dict *)_dict;
        const struct dict_sql_map *map;
        struct sql_result *result = NULL;
+       string_t *query = t_str_new(256);
+       const char *error;
        int ret;
 
-       T_BEGIN {
-               string_t *query = t_str_new(256);
-               const char *error;
-
-               ret = sql_lookup_get_query(dict, key, query, &map, &error);
-               if (ret < 0)
-                       i_error("%s", error);
-               else
-                       result = sql_query_s(dict->db, str_c(query));
-       } T_END;
-
+       ret = sql_lookup_get_query(dict, key, query, &map, &error);
        if (ret < 0) {
+               i_error("%s", error);
                *value_r = NULL;
                return -1;
        }
+       result = sql_query_s(dict->db, str_c(query));
 
        ret = sql_result_next_row(result);
        if (ret <= 0) {
@@ -509,27 +503,24 @@ sql_dict_lookup_async(struct dict *_dict, const char *key,
        struct sql_dict *dict = (struct sql_dict *)_dict;
        const struct dict_sql_map *map;
        struct sql_dict_lookup_context *ctx;
+       string_t *query = t_str_new(256);
+       const char *error;
 
-       T_BEGIN {
-               string_t *query = t_str_new(256);
-               const char *error;
-
-               if (sql_lookup_get_query(dict, key, query, &map, &error) < 0) {
-                       struct dict_lookup_result result;
+       if (sql_lookup_get_query(dict, key, query, &map, &error) < 0) {
+               struct dict_lookup_result result;
 
-                       i_zero(&result);
-                       result.ret = -1;
-                       result.error = error;
-                       callback(&result, context);
-               } else {
-                       ctx = i_new(struct sql_dict_lookup_context, 1);
-                       ctx->callback = callback;
-                       ctx->context = context;
-                       ctx->map = map;
-                       sql_query(dict->db, str_c(query),
-                                 sql_dict_lookup_async_callback, ctx);
-               }
-       } T_END;
+               i_zero(&result);
+               result.ret = -1;
+               result.error = error;
+               callback(&result, context);
+       } else {
+               ctx = i_new(struct sql_dict_lookup_context, 1);
+               ctx->callback = callback;
+               ctx->context = context;
+               ctx->map = map;
+               sql_query(dict->db, str_c(query),
+                         sql_dict_lookup_async_callback, ctx);
+       }
 }
 
 static const struct dict_sql_map *
@@ -655,30 +646,27 @@ static void sql_dict_iterate_callback(struct sql_result *result,
 static int sql_dict_iterate_next_query(struct sql_dict_iterate_context *ctx)
 {
        struct sql_dict *dict = (struct sql_dict *)ctx->ctx.dict;
+       string_t *query = t_str_new(256);
        const char *error;
        unsigned int path_idx = ctx->path_idx;
        int ret;
 
-       T_BEGIN {
-               string_t *query = t_str_new(256);
-
-               ret = sql_dict_iterate_build_next_query(ctx, query, &error);
-               if (ret < 0) {
-                       /* failed */
-                       i_error("sql dict iterate failed for %s: %s",
-                               ctx->paths[path_idx], error);
-               } else if (ret == 0) {
-                       /* this is expected error */
-               } else if ((ctx->flags & DICT_ITERATE_FLAG_ASYNC) == 0) {
-                       ctx->result = sql_query_s(dict->db, str_c(query));
-               } else {
-                       i_assert(ctx->result == NULL);
-                       ctx->synchronous_result = TRUE;
-                       sql_query(dict->db, str_c(query),
-                                 sql_dict_iterate_callback, ctx);
-                       ctx->synchronous_result = FALSE;
-               }
-       } T_END;
+       ret = sql_dict_iterate_build_next_query(ctx, query, &error);
+       if (ret < 0) {
+               /* failed */
+               i_error("sql dict iterate failed for %s: %s",
+                       ctx->paths[path_idx], error);
+       } else if (ret == 0) {
+               /* this is expected error */
+       } else if ((ctx->flags & DICT_ITERATE_FLAG_ASYNC) == 0) {
+               ctx->result = sql_query_s(dict->db, str_c(query));
+       } else {
+               i_assert(ctx->result == NULL);
+               ctx->synchronous_result = TRUE;
+               sql_query(dict->db, str_c(query),
+                         sql_dict_iterate_callback, ctx);
+               ctx->synchronous_result = FALSE;
+       }
        return ret;
 }
 
@@ -1084,6 +1072,9 @@ static void sql_dict_set_real(struct dict_transaction_context *_ctx,
        struct sql_dict *dict = (struct sql_dict *)_ctx->dict;
        const struct dict_sql_map *map;
        ARRAY_TYPE(const_string) values;
+       struct dict_sql_build_query build;
+       struct dict_sql_build_query_field field;
+       const char *query, *error;
 
        map = sql_dict_find_map(dict, key, &values);
        if (map == NULL) {
@@ -1092,29 +1083,23 @@ static void sql_dict_set_real(struct dict_transaction_context *_ctx,
                return;
        }
 
-       T_BEGIN {
-               struct dict_sql_build_query build;
-               struct dict_sql_build_query_field field;
-               const char *query, *error;
-
-               field.map = map;
-               field.value = value;
+       field.map = map;
+       field.value = value;
 
-               i_zero(&build);
-               build.dict = dict;
-               t_array_init(&build.fields, 1);
-               array_append(&build.fields, &field, 1);
-               build.extra_values = &values;
-               build.key1 = key[0];
+       i_zero(&build);
+       build.dict = dict;
+       t_array_init(&build.fields, 1);
+       array_append(&build.fields, &field, 1);
+       build.extra_values = &values;
+       build.key1 = key[0];
 
-               if (sql_dict_set_query(ctx, &build, &query, &error) < 0) {
-                       i_error("dict-sql: Failed to set %s=%s: %s",
-                               key, value, error);
-                       ctx->failed = TRUE;
-               } else {
-                       sql_update(ctx->sql_ctx, query);
-               }
-       } T_END;
+       if (sql_dict_set_query(ctx, &build, &query, &error) < 0) {
+               i_error("dict-sql: Failed to set %s=%s: %s",
+                       key, value, error);
+               ctx->failed = TRUE;
+       } else {
+               sql_update(ctx->sql_ctx, query);
+       }
 }
 
 static void sql_dict_unset(struct dict_transaction_context *_ctx,
@@ -1125,6 +1110,8 @@ static void sql_dict_unset(struct dict_transaction_context *_ctx,
        struct sql_dict *dict = (struct sql_dict *)_ctx->dict;
        const struct dict_sql_map *map;
        ARRAY_TYPE(const_string) values;
+       string_t *query = t_str_new(256);
+       const char *error;
 
        if (ctx->prev_inc_map != NULL)
                sql_dict_prev_inc_flush(ctx);
@@ -1138,20 +1125,15 @@ static void sql_dict_unset(struct dict_transaction_context *_ctx,
                return;
        }
 
-       T_BEGIN {
-               string_t *query = t_str_new(256);
-               const char *error;
-
-               str_printfa(query, "DELETE FROM %s", map->table);
-               sql_dict_transaction_add_timestamp(ctx, query);
-               if (sql_dict_where_build(dict, map, &values, key[0],
-                                        SQL_DICT_RECURSE_NONE, query, &error) < 0) {
-                       i_error("dict-sql: Failed to delete %s: %s", key, error);
-                       ctx->failed = TRUE;
-               } else {
-                       sql_update(ctx->sql_ctx, str_c(query));
-               }
-       } T_END;
+       str_printfa(query, "DELETE FROM %s", map->table);
+       sql_dict_transaction_add_timestamp(ctx, query);
+       if (sql_dict_where_build(dict, map, &values, key[0],
+                                SQL_DICT_RECURSE_NONE, query, &error) < 0) {
+               i_error("dict-sql: Failed to delete %s: %s", key, error);
+               ctx->failed = TRUE;
+       } else {
+               sql_update(ctx->sql_ctx, str_c(query));
+       }
 }
 
 static void
@@ -1187,34 +1169,31 @@ static void sql_dict_atomic_inc_real(struct sql_dict_transaction_context *ctx,
        struct sql_dict *dict = (struct sql_dict *)ctx->ctx.dict;
        const struct dict_sql_map *map;
        ARRAY_TYPE(const_string) values;
+       struct dict_sql_build_query build;
+       struct dict_sql_build_query_field field;
+       const char *query, *error;
 
        map = sql_dict_find_map(dict, key, &values);
        i_assert(map != NULL);
 
-       T_BEGIN {
-               struct dict_sql_build_query build;
-               struct dict_sql_build_query_field field;
-               const char *query, *error;
+       field.map = map;
+       field.value = t_strdup_printf("%lld", diff);
 
-               field.map = map;
-               field.value = t_strdup_printf("%lld", diff);
+       i_zero(&build);
+       build.dict = dict;
+       t_array_init(&build.fields, 1);
+       array_append(&build.fields, &field, 1);
+       build.extra_values = &values;
+       build.key1 = key[0];
+       build.inc = TRUE;
 
-               i_zero(&build);
-               build.dict = dict;
-               t_array_init(&build.fields, 1);
-               array_append(&build.fields, &field, 1);
-               build.extra_values = &values;
-               build.key1 = key[0];
-               build.inc = TRUE;
-
-               if (sql_dict_update_query(ctx, &build, &query, &error) < 0) {
-                       i_error("dict-sql: Failed to increase %s: %s", key, error);
-                       ctx->failed = TRUE;
-               } else {
-                       sql_update_get_rows(ctx->sql_ctx, query,
-                                           sql_dict_next_inc_row(ctx));
-               }
-       } T_END;
+       if (sql_dict_update_query(ctx, &build, &query, &error) < 0) {
+               i_error("dict-sql: Failed to increase %s: %s", key, error);
+               ctx->failed = TRUE;
+       } else {
+               sql_update_get_rows(ctx->sql_ctx, query,
+                                   sql_dict_next_inc_row(ctx));
+       }
 }
 
 static void sql_dict_prev_set_flush(struct sql_dict_transaction_context *ctx)
@@ -1360,7 +1339,7 @@ static void sql_dict_atomic_inc(struct dict_transaction_context *_ctx,
                                         ctx->prev_inc_key, key, &values)) {
                sql_dict_prev_inc_flush(ctx);
                sql_dict_atomic_inc_real(ctx, key, diff);
-       } else T_BEGIN {
+       } else {
                struct dict_sql_build_query build;
                struct dict_sql_build_query_field *field;
                const char *query, *error;
@@ -1389,7 +1368,7 @@ static void sql_dict_atomic_inc(struct dict_transaction_context *_ctx,
 
                i_free_and_null(ctx->prev_inc_key);
                ctx->prev_inc_map = NULL;
-       } T_END;
+       }
 }
 
 static struct dict sql_dict = {

diff --git a/src/lib-dict/dict.c b/src/lib-dict/dict.c
index a3a3840ee31894769dc212e514602001ddde6ecb..3f1d062a4a86f7a2b3dd7dddd8fe9e306d0a9a40 100644 (file)
--- a/src/lib-dict/dict.c
+++ b/src/lib-dict/dict.c
@@ -309,7 +309,9 @@ void dict_set(struct dict_transaction_context *ctx,
 {
        i_assert(dict_key_prefix_is_valid(key));
 
-       ctx->dict->v.set(ctx, key, value);
+       T_BEGIN {
+               ctx->dict->v.set(ctx, key, value);
+       } T_END;
        ctx->changed = TRUE;
 }
 
@@ -318,7 +320,9 @@ void dict_unset(struct dict_transaction_context *ctx,
 {
        i_assert(dict_key_prefix_is_valid(key));
 
-       ctx->dict->v.unset(ctx, key);
+       T_BEGIN {
+               ctx->dict->v.unset(ctx, key);
+       } T_END;
        ctx->changed = TRUE;
 }
 
@@ -336,10 +340,10 @@ void dict_atomic_inc(struct dict_transaction_context *ctx,
 {
        i_assert(dict_key_prefix_is_valid(key));
 
-       if (diff != 0) {
+       if (diff != 0) T_BEGIN {
                ctx->dict->v.atomic_inc(ctx, key, diff);
                ctx->changed = TRUE;
-       }
+       } T_END;
 }
 
 const char *dict_escape_string(const char *str)

diff --git a/src/plugins/dict-ldap/dict-ldap.c b/src/plugins/dict-ldap/dict-ldap.c
index 0d6cbc543d3f16bb53baa961b414b1f219e13632..99fc0a65ed9f81239aaccd2642de46b2eff941d8 100644 (file)
--- a/src/plugins/dict-ldap/dict-ldap.c
+++ b/src/plugins/dict-ldap/dict-ldap.c
@@ -349,15 +349,13 @@ int ldap_dict_lookup(struct dict *dict, pool_t pool,
        pool_t orig_pool = pool;
        int ret;
 
-       T_BEGIN {
-               ldap_dict_lookup_async(dict, key, ldap_dict_lookup_done, &res);
+       ldap_dict_lookup_async(dict, key, ldap_dict_lookup_done, &res);
 
-               if ((ret = ldap_dict_wait(dict)) == 0) {
-                       if (res.ret == 0) {
-                               *value_r = p_strdup(orig_pool, res.value);
-                       } else ret = res.ret;
-               }
-       } T_END;
+       if ((ret = ldap_dict_wait(dict)) == 0) {
+               if (res.ret == 0) {
+                       *value_r = p_strdup(orig_pool, res.value);
+               } else ret = res.ret;
+       }
        return ret;
 }
 
@@ -426,30 +424,28 @@ void ldap_dict_lookup_async(struct dict *dict, const char *key,
 
        /* key needs to be transformed into something else */
        ARRAY_TYPE(const_string) values;
-       T_BEGIN {
-               const char *attributes[2] = {0, 0};
-               t_array_init(&values, 8);
-               const struct dict_ldap_map *map = ldap_dict_find_map(ctx, key, &values);
-
-               if (map != NULL) {
-                       op->map = map;
-                       attributes[0] = map->value_attribute;
-                       /* build lookup */
-                       i_zero(&input);
-                       input.base_dn = map->base_dn;
-                       input.scope = map->scope_val;
-                       ldap_dict_build_query(ctx, map, &values, strncmp(key, DICT_PATH_PRIVATE, strlen(DICT_PATH_PRIVATE))==0, query);
-                       input.filter = str_c(query);
-                       input.attributes = attributes;
-                       input.timeout_secs = ctx->set->timeout;
-                       ctx->pending++;
-                       ldap_search_start(ctx->client, &input, ldap_dict_lookup_callback, op);
-               } else {
-                       op->res.error = "no such key";
-                       callback(&(op->res), context);
-                       pool_unref(&oppool);
-               }
-       } T_END;
+       const char *attributes[2] = {0, 0};
+       t_array_init(&values, 8);
+       const struct dict_ldap_map *map = ldap_dict_find_map(ctx, key, &values);
+
+       if (map != NULL) {
+               op->map = map;
+               attributes[0] = map->value_attribute;
+               /* build lookup */
+               i_zero(&input);
+               input.base_dn = map->base_dn;
+               input.scope = map->scope_val;
+               ldap_dict_build_query(ctx, map, &values, strncmp(key, DICT_PATH_PRIVATE, strlen(DICT_PATH_PRIVATE))==0, query);
+               input.filter = str_c(query);
+               input.attributes = attributes;
+               input.timeout_secs = ctx->set->timeout;
+               ctx->pending++;
+               ldap_search_start(ctx->client, &input, ldap_dict_lookup_callback, op);
+       } else {
+               op->res.error = "no such key";
+               callback(&(op->res), context);
+               pool_unref(&oppool);
+       }
 }
 
 struct dict dict_driver_ldap = {