]> git.sur5r.net Git - bacula/bacula/blobdiff - bacula/src/lib/mem_pool.c
Big backport from Enterprise
[bacula/bacula] / bacula / src / lib / mem_pool.c
index 686c164e66de160c9e32d1dcc1e148c7d2822f38..a29e68ef38bf2fb302e0176f373097141dcb67b8 100644 (file)
@@ -1,3 +1,21 @@
+/*
+   Bacula(R) - The Network Backup Solution
+
+   Copyright (C) 2000-2017 Kern Sibbald
+
+   The original author of Bacula is Kern Sibbald, with contributions
+   from many others, a complete list can be found in the file AUTHORS.
+
+   You may use this file and others of this release according to the
+   license defined in the LICENSE file, which includes the Affero General
+   Public License, v3.0 ("AGPLv3") and some additional permissions and
+   terms pursuant to its AGPLv3 Section 7.
+
+   This notice must be preserved when any source code is 
+   conveyed and/or propagated.
+
+   Bacula(R) is a registered trademark of Kern Sibbald.
+*/
 /*
  *  Bacula memory pool routines.
  *
  *
  *           Kern E. Sibbald
  *
- *   Version $Id$
  */
-/*
-   Bacula® - The Network Backup Solution
-
-   Copyright (C) 2000-2006 Free Software Foundation Europe e.V.
-
-   The main author of Bacula is Kern Sibbald, with contributions from
-   many others, a complete list can be found in the file AUTHORS.
-   This program is Free Software; you can redistribute it and/or
-   modify it under the terms of version two of the GNU General Public
-   License as published by the Free Software Foundation plus additions
-   that are listed in the file LICENSE.
-
-   This program is distributed in the hope that it will be useful, but
-   WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-   General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-   02110-1301, USA.
-
-   Bacula® is a registered trademark of John Walker.
-   The licensor of Bacula is the Free Software Foundation Europe
-   (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
-   Switzerland, email:ftf@fsfeurope.org.
-*/
 
 #include "bacula.h"
+#define dbglvl DT_MEMORY|800
+
+#ifdef HAVE_MALLOC_TRIM
+extern "C" int malloc_trim (size_t pad);
+#endif
 
 struct s_pool_ctl {
    int32_t size;                      /* default size */
@@ -70,7 +65,8 @@ static struct s_pool_ctl pool_ctl[] = {
    {  NLEN, NLEN,0, 0, NULL },        /* PM_NAME Bacula name */
    {  256,  256, 0, 0, NULL },        /* PM_FNAME filename buffers */
    {  512,  512, 0, 0, NULL },        /* PM_MESSAGE message buffer */
-   { 1024, 1024, 0, 0, NULL }         /* PM_EMSG error message buffer */
+   { 1024, 1024, 0, 0, NULL },        /* PM_EMSG error message buffer */
+  {  4096, 4096, 0, 0, NULL }         /* PM_BSOCK message buffer */
 };
 #else
 
@@ -80,7 +76,8 @@ static struct s_pool_ctl pool_ctl[] = {
    {  NLEN, NLEN,0, 0, NULL },        /* PM_NAME Bacula name */
    {   20,   20, 0, 0, NULL },        /* PM_FNAME filename buffers */
    {   20,   20, 0, 0, NULL },        /* PM_MESSAGE message buffer */
-   {   20,   20, 0, 0, NULL }         /* PM_EMSG error message buffer */
+   {   20,   20, 0, 0, NULL },        /* PM_EMSG error message buffer */
+   {   20,   20, 0, 0, NULL }         /* PM_BSOCK message buffer */
 };
 #endif
 
@@ -90,15 +87,16 @@ struct abufhead {
    int32_t ablen;                     /* Buffer length in bytes */
    int32_t pool;                      /* pool */
    struct abufhead *next;             /* pointer to next free buffer */
+   int32_t bnet_size;                 /* dummy for bnet_send() */
+   int32_t bnet_extension;            /* dummy for bnet extension */
 };
 
 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 
+#define HEAD_SIZE BALIGN(sizeof(struct abufhead))
 
 #ifdef SMARTALLOC
 
-#define HEAD_SIZE BALIGN(sizeof(struct abufhead))
-
 POOLMEM *sm_get_pool_memory(const char *fname, int lineno, int pool)
 {
    struct abufhead *buf;
@@ -115,7 +113,7 @@ POOLMEM *sm_get_pool_memory(const char *fname, int lineno, int pool)
          pool_ctl[pool].max_used = pool_ctl[pool].in_use;
       }
       V(mutex);
-      Dmsg3(1800, "sm_get_pool_memory reuse %p to %s:%d\n", buf, fname, lineno);
+      Dmsg3(dbglvl, "sm_get_pool_memory reuse %p to %s:%d\n", buf, fname, lineno);
       sm_new_owner(fname, lineno, (char *)buf);
       return (POOLMEM *)((char *)buf+HEAD_SIZE);
    }
@@ -131,7 +129,7 @@ POOLMEM *sm_get_pool_memory(const char *fname, int lineno, int pool)
       pool_ctl[pool].max_used = pool_ctl[pool].in_use;
    }
    V(mutex);
-   Dmsg3(1800, "sm_get_pool_memory give %p to %s:%d\n", buf, fname, lineno);
+   Dmsg3(dbglvl, "sm_get_pool_memory give %p to %s:%d\n", buf, fname, lineno);
    return (POOLMEM *)((char *)buf+HEAD_SIZE);
 }
 
@@ -153,13 +151,14 @@ POOLMEM *sm_get_memory(const char *fname, int lineno, int32_t size)
    return (POOLMEM *)(((char *)buf)+HEAD_SIZE);
 }
 
-
 /* Return the size of a memory buffer */
 int32_t sm_sizeof_pool_memory(const char *fname, int lineno, POOLMEM *obuf)
 {
    char *cp = (char *)obuf;
 
-   ASSERT(obuf);
+   if (obuf == NULL) {
+      Emsg0(M_ABORT, 0, _("obuf is NULL\n"));
+   }
    cp -= HEAD_SIZE;
    return ((struct abufhead *)cp)->ablen;
 }
@@ -211,13 +210,15 @@ void sm_free_pool_memory(const char *fname, int lineno, POOLMEM *obuf)
    if (pool == 0) {
       free((char *)buf);              /* free nonpooled memory */
    } else {                           /* otherwise link it to the free pool chain */
-#ifdef DEBUG
+
+   /* Disabled because it hangs in #5507 */
+#ifdef xDEBUG
       struct abufhead *next;
       /* Don't let him free the same buffer twice */
       for (next=pool_ctl[pool].free_buf; next; next=next->next) {
          if (next == buf) {
-            Dmsg4(1800, "free_pool_memory %p pool=%d from %s:%d\n", buf, pool, fname, lineno);
-            Dmsg4(1800, "bad free_pool_memory %p pool=%d from %s:%d\n", buf, pool, fname, lineno);
+            Dmsg4(dbglvl, "free_pool_memory %p pool=%d from %s:%d\n", buf, pool, fname, lineno);
+            Dmsg4(dbglvl, "bad free_pool_memory %p pool=%d from %s:%d\n", buf, pool, fname, lineno);
             V(mutex);                 /* unblock the pool */
             ASSERT(next != buf);      /* attempt to free twice */
          }
@@ -226,11 +227,10 @@ void sm_free_pool_memory(const char *fname, int lineno, POOLMEM *obuf)
       buf->next = pool_ctl[pool].free_buf;
       pool_ctl[pool].free_buf = buf;
    }
-   Dmsg4(1800, "free_pool_memory %p pool=%d from %s:%d\n", buf, pool, fname, lineno);
+   Dmsg4(dbglvl, "free_pool_memory %p pool=%d from %s:%d\n", buf, pool, fname, lineno);
    V(mutex);
 }
 
-
 #else
 
 /* =========  NO SMARTALLOC  =========================================  */
@@ -247,7 +247,7 @@ POOLMEM *get_pool_memory(int pool)
       return (POOLMEM *)((char *)buf+HEAD_SIZE);
    }
 
-   if ((buf=malloc(pool_ctl[pool].size+HEAD_SIZE)) == NULL) {
+   if ((buf=(struct abufhead*)malloc(pool_ctl[pool].size+HEAD_SIZE)) == NULL) {
       V(mutex);
       Emsg1(M_ABORT, 0, _("Out of memory requesting %d bytes\n"), pool_ctl[pool].size);
    }
@@ -268,7 +268,7 @@ POOLMEM *get_memory(int32_t size)
    struct abufhead *buf;
    int pool = 0;
 
-   if ((buf=malloc(size+HEAD_SIZE)) == NULL) {
+   if ((buf=(struct abufhead *)malloc(size+HEAD_SIZE)) == NULL) {
       Emsg1(M_ABORT, 0, _("Out of memory requesting %d bytes\n"), size);
    }
    buf->ablen = size;
@@ -281,7 +281,6 @@ POOLMEM *get_memory(int32_t size)
    return (POOLMEM *)(((char *)buf)+HEAD_SIZE);
 }
 
-
 /* Return the size of a memory buffer */
 int32_t sizeof_pool_memory(POOLMEM *obuf)
 {
@@ -292,8 +291,6 @@ int32_t sizeof_pool_memory(POOLMEM *obuf)
    return ((struct abufhead *)cp)->ablen;
 }
 
-
-
 /* Realloc pool memory buffer */
 POOLMEM *realloc_pool_memory(POOLMEM *obuf, int32_t size)
 {
@@ -318,7 +315,6 @@ POOLMEM *realloc_pool_memory(POOLMEM *obuf, int32_t size)
    return (POOLMEM *)(((char *)buf)+HEAD_SIZE);
 }
 
-
 POOLMEM *check_pool_memory_size(POOLMEM *obuf, int32_t size)
 {
    ASSERT(obuf);
@@ -355,13 +351,11 @@ void free_pool_memory(POOLMEM *obuf)
       buf->next = pool_ctl[pool].free_buf;
       pool_ctl[pool].free_buf = buf;
    }
-   Dmsg2(1800, "free_pool_memory %p pool=%d\n", buf, pool);
+   Dmsg2(dbglvl, "free_pool_memory %p pool=%d\n", buf, pool);
    V(mutex);
 }
-
 #endif /* SMARTALLOC */
 
-
 /*
  * Clean up memory pool periodically
  *
@@ -381,19 +375,17 @@ void garbage_collect_memory_pool()
       return;
    }
    now = time(NULL);
-   if (now >= last_garbage_collection + garbage_interval) {
+   if (now >= last_garbage_collection + garbage_interval ||
+       sm_bytes > 500000) {
       last_garbage_collection = now;
       V(mutex);
-      close_memory_pool();
+      garbage_collect_memory();
    } else {
       V(mutex);
    }
 }
 
-
-
-
-/* Release all pooled memory */
+/* Release all freed pooled memory */
 void close_memory_pool()
 {
    struct abufhead *buf, *next;
@@ -414,16 +406,33 @@ void close_memory_pool()
       }
       pool_ctl[i].free_buf = NULL;
    }
-   Dmsg2(100, "Freed mem_pool count=%d size=%s\n", count, edit_uint64_with_commas(bytes, ed1));
+   Dmsg2(DT_MEMORY|001, "Freed mem_pool count=%d size=%s\n", count, edit_uint64_with_commas(bytes, ed1));
+   if (chk_dbglvl(DT_MEMORY|1)) {
+      print_memory_pool_stats();
+   }
    V(mutex);
 
 }
 
-#ifdef DEBUG
+/*
+ * Garbage collect and trim memory if possible
+ *  This should be called after all big memory usages
+ *  if possible.
+ */
+void garbage_collect_memory()
+{
+   close_memory_pool();         /* release free chain */
+#ifdef HAVE_MALLOC_TRIM
+   P(mutex);
+   malloc_trim(8192);
+   V(mutex);
+#endif
+}
 
+#ifdef DEBUG
 static const char *pool_name(int pool)
 {
-   static const char *name[] = {"NoPool", "NAME  ", "FNAME ", "MSG   ", "EMSG  "};
+   static const char *name[] = {"NoPool", "NAME  ", "FNAME ", "MSG   ", "EMSG  ", "BSOCK "};
    static char buf[30];
 
    if (pool >= 0 && pool <= PM_MAX) {
@@ -449,7 +458,6 @@ void print_memory_pool_stats()
 void print_memory_pool_stats() {}
 #endif /* DEBUG */
 
-
 /*
  * Concatenate a string (str) onto a pool memory buffer pm
  *   Returns: length of concatenated string
@@ -457,8 +465,11 @@ void print_memory_pool_stats() {}
 int pm_strcat(POOLMEM **pm, const char *str)
 {
    int pmlen = strlen(*pm);
-   int len = strlen(str) + 1;
+   int len;
 
+   if (!str) str = "";
+
+   len = strlen(str) + 1;
    *pm = check_pool_memory_size(*pm, pmlen + len);
    memcpy(*pm+pmlen, str, len);
    return pmlen + len - 1;
@@ -467,14 +478,16 @@ int pm_strcat(POOLMEM **pm, const char *str)
 int pm_strcat(POOLMEM *&pm, const char *str)
 {
    int pmlen = strlen(pm);
-   int len = strlen(str) + 1;
+   int len;
+
+   if (!str) str = "";
 
+   len = strlen(str) + 1;
    pm = check_pool_memory_size(pm, pmlen + len);
    memcpy(pm+pmlen, str, len);
    return pmlen + len - 1;
 }
 
-
 int pm_strcat(POOLMEM *&pm, POOL_MEM &str)
 {
    int pmlen = strlen(pm);
@@ -488,13 +501,26 @@ int pm_strcat(POOLMEM *&pm, POOL_MEM &str)
 int pm_strcat(POOL_MEM &pm, const char *str)
 {
    int pmlen = strlen(pm.c_str());
-   int len = strlen(str) + 1;
+   int len;
+
+   if (!str) str = "";
 
+   len = strlen(str) + 1;
    pm.check_size(pmlen + len);
    memcpy(pm.c_str()+pmlen, str, len);
    return pmlen + len - 1;
 }
 
+int pm_strcat(POOL_MEM &pm, POOL_MEM &str)
+{
+   int pmlen = strlen(pm.c_str());
+   int len;
+
+   len = strlen(str.c_str()) + 1;
+   pm.check_size(pmlen + len);
+   memcpy(pm.c_str()+pmlen, str.c_str(), len);
+   return pmlen + len - 1;
+}
 
 /*
  * Copy a string (str) into a pool memory buffer pm
@@ -502,8 +528,11 @@ int pm_strcat(POOL_MEM &pm, const char *str)
  */
 int pm_strcpy(POOLMEM **pm, const char *str)
 {
-   int len = strlen(str) + 1;
+   int len;
+
+   if (!str) str = "";
 
+   len = strlen(str) + 1;
    *pm = check_pool_memory_size(*pm, len);
    memcpy(*pm, str, len);
    return len - 1;
@@ -511,8 +540,11 @@ int pm_strcpy(POOLMEM **pm, const char *str)
 
 int pm_strcpy(POOLMEM *&pm, const char *str)
 {
-   int len = strlen(str) + 1;
+   int len;
 
+   if (!str) str = "";
+
+   len = strlen(str) + 1;
    pm = check_pool_memory_size(pm, len);
    memcpy(pm, str, len);
    return len - 1;
@@ -527,15 +559,50 @@ int pm_strcpy(POOLMEM *&pm, POOL_MEM &str)
    return len - 1;
 }
 
-
 int pm_strcpy(POOL_MEM &pm, const char *str)
 {
-   int len = strlen(str) + 1;
+   int len;
+
+   if (!str) str = "";
+
+   len = strlen(str) + 1;
    pm.check_size(len);
    memcpy(pm.c_str(), str, len);
    return len - 1;
 }
 
+/*
+ * Copy data into a pool memory buffer pm
+ *   Returns: length of data copied
+ */
+int pm_memcpy(POOLMEM **pm, const char *data, int32_t n)
+{
+   *pm = check_pool_memory_size(*pm, n);
+   memcpy(*pm, data, n);
+   return n;
+}
+
+int pm_memcpy(POOLMEM *&pm, const char *data, int32_t n)
+{
+   pm = check_pool_memory_size(pm, n);
+   memcpy(pm, data, n);
+   return n;
+}
+
+int pm_memcpy(POOLMEM *&pm, POOL_MEM &data, int32_t n)
+{
+   pm = check_pool_memory_size(pm, n);
+   memcpy(pm, data.c_str(), n);
+   return n;
+}
+
+int pm_memcpy(POOL_MEM &pm, const char *data, int32_t n)
+{
+   pm.check_size(n);
+   memcpy(pm.c_str(), data, n);
+   return n;
+}
+
 /* ==============  CLASS POOL_MEM   ============== */
 
 /* Return the size of a memory buffer */
@@ -576,17 +643,23 @@ void POOL_MEM::realloc_pm(int32_t size)
 int POOL_MEM::strcat(const char *str)
 {
    int pmlen = strlen(mem);
-   int len = strlen(str) + 1;
+   int len;
 
+   if (!str) str = "";
+
+   len = strlen(str) + 1;
    check_size(pmlen + len);
    memcpy(mem+pmlen, str, len);
    return pmlen + len - 1;
 }
 
-
 int POOL_MEM::strcpy(const char *str)
 {
-   int len = strlen(str) + 1;
+   int len;
+
+   if (!str) str = "";
+
+   len = strlen(str) + 1;
    check_size(len);
    memcpy(mem, str, len);
    return len - 1;