Annotation of embedaddon/mpd/src/contrib/libpdel/util/typed_mem.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * Copyright (c) 2001-2002 Packet Design, LLC.
! 4: * All rights reserved.
! 5: *
! 6: * Subject to the following obligations and disclaimer of warranty,
! 7: * use and redistribution of this software, in source or object code
! 8: * forms, with or without modifications are expressly permitted by
! 9: * Packet Design; provided, however, that:
! 10: *
! 11: * (i) Any and all reproductions of the source or object code
! 12: * must include the copyright notice above and the following
! 13: * disclaimer of warranties; and
! 14: * (ii) No rights are granted, in any manner or form, to use
! 15: * Packet Design trademarks, including the mark "PACKET DESIGN"
! 16: * on advertising, endorsements, or otherwise except as such
! 17: * appears in the above copyright notice or in the software.
! 18: *
! 19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
! 20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
! 21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
! 22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
! 23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
! 24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
! 25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
! 26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
! 27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
! 28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
! 29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
! 30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
! 31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
! 32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
! 33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
! 35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
! 36: * THE POSSIBILITY OF SUCH DAMAGE.
! 37: *
! 38: * Author: Archie Cobbs <archie@freebsd.org>
! 39: */
! 40:
! 41: #include <sys/types.h>
! 42: #include <sys/param.h>
! 43:
! 44: #ifndef _KERNEL
! 45: #include <stdio.h>
! 46: #include <stddef.h>
! 47: #include <stdlib.h>
! 48: #include <stdarg.h>
! 49: #include <syslog.h>
! 50: #include <string.h>
! 51: #include <assert.h>
! 52: #include <errno.h>
! 53: #include <pthread.h>
! 54: #else
! 55: #include <sys/systm.h>
! 56: #include <machine/stdarg.h>
! 57: #include <malloc.h>
! 58: #include "util/kernelglue.h"
! 59: #endif
! 60:
! 61: #include "structs/structs.h"
! 62: #include "structs/type/array.h"
! 63: #include "structs/type/struct.h"
! 64: #include "structs/type/string.h"
! 65: #include "structs/type/int.h"
! 66: #include "util/gtree.h"
! 67: #include "util/typed_mem.h"
! 68:
! 69: /* Alignment, with a minimum of 4 bytes */
! 70: #if defined(__FreeBSD__)
! 71: #include <machine/param.h>
! 72: #define ALIGNMENT (_ALIGNBYTES + 1)
! 73: #else
! 74: #define ALIGNMENT 8 /* conservative guess */
! 75: #endif
! 76:
! 77: /* Summary information about a single type of memory */
! 78: struct mem_type {
! 79: char name[TYPED_MEM_TYPELEN];/* string for this type */
! 80: u_int32_t count; /* number of allocated blocks */
! 81: size_t total; /* total allocated bytes */
! 82: };
! 83:
! 84: /* Information about a single allocated block of memory */
! 85: struct mem_info {
! 86: void *mem; /* actual memory block */
! 87: size_t size; /* size of memory block */
! 88: struct mem_type *type; /* pointer to type info */
! 89: };
! 90:
! 91: /*
! 92: * Structs type for 'struct typed_mem_stats'
! 93: */
! 94: #define TYPED_MEM_STATS_MTYPE "typed_mem_stats"
! 95:
! 96: static const struct structs_type typebuf_type
! 97: = STRUCTS_FIXEDSTRING_TYPE(TYPED_MEM_TYPELEN);
! 98: static const struct structs_field typed_mem_typestats_fields[] = {
! 99: STRUCTS_STRUCT_FIELD(typed_mem_typestats, type, &typebuf_type),
! 100: STRUCTS_STRUCT_FIELD(typed_mem_typestats, allocs, &structs_type_uint),
! 101: STRUCTS_STRUCT_FIELD(typed_mem_typestats, bytes, &structs_type_uint),
! 102: STRUCTS_STRUCT_FIELD_END
! 103: };
! 104: static const struct structs_type typed_mem_typestats_type
! 105: = STRUCTS_STRUCT_TYPE(typed_mem_typestats, typed_mem_typestats_fields);
! 106: const struct structs_type typed_mem_stats_type
! 107: = STRUCTS_ARRAY_TYPE(&typed_mem_typestats_type,
! 108: TYPED_MEM_STATS_MTYPE, "type");
! 109:
! 110: /* We need to use the real functions in here */
! 111: #undef malloc
! 112: #undef calloc
! 113: #undef realloc
! 114: #undef reallocf
! 115: #undef free
! 116: #undef asprintf
! 117: #undef vasprintf
! 118:
! 119: /* How to print out problems */
! 120: #define WHINE(fmt, args...) (void)fprintf(stderr, fmt "\n" , ## args)
! 121:
! 122: /*
! 123: * Kernel glue
! 124: */
! 125: #ifdef _KERNEL
! 126:
! 127: #if TYPED_MEM_TRACE
! 128: #error TYPED_MEM_TRACE not supported in kernel mode
! 129: #endif
! 130:
! 131: #define malloc(x) kern_malloc(x)
! 132: #define realloc(x, y) kern_realloc(x, y)
! 133: #define free(x) kern_free(x)
! 134:
! 135: #define pthread_mutex_lock() 0
! 136: #define pthread_mutex_unlock() 0
! 137:
! 138: #undef WHINE
! 139: #define WHINE(fmt, args...) log(LOG_CRIT, fmt "\n" , ## args)
! 140:
! 141: #endif /* _KERNEL */
! 142:
! 143: /*
! 144: * Internal variables
! 145: */
! 146: static u_char typed_mem_started;
! 147: static u_char typed_mem_enabled;
! 148: static struct gtree *mem_tree;
! 149: static struct gtree *type_tree;
! 150: static u_int tree_node_size;
! 151:
! 152: #ifndef _KERNEL
! 153: static pthread_mutex_t typed_mem_mutex;
! 154: #endif
! 155:
! 156: /* Guard bytes. Should have an "aligned" length. */
! 157: static const u_char typed_mem_guard_data[] = { 0x34, 0x8e, 0x71, 0x9f };
! 158: static u_char typed_mem_guard[ALIGNMENT];
! 159:
! 160: /*
! 161: * Internal functions
! 162: */
! 163: static gtree_cmp_t type_cmp;
! 164: static gtree_print_t type_print;
! 165: static gtree_cmp_t mem_cmp;
! 166:
! 167: static struct mem_info *typed_mem_find(
! 168: #if TYPED_MEM_TRACE
! 169: const char *file, u_int line,
! 170: #endif
! 171: void *mem, const char *typename, const char *func);
! 172:
! 173: #ifndef _KERNEL
! 174: static gtree_print_t mem_print;
! 175: #else
! 176: #define mem_print NULL
! 177: #endif
! 178:
! 179: /*
! 180: * Enable typed memory.
! 181: */
! 182: int
! 183: typed_mem_enable(void)
! 184: {
! 185: pthread_mutexattr_t mattr;
! 186: int i;
! 187:
! 188: /* Already enabled? */
! 189: if (typed_mem_enabled)
! 190: return (0);
! 191:
! 192: /* Already started allocating memory? */
! 193: if (typed_mem_started) {
! 194: errno = EALREADY;
! 195: return (-1);
! 196: }
! 197:
! 198: /* Initialize recursive mutex */
! 199: if ((errno = pthread_mutexattr_init(&mattr)) != 0)
! 200: return (-1);
! 201: if ((errno = pthread_mutexattr_settype(&mattr,
! 202: PTHREAD_MUTEX_RECURSIVE)) != 0) {
! 203: pthread_mutexattr_destroy(&mattr);
! 204: return (-1);
! 205: }
! 206: if ((errno = pthread_mutex_init(&typed_mem_mutex, &mattr)) != 0) {
! 207: pthread_mutexattr_destroy(&mattr);
! 208: return (-1);
! 209: }
! 210: pthread_mutexattr_destroy(&mattr);
! 211:
! 212: /* Fill in guard bytes */
! 213: for (i = 0; i < ALIGNMENT; i++) {
! 214: typed_mem_guard[i] = typed_mem_guard_data[
! 215: i % sizeof(typed_mem_guard_data)];
! 216: }
! 217:
! 218: /* Done */
! 219: typed_mem_enabled = 1;
! 220: return (0);
! 221: }
! 222:
! 223: /*
! 224: * realloc(3) replacement
! 225: */
! 226: void *
! 227: typed_mem_realloc(
! 228: #if TYPED_MEM_TRACE
! 229: const char *file, u_int line,
! 230: #endif
! 231: const char *typename, void *mem, size_t size)
! 232: {
! 233: #if TYPED_MEM_TRACE
! 234: void *const omem = mem;
! 235: #endif
! 236: struct mem_info *info;
! 237: void *rtn = NULL;
! 238: int errno_save;
! 239: int removed;
! 240: int r;
! 241:
! 242: /* Check if typed memory is active */
! 243: typed_mem_started = 1;
! 244: if (!typed_mem_enabled || typename == NULL)
! 245: return (realloc(mem, size));
! 246:
! 247: /* Lock info */
! 248: r = pthread_mutex_lock(&typed_mem_mutex);
! 249: assert(r == 0);
! 250:
! 251: /* Initialize first */
! 252: if (mem_tree == NULL) {
! 253: if ((mem_tree = gtree_create(NULL, NULL,
! 254: mem_cmp, NULL, NULL, mem_print)) == NULL)
! 255: goto done;
! 256: if ((type_tree = gtree_create(NULL, NULL,
! 257: type_cmp, NULL, NULL, type_print)) == NULL) {
! 258: gtree_destroy(&mem_tree);
! 259: goto done;
! 260: }
! 261: tree_node_size = gtree_node_size();
! 262: }
! 263:
! 264: /* Find/create the memory descriptor block */
! 265: if (mem == NULL) {
! 266: struct mem_type *type;
! 267: struct mem_type tkey;
! 268:
! 269: /* Get memory and new descriptor block */
! 270: if ((info = malloc(sizeof(*info))) == NULL)
! 271: goto done;
! 272: if ((info->mem = malloc(size
! 273: + 2 * sizeof(typed_mem_guard))) == NULL) {
! 274: errno_save = errno;
! 275: free(info);
! 276: errno = errno_save;
! 277: goto done;
! 278: }
! 279: info->size = size;
! 280:
! 281: /* Find/create type descriptor for this memory type */
! 282: strncpy(tkey.name, typename, sizeof(tkey.name) - 1);
! 283: tkey.name[sizeof(tkey.name) - 1] = '\0';
! 284: if ((type = gtree_get(type_tree, &tkey)) == NULL) {
! 285: if ((type = malloc(sizeof(*type))) == NULL) {
! 286: errno_save = errno;
! 287: free(info->mem);
! 288: free(info);
! 289: errno = errno_save;
! 290: goto done;
! 291: }
! 292: strcpy(type->name, tkey.name);
! 293: type->count = 0;
! 294: type->total = 0;
! 295: if (gtree_put(type_tree, type) == -1) {
! 296: errno_save = errno;
! 297: free(type);
! 298: free(info->mem);
! 299: free(info);
! 300: errno = errno_save;
! 301: goto done;
! 302: }
! 303: }
! 304: info->type = type;
! 305:
! 306: /* Add block descriptor to mem tree */
! 307: if (gtree_put(mem_tree, info) == -1) {
! 308: errno_save = errno;
! 309: if (type->count == 0) { /* was a new type */
! 310: removed = gtree_remove(type_tree, type);
! 311: assert(removed);
! 312: free(type);
! 313: }
! 314: free(info->mem);
! 315: free(info);
! 316: errno = errno_save;
! 317: goto done;
! 318: }
! 319: } else {
! 320: void *node;
! 321:
! 322: /* Find memory descriptor */
! 323: #if TYPED_MEM_TRACE
! 324: info = typed_mem_find(file, line, mem, typename, "REALLOC");
! 325: #else
! 326: info = typed_mem_find(mem, typename, "REALLOC");
! 327: #endif
! 328:
! 329: /* Pre-allocate mem tree node */
! 330: if ((node = malloc(tree_node_size)) == NULL)
! 331: goto done;
! 332:
! 333: /* Get reallocated memory block */
! 334: if ((mem = realloc(info->mem,
! 335: size + 2 * sizeof(typed_mem_guard))) == NULL) {
! 336: errno_save = errno;
! 337: free(node);
! 338: errno = errno_save;
! 339: goto done;
! 340: }
! 341:
! 342: /* Subtract old block from type stats */
! 343: info->type->total -= info->size;
! 344: info->type->count--;
! 345:
! 346: /* Update block descriptor */
! 347: info->size = size;
! 348: if (info->mem != mem) {
! 349: removed = gtree_remove(mem_tree, info);
! 350: assert(removed);
! 351: info->mem = mem;
! 352: gtree_put_prealloc(mem_tree, info, node);
! 353: } else
! 354: free(node); /* we didn't need it */
! 355: }
! 356:
! 357: /* Add new block to type stats */
! 358: info->type->total += info->size;
! 359: info->type->count++;
! 360:
! 361: /* Install guard bytes */
! 362: memcpy(info->mem, typed_mem_guard, sizeof(typed_mem_guard));
! 363: memcpy((u_char *)info->mem + sizeof(typed_mem_guard) + info->size,
! 364: typed_mem_guard, sizeof(typed_mem_guard));
! 365:
! 366: #if TYPED_MEM_TRACE
! 367: /* Tracing */
! 368: {
! 369: const char *basename;
! 370:
! 371: if ((basename = strrchr(file, '/')) != NULL)
! 372: basename++;
! 373: else
! 374: basename = file;
! 375: fprintf(stderr, "%s:%u:ALLOC %p -> %p \"%s\" %u [%u]\n",
! 376: basename, line, omem, (u_char *)info->mem
! 377: + sizeof(typed_mem_guard), typename, size,
! 378: info->type->count);
! 379: }
! 380: #endif
! 381:
! 382: /* Return memory block */
! 383: rtn = (u_char *)info->mem + sizeof(typed_mem_guard);
! 384:
! 385: done:
! 386: /* Done */
! 387: r = pthread_mutex_unlock(&typed_mem_mutex);
! 388: assert(r == 0);
! 389: return (rtn);
! 390: }
! 391:
! 392: /*
! 393: * reallocf(3) replacement
! 394: */
! 395: void *
! 396: typed_mem_reallocf(
! 397: #if TYPED_MEM_TRACE
! 398: const char *file, u_int line,
! 399: #endif
! 400: const char *typename, void *mem, size_t size)
! 401: {
! 402: void *p;
! 403:
! 404: #if TYPED_MEM_TRACE
! 405: if ((p = typed_mem_realloc(file, line, typename, mem, size)) == NULL)
! 406: typed_mem_free(file, line, typename, mem);
! 407: #else
! 408: if ((p = typed_mem_realloc(typename, mem, size)) == NULL)
! 409: typed_mem_free(typename, mem);
! 410: #endif
! 411: return (p);
! 412: }
! 413:
! 414: /*
! 415: * free(3) replacement
! 416: *
! 417: * Note: it is OK if "typedname" points to memory within the region
! 418: * pointed to by "mem".
! 419: */
! 420: void
! 421: typed_mem_free(
! 422: #if TYPED_MEM_TRACE
! 423: const char *file, u_int line,
! 424: #endif
! 425: const char *typename, void *mem)
! 426: {
! 427: const int errno_save = errno;
! 428: struct mem_info *info;
! 429: int removed;
! 430: int r;
! 431:
! 432: /* free(NULL) does nothing */
! 433: if (mem == NULL)
! 434: return;
! 435:
! 436: /* Check if typed memory is active */
! 437: typed_mem_started = 1;
! 438: if (!typed_mem_enabled || typename == NULL) {
! 439: free(mem);
! 440: return;
! 441: }
! 442:
! 443: /* Lock info */
! 444: r = pthread_mutex_lock(&typed_mem_mutex);
! 445: assert(r == 0);
! 446:
! 447: /* Find memory descriptor */
! 448: #if TYPED_MEM_TRACE
! 449: info = typed_mem_find(file, line, mem, typename, "FREE");
! 450: #else
! 451: info = typed_mem_find(mem, typename, "FREE");
! 452: #endif
! 453:
! 454: #if TYPED_MEM_TRACE
! 455: /* Tracing */
! 456: {
! 457: const char *basename;
! 458:
! 459: if ((basename = strrchr(file, '/')) != NULL)
! 460: basename++;
! 461: else
! 462: basename = file;
! 463: fprintf(stderr, "%s:%u:FREE %p -> %p \"%s\" [%u]\n",
! 464: basename, line, mem, (void *)0,
! 465: typename, info->type->count);
! 466: }
! 467: #endif
! 468:
! 469: /* Subtract block from descriptor info */
! 470: info->type->total -= info->size;
! 471: if (--info->type->count == 0) {
! 472: assert(info->type->total == 0);
! 473: removed = gtree_remove(type_tree, info->type);
! 474: assert(removed);
! 475: free(info->type);
! 476: }
! 477:
! 478: /* Free memory and descriptor block */
! 479: removed = gtree_remove(mem_tree, info);
! 480: assert(removed);
! 481: free(info->mem);
! 482: free(info);
! 483:
! 484: /* Done */
! 485: r = pthread_mutex_unlock(&typed_mem_mutex);
! 486: assert(r == 0);
! 487: errno = errno_save;
! 488: }
! 489:
! 490: /*
! 491: * calloc(3) replacement
! 492: */
! 493: void *
! 494: typed_mem_calloc(
! 495: #if TYPED_MEM_TRACE
! 496: const char *file, u_int line,
! 497: #endif
! 498: const char *type, size_t num, size_t size)
! 499: {
! 500: void *mem;
! 501:
! 502: size *= num;
! 503: #if TYPED_MEM_TRACE
! 504: if ((mem = typed_mem_realloc(file, line, type, NULL, size)) == NULL)
! 505: return (NULL);
! 506: #else
! 507: if ((mem = typed_mem_realloc(type, NULL, size)) == NULL)
! 508: return (NULL);
! 509: #endif
! 510: memset(mem, 0, size);
! 511: return (mem);
! 512: }
! 513:
! 514: /*
! 515: * strdup(3) replacement
! 516: */
! 517: char *
! 518: typed_mem_strdup(
! 519: #if TYPED_MEM_TRACE
! 520: const char *file, u_int line,
! 521: #endif
! 522: const char *type, const char *string)
! 523: {
! 524: const int slen = strlen(string) + 1;
! 525: char *result;
! 526:
! 527: #if TYPED_MEM_TRACE
! 528: if ((result = typed_mem_realloc(file, line, type, NULL, slen)) == NULL)
! 529: return (NULL);
! 530: #else
! 531: if ((result = typed_mem_realloc(type, NULL, slen)) == NULL)
! 532: return (NULL);
! 533: #endif
! 534: memcpy(result, string, slen);
! 535: return (result);
! 536: }
! 537:
! 538: /*
! 539: * asprintf(3) replacement
! 540: */
! 541: int
! 542: typed_mem_asprintf(
! 543: #if TYPED_MEM_TRACE
! 544: const char *file, u_int line,
! 545: #endif
! 546: const char *type, char **ret, const char *fmt, ...)
! 547: {
! 548: va_list args;
! 549: int r;
! 550:
! 551: va_start(args, fmt);
! 552: #if TYPED_MEM_TRACE
! 553: r = typed_mem_vasprintf(file, line, type, ret, fmt, args);
! 554: #else
! 555: r = typed_mem_vasprintf(type, ret, fmt, args);
! 556: #endif
! 557: va_end(args);
! 558: return (r);
! 559: }
! 560:
! 561: /*
! 562: * vasprintf(3) replacement
! 563: */
! 564: int
! 565: typed_mem_vasprintf(
! 566: #if TYPED_MEM_TRACE
! 567: const char *file, u_int line,
! 568: #endif
! 569: const char *type, char **ret, const char *fmt, va_list args)
! 570: {
! 571: int errno_save;
! 572: char *s;
! 573: int r;
! 574:
! 575: if ((r = vasprintf(ret, fmt, args)) == -1) {
! 576: *ret = NULL;
! 577: return (-1);
! 578: }
! 579: if (!typed_mem_enabled)
! 580: return r;
! 581: s = *ret;
! 582: #if TYPED_MEM_TRACE
! 583: *ret = typed_mem_strdup(file, line, type, s);
! 584: #else
! 585: *ret = typed_mem_strdup(type, s);
! 586: #endif
! 587: errno_save = errno;
! 588: free(s);
! 589: if (*ret == NULL) {
! 590: errno = errno_save;
! 591: return (-1);
! 592: }
! 593: return (r);
! 594: }
! 595:
! 596: /*
! 597: * Get type for a memory block.
! 598: */
! 599: char *
! 600: typed_mem_type(const void *mem, char *typebuf)
! 601: {
! 602: struct mem_info *info = NULL;
! 603: struct mem_info ikey;
! 604: int r;
! 605:
! 606: /* Are we enabled? */
! 607: if (!typed_mem_enabled) {
! 608: errno = ENXIO;
! 609: return (NULL);
! 610: }
! 611:
! 612: /* Lock info */
! 613: r = pthread_mutex_lock(&typed_mem_mutex);
! 614: assert(r == 0);
! 615:
! 616: /* Find memory descriptor */
! 617: ikey.mem = (u_char *)mem - sizeof(typed_mem_guard);
! 618: if (mem_tree == NULL || (info = gtree_get(mem_tree, &ikey)) == NULL) {
! 619: errno = ENOENT;
! 620: typebuf = NULL;
! 621: goto done;
! 622: }
! 623:
! 624: /* Copy type */
! 625: strlcpy(typebuf, info->type->name, TYPED_MEM_TYPELEN);
! 626:
! 627: done:
! 628: /* Unlock info */
! 629: r = pthread_mutex_unlock(&typed_mem_mutex);
! 630: assert(r == 0);
! 631:
! 632: /* Done */
! 633: return (typebuf);
! 634: }
! 635:
! 636: /*
! 637: * Return typed memory usage statistics. The caller must free the
! 638: * array by calling "structs_free(&typed_mem_stats_type, NULL, stats)".
! 639: *
! 640: * Returns zero if successful, -1 (and sets errno) if not.
! 641: * If typed memory is disabled, errno = ENXIO.
! 642: */
! 643: int
! 644: typed_mem_usage(struct typed_mem_stats *stats)
! 645: {
! 646: struct mem_type *type;
! 647: int i;
! 648: int r;
! 649:
! 650: /* Check if enabled */
! 651: if (!typed_mem_enabled) {
! 652: errno = ENXIO;
! 653: return (-1);
! 654: }
! 655:
! 656: /* Lock info */
! 657: r = pthread_mutex_lock(&typed_mem_mutex);
! 658: assert(r == 0);
! 659:
! 660: /* Allocate array */
! 661: memset(stats, 0, sizeof(*stats));
! 662: if ((stats->elems = typed_mem_realloc(
! 663: #if TYPED_MEM_TRACE
! 664: __FILE__, __LINE__,
! 665: #endif
! 666: TYPED_MEM_STATS_MTYPE, NULL, (gtree_size(type_tree) + 1)
! 667: * sizeof(*stats->elems))) == NULL) {
! 668: r = pthread_mutex_unlock(&typed_mem_mutex);
! 669: assert(r == 0);
! 670: return (-1);
! 671: }
! 672:
! 673: /* Copy type stats */
! 674: for (i = 0, type = gtree_first(type_tree);
! 675: type != NULL; i++, type = gtree_next(type_tree, type)) {
! 676: struct typed_mem_typestats *const elem = &stats->elems[i];
! 677:
! 678: strlcpy(elem->type, type->name, sizeof(elem->type));
! 679: elem->allocs = type->count;
! 680: elem->bytes = type->total;
! 681: }
! 682: stats->length = i;
! 683:
! 684: /* Unlock info */
! 685: r = pthread_mutex_unlock(&typed_mem_mutex);
! 686: assert(r == 0);
! 687:
! 688: /* Done */
! 689: return (0);
! 690: }
! 691:
! 692: #ifndef _KERNEL
! 693:
! 694: /*
! 695: * Return usage statistics in a malloc'd string of the specified type.
! 696: */
! 697: void
! 698: typed_mem_dump(FILE *fp)
! 699: {
! 700: u_long total_blocks = 0;
! 701: u_long total_alloc = 0;
! 702: struct mem_type *type;
! 703: int r;
! 704:
! 705: /* Check if enabled */
! 706: if (!typed_mem_enabled) {
! 707: fprintf(fp, "Typed memory is not enabled.\n");
! 708: return;
! 709: }
! 710:
! 711: /* Print header */
! 712: fprintf(fp, " %-28s %10s %10s\n", "Type", "Count", "Total");
! 713: fprintf(fp, " %-28s %10s %10s\n", "----", "-----", "-----");
! 714:
! 715: /* Lock info */
! 716: r = pthread_mutex_lock(&typed_mem_mutex);
! 717: assert(r == 0);
! 718:
! 719: /* Print allocation types */
! 720: for (type = gtree_first(type_tree);
! 721: type != NULL; type = gtree_next(type_tree, type)) {
! 722: fprintf(fp, " %-28s %10u %10lu\n",
! 723: type->name, (int)type->count, (u_long)type->total);
! 724: total_blocks += type->count;
! 725: total_alloc += type->total;
! 726: }
! 727:
! 728: /* Print totals */
! 729: fprintf(fp, " %-28s %10s %10s\n", "", "-----", "-----");
! 730: fprintf(fp, " %-28s %10lu %10lu\n",
! 731: "Totals", total_blocks, total_alloc);
! 732:
! 733: /* Unlock info */
! 734: r = pthread_mutex_unlock(&typed_mem_mutex);
! 735: assert(r == 0);
! 736: }
! 737:
! 738: #endif /* !_KERNEL */
! 739:
! 740: /*
! 741: * Find memory block info descriptor and verify guard bytes
! 742: *
! 743: * This assumes the mutex is locked.
! 744: */
! 745: static struct mem_info *
! 746: typed_mem_find(
! 747: #if TYPED_MEM_TRACE
! 748: const char *file, u_int line,
! 749: #endif
! 750: void *mem, const char *typename, const char *func)
! 751: {
! 752: struct mem_info *info = NULL;
! 753: struct mem_info ikey;
! 754:
! 755: /* Find memory descriptor which must already exist */
! 756: ikey.mem = (u_char *)mem - sizeof(typed_mem_guard);
! 757: if (mem_tree == NULL || (info = gtree_get(mem_tree, &ikey)) == NULL) {
! 758: #if TYPED_MEM_TRACE
! 759: WHINE("%s:%u: %s() of unallocated block:"
! 760: " ptr=%p type=\"%s\"", file, line, func, mem, typename);
! 761: #else
! 762: WHINE("%s() of unallocated block:"
! 763: " ptr=%p type=\"%s\"", func, mem, typename);
! 764: #endif
! 765: assert(0);
! 766: }
! 767:
! 768: /* Check type is the same */
! 769: if (strncmp(info->type->name, typename, TYPED_MEM_TYPELEN - 1) != 0) {
! 770: #if TYPED_MEM_TRACE
! 771: WHINE("%s:%u: %s() with wrong type:"
! 772: " ptr=%p \"%s\" != \"%s\"", file, line,
! 773: func, mem, typename, info->type->name);
! 774: #else
! 775: WHINE("%s() with wrong type:"
! 776: " ptr=%p \"%s\" != \"%s\"",
! 777: func, mem, typename, info->type->name);
! 778: #endif
! 779: assert(0);
! 780: }
! 781:
! 782: /* Check ref count */
! 783: assert(info->type->count > 0);
! 784:
! 785: /* Check guard bytes */
! 786: if (memcmp(info->mem, typed_mem_guard, sizeof(typed_mem_guard)) != 0) {
! 787: #if TYPED_MEM_TRACE
! 788: WHINE("%s:%u: %s(): %s guard violated ptr=%p type=\"%s\"",
! 789: file, line, func, "head", mem, typename);
! 790: #else
! 791: WHINE("%s(): %s guard violated ptr=%p type=\"%s\"",
! 792: func, "head", mem, typename);
! 793: #endif
! 794: assert(0);
! 795: }
! 796: if (memcmp((u_char *)info->mem + sizeof(typed_mem_guard) + info->size,
! 797: typed_mem_guard, sizeof(typed_mem_guard)) != 0) {
! 798: #if TYPED_MEM_TRACE
! 799: WHINE("%s:%u: %s(): %s guard violated ptr=%p type=\"%s\"",
! 800: file, line, func, "tail", mem, typename);
! 801: #else
! 802: WHINE("%s(): %s guard violated ptr=%p type=\"%s\"",
! 803: func, "tail", mem, typename);
! 804: #endif
! 805: assert(0);
! 806: }
! 807:
! 808: /* Done */
! 809: return (info);
! 810: }
! 811:
! 812: /*
! 813: * Sort type descriptors by type string.
! 814: */
! 815: static int
! 816: type_cmp(struct gtree *g, const void *item1, const void *item2)
! 817: {
! 818: const struct mem_type *const type1 = item1;
! 819: const struct mem_type *const type2 = item2;
! 820:
! 821: return (strcmp(type1->name, type2->name));
! 822: }
! 823:
! 824: /*
! 825: * Print a type
! 826: */
! 827: static const char *
! 828: type_print(struct gtree *g, const void *item)
! 829: {
! 830: const struct mem_type *const type = item;
! 831:
! 832: return (type->name);
! 833: }
! 834:
! 835: /*
! 836: * Sort memory block descriptors by memory address.
! 837: */
! 838: static int
! 839: mem_cmp(struct gtree *g, const void *item1, const void *item2)
! 840: {
! 841: const struct mem_info *const info1 = item1;
! 842: const struct mem_info *const info2 = item2;
! 843:
! 844: if (info1->mem < info2->mem)
! 845: return (-1);
! 846: if (info1->mem > info2->mem)
! 847: return (1);
! 848: return (0);
! 849: }
! 850:
! 851: #ifndef _KERNEL
! 852:
! 853: /*
! 854: * Print a type
! 855: */
! 856: static const char *
! 857: mem_print(struct gtree *g, const void *item)
! 858: {
! 859: const struct mem_info *const info = item;
! 860: static char buf[32];
! 861:
! 862: snprintf(buf, sizeof(buf), "%p", info->mem);
! 863: return (buf);
! 864: }
! 865:
! 866: #endif /* !_KERNEL */
! 867:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to typed_mem.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mpd / src / contrib / libpdel / util