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