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 * Portions Copyright 2006-2008 John Birrell jb@freebsd.org 22 * 23 * $FreeBSD$ 24 * 25 */ 26 27 #include <sys/cdefs.h> 28 #include <sys/param.h> 29 #include <sys/systm.h> 30 #include <sys/conf.h> 31 #include <sys/ctype.h> 32 #include <sys/kernel.h> 33 #include <sys/malloc.h> 34 #include <sys/module.h> 35 36 #include <sys/dtrace.h> 37 #include <sys/dtrace_bsd.h> 38 39 extern bool dtrace_malloc_enabled; 40 static uint32_t dtrace_malloc_enabled_count; 41 42 static d_open_t dtmalloc_open; 43 static int dtmalloc_unload(void); 44 static void dtmalloc_getargdesc(void *, dtrace_id_t, void *, dtrace_argdesc_t *); 45 static void dtmalloc_provide(void *, dtrace_probedesc_t *); 46 static void dtmalloc_destroy(void *, dtrace_id_t, void *); 47 static void dtmalloc_enable(void *, dtrace_id_t, void *); 48 static void dtmalloc_disable(void *, dtrace_id_t, void *); 49 static void dtmalloc_load(void *); 50 51 static struct cdevsw dtmalloc_cdevsw = { 52 .d_version = D_VERSION, 53 .d_open = dtmalloc_open, 54 .d_name = "dtmalloc", 55 }; 56 57 static dtrace_pattr_t dtmalloc_attr = { 58 { DTRACE_STABILITY_STABLE, DTRACE_STABILITY_STABLE, DTRACE_CLASS_COMMON }, 59 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN }, 60 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN }, 61 { DTRACE_STABILITY_STABLE, DTRACE_STABILITY_STABLE, DTRACE_CLASS_COMMON }, 62 { DTRACE_STABILITY_STABLE, DTRACE_STABILITY_STABLE, DTRACE_CLASS_COMMON }, 63 }; 64 65 static dtrace_pops_t dtmalloc_pops = { 66 .dtps_provide = dtmalloc_provide, 67 .dtps_provide_module = NULL, 68 .dtps_enable = dtmalloc_enable, 69 .dtps_disable = dtmalloc_disable, 70 .dtps_suspend = NULL, 71 .dtps_resume = NULL, 72 .dtps_getargdesc = dtmalloc_getargdesc, 73 .dtps_getargval = NULL, 74 .dtps_usermode = NULL, 75 .dtps_destroy = dtmalloc_destroy 76 }; 77 78 static struct cdev *dtmalloc_cdev; 79 static dtrace_provider_id_t dtmalloc_id; 80 81 static void 82 dtmalloc_getargdesc(void *arg, dtrace_id_t id, void *parg, dtrace_argdesc_t *desc) 83 { 84 const char *p = NULL; 85 86 switch (desc->dtargd_ndx) { 87 case 0: 88 p = "struct malloc_type *"; 89 break; 90 case 1: 91 p = "struct malloc_type_internal *"; 92 break; 93 case 2: 94 p = "struct malloc_type_stats *"; 95 break; 96 case 3: 97 p = "unsigned long"; 98 break; 99 case 4: 100 p = "int"; 101 break; 102 default: 103 desc->dtargd_ndx = DTRACE_ARGNONE; 104 break; 105 } 106 107 if (p != NULL) 108 strlcpy(desc->dtargd_native, p, sizeof(desc->dtargd_native)); 109 110 return; 111 } 112 113 static void 114 dtmalloc_type_cb(struct malloc_type *mtp, void *arg __unused) 115 { 116 char name[DTRACE_FUNCNAMELEN]; 117 struct malloc_type_internal *mtip = mtp->ks_handle; 118 int i; 119 120 /* 121 * malloc_type descriptions are allowed to contain whitespace, but 122 * DTrace probe identifiers are not, so replace the whitespace with 123 * underscores. 124 */ 125 strlcpy(name, mtp->ks_shortdesc, sizeof(name)); 126 for (i = 0; name[i] != 0; i++) 127 if (isspace(name[i])) 128 name[i] = '_'; 129 130 if (dtrace_probe_lookup(dtmalloc_id, NULL, name, "malloc") != 0) 131 return; 132 133 (void) dtrace_probe_create(dtmalloc_id, NULL, name, "malloc", 0, 134 &mtip->mti_probes[DTMALLOC_PROBE_MALLOC]); 135 (void) dtrace_probe_create(dtmalloc_id, NULL, name, "free", 0, 136 &mtip->mti_probes[DTMALLOC_PROBE_FREE]); 137 } 138 139 static void 140 dtmalloc_provide(void *arg, dtrace_probedesc_t *desc) 141 { 142 if (desc != NULL) 143 return; 144 145 malloc_type_list(dtmalloc_type_cb, desc); 146 } 147 148 static void 149 dtmalloc_destroy(void *arg, dtrace_id_t id, void *parg) 150 { 151 } 152 153 static void 154 dtmalloc_enable(void *arg, dtrace_id_t id, void *parg) 155 { 156 uint32_t *p = parg; 157 *p = id; 158 dtrace_malloc_enabled_count++; 159 if (dtrace_malloc_enabled_count == 1) 160 dtrace_malloc_enabled = true; 161 } 162 163 static void 164 dtmalloc_disable(void *arg, dtrace_id_t id, void *parg) 165 { 166 uint32_t *p = parg; 167 *p = 0; 168 dtrace_malloc_enabled_count--; 169 if (dtrace_malloc_enabled_count == 0) 170 dtrace_malloc_enabled = false; 171 } 172 173 static void 174 dtmalloc_load(void *dummy) 175 { 176 /* Create the /dev/dtrace/dtmalloc entry. */ 177 dtmalloc_cdev = make_dev(&dtmalloc_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600, 178 "dtrace/dtmalloc"); 179 180 if (dtrace_register("dtmalloc", &dtmalloc_attr, DTRACE_PRIV_USER, 181 NULL, &dtmalloc_pops, NULL, &dtmalloc_id) != 0) 182 return; 183 184 dtrace_malloc_probe = dtrace_probe; 185 } 186 187 188 static int 189 dtmalloc_unload() 190 { 191 int error = 0; 192 193 dtrace_malloc_probe = NULL; 194 195 if ((error = dtrace_unregister(dtmalloc_id)) != 0) 196 return (error); 197 198 destroy_dev(dtmalloc_cdev); 199 200 return (error); 201 } 202 203 static int 204 dtmalloc_modevent(module_t mod __unused, int type, void *data __unused) 205 { 206 int error = 0; 207 208 switch (type) { 209 case MOD_LOAD: 210 break; 211 212 case MOD_UNLOAD: 213 break; 214 215 case MOD_SHUTDOWN: 216 break; 217 218 default: 219 error = EOPNOTSUPP; 220 break; 221 222 } 223 224 return (error); 225 } 226 227 static int 228 dtmalloc_open(struct cdev *dev __unused, int oflags __unused, int devtype __unused, struct thread *td __unused) 229 { 230 return (0); 231 } 232 233 SYSINIT(dtmalloc_load, SI_SUB_DTRACE_PROVIDER, SI_ORDER_ANY, dtmalloc_load, NULL); 234 SYSUNINIT(dtmalloc_unload, SI_SUB_DTRACE_PROVIDER, SI_ORDER_ANY, dtmalloc_unload, NULL); 235 236 DEV_MODULE(dtmalloc, dtmalloc_modevent, NULL); 237 MODULE_VERSION(dtmalloc, 1); 238 MODULE_DEPEND(dtmalloc, dtrace, 1, 1, 1); 239 MODULE_DEPEND(dtmalloc, opensolaris, 1, 1, 1); 240