mem0dbg.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:22k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /************************************************************************
  2. The memory management: the debug code. This is not a compilation module,
  3. but is included in mem0mem.* !
  4. (c) 1994, 1995 Innobase Oy
  5. Created 6/9/1994 Heikki Tuuri
  6. *************************************************************************/
  7. #ifdef UNIV_MEM_DEBUG
  8. mutex_t mem_hash_mutex;  /* The mutex which protects in the
  9. debug version the hash table containing
  10. the list of live memory heaps, and
  11. also the global variables below. */
  12. /* The following variables contain information about the
  13. extent of memory allocations. Only used in the debug version.
  14. Protected by mem_hash_mutex above. */
  15. static ulint mem_n_created_heaps  = 0;
  16. static ulint mem_n_allocations    = 0;
  17. static ulint mem_total_allocated_memory = 0;
  18. ulint mem_current_allocated_memory = 0;
  19. static ulint mem_max_allocated_memory = 0;
  20. static ulint mem_last_print_info = 0;
  21. /* Size of the hash table for memory management tracking */
  22. #define MEM_HASH_SIZE 997
  23. /* The node of the list containing currently allocated memory heaps */
  24. typedef struct mem_hash_node_struct mem_hash_node_t;
  25. struct mem_hash_node_struct {
  26. UT_LIST_NODE_T(mem_hash_node_t)
  27. list; /* hash list node */
  28. mem_heap_t* heap; /* memory heap */
  29. const char* file_name;/* file where heap was created*/
  30. ulint line; /* file line of creation */
  31. ulint nth_heap;/* this is the nth heap created */
  32. UT_LIST_NODE_T(mem_hash_node_t)
  33. all_list;/* list of all created heaps */
  34. };
  35. typedef UT_LIST_BASE_NODE_T(mem_hash_node_t) mem_hash_cell_t;
  36. /* The hash table of allocated heaps */
  37. static mem_hash_cell_t mem_hash_table[MEM_HASH_SIZE];
  38. /* The base node of the list of all allocated heaps */
  39. static mem_hash_cell_t mem_all_list_base;
  40. static ibool mem_hash_initialized = FALSE;
  41. UNIV_INLINE
  42. mem_hash_cell_t*
  43. mem_hash_get_nth_cell(ulint i);
  44. /* Accessor function for the hash table. Returns a pointer to the
  45. table cell. */
  46. UNIV_INLINE
  47. mem_hash_cell_t*
  48. mem_hash_get_nth_cell(ulint i)
  49. {
  50. ut_a(i < MEM_HASH_SIZE);
  51. return(&(mem_hash_table[i]));
  52. }
  53. #endif /* UNIV_MEM_DEBUG */
  54. /* Accessor functions for a memory field in the debug version */
  55. void
  56. mem_field_header_set_len(byte* field, ulint len)
  57. {
  58. mach_write_to_4(field - 2 * sizeof(ulint), len);
  59. }
  60. ulint
  61. mem_field_header_get_len(byte* field)
  62. {
  63. return(mach_read_from_4(field - 2 * sizeof(ulint)));
  64. }
  65. void
  66. mem_field_header_set_check(byte* field, ulint check)
  67. {
  68. mach_write_to_4(field - sizeof(ulint), check);
  69. }
  70. ulint
  71. mem_field_header_get_check(byte* field)
  72. {
  73. return(mach_read_from_4(field - sizeof(ulint)));
  74. }
  75. void
  76. mem_field_trailer_set_check(byte* field, ulint check)
  77. {
  78. mach_write_to_4(field + mem_field_header_get_len(field), check);
  79. }
  80. ulint
  81. mem_field_trailer_get_check(byte* field)
  82. {
  83. return(mach_read_from_4(field +
  84. mem_field_header_get_len(field)));
  85. }
  86. /**********************************************************************
  87. Initializes the memory system. */
  88. void
  89. mem_init(
  90. /*=====*/
  91. ulint size) /* in: common pool size in bytes */
  92. {
  93. #ifdef UNIV_MEM_DEBUG
  94. ulint i;
  95. /* Initialize the hash table */
  96. ut_a(FALSE == mem_hash_initialized);
  97. mutex_create(&mem_hash_mutex);
  98. mutex_set_level(&mem_hash_mutex, SYNC_MEM_HASH);
  99. for (i = 0; i < MEM_HASH_SIZE; i++) {
  100. UT_LIST_INIT(*mem_hash_get_nth_cell(i));
  101. }
  102. UT_LIST_INIT(mem_all_list_base);
  103. mem_hash_initialized = TRUE;
  104. #endif
  105. mem_comm_pool = mem_pool_create(size);
  106. }
  107. /**********************************************************************
  108. Initializes an allocated memory field in the debug version. */
  109. void
  110. mem_field_init(
  111. /*===========*/
  112. byte* buf, /* in: memory field */
  113. ulint n) /* in: how many bytes the user requested */
  114. {
  115. ulint rnd;
  116. byte* usr_buf;
  117. usr_buf = buf + MEM_FIELD_HEADER_SIZE;
  118. /* In the debug version write the length field and the 
  119. check fields to the start and the end of the allocated storage.
  120. The field header consists of a length field and
  121. a random number field, in this order. The field trailer contains
  122. the same random number as a check field. */
  123. mem_field_header_set_len(usr_buf, n);
  124. rnd = ut_rnd_gen_ulint();
  125. mem_field_header_set_check(usr_buf, rnd);
  126. mem_field_trailer_set_check(usr_buf, rnd);
  127. #ifdef UNIV_MEM_DEBUG
  128. /* Update the memory allocation information */
  129. mutex_enter(&mem_hash_mutex);
  130. mem_total_allocated_memory += n;
  131. mem_current_allocated_memory += n;
  132. mem_n_allocations++;
  133. if (mem_current_allocated_memory > mem_max_allocated_memory) {
  134. mem_max_allocated_memory = mem_current_allocated_memory;
  135. }
  136. mutex_exit(&mem_hash_mutex);
  137. /* In the debug version set the buffer to a random
  138. combination of 0xBA and 0xBE */
  139. mem_init_buf(usr_buf, n);
  140. #endif /* UNIV_MEM_DEBUG */
  141. }
  142. /**********************************************************************
  143. Erases an allocated memory field in the debug version. */
  144. void
  145. mem_field_erase(
  146. /*============*/
  147. byte* buf, /* in: memory field */
  148. ulint n __attribute__((unused)))
  149. /* in: how many bytes the user requested */
  150. {
  151. byte* usr_buf;
  152. usr_buf = buf + MEM_FIELD_HEADER_SIZE;
  153. #ifdef UNIV_MEM_DEBUG
  154. mutex_enter(&mem_hash_mutex);
  155. mem_current_allocated_memory    -= n;
  156. mutex_exit(&mem_hash_mutex);
  157. /* Check that the field lengths agree */
  158. ut_ad(n == (ulint)mem_field_header_get_len(usr_buf));
  159. /* In the debug version, set the freed space to a random
  160. combination of 0xDE and 0xAD */
  161. mem_erase_buf(buf, MEM_SPACE_NEEDED(n));
  162. #endif /* UNIV_MEM_DEBUG */
  163. }
  164. #ifdef UNIV_MEM_DEBUG
  165. /*******************************************************************
  166. Initializes a buffer to a random combination of hex BA and BE.
  167. Used to initialize allocated memory. */
  168. void
  169. mem_init_buf(
  170. /*=========*/
  171. byte*   buf,    /* in: pointer to buffer */
  172. ulint    n)     /* in: length of buffer */
  173. {
  174. byte*   ptr;
  175. for (ptr = buf; ptr < buf + n; ptr++) {
  176. if (ut_rnd_gen_ibool()) {
  177. *ptr = 0xBA;
  178. } else {
  179. *ptr = 0xBE;
  180. }
  181. }
  182. }
  183. /*******************************************************************
  184. Initializes a buffer to a random combination of hex DE and AD.
  185. Used to erase freed memory.*/
  186. void
  187. mem_erase_buf(
  188. /*==========*/
  189. byte*   buf,    /* in: pointer to buffer */
  190. ulint    n)      /* in: length of buffer */
  191. {
  192. byte*   ptr;
  193. for (ptr = buf; ptr < buf + n; ptr++) {
  194. if (ut_rnd_gen_ibool()) {
  195. *ptr = 0xDE;
  196. } else {
  197. *ptr = 0xAD;
  198. }
  199. }
  200. }
  201. /*******************************************************************
  202. Inserts a created memory heap to the hash table of current allocated
  203. memory heaps. */
  204. void
  205. mem_hash_insert(
  206. /*============*/
  207. mem_heap_t* heap,    /* in: the created heap */
  208. const char* file_name, /* in: file name of creation */
  209. ulint line)    /* in: line where created */
  210. {
  211. mem_hash_node_t* new_node;
  212. ulint cell_no ;
  213. ut_ad(mem_heap_check(heap));
  214. mutex_enter(&mem_hash_mutex);
  215. cell_no = ut_hash_ulint((ulint)heap, MEM_HASH_SIZE);
  216. /* Allocate a new node to the list */
  217. new_node = ut_malloc(sizeof(mem_hash_node_t));
  218. new_node->heap = heap;
  219. new_node->file_name = file_name;
  220. new_node->line = line;
  221. new_node->nth_heap = mem_n_created_heaps;
  222. /* Insert into lists */
  223. UT_LIST_ADD_FIRST(list, *mem_hash_get_nth_cell(cell_no), new_node);
  224. UT_LIST_ADD_LAST(all_list, mem_all_list_base, new_node);
  225. mem_n_created_heaps++;
  226. mutex_exit(&mem_hash_mutex);
  227. }
  228. /*******************************************************************
  229. Removes a memory heap (which is going to be freed by the caller)
  230. from the list of live memory heaps. Returns the size of the heap
  231. in terms of how much memory in bytes was allocated for the user of
  232. the heap (not the total space occupied by the heap).
  233. Also validates the heap.
  234. NOTE: This function does not free the storage occupied by the
  235. heap itself, only the node in the list of heaps. */
  236. void
  237. mem_hash_remove(
  238. /*============*/
  239. mem_heap_t* heap,    /* in: the heap to be freed */
  240. const char* file_name, /* in: file name of freeing */
  241. ulint line)    /* in: line where freed */
  242. {
  243. mem_hash_node_t* node;
  244. ulint cell_no;
  245. ibool error;
  246. ulint size;
  247. ut_ad(mem_heap_check(heap));
  248. mutex_enter(&mem_hash_mutex);
  249. cell_no = ut_hash_ulint((ulint)heap, MEM_HASH_SIZE);
  250. /* Look for the heap in the hash table list */
  251. node = UT_LIST_GET_FIRST(*mem_hash_get_nth_cell(cell_no));
  252. while (node != NULL) {
  253. if (node->heap == heap) {
  254. break;
  255. }
  256. node = UT_LIST_GET_NEXT(list, node);
  257. }
  258. if (node == NULL) {
  259. fprintf(stderr,
  260.          "Memory heap or buffer freed in %s line %lu did not exist.n",
  261. file_name, (ulong) line);
  262. ut_error;
  263. }
  264. /* Remove from lists */
  265. UT_LIST_REMOVE(list, *mem_hash_get_nth_cell(cell_no), node);
  266. UT_LIST_REMOVE(all_list, mem_all_list_base, node);
  267. /* Validate the heap which will be freed */
  268. mem_heap_validate_or_print(node->heap, NULL, FALSE, &error, &size,
  269. NULL, NULL);
  270. if (error) {
  271. fprintf(stderr,
  272. "Inconsistency in memory heap or buffer n:o %lu createdn"
  273. "in %s line %lu and tried to free in %s line %lu.n"
  274. "Hex dump of 400 bytes around memory heap first block start:n",
  275. node->nth_heap, node->file_name, (ulong) node->line,
  276. file_name, (ulong) line);
  277. ut_print_buf(stderr, (byte*)node->heap - 200, 400);
  278. fputs("nDump of the mem heap:n", stderr);
  279. mem_heap_validate_or_print(node->heap, NULL, TRUE, &error,
  280.  &size, NULL, NULL);
  281. ut_error;
  282. }
  283. /* Free the memory occupied by the node struct */
  284. ut_free(node);
  285. mem_current_allocated_memory -= size;
  286. mutex_exit(&mem_hash_mutex);
  287. }
  288. #endif /* UNIV_MEM_DEBUG */
  289. /*******************************************************************
  290. Checks a memory heap for consistency and prints the contents if requested.
  291. Outputs the sum of sizes of buffers given to the user (only in
  292. the debug version), the physical size of the heap and the number of
  293. blocks in the heap. In case of error returns 0 as sizes and number
  294. of blocks. */
  295. void
  296. mem_heap_validate_or_print(
  297. /*=======================*/
  298. mem_heap_t*  heap,  /* in: memory heap */
  299. byte* top __attribute__((unused)),
  300.                         /* in: calculate and validate only until
  301. this top pointer in the heap is reached,
  302. if this pointer is NULL, ignored */
  303. ibool print, /* in: if TRUE, prints the contents
  304. of the heap; works only in
  305. the debug version */
  306. ibool* error, /* out: TRUE if error */
  307. ulint* us_size,/* out: allocated memory 
  308. (for the user) in the heap,
  309. if a NULL pointer is passed as this
  310. argument, it is ignored; in the
  311. non-debug version this is always -1 */
  312. ulint* ph_size,/* out: physical size of the heap,
  313. if a NULL pointer is passed as this
  314. argument, it is ignored */
  315. ulint* n_blocks) /* out: number of blocks in the heap,
  316. if a NULL pointer is passed as this
  317. argument, it is ignored */
  318. {
  319. mem_block_t* block;
  320. ulint total_len  = 0;
  321. ulint block_count = 0;
  322. ulint phys_len = 0;
  323. #ifdef UNIV_MEM_DEBUG
  324. ulint len;
  325. byte* field;
  326. byte* user_field;
  327. ulint check_field;
  328. #endif
  329. /* Pessimistically, we set the parameters to error values */
  330.   if (us_size != NULL) {
  331. *us_size = 0;
  332. }
  333.   if (ph_size != NULL) {
  334. *ph_size = 0;
  335. }
  336. if (n_blocks != NULL) {
  337. *n_blocks = 0;
  338. }
  339. *error = TRUE;
  340. block = heap;
  341. if (block->magic_n != MEM_BLOCK_MAGIC_N) {
  342. return;
  343. }
  344. if (print) {
  345. fputs("Memory heap:", stderr);
  346. }
  347. while (block != NULL) {
  348. phys_len += mem_block_get_len(block);
  349. if ((block->type == MEM_HEAP_BUFFER)
  350.     && (mem_block_get_len(block) > UNIV_PAGE_SIZE)) {
  351. fprintf(stderr,
  352. "InnoDB: Error: mem block %p length %lu > UNIV_PAGE_SIZEn", block,
  353. (ulong) mem_block_get_len(block));
  354.      /* error */
  355.      return;
  356. }
  357. #ifdef UNIV_MEM_DEBUG
  358. /* We can trace the fields of the block only in the debug
  359. version */
  360. if (print) {
  361. fprintf(stderr, " Block %ld:", block_count);
  362. }
  363. field = (byte*)block + mem_block_get_start(block);
  364. if (top && (field == top)) {
  365. goto completed;
  366. }
  367. while (field < (byte*)block + mem_block_get_free(block)) {
  368. /* Calculate the pointer to the storage
  369. which was given to the user */
  370. user_field = field + MEM_FIELD_HEADER_SIZE;
  371. len = mem_field_header_get_len(user_field); 
  372.    
  373. if (print) {
  374. ut_print_buf(stderr, user_field, len);
  375. }
  376. total_len += len;
  377. check_field = mem_field_header_get_check(user_field);
  378. if (check_field != 
  379.     mem_field_trailer_get_check(user_field)) {
  380. /* error */
  381. fprintf(stderr,
  382. "InnoDB: Error: block %lx mem field %lx len %lun"
  383. "InnoDB: header check field is %lx but trailer %lxn", (ulint)block,
  384.    (ulint)field, len, check_field,
  385.    mem_field_trailer_get_check(user_field));
  386.       return;
  387. }
  388. /* Move to next field */
  389. field = field + MEM_SPACE_NEEDED(len);
  390. if (top && (field == top)) {
  391. goto completed;
  392. }
  393. }
  394. /* At the end check that we have arrived to the first free
  395. position */
  396. if (field != (byte*)block + mem_block_get_free(block)) {
  397. /* error */
  398. fprintf(stderr,
  399. "InnoDB: Error: block %lx end of mem fields %lxn"
  400. "InnoDB: but block free at %lxn", (ulint)block, (ulint)field,
  401. (ulint)((byte*)block + mem_block_get_free(block)));
  402. return;
  403. }
  404. #endif
  405. block = UT_LIST_GET_NEXT(list, block);
  406. block_count++;
  407. }
  408. #ifdef UNIV_MEM_DEBUG
  409. completed:
  410. #endif
  411.   if (us_size != NULL) {
  412. *us_size = total_len;
  413. }
  414.   if (ph_size != NULL) {
  415. *ph_size = phys_len;
  416. }
  417. if (n_blocks != NULL) {
  418. *n_blocks = block_count;
  419. }
  420. *error = FALSE;
  421. }
  422. /******************************************************************
  423. Prints the contents of a memory heap. */
  424. void
  425. mem_heap_print(
  426. /*===========*/
  427. mem_heap_t* heap) /* in: memory heap */
  428. {
  429. ibool error;
  430. ulint us_size;
  431. ulint phys_size;
  432. ulint n_blocks;
  433. ut_ad(mem_heap_check(heap));
  434. mem_heap_validate_or_print(heap, NULL, TRUE, &error, 
  435. &us_size, &phys_size, &n_blocks);
  436. fprintf(stderr,
  437.   "nheap type: %lu; size: user size %lu; physical size %lu; blocks %lu.n",
  438. (ulong) heap->type, (ulong) us_size,
  439. (ulong) phys_size, (ulong) n_blocks);
  440. ut_a(!error);
  441. }
  442. /******************************************************************
  443. Checks that an object is a memory heap (or a block of it). */
  444. ibool
  445. mem_heap_check(
  446. /*===========*/
  447. /* out: TRUE if ok */
  448. mem_heap_t* heap) /* in: memory heap */
  449. {
  450. ut_a(heap->magic_n == MEM_BLOCK_MAGIC_N);
  451. return(TRUE);
  452. }
  453. /******************************************************************
  454. Validates the contents of a memory heap. */
  455. ibool
  456. mem_heap_validate(
  457. /*==============*/
  458. /* out: TRUE if ok */
  459. mem_heap_t* heap) /* in: memory heap */
  460. {
  461. ibool error;
  462. ulint us_size;
  463. ulint phys_size;
  464. ulint n_blocks;
  465. ut_ad(mem_heap_check(heap));
  466. mem_heap_validate_or_print(heap, NULL, FALSE, &error, &us_size,
  467. &phys_size, &n_blocks);
  468. if (error) {
  469. mem_heap_print(heap);
  470. }
  471. ut_a(!error);
  472. return(TRUE);
  473. }
  474. #ifdef UNIV_MEM_DEBUG
  475. /*********************************************************************
  476. TRUE if no memory is currently allocated. */
  477. ibool
  478. mem_all_freed(void)
  479. /*===============*/
  480. /* out: TRUE if no heaps exist */
  481. {
  482. mem_hash_node_t* node;
  483. ulint heap_count = 0;
  484. ulint i;
  485. mem_validate();
  486. mutex_enter(&mem_hash_mutex);
  487. for (i = 0; i < MEM_HASH_SIZE; i++) {
  488. node = UT_LIST_GET_FIRST(*mem_hash_get_nth_cell(i));
  489. while (node != NULL) {
  490. heap_count++;
  491. node = UT_LIST_GET_NEXT(list, node);
  492. }
  493. }
  494. mutex_exit(&mem_hash_mutex);
  495. if (heap_count == 0) {
  496. ut_a(mem_pool_get_reserved(mem_comm_pool) == 0);
  497. return(TRUE);
  498. } else {
  499. return(FALSE);
  500. }
  501. }
  502. /*********************************************************************
  503. Validates the dynamic memory allocation system. */
  504. ibool
  505. mem_validate_no_assert(void)
  506. /*========================*/
  507. /* out: TRUE if error */
  508. {
  509. mem_hash_node_t* node;
  510. ulint n_heaps  = 0;
  511. ulint allocated_mem;
  512. ulint ph_size;
  513. ulint total_allocated_mem  = 0;
  514. ibool error = FALSE;
  515. ulint n_blocks;
  516. ulint i;
  517. mem_pool_validate(mem_comm_pool);
  518. mutex_enter(&mem_hash_mutex);
  519. for (i = 0; i < MEM_HASH_SIZE; i++) {
  520. node = UT_LIST_GET_FIRST(*mem_hash_get_nth_cell(i));
  521. while (node != NULL) {
  522. n_heaps++;
  523. mem_heap_validate_or_print(node->heap, NULL,
  524. FALSE, &error, &allocated_mem, 
  525. &ph_size, &n_blocks);
  526. if (error) {
  527. fprintf(stderr,
  528. "nERROR!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!nn"
  529. "Inconsistency in memory heap or buffer createdn"
  530. "in %s line %lu.n",
  531. node->file_name, node->line);
  532. mutex_exit(&mem_hash_mutex);
  533. return(TRUE);
  534. }
  535. total_allocated_mem += allocated_mem;
  536. node = UT_LIST_GET_NEXT(list, node);
  537. }
  538. }
  539. if ((n_heaps == 0) && (mem_current_allocated_memory != 0)) {
  540. error = TRUE;
  541. }
  542. if (mem_total_allocated_memory < mem_current_allocated_memory) {
  543. error = TRUE;
  544. }
  545. if (mem_max_allocated_memory > mem_total_allocated_memory) {
  546. error = TRUE;
  547. }
  548. if (mem_n_created_heaps < n_heaps) {
  549. error = TRUE;
  550. }
  551. mutex_exit(&mem_hash_mutex);
  552.  
  553. return(error);
  554. }
  555. /****************************************************************
  556. Validates the dynamic memory */
  557. ibool
  558. mem_validate(void)
  559. /*==============*/
  560. /* out: TRUE if ok */
  561. {
  562. ut_a(!mem_validate_no_assert());
  563. return(TRUE);
  564. }
  565. #endif /* UNIV_MEM_DEBUG */
  566. /****************************************************************
  567. Tries to find neigboring memory allocation blocks and dumps to stderr
  568. the neighborhood of a given pointer. */
  569. void
  570. mem_analyze_corruption(
  571. /*===================*/
  572. byte* ptr) /* in: pointer to place of possible corruption */
  573. {
  574. byte* p;
  575. ulint i;
  576. ulint dist;
  577. fputs("InnoDB: Apparent memory corruption: mem dump ", stderr);
  578. ut_print_buf(stderr, ptr - 250, 500);
  579. fputs("nInnoDB: Scanning backward trying to find previous allocated mem blocksn", stderr);
  580. p = ptr;
  581. dist = 0;
  582.   
  583. for (i = 0; i < 10; i++) {
  584. for (;;) {
  585. if (((ulint)p) % 4 == 0) {
  586.     if (*((ulint*)p) == MEM_BLOCK_MAGIC_N) {
  587. fprintf(stderr,
  588. "Mem block at - %lu, file %s, line %lun",
  589. (ulong) dist, (p + sizeof(ulint)),
  590. (ulong) (*(ulint*)(p + 8 + sizeof(ulint))));
  591. break;
  592.     }
  593.     if (*((ulint*)p) == MEM_FREED_BLOCK_MAGIC_N) {
  594. fprintf(stderr,
  595. "Freed mem block at - %lu, file %s, line %lun",
  596. (ulong) dist, (p + sizeof(ulint)),
  597. (ulong) (*(ulint*)(p + 8 + sizeof(ulint))));
  598. break;
  599.     }
  600. }
  601. p--;
  602. dist++;
  603. }
  604. p--;
  605. dist++;
  606. }
  607. fprintf(stderr,
  608.   "InnoDB: Scanning forward trying to find next allocated mem blocksn");
  609. p = ptr;
  610. dist = 0;
  611.   
  612. for (i = 0; i < 10; i++) {
  613. for (;;) {
  614. if (((ulint)p) % 4 == 0) {
  615.     if (*((ulint*)p) == MEM_BLOCK_MAGIC_N) {
  616. fprintf(stderr,
  617. "Mem block at + %lu, file %s, line %lun",
  618. (ulong) dist, (p + sizeof(ulint)),
  619. (ulong) (*(ulint*)(p + 8 + sizeof(ulint))));
  620. break;
  621.     }
  622.     if (*((ulint*)p) == MEM_FREED_BLOCK_MAGIC_N) {
  623. fprintf(stderr,
  624. "Freed mem block at + %lu, file %s, line %lun",
  625. (ulong) dist, (p + sizeof(ulint)),
  626. (ulong) (*(ulint*)(p + 8 + sizeof(ulint))));
  627. break;
  628.     }
  629. }
  630. p++;
  631. dist++;
  632. }
  633. p++;
  634. dist++;
  635. }
  636. }
  637. /*********************************************************************
  638. Prints information of dynamic memory usage and currently allocated
  639. memory heaps or buffers. Can only be used in the debug version. */
  640. static
  641. void
  642. mem_print_info_low(
  643. /*===============*/
  644. ibool print_all)      /* in: if TRUE, all heaps are printed,
  645. else only the heaps allocated after the
  646. previous call of this function */
  647. {
  648. #ifdef UNIV_MEM_DEBUG
  649. mem_hash_node_t* node;
  650. ulint n_heaps  = 0;
  651. ulint allocated_mem;
  652. ulint ph_size;
  653. ulint total_allocated_mem  = 0;
  654. ibool error;
  655. ulint n_blocks;
  656. #endif
  657. FILE* outfile;
  658. /* outfile = fopen("ibdebug", "a"); */
  659. outfile = stdout;
  660. fprintf(outfile, "n");
  661. fprintf(outfile,
  662. "________________________________________________________n");
  663. fprintf(outfile, "MEMORY ALLOCATION INFORMATIONnn");
  664. #ifndef UNIV_MEM_DEBUG
  665. UT_NOT_USED(print_all);
  666. mem_pool_print_info(outfile, mem_comm_pool);
  667. fprintf(outfile,
  668. "Sorry, non-debug version cannot give more memory infon");
  669. /* fclose(outfile); */
  670. return;
  671. #else
  672. mutex_enter(&mem_hash_mutex);
  673. fprintf(outfile, "LIST OF CREATED HEAPS AND ALLOCATED BUFFERS: nn");
  674. if (!print_all) {
  675. fprintf(outfile, "AFTER THE LAST PRINT INFOn");
  676. }
  677. node = UT_LIST_GET_FIRST(mem_all_list_base);
  678. while (node != NULL) {
  679. n_heaps++;
  680. if (!print_all && node->nth_heap < mem_last_print_info) {
  681. goto next_heap;
  682. }
  683. mem_heap_validate_or_print(node->heap, NULL, 
  684. FALSE, &error, &allocated_mem, 
  685. &ph_size, &n_blocks);
  686. total_allocated_mem += allocated_mem;
  687. fprintf(outfile,
  688.  "%lu: file %s line %lu of size %lu phys.size %lu with %lu blocks, type %lun",
  689. node->nth_heap, node->file_name, node->line, 
  690. allocated_mem, ph_size, n_blocks,
  691. (node->heap)->type);
  692. next_heap:
  693. node = UT_LIST_GET_NEXT(all_list, node);
  694. }
  695. fprintf(outfile, "n");
  696. fprintf(outfile, "Current allocated memory    : %lun", 
  697. mem_current_allocated_memory);
  698. fprintf(outfile, "Current allocated heaps and buffers : %lun", 
  699. n_heaps);
  700. fprintf(outfile, "Cumulative allocated memory    : %lun", 
  701. mem_total_allocated_memory);
  702. fprintf(outfile, "Maximum allocated memory    : %lun",
  703. mem_max_allocated_memory);
  704. fprintf(outfile, "Cumulative created heaps and buffers : %lun", 
  705. mem_n_created_heaps);
  706. fprintf(outfile, "Cumulative number of allocations : %lun", 
  707. mem_n_allocations);
  708. mem_last_print_info = mem_n_created_heaps;
  709. mutex_exit(&mem_hash_mutex);
  710. mem_pool_print_info(outfile, mem_comm_pool);
  711. /* mem_validate(); */
  712. /*  fclose(outfile); */
  713. #endif
  714. }
  715. /*********************************************************************
  716. Prints information of dynamic memory usage and currently allocated memory
  717. heaps or buffers. Can only be used in the debug version. */
  718. void
  719. mem_print_info(void)
  720. /*================*/
  721. {
  722. mem_print_info_low(TRUE);
  723. }
  724. /*********************************************************************
  725. Prints information of dynamic memory usage and currently allocated memory
  726. heaps or buffers since the last ..._print_info or..._print_new_info. */
  727. void
  728. mem_print_new_info(void)
  729. /*====================*/
  730. {
  731. mem_print_info_low(FALSE);
  732. }