1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 * 26 * alloc.c -- memory allocation wrapper functions, for eft.so FMD module 27 * 28 */ 29 30 #include <stdlib.h> 31 #include <string.h> 32 #include <strings.h> 33 #include <fm/fmd_api.h> 34 35 #include "alloc.h" 36 #include "out.h" 37 #include "stats.h" 38 39 extern fmd_hdl_t *Hdl; /* handle from eft.c */ 40 41 /* room to store size, possibly more to maintain alignment for long longs */ 42 #define HDRSIZ sizeof (long long) 43 44 static struct stats *Malloctotal; 45 static struct stats *Freetotal; 46 static struct stats *Malloccount; 47 static struct stats *Freecount; 48 49 static int totalcount; 50 51 void 52 alloc_init(void) 53 { 54 Malloctotal = stats_new_counter("alloc.total", "bytes allocated", 1); 55 Freetotal = stats_new_counter("free.total", "bytes freed", 1); 56 Malloccount = stats_new_counter("alloc.calls", "alloc calls", 1); 57 Freecount = stats_new_counter("free.calls", "free calls", 1); 58 } 59 60 void 61 alloc_fini(void) 62 { 63 struct stats *mt, *ft, *mc, *fc; 64 65 mt = Malloctotal; 66 ft = Freetotal; 67 mc = Malloccount; 68 fc = Freecount; 69 70 Malloctotal = NULL; 71 Freetotal = NULL; 72 Malloccount = NULL; 73 Freecount = NULL; 74 75 stats_delete(mt); 76 stats_delete(ft); 77 stats_delete(mc); 78 stats_delete(fc); 79 } 80 81 /* 82 * alloc_malloc -- a malloc() with checks 83 * 84 * this routine is typically called via the MALLOC() macro in alloc.h 85 */ 86 /*ARGSUSED*/ 87 void * 88 alloc_malloc(size_t nbytes, const char *fname, int line) 89 { 90 char *retval; 91 92 ASSERT(nbytes > 0); 93 94 retval = fmd_hdl_alloc(Hdl, nbytes + HDRSIZ, FMD_SLEEP); 95 96 /* retval can't be NULL since fmd_hdl_alloc() sleeps for memory */ 97 98 bcopy((void *)&nbytes, (void *)retval, sizeof (nbytes)); 99 retval += HDRSIZ; 100 101 if (Malloctotal) 102 stats_counter_add(Malloctotal, nbytes); 103 104 if (Malloccount) 105 stats_counter_bump(Malloccount); 106 107 totalcount += nbytes + HDRSIZ; 108 return ((void *)retval); 109 } 110 111 /* 112 * alloc_realloc -- a realloc() with checks 113 * 114 * this routine is typically called via the REALLOC() macro in alloc.h 115 */ 116 void * 117 alloc_realloc(void *ptr, size_t nbytes, const char *fname, int line) 118 { 119 void *retval = alloc_malloc(nbytes, fname, line); 120 121 if (ptr != NULL) { 122 size_t osize; 123 124 bcopy((void *)((char *)ptr - HDRSIZ), (void *)&osize, 125 sizeof (osize)); 126 /* now we have the new memory, copy in the old contents */ 127 bcopy(ptr, retval, (osize < nbytes) ? osize : nbytes); 128 129 /* don't need the old memory anymore */ 130 alloc_free((char *)ptr, fname, line); 131 } 132 133 return (retval); 134 } 135 136 /* 137 * alloc_strdup -- a strdup() with checks 138 * 139 * this routine is typically called via the STRDUP() macro in alloc.h 140 */ 141 char * 142 alloc_strdup(const char *ptr, const char *fname, int line) 143 { 144 char *retval = alloc_malloc(strlen(ptr) + 1, fname, line); 145 146 (void) strcpy(retval, ptr); 147 148 return (retval); 149 } 150 151 /* 152 * alloc_free -- a free() with checks 153 * 154 * this routine is typically called via the FREE() macro in alloc.h 155 */ 156 /*ARGSUSED*/ 157 void 158 alloc_free(void *ptr, const char *fname, int line) 159 { 160 size_t osize; 161 162 ASSERT(ptr != NULL); 163 164 bcopy((void *)((char *)ptr - HDRSIZ), (void *)&osize, sizeof (osize)); 165 166 /* nothing to check in this version */ 167 168 fmd_hdl_free(Hdl, (char *)ptr - HDRSIZ, osize + HDRSIZ); 169 170 if (Freetotal) 171 stats_counter_add(Freetotal, osize); 172 173 if (Freecount) 174 stats_counter_bump(Freecount); 175 totalcount -= osize + HDRSIZ; 176 } 177 178 int 179 alloc_total() 180 { 181 return (totalcount); 182 } 183 184 /* 185 * variants that don't maintain size in header - saves space 186 */ 187 void * 188 alloc_xmalloc(size_t nbytes) 189 { 190 char *retval; 191 192 ASSERT(nbytes > 0); 193 retval = fmd_hdl_alloc(Hdl, nbytes, FMD_SLEEP); 194 if (Malloctotal) 195 stats_counter_add(Malloctotal, nbytes); 196 if (Malloccount) 197 stats_counter_bump(Malloccount); 198 totalcount += nbytes; 199 return ((void *)retval); 200 } 201 202 void 203 alloc_xfree(void *ptr, size_t size) 204 { 205 ASSERT(ptr != NULL); 206 207 fmd_hdl_free(Hdl, (char *)ptr, size); 208 if (Freetotal) 209 stats_counter_add(Freetotal, size); 210 if (Freecount) 211 stats_counter_bump(Freecount); 212 totalcount -= size; 213 } 214