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 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* 27 * Copyright (c) 2011 by Delphix. All rights reserved. 28 */ 29 30 #include <stdlib.h> 31 #include <strings.h> 32 #include <errno.h> 33 #include <unistd.h> 34 #include <assert.h> 35 36 #include <dt_impl.h> 37 #include <dt_printf.h> 38 39 static int 40 dt_strdata_add(dtrace_hdl_t *dtp, dtrace_recdesc_t *rec, void ***data, int *max) 41 { 42 int maxformat; 43 dtrace_fmtdesc_t fmt; 44 void *result; 45 46 if (rec->dtrd_format == 0) 47 return (0); 48 49 if (rec->dtrd_format <= *max && 50 (*data)[rec->dtrd_format - 1] != NULL) { 51 return (0); 52 } 53 54 bzero(&fmt, sizeof (fmt)); 55 fmt.dtfd_format = rec->dtrd_format; 56 fmt.dtfd_string = NULL; 57 fmt.dtfd_length = 0; 58 59 if (dt_ioctl(dtp, DTRACEIOC_FORMAT, &fmt) == -1) 60 return (dt_set_errno(dtp, errno)); 61 62 if ((fmt.dtfd_string = dt_alloc(dtp, fmt.dtfd_length)) == NULL) 63 return (dt_set_errno(dtp, EDT_NOMEM)); 64 65 if (dt_ioctl(dtp, DTRACEIOC_FORMAT, &fmt) == -1) { 66 free(fmt.dtfd_string); 67 return (dt_set_errno(dtp, errno)); 68 } 69 70 while (rec->dtrd_format > (maxformat = *max)) { 71 int new_max = maxformat ? (maxformat << 1) : 1; 72 size_t nsize = new_max * sizeof (void *); 73 size_t osize = maxformat * sizeof (void *); 74 void **new_data = dt_zalloc(dtp, nsize); 75 76 if (new_data == NULL) { 77 dt_free(dtp, fmt.dtfd_string); 78 return (dt_set_errno(dtp, EDT_NOMEM)); 79 } 80 81 bcopy(*data, new_data, osize); 82 free(*data); 83 84 *data = new_data; 85 *max = new_max; 86 } 87 88 switch (rec->dtrd_action) { 89 case DTRACEACT_DIFEXPR: 90 result = fmt.dtfd_string; 91 break; 92 case DTRACEACT_PRINTA: 93 result = dtrace_printa_create(dtp, fmt.dtfd_string); 94 dt_free(dtp, fmt.dtfd_string); 95 break; 96 default: 97 result = dtrace_printf_create(dtp, fmt.dtfd_string); 98 dt_free(dtp, fmt.dtfd_string); 99 break; 100 } 101 102 if (result == NULL) 103 return (-1); 104 105 (*data)[rec->dtrd_format - 1] = result; 106 107 return (0); 108 } 109 110 static int 111 dt_epid_add(dtrace_hdl_t *dtp, dtrace_epid_t id) 112 { 113 dtrace_id_t max; 114 int rval, i; 115 dtrace_eprobedesc_t *enabled, *nenabled; 116 dtrace_probedesc_t *probe; 117 118 while (id >= (max = dtp->dt_maxprobe) || dtp->dt_pdesc == NULL) { 119 dtrace_id_t new_max = max ? (max << 1) : 1; 120 size_t nsize = new_max * sizeof (void *); 121 dtrace_probedesc_t **new_pdesc; 122 dtrace_eprobedesc_t **new_edesc; 123 124 if ((new_pdesc = malloc(nsize)) == NULL || 125 (new_edesc = malloc(nsize)) == NULL) { 126 free(new_pdesc); 127 return (dt_set_errno(dtp, EDT_NOMEM)); 128 } 129 130 bzero(new_pdesc, nsize); 131 bzero(new_edesc, nsize); 132 133 if (dtp->dt_pdesc != NULL) { 134 size_t osize = max * sizeof (void *); 135 136 bcopy(dtp->dt_pdesc, new_pdesc, osize); 137 free(dtp->dt_pdesc); 138 139 bcopy(dtp->dt_edesc, new_edesc, osize); 140 free(dtp->dt_edesc); 141 } 142 143 dtp->dt_pdesc = new_pdesc; 144 dtp->dt_edesc = new_edesc; 145 dtp->dt_maxprobe = new_max; 146 } 147 148 if (dtp->dt_pdesc[id] != NULL) 149 return (0); 150 151 if ((enabled = malloc(sizeof (dtrace_eprobedesc_t))) == NULL) 152 return (dt_set_errno(dtp, EDT_NOMEM)); 153 154 bzero(enabled, sizeof (dtrace_eprobedesc_t)); 155 enabled->dtepd_epid = id; 156 enabled->dtepd_nrecs = 1; 157 158 if (dt_ioctl(dtp, DTRACEIOC_EPROBE, enabled) == -1) { 159 rval = dt_set_errno(dtp, errno); 160 free(enabled); 161 return (rval); 162 } 163 164 if (DTRACE_SIZEOF_EPROBEDESC(enabled) != sizeof (*enabled)) { 165 /* 166 * There must be more than one action. Allocate the 167 * appropriate amount of space and try again. 168 */ 169 if ((nenabled = 170 malloc(DTRACE_SIZEOF_EPROBEDESC(enabled))) != NULL) 171 bcopy(enabled, nenabled, sizeof (*enabled)); 172 173 free(enabled); 174 175 if ((enabled = nenabled) == NULL) 176 return (dt_set_errno(dtp, EDT_NOMEM)); 177 178 rval = dt_ioctl(dtp, DTRACEIOC_EPROBE, enabled); 179 180 if (rval == -1) { 181 rval = dt_set_errno(dtp, errno); 182 free(enabled); 183 return (rval); 184 } 185 } 186 187 if ((probe = malloc(sizeof (dtrace_probedesc_t))) == NULL) { 188 free(enabled); 189 return (dt_set_errno(dtp, EDT_NOMEM)); 190 } 191 192 probe->dtpd_id = enabled->dtepd_probeid; 193 194 if (dt_ioctl(dtp, DTRACEIOC_PROBES, probe) == -1) { 195 rval = dt_set_errno(dtp, errno); 196 goto err; 197 } 198 199 for (i = 0; i < enabled->dtepd_nrecs; i++) { 200 dtrace_recdesc_t *rec = &enabled->dtepd_rec[i]; 201 202 if (DTRACEACT_ISPRINTFLIKE(rec->dtrd_action)) { 203 if (dt_strdata_add(dtp, rec, &dtp->dt_formats, 204 &dtp->dt_maxformat) != 0) { 205 rval = -1; 206 goto err; 207 } 208 } else if (rec->dtrd_action == DTRACEACT_DIFEXPR) { 209 if (dt_strdata_add(dtp, rec, 210 (void ***)&dtp->dt_strdata, 211 &dtp->dt_maxstrdata) != 0) { 212 rval = -1; 213 goto err; 214 } 215 } 216 217 } 218 219 dtp->dt_pdesc[id] = probe; 220 dtp->dt_edesc[id] = enabled; 221 222 return (0); 223 224 err: 225 /* 226 * If we failed, free our allocated probes. Note that if we failed 227 * while allocating formats, we aren't going to free formats that 228 * we have already allocated. This is okay; these formats are 229 * hanging off of dt_formats and will therefore not be leaked. 230 */ 231 free(enabled); 232 free(probe); 233 return (rval); 234 } 235 236 int 237 dt_epid_lookup(dtrace_hdl_t *dtp, dtrace_epid_t epid, 238 dtrace_eprobedesc_t **epdp, dtrace_probedesc_t **pdp) 239 { 240 int rval; 241 242 if (epid >= dtp->dt_maxprobe || dtp->dt_pdesc[epid] == NULL) { 243 if ((rval = dt_epid_add(dtp, epid)) != 0) 244 return (rval); 245 } 246 247 assert(epid < dtp->dt_maxprobe); 248 assert(dtp->dt_edesc[epid] != NULL); 249 assert(dtp->dt_pdesc[epid] != NULL); 250 *epdp = dtp->dt_edesc[epid]; 251 *pdp = dtp->dt_pdesc[epid]; 252 253 return (0); 254 } 255 256 void 257 dt_epid_destroy(dtrace_hdl_t *dtp) 258 { 259 size_t i; 260 261 assert((dtp->dt_pdesc != NULL && dtp->dt_edesc != NULL && 262 dtp->dt_maxprobe > 0) || (dtp->dt_pdesc == NULL && 263 dtp->dt_edesc == NULL && dtp->dt_maxprobe == 0)); 264 265 if (dtp->dt_pdesc == NULL) 266 return; 267 268 for (i = 0; i < dtp->dt_maxprobe; i++) { 269 if (dtp->dt_edesc[i] == NULL) { 270 assert(dtp->dt_pdesc[i] == NULL); 271 continue; 272 } 273 274 assert(dtp->dt_pdesc[i] != NULL); 275 free(dtp->dt_edesc[i]); 276 free(dtp->dt_pdesc[i]); 277 } 278 279 free(dtp->dt_pdesc); 280 dtp->dt_pdesc = NULL; 281 282 free(dtp->dt_edesc); 283 dtp->dt_edesc = NULL; 284 dtp->dt_maxprobe = 0; 285 } 286 287 void * 288 dt_format_lookup(dtrace_hdl_t *dtp, int format) 289 { 290 if (format == 0 || format > dtp->dt_maxformat) 291 return (NULL); 292 293 if (dtp->dt_formats == NULL) 294 return (NULL); 295 296 return (dtp->dt_formats[format - 1]); 297 } 298 299 void 300 dt_format_destroy(dtrace_hdl_t *dtp) 301 { 302 int i; 303 304 for (i = 0; i < dtp->dt_maxformat; i++) { 305 if (dtp->dt_formats[i] != NULL) 306 dt_printf_destroy(dtp->dt_formats[i]); 307 } 308 309 free(dtp->dt_formats); 310 dtp->dt_formats = NULL; 311 } 312 313 static int 314 dt_aggid_add(dtrace_hdl_t *dtp, dtrace_aggid_t id) 315 { 316 dtrace_id_t max; 317 dtrace_epid_t epid; 318 int rval; 319 320 while (id >= (max = dtp->dt_maxagg) || dtp->dt_aggdesc == NULL) { 321 dtrace_id_t new_max = max ? (max << 1) : 1; 322 size_t nsize = new_max * sizeof (void *); 323 dtrace_aggdesc_t **new_aggdesc; 324 325 if ((new_aggdesc = malloc(nsize)) == NULL) 326 return (dt_set_errno(dtp, EDT_NOMEM)); 327 328 bzero(new_aggdesc, nsize); 329 330 if (dtp->dt_aggdesc != NULL) { 331 bcopy(dtp->dt_aggdesc, new_aggdesc, 332 max * sizeof (void *)); 333 free(dtp->dt_aggdesc); 334 } 335 336 dtp->dt_aggdesc = new_aggdesc; 337 dtp->dt_maxagg = new_max; 338 } 339 340 if (dtp->dt_aggdesc[id] == NULL) { 341 dtrace_aggdesc_t *agg, *nagg; 342 343 if ((agg = malloc(sizeof (dtrace_aggdesc_t))) == NULL) 344 return (dt_set_errno(dtp, EDT_NOMEM)); 345 346 bzero(agg, sizeof (dtrace_aggdesc_t)); 347 agg->dtagd_id = id; 348 agg->dtagd_nrecs = 1; 349 350 if (dt_ioctl(dtp, DTRACEIOC_AGGDESC, agg) == -1) { 351 rval = dt_set_errno(dtp, errno); 352 free(agg); 353 return (rval); 354 } 355 356 if (DTRACE_SIZEOF_AGGDESC(agg) != sizeof (*agg)) { 357 /* 358 * There must be more than one action. Allocate the 359 * appropriate amount of space and try again. 360 */ 361 if ((nagg = malloc(DTRACE_SIZEOF_AGGDESC(agg))) != NULL) 362 bcopy(agg, nagg, sizeof (*agg)); 363 364 free(agg); 365 366 if ((agg = nagg) == NULL) 367 return (dt_set_errno(dtp, EDT_NOMEM)); 368 369 rval = dt_ioctl(dtp, DTRACEIOC_AGGDESC, agg); 370 371 if (rval == -1) { 372 rval = dt_set_errno(dtp, errno); 373 free(agg); 374 return (rval); 375 } 376 } 377 378 /* 379 * If we have a uarg, it's a pointer to the compiler-generated 380 * statement; we'll use this value to get the name and 381 * compiler-generated variable ID for the aggregation. If 382 * we're grabbing an anonymous enabling, this pointer value 383 * is obviously meaningless -- and in this case, we can't 384 * provide the compiler-generated aggregation information. 385 */ 386 if (dtp->dt_options[DTRACEOPT_GRABANON] == DTRACEOPT_UNSET && 387 agg->dtagd_rec[0].dtrd_uarg != 0) { 388 dtrace_stmtdesc_t *sdp; 389 dt_ident_t *aid; 390 391 sdp = (dtrace_stmtdesc_t *)(uintptr_t) 392 agg->dtagd_rec[0].dtrd_uarg; 393 aid = sdp->dtsd_aggdata; 394 agg->dtagd_name = aid->di_name; 395 agg->dtagd_varid = aid->di_id; 396 } else { 397 agg->dtagd_varid = DTRACE_AGGVARIDNONE; 398 } 399 400 if ((epid = agg->dtagd_epid) >= dtp->dt_maxprobe || 401 dtp->dt_pdesc[epid] == NULL) { 402 if ((rval = dt_epid_add(dtp, epid)) != 0) { 403 free(agg); 404 return (rval); 405 } 406 } 407 408 dtp->dt_aggdesc[id] = agg; 409 } 410 411 return (0); 412 } 413 414 int 415 dt_aggid_lookup(dtrace_hdl_t *dtp, dtrace_aggid_t aggid, 416 dtrace_aggdesc_t **adp) 417 { 418 int rval; 419 420 if (aggid >= dtp->dt_maxagg || dtp->dt_aggdesc[aggid] == NULL) { 421 if ((rval = dt_aggid_add(dtp, aggid)) != 0) 422 return (rval); 423 } 424 425 assert(aggid < dtp->dt_maxagg); 426 assert(dtp->dt_aggdesc[aggid] != NULL); 427 *adp = dtp->dt_aggdesc[aggid]; 428 429 return (0); 430 } 431 432 void 433 dt_aggid_destroy(dtrace_hdl_t *dtp) 434 { 435 size_t i; 436 437 assert((dtp->dt_aggdesc != NULL && dtp->dt_maxagg != 0) || 438 (dtp->dt_aggdesc == NULL && dtp->dt_maxagg == 0)); 439 440 if (dtp->dt_aggdesc == NULL) 441 return; 442 443 for (i = 0; i < dtp->dt_maxagg; i++) { 444 if (dtp->dt_aggdesc[i] != NULL) 445 free(dtp->dt_aggdesc[i]); 446 } 447 448 free(dtp->dt_aggdesc); 449 dtp->dt_aggdesc = NULL; 450 dtp->dt_maxagg = 0; 451 } 452 453 const char * 454 dt_strdata_lookup(dtrace_hdl_t *dtp, int idx) 455 { 456 if (idx == 0 || idx > dtp->dt_maxstrdata) 457 return (NULL); 458 459 if (dtp->dt_strdata == NULL) 460 return (NULL); 461 462 return (dtp->dt_strdata[idx - 1]); 463 } 464 465 void 466 dt_strdata_destroy(dtrace_hdl_t *dtp) 467 { 468 int i; 469 470 for (i = 0; i < dtp->dt_maxstrdata; i++) { 471 free(dtp->dt_strdata[i]); 472 } 473 474 free(dtp->dt_strdata); 475 dtp->dt_strdata = NULL; 476 } 477