usr/src/cmd/fm/modules/common/eversholt/alloc.c

   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 #pragma ident   "%Z%%M% %I%     %E% SMI"
  31
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <strings.h>
  35 #include <fm/fmd_api.h>
  36
  37 #include "alloc.h"
  38 #include "out.h"
  39 #include "stats.h"
  40
  41 extern fmd_hdl_t *Hdl;          /* handle from eft.c */
  42
  43 /* room to store size, possibly more to maintain alignment for long longs */
  44 #define HDRSIZ  sizeof (long long)
  45
  46 static struct stats *Malloctotal;
  47 static struct stats *Freetotal;
  48 static struct stats *Malloccount;
  49 static struct stats *Freecount;
  50
  51 static int totalcount;
  52
  53 void
  54 alloc_init(void)
  55 {
  56         Malloctotal = stats_new_counter("alloc.total", "bytes allocated", 1);
  57         Freetotal = stats_new_counter("free.total", "bytes freed", 1);
  58         Malloccount = stats_new_counter("alloc.calls", "alloc calls", 1);
  59         Freecount = stats_new_counter("free.calls", "free calls", 1);
  60 }
  61
  62 void
  63 alloc_fini(void)
  64 {
  65         struct stats *mt, *ft, *mc, *fc;
  66
  67         mt = Malloctotal;
  68         ft = Freetotal;
  69         mc = Malloccount;
  70         fc = Freecount;
  71
  72         Malloctotal = NULL;
  73         Freetotal = NULL;
  74         Malloccount = NULL;
  75         Freecount = NULL;
  76
  77         stats_delete(mt);
  78         stats_delete(ft);
  79         stats_delete(mc);
  80         stats_delete(fc);
  81 }
  82
  83 /*
  84  * alloc_malloc -- a malloc() with checks
  85  *
  86  * this routine is typically called via the MALLOC() macro in alloc.h
  87  */
  88 /*ARGSUSED*/
  89 void *
  90 alloc_malloc(size_t nbytes, const char *fname, int line)
  91 {
  92         char *retval;
  93
  94         ASSERT(nbytes > 0);
  95
  96         retval = fmd_hdl_alloc(Hdl, nbytes + HDRSIZ, FMD_SLEEP);
  97
  98         /* retval can't be NULL since fmd_hdl_alloc() sleeps for memory */
  99
 100         bcopy((void *)&nbytes, (void *)retval, sizeof (nbytes));
 101         retval += HDRSIZ;
 102
 103         if (Malloctotal)
 104                 stats_counter_add(Malloctotal, nbytes);
 105
 106         if (Malloccount)
 107                 stats_counter_bump(Malloccount);
 108
 109         totalcount += nbytes + HDRSIZ;
 110         return ((void *)retval);
 111 }
 112
 113 /*
 114  * alloc_realloc -- a realloc() with checks
 115  *
 116  * this routine is typically called via the REALLOC() macro in alloc.h
 117  */
 118 void *
 119 alloc_realloc(void *ptr, size_t nbytes, const char *fname, int line)
 120 {
 121         void *retval = alloc_malloc(nbytes, fname, line);
 122
 123         if (ptr != NULL) {
 124                 size_t osize;
 125
 126                 bcopy((void *)((char *)ptr - HDRSIZ), (void *)&osize,
 127                     sizeof (osize));
 128                 /* now we have the new memory, copy in the old contents */
 129                 bcopy(ptr, retval, (osize < nbytes) ? osize : nbytes);
 130
 131                 /* don't need the old memory anymore */
 132                 alloc_free((char *)ptr, fname, line);
 133         }
 134
 135         return (retval);
 136 }
 137
 138 /*
 139  * alloc_strdup -- a strdup() with checks
 140  *
 141  * this routine is typically called via the STRDUP() macro in alloc.h
 142  */
 143 char *
 144 alloc_strdup(const char *ptr, const char *fname, int line)
 145 {
 146         char *retval = alloc_malloc(strlen(ptr) + 1, fname, line);
 147
 148         (void) strcpy(retval, ptr);
 149
 150         return (retval);
 151 }
 152
 153 /*
 154  * alloc_free -- a free() with checks
 155  *
 156  * this routine is typically called via the FREE() macro in alloc.h
 157  */
 158 /*ARGSUSED*/
 159 void
 160 alloc_free(void *ptr, const char *fname, int line)
 161 {
 162         size_t osize;
 163
 164         ASSERT(ptr != NULL);
 165
 166         bcopy((void *)((char *)ptr - HDRSIZ), (void *)&osize, sizeof (osize));
 167
 168         /* nothing to check in this version */
 169
 170         fmd_hdl_free(Hdl, (char *)ptr - HDRSIZ, osize + HDRSIZ);
 171
 172         if (Freetotal)
 173                 stats_counter_add(Freetotal, osize);
 174
 175         if (Freecount)
 176                 stats_counter_bump(Freecount);
 177         totalcount -= osize + HDRSIZ;
 178 }
 179
 180 int
 181 alloc_total()
 182 {
 183         return (totalcount);
 184 }
 185
 186 /*
 187  * variants that don't maintain size in header - saves space
 188  */
 189 void *
 190 alloc_xmalloc(size_t nbytes)
 191 {
 192         char *retval;
 193
 194         ASSERT(nbytes > 0);
 195         retval = fmd_hdl_alloc(Hdl, nbytes, FMD_SLEEP);
 196         if (Malloctotal)
 197                 stats_counter_add(Malloctotal, nbytes);
 198         if (Malloccount)
 199                 stats_counter_bump(Malloccount);
 200         totalcount += nbytes;
 201         return ((void *)retval);
 202 }
 203
 204 void
 205 alloc_xfree(void *ptr, size_t size)
 206 {
 207         ASSERT(ptr != NULL);
 208
 209         fmd_hdl_free(Hdl, (char *)ptr, size);
 210         if (Freetotal)
 211                 stats_counter_add(Freetotal, size);
 212         if (Freecount)
 213                 stats_counter_bump(Freecount);
 214         totalcount -= size;
 215 }