[Project] Support mempool flags

diff --git a/src/controller.c b/src/controller.c
index 2ab796791552dcd24dd0bd8b7fa0e36201c73c17..e4ad7085d9d5819f2def4ac02bebece40f4f1aae 100644 (file)
--- a/src/controller.c
+++ b/src/controller.c
@@ -3088,7 +3088,7 @@ rspamd_controller_accept_socket (EV_P_ ev_io *w, int revents)
 
        session = g_malloc0 (sizeof (struct rspamd_controller_session));
        session->pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
-                       "csession");
+                       "csession", 0);
        session->ctx = ctx;
        session->cfg = ctx->cfg;
        session->lang_det = ctx->lang_det;

diff --git a/src/libserver/cfg_utils.c b/src/libserver/cfg_utils.c
index ca5c71ea96e5f470ee832036a0aefbad42466902..37a3d45788388ebc697a3f1f56dfab7659d72acc 100644 (file)
--- a/src/libserver/cfg_utils.c
+++ b/src/libserver/cfg_utils.c
@@ -133,7 +133,7 @@ rspamd_config_new (enum rspamd_config_init_flags flags)
        struct rspamd_config *cfg;
        rspamd_mempool_t *pool;
 
-       pool = rspamd_mempool_new (8 * 1024 * 1024, "cfg");
+       pool = rspamd_mempool_new (8 * 1024 * 1024, "cfg", 0);
        cfg = rspamd_mempool_alloc0 (pool, sizeof (*cfg));
        /* Allocate larger pool for cfg */
        cfg->cfg_pool = pool;

diff --git a/src/libserver/fuzzy_backend_sqlite.c b/src/libserver/fuzzy_backend_sqlite.c
index 90c0db70dee4a512c1b6221ace7d9b546a47e727..0f9b3c1eed3dc5b65aef786ec31b7fb0f638cd4b 100644 (file)
--- a/src/libserver/fuzzy_backend_sqlite.c
+++ b/src/libserver/fuzzy_backend_sqlite.c
@@ -431,7 +431,8 @@ rspamd_fuzzy_backend_sqlite_open_db (const gchar *path, GError **err)
        bk = g_malloc0 (sizeof (*bk));
        bk->path = g_strdup (path);
        bk->expired = 0;
-       bk->pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "fuzzy_backend");
+       bk->pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
+                       "fuzzy_backend", 0);
        bk->db = rspamd_sqlite3_open_or_create (bk->pool, bk->path,
                        create_tables_sql, 1, err);
 

diff --git a/src/libserver/milter.c b/src/libserver/milter.c
index 1b24fa3dae9cccd697eaa4ae125235d3aaca5b66..bc33708ff99d085affd1b8faf2a39488527eff19 100644 (file)
--- a/src/libserver/milter.c
+++ b/src/libserver/milter.c
@@ -1105,7 +1105,7 @@ rspamd_milter_handle_socket (gint fd, ev_tstamp timeout,
        priv->parser.buf = rspamd_fstring_sized_new (RSPAMD_MILTER_MESSAGE_CHUNK + 5);
        priv->event_loop = ev_base;
        priv->state = RSPAMD_MILTER_READ_MORE;
-       priv->pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "milter");
+       priv->pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "milter", 0);
        priv->discard_on_reject = milter_ctx->discard_on_reject;
        priv->quarantine_on_reject = milter_ctx->quarantine_on_reject;
        priv->ev.timeout = timeout;

diff --git a/src/libserver/rspamd_symcache.c b/src/libserver/rspamd_symcache.c
index d5022cedd118959c5b4e7bdf7369a86a358dcdd4..f232a6a242be22c554496fab3484be81a540e07c 100644 (file)
--- a/src/libserver/rspamd_symcache.c
+++ b/src/libserver/rspamd_symcache.c
@@ -1319,7 +1319,7 @@ rspamd_symcache_new (struct rspamd_config *cfg)
 
        cache = g_malloc0 (sizeof (struct rspamd_symcache));
        cache->static_pool =
-                       rspamd_mempool_new (rspamd_mempool_suggest_size (), "symcache");
+                       rspamd_mempool_new (rspamd_mempool_suggest_size (), "symcache", 0);
        cache->items_by_symbol = g_hash_table_new (rspamd_str_hash,
                        rspamd_str_equal);
        cache->items_by_id = g_ptr_array_new ();

diff --git a/src/libserver/task.c b/src/libserver/task.c
index e7aab0f8219d2520048fd522e4b392630590809b..9eebe02a2186c90fed3cf0671b93cad18d70ac46 100644 (file)
--- a/src/libserver/task.c
+++ b/src/libserver/task.c
@@ -60,7 +60,8 @@ rspamd_task_quark (void)
  * Create new task
  */
 struct rspamd_task *
-rspamd_task_new (struct rspamd_worker *worker, struct rspamd_config *cfg,
+rspamd_task_new (struct rspamd_worker *worker,
+                                struct rspamd_config *cfg,
                                 rspamd_mempool_t *pool,
                                 struct rspamd_lang_detector *lang_det,
                                 struct ev_loop *event_loop)
@@ -70,7 +71,7 @@ rspamd_task_new (struct rspamd_worker *worker, struct rspamd_config *cfg,
        guint flags = 0;
 
        if (pool == NULL) {
-               task_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "task");
+               task_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "task", 0);
                flags |= RSPAMD_TASK_FLAG_OWN_POOL;
        }
        else {

diff --git a/src/libutil/map_helpers.c b/src/libutil/map_helpers.c
index d67e2fc4dda228ab91127eebb3c33ed5ded08089..d179d44f5c4f8ab43a949552e54dbf98540bfaf0 100644 (file)
--- a/src/libutil/map_helpers.c
+++ b/src/libutil/map_helpers.c
@@ -631,11 +631,11 @@ rspamd_map_helper_new_hash (struct rspamd_map *map)
 
        if (map) {
                pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
-                               map->tag);
+                               map->tag, 0);
        }
        else {
                pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
-                               NULL);
+                               NULL, 0);
        }
 
        htb = rspamd_mempool_alloc0 (pool, sizeof (*htb));
@@ -688,11 +688,11 @@ rspamd_map_helper_new_radix (struct rspamd_map *map)
 
        if (map) {
                pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
-                               map->tag);
+                               map->tag, 0);
        }
        else {
                pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
-                               NULL);
+                               NULL, 0);
        }
 
        r = rspamd_mempool_alloc0 (pool, sizeof (*r));
@@ -746,7 +746,7 @@ rspamd_map_helper_new_regexp (struct rspamd_map *map,
        rspamd_mempool_t *pool;
 
        pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
-                       map->tag);
+                       map->tag, 0);
 
        re_map = rspamd_mempool_alloc0 (pool, sizeof (*re_map));
        re_map->pool = pool;

diff --git a/src/libutil/mem_pool.c b/src/libutil/mem_pool.c
index 54113b265ff6e1bb21469f22fd8f40466eefec6a..728c103500c8777d4dd54297e70628b1ed79f3ae 100644 (file)
--- a/src/libutil/mem_pool.c
+++ b/src/libutil/mem_pool.c
@@ -272,7 +272,7 @@ rspamd_mempool_append_chain (rspamd_mempool_t * pool,
  * @return new memory pool object
  */
 rspamd_mempool_t *
-rspamd_mempool_new_ (gsize size, const gchar *tag, const gchar *loc)
+rspamd_mempool_new_ (gsize size, const gchar *tag, gint flags, const gchar *loc)
 {
        rspamd_mempool_t *new_pool;
        gpointer map;
@@ -345,6 +345,7 @@ rspamd_mempool_new_ (gsize size, const gchar *tag, const gchar *loc)
        /*
         * Memory layout:
         * struct rspamd_mempool_t
+        * <optional debug hash table>
         * struct rspamd_mempool_specific
         * struct _pool_chain
         * alignment (if needed)
@@ -353,6 +354,7 @@ rspamd_mempool_new_ (gsize size, const gchar *tag, const gchar *loc)
        guchar *mem_chunk;
        gint ret = posix_memalign ((void **)&mem_chunk, MIN_MEM_ALIGNMENT,
                        total_size);
+       gsize priv_offset;
 
        if (ret != 0 || mem_chunk == NULL) {
                g_error ("%s: failed to allocate %"G_GSIZE_FORMAT" bytes: %d - %s",
@@ -362,14 +364,26 @@ rspamd_mempool_new_ (gsize size, const gchar *tag, const gchar *loc)
 
        /* Set memory layout */
        new_pool = (rspamd_mempool_t *)mem_chunk;
+       if (flags & RSPAMD_MEMPOOL_DEBUG) {
+               /* Allocate debug table */
+               GHashTable *debug_tbl = (GHashTable *)(mem_chunk + sizeof (rspamd_mempool_t));
+
+               debug_tbl = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
+               priv_offset = sizeof (rspamd_mempool_t) + sizeof (GHashTable *);
+       }
+       else {
+               priv_offset = sizeof (rspamd_mempool_t);
+       }
+
        new_pool->priv = (struct rspamd_mempool_specific *)(mem_chunk +
-                       sizeof (rspamd_mempool_t));
-       /* Zere memory for specific and for the first chain */
+                       priv_offset);
+       /* Zero memory for specific and for the first chain */
        memset (new_pool->priv, 0, sizeof (struct rspamd_mempool_specific) +
                        sizeof (struct _pool_chain));
 
        new_pool->priv->entry = entry;
        new_pool->priv->elt_len = size;
+       new_pool->priv->flags = flags;
 
        if (tag) {
                rspamd_strlcpy (new_pool->tag.tagname, tag, sizeof (new_pool->tag.tagname));
@@ -393,11 +407,11 @@ rspamd_mempool_new_ (gsize size, const gchar *tag, const gchar *loc)
 
        nchain = (struct _pool_chain *)
                        (mem_chunk +
-                       sizeof (rspamd_mempool_t) +
-                       sizeof (struct rspamd_mempool_specific));
+                        priv_offset +
+                        sizeof (struct rspamd_mempool_specific));
 
        guchar *unaligned = mem_chunk +
-                                               sizeof (rspamd_mempool_t) +
+                                               priv_offset +
                                                sizeof (struct rspamd_mempool_specific) +
                                                sizeof (struct _pool_chain);
 
@@ -418,12 +432,13 @@ rspamd_mempool_new_ (gsize size, const gchar *tag, const gchar *loc)
 
 static void *
 memory_pool_alloc_common (rspamd_mempool_t * pool, gsize size,
-                                                 enum rspamd_mempool_chain_type pool_type)
+                                                 enum rspamd_mempool_chain_type pool_type,
+                                                 const gchar *loc)
 RSPAMD_ATTR_ALLOC_SIZE(2) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT) RSPAMD_ATTR_RETURNS_NONNUL;
 
 static void *
 memory_pool_alloc_common (rspamd_mempool_t * pool, gsize size,
-               enum rspamd_mempool_chain_type pool_type)
+               enum rspamd_mempool_chain_type pool_type, const gchar *loc)
 {
        guint8 *tmp;
        struct _pool_chain *new, *cur;
@@ -497,22 +512,21 @@ memory_pool_alloc_common (rspamd_mempool_t * pool, gsize size,
 
 
 void *
-rspamd_mempool_alloc (rspamd_mempool_t * pool, gsize size)
+rspamd_mempool_alloc_ (rspamd_mempool_t * pool, gsize size, const gchar *loc)
 {
-       return memory_pool_alloc_common (pool, size, RSPAMD_MEMPOOL_NORMAL);
+       return memory_pool_alloc_common (pool, size, RSPAMD_MEMPOOL_NORMAL, loc);
 }
 
 void *
-rspamd_mempool_alloc0 (rspamd_mempool_t * pool, gsize size)
+rspamd_mempool_alloc0_ (rspamd_mempool_t * pool, gsize size, const gchar *loc)
 {
-       void *pointer = rspamd_mempool_alloc (pool, size);
-
+       void *pointer = rspamd_mempool_alloc_ (pool, size, loc);
        memset (pointer, 0, size);
 
        return pointer;
 }
 void *
-rspamd_mempool_alloc0_shared (rspamd_mempool_t * pool, gsize size)
+rspamd_mempool_alloc0_shared_ (rspamd_mempool_t * pool, gsize size, const gchar *loc)
 {
        void *pointer = rspamd_mempool_alloc_shared (pool, size);
 
@@ -521,14 +535,14 @@ rspamd_mempool_alloc0_shared (rspamd_mempool_t * pool, gsize size)
 }
 
 void *
-rspamd_mempool_alloc_shared (rspamd_mempool_t * pool, gsize size)
+rspamd_mempool_alloc_shared_ (rspamd_mempool_t * pool, gsize size, const gchar *loc)
 {
-       return memory_pool_alloc_common (pool, size, RSPAMD_MEMPOOL_SHARED);
+       return memory_pool_alloc_common (pool, size, RSPAMD_MEMPOOL_SHARED, loc);
 }
 
 
 gchar *
-rspamd_mempool_strdup (rspamd_mempool_t * pool, const gchar *src)
+rspamd_mempool_strdup_ (rspamd_mempool_t * pool, const gchar *src, const gchar *loc)
 {
        gsize len;
        gchar *newstr;
@@ -538,7 +552,7 @@ rspamd_mempool_strdup (rspamd_mempool_t * pool, const gchar *src)
        }
 
        len = strlen (src);
-       newstr = rspamd_mempool_alloc (pool, len + 1);
+       newstr = rspamd_mempool_alloc_ (pool, len + 1, loc);
        memcpy (newstr, src, len);
        newstr[len] = '\0';
 
@@ -546,7 +560,8 @@ rspamd_mempool_strdup (rspamd_mempool_t * pool, const gchar *src)
 }
 
 gchar *
-rspamd_mempool_fstrdup (rspamd_mempool_t * pool, const struct f_str_s *src)
+rspamd_mempool_fstrdup_ (rspamd_mempool_t * pool, const struct f_str_s *src,
+               const gchar *loc)
 {
        gchar *newstr;
 
@@ -554,7 +569,7 @@ rspamd_mempool_fstrdup (rspamd_mempool_t * pool, const struct f_str_s *src)
                return NULL;
        }
 
-       newstr = rspamd_mempool_alloc (pool, src->len + 1);
+       newstr = rspamd_mempool_alloc_ (pool, src->len + 1, loc);
        memcpy (newstr, src->str, src->len);
        newstr[src->len] = '\0';
 
@@ -562,7 +577,8 @@ rspamd_mempool_fstrdup (rspamd_mempool_t * pool, const struct f_str_s *src)
 }
 
 gchar *
-rspamd_mempool_ftokdup (rspamd_mempool_t *pool, const rspamd_ftok_t *src)
+rspamd_mempool_ftokdup_ (rspamd_mempool_t *pool, const rspamd_ftok_t *src,
+               const gchar *loc)
 {
        gchar *newstr;
 
@@ -570,7 +586,7 @@ rspamd_mempool_ftokdup (rspamd_mempool_t *pool, const rspamd_ftok_t *src)
                return NULL;
        }
 
-       newstr = rspamd_mempool_alloc (pool, src->len + 1);
+       newstr = rspamd_mempool_alloc_ (pool, src->len + 1, loc);
        memcpy (newstr, src->begin, src->len);
        newstr[src->len] = '\0';
 
@@ -587,7 +603,7 @@ rspamd_mempool_add_destructor_full (rspamd_mempool_t * pool,
        struct _pool_destructors *cur;
 
        POOL_MTX_LOCK ();
-       cur = rspamd_mempool_alloc (pool, sizeof (*cur));
+       cur = rspamd_mempool_alloc_ (pool, sizeof (*cur), line);
        cur->func = func;
        cur->data = data;
        cur->function = function;

diff --git a/src/libutil/mem_pool.h b/src/libutil/mem_pool.h
index 75e949985673067983f54d13fda0f6615859139b..773be33d3d9af0a9935a026a9f7b5345823959b5 100644 (file)
--- a/src/libutil/mem_pool.h
+++ b/src/libutil/mem_pool.h
@@ -137,9 +137,11 @@ typedef struct memory_pool_stat_s {
  * @param size size of pool's page
  * @return new memory pool object
  */
-rspamd_mempool_t *rspamd_mempool_new_ (gsize size, const gchar *tag, const gchar *loc);
+rspamd_mempool_t *rspamd_mempool_new_ (gsize size, const gchar *tag, gint flags,
+               const gchar *loc);
 
-#define rspamd_mempool_new(size, tag) rspamd_mempool_new_((size), (tag), G_STRLOC)
+#define rspamd_mempool_new(size, tag, flags) \
+       rspamd_mempool_new_((size), (tag), (flags), G_STRLOC)
 
 /**
  * Get memory from pool
@@ -147,8 +149,10 @@ rspamd_mempool_t *rspamd_mempool_new_ (gsize size, const gchar *tag, const gchar
  * @param size bytes to allocate
  * @return pointer to allocated object
  */
-void *rspamd_mempool_alloc (rspamd_mempool_t *pool, gsize size)
+void *rspamd_mempool_alloc_ (rspamd_mempool_t *pool, gsize size, const gchar *loc)
 RSPAMD_ATTR_ALLOC_SIZE(2) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT) RSPAMD_ATTR_RETURNS_NONNUL;
+#define rspamd_mempool_alloc(pool, size) \
+       rspamd_mempool_alloc_((pool), (size), G_STRLOC)
 
 /**
  * Get memory and set it to zero
@@ -156,8 +160,10 @@ RSPAMD_ATTR_ALLOC_SIZE(2) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT) RSPAMD_ATTR
  * @param size bytes to allocate
  * @return pointer to allocated object
  */
-void *rspamd_mempool_alloc0 (rspamd_mempool_t *pool, gsize size)
+void *rspamd_mempool_alloc0_ (rspamd_mempool_t *pool, gsize size, const gchar *loc)
 RSPAMD_ATTR_ALLOC_SIZE(2) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT) RSPAMD_ATTR_RETURNS_NONNUL;
+#define rspamd_mempool_alloc0(pool, size) \
+       rspamd_mempool_alloc0_((pool), (size), G_STRLOC)
 
 /**
  * Make a copy of string in pool
@@ -165,8 +171,10 @@ RSPAMD_ATTR_ALLOC_SIZE(2) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT) RSPAMD_ATTR
  * @param src source string
  * @return pointer to newly created string that is copy of src
  */
-gchar *rspamd_mempool_strdup (rspamd_mempool_t *pool, const gchar *src)
+gchar *rspamd_mempool_strdup_ (rspamd_mempool_t *pool, const gchar *src, const gchar *loc)
 RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT);
+#define rspamd_mempool_strdup(pool, src) \
+       rspamd_mempool_strdup_ ((pool), (src), G_STRLOC)
 
 /**
  * Make a copy of fixed string in pool as null terminated string
@@ -174,8 +182,12 @@ RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT);
  * @param src source string
  * @return pointer to newly created string that is copy of src
  */
-gchar *rspamd_mempool_fstrdup (rspamd_mempool_t *pool,
-                                                          const struct f_str_s *src) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT);
+gchar *rspamd_mempool_fstrdup_ (rspamd_mempool_t *pool,
+                                                               const struct f_str_s *src,
+                                                               const gchar *loc)
+RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT);
+#define rspamd_mempool_fstrdup(pool, src) \
+       rspamd_mempool_fstrdup_ ((pool), (src), G_STRLOC)
 
 struct f_str_tok;
 
@@ -185,19 +197,27 @@ struct f_str_tok;
  * @param src source string
  * @return pointer to newly created string that is copy of src
  */
-gchar *rspamd_mempool_ftokdup (rspamd_mempool_t *pool,
-                                                          const struct f_str_tok *src) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT);
+gchar *rspamd_mempool_ftokdup_ (rspamd_mempool_t *pool,
+                                                               const struct f_str_tok *src,
+                                                               const gchar *loc)
+RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT);
+#define rspamd_mempool_ftokdup(pool, src) \
+       rspamd_mempool_ftokdup_ ((pool), (src), G_STRLOC)
 
 /**
  * Allocate piece of shared memory
  * @param pool memory pool object
  * @param size bytes to allocate
  */
-void *rspamd_mempool_alloc_shared (rspamd_mempool_t *pool, gsize size)
+void *rspamd_mempool_alloc_shared_ (rspamd_mempool_t *pool, gsize size, const gchar *loc)
 RSPAMD_ATTR_ALLOC_SIZE(2) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT) RSPAMD_ATTR_RETURNS_NONNUL;
+#define rspamd_mempool_alloc_shared(pool, size) \
+       rspamd_mempool_alloc_shared_((pool), (size), G_STRLOC)
 
-void *rspamd_mempool_alloc0_shared (rspamd_mempool_t *pool, gsize size)
+void *rspamd_mempool_alloc0_shared_ (rspamd_mempool_t *pool, gsize size, const gchar *loc)
 RSPAMD_ATTR_ALLOC_SIZE(2) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT) RSPAMD_ATTR_RETURNS_NONNUL;
+#define rspamd_mempool_alloc0_shared(pool, size) \
+       rspamd_mempool_alloc0_shared_((pool), (size), G_STRLOC)
 
 /**
  * Add destructor callback to pool

diff --git a/src/libutil/mem_pool_internal.h b/src/libutil/mem_pool_internal.h
index c96287a68c3a2a7104da9824ebc3240efa3f33b1..1f253e79094226203738380b7b94fdce6e8079e2 100644 (file)
--- a/src/libutil/mem_pool_internal.h
+++ b/src/libutil/mem_pool_internal.h
@@ -60,10 +60,11 @@ struct rspamd_mempool_specific {
        struct _pool_destructors *dtors_head, *dtors_tail;
        GPtrArray *trash_stack;
        GHashTable *variables;                  /**< private memory pool variables                      */
+       struct rspamd_mempool_entry_point *entry;
        gsize elt_len;                            /**< size of an element                                               */
        gsize used_memory;
-       gsize wasted_memory;
-       struct rspamd_mempool_entry_point *entry;
+       guint wasted_memory;
+       gint flags;
 };
 
 /**

diff --git a/src/libutil/radix.c b/src/libutil/radix.c
index 3ea6c6b8c2e58bdde0776fa9462aac91ac850dc9..8eb05cd1fc246d445b0636120275bbae20322990 100644 (file)
--- a/src/libutil/radix.c
+++ b/src/libutil/radix.c
@@ -130,7 +130,7 @@ radix_create_compressed (void)
                return NULL;
        }
 
-       tree->pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), NULL);
+       tree->pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), NULL, 0);
        tree->size = 0;
        tree->duplicates = 0;
        tree->tree = btrie_init (tree->pool);

diff --git a/src/libutil/upstream.c b/src/libutil/upstream.c
index 7d8b8104830934cfae9c61a6c414d0e1a990f597..196d9cde865a91ded01b42e5a6d4d0f7c28ab801 100644 (file)
--- a/src/libutil/upstream.c
+++ b/src/libutil/upstream.c
@@ -258,7 +258,7 @@ rspamd_upstreams_library_init (void)
        ctx = g_malloc0 (sizeof (*ctx));
        memcpy (&ctx->limits, &default_limits, sizeof (ctx->limits));
        ctx->pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
-                       "upstreams");
+                       "upstreams", 0);
 
        ctx->upstreams = g_queue_new ();
        REF_INIT_RETAIN (ctx, rspamd_upstream_ctx_dtor);

diff --git a/src/lua/lua_mempool.c b/src/lua/lua_mempool.c
index 06dcd2d5c0bc94890d58809b431f731bb7d3f2ef..c376ee70108e66d6aedb52fe81861df1499e7238 100644 (file)
--- a/src/lua/lua_mempool.c
+++ b/src/lua/lua_mempool.c
@@ -154,7 +154,7 @@ lua_mempool_create (lua_State *L)
 {
        LUA_TRACE_POINT;
        struct memory_pool_s *mempool = rspamd_mempool_new (
-                       rspamd_mempool_suggest_size (), "lua"), **pmempool;
+                       rspamd_mempool_suggest_size (), "lua", 0), **pmempool;
 
        if (mempool) {
                pmempool = lua_newuserdata (L, sizeof (struct memory_pool_s *));

diff --git a/src/lua/lua_regexp.c b/src/lua/lua_regexp.c
index c0458a8767837bf039b03f40e0e182b5bec90cfa..70a5a5df402181a14e5298872e44cebe69ada895 100644 (file)
--- a/src/lua/lua_regexp.c
+++ b/src/lua/lua_regexp.c
@@ -891,7 +891,7 @@ luaopen_regexp (lua_State * L)
 {
        if (!regexp_static_pool) {
                regexp_static_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
-                               "regexp_lua_pool");
+                               "regexp_lua_pool", 0);
        }
 
        rspamd_lua_new_class (L, "rspamd{regexp}", regexplib_m);

diff --git a/src/lua/lua_url.c b/src/lua/lua_url.c
index c0cfb49b8651728820bd85bebb17eca9dae19b8b..0bd4f1c7e830cf368cdd86cd895df2eec2e73834 100644 (file)
--- a/src/lua/lua_url.c
+++ b/src/lua/lua_url.c
@@ -731,7 +731,7 @@ lua_url_create (lua_State *L)
        }
        else {
                own_pool = TRUE;
-               pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "url");
+               pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "url", 0);
                text = luaL_checklstring (L, 1, &length);
        }
 

diff --git a/src/lua/lua_util.c b/src/lua/lua_util.c
index ef9c3105e021c78f534e9237a84f4024f9fae7b0..b713394029f30818b11dd7cd9ab69105c2fb4c53 100644 (file)
--- a/src/lua/lua_util.c
+++ b/src/lua/lua_util.c
@@ -1386,7 +1386,7 @@ lua_util_parse_html (lua_State *L)
        }
 
        if (start != NULL) {
-               pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), NULL);
+               pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), NULL, 0);
                hc = rspamd_mempool_alloc0 (pool, sizeof (*hc));
                in = g_byte_array_sized_new (len);
                g_byte_array_append (in, start, len);
@@ -1456,7 +1456,8 @@ lua_util_parse_addr (lua_State *L)
                        }
                }
                else {
-                       pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "lua util");
+                       pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
+                                       "lua util", 0);
                        own_pool = TRUE;
                }
 
@@ -1660,7 +1661,8 @@ lua_util_parse_mail_address (lua_State *L)
                        }
                }
                else {
-                       pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "lua util");
+                       pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
+                                       "lua util", 0);
                        own_pool = TRUE;
                }
 

diff --git a/src/lua/lua_worker.c b/src/lua/lua_worker.c
index 4a3e4e908c212804b98546516e2252e4c18c9a52..17266ae96dc7ece1348441248c4d421fb272f678 100644 (file)
--- a/src/lua/lua_worker.c
+++ b/src/lua/lua_worker.c
@@ -423,7 +423,7 @@ lua_worker_add_control_handler (lua_State *L)
                }
 
                rspamd_mempool_t *pool = rspamd_mempool_new (
-                               rspamd_mempool_suggest_size (), "lua_control");
+                               rspamd_mempool_suggest_size (), "lua_control", 0);
                cbd = rspamd_mempool_alloc0 (pool, sizeof (*cbd));
                cbd->pool = pool;
                cbd->event_loop = event_loop;

diff --git a/src/plugins/fuzzy_check.c b/src/plugins/fuzzy_check.c
index 9874c8bbc071834db203f67c1ada8d34832858ac..713edc41b29864924363bdcf105da7571806560b 100644 (file)
--- a/src/plugins/fuzzy_check.c
+++ b/src/plugins/fuzzy_check.c
@@ -618,7 +618,8 @@ fuzzy_check_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
        fuzzy_module_ctx = rspamd_mempool_alloc0 (cfg->cfg_pool,
                        sizeof (struct fuzzy_ctx));
 
-       fuzzy_module_ctx->fuzzy_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), NULL);
+       fuzzy_module_ctx->fuzzy_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
+                       NULL, 0);
        /* TODO: this should match rules count actually */
        fuzzy_module_ctx->keypairs_cache = rspamd_keypair_cache_new (32);
        fuzzy_module_ctx->fuzzy_rules = g_ptr_array_new ();

diff --git a/src/rspamadm/rspamadm.c b/src/rspamadm/rspamadm.c
index 661b468afd0635bd859319ca1cd3346aceeaa98e..775b505eedc22b4d8e18228685e623f2de91335c 100644 (file)
--- a/src/rspamadm/rspamadm.c
+++ b/src/rspamadm/rspamadm.c
@@ -396,7 +396,7 @@ main (gint argc, gchar **argv, gchar **env)
        rspamd_main->pid = getpid ();
        rspamd_main->type = process_quark;
        rspamd_main->server_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
-                       "rspamadm");
+                       "rspamadm", 0);
 
        rspamadm_fill_internal_commands (all_commands);
        help_command.command_data = all_commands;

diff --git a/src/rspamd.c b/src/rspamd.c
index b7c3bd910ff03f7b409ac9414b1ffef3948e6eae..f25884f6fd4c8ccd3efa7b39d7b82d7c1a94be94 100644 (file)
--- a/src/rspamd.c
+++ b/src/rspamd.c
@@ -1186,7 +1186,7 @@ main (gint argc, gchar **argv, gchar **env)
        rspamd_main = (struct rspamd_main *) g_malloc0 (sizeof (struct rspamd_main));
 
        rspamd_main->server_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
-                       "main");
+                       "main", 0);
        rspamd_main->stat = rspamd_mempool_alloc0_shared (rspamd_main->server_pool,
                        sizeof (struct rspamd_stat));
        rspamd_main->cfg = rspamd_config_new (RSPAMD_CONFIG_INIT_DEFAULT);

diff --git a/src/rspamd_proxy.c b/src/rspamd_proxy.c
index 2a0cadbf10a753b4e91ae731a55f69944f26b78d..6153ddd21d61f448449f542d27ea26b16788e190 100644 (file)
--- a/src/rspamd_proxy.c
+++ b/src/rspamd_proxy.c
@@ -1172,7 +1172,7 @@ proxy_session_refresh (struct rspamd_proxy_session *session)
        session->client_addr = NULL;
        nsession->ctx = session->ctx;
        nsession->worker = session->worker;
-       nsession->pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "proxy");
+       nsession->pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "proxy", 0);
        nsession->client_sock = session->client_sock;
        session->client_sock = -1;
        nsession->mirror_conns = g_ptr_array_sized_new (nsession->ctx->mirrors->len);
@@ -2169,7 +2169,7 @@ proxy_accept_socket (EV_P_ ev_io *w, int revents)
        session->mirror_conns = g_ptr_array_sized_new (ctx->mirrors->len);
 
        session->pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
-                       "proxy");
+                       "proxy", 0);
        session->ctx = ctx;
        session->worker = worker;
 

diff --git a/test/rspamd_dns_test.c b/test/rspamd_dns_test.c
index 6b12746aed598659b23e755e2fcf63e26ded0b4b..25c28528efc27db439b1fe25f7b44b56fc8c7a4f 100644 (file)
--- a/test/rspamd_dns_test.c
+++ b/test/rspamd_dns_test.c
@@ -70,11 +70,11 @@ rspamd_dns_test_func ()
 
        cfg = (struct rspamd_config *)g_malloc (sizeof (struct rspamd_config));
        bzero (cfg, sizeof (struct rspamd_config));
-       cfg->cfg_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), NULL);
+       cfg->cfg_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), NULL, 0);
        cfg->dns_retransmits = 2;
        cfg->dns_timeout = 0.5;
 
-       pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), NULL);
+       pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), NULL, 0);
 
        s = rspamd_session_create (pool, session_fin, NULL, NULL, NULL);
 

diff --git a/test/rspamd_mem_pool_test.c b/test/rspamd_mem_pool_test.c
index 61b9a7a9460ffdefe97802ae331b299bc242e5fb..61b4efe3f02236790cebb0352c71da7c7ad7a4c9 100644 (file)
--- a/test/rspamd_mem_pool_test.c
+++ b/test/rspamd_mem_pool_test.c
@@ -20,7 +20,7 @@ rspamd_mem_pool_test_func ()
        pid_t pid;
        int ret;
 
-       pool = rspamd_mempool_new (sizeof (TEST_BUF), NULL);
+       pool = rspamd_mempool_new (sizeof (TEST_BUF), NULL, 0);
        tmp = rspamd_mempool_alloc (pool, sizeof (TEST_BUF));
        tmp2 = rspamd_mempool_alloc (pool, sizeof (TEST_BUF) * 2);
        tmp3 = rspamd_mempool_alloc_shared (pool, sizeof (TEST_BUF));
@@ -32,8 +32,8 @@ rspamd_mem_pool_test_func ()
        g_assert (strncmp (tmp, TEST_BUF, sizeof (TEST_BUF)) == 0);
        g_assert (strncmp (tmp2, TEST2_BUF, sizeof (TEST2_BUF)) == 0);
        g_assert (strncmp (tmp3, TEST_BUF, sizeof (TEST_BUF)) == 0);
-       
+
        rspamd_mempool_delete (pool);
        rspamd_mempool_stat (&st);
-       
+
 }

diff --git a/test/rspamd_radix_test.c b/test/rspamd_radix_test.c
index 5a42b36e547a77e35c2a769bd6bf1fbc4e26f70c..dda0bff366278cecae85d8e059cb151dbc6ca10f 100644 (file)
--- a/test/rspamd_radix_test.c
+++ b/test/rspamd_radix_test.c
@@ -148,7 +148,7 @@ rspamd_btrie_test_vec (void)
        gsize i;
        gpointer val;
 
-       pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "btrie");
+       pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), "btrie", 0);
        tree = btrie_init (pool);
 
        while (t->ip != NULL) {
@@ -238,7 +238,7 @@ rspamd_radix_test_func (void)
                addrs[i].mask6 = ottery_rand_range(128);
        }
 
-       pool = rspamd_mempool_new (65536, "btrie");
+       pool = rspamd_mempool_new (65536, "btrie", 0);
        btrie = btrie_init (pool);
        msg_notice ("btrie performance (%z elts)", nelts);
 

diff --git a/test/rspamd_test_suite.c b/test/rspamd_test_suite.c
index db12a1a0cc23c25946edee21a39d9ad05b07ad27..d7b6606425b0f7b88732860a785a885ae4d3edce 100644 (file)
--- a/test/rspamd_test_suite.c
+++ b/test/rspamd_test_suite.c
@@ -31,11 +31,11 @@ main (int argc, char **argv)
 
        rspamd_main = (struct rspamd_main *)g_malloc (sizeof (struct rspamd_main));
        memset (rspamd_main, 0, sizeof (struct rspamd_main));
-       rspamd_main->server_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), NULL);
+       rspamd_main->server_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), NULL, 0);
        cfg = rspamd_config_new (RSPAMD_CONFIG_INIT_DEFAULT);
        cfg->libs_ctx = rspamd_init_libs ();
        rspamd_main->cfg = cfg;
-       cfg->cfg_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), NULL);
+       cfg->cfg_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (), NULL, 0);
        cfg->log_type = RSPAMD_LOG_CONSOLE;
        cfg->log_level = G_LOG_LEVEL_MESSAGE;