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