1 /* 2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 12 #define __VPX_MEM_C__ 13 14 #include "vpx_mem.h" 15 #include <stdio.h> 16 #include <stdlib.h> 17 #include <string.h> 18 #include "include/vpx_mem_intrnl.h" 19 20 #if CONFIG_MEM_TRACKER 21 #ifndef VPX_NO_GLOBALS 22 static unsigned long g_alloc_count = 0; 23 #else 24 #include "vpx_global_handling.h" 25 #define g_alloc_count vpxglobalm(vpxmem,g_alloc_count) 26 #endif 27 #endif 28 29 #if CONFIG_MEM_MANAGER 30 # include "heapmm.h" 31 # include "hmm_intrnl.h" 32 33 # define SHIFT_HMM_ADDR_ALIGN_UNIT 5 34 # define TOTAL_MEMORY_TO_ALLOCATE 20971520 /* 20 * 1024 * 1024 */ 35 36 # define MM_DYNAMIC_MEMORY 1 37 # if MM_DYNAMIC_MEMORY 38 static unsigned char *g_p_mng_memory_raw = NULL; 39 static unsigned char *g_p_mng_memory = NULL; 40 # else 41 static unsigned char g_p_mng_memory[TOTAL_MEMORY_TO_ALLOCATE]; 42 # endif 43 44 static size_t g_mm_memory_size = TOTAL_MEMORY_TO_ALLOCATE; 45 46 static hmm_descriptor hmm_d; 47 static int g_mng_memory_allocated = 0; 48 49 static int vpx_mm_create_heap_memory(); 50 static void *vpx_mm_realloc(void *memblk, size_t size); 51 #endif /*CONFIG_MEM_MANAGER*/ 52 53 #if USE_GLOBAL_FUNCTION_POINTERS 54 struct GLOBAL_FUNC_POINTERS { 55 g_malloc_func g_malloc; 56 g_calloc_func g_calloc; 57 g_realloc_func g_realloc; 58 g_free_func g_free; 59 g_memcpy_func g_memcpy; 60 g_memset_func g_memset; 61 g_memmove_func g_memmove; 62 } *g_func = NULL; 63 64 # define VPX_MALLOC_L g_func->g_malloc 65 # define VPX_REALLOC_L g_func->g_realloc 66 # define VPX_FREE_L g_func->g_free 67 # define VPX_MEMCPY_L g_func->g_memcpy 68 # define VPX_MEMSET_L g_func->g_memset 69 # define VPX_MEMMOVE_L g_func->g_memmove 70 #else 71 # define VPX_MALLOC_L malloc 72 # define VPX_REALLOC_L realloc 73 # define VPX_FREE_L free 74 # define VPX_MEMCPY_L memcpy 75 # define VPX_MEMSET_L memset 76 # define VPX_MEMMOVE_L memmove 77 #endif /* USE_GLOBAL_FUNCTION_POINTERS */ 78 79 unsigned int vpx_mem_get_version() { 80 unsigned int ver = ((unsigned int)(unsigned char)VPX_MEM_VERSION_CHIEF << 24 | 81 (unsigned int)(unsigned char)VPX_MEM_VERSION_MAJOR << 16 | 82 (unsigned int)(unsigned char)VPX_MEM_VERSION_MINOR << 8 | 83 (unsigned int)(unsigned char)VPX_MEM_VERSION_PATCH); 84 return ver; 85 } 86 87 int vpx_mem_set_heap_size(size_t size) { 88 int ret = -1; 89 90 #if CONFIG_MEM_MANAGER 91 #if MM_DYNAMIC_MEMORY 92 93 if (!g_mng_memory_allocated && size) { 94 g_mm_memory_size = size; 95 ret = 0; 96 } else 97 ret = -3; 98 99 #else 100 ret = -2; 101 #endif 102 #else 103 (void)size; 104 #endif 105 106 return ret; 107 } 108 109 void *vpx_memalign(size_t align, size_t size) { 110 void *addr, 111 * x = NULL; 112 113 #if CONFIG_MEM_MANAGER 114 int number_aau; 115 116 if (vpx_mm_create_heap_memory() < 0) { 117 _P(printf("[vpx][mm] ERROR vpx_memalign() Couldn't create memory for Heap.\n");) 118 } 119 120 number_aau = ((size + align - 1 + ADDRESS_STORAGE_SIZE) >> 121 SHIFT_HMM_ADDR_ALIGN_UNIT) + 1; 122 123 addr = hmm_alloc(&hmm_d, number_aau); 124 #else 125 addr = VPX_MALLOC_L(size + align - 1 + ADDRESS_STORAGE_SIZE); 126 #endif /*CONFIG_MEM_MANAGER*/ 127 128 if (addr) { 129 x = align_addr((unsigned char *)addr + ADDRESS_STORAGE_SIZE, (int)align); 130 /* save the actual malloc address */ 131 ((size_t *)x)[-1] = (size_t)addr; 132 } 133 134 return x; 135 } 136 137 void *vpx_malloc(size_t size) { 138 return vpx_memalign(DEFAULT_ALIGNMENT, size); 139 } 140 141 void *vpx_calloc(size_t num, size_t size) { 142 void *x; 143 144 x = vpx_memalign(DEFAULT_ALIGNMENT, num * size); 145 146 if (x) 147 VPX_MEMSET_L(x, 0, num * size); 148 149 return x; 150 } 151 152 void *vpx_realloc(void *memblk, size_t size) { 153 void *addr, 154 * new_addr = NULL; 155 int align = DEFAULT_ALIGNMENT; 156 157 /* 158 The realloc() function changes the size of the object pointed to by 159 ptr to the size specified by size, and returns a pointer to the 160 possibly moved block. The contents are unchanged up to the lesser 161 of the new and old sizes. If ptr is null, realloc() behaves like 162 malloc() for the specified size. If size is zero (0) and ptr is 163 not a null pointer, the object pointed to is freed. 164 */ 165 if (!memblk) 166 new_addr = vpx_malloc(size); 167 else if (!size) 168 vpx_free(memblk); 169 else { 170 addr = (void *)(((size_t *)memblk)[-1]); 171 memblk = NULL; 172 173 #if CONFIG_MEM_MANAGER 174 new_addr = vpx_mm_realloc(addr, size + align + ADDRESS_STORAGE_SIZE); 175 #else 176 new_addr = VPX_REALLOC_L(addr, size + align + ADDRESS_STORAGE_SIZE); 177 #endif 178 179 if (new_addr) { 180 addr = new_addr; 181 new_addr = (void *)(((size_t) 182 ((unsigned char *)new_addr + ADDRESS_STORAGE_SIZE) + (align - 1)) & 183 (size_t) - align); 184 /* save the actual malloc address */ 185 ((size_t *)new_addr)[-1] = (size_t)addr; 186 } 187 } 188 189 return new_addr; 190 } 191 192 void vpx_free(void *memblk) { 193 if (memblk) { 194 void *addr = (void *)(((size_t *)memblk)[-1]); 195 #if CONFIG_MEM_MANAGER 196 hmm_free(&hmm_d, addr); 197 #else 198 VPX_FREE_L(addr); 199 #endif 200 } 201 } 202 203 #if CONFIG_MEM_TRACKER 204 void *xvpx_memalign(size_t align, size_t size, char *file, int line) { 205 #if TRY_BOUNDS_CHECK 206 unsigned char *x_bounds; 207 #endif 208 209 void *x; 210 211 if (g_alloc_count == 0) { 212 #if TRY_BOUNDS_CHECK 213 int i_rv = vpx_memory_tracker_init(BOUNDS_CHECK_PAD_SIZE, BOUNDS_CHECK_VALUE); 214 #else 215 int i_rv = vpx_memory_tracker_init(0, 0); 216 #endif 217 218 if (i_rv < 0) { 219 _P(printf("ERROR xvpx_malloc MEM_TRACK_USAGE error vpx_memory_tracker_init().\n");) 220 } 221 } 222 223 #if TRY_BOUNDS_CHECK 224 { 225 int i; 226 unsigned int tempme = BOUNDS_CHECK_VALUE; 227 228 x_bounds = vpx_memalign(align, size + (BOUNDS_CHECK_PAD_SIZE * 2)); 229 230 if (x_bounds) { 231 /*we're aligning the address twice here but to keep things 232 consistent we want to have the padding come before the stored 233 address so no matter what free function gets called we will 234 attempt to free the correct address*/ 235 x_bounds = (unsigned char *)(((size_t *)x_bounds)[-1]); 236 x = align_addr(x_bounds + BOUNDS_CHECK_PAD_SIZE + ADDRESS_STORAGE_SIZE, 237 (int)align); 238 /* save the actual malloc address */ 239 ((size_t *)x)[-1] = (size_t)x_bounds; 240 241 for (i = 0; i < BOUNDS_CHECK_PAD_SIZE; i += sizeof(unsigned int)) { 242 VPX_MEMCPY_L(x_bounds + i, &tempme, sizeof(unsigned int)); 243 VPX_MEMCPY_L((unsigned char *)x + size + i, 244 &tempme, sizeof(unsigned int)); 245 } 246 } else 247 x = NULL; 248 } 249 #else 250 x = vpx_memalign(align, size); 251 #endif /*TRY_BOUNDS_CHECK*/ 252 253 g_alloc_count++; 254 255 vpx_memory_tracker_add((size_t)x, (unsigned int)size, file, line, 1); 256 257 return x; 258 } 259 260 void *xvpx_malloc(size_t size, char *file, int line) { 261 return xvpx_memalign(DEFAULT_ALIGNMENT, size, file, line); 262 } 263 264 void *xvpx_calloc(size_t num, size_t size, char *file, int line) { 265 void *x = xvpx_memalign(DEFAULT_ALIGNMENT, num * size, file, line); 266 267 if (x) 268 VPX_MEMSET_L(x, 0, num * size); 269 270 return x; 271 } 272 273 void *xvpx_realloc(void *memblk, size_t size, char *file, int line) { 274 struct mem_block *p = NULL; 275 int orig_size = 0, 276 orig_line = 0; 277 char *orig_file = NULL; 278 279 #if TRY_BOUNDS_CHECK 280 unsigned char *x_bounds = memblk ? 281 (unsigned char *)(((size_t *)memblk)[-1]) : 282 NULL; 283 #endif 284 285 void *x; 286 287 if (g_alloc_count == 0) { 288 #if TRY_BOUNDS_CHECK 289 290 if (!vpx_memory_tracker_init(BOUNDS_CHECK_PAD_SIZE, BOUNDS_CHECK_VALUE)) 291 #else 292 if (!vpx_memory_tracker_init(0, 0)) 293 #endif 294 { 295 _P(printf("ERROR xvpx_malloc MEM_TRACK_USAGE error vpx_memory_tracker_init().\n");) 296 } 297 } 298 299 if ((p = vpx_memory_tracker_find((size_t)memblk))) { 300 orig_size = p->size; 301 orig_file = p->file; 302 orig_line = p->line; 303 } 304 305 #if TRY_BOUNDS_CHECK_ON_FREE 306 vpx_memory_tracker_check_integrity(file, line); 307 #endif 308 309 /* have to do this regardless of success, because 310 * the memory that does get realloc'd may change 311 * the bounds values of this block 312 */ 313 vpx_memory_tracker_remove((size_t)memblk); 314 315 #if TRY_BOUNDS_CHECK 316 { 317 int i; 318 unsigned int tempme = BOUNDS_CHECK_VALUE; 319 320 x_bounds = vpx_realloc(memblk, size + (BOUNDS_CHECK_PAD_SIZE * 2)); 321 322 if (x_bounds) { 323 x_bounds = (unsigned char *)(((size_t *)x_bounds)[-1]); 324 x = align_addr(x_bounds + BOUNDS_CHECK_PAD_SIZE + ADDRESS_STORAGE_SIZE, 325 (int)DEFAULT_ALIGNMENT); 326 /* save the actual malloc address */ 327 ((size_t *)x)[-1] = (size_t)x_bounds; 328 329 for (i = 0; i < BOUNDS_CHECK_PAD_SIZE; i += sizeof(unsigned int)) { 330 VPX_MEMCPY_L(x_bounds + i, &tempme, sizeof(unsigned int)); 331 VPX_MEMCPY_L((unsigned char *)x + size + i, 332 &tempme, sizeof(unsigned int)); 333 } 334 } else 335 x = NULL; 336 } 337 #else 338 x = vpx_realloc(memblk, size); 339 #endif /*TRY_BOUNDS_CHECK*/ 340 341 if (!memblk) ++g_alloc_count; 342 343 if (x) 344 vpx_memory_tracker_add((size_t)x, (unsigned int)size, file, line, 1); 345 else 346 vpx_memory_tracker_add((size_t)memblk, orig_size, orig_file, orig_line, 1); 347 348 return x; 349 } 350 351 void xvpx_free(void *p_address, char *file, int line) { 352 #if TRY_BOUNDS_CHECK 353 unsigned char *p_bounds_address = (unsigned char *)p_address; 354 /*p_bounds_address -= BOUNDS_CHECK_PAD_SIZE;*/ 355 #endif 356 357 #if !TRY_BOUNDS_CHECK_ON_FREE 358 (void)file; 359 (void)line; 360 #endif 361 362 if (p_address) { 363 #if TRY_BOUNDS_CHECK_ON_FREE 364 vpx_memory_tracker_check_integrity(file, line); 365 #endif 366 367 /* if the addr isn't found in the list, assume it was allocated via 368 * vpx_ calls not xvpx_, therefore it does not contain any padding 369 */ 370 if (vpx_memory_tracker_remove((size_t)p_address) == -2) { 371 p_bounds_address = p_address; 372 _P(fprintf(stderr, "[vpx_mem][xvpx_free] addr: %p not found in" 373 " list; freed from file:%s" 374 " line:%d\n", p_address, file, line)); 375 } else 376 --g_alloc_count; 377 378 #if TRY_BOUNDS_CHECK 379 vpx_free(p_bounds_address); 380 #else 381 vpx_free(p_address); 382 #endif 383 384 if (!g_alloc_count) 385 vpx_memory_tracker_destroy(); 386 } 387 } 388 389 #endif /*CONFIG_MEM_TRACKER*/ 390 391 #if CONFIG_MEM_CHECKS 392 #if defined(VXWORKS) 393 #include <task_lib.h> /*for task_delay()*/ 394 /* This function is only used to get a stack trace of the player 395 object so we can se where we are having a problem. */ 396 static int get_my_tt(int task) { 397 tt(task); 398 399 return 0; 400 } 401 402 static void vx_sleep(int msec) { 403 int ticks_to_sleep = 0; 404 405 if (msec) { 406 int msec_per_tick = 1000 / sys_clk_rate_get(); 407 408 if (msec < msec_per_tick) 409 ticks_to_sleep++; 410 else 411 ticks_to_sleep = msec / msec_per_tick; 412 } 413 414 task_delay(ticks_to_sleep); 415 } 416 #endif 417 #endif 418 419 void *vpx_memcpy(void *dest, const void *source, size_t length) { 420 #if CONFIG_MEM_CHECKS 421 422 if (((int)dest < 0x4000) || ((int)source < 0x4000)) { 423 _P(printf("WARNING: vpx_memcpy dest:0x%x source:0x%x len:%d\n", (int)dest, (int)source, length);) 424 425 #if defined(VXWORKS) 426 sp(get_my_tt, task_id_self(), 0, 0, 0, 0, 0, 0, 0, 0); 427 428 vx_sleep(10000); 429 #endif 430 } 431 432 #endif 433 434 return VPX_MEMCPY_L(dest, source, length); 435 } 436 437 void *vpx_memset(void *dest, int val, size_t length) { 438 #if CONFIG_MEM_CHECKS 439 440 if ((int)dest < 0x4000) { 441 _P(printf("WARNING: vpx_memset dest:0x%x val:%d len:%d\n", (int)dest, val, length);) 442 443 #if defined(VXWORKS) 444 sp(get_my_tt, task_id_self(), 0, 0, 0, 0, 0, 0, 0, 0); 445 446 vx_sleep(10000); 447 #endif 448 } 449 450 #endif 451 452 return VPX_MEMSET_L(dest, val, length); 453 } 454 455 void *vpx_memmove(void *dest, const void *src, size_t count) { 456 #if CONFIG_MEM_CHECKS 457 458 if (((int)dest < 0x4000) || ((int)src < 0x4000)) { 459 _P(printf("WARNING: vpx_memmove dest:0x%x src:0x%x count:%d\n", (int)dest, (int)src, count);) 460 461 #if defined(VXWORKS) 462 sp(get_my_tt, task_id_self(), 0, 0, 0, 0, 0, 0, 0, 0); 463 464 vx_sleep(10000); 465 #endif 466 } 467 468 #endif 469 470 return VPX_MEMMOVE_L(dest, src, count); 471 } 472 473 #if CONFIG_MEM_MANAGER 474 475 static int vpx_mm_create_heap_memory() { 476 int i_rv = 0; 477 478 if (!g_mng_memory_allocated) { 479 #if MM_DYNAMIC_MEMORY 480 g_p_mng_memory_raw = 481 (unsigned char *)malloc(g_mm_memory_size + HMM_ADDR_ALIGN_UNIT); 482 483 if (g_p_mng_memory_raw) { 484 g_p_mng_memory = (unsigned char *)((((unsigned int)g_p_mng_memory_raw) + 485 HMM_ADDR_ALIGN_UNIT - 1) & 486 -(int)HMM_ADDR_ALIGN_UNIT); 487 488 _P(printf("[vpx][mm] total memory size:%d g_p_mng_memory_raw:0x%x g_p_mng_memory:0x%x\n" 489 , g_mm_memory_size + HMM_ADDR_ALIGN_UNIT 490 , (unsigned int)g_p_mng_memory_raw 491 , (unsigned int)g_p_mng_memory);) 492 } else { 493 _P(printf("[vpx][mm] Couldn't allocate memory:%d for vpx memory manager.\n" 494 , g_mm_memory_size);) 495 496 i_rv = -1; 497 } 498 499 if (g_p_mng_memory) 500 #endif 501 { 502 int chunk_size = 0; 503 504 g_mng_memory_allocated = 1; 505 506 hmm_init(&hmm_d); 507 508 chunk_size = g_mm_memory_size >> SHIFT_HMM_ADDR_ALIGN_UNIT; 509 510 chunk_size -= DUMMY_END_BLOCK_BAUS; 511 512 _P(printf("[vpx][mm] memory size:%d for vpx memory manager. g_p_mng_memory:0x%x chunk_size:%d\n" 513 , g_mm_memory_size 514 , (unsigned int)g_p_mng_memory 515 , chunk_size);) 516 517 hmm_new_chunk(&hmm_d, (void *)g_p_mng_memory, chunk_size); 518 } 519 520 #if MM_DYNAMIC_MEMORY 521 else { 522 _P(printf("[vpx][mm] Couldn't allocate memory:%d for vpx memory manager.\n" 523 , g_mm_memory_size);) 524 525 i_rv = -1; 526 } 527 528 #endif 529 } 530 531 return i_rv; 532 } 533 534 static void *vpx_mm_realloc(void *memblk, size_t size) { 535 void *p_ret = NULL; 536 537 if (vpx_mm_create_heap_memory() < 0) { 538 _P(printf("[vpx][mm] ERROR vpx_mm_realloc() Couldn't create memory for Heap.\n");) 539 } else { 540 int i_rv = 0; 541 int old_num_aaus; 542 int new_num_aaus; 543 544 old_num_aaus = hmm_true_size(memblk); 545 new_num_aaus = (size >> SHIFT_HMM_ADDR_ALIGN_UNIT) + 1; 546 547 if (old_num_aaus == new_num_aaus) { 548 p_ret = memblk; 549 } else { 550 i_rv = hmm_resize(&hmm_d, memblk, new_num_aaus); 551 552 if (i_rv == 0) { 553 p_ret = memblk; 554 } else { 555 /* Error. Try to malloc and then copy data. */ 556 void *p_from_malloc; 557 558 new_num_aaus = (size >> SHIFT_HMM_ADDR_ALIGN_UNIT) + 1; 559 p_from_malloc = hmm_alloc(&hmm_d, new_num_aaus); 560 561 if (p_from_malloc) { 562 vpx_memcpy(p_from_malloc, memblk, size); 563 hmm_free(&hmm_d, memblk); 564 565 p_ret = p_from_malloc; 566 } 567 } 568 } 569 } 570 571 return p_ret; 572 } 573 #endif /*CONFIG_MEM_MANAGER*/ 574 575 #if USE_GLOBAL_FUNCTION_POINTERS 576 # if CONFIG_MEM_TRACKER 577 extern int vpx_memory_tracker_set_functions(g_malloc_func g_malloc_l 578 , g_calloc_func g_calloc_l 579 , g_realloc_func g_realloc_l 580 , g_free_func g_free_l 581 , g_memcpy_func g_memcpy_l 582 , g_memset_func g_memset_l 583 , g_memmove_func g_memmove_l); 584 # endif 585 #endif /*USE_GLOBAL_FUNCTION_POINTERS*/ 586 int vpx_mem_set_functions(g_malloc_func g_malloc_l 587 , g_calloc_func g_calloc_l 588 , g_realloc_func g_realloc_l 589 , g_free_func g_free_l 590 , g_memcpy_func g_memcpy_l 591 , g_memset_func g_memset_l 592 , g_memmove_func g_memmove_l) { 593 #if USE_GLOBAL_FUNCTION_POINTERS 594 595 /* If use global functions is turned on then the 596 application must set the global functions before 597 it does anything else or vpx_mem will have 598 unpredictable results. */ 599 if (!g_func) { 600 g_func = (struct GLOBAL_FUNC_POINTERS *) 601 g_malloc_l(sizeof(struct GLOBAL_FUNC_POINTERS)); 602 603 if (!g_func) { 604 return -1; 605 } 606 } 607 608 #if CONFIG_MEM_TRACKER 609 { 610 int rv = 0; 611 rv = vpx_memory_tracker_set_functions(g_malloc_l 612 , g_calloc_l 613 , g_realloc_l 614 , g_free_l 615 , g_memcpy_l 616 , g_memset_l 617 , g_memmove_l); 618 619 if (rv < 0) { 620 return rv; 621 } 622 } 623 #endif 624 625 g_func->g_malloc = g_malloc_l; 626 g_func->g_calloc = g_calloc_l; 627 g_func->g_realloc = g_realloc_l; 628 g_func->g_free = g_free_l; 629 g_func->g_memcpy = g_memcpy_l; 630 g_func->g_memset = g_memset_l; 631 g_func->g_memmove = g_memmove_l; 632 633 return 0; 634 #else 635 (void)g_malloc_l; 636 (void)g_calloc_l; 637 (void)g_realloc_l; 638 (void)g_free_l; 639 (void)g_memcpy_l; 640 (void)g_memset_l; 641 (void)g_memmove_l; 642 return -1; 643 #endif 644 } 645 646 int vpx_mem_unset_functions() { 647 #if USE_GLOBAL_FUNCTION_POINTERS 648 649 if (g_func) { 650 g_free_func temp_free = g_func->g_free; 651 temp_free(g_func); 652 g_func = NULL; 653 } 654 655 #endif 656 return 0; 657 } 658
