/*
Bacula® - The Network Backup Solution
- Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
+ Copyright (C) 2000-2011 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
+ modify it under the terms of version three of the GNU Affero General Public
License as published by the Free Software Foundation and included
in the file LICENSE.
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
+ You should have received a copy of the GNU Affero 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.
+ Bacula® is a registered trademark of Kern Sibbald.
The licensor of Bacula is the Free Software Foundation Europe
(FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
Switzerland, email:ftf@fsfeurope.org.
*
* Kern E. Sibbald
*
- * Version $Id$
*/
#include "bacula.h"
+#ifdef HAVE_MALLOC_TRIM
+extern "C" int malloc_trim (size_t pad);
+#endif
+
struct s_pool_ctl {
int32_t size; /* default size */
int32_t max_allocated; /* max allocated */
{ 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
{ 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
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-
#ifdef SMARTALLOC
#define HEAD_SIZE BALIGN(sizeof(struct abufhead))
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;
}
V(mutex);
}
-
#else
/* ========= NO SMARTALLOC ========================================= */
return (POOLMEM *)(((char *)buf)+HEAD_SIZE);
}
-
/* Return the size of a memory buffer */
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)
{
return (POOLMEM *)(((char *)buf)+HEAD_SIZE);
}
-
POOLMEM *check_pool_memory_size(POOLMEM *obuf, int32_t size)
{
ASSERT(obuf);
Dmsg2(1800, "free_pool_memory %p pool=%d\n", buf, pool);
V(mutex);
}
-
#endif /* SMARTALLOC */
-
/*
* Clean up memory pool periodically
*
if (now >= last_garbage_collection + garbage_interval) {
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;
}
pool_ctl[i].free_buf = NULL;
}
- Dmsg2(100, "Freed mem_pool count=%d size=%s\n", count, edit_uint64_with_commas(bytes, ed1));
+ Dmsg2(001, "Freed mem_pool count=%d size=%s\n", count, edit_uint64_with_commas(bytes, ed1));
+ if (debug_level >= 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) {
void print_memory_pool_stats() {}
#endif /* DEBUG */
-
/*
* Concatenate a string (str) onto a pool memory buffer pm
* Returns: length of concatenated string
return pmlen + len - 1;
}
-
int pm_strcat(POOLMEM *&pm, POOL_MEM &str)
{
int pmlen = strlen(pm);
return pmlen + len - 1;
}
-
/*
* Copy a string (str) into a pool memory buffer pm
* Returns: length of string copied
return len - 1;
}
-
int pm_strcpy(POOL_MEM &pm, const char *str)
{
int 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 */
return pmlen + len - 1;
}
-
int POOL_MEM::strcpy(const char *str)
{
int len;
projects / bacula / bacula / blobdiff