Mercurial > dovecot > core-2.2

changeset 22516:16835a26b202

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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.
author Timo Sirainen <timo.sirainen@dovecot.fi>
date Fri, 06 May 2016 12:19:21 +0300
parents b6c3fc6d0cc0
children 9bb9e436a642
files src/lib-dict/dict-memcached-ascii.c src/lib-dict/dict-memcached.c src/lib-dict/dict-redis.c src/lib-dict/dict-sql.c src/lib-dict/dict.c src/plugins/dict-ldap/dict-ldap.c
diffstat 6 files changed, 133 insertions(+), 198 deletions(-) [+]
line wrap: on
line diff
--- a/src/lib-dict/dict-memcached-ascii.c	Tue Aug 15 14:27:40 2017 +0300
+++ b/src/lib-dict/dict-memcached-ascii.c	Fri May 06 12:19:21 2016 +0300
@@ -483,11 +483,12 @@
 }
 
 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)
 {
+	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;
-	struct memcached_ascii_dict_reply *reply;
 
 	if (memcached_ascii_connect(dict) < 0)
 		return -1;
@@ -507,21 +508,6 @@
 	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)
 {
--- a/src/lib-dict/dict-memcached.c	Tue Aug 15 14:27:40 2017 +0300
+++ b/src/lib-dict/dict-memcached.c	Fri May 06 12:19:21 2016 +0300
@@ -271,10 +271,10 @@
 	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 @@
 	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",
 	{
--- a/src/lib-dict/dict-redis.c	Tue Aug 15 14:27:40 2017 +0300
+++ b/src/lib-dict/dict-redis.c	Fri May 06 12:19:21 2016 +0300
@@ -488,10 +488,10 @@
 	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 @@
 	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)
 {
--- a/src/lib-dict/dict-sql.c	Tue Aug 15 14:27:40 2017 +0300
+++ b/src/lib-dict/dict-sql.c	Fri May 06 12:19:21 2016 +0300
@@ -437,23 +437,17 @@
 	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 @@
 	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 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 @@
 	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 @@
 		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 @@
 	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 @@
 		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 @@
 	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 @@
 					 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 @@
 
 		i_free_and_null(ctx->prev_inc_key);
 		ctx->prev_inc_map = NULL;
-	} T_END;
+	}
 }
 
 static struct dict sql_dict = {
--- a/src/lib-dict/dict.c	Tue Aug 15 14:27:40 2017 +0300
+++ b/src/lib-dict/dict.c	Fri May 06 12:19:21 2016 +0300
@@ -309,7 +309,9 @@
 {
 	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 @@
 {
 	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 @@
 {
 	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)
--- a/src/plugins/dict-ldap/dict-ldap.c	Tue Aug 15 14:27:40 2017 +0300
+++ b/src/plugins/dict-ldap/dict-ldap.c	Fri May 06 12:19:21 2016 +0300
@@ -349,15 +349,13 @@
 	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 @@
 
 	/* 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);
+	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;
+	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 = {