X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Flib%2Fmem_pool.c;h=a371fdd737f746b5dbbc1cef0064bfbdc251d435;hb=897707854a8240d026e933215009f931bb9c5762;hp=686c164e66de160c9e32d1dcc1e148c7d2822f38;hpb=df5f98ee8de968e28ff5a9b5725511a743cb2bcc;p=bacula%2Fbacula diff --git a/bacula/src/lib/mem_pool.c b/bacula/src/lib/mem_pool.c index 686c164e66..a371fdd737 100644 --- a/bacula/src/lib/mem_pool.c +++ b/bacula/src/lib/mem_pool.c @@ -1,51 +1,50 @@ -/* - * Bacula memory pool routines. - * - * The idea behind these routines is that there will be - * pools of memory that are pre-allocated for quick - * access. The pools will have a fixed memory size on allocation - * but if need be, the size can be increased. This is - * particularly useful for filename - * buffers where 256 bytes should be sufficient in 99.99% - * of the cases, but when it isn't we want to be able to - * increase the size. - * - * A major advantage of the pool memory aside from the speed - * is that the buffer carrys around its size, so to ensure that - * there is enough memory, simply call the check_pool_memory_size() - * with the desired size and it will adjust only if necessary. - * - * Kern E. Sibbald - * - * Version $Id$ - */ /* Bacula® - The Network Backup Solution - Copyright (C) 2000-2006 Free Software Foundation Europe e.V. + Copyright (C) 2000-2010 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. + 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. 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 + 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. */ +/* + * Bacula memory pool routines. + * + * The idea behind these routines is that there will be + * pools of memory that are pre-allocated for quick + * access. The pools will have a fixed memory size on allocation + * but if need be, the size can be increased. This is + * particularly useful for filename + * buffers where 256 bytes should be sufficient in 99.99% + * of the cases, but when it isn't we want to be able to + * increase the size. + * + * A major advantage of the pool memory aside from the speed + * is that the buffer carrys around its size, so to ensure that + * there is enough memory, simply call the check_pool_memory_size() + * with the desired size and it will adjust only if necessary. + * + * Kern E. Sibbald + * + */ #include "bacula.h" @@ -90,11 +89,11 @@ 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() */ }; static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; - #ifdef SMARTALLOC #define HEAD_SIZE BALIGN(sizeof(struct abufhead)) @@ -153,13 +152,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; } @@ -230,7 +230,6 @@ void sm_free_pool_memory(const char *fname, int lineno, POOLMEM *obuf) V(mutex); } - #else /* ========= NO SMARTALLOC ========================================= */ @@ -281,7 +280,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 +290,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 +314,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); @@ -358,10 +353,8 @@ void free_pool_memory(POOLMEM *obuf) Dmsg2(1800, "free_pool_memory %p pool=%d\n", buf, pool); V(mutex); } - #endif /* SMARTALLOC */ - /* * Clean up memory pool periodically * @@ -390,9 +383,6 @@ void garbage_collect_memory_pool() } } - - - /* Release all pooled memory */ void close_memory_pool() { @@ -414,13 +404,15 @@ 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(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 - static const char *pool_name(int pool) { static const char *name[] = {"NoPool", "NAME ", "FNAME ", "MSG ", "EMSG "}; @@ -449,7 +441,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 +448,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 +461,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,22 +484,27 @@ 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; } - /* * Copy a string (str) into a pool memory buffer pm * Returns: length of string copied */ 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 +512,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 +531,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 +615,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;