2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2009 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version two of the GNU General Public
10 License as published by the Free Software Foundation and included
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of Kern Sibbald.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
31 Smart Memory Allocator
33 Evolved over several years, starting with the initial
34 SMARTALLOC code for AutoSketch in 1986, guided by the Blind
35 Watchbreaker, John Walker. Isolated in this general-purpose
36 form in September of 1989. Updated with be more POSIX
37 compliant and to include Web-friendly HTML documentation in
38 October of 1998 by the same culprit. For additional
39 information and the current version visit the Web page:
41 http://www.fourmilab.ch/smartall/
48 #define _LOCKMGR_COMPLIANT
51 /* Use the real routines here */
57 /* We normally turn off debugging here.
58 * If you want it, simply #ifdef all the
66 #define Dmsg2(l,f,a1,a2)
67 #define Dmsg3(l,f,a1,a2,a3)
68 #define Dmsg4(l,f,a1,a2,a3,a4)
71 uint64_t sm_max_bytes = 0;
72 uint64_t sm_bytes = 0;
73 uint32_t sm_max_buffers = 0;
74 uint32_t sm_buffers = 0;
78 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
80 extern char my_name[]; /* daemon name */
82 typedef unsigned short sm_ushort;
84 #define EOS '\0' /* End of string sentinel */
85 #define sm_min(a, b) ((a) < (b) ? (a) : (b))
87 /* Queue data structures */
89 /* Memory allocation control structures and storage. */
92 struct b_queue abq; /* Links on allocated queue */
93 unsigned ablen; /* Buffer length in bytes */
94 const char *abfname; /* File name pointer */
95 sm_ushort ablineno; /* Line number of allocation */
96 bool abin_use; /* set when malloced and cleared when free */
99 static struct b_queue abqueue = { /* Allocated buffer queue */
104 static bool bufimode = false; /* Buffers not tracked when True */
106 #define HEAD_SIZE BALIGN(sizeof(struct abufhead))
109 /* SMALLOC -- Allocate buffer, enqueing on the orphaned buffer
112 static void *smalloc(const char *fname, int lineno, unsigned int nbytes)
116 /* Note: Unix MALLOC actually permits a zero length to be
117 passed and allocates a valid block with zero user bytes.
118 Such a block can later be expanded with realloc(). We
119 disallow this based on the belief that it's better to make
120 a special case and allocate one byte in the rare case this
121 is desired than to miss all the erroneous occurrences where
122 buffer length calculation code results in a zero. */
126 nbytes += HEAD_SIZE + 1;
127 if ((buf = (char *)malloc(nbytes)) != NULL) {
128 struct abufhead *head = (struct abufhead *)buf;
130 /* Enqueue buffer on allocated list */
131 qinsert(&abqueue, (struct b_queue *) buf);
132 head->ablen = nbytes;
133 head->abfname = bufimode ? NULL : fname;
134 head->ablineno = (sm_ushort)lineno;
135 head->abin_use = true;
136 /* Emplace end-clobber detector at end of buffer */
137 buf[nbytes - 1] = (uint8_t)((((intptr_t) buf) & 0xFF) ^ 0xC5);
138 buf += HEAD_SIZE; /* Increment to user data start */
139 if (++sm_buffers > sm_max_buffers) {
140 sm_max_buffers = sm_buffers;
143 if (sm_bytes > sm_max_bytes) {
144 sm_max_bytes = sm_bytes;
148 Emsg0(M_ABORT, 0, _("Out of memory\n"));
150 Dmsg4(1150, "smalloc %d at %p from %s:%d\n", nbytes, buf, fname, lineno);
151 #if SMALLOC_SANITY_CHECK > 0
152 if (sm_bytes > SMALLOC_SANITY_CHECK) {
153 Emsg0(M_ABORT, 0, _("Too much memory used."));
159 /* SM_NEW_OWNER -- Update the File and line number for a buffer
160 This is to accomodate mem_pool. */
162 void sm_new_owner(const char *fname, int lineno, char *buf)
164 buf -= HEAD_SIZE; /* Decrement to header */
165 ((struct abufhead *)buf)->abfname = bufimode ? NULL : fname;
166 ((struct abufhead *)buf)->ablineno = (sm_ushort) lineno;
167 ((struct abufhead *)buf)->abin_use = true;
171 /* SM_FREE -- Update free pool availability. FREE is never called
172 except through this interface or by actuallyfree().
173 free(x) is defined to generate a call to this
176 void sm_free(const char *file, int line, void *fp)
178 char *cp = (char *) fp;
182 Emsg2(M_ABORT, 0, _("Attempt to free NULL called from %s:%d\n"), file, line);
186 qp = (struct b_queue *)cp;
187 struct abufhead *head = (struct abufhead *)cp;
190 Dmsg4(1150, "sm_free %d at %p from %s:%d\n",
192 head->abfname, head->ablineno);
194 if (!head->abin_use) {
196 Emsg2(M_ABORT, 0, _("double free from %s:%d\n"), file, line);
198 head->abin_use = false;
200 /* The following assertions will catch virtually every release
201 of an address which isn't an allocated buffer. */
202 if (qp->qnext->qprev != qp) {
204 Emsg2(M_ABORT, 0, _("qp->qnext->qprev != qp called from %s:%d\n"), file, line);
206 if (qp->qprev->qnext != qp) {
208 Emsg2(M_ABORT, 0, _("qp->qprev->qnext != qp called from %s:%d\n"), file, line);
211 /* The following assertion detects storing off the end of the
212 allocated space in the buffer by comparing the end of buffer
213 checksum with the address of the buffer. */
215 if (((unsigned char *)cp)[head->ablen - 1] != ((((intptr_t) cp) & 0xFF) ^ 0xC5)) {
217 Emsg2(M_ABORT, 0, _("Buffer overrun called from %s:%d\n"), file, line);
219 if (sm_buffers > 0) {
221 sm_bytes -= head->ablen;
227 /* Now we wipe the contents of the just-released buffer with
228 "designer garbage" (Duff Kurland's phrase) of alternating
229 bits. This is intended to ruin the day for any miscreant who
230 attempts to access data through a pointer into storage that's
231 been previously released.
233 Modified, kes May, 2007 to not zap the header. This allows us
234 to check the in_use bit and detect doubly freed buffers.
237 memset(cp+HEAD_SIZE, 0xAA, (int)(head->ablen - HEAD_SIZE));
242 /* SM_MALLOC -- Allocate buffer. NULL is returned if no memory
245 void *sm_malloc(const char *fname, int lineno, unsigned int nbytes)
249 if ((buf = smalloc(fname, lineno, nbytes)) != NULL) {
251 /* To catch sloppy code that assumes buffers obtained from
252 malloc() are zeroed, we preset the buffer contents to
253 "designer garbage" consisting of alternating bits. */
255 memset(buf, 0x55, (int) nbytes);
257 Emsg0(M_ABORT, 0, _("Out of memory\n"));
262 /* SM_CALLOC -- Allocate an array and clear it to zero. */
264 void *sm_calloc(const char *fname, int lineno,
265 unsigned int nelem, unsigned int elsize)
269 if ((buf = smalloc(fname, lineno, nelem * elsize)) != NULL) {
270 memset(buf, 0, (int) (nelem * elsize));
272 Emsg0(M_ABORT, 0, _("Out of memory\n"));
277 /* SM_REALLOC -- Adjust the size of a previously allocated buffer.
278 Note that the trick of "resurrecting" a previously
279 freed buffer with realloc() is NOT supported by this
280 function. Further, because of the need to maintain
281 our control storage, SM_REALLOC must always allocate
282 a new block and copy the data in the old block.
283 This may result in programs which make heavy use of
284 realloc() running much slower than normally. */
286 void *sm_realloc(const char *fname, int lineno, void *ptr, unsigned int size)
290 char *cp = (char *) ptr;
292 Dmsg4(400, "sm_realloc %s:%d %p %d\n", fname, lineno, ptr, size);
294 e_msg(fname, lineno, M_ABORT, 0, _("sm_realloc size: %d\n"), size);
297 /* If the old block pointer is NULL, treat realloc() as a
298 malloc(). SVID is silent on this, but many C libraries
301 return sm_malloc(fname, lineno, size);
304 /* If the old and new sizes are the same, be a nice guy and just
305 return the buffer passed in. */
307 struct abufhead *head = (struct abufhead *)cp;
308 osize = head->ablen - (HEAD_SIZE + 1);
313 /* Sizes differ. Allocate a new buffer of the requested size.
314 If we can't obtain such a buffer, act as defined in SVID:
315 return NULL from realloc() and leave the buffer in PTR
319 // sm_bytes -= head->ablen;
321 if ((buf = smalloc(fname, lineno, size)) != NULL) {
322 memcpy(buf, ptr, (int)sm_min(size, osize));
323 /* If the new buffer is larger than the old, fill the balance
324 of it with "designer garbage". */
326 memset(((char *) buf) + osize, 0x55, (int) (size - osize));
329 /* All done. Free and dechain the original buffer. */
330 sm_free(fname, lineno, ptr);
332 Dmsg4(150, _("sm_realloc %d at %p from %s:%d\n"), size, buf, fname, lineno);
336 /* ACTUALLYMALLOC -- Call the system malloc() function to obtain
337 storage which will eventually be released
338 by system or library routines not compiled
341 void *actuallymalloc(unsigned int size)
346 /* ACTUALLYCALLOC -- Call the system calloc() function to obtain
347 storage which will eventually be released
348 by system or library routines not compiled
351 void *actuallycalloc(unsigned int nelem, unsigned int elsize)
353 return calloc(nelem, elsize);
356 /* ACTUALLYREALLOC -- Call the system realloc() function to obtain
357 storage which will eventually be released
358 by system or library routines not compiled
361 void *actuallyrealloc(void *ptr, unsigned int size)
363 Dmsg2(400, "Actuallyrealloc %p %d\n", ptr, size);
364 return realloc(ptr, size);
367 /* ACTUALLYFREE -- Interface to system free() function to release
368 buffers allocated by low-level routines. */
370 void actuallyfree(void *cp)
375 /* SM_DUMP -- Print orphaned buffers (and dump them if BUFDUMP is
377 * N.B. DO NOT USE any Bacula print routines (Dmsg, Jmsg, Emsg, ...)
378 * as they have all been shut down at this point.
380 void sm_dump(bool bufdump, bool in_use)
386 ap = (struct abufhead *)abqueue.qnext;
388 while (ap != (struct abufhead *) &abqueue) {
391 (ap->abq.qnext->qprev != (struct b_queue *) ap) ||
392 (ap->abq.qprev->qnext != (struct b_queue *) ap)) {
394 "\nOrphaned buffers exist. Dump terminated following\n"
395 " discovery of bad links in chain of orphaned buffers.\n"
396 " Buffer address with bad links: %p\n"), ap);
400 if (ap->abfname != NULL) {
401 unsigned memsize = ap->ablen - (HEAD_SIZE + 1);
403 char *cp = ((char *)ap) + HEAD_SIZE;
405 bsnprintf(errmsg, sizeof(errmsg),
406 _("%s buffer: %s %6u bytes buf=%p allocated at %s:%d\n"),
407 in_use?"In use":"Orphaned",
408 my_name, memsize, cp, ap->abfname, ap->ablineno
410 fprintf(stderr, "%s", errmsg);
418 bstrncat(errmsg, "\n", sizeof(errmsg));
420 fprintf(stderr, "%s", errmsg);
423 bsnprintf(buf, sizeof(buf), " %02X",
425 bstrncat(errmsg, buf, sizeof(errmsg));
429 fprintf(stderr, "%s\n", errmsg);
432 ap = (struct abufhead *) ap->abq.qnext;
438 /* SM_CHECK -- Check the buffers and dump if any damage exists. */
439 void sm_check(const char *fname, int lineno, bool bufdump)
441 if (!sm_check_rtn(fname, lineno, bufdump)) {
442 Emsg2(M_ABORT, 0, _("Damaged buffer found. Called from %s:%d\n"),
448 /* SM_CHECK_RTN -- Check the buffers and return 1 if OK otherwise 0 */
449 int sm_check_rtn(const char *fname, int lineno, bool bufdump)
455 ap = (struct abufhead *) abqueue.qnext;
456 while (ap != (struct abufhead *)&abqueue) {
459 if (ap->abq.qnext->qprev != (struct b_queue *)ap) {
462 if (ap->abq.qprev->qnext != (struct b_queue *)ap) {
465 if (((unsigned char *) ap)[((struct abufhead *)ap)->ablen - 1] !=
466 ((((intptr_t) ap) & 0xFF) ^ 0xC5)) {
475 _("\nDamaged buffers found at %s:%d\n"), fname, lineno);
478 fprintf(stderr, _(" discovery of bad prev link.\n"));
481 fprintf(stderr, _(" discovery of bad next link.\n"));
484 fprintf(stderr, _(" discovery of data overrun.\n"));
487 fprintf(stderr, _(" NULL pointer.\n"));
493 fprintf(stderr, _(" Buffer address: %p\n"), ap);
495 if (ap->abfname != NULL) {
496 unsigned memsize = ap->ablen - (HEAD_SIZE + 1);
500 _("Damaged buffer: %6u bytes allocated at line %d of %s %s\n"),
501 memsize, ap->ablineno, my_name, ap->abfname
505 char *cp = ((char *) ap) + HEAD_SIZE;
510 strcat(errmsg, "\n");
512 fprintf(stderr, "%s", errmsg);
516 sprintf(errmsg + strlen(errmsg), " %02X",
519 sprintf(errmsg + strlen(errmsg), " %c ",
525 fprintf(stderr, "%s\n", errmsg);
529 ap = (struct abufhead *)ap->abq.qnext;
533 return badbuf ? 0 : 1;
537 /* SM_STATIC -- Orphaned buffer detection can be disabled (for such
538 items as buffers allocated during initialisation) by
539 calling sm_static(1). Normal orphaned buffer
540 detection can be re-enabled with sm_static(0). Note
541 that all the other safeguards still apply to buffers
542 allocated when sm_static(1) mode is in effect. */
544 void sm_static(bool mode)
550 * Here we overload C++'s global new and delete operators
551 * so that the memory is allocated through smartalloc.
555 void * operator new(size_t size)
557 // Dmsg1(000, "new called %d\n", size);
558 return sm_malloc(__FILE__, __LINE__, size);
561 void operator delete(void *buf)
563 // Dmsg1(000, "free called %p\n", buf);
564 sm_free(__FILE__, __LINE__, buf);