contrib/jemalloc/src/prof.c

   1 #define JEMALLOC_PROF_C_
   2 #include "jemalloc/internal/jemalloc_internal.h"
   3 /******************************************************************************/
   4
   5 #ifdef JEMALLOC_PROF_LIBUNWIND
   6 #define UNW_LOCAL_ONLY
   7 #include <libunwind.h>
   8 #endif
   9
  10 #ifdef JEMALLOC_PROF_LIBGCC
  11 #include <unwind.h>
  12 #endif
  13
  14 /******************************************************************************/
  15 /* Data. */
  16
  17 bool            opt_prof = false;
  18 bool            opt_prof_active = true;
  19 bool            opt_prof_thread_active_init = true;
  20 size_t          opt_lg_prof_sample = LG_PROF_SAMPLE_DEFAULT;
  21 ssize_t         opt_lg_prof_interval = LG_PROF_INTERVAL_DEFAULT;
  22 bool            opt_prof_gdump = false;
  23 bool            opt_prof_final = false;
  24 bool            opt_prof_leak = false;
  25 bool            opt_prof_accum = false;
  26 char            opt_prof_prefix[
  27     /* Minimize memory bloat for non-prof builds. */
  28 #ifdef JEMALLOC_PROF
  29     PATH_MAX +
  30 #endif
  31     1];
  32
  33 /*
  34  * Initialized as opt_prof_active, and accessed via
  35  * prof_active_[gs]et{_unlocked,}().
  36  */
  37 bool                    prof_active;
  38 static malloc_mutex_t   prof_active_mtx;
  39
  40 /*
  41  * Initialized as opt_prof_thread_active_init, and accessed via
  42  * prof_thread_active_init_[gs]et().
  43  */
  44 static bool             prof_thread_active_init;
  45 static malloc_mutex_t   prof_thread_active_init_mtx;
  46
  47 /*
  48  * Initialized as opt_prof_gdump, and accessed via
  49  * prof_gdump_[gs]et{_unlocked,}().
  50  */
  51 bool                    prof_gdump_val;
  52 static malloc_mutex_t   prof_gdump_mtx;
  53
  54 uint64_t        prof_interval = 0;
  55
  56 size_t          lg_prof_sample;
  57
  58 /*
  59  * Table of mutexes that are shared among gctx's.  These are leaf locks, so
  60  * there is no problem with using them for more than one gctx at the same time.
  61  * The primary motivation for this sharing though is that gctx's are ephemeral,
  62  * and destroying mutexes causes complications for systems that allocate when
  63  * creating/destroying mutexes.
  64  */
  65 static malloc_mutex_t   *gctx_locks;
  66 static unsigned         cum_gctxs; /* Atomic counter. */
  67
  68 /*
  69  * Table of mutexes that are shared among tdata's.  No operations require
  70  * holding multiple tdata locks, so there is no problem with using them for more
  71  * than one tdata at the same time, even though a gctx lock may be acquired
  72  * while holding a tdata lock.
  73  */
  74 static malloc_mutex_t   *tdata_locks;
  75
  76 /*
  77  * Global hash of (prof_bt_t *)-->(prof_gctx_t *).  This is the master data
  78  * structure that knows about all backtraces currently captured.
  79  */
  80 static ckh_t            bt2gctx;
  81 static malloc_mutex_t   bt2gctx_mtx;
  82
  83 /*
  84  * Tree of all extant prof_tdata_t structures, regardless of state,
  85  * {attached,detached,expired}.
  86  */
  87 static prof_tdata_tree_t        tdatas;
  88 static malloc_mutex_t   tdatas_mtx;
  89
  90 static uint64_t         next_thr_uid;
  91 static malloc_mutex_t   next_thr_uid_mtx;
  92
  93 static malloc_mutex_t   prof_dump_seq_mtx;
  94 static uint64_t         prof_dump_seq;
  95 static uint64_t         prof_dump_iseq;
  96 static uint64_t         prof_dump_mseq;
  97 static uint64_t         prof_dump_useq;
  98
  99 /*
 100  * This buffer is rather large for stack allocation, so use a single buffer for
 101  * all profile dumps.
 102  */
 103 static malloc_mutex_t   prof_dump_mtx;
 104 static char             prof_dump_buf[
 105     /* Minimize memory bloat for non-prof builds. */
 106 #ifdef JEMALLOC_PROF
 107     PROF_DUMP_BUFSIZE
 108 #else
 109     1
 110 #endif
 111 ];
 112 static size_t           prof_dump_buf_end;
 113 static int              prof_dump_fd;
 114
 115 /* Do not dump any profiles until bootstrapping is complete. */
 116 static bool             prof_booted = false;
 117
 118 /******************************************************************************/
 119 /*
 120  * Function prototypes for static functions that are referenced prior to
 121  * definition.
 122  */
 123
 124 static bool     prof_tctx_should_destroy(prof_tctx_t *tctx);
 125 static void     prof_tctx_destroy(tsd_t *tsd, prof_tctx_t *tctx);
 126 static bool     prof_tdata_should_destroy(prof_tdata_t *tdata,
 127     bool even_if_attached);
 128 static void     prof_tdata_destroy(tsd_t *tsd, prof_tdata_t *tdata,
 129     bool even_if_attached);
 130 static char     *prof_thread_name_alloc(tsd_t *tsd, const char *thread_name);
 131
 132 /******************************************************************************/
 133 /* Red-black trees. */
 134
 135 JEMALLOC_INLINE_C int
 136 prof_tctx_comp(const prof_tctx_t *a, const prof_tctx_t *b)
 137 {
 138         uint64_t a_thr_uid = a->thr_uid;
 139         uint64_t b_thr_uid = b->thr_uid;
 140         int ret = (a_thr_uid > b_thr_uid) - (a_thr_uid < b_thr_uid);
 141         if (ret == 0) {
 142                 uint64_t a_thr_discrim = a->thr_discrim;
 143                 uint64_t b_thr_discrim = b->thr_discrim;
 144                 ret = (a_thr_discrim > b_thr_discrim) - (a_thr_discrim <
 145                     b_thr_discrim);
 146                 if (ret == 0) {
 147                         uint64_t a_tctx_uid = a->tctx_uid;
 148                         uint64_t b_tctx_uid = b->tctx_uid;
 149                         ret = (a_tctx_uid > b_tctx_uid) - (a_tctx_uid <
 150                             b_tctx_uid);
 151                 }
 152         }
 153         return (ret);
 154 }
 155
 156 rb_gen(static UNUSED, tctx_tree_, prof_tctx_tree_t, prof_tctx_t,
 157     tctx_link, prof_tctx_comp)
 158
 159 JEMALLOC_INLINE_C int
 160 prof_gctx_comp(const prof_gctx_t *a, const prof_gctx_t *b)
 161 {
 162         unsigned a_len = a->bt.len;
 163         unsigned b_len = b->bt.len;
 164         unsigned comp_len = (a_len < b_len) ? a_len : b_len;
 165         int ret = memcmp(a->bt.vec, b->bt.vec, comp_len * sizeof(void *));
 166         if (ret == 0)
 167                 ret = (a_len > b_len) - (a_len < b_len);
 168         return (ret);
 169 }
 170
 171 rb_gen(static UNUSED, gctx_tree_, prof_gctx_tree_t, prof_gctx_t, dump_link,
 172     prof_gctx_comp)
 173
 174 JEMALLOC_INLINE_C int
 175 prof_tdata_comp(const prof_tdata_t *a, const prof_tdata_t *b)
 176 {
 177         int ret;
 178         uint64_t a_uid = a->thr_uid;
 179         uint64_t b_uid = b->thr_uid;
 180
 181         ret = ((a_uid > b_uid) - (a_uid < b_uid));
 182         if (ret == 0) {
 183                 uint64_t a_discrim = a->thr_discrim;
 184                 uint64_t b_discrim = b->thr_discrim;
 185
 186                 ret = ((a_discrim > b_discrim) - (a_discrim < b_discrim));
 187         }
 188         return (ret);
 189 }
 190
 191 rb_gen(static UNUSED, tdata_tree_, prof_tdata_tree_t, prof_tdata_t, tdata_link,
 192     prof_tdata_comp)
 193
 194 /******************************************************************************/
 195
 196 void
 197 prof_alloc_rollback(tsd_t *tsd, prof_tctx_t *tctx, bool updated)
 198 {
 199         prof_tdata_t *tdata;
 200
 201         cassert(config_prof);
 202
 203         if (updated) {
 204                 /*
 205                  * Compute a new sample threshold.  This isn't very important in
 206                  * practice, because this function is rarely executed, so the
 207                  * potential for sample bias is minimal except in contrived
 208                  * programs.
 209                  */
 210                 tdata = prof_tdata_get(tsd, true);
 211                 if (tdata != NULL)
 212                         prof_sample_threshold_update(tdata);
 213         }
 214
 215         if ((uintptr_t)tctx > (uintptr_t)1U) {
 216                 malloc_mutex_lock(tctx->tdata->lock);
 217                 tctx->prepared = false;
 218                 if (prof_tctx_should_destroy(tctx))
 219                         prof_tctx_destroy(tsd, tctx);
 220                 else
 221                         malloc_mutex_unlock(tctx->tdata->lock);
 222         }
 223 }
 224
 225 void
 226 prof_malloc_sample_object(const void *ptr, size_t usize, prof_tctx_t *tctx)
 227 {
 228
 229         prof_tctx_set(ptr, usize, tctx);
 230
 231         malloc_mutex_lock(tctx->tdata->lock);
 232         tctx->cnts.curobjs++;
 233         tctx->cnts.curbytes += usize;
 234         if (opt_prof_accum) {
 235                 tctx->cnts.accumobjs++;
 236                 tctx->cnts.accumbytes += usize;
 237         }
 238         tctx->prepared = false;
 239         malloc_mutex_unlock(tctx->tdata->lock);
 240 }
 241
 242 void
 243 prof_free_sampled_object(tsd_t *tsd, size_t usize, prof_tctx_t *tctx)
 244 {
 245
 246         malloc_mutex_lock(tctx->tdata->lock);
 247         assert(tctx->cnts.curobjs > 0);
 248         assert(tctx->cnts.curbytes >= usize);
 249         tctx->cnts.curobjs--;
 250         tctx->cnts.curbytes -= usize;
 251
 252         if (prof_tctx_should_destroy(tctx))
 253                 prof_tctx_destroy(tsd, tctx);
 254         else
 255                 malloc_mutex_unlock(tctx->tdata->lock);
 256 }
 257
 258 void
 259 bt_init(prof_bt_t *bt, void **vec)
 260 {
 261
 262         cassert(config_prof);
 263
 264         bt->vec = vec;
 265         bt->len = 0;
 266 }
 267
 268 JEMALLOC_INLINE_C void
 269 prof_enter(tsd_t *tsd, prof_tdata_t *tdata)
 270 {
 271
 272         cassert(config_prof);
 273         assert(tdata == prof_tdata_get(tsd, false));
 274
 275         if (tdata != NULL) {
 276                 assert(!tdata->enq);
 277                 tdata->enq = true;
 278         }
 279
 280         malloc_mutex_lock(&bt2gctx_mtx);
 281 }
 282
 283 JEMALLOC_INLINE_C void
 284 prof_leave(tsd_t *tsd, prof_tdata_t *tdata)
 285 {
 286
 287         cassert(config_prof);
 288         assert(tdata == prof_tdata_get(tsd, false));
 289
 290         malloc_mutex_unlock(&bt2gctx_mtx);
 291
 292         if (tdata != NULL) {
 293                 bool idump, gdump;
 294
 295                 assert(tdata->enq);
 296                 tdata->enq = false;
 297                 idump = tdata->enq_idump;
 298                 tdata->enq_idump = false;
 299                 gdump = tdata->enq_gdump;
 300                 tdata->enq_gdump = false;
 301
 302                 if (idump)
 303                         prof_idump();
 304                 if (gdump)
 305                         prof_gdump();
 306         }
 307 }
 308
 309 #ifdef JEMALLOC_PROF_LIBUNWIND
 310 void
 311 prof_backtrace(prof_bt_t *bt)
 312 {
 313         int nframes;
 314
 315         cassert(config_prof);
 316         assert(bt->len == 0);
 317         assert(bt->vec != NULL);
 318
 319         nframes = unw_backtrace(bt->vec, PROF_BT_MAX);
 320         if (nframes <= 0)
 321                 return;
 322         bt->len = nframes;
 323 }
 324 #elif (defined(JEMALLOC_PROF_LIBGCC))
 325 static _Unwind_Reason_Code
 326 prof_unwind_init_callback(struct _Unwind_Context *context, void *arg)
 327 {
 328
 329         cassert(config_prof);
 330
 331         return (_URC_NO_REASON);
 332 }
 333
 334 static _Unwind_Reason_Code
 335 prof_unwind_callback(struct _Unwind_Context *context, void *arg)
 336 {
 337         prof_unwind_data_t *data = (prof_unwind_data_t *)arg;
 338         void *ip;
 339
 340         cassert(config_prof);
 341
 342         ip = (void *)_Unwind_GetIP(context);
 343         if (ip == NULL)
 344                 return (_URC_END_OF_STACK);
 345         data->bt->vec[data->bt->len] = ip;
 346         data->bt->len++;
 347         if (data->bt->len == data->max)
 348                 return (_URC_END_OF_STACK);
 349
 350         return (_URC_NO_REASON);
 351 }
 352
 353 void
 354 prof_backtrace(prof_bt_t *bt)
 355 {
 356         prof_unwind_data_t data = {bt, PROF_BT_MAX};
 357
 358         cassert(config_prof);
 359
 360         _Unwind_Backtrace(prof_unwind_callback, &data);
 361 }
 362 #elif (defined(JEMALLOC_PROF_GCC))
 363 void
 364 prof_backtrace(prof_bt_t *bt)
 365 {
 366 #define BT_FRAME(i)                                                     \
 367         if ((i) < PROF_BT_MAX) {                                        \
 368                 void *p;                                                \
 369                 if (__builtin_frame_address(i) == 0)                    \
 370                         return;                                         \
 371                 p = __builtin_return_address(i);                        \
 372                 if (p == NULL)                                          \
 373                         return;                                         \
 374                 bt->vec[(i)] = p;                                       \
 375                 bt->len = (i) + 1;                                      \
 376         } else                                                          \
 377                 return;
 378
 379         cassert(config_prof);
 380
 381         BT_FRAME(0)
 382         BT_FRAME(1)
 383         BT_FRAME(2)
 384         BT_FRAME(3)
 385         BT_FRAME(4)
 386         BT_FRAME(5)
 387         BT_FRAME(6)
 388         BT_FRAME(7)
 389         BT_FRAME(8)
 390         BT_FRAME(9)
 391
 392         BT_FRAME(10)
 393         BT_FRAME(11)
 394         BT_FRAME(12)
 395         BT_FRAME(13)
 396         BT_FRAME(14)
 397         BT_FRAME(15)
 398         BT_FRAME(16)
 399         BT_FRAME(17)
 400         BT_FRAME(18)
 401         BT_FRAME(19)
 402
 403         BT_FRAME(20)
 404         BT_FRAME(21)
 405         BT_FRAME(22)
 406         BT_FRAME(23)
 407         BT_FRAME(24)
 408         BT_FRAME(25)
 409         BT_FRAME(26)
 410         BT_FRAME(27)
 411         BT_FRAME(28)
 412         BT_FRAME(29)
 413
 414         BT_FRAME(30)
 415         BT_FRAME(31)
 416         BT_FRAME(32)
 417         BT_FRAME(33)
 418         BT_FRAME(34)
 419         BT_FRAME(35)
 420         BT_FRAME(36)
 421         BT_FRAME(37)
 422         BT_FRAME(38)
 423         BT_FRAME(39)
 424
 425         BT_FRAME(40)
 426         BT_FRAME(41)
 427         BT_FRAME(42)
 428         BT_FRAME(43)
 429         BT_FRAME(44)
 430         BT_FRAME(45)
 431         BT_FRAME(46)
 432         BT_FRAME(47)
 433         BT_FRAME(48)
 434         BT_FRAME(49)
 435
 436         BT_FRAME(50)
 437         BT_FRAME(51)
 438         BT_FRAME(52)
 439         BT_FRAME(53)
 440         BT_FRAME(54)
 441         BT_FRAME(55)
 442         BT_FRAME(56)
 443         BT_FRAME(57)
 444         BT_FRAME(58)
 445         BT_FRAME(59)
 446
 447         BT_FRAME(60)
 448         BT_FRAME(61)
 449         BT_FRAME(62)
 450         BT_FRAME(63)
 451         BT_FRAME(64)
 452         BT_FRAME(65)
 453         BT_FRAME(66)
 454         BT_FRAME(67)
 455         BT_FRAME(68)
 456         BT_FRAME(69)
 457
 458         BT_FRAME(70)
 459         BT_FRAME(71)
 460         BT_FRAME(72)
 461         BT_FRAME(73)
 462         BT_FRAME(74)
 463         BT_FRAME(75)
 464         BT_FRAME(76)
 465         BT_FRAME(77)
 466         BT_FRAME(78)
 467         BT_FRAME(79)
 468
 469         BT_FRAME(80)
 470         BT_FRAME(81)
 471         BT_FRAME(82)
 472         BT_FRAME(83)
 473         BT_FRAME(84)
 474         BT_FRAME(85)
 475         BT_FRAME(86)
 476         BT_FRAME(87)
 477         BT_FRAME(88)
 478         BT_FRAME(89)
 479
 480         BT_FRAME(90)
 481         BT_FRAME(91)
 482         BT_FRAME(92)
 483         BT_FRAME(93)
 484         BT_FRAME(94)
 485         BT_FRAME(95)
 486         BT_FRAME(96)
 487         BT_FRAME(97)
 488         BT_FRAME(98)
 489         BT_FRAME(99)
 490
 491         BT_FRAME(100)
 492         BT_FRAME(101)
 493         BT_FRAME(102)
 494         BT_FRAME(103)
 495         BT_FRAME(104)
 496         BT_FRAME(105)
 497         BT_FRAME(106)
 498         BT_FRAME(107)
 499         BT_FRAME(108)
 500         BT_FRAME(109)
 501
 502         BT_FRAME(110)
 503         BT_FRAME(111)
 504         BT_FRAME(112)
 505         BT_FRAME(113)
 506         BT_FRAME(114)
 507         BT_FRAME(115)
 508         BT_FRAME(116)
 509         BT_FRAME(117)
 510         BT_FRAME(118)
 511         BT_FRAME(119)
 512
 513         BT_FRAME(120)
 514         BT_FRAME(121)
 515         BT_FRAME(122)
 516         BT_FRAME(123)
 517         BT_FRAME(124)
 518         BT_FRAME(125)
 519         BT_FRAME(126)
 520         BT_FRAME(127)
 521 #undef BT_FRAME
 522 }
 523 #else
 524 void
 525 prof_backtrace(prof_bt_t *bt)
 526 {
 527
 528         cassert(config_prof);
 529         not_reached();
 530 }
 531 #endif
 532
 533 static malloc_mutex_t *
 534 prof_gctx_mutex_choose(void)
 535 {
 536         unsigned ngctxs = atomic_add_u(&cum_gctxs, 1);
 537
 538         return (&gctx_locks[(ngctxs - 1) % PROF_NCTX_LOCKS]);
 539 }
 540
 541 static malloc_mutex_t *
 542 prof_tdata_mutex_choose(uint64_t thr_uid)
 543 {
 544
 545         return (&tdata_locks[thr_uid % PROF_NTDATA_LOCKS]);
 546 }
 547
 548 static prof_gctx_t *
 549 prof_gctx_create(tsd_t *tsd, prof_bt_t *bt)
 550 {
 551         /*
 552          * Create a single allocation that has space for vec of length bt->len.
 553          */
 554         size_t size = offsetof(prof_gctx_t, vec) + (bt->len * sizeof(void *));
 555         prof_gctx_t *gctx = (prof_gctx_t *)iallocztm(tsd, size,
 556             size2index(size), false, tcache_get(tsd, true), true, NULL, true);
 557         if (gctx == NULL)
 558                 return (NULL);
 559         gctx->lock = prof_gctx_mutex_choose();
 560         /*
 561          * Set nlimbo to 1, in order to avoid a race condition with
 562          * prof_tctx_destroy()/prof_gctx_try_destroy().
 563          */
 564         gctx->nlimbo = 1;
 565         tctx_tree_new(&gctx->tctxs);
 566         /* Duplicate bt. */
 567         memcpy(gctx->vec, bt->vec, bt->len * sizeof(void *));
 568         gctx->bt.vec = gctx->vec;
 569         gctx->bt.len = bt->len;
 570         return (gctx);
 571 }
 572
 573 static void
 574 prof_gctx_try_destroy(tsd_t *tsd, prof_tdata_t *tdata_self, prof_gctx_t *gctx,
 575     prof_tdata_t *tdata)
 576 {
 577
 578         cassert(config_prof);
 579
 580         /*
 581          * Check that gctx is still unused by any thread cache before destroying
 582          * it.  prof_lookup() increments gctx->nlimbo in order to avoid a race
 583          * condition with this function, as does prof_tctx_destroy() in order to
 584          * avoid a race between the main body of prof_tctx_destroy() and entry
 585          * into this function.
 586          */
 587         prof_enter(tsd, tdata_self);
 588         malloc_mutex_lock(gctx->lock);
 589         assert(gctx->nlimbo != 0);
 590         if (tctx_tree_empty(&gctx->tctxs) && gctx->nlimbo == 1) {
 591                 /* Remove gctx from bt2gctx. */
 592                 if (ckh_remove(tsd, &bt2gctx, &gctx->bt, NULL, NULL))
 593                         not_reached();
 594                 prof_leave(tsd, tdata_self);
 595                 /* Destroy gctx. */
 596                 malloc_mutex_unlock(gctx->lock);
 597                 idalloctm(tsd, gctx, tcache_get(tsd, false), true, true);
 598         } else {
 599                 /*
 600                  * Compensate for increment in prof_tctx_destroy() or
 601                  * prof_lookup().
 602                  */
 603                 gctx->nlimbo--;
 604                 malloc_mutex_unlock(gctx->lock);
 605                 prof_leave(tsd, tdata_self);
 606         }
 607 }
 608
 609 /* tctx->tdata->lock must be held. */
 610 static bool
 611 prof_tctx_should_destroy(prof_tctx_t *tctx)
 612 {
 613
 614         if (opt_prof_accum)
 615                 return (false);
 616         if (tctx->cnts.curobjs != 0)
 617                 return (false);
 618         if (tctx->prepared)
 619                 return (false);
 620         return (true);
 621 }
 622
 623 static bool
 624 prof_gctx_should_destroy(prof_gctx_t *gctx)
 625 {
 626
 627         if (opt_prof_accum)
 628                 return (false);
 629         if (!tctx_tree_empty(&gctx->tctxs))
 630                 return (false);
 631         if (gctx->nlimbo != 0)
 632                 return (false);
 633         return (true);
 634 }
 635
 636 /* tctx->tdata->lock is held upon entry, and released before return. */
 637 static void
 638 prof_tctx_destroy(tsd_t *tsd, prof_tctx_t *tctx)
 639 {
 640         prof_tdata_t *tdata = tctx->tdata;
 641         prof_gctx_t *gctx = tctx->gctx;
 642         bool destroy_tdata, destroy_tctx, destroy_gctx;
 643
 644         assert(tctx->cnts.curobjs == 0);
 645         assert(tctx->cnts.curbytes == 0);
 646         assert(!opt_prof_accum);
 647         assert(tctx->cnts.accumobjs == 0);
 648         assert(tctx->cnts.accumbytes == 0);
 649
 650         ckh_remove(tsd, &tdata->bt2tctx, &gctx->bt, NULL, NULL);
 651         destroy_tdata = prof_tdata_should_destroy(tdata, false);
 652         malloc_mutex_unlock(tdata->lock);
 653
 654         malloc_mutex_lock(gctx->lock);
 655         switch (tctx->state) {
 656         case prof_tctx_state_nominal:
 657                 tctx_tree_remove(&gctx->tctxs, tctx);
 658                 destroy_tctx = true;
 659                 if (prof_gctx_should_destroy(gctx)) {
 660                         /*
 661                          * Increment gctx->nlimbo in order to keep another
 662                          * thread from winning the race to destroy gctx while
 663                          * this one has gctx->lock dropped.  Without this, it
 664                          * would be possible for another thread to:
 665                          *
 666                          * 1) Sample an allocation associated with gctx.
 667                          * 2) Deallocate the sampled object.
 668                          * 3) Successfully prof_gctx_try_destroy(gctx).
 669                          *
 670                          * The result would be that gctx no longer exists by the
 671                          * time this thread accesses it in
 672                          * prof_gctx_try_destroy().
 673                          */
 674                         gctx->nlimbo++;
 675                         destroy_gctx = true;
 676                 } else
 677                         destroy_gctx = false;
 678                 break;
 679         case prof_tctx_state_dumping:
 680                 /*
 681                  * A dumping thread needs tctx to remain valid until dumping
 682                  * has finished.  Change state such that the dumping thread will
 683                  * complete destruction during a late dump iteration phase.
 684                  */
 685                 tctx->state = prof_tctx_state_purgatory;
 686                 destroy_tctx = false;
 687                 destroy_gctx = false;
 688                 break;
 689         default:
 690                 not_reached();
 691                 destroy_tctx = false;
 692                 destroy_gctx = false;
 693         }
 694         malloc_mutex_unlock(gctx->lock);
 695         if (destroy_gctx) {
 696                 prof_gctx_try_destroy(tsd, prof_tdata_get(tsd, false), gctx,
 697                     tdata);
 698         }
 699
 700         if (destroy_tdata)
 701                 prof_tdata_destroy(tsd, tdata, false);
 702
 703         if (destroy_tctx)
 704                 idalloctm(tsd, tctx, tcache_get(tsd, false), true, true);
 705 }
 706
 707 static bool
 708 prof_lookup_global(tsd_t *tsd, prof_bt_t *bt, prof_tdata_t *tdata,
 709     void **p_btkey, prof_gctx_t **p_gctx, bool *p_new_gctx)
 710 {
 711         union {
 712                 prof_gctx_t     *p;
 713                 void            *v;
 714         } gctx;
 715         union {
 716                 prof_bt_t       *p;
 717                 void            *v;
 718         } btkey;
 719         bool new_gctx;
 720
 721         prof_enter(tsd, tdata);
 722         if (ckh_search(&bt2gctx, bt, &btkey.v, &gctx.v)) {
 723                 /* bt has never been seen before.  Insert it. */
 724                 gctx.p = prof_gctx_create(tsd, bt);
 725                 if (gctx.v == NULL) {
 726                         prof_leave(tsd, tdata);
 727                         return (true);
 728                 }
 729                 btkey.p = &gctx.p->bt;
 730                 if (ckh_insert(tsd, &bt2gctx, btkey.v, gctx.v)) {
 731                         /* OOM. */
 732                         prof_leave(tsd, tdata);
 733                         idalloctm(tsd, gctx.v, tcache_get(tsd, false), true,
 734                             true);
 735                         return (true);
 736                 }
 737                 new_gctx = true;
 738         } else {
 739                 /*
 740                  * Increment nlimbo, in order to avoid a race condition with
 741                  * prof_tctx_destroy()/prof_gctx_try_destroy().
 742                  */
 743                 malloc_mutex_lock(gctx.p->lock);
 744                 gctx.p->nlimbo++;
 745                 malloc_mutex_unlock(gctx.p->lock);
 746                 new_gctx = false;
 747         }
 748         prof_leave(tsd, tdata);
 749
 750         *p_btkey = btkey.v;
 751         *p_gctx = gctx.p;
 752         *p_new_gctx = new_gctx;
 753         return (false);
 754 }
 755
 756 prof_tctx_t *
 757 prof_lookup(tsd_t *tsd, prof_bt_t *bt)
 758 {
 759         union {
 760                 prof_tctx_t     *p;
 761                 void            *v;
 762         } ret;
 763         prof_tdata_t *tdata;
 764         bool not_found;
 765
 766         cassert(config_prof);
 767
 768         tdata = prof_tdata_get(tsd, false);
 769         if (tdata == NULL)
 770                 return (NULL);
 771
 772         malloc_mutex_lock(tdata->lock);
 773         not_found = ckh_search(&tdata->bt2tctx, bt, NULL, &ret.v);
 774         if (!not_found) /* Note double negative! */
 775                 ret.p->prepared = true;
 776         malloc_mutex_unlock(tdata->lock);
 777         if (not_found) {
 778                 tcache_t *tcache;
 779                 void *btkey;
 780                 prof_gctx_t *gctx;
 781                 bool new_gctx, error;
 782
 783                 /*
 784                  * This thread's cache lacks bt.  Look for it in the global
 785                  * cache.
 786                  */
 787                 if (prof_lookup_global(tsd, bt, tdata, &btkey, &gctx,
 788                     &new_gctx))
 789                         return (NULL);
 790
 791                 /* Link a prof_tctx_t into gctx for this thread. */
 792                 tcache = tcache_get(tsd, true);
 793                 ret.v = iallocztm(tsd, sizeof(prof_tctx_t),
 794                     size2index(sizeof(prof_tctx_t)), false, tcache, true, NULL,
 795                     true);
 796                 if (ret.p == NULL) {
 797                         if (new_gctx)
 798                                 prof_gctx_try_destroy(tsd, tdata, gctx, tdata);
 799                         return (NULL);
 800                 }
 801                 ret.p->tdata = tdata;
 802                 ret.p->thr_uid = tdata->thr_uid;
 803                 ret.p->thr_discrim = tdata->thr_discrim;
 804                 memset(&ret.p->cnts, 0, sizeof(prof_cnt_t));
 805                 ret.p->gctx = gctx;
 806                 ret.p->tctx_uid = tdata->tctx_uid_next++;
 807                 ret.p->prepared = true;
 808                 ret.p->state = prof_tctx_state_initializing;
 809                 malloc_mutex_lock(tdata->lock);
 810                 error = ckh_insert(tsd, &tdata->bt2tctx, btkey, ret.v);
 811                 malloc_mutex_unlock(tdata->lock);
 812                 if (error) {
 813                         if (new_gctx)
 814                                 prof_gctx_try_destroy(tsd, tdata, gctx, tdata);
 815                         idalloctm(tsd, ret.v, tcache, true, true);
 816                         return (NULL);
 817                 }
 818                 malloc_mutex_lock(gctx->lock);
 819                 ret.p->state = prof_tctx_state_nominal;
 820                 tctx_tree_insert(&gctx->tctxs, ret.p);
 821                 gctx->nlimbo--;
 822                 malloc_mutex_unlock(gctx->lock);
 823         }
 824
 825         return (ret.p);
 826 }
 827
 828 void
 829 prof_sample_threshold_update(prof_tdata_t *tdata)
 830 {
 831         /*
 832          * The body of this function is compiled out unless heap profiling is
 833          * enabled, so that it is possible to compile jemalloc with floating
 834          * point support completely disabled.  Avoiding floating point code is
 835          * important on memory-constrained systems, but it also enables a
 836          * workaround for versions of glibc that don't properly save/restore
 837          * floating point registers during dynamic lazy symbol loading (which
 838          * internally calls into whatever malloc implementation happens to be
 839          * integrated into the application).  Note that some compilers (e.g.
 840          * gcc 4.8) may use floating point registers for fast memory moves, so
 841          * jemalloc must be compiled with such optimizations disabled (e.g.
 842          * -mno-sse) in order for the workaround to be complete.
 843          */
 844 #ifdef JEMALLOC_PROF
 845         uint64_t r;
 846         double u;
 847
 848         if (!config_prof)
 849                 return;
 850
 851         if (lg_prof_sample == 0) {
 852                 tdata->bytes_until_sample = 0;
 853                 return;
 854         }
 855
 856         /*
 857          * Compute sample interval as a geometrically distributed random
 858          * variable with mean (2^lg_prof_sample).
 859          *
 860          *                             __        __
 861          *                             |  log(u)  |                     1
 862          * tdata->bytes_until_sample = | -------- |, where p = ---------------
 863          *                             | log(1-p) |             lg_prof_sample
 864          *                                                     2
 865          *
 866          * For more information on the math, see:
 867          *
 868          *   Non-Uniform Random Variate Generation
 869          *   Luc Devroye
 870          *   Springer-Verlag, New York, 1986
 871          *   pp 500
 872          *   (http://luc.devroye.org/rnbookindex.html)
 873          */
 874         r = prng_lg_range(&tdata->prng_state, 53);
 875         u = (double)r * (1.0/9007199254740992.0L);
 876         tdata->bytes_until_sample = (uint64_t)(log(u) /
 877             log(1.0 - (1.0 / (double)((uint64_t)1U << lg_prof_sample))))
 878             + (uint64_t)1U;
 879 #endif
 880 }
 881
 882 #ifdef JEMALLOC_JET
 883 static prof_tdata_t *
 884 prof_tdata_count_iter(prof_tdata_tree_t *tdatas, prof_tdata_t *tdata, void *arg)
 885 {
 886         size_t *tdata_count = (size_t *)arg;
 887
 888         (*tdata_count)++;
 889
 890         return (NULL);
 891 }
 892
 893 size_t
 894 prof_tdata_count(void)
 895 {
 896         size_t tdata_count = 0;
 897
 898         malloc_mutex_lock(&tdatas_mtx);
 899         tdata_tree_iter(&tdatas, NULL, prof_tdata_count_iter,
 900             (void *)&tdata_count);
 901         malloc_mutex_unlock(&tdatas_mtx);
 902
 903         return (tdata_count);
 904 }
 905 #endif
 906
 907 #ifdef JEMALLOC_JET
 908 size_t
 909 prof_bt_count(void)
 910 {
 911         size_t bt_count;
 912         tsd_t *tsd;
 913         prof_tdata_t *tdata;
 914
 915         tsd = tsd_fetch();
 916         tdata = prof_tdata_get(tsd, false);
 917         if (tdata == NULL)
 918                 return (0);
 919
 920         malloc_mutex_lock(&bt2gctx_mtx);
 921         bt_count = ckh_count(&bt2gctx);
 922         malloc_mutex_unlock(&bt2gctx_mtx);
 923
 924         return (bt_count);
 925 }
 926 #endif
 927
 928 #ifdef JEMALLOC_JET
 929 #undef prof_dump_open
 930 #define prof_dump_open JEMALLOC_N(prof_dump_open_impl)
 931 #endif
 932 static int
 933 prof_dump_open(bool propagate_err, const char *filename)
 934 {
 935         int fd;
 936
 937         fd = creat(filename, 0644);
 938         if (fd == -1 && !propagate_err) {
 939                 malloc_printf("<jemalloc>: creat(\"%s\"), 0644) failed\n",
 940                     filename);
 941                 if (opt_abort)
 942                         abort();
 943         }
 944
 945         return (fd);
 946 }
 947 #ifdef JEMALLOC_JET
 948 #undef prof_dump_open
 949 #define prof_dump_open JEMALLOC_N(prof_dump_open)
 950 prof_dump_open_t *prof_dump_open = JEMALLOC_N(prof_dump_open_impl);
 951 #endif
 952
 953 static bool
 954 prof_dump_flush(bool propagate_err)
 955 {
 956         bool ret = false;
 957         ssize_t err;
 958
 959         cassert(config_prof);
 960
 961         err = write(prof_dump_fd, prof_dump_buf, prof_dump_buf_end);
 962         if (err == -1) {
 963                 if (!propagate_err) {
 964                         malloc_write("<jemalloc>: write() failed during heap "
 965                             "profile flush\n");
 966                         if (opt_abort)
 967                                 abort();
 968                 }
 969                 ret = true;
 970         }
 971         prof_dump_buf_end = 0;
 972
 973         return (ret);
 974 }
 975
 976 static bool
 977 prof_dump_close(bool propagate_err)
 978 {
 979         bool ret;
 980
 981         assert(prof_dump_fd != -1);
 982         ret = prof_dump_flush(propagate_err);
 983         close(prof_dump_fd);
 984         prof_dump_fd = -1;
 985
 986         return (ret);
 987 }
 988
 989 static bool
 990 prof_dump_write(bool propagate_err, const char *s)
 991 {
 992         size_t i, slen, n;
 993
 994         cassert(config_prof);
 995
 996         i = 0;
 997         slen = strlen(s);
 998         while (i < slen) {
 999                 /* Flush the buffer if it is full. */
1000                 if (prof_dump_buf_end == PROF_DUMP_BUFSIZE)
1001                         if (prof_dump_flush(propagate_err) && propagate_err)
1002                                 return (true);
1003
1004                 if (prof_dump_buf_end + slen <= PROF_DUMP_BUFSIZE) {
1005                         /* Finish writing. */
1006                         n = slen - i;
1007                 } else {
1008                         /* Write as much of s as will fit. */
1009                         n = PROF_DUMP_BUFSIZE - prof_dump_buf_end;
1010                 }
1011                 memcpy(&prof_dump_buf[prof_dump_buf_end], &s[i], n);
1012                 prof_dump_buf_end += n;
1013                 i += n;
1014         }
1015
1016         return (false);
1017 }
1018
1019 JEMALLOC_FORMAT_PRINTF(2, 3)
1020 static bool
1021 prof_dump_printf(bool propagate_err, const char *format, ...)
1022 {
1023         bool ret;
1024         va_list ap;
1025         char buf[PROF_PRINTF_BUFSIZE];
1026
1027         va_start(ap, format);
1028         malloc_vsnprintf(buf, sizeof(buf), format, ap);
1029         va_end(ap);
1030         ret = prof_dump_write(propagate_err, buf);
1031
1032         return (ret);
1033 }
1034
1035 /* tctx->tdata->lock is held. */
1036 static void
1037 prof_tctx_merge_tdata(prof_tctx_t *tctx, prof_tdata_t *tdata)
1038 {
1039
1040         malloc_mutex_lock(tctx->gctx->lock);
1041
1042         switch (tctx->state) {
1043         case prof_tctx_state_initializing:
1044                 malloc_mutex_unlock(tctx->gctx->lock);
1045                 return;
1046         case prof_tctx_state_nominal:
1047                 tctx->state = prof_tctx_state_dumping;
1048                 malloc_mutex_unlock(tctx->gctx->lock);
1049
1050                 memcpy(&tctx->dump_cnts, &tctx->cnts, sizeof(prof_cnt_t));
1051
1052                 tdata->cnt_summed.curobjs += tctx->dump_cnts.curobjs;
1053                 tdata->cnt_summed.curbytes += tctx->dump_cnts.curbytes;
1054                 if (opt_prof_accum) {
1055                         tdata->cnt_summed.accumobjs +=
1056                             tctx->dump_cnts.accumobjs;
1057                         tdata->cnt_summed.accumbytes +=
1058                             tctx->dump_cnts.accumbytes;
1059                 }
1060                 break;
1061         case prof_tctx_state_dumping:
1062         case prof_tctx_state_purgatory:
1063                 not_reached();
1064         }
1065 }
1066
1067 /* gctx->lock is held. */
1068 static void
1069 prof_tctx_merge_gctx(prof_tctx_t *tctx, prof_gctx_t *gctx)
1070 {
1071
1072         gctx->cnt_summed.curobjs += tctx->dump_cnts.curobjs;
1073         gctx->cnt_summed.curbytes += tctx->dump_cnts.curbytes;
1074         if (opt_prof_accum) {
1075                 gctx->cnt_summed.accumobjs += tctx->dump_cnts.accumobjs;
1076                 gctx->cnt_summed.accumbytes += tctx->dump_cnts.accumbytes;
1077         }
1078 }
1079
1080 /* tctx->gctx is held. */
1081 static prof_tctx_t *
1082 prof_tctx_merge_iter(prof_tctx_tree_t *tctxs, prof_tctx_t *tctx, void *arg)
1083 {
1084
1085         switch (tctx->state) {
1086         case prof_tctx_state_nominal:
1087                 /* New since dumping started; ignore. */
1088                 break;
1089         case prof_tctx_state_dumping:
1090         case prof_tctx_state_purgatory:
1091                 prof_tctx_merge_gctx(tctx, tctx->gctx);
1092                 break;
1093         default:
1094                 not_reached();
1095         }
1096
1097         return (NULL);
1098 }
1099
1100 /* gctx->lock is held. */
1101 static prof_tctx_t *
1102 prof_tctx_dump_iter(prof_tctx_tree_t *tctxs, prof_tctx_t *tctx, void *arg)
1103 {
1104         bool propagate_err = *(bool *)arg;
1105
1106         switch (tctx->state) {
1107         case prof_tctx_state_initializing:
1108         case prof_tctx_state_nominal:
1109                 /* Not captured by this dump. */
1110                 break;
1111         case prof_tctx_state_dumping:
1112         case prof_tctx_state_purgatory:
1113                 if (prof_dump_printf(propagate_err,
1114                     "  t%"FMTu64": %"FMTu64": %"FMTu64" [%"FMTu64": "
1115                     "%"FMTu64"]\n", tctx->thr_uid, tctx->dump_cnts.curobjs,
1116                     tctx->dump_cnts.curbytes, tctx->dump_cnts.accumobjs,
1117                     tctx->dump_cnts.accumbytes))
1118                         return (tctx);
1119                 break;
1120         default:
1121                 not_reached();
1122         }
1123         return (NULL);
1124 }
1125
1126 /* tctx->gctx is held. */
1127 static prof_tctx_t *
1128 prof_tctx_finish_iter(prof_tctx_tree_t *tctxs, prof_tctx_t *tctx, void *arg)
1129 {
1130         prof_tctx_t *ret;
1131
1132         switch (tctx->state) {
1133         case prof_tctx_state_nominal:
1134                 /* New since dumping started; ignore. */
1135                 break;
1136         case prof_tctx_state_dumping:
1137                 tctx->state = prof_tctx_state_nominal;
1138                 break;
1139         case prof_tctx_state_purgatory:
1140                 ret = tctx;
1141                 goto label_return;
1142         default:
1143                 not_reached();
1144         }
1145
1146         ret = NULL;
1147 label_return:
1148         return (ret);
1149 }
1150
1151 static void
1152 prof_dump_gctx_prep(prof_gctx_t *gctx, prof_gctx_tree_t *gctxs)
1153 {
1154
1155         cassert(config_prof);
1156
1157         malloc_mutex_lock(gctx->lock);
1158
1159         /*
1160          * Increment nlimbo so that gctx won't go away before dump.
1161          * Additionally, link gctx into the dump list so that it is included in
1162          * prof_dump()'s second pass.
1163          */
1164         gctx->nlimbo++;
1165         gctx_tree_insert(gctxs, gctx);
1166
1167         memset(&gctx->cnt_summed, 0, sizeof(prof_cnt_t));
1168
1169         malloc_mutex_unlock(gctx->lock);
1170 }
1171
1172 static prof_gctx_t *
1173 prof_gctx_merge_iter(prof_gctx_tree_t *gctxs, prof_gctx_t *gctx, void *arg)
1174 {
1175         size_t *leak_ngctx = (size_t *)arg;
1176
1177         malloc_mutex_lock(gctx->lock);
1178         tctx_tree_iter(&gctx->tctxs, NULL, prof_tctx_merge_iter, NULL);
1179         if (gctx->cnt_summed.curobjs != 0)
1180                 (*leak_ngctx)++;
1181         malloc_mutex_unlock(gctx->lock);
1182
1183         return (NULL);
1184 }
1185
1186 static void
1187 prof_gctx_finish(tsd_t *tsd, prof_gctx_tree_t *gctxs)
1188 {
1189         prof_tdata_t *tdata = prof_tdata_get(tsd, false);
1190         prof_gctx_t *gctx;
1191
1192         /*
1193          * Standard tree iteration won't work here, because as soon as we
1194          * decrement gctx->nlimbo and unlock gctx, another thread can
1195          * concurrently destroy it, which will corrupt the tree.  Therefore,
1196          * tear down the tree one node at a time during iteration.
1197          */
1198         while ((gctx = gctx_tree_first(gctxs)) != NULL) {
1199                 gctx_tree_remove(gctxs, gctx);
1200                 malloc_mutex_lock(gctx->lock);
1201                 {
1202                         prof_tctx_t *next;
1203
1204                         next = NULL;
1205                         do {
1206                                 prof_tctx_t *to_destroy =
1207                                     tctx_tree_iter(&gctx->tctxs, next,
1208                                     prof_tctx_finish_iter, NULL);
1209                                 if (to_destroy != NULL) {
1210                                         next = tctx_tree_next(&gctx->tctxs,
1211                                             to_destroy);
1212                                         tctx_tree_remove(&gctx->tctxs,
1213                                             to_destroy);
1214                                         idalloctm(tsd, to_destroy,
1215                                             tcache_get(tsd, false), true, true);
1216                                 } else
1217                                         next = NULL;
1218                         } while (next != NULL);
1219                 }
1220                 gctx->nlimbo--;
1221                 if (prof_gctx_should_destroy(gctx)) {
1222                         gctx->nlimbo++;
1223                         malloc_mutex_unlock(gctx->lock);
1224                         prof_gctx_try_destroy(tsd, tdata, gctx, tdata);
1225                 } else
1226                         malloc_mutex_unlock(gctx->lock);
1227         }
1228 }
1229
1230 static prof_tdata_t *
1231 prof_tdata_merge_iter(prof_tdata_tree_t *tdatas, prof_tdata_t *tdata, void *arg)
1232 {
1233         prof_cnt_t *cnt_all = (prof_cnt_t *)arg;
1234
1235         malloc_mutex_lock(tdata->lock);
1236         if (!tdata->expired) {
1237                 size_t tabind;
1238                 union {
1239                         prof_tctx_t     *p;
1240                         void            *v;
1241                 } tctx;
1242
1243                 tdata->dumping = true;
1244                 memset(&tdata->cnt_summed, 0, sizeof(prof_cnt_t));
1245                 for (tabind = 0; !ckh_iter(&tdata->bt2tctx, &tabind, NULL,
1246                     &tctx.v);)
1247                         prof_tctx_merge_tdata(tctx.p, tdata);
1248
1249                 cnt_all->curobjs += tdata->cnt_summed.curobjs;
1250                 cnt_all->curbytes += tdata->cnt_summed.curbytes;
1251                 if (opt_prof_accum) {
1252                         cnt_all->accumobjs += tdata->cnt_summed.accumobjs;
1253                         cnt_all->accumbytes += tdata->cnt_summed.accumbytes;
1254                 }
1255         } else
1256                 tdata->dumping = false;
1257         malloc_mutex_unlock(tdata->lock);
1258
1259         return (NULL);
1260 }
1261
1262 static prof_tdata_t *
1263 prof_tdata_dump_iter(prof_tdata_tree_t *tdatas, prof_tdata_t *tdata, void *arg)
1264 {
1265         bool propagate_err = *(bool *)arg;
1266
1267         if (!tdata->dumping)
1268                 return (NULL);
1269
1270         if (prof_dump_printf(propagate_err,
1271             "  t%"FMTu64": %"FMTu64": %"FMTu64" [%"FMTu64": %"FMTu64"]%s%s\n",
1272             tdata->thr_uid, tdata->cnt_summed.curobjs,
1273             tdata->cnt_summed.curbytes, tdata->cnt_summed.accumobjs,
1274             tdata->cnt_summed.accumbytes,
1275             (tdata->thread_name != NULL) ? " " : "",
1276             (tdata->thread_name != NULL) ? tdata->thread_name : ""))
1277                 return (tdata);
1278         return (NULL);
1279 }
1280
1281 #ifdef JEMALLOC_JET
1282 #undef prof_dump_header
1283 #define prof_dump_header JEMALLOC_N(prof_dump_header_impl)
1284 #endif
1285 static bool
1286 prof_dump_header(bool propagate_err, const prof_cnt_t *cnt_all)
1287 {
1288         bool ret;
1289
1290         if (prof_dump_printf(propagate_err,
1291             "heap_v2/%"FMTu64"\n"
1292             "  t*: %"FMTu64": %"FMTu64" [%"FMTu64": %"FMTu64"]\n",
1293             ((uint64_t)1U << lg_prof_sample), cnt_all->curobjs,
1294             cnt_all->curbytes, cnt_all->accumobjs, cnt_all->accumbytes))
1295                 return (true);
1296
1297         malloc_mutex_lock(&tdatas_mtx);
1298         ret = (tdata_tree_iter(&tdatas, NULL, prof_tdata_dump_iter,
1299             (void *)&propagate_err) != NULL);
1300         malloc_mutex_unlock(&tdatas_mtx);
1301         return (ret);
1302 }
1303 #ifdef JEMALLOC_JET
1304 #undef prof_dump_header
1305 #define prof_dump_header JEMALLOC_N(prof_dump_header)
1306 prof_dump_header_t *prof_dump_header = JEMALLOC_N(prof_dump_header_impl);
1307 #endif
1308
1309 /* gctx->lock is held. */
1310 static bool
1311 prof_dump_gctx(bool propagate_err, prof_gctx_t *gctx, const prof_bt_t *bt,
1312     prof_gctx_tree_t *gctxs)
1313 {
1314         bool ret;
1315         unsigned i;
1316
1317         cassert(config_prof);
1318
1319         /* Avoid dumping such gctx's that have no useful data. */
1320         if ((!opt_prof_accum && gctx->cnt_summed.curobjs == 0) ||
1321             (opt_prof_accum && gctx->cnt_summed.accumobjs == 0)) {
1322                 assert(gctx->cnt_summed.curobjs == 0);
1323                 assert(gctx->cnt_summed.curbytes == 0);
1324                 assert(gctx->cnt_summed.accumobjs == 0);
1325                 assert(gctx->cnt_summed.accumbytes == 0);
1326                 ret = false;
1327                 goto label_return;
1328         }
1329
1330         if (prof_dump_printf(propagate_err, "@")) {
1331                 ret = true;
1332                 goto label_return;
1333         }
1334         for (i = 0; i < bt->len; i++) {
1335                 if (prof_dump_printf(propagate_err, " %#"FMTxPTR,
1336                     (uintptr_t)bt->vec[i])) {
1337                         ret = true;
1338                         goto label_return;
1339                 }
1340         }
1341
1342         if (prof_dump_printf(propagate_err,
1343             "\n"
1344             "  t*: %"FMTu64": %"FMTu64" [%"FMTu64": %"FMTu64"]\n",
1345             gctx->cnt_summed.curobjs, gctx->cnt_summed.curbytes,
1346             gctx->cnt_summed.accumobjs, gctx->cnt_summed.accumbytes)) {
1347                 ret = true;
1348                 goto label_return;
1349         }
1350
1351         if (tctx_tree_iter(&gctx->tctxs, NULL, prof_tctx_dump_iter,
1352             (void *)&propagate_err) != NULL) {
1353                 ret = true;
1354                 goto label_return;
1355         }
1356
1357         ret = false;
1358 label_return:
1359         return (ret);
1360 }
1361
1362 #ifndef _WIN32
1363 JEMALLOC_FORMAT_PRINTF(1, 2)
1364 static int
1365 prof_open_maps(const char *format, ...)
1366 {
1367         int mfd;
1368         va_list ap;
1369         char filename[PATH_MAX + 1];
1370
1371         va_start(ap, format);
1372         malloc_vsnprintf(filename, sizeof(filename), format, ap);
1373         va_end(ap);
1374         mfd = open(filename, O_RDONLY);
1375
1376         return (mfd);
1377 }
1378 #endif
1379
1380 static int
1381 prof_getpid(void)
1382 {
1383
1384 #ifdef _WIN32
1385         return (GetCurrentProcessId());
1386 #else
1387         return (getpid());
1388 #endif
1389 }
1390
1391 static bool
1392 prof_dump_maps(bool propagate_err)
1393 {
1394         bool ret;
1395         int mfd;
1396
1397         cassert(config_prof);
1398 #ifdef __FreeBSD__
1399         mfd = prof_open_maps("/proc/curproc/map");
1400 #elif defined(_WIN32)
1401         mfd = -1; // Not implemented
1402 #else
1403         {
1404                 int pid = prof_getpid();
1405
1406                 mfd = prof_open_maps("/proc/%d/task/%d/maps", pid, pid);
1407                 if (mfd == -1)
1408                         mfd = prof_open_maps("/proc/%d/maps", pid);
1409         }
1410 #endif
1411         if (mfd != -1) {
1412                 ssize_t nread;
1413
1414                 if (prof_dump_write(propagate_err, "\nMAPPED_LIBRARIES:\n") &&
1415                     propagate_err) {
1416                         ret = true;
1417                         goto label_return;
1418                 }
1419                 nread = 0;
1420                 do {
1421                         prof_dump_buf_end += nread;
1422                         if (prof_dump_buf_end == PROF_DUMP_BUFSIZE) {
1423                                 /* Make space in prof_dump_buf before read(). */
1424                                 if (prof_dump_flush(propagate_err) &&
1425                                     propagate_err) {
1426                                         ret = true;
1427                                         goto label_return;
1428                                 }
1429                         }
1430                         nread = read(mfd, &prof_dump_buf[prof_dump_buf_end],
1431                             PROF_DUMP_BUFSIZE - prof_dump_buf_end);
1432                 } while (nread > 0);
1433         } else {
1434                 ret = true;
1435                 goto label_return;
1436         }
1437
1438         ret = false;
1439 label_return:
1440         if (mfd != -1)
1441                 close(mfd);
1442         return (ret);
1443 }
1444
1445 static void
1446 prof_leakcheck(const prof_cnt_t *cnt_all, size_t leak_ngctx,
1447     const char *filename)
1448 {
1449
1450         if (cnt_all->curbytes != 0) {
1451                 malloc_printf("<jemalloc>: Leak summary: %"FMTu64" byte%s, %"
1452                     FMTu64" object%s, %zu context%s\n",
1453                     cnt_all->curbytes, (cnt_all->curbytes != 1) ? "s" : "",
1454                     cnt_all->curobjs, (cnt_all->curobjs != 1) ? "s" : "",
1455                     leak_ngctx, (leak_ngctx != 1) ? "s" : "");
1456                 malloc_printf(
1457                     "<jemalloc>: Run jeprof on \"%s\" for leak detail\n",
1458                     filename);
1459         }
1460 }
1461
1462 static prof_gctx_t *
1463 prof_gctx_dump_iter(prof_gctx_tree_t *gctxs, prof_gctx_t *gctx, void *arg)
1464 {
1465         prof_gctx_t *ret;
1466         bool propagate_err = *(bool *)arg;
1467
1468         malloc_mutex_lock(gctx->lock);
1469
1470         if (prof_dump_gctx(propagate_err, gctx, &gctx->bt, gctxs)) {
1471                 ret = gctx;
1472                 goto label_return;
1473         }
1474
1475         ret = NULL;
1476 label_return:
1477         malloc_mutex_unlock(gctx->lock);
1478         return (ret);
1479 }
1480
1481 static bool
1482 prof_dump(tsd_t *tsd, bool propagate_err, const char *filename, bool leakcheck)
1483 {
1484         prof_tdata_t *tdata;
1485         prof_cnt_t cnt_all;
1486         size_t tabind;
1487         union {
1488                 prof_gctx_t     *p;
1489                 void            *v;
1490         } gctx;
1491         size_t leak_ngctx;
1492         prof_gctx_tree_t gctxs;
1493
1494         cassert(config_prof);
1495
1496         tdata = prof_tdata_get(tsd, true);
1497         if (tdata == NULL)
1498                 return (true);
1499
1500         malloc_mutex_lock(&prof_dump_mtx);
1501         prof_enter(tsd, tdata);
1502
1503         /*
1504          * Put gctx's in limbo and clear their counters in preparation for
1505          * summing.
1506          */
1507         gctx_tree_new(&gctxs);
1508         for (tabind = 0; !ckh_iter(&bt2gctx, &tabind, NULL, &gctx.v);)
1509                 prof_dump_gctx_prep(gctx.p, &gctxs);
1510
1511         /*
1512          * Iterate over tdatas, and for the non-expired ones snapshot their tctx
1513          * stats and merge them into the associated gctx's.
1514          */
1515         memset(&cnt_all, 0, sizeof(prof_cnt_t));
1516         malloc_mutex_lock(&tdatas_mtx);
1517         tdata_tree_iter(&tdatas, NULL, prof_tdata_merge_iter, (void *)&cnt_all);
1518         malloc_mutex_unlock(&tdatas_mtx);
1519
1520         /* Merge tctx stats into gctx's. */
1521         leak_ngctx = 0;
1522         gctx_tree_iter(&gctxs, NULL, prof_gctx_merge_iter, (void *)&leak_ngctx);
1523
1524         prof_leave(tsd, tdata);
1525
1526         /* Create dump file. */
1527         if ((prof_dump_fd = prof_dump_open(propagate_err, filename)) == -1)
1528                 goto label_open_close_error;
1529
1530         /* Dump profile header. */
1531         if (prof_dump_header(propagate_err, &cnt_all))
1532                 goto label_write_error;
1533
1534         /* Dump per gctx profile stats. */
1535         if (gctx_tree_iter(&gctxs, NULL, prof_gctx_dump_iter,
1536             (void *)&propagate_err) != NULL)
1537                 goto label_write_error;
1538
1539         /* Dump /proc/<pid>/maps if possible. */
1540         if (prof_dump_maps(propagate_err))
1541                 goto label_write_error;
1542
1543         if (prof_dump_close(propagate_err))
1544                 goto label_open_close_error;
1545
1546         prof_gctx_finish(tsd, &gctxs);
1547         malloc_mutex_unlock(&prof_dump_mtx);
1548
1549         if (leakcheck)
1550                 prof_leakcheck(&cnt_all, leak_ngctx, filename);
1551
1552         return (false);
1553 label_write_error:
1554         prof_dump_close(propagate_err);
1555 label_open_close_error:
1556         prof_gctx_finish(tsd, &gctxs);
1557         malloc_mutex_unlock(&prof_dump_mtx);
1558         return (true);
1559 }
1560
1561 #define DUMP_FILENAME_BUFSIZE   (PATH_MAX + 1)
1562 #define VSEQ_INVALID            UINT64_C(0xffffffffffffffff)
1563 static void
1564 prof_dump_filename(char *filename, char v, uint64_t vseq)
1565 {
1566
1567         cassert(config_prof);
1568
1569         if (vseq != VSEQ_INVALID) {
1570                 /* "<prefix>.<pid>.<seq>.v<vseq>.heap" */
1571                 malloc_snprintf(filename, DUMP_FILENAME_BUFSIZE,
1572                     "%s.%d.%"FMTu64".%c%"FMTu64".heap",
1573                     opt_prof_prefix, prof_getpid(), prof_dump_seq, v, vseq);
1574         } else {
1575                 /* "<prefix>.<pid>.<seq>.<v>.heap" */
1576                 malloc_snprintf(filename, DUMP_FILENAME_BUFSIZE,
1577                     "%s.%d.%"FMTu64".%c.heap",
1578                     opt_prof_prefix, prof_getpid(), prof_dump_seq, v);
1579         }
1580         prof_dump_seq++;
1581 }
1582
1583 static void
1584 prof_fdump(void)
1585 {
1586         tsd_t *tsd;
1587         char filename[DUMP_FILENAME_BUFSIZE];
1588
1589         cassert(config_prof);
1590         assert(opt_prof_final);
1591         assert(opt_prof_prefix[0] != '\0');
1592
1593         if (!prof_booted)
1594                 return;
1595         tsd = tsd_fetch();
1596
1597         malloc_mutex_lock(&prof_dump_seq_mtx);
1598         prof_dump_filename(filename, 'f', VSEQ_INVALID);
1599         malloc_mutex_unlock(&prof_dump_seq_mtx);
1600         prof_dump(tsd, false, filename, opt_prof_leak);
1601 }
1602
1603 void
1604 prof_idump(void)
1605 {
1606         tsd_t *tsd;
1607         prof_tdata_t *tdata;
1608
1609         cassert(config_prof);
1610
1611         if (!prof_booted)
1612                 return;
1613         tsd = tsd_fetch();
1614         tdata = prof_tdata_get(tsd, false);
1615         if (tdata == NULL)
1616                 return;
1617         if (tdata->enq) {
1618                 tdata->enq_idump = true;
1619                 return;
1620         }
1621
1622         if (opt_prof_prefix[0] != '\0') {
1623                 char filename[PATH_MAX + 1];
1624                 malloc_mutex_lock(&prof_dump_seq_mtx);
1625                 prof_dump_filename(filename, 'i', prof_dump_iseq);
1626                 prof_dump_iseq++;
1627                 malloc_mutex_unlock(&prof_dump_seq_mtx);
1628                 prof_dump(tsd, false, filename, false);
1629         }
1630 }
1631
1632 bool
1633 prof_mdump(const char *filename)
1634 {
1635         tsd_t *tsd;
1636         char filename_buf[DUMP_FILENAME_BUFSIZE];
1637
1638         cassert(config_prof);
1639
1640         if (!opt_prof || !prof_booted)
1641                 return (true);
1642         tsd = tsd_fetch();
1643
1644         if (filename == NULL) {
1645                 /* No filename specified, so automatically generate one. */
1646                 if (opt_prof_prefix[0] == '\0')
1647                         return (true);
1648                 malloc_mutex_lock(&prof_dump_seq_mtx);
1649                 prof_dump_filename(filename_buf, 'm', prof_dump_mseq);
1650                 prof_dump_mseq++;
1651                 malloc_mutex_unlock(&prof_dump_seq_mtx);
1652                 filename = filename_buf;
1653         }
1654         return (prof_dump(tsd, true, filename, false));
1655 }
1656
1657 void
1658 prof_gdump(void)
1659 {
1660         tsd_t *tsd;
1661         prof_tdata_t *tdata;
1662
1663         cassert(config_prof);
1664
1665         if (!prof_booted)
1666                 return;
1667         tsd = tsd_fetch();
1668         tdata = prof_tdata_get(tsd, false);
1669         if (tdata == NULL)
1670                 return;
1671         if (tdata->enq) {
1672                 tdata->enq_gdump = true;
1673                 return;
1674         }
1675
1676         if (opt_prof_prefix[0] != '\0') {
1677                 char filename[DUMP_FILENAME_BUFSIZE];
1678                 malloc_mutex_lock(&prof_dump_seq_mtx);
1679                 prof_dump_filename(filename, 'u', prof_dump_useq);
1680                 prof_dump_useq++;
1681                 malloc_mutex_unlock(&prof_dump_seq_mtx);
1682                 prof_dump(tsd, false, filename, false);
1683         }
1684 }
1685
1686 static void
1687 prof_bt_hash(const void *key, size_t r_hash[2])
1688 {
1689         prof_bt_t *bt = (prof_bt_t *)key;
1690
1691         cassert(config_prof);
1692
1693         hash(bt->vec, bt->len * sizeof(void *), 0x94122f33U, r_hash);
1694 }
1695
1696 static bool
1697 prof_bt_keycomp(const void *k1, const void *k2)
1698 {
1699         const prof_bt_t *bt1 = (prof_bt_t *)k1;
1700         const prof_bt_t *bt2 = (prof_bt_t *)k2;
1701
1702         cassert(config_prof);
1703
1704         if (bt1->len != bt2->len)
1705                 return (false);
1706         return (memcmp(bt1->vec, bt2->vec, bt1->len * sizeof(void *)) == 0);
1707 }
1708
1709 JEMALLOC_INLINE_C uint64_t
1710 prof_thr_uid_alloc(void)
1711 {
1712         uint64_t thr_uid;
1713
1714         malloc_mutex_lock(&next_thr_uid_mtx);
1715         thr_uid = next_thr_uid;
1716         next_thr_uid++;
1717         malloc_mutex_unlock(&next_thr_uid_mtx);
1718
1719         return (thr_uid);
1720 }
1721
1722 static prof_tdata_t *
1723 prof_tdata_init_impl(tsd_t *tsd, uint64_t thr_uid, uint64_t thr_discrim,
1724     char *thread_name, bool active)
1725 {
1726         prof_tdata_t *tdata;
1727         tcache_t *tcache;
1728
1729         cassert(config_prof);
1730
1731         /* Initialize an empty cache for this thread. */
1732         tcache = tcache_get(tsd, true);
1733         tdata = (prof_tdata_t *)iallocztm(tsd, sizeof(prof_tdata_t),
1734             size2index(sizeof(prof_tdata_t)), false, tcache, true, NULL, true);
1735         if (tdata == NULL)
1736                 return (NULL);
1737
1738         tdata->lock = prof_tdata_mutex_choose(thr_uid);
1739         tdata->thr_uid = thr_uid;
1740         tdata->thr_discrim = thr_discrim;
1741         tdata->thread_name = thread_name;
1742         tdata->attached = true;
1743         tdata->expired = false;
1744         tdata->tctx_uid_next = 0;
1745
1746         if (ckh_new(tsd, &tdata->bt2tctx, PROF_CKH_MINITEMS,
1747             prof_bt_hash, prof_bt_keycomp)) {
1748                 idalloctm(tsd, tdata, tcache, true, true);
1749                 return (NULL);
1750         }
1751
1752         tdata->prng_state = (uint64_t)(uintptr_t)tdata;
1753         prof_sample_threshold_update(tdata);
1754
1755         tdata->enq = false;
1756         tdata->enq_idump = false;
1757         tdata->enq_gdump = false;
1758
1759         tdata->dumping = false;
1760         tdata->active = active;
1761
1762         malloc_mutex_lock(&tdatas_mtx);
1763         tdata_tree_insert(&tdatas, tdata);
1764         malloc_mutex_unlock(&tdatas_mtx);
1765
1766         return (tdata);
1767 }
1768
1769 prof_tdata_t *
1770 prof_tdata_init(tsd_t *tsd)
1771 {
1772
1773         return (prof_tdata_init_impl(tsd, prof_thr_uid_alloc(), 0, NULL,
1774             prof_thread_active_init_get()));
1775 }
1776
1777 /* tdata->lock must be held. */
1778 static bool
1779 prof_tdata_should_destroy(prof_tdata_t *tdata, bool even_if_attached)
1780 {
1781
1782         if (tdata->attached && !even_if_attached)
1783                 return (false);
1784         if (ckh_count(&tdata->bt2tctx) != 0)
1785                 return (false);
1786         return (true);
1787 }
1788
1789 /* tdatas_mtx must be held. */
1790 static void
1791 prof_tdata_destroy_locked(tsd_t *tsd, prof_tdata_t *tdata,
1792     bool even_if_attached)
1793 {
1794         tcache_t *tcache;
1795
1796         assert(prof_tdata_should_destroy(tdata, even_if_attached));
1797         assert(tsd_prof_tdata_get(tsd) != tdata);
1798
1799         tdata_tree_remove(&tdatas, tdata);
1800
1801         tcache = tcache_get(tsd, false);
1802         if (tdata->thread_name != NULL)
1803                 idalloctm(tsd, tdata->thread_name, tcache, true, true);
1804         ckh_delete(tsd, &tdata->bt2tctx);
1805         idalloctm(tsd, tdata, tcache, true, true);
1806 }
1807
1808 static void
1809 prof_tdata_destroy(tsd_t *tsd, prof_tdata_t *tdata, bool even_if_attached)
1810 {
1811
1812         malloc_mutex_lock(&tdatas_mtx);
1813         prof_tdata_destroy_locked(tsd, tdata, even_if_attached);
1814         malloc_mutex_unlock(&tdatas_mtx);
1815 }
1816
1817 static void
1818 prof_tdata_detach(tsd_t *tsd, prof_tdata_t *tdata)
1819 {
1820         bool destroy_tdata;
1821
1822         malloc_mutex_lock(tdata->lock);
1823         if (tdata->attached) {
1824                 destroy_tdata = prof_tdata_should_destroy(tdata, true);
1825                 /*
1826                  * Only detach if !destroy_tdata, because detaching would allow
1827                  * another thread to win the race to destroy tdata.
1828                  */
1829                 if (!destroy_tdata)
1830                         tdata->attached = false;
1831                 tsd_prof_tdata_set(tsd, NULL);
1832         } else
1833                 destroy_tdata = false;
1834         malloc_mutex_unlock(tdata->lock);
1835         if (destroy_tdata)
1836                 prof_tdata_destroy(tsd, tdata, true);
1837 }
1838
1839 prof_tdata_t *
1840 prof_tdata_reinit(tsd_t *tsd, prof_tdata_t *tdata)
1841 {
1842         uint64_t thr_uid = tdata->thr_uid;
1843         uint64_t thr_discrim = tdata->thr_discrim + 1;
1844         char *thread_name = (tdata->thread_name != NULL) ?
1845             prof_thread_name_alloc(tsd, tdata->thread_name) : NULL;
1846         bool active = tdata->active;
1847
1848         prof_tdata_detach(tsd, tdata);
1849         return (prof_tdata_init_impl(tsd, thr_uid, thr_discrim, thread_name,
1850             active));
1851 }
1852
1853 static bool
1854 prof_tdata_expire(prof_tdata_t *tdata)
1855 {
1856         bool destroy_tdata;
1857
1858         malloc_mutex_lock(tdata->lock);
1859         if (!tdata->expired) {
1860                 tdata->expired = true;
1861                 destroy_tdata = tdata->attached ? false :
1862                     prof_tdata_should_destroy(tdata, false);
1863         } else
1864                 destroy_tdata = false;
1865         malloc_mutex_unlock(tdata->lock);
1866
1867         return (destroy_tdata);
1868 }
1869
1870 static prof_tdata_t *
1871 prof_tdata_reset_iter(prof_tdata_tree_t *tdatas, prof_tdata_t *tdata, void *arg)
1872 {
1873
1874         return (prof_tdata_expire(tdata) ? tdata : NULL);
1875 }
1876
1877 void
1878 prof_reset(tsd_t *tsd, size_t lg_sample)
1879 {
1880         prof_tdata_t *next;
1881
1882         assert(lg_sample < (sizeof(uint64_t) << 3));
1883
1884         malloc_mutex_lock(&prof_dump_mtx);
1885         malloc_mutex_lock(&tdatas_mtx);
1886
1887         lg_prof_sample = lg_sample;
1888
1889         next = NULL;
1890         do {
1891                 prof_tdata_t *to_destroy = tdata_tree_iter(&tdatas, next,
1892                     prof_tdata_reset_iter, NULL);
1893                 if (to_destroy != NULL) {
1894                         next = tdata_tree_next(&tdatas, to_destroy);
1895                         prof_tdata_destroy_locked(tsd, to_destroy, false);
1896                 } else
1897                         next = NULL;
1898         } while (next != NULL);
1899
1900         malloc_mutex_unlock(&tdatas_mtx);
1901         malloc_mutex_unlock(&prof_dump_mtx);
1902 }
1903
1904 void
1905 prof_tdata_cleanup(tsd_t *tsd)
1906 {
1907         prof_tdata_t *tdata;
1908
1909         if (!config_prof)
1910                 return;
1911
1912         tdata = tsd_prof_tdata_get(tsd);
1913         if (tdata != NULL)
1914                 prof_tdata_detach(tsd, tdata);
1915 }
1916
1917 bool
1918 prof_active_get(void)
1919 {
1920         bool prof_active_current;
1921
1922         malloc_mutex_lock(&prof_active_mtx);
1923         prof_active_current = prof_active;
1924         malloc_mutex_unlock(&prof_active_mtx);
1925         return (prof_active_current);
1926 }
1927
1928 bool
1929 prof_active_set(bool active)
1930 {
1931         bool prof_active_old;
1932
1933         malloc_mutex_lock(&prof_active_mtx);
1934         prof_active_old = prof_active;
1935         prof_active = active;
1936         malloc_mutex_unlock(&prof_active_mtx);
1937         return (prof_active_old);
1938 }
1939
1940 const char *
1941 prof_thread_name_get(void)
1942 {
1943         tsd_t *tsd;
1944         prof_tdata_t *tdata;
1945
1946         tsd = tsd_fetch();
1947         tdata = prof_tdata_get(tsd, true);
1948         if (tdata == NULL)
1949                 return ("");
1950         return (tdata->thread_name != NULL ? tdata->thread_name : "");
1951 }
1952
1953 static char *
1954 prof_thread_name_alloc(tsd_t *tsd, const char *thread_name)
1955 {
1956         char *ret;
1957         size_t size;
1958
1959         if (thread_name == NULL)
1960                 return (NULL);
1961
1962         size = strlen(thread_name) + 1;
1963         if (size == 1)
1964                 return ("");
1965
1966         ret = iallocztm(tsd, size, size2index(size), false, tcache_get(tsd,
1967             true), true, NULL, true);
1968         if (ret == NULL)
1969                 return (NULL);
1970         memcpy(ret, thread_name, size);
1971         return (ret);
1972 }
1973
1974 int
1975 prof_thread_name_set(tsd_t *tsd, const char *thread_name)
1976 {
1977         prof_tdata_t *tdata;
1978         unsigned i;
1979         char *s;
1980
1981         tdata = prof_tdata_get(tsd, true);
1982         if (tdata == NULL)
1983                 return (EAGAIN);
1984
1985         /* Validate input. */
1986         if (thread_name == NULL)
1987                 return (EFAULT);
1988         for (i = 0; thread_name[i] != '\0'; i++) {
1989                 char c = thread_name[i];
1990                 if (!isgraph(c) && !isblank(c))
1991                         return (EFAULT);
1992         }
1993
1994         s = prof_thread_name_alloc(tsd, thread_name);
1995         if (s == NULL)
1996                 return (EAGAIN);
1997
1998         if (tdata->thread_name != NULL) {
1999                 idalloctm(tsd, tdata->thread_name, tcache_get(tsd, false),
2000                     true, true);
2001                 tdata->thread_name = NULL;
2002         }
2003         if (strlen(s) > 0)
2004                 tdata->thread_name = s;
2005         return (0);
2006 }
2007
2008 bool
2009 prof_thread_active_get(void)
2010 {
2011         tsd_t *tsd;
2012         prof_tdata_t *tdata;
2013
2014         tsd = tsd_fetch();
2015         tdata = prof_tdata_get(tsd, true);
2016         if (tdata == NULL)
2017                 return (false);
2018         return (tdata->active);
2019 }
2020
2021 bool
2022 prof_thread_active_set(bool active)
2023 {
2024         tsd_t *tsd;
2025         prof_tdata_t *tdata;
2026
2027         tsd = tsd_fetch();
2028         tdata = prof_tdata_get(tsd, true);
2029         if (tdata == NULL)
2030                 return (true);
2031         tdata->active = active;
2032         return (false);
2033 }
2034
2035 bool
2036 prof_thread_active_init_get(void)
2037 {
2038         bool active_init;
2039
2040         malloc_mutex_lock(&prof_thread_active_init_mtx);
2041         active_init = prof_thread_active_init;
2042         malloc_mutex_unlock(&prof_thread_active_init_mtx);
2043         return (active_init);
2044 }
2045
2046 bool
2047 prof_thread_active_init_set(bool active_init)
2048 {
2049         bool active_init_old;
2050
2051         malloc_mutex_lock(&prof_thread_active_init_mtx);
2052         active_init_old = prof_thread_active_init;
2053         prof_thread_active_init = active_init;
2054         malloc_mutex_unlock(&prof_thread_active_init_mtx);
2055         return (active_init_old);
2056 }
2057
2058 bool
2059 prof_gdump_get(void)
2060 {
2061         bool prof_gdump_current;
2062
2063         malloc_mutex_lock(&prof_gdump_mtx);
2064         prof_gdump_current = prof_gdump_val;
2065         malloc_mutex_unlock(&prof_gdump_mtx);
2066         return (prof_gdump_current);
2067 }
2068
2069 bool
2070 prof_gdump_set(bool gdump)
2071 {
2072         bool prof_gdump_old;
2073
2074         malloc_mutex_lock(&prof_gdump_mtx);
2075         prof_gdump_old = prof_gdump_val;
2076         prof_gdump_val = gdump;
2077         malloc_mutex_unlock(&prof_gdump_mtx);
2078         return (prof_gdump_old);
2079 }
2080
2081 void
2082 prof_boot0(void)
2083 {
2084
2085         cassert(config_prof);
2086
2087         memcpy(opt_prof_prefix, PROF_PREFIX_DEFAULT,
2088             sizeof(PROF_PREFIX_DEFAULT));
2089 }
2090
2091 void
2092 prof_boot1(void)
2093 {
2094
2095         cassert(config_prof);
2096
2097         /*
2098          * opt_prof must be in its final state before any arenas are
2099          * initialized, so this function must be executed early.
2100          */
2101
2102         if (opt_prof_leak && !opt_prof) {
2103                 /*
2104                  * Enable opt_prof, but in such a way that profiles are never
2105                  * automatically dumped.
2106                  */
2107                 opt_prof = true;
2108                 opt_prof_gdump = false;
2109         } else if (opt_prof) {
2110                 if (opt_lg_prof_interval >= 0) {
2111                         prof_interval = (((uint64_t)1U) <<
2112                             opt_lg_prof_interval);
2113                 }
2114         }
2115 }
2116
2117 bool
2118 prof_boot2(void)
2119 {
2120
2121         cassert(config_prof);
2122
2123         if (opt_prof) {
2124                 tsd_t *tsd;
2125                 unsigned i;
2126
2127                 lg_prof_sample = opt_lg_prof_sample;
2128
2129                 prof_active = opt_prof_active;
2130                 if (malloc_mutex_init(&prof_active_mtx))
2131                         return (true);
2132
2133                 prof_gdump_val = opt_prof_gdump;
2134                 if (malloc_mutex_init(&prof_gdump_mtx))
2135                         return (true);
2136
2137                 prof_thread_active_init = opt_prof_thread_active_init;
2138                 if (malloc_mutex_init(&prof_thread_active_init_mtx))
2139                         return (true);
2140
2141                 tsd = tsd_fetch();
2142                 if (ckh_new(tsd, &bt2gctx, PROF_CKH_MINITEMS, prof_bt_hash,
2143                     prof_bt_keycomp))
2144                         return (true);
2145                 if (malloc_mutex_init(&bt2gctx_mtx))
2146                         return (true);
2147
2148                 tdata_tree_new(&tdatas);
2149                 if (malloc_mutex_init(&tdatas_mtx))
2150                         return (true);
2151
2152                 next_thr_uid = 0;
2153                 if (malloc_mutex_init(&next_thr_uid_mtx))
2154                         return (true);
2155
2156                 if (malloc_mutex_init(&prof_dump_seq_mtx))
2157                         return (true);
2158                 if (malloc_mutex_init(&prof_dump_mtx))
2159                         return (true);
2160
2161                 if (opt_prof_final && opt_prof_prefix[0] != '\0' &&
2162                     atexit(prof_fdump) != 0) {
2163                         malloc_write("<jemalloc>: Error in atexit()\n");
2164                         if (opt_abort)
2165                                 abort();
2166                 }
2167
2168                 gctx_locks = (malloc_mutex_t *)base_alloc(PROF_NCTX_LOCKS *
2169                     sizeof(malloc_mutex_t));
2170                 if (gctx_locks == NULL)
2171                         return (true);
2172                 for (i = 0; i < PROF_NCTX_LOCKS; i++) {
2173                         if (malloc_mutex_init(&gctx_locks[i]))
2174                                 return (true);
2175                 }
2176
2177                 tdata_locks = (malloc_mutex_t *)base_alloc(PROF_NTDATA_LOCKS *
2178                     sizeof(malloc_mutex_t));
2179                 if (tdata_locks == NULL)
2180                         return (true);
2181                 for (i = 0; i < PROF_NTDATA_LOCKS; i++) {
2182                         if (malloc_mutex_init(&tdata_locks[i]))
2183                                 return (true);
2184                 }
2185         }
2186
2187 #ifdef JEMALLOC_PROF_LIBGCC
2188         /*
2189          * Cause the backtracing machinery to allocate its internal state
2190          * before enabling profiling.
2191          */
2192         _Unwind_Backtrace(prof_unwind_init_callback, NULL);
2193 #endif
2194
2195         prof_booted = true;
2196
2197         return (false);
2198 }
2199
2200 void
2201 prof_prefork(void)
2202 {
2203
2204         if (opt_prof) {
2205                 unsigned i;
2206
2207                 malloc_mutex_prefork(&tdatas_mtx);
2208                 malloc_mutex_prefork(&bt2gctx_mtx);
2209                 malloc_mutex_prefork(&next_thr_uid_mtx);
2210                 malloc_mutex_prefork(&prof_dump_seq_mtx);
2211                 for (i = 0; i < PROF_NCTX_LOCKS; i++)
2212                         malloc_mutex_prefork(&gctx_locks[i]);
2213                 for (i = 0; i < PROF_NTDATA_LOCKS; i++)
2214                         malloc_mutex_prefork(&tdata_locks[i]);
2215         }
2216 }
2217
2218 void
2219 prof_postfork_parent(void)
2220 {
2221
2222         if (opt_prof) {
2223                 unsigned i;
2224
2225                 for (i = 0; i < PROF_NTDATA_LOCKS; i++)
2226                         malloc_mutex_postfork_parent(&tdata_locks[i]);
2227                 for (i = 0; i < PROF_NCTX_LOCKS; i++)
2228                         malloc_mutex_postfork_parent(&gctx_locks[i]);
2229                 malloc_mutex_postfork_parent(&prof_dump_seq_mtx);
2230                 malloc_mutex_postfork_parent(&next_thr_uid_mtx);
2231                 malloc_mutex_postfork_parent(&bt2gctx_mtx);
2232                 malloc_mutex_postfork_parent(&tdatas_mtx);
2233         }
2234 }
2235
2236 void
2237 prof_postfork_child(void)
2238 {
2239
2240         if (opt_prof) {
2241                 unsigned i;
2242
2243                 for (i = 0; i < PROF_NTDATA_LOCKS; i++)
2244                         malloc_mutex_postfork_child(&tdata_locks[i]);
2245                 for (i = 0; i < PROF_NCTX_LOCKS; i++)
2246                         malloc_mutex_postfork_child(&gctx_locks[i]);
2247                 malloc_mutex_postfork_child(&prof_dump_seq_mtx);
2248                 malloc_mutex_postfork_child(&next_thr_uid_mtx);
2249                 malloc_mutex_postfork_child(&bt2gctx_mtx);
2250                 malloc_mutex_postfork_child(&tdatas_mtx);
2251         }
2252 }
2253
2254 /******************************************************************************/