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
dt_strdata_add(dtrace_hdl_t * dtp,dtrace_recdesc_t * rec,void *** data,int * max)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
dt_epid_add(dtrace_hdl_t * dtp,dtrace_epid_t id)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
dt_epid_lookup(dtrace_hdl_t * dtp,dtrace_epid_t epid,dtrace_eprobedesc_t ** epdp,dtrace_probedesc_t ** pdp)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
dt_epid_destroy(dtrace_hdl_t * dtp)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 *
dt_format_lookup(dtrace_hdl_t * dtp,int format)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
dt_format_destroy(dtrace_hdl_t * dtp)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
dt_aggid_add(dtrace_hdl_t * dtp,dtrace_aggid_t id)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 != NULL) {
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
dt_aggid_lookup(dtrace_hdl_t * dtp,dtrace_aggid_t aggid,dtrace_aggdesc_t ** adp)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
dt_aggid_destroy(dtrace_hdl_t * dtp)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 *
dt_strdata_lookup(dtrace_hdl_t * dtp,int idx)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
dt_strdata_destroy(dtrace_hdl_t * dtp)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