git.sur5r.net Git - bacula/bacula/blob - bacula/src/lib/mem_pool.c

   1 /*
   2    Bacula(R) - The Network Backup Solution
   3
   4    Copyright (C) 2000-2016 Kern Sibbald
   5
   6    The original author of Bacula is Kern Sibbald, with contributions
   7    from many others, a complete list can be found in the file AUTHORS.
   8
   9    You may use this file and others of this release according to the
  10    license defined in the LICENSE file, which includes the Affero General
  11    Public License, v3.0 ("AGPLv3") and some additional permissions and
  12    terms pursuant to its AGPLv3 Section 7.
  13
  14    This notice must be preserved when any source code is
  15    conveyed and/or propagated.
  16
  17    Bacula(R) is a registered trademark of Kern Sibbald.
  18 */
  19 /*
  20  *  Bacula memory pool routines.
  21  *
  22  *  The idea behind these routines is that there will be
  23  *  pools of memory that are pre-allocated for quick
  24  *  access. The pools will have a fixed memory size on allocation
  25  *  but if need be, the size can be increased. This is
  26  *  particularly useful for filename
  27  *  buffers where 256 bytes should be sufficient in 99.99%
  28  *  of the cases, but when it isn't we want to be able to
  29  *  increase the size.
  30  *
  31  *  A major advantage of the pool memory aside from the speed
  32  *  is that the buffer carrys around its size, so to ensure that
  33  *  there is enough memory, simply call the check_pool_memory_size()
  34  *  with the desired size and it will adjust only if necessary.
  35  *
  36  *           Kern E. Sibbald
  37  *
  38  */
  39
  40 #include "bacula.h"
  41 #define dbglvl DT_MEMORY|800
  42
  43 #ifdef HAVE_MALLOC_TRIM
  44 extern "C" int malloc_trim (size_t pad);
  45 #endif
  46
  47 struct s_pool_ctl {
  48    int32_t size;                      /* default size */
  49    int32_t max_allocated;             /* max allocated */
  50    int32_t max_used;                  /* max buffers used */
  51    int32_t in_use;                    /* number in use */
  52    struct abufhead *free_buf;         /* pointer to free buffers */
  53 };
  54
  55 /* Bacula Name length plus extra */
  56 #define NLEN (MAX_NAME_LENGTH+2)
  57
  58 /* #define STRESS_TEST_POOL */
  59 #ifndef STRESS_TEST_POOL
  60 /*
  61  * Define default Pool buffer sizes
  62  */
  63 static struct s_pool_ctl pool_ctl[] = {
  64    {  256,  256, 0, 0, NULL },        /* PM_NOPOOL no pooling */
  65    {  NLEN, NLEN,0, 0, NULL },        /* PM_NAME Bacula name */
  66    {  256,  256, 0, 0, NULL },        /* PM_FNAME filename buffers */
  67    {  512,  512, 0, 0, NULL },        /* PM_MESSAGE message buffer */
  68    { 1024, 1024, 0, 0, NULL },        /* PM_EMSG error message buffer */
  69   {  4096, 4096, 0, 0, NULL }         /* PM_BSOCK message buffer */
  70 };
  71 #else
  72
  73 /* This is used ONLY when stress testing the code */
  74 static struct s_pool_ctl pool_ctl[] = {
  75    {   20,   20, 0, 0, NULL },        /* PM_NOPOOL no pooling */
  76    {  NLEN, NLEN,0, 0, NULL },        /* PM_NAME Bacula name */
  77    {   20,   20, 0, 0, NULL },        /* PM_FNAME filename buffers */
  78    {   20,   20, 0, 0, NULL },        /* PM_MESSAGE message buffer */
  79    {   20,   20, 0, 0, NULL },        /* PM_EMSG error message buffer */
  80    {   20,   20, 0, 0, NULL }         /* PM_BSOCK message buffer */
  81 };
  82 #endif
  83
  84
  85 /*  Memory allocation control structures and storage.  */
  86 struct abufhead {
  87    int32_t ablen;                     /* Buffer length in bytes */
  88    int32_t pool;                      /* pool */
  89    struct abufhead *next;             /* pointer to next free buffer */
  90    int32_t bnet_size;                 /* dummy for bnet_send() */
  91    int32_t bnet_extension;            /* dummy for bnet extension */
  92 };
  93
  94 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  95
  96 #define HEAD_SIZE BALIGN(sizeof(struct abufhead))
  97
  98 #ifdef SMARTALLOC
  99
 100 POOLMEM *sm_get_pool_memory(const char *fname, int lineno, int pool)
 101 {
 102    struct abufhead *buf;
 103
 104    if (pool > PM_MAX) {
 105       Emsg2(M_ABORT, 0, _("MemPool index %d larger than max %d\n"), pool, PM_MAX);
 106    }
 107    P(mutex);
 108    if (pool_ctl[pool].free_buf) {
 109       buf = pool_ctl[pool].free_buf;
 110       pool_ctl[pool].free_buf = buf->next;
 111       pool_ctl[pool].in_use++;
 112       if (pool_ctl[pool].in_use > pool_ctl[pool].max_used) {
 113          pool_ctl[pool].max_used = pool_ctl[pool].in_use;
 114       }
 115       V(mutex);
 116       Dmsg3(dbglvl, "sm_get_pool_memory reuse %p to %s:%d\n", buf, fname, lineno);
 117       sm_new_owner(fname, lineno, (char *)buf);
 118       return (POOLMEM *)((char *)buf+HEAD_SIZE);
 119    }
 120
 121    if ((buf = (struct abufhead *)sm_malloc(fname, lineno, pool_ctl[pool].size+HEAD_SIZE)) == NULL) {
 122       V(mutex);
 123       Emsg1(M_ABORT, 0, _("Out of memory requesting %d bytes\n"), pool_ctl[pool].size);
 124    }
 125    buf->ablen = pool_ctl[pool].size;
 126    buf->pool = pool;
 127    pool_ctl[pool].in_use++;
 128    if (pool_ctl[pool].in_use > pool_ctl[pool].max_used) {
 129       pool_ctl[pool].max_used = pool_ctl[pool].in_use;
 130    }
 131    V(mutex);
 132    Dmsg3(dbglvl, "sm_get_pool_memory give %p to %s:%d\n", buf, fname, lineno);
 133    return (POOLMEM *)((char *)buf+HEAD_SIZE);
 134 }
 135
 136 /* Get nonpool memory of size requested */
 137 POOLMEM *sm_get_memory(const char *fname, int lineno, int32_t size)
 138 {
 139    struct abufhead *buf;
 140    int pool = 0;
 141
 142    if ((buf = (struct abufhead *)sm_malloc(fname, lineno, size+HEAD_SIZE)) == NULL) {
 143       Emsg1(M_ABORT, 0, _("Out of memory requesting %d bytes\n"), size);
 144    }
 145    buf->ablen = size;
 146    buf->pool = pool;
 147    buf->next = NULL;
 148    pool_ctl[pool].in_use++;
 149    if (pool_ctl[pool].in_use > pool_ctl[pool].max_used)
 150       pool_ctl[pool].max_used = pool_ctl[pool].in_use;
 151    return (POOLMEM *)(((char *)buf)+HEAD_SIZE);
 152 }
 153
 154 /* Return the size of a memory buffer */
 155 int32_t sm_sizeof_pool_memory(const char *fname, int lineno, POOLMEM *obuf)
 156 {
 157    char *cp = (char *)obuf;
 158
 159    if (obuf == NULL) {
 160       Emsg0(M_ABORT, 0, _("obuf is NULL\n"));
 161    }
 162    cp -= HEAD_SIZE;
 163    return ((struct abufhead *)cp)->ablen;
 164 }
 165
 166 /* Realloc pool memory buffer */
 167 POOLMEM *sm_realloc_pool_memory(const char *fname, int lineno, POOLMEM *obuf, int32_t size)
 168 {
 169    char *cp = (char *)obuf;
 170    void *buf;
 171    int pool;
 172
 173    ASSERT(obuf);
 174    P(mutex);
 175    cp -= HEAD_SIZE;
 176    buf = sm_realloc(fname, lineno, cp, size+HEAD_SIZE);
 177    if (buf == NULL) {
 178       V(mutex);
 179       Emsg1(M_ABORT, 0, _("Out of memory requesting %d bytes\n"), size);
 180    }
 181    ((struct abufhead *)buf)->ablen = size;
 182    pool = ((struct abufhead *)buf)->pool;
 183    if (size > pool_ctl[pool].max_allocated) {
 184       pool_ctl[pool].max_allocated = size;
 185    }
 186    V(mutex);
 187    return (POOLMEM *)(((char *)buf)+HEAD_SIZE);
 188 }
 189
 190 POOLMEM *sm_check_pool_memory_size(const char *fname, int lineno, POOLMEM *obuf, int32_t size)
 191 {
 192    ASSERT(obuf);
 193    if (size <= sizeof_pool_memory(obuf)) {
 194       return obuf;
 195    }
 196    return realloc_pool_memory(obuf, size);
 197 }
 198
 199 /* Free a memory buffer */
 200 void sm_free_pool_memory(const char *fname, int lineno, POOLMEM *obuf)
 201 {
 202    struct abufhead *buf;
 203    int pool;
 204
 205    ASSERT(obuf);
 206    P(mutex);
 207    buf = (struct abufhead *)((char *)obuf - HEAD_SIZE);
 208    pool = buf->pool;
 209    pool_ctl[pool].in_use--;
 210    if (pool == 0) {
 211       free((char *)buf);              /* free nonpooled memory */
 212    } else {                           /* otherwise link it to the free pool chain */
 213
 214    /* Disabled because it hangs in #5507 */
 215 #ifdef xDEBUG
 216       struct abufhead *next;
 217       /* Don't let him free the same buffer twice */
 218       for (next=pool_ctl[pool].free_buf; next; next=next->next) {
 219          if (next == buf) {
 220             Dmsg4(dbglvl, "free_pool_memory %p pool=%d from %s:%d\n", buf, pool, fname, lineno);
 221             Dmsg4(dbglvl, "bad free_pool_memory %p pool=%d from %s:%d\n", buf, pool, fname, lineno);
 222             V(mutex);                 /* unblock the pool */
 223             ASSERT(next != buf);      /* attempt to free twice */
 224          }
 225       }
 226 #endif
 227       buf->next = pool_ctl[pool].free_buf;
 228       pool_ctl[pool].free_buf = buf;
 229    }
 230    Dmsg4(dbglvl, "free_pool_memory %p pool=%d from %s:%d\n", buf, pool, fname, lineno);
 231    V(mutex);
 232 }
 233
 234 #else
 235
 236 /* =========  NO SMARTALLOC  =========================================  */
 237
 238 POOLMEM *get_pool_memory(int pool)
 239 {
 240    struct abufhead *buf;
 241
 242    P(mutex);
 243    if (pool_ctl[pool].free_buf) {
 244       buf = pool_ctl[pool].free_buf;
 245       pool_ctl[pool].free_buf = buf->next;
 246       V(mutex);
 247       return (POOLMEM *)((char *)buf+HEAD_SIZE);
 248    }
 249
 250    if ((buf=(struct abufhead*)malloc(pool_ctl[pool].size+HEAD_SIZE)) == NULL) {
 251       V(mutex);
 252       Emsg1(M_ABORT, 0, _("Out of memory requesting %d bytes\n"), pool_ctl[pool].size);
 253    }
 254    buf->ablen = pool_ctl[pool].size;
 255    buf->pool = pool;
 256    buf->next = NULL;
 257    pool_ctl[pool].in_use++;
 258    if (pool_ctl[pool].in_use > pool_ctl[pool].max_used) {
 259       pool_ctl[pool].max_used = pool_ctl[pool].in_use;
 260    }
 261    V(mutex);
 262    return (POOLMEM *)(((char *)buf)+HEAD_SIZE);
 263 }
 264
 265 /* Get nonpool memory of size requested */
 266 POOLMEM *get_memory(int32_t size)
 267 {
 268    struct abufhead *buf;
 269    int pool = 0;
 270
 271    if ((buf=(struct abufhead *)malloc(size+HEAD_SIZE)) == NULL) {
 272       Emsg1(M_ABORT, 0, _("Out of memory requesting %d bytes\n"), size);
 273    }
 274    buf->ablen = size;
 275    buf->pool = pool;
 276    buf->next = NULL;
 277    pool_ctl[pool].in_use++;
 278    if (pool_ctl[pool].in_use > pool_ctl[pool].max_used) {
 279       pool_ctl[pool].max_used = pool_ctl[pool].in_use;
 280    }
 281    return (POOLMEM *)(((char *)buf)+HEAD_SIZE);
 282 }
 283
 284 /* Return the size of a memory buffer */
 285 int32_t sizeof_pool_memory(POOLMEM *obuf)
 286 {
 287    char *cp = (char *)obuf;
 288
 289    ASSERT(obuf);
 290    cp -= HEAD_SIZE;
 291    return ((struct abufhead *)cp)->ablen;
 292 }
 293
 294 /* Realloc pool memory buffer */
 295 POOLMEM *realloc_pool_memory(POOLMEM *obuf, int32_t size)
 296 {
 297    char *cp = (char *)obuf;
 298    void *buf;
 299    int pool;
 300
 301    ASSERT(obuf);
 302    P(mutex);
 303    cp -= HEAD_SIZE;
 304    buf = realloc(cp, size+HEAD_SIZE);
 305    if (buf == NULL) {
 306       V(mutex);
 307       Emsg1(M_ABORT, 0, _("Out of memory requesting %d bytes\n"), size);
 308    }
 309    ((struct abufhead *)buf)->ablen = size;
 310    pool = ((struct abufhead *)buf)->pool;
 311    if (size > pool_ctl[pool].max_allocated) {
 312       pool_ctl[pool].max_allocated = size;
 313    }
 314    V(mutex);
 315    return (POOLMEM *)(((char *)buf)+HEAD_SIZE);
 316 }
 317
 318 POOLMEM *check_pool_memory_size(POOLMEM *obuf, int32_t size)
 319 {
 320    ASSERT(obuf);
 321    if (size <= sizeof_pool_memory(obuf)) {
 322       return obuf;
 323    }
 324    return realloc_pool_memory(obuf, size);
 325 }
 326
 327 /* Free a memory buffer */
 328 void free_pool_memory(POOLMEM *obuf)
 329 {
 330    struct abufhead *buf;
 331    int pool;
 332
 333    ASSERT(obuf);
 334    P(mutex);
 335    buf = (struct abufhead *)((char *)obuf - HEAD_SIZE);
 336    pool = buf->pool;
 337    pool_ctl[pool].in_use--;
 338    if (pool == 0) {
 339       free((char *)buf);              /* free nonpooled memory */
 340    } else {                           /* otherwise link it to the free pool chain */
 341 #ifdef DEBUG
 342       struct abufhead *next;
 343       /* Don't let him free the same buffer twice */
 344       for (next=pool_ctl[pool].free_buf; next; next=next->next) {
 345          if (next == buf) {
 346             V(mutex);
 347             ASSERT(next != buf);  /* attempt to free twice */
 348          }
 349       }
 350 #endif
 351       buf->next = pool_ctl[pool].free_buf;
 352       pool_ctl[pool].free_buf = buf;
 353    }
 354    Dmsg2(dbglvl, "free_pool_memory %p pool=%d\n", buf, pool);
 355    V(mutex);
 356 }
 357 #endif /* SMARTALLOC */
 358
 359 /*
 360  * Clean up memory pool periodically
 361  *
 362  */
 363 static time_t last_garbage_collection = 0;
 364 const int garbage_interval = 24 * 60 * 60;  /* garbage collect every 24 hours */
 365
 366 void garbage_collect_memory_pool()
 367 {
 368    time_t now;
 369
 370    Dmsg0(200, "garbage collect memory pool\n");
 371    P(mutex);
 372    if (last_garbage_collection == 0) {
 373       last_garbage_collection = time(NULL);
 374       V(mutex);
 375       return;
 376    }
 377    now = time(NULL);
 378    if (now >= last_garbage_collection + garbage_interval ||
 379        sm_bytes > 500000) {
 380       last_garbage_collection = now;
 381       V(mutex);
 382       garbage_collect_memory();
 383    } else {
 384       V(mutex);
 385    }
 386 }
 387
 388 /* Release all freed pooled memory */
 389 void close_memory_pool()
 390 {
 391    struct abufhead *buf, *next;
 392    int count = 0;
 393    uint64_t bytes = 0;
 394    char ed1[50];
 395
 396    sm_check(__FILE__, __LINE__, false);
 397    P(mutex);
 398    for (int i=1; i<=PM_MAX; i++) {
 399       buf = pool_ctl[i].free_buf;
 400       while (buf) {
 401          next = buf->next;
 402          count++;
 403          bytes += sizeof_pool_memory((char *)buf);
 404          free((char *)buf);
 405          buf = next;
 406       }
 407       pool_ctl[i].free_buf = NULL;
 408    }
 409    Dmsg2(DT_MEMORY|001, "Freed mem_pool count=%d size=%s\n", count, edit_uint64_with_commas(bytes, ed1));
 410    if (chk_dbglvl(DT_MEMORY|1)) {
 411       print_memory_pool_stats();
 412    }
 413    V(mutex);
 414
 415 }
 416
 417 /*
 418  * Garbage collect and trim memory if possible
 419  *  This should be called after all big memory usages
 420  *  if possible.
 421  */
 422 void garbage_collect_memory()
 423 {
 424    close_memory_pool();         /* release free chain */
 425 #ifdef HAVE_MALLOC_TRIM
 426    P(mutex);
 427    malloc_trim(8192);
 428    V(mutex);
 429 #endif
 430 }
 431
 432 #ifdef DEBUG
 433 static const char *pool_name(int pool)
 434 {
 435    static const char *name[] = {"NoPool", "NAME  ", "FNAME ", "MSG   ", "EMSG  ", "BSOCK "};
 436    static char buf[30];
 437
 438    if (pool >= 0 && pool <= PM_MAX) {
 439       return name[pool];
 440    }
 441    sprintf(buf, "%-6d", pool);
 442    return buf;
 443 }
 444
 445 /* Print staticstics on memory pool usage
 446  */
 447 void print_memory_pool_stats()
 448 {
 449    Pmsg0(-1, "Pool   Maxsize  Maxused  Inuse\n");
 450    for (int i=0; i<=PM_MAX; i++)
 451       Pmsg4(-1, "%5s  %7d  %7d  %5d\n", pool_name(i), pool_ctl[i].max_allocated,
 452          pool_ctl[i].max_used, pool_ctl[i].in_use);
 453
 454    Pmsg0(-1, "\n");
 455 }
 456
 457 #else
 458 void print_memory_pool_stats() {}
 459 #endif /* DEBUG */
 460
 461 /*
 462  * Concatenate a string (str) onto a pool memory buffer pm
 463  *   Returns: length of concatenated string
 464  */
 465 int pm_strcat(POOLMEM **pm, const char *str)
 466 {
 467    int pmlen = strlen(*pm);
 468    int len;
 469
 470    if (!str) str = "";
 471
 472    len = strlen(str) + 1;
 473    *pm = check_pool_memory_size(*pm, pmlen + len);
 474    memcpy(*pm+pmlen, str, len);
 475    return pmlen + len - 1;
 476 }
 477
 478 int pm_strcat(POOLMEM *&pm, const char *str)
 479 {
 480    int pmlen = strlen(pm);
 481    int len;
 482
 483    if (!str) str = "";
 484
 485    len = strlen(str) + 1;
 486    pm = check_pool_memory_size(pm, pmlen + len);
 487    memcpy(pm+pmlen, str, len);
 488    return pmlen + len - 1;
 489 }
 490
 491 int pm_strcat(POOLMEM *&pm, POOL_MEM &str)
 492 {
 493    int pmlen = strlen(pm);
 494    int len = strlen(str.c_str()) + 1;
 495
 496    pm = check_pool_memory_size(pm, pmlen + len);
 497    memcpy(pm+pmlen, str.c_str(), len);
 498    return pmlen + len - 1;
 499 }
 500
 501 int pm_strcat(POOL_MEM &pm, const char *str)
 502 {
 503    int pmlen = strlen(pm.c_str());
 504    int len;
 505
 506    if (!str) str = "";
 507
 508    len = strlen(str) + 1;
 509    pm.check_size(pmlen + len);
 510    memcpy(pm.c_str()+pmlen, str, len);
 511    return pmlen + len - 1;
 512 }
 513
 514 /*
 515  * Copy a string (str) into a pool memory buffer pm
 516  *   Returns: length of string copied
 517  */
 518 int pm_strcpy(POOLMEM **pm, const char *str)
 519 {
 520    int len;
 521
 522    if (!str) str = "";
 523
 524    len = strlen(str) + 1;
 525    *pm = check_pool_memory_size(*pm, len);
 526    memcpy(*pm, str, len);
 527    return len - 1;
 528 }
 529
 530 int pm_strcpy(POOLMEM *&pm, const char *str)
 531 {
 532    int len;
 533
 534    if (!str) str = "";
 535
 536    len = strlen(str) + 1;
 537    pm = check_pool_memory_size(pm, len);
 538    memcpy(pm, str, len);
 539    return len - 1;
 540 }
 541
 542 int pm_strcpy(POOLMEM *&pm, POOL_MEM &str)
 543 {
 544    int len = strlen(str.c_str()) + 1;
 545
 546    pm = check_pool_memory_size(pm, len);
 547    memcpy(pm, str.c_str(), len);
 548    return len - 1;
 549 }
 550
 551 int pm_strcpy(POOL_MEM &pm, const char *str)
 552 {
 553    int len;
 554
 555    if (!str) str = "";
 556
 557    len = strlen(str) + 1;
 558    pm.check_size(len);
 559    memcpy(pm.c_str(), str, len);
 560    return len - 1;
 561 }
 562
 563 /*
 564  * Copy data into a pool memory buffer pm
 565  *   Returns: length of data copied
 566  */
 567 int pm_memcpy(POOLMEM **pm, const char *data, int32_t n)
 568 {
 569    *pm = check_pool_memory_size(*pm, n);
 570    memcpy(*pm, data, n);
 571    return n;
 572 }
 573
 574 int pm_memcpy(POOLMEM *&pm, const char *data, int32_t n)
 575 {
 576    pm = check_pool_memory_size(pm, n);
 577    memcpy(pm, data, n);
 578    return n;
 579 }
 580
 581 int pm_memcpy(POOLMEM *&pm, POOL_MEM &data, int32_t n)
 582 {
 583    pm = check_pool_memory_size(pm, n);
 584    memcpy(pm, data.c_str(), n);
 585    return n;
 586 }
 587
 588 int pm_memcpy(POOL_MEM &pm, const char *data, int32_t n)
 589 {
 590    pm.check_size(n);
 591    memcpy(pm.c_str(), data, n);
 592    return n;
 593 }
 594
 595 /* ==============  CLASS POOL_MEM   ============== */
 596
 597 /* Return the size of a memory buffer */
 598 int32_t POOL_MEM::max_size()
 599 {
 600    int32_t size;
 601    char *cp = mem;
 602    cp -= HEAD_SIZE;
 603    size = ((struct abufhead *)cp)->ablen;
 604    Dmsg1(900, "max_size=%d\n", size);
 605    return size;
 606 }
 607
 608 void POOL_MEM::realloc_pm(int32_t size)
 609 {
 610    char *cp = mem;
 611    char *buf;
 612    int pool;
 613
 614    P(mutex);
 615    cp -= HEAD_SIZE;
 616    buf = (char *)realloc(cp, size+HEAD_SIZE);
 617    if (buf == NULL) {
 618       V(mutex);
 619       Emsg1(M_ABORT, 0, _("Out of memory requesting %d bytes\n"), size);
 620    }
 621    Dmsg2(900, "Old buf=%p new buf=%p\n", cp, buf);
 622    ((struct abufhead *)buf)->ablen = size;
 623    pool = ((struct abufhead *)buf)->pool;
 624    if (size > pool_ctl[pool].max_allocated) {
 625       pool_ctl[pool].max_allocated = size;
 626    }
 627    mem = buf+HEAD_SIZE;
 628    V(mutex);
 629    Dmsg3(900, "Old buf=%p new buf=%p mem=%p\n", cp, buf, mem);
 630 }
 631
 632 int POOL_MEM::strcat(const char *str)
 633 {
 634    int pmlen = strlen(mem);
 635    int len;
 636
 637    if (!str) str = "";
 638
 639    len = strlen(str) + 1;
 640    check_size(pmlen + len);
 641    memcpy(mem+pmlen, str, len);
 642    return pmlen + len - 1;
 643 }
 644
 645 int POOL_MEM::strcpy(const char *str)
 646 {
 647    int len;
 648
 649    if (!str) str = "";
 650
 651    len = strlen(str) + 1;
 652    check_size(len);
 653    memcpy(mem, str, len);
 654    return len - 1;
 655 }