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, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22
23 /*
24 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 */
27
28 #pragma ident "%Z%%M% %I% %E% SMI"
29
30 #include <dt_impl.h>
31 #include <stddef.h>
32 #include <errno.h>
33 #include <assert.h>
34 #include <time.h>
35
36 static const struct {
37 int dtslt_option;
38 size_t dtslt_offs;
39 } _dtrace_sleeptab[] = {
40 { DTRACEOPT_STATUSRATE, offsetof(dtrace_hdl_t, dt_laststatus) },
41 { DTRACEOPT_AGGRATE, offsetof(dtrace_hdl_t, dt_lastagg) },
42 { DTRACEOPT_SWITCHRATE, offsetof(dtrace_hdl_t, dt_lastswitch) },
43 { DTRACEOPT_MAX, 0 }
44 };
45
46 void
47 dtrace_sleep(dtrace_hdl_t *dtp)
48 {
49 dt_proc_hash_t *dph = dtp->dt_procs;
50 dtrace_optval_t policy = dtp->dt_options[DTRACEOPT_BUFPOLICY];
51 dt_proc_notify_t *dprn;
52
53 hrtime_t earliest = INT64_MAX;
54 struct timespec tv;
55 hrtime_t now;
56 int i;
57
58 for (i = 0; _dtrace_sleeptab[i].dtslt_option < DTRACEOPT_MAX; i++) {
59 uintptr_t a = (uintptr_t)dtp + _dtrace_sleeptab[i].dtslt_offs;
60 int opt = _dtrace_sleeptab[i].dtslt_option;
61 dtrace_optval_t interval = dtp->dt_options[opt];
62
63 /*
64 * If the buffering policy is set to anything other than
65 * "switch", we ignore the aggrate and switchrate -- they're
66 * meaningless.
67 */
68 if (policy != DTRACEOPT_BUFPOLICY_SWITCH &&
69 _dtrace_sleeptab[i].dtslt_option != DTRACEOPT_STATUSRATE)
70 continue;
71
72 if (*((hrtime_t *)a) + interval < earliest)
73 earliest = *((hrtime_t *)a) + interval;
74 }
75
76 (void) pthread_mutex_lock(&dph->dph_lock);
77
78 now = gethrtime();
79
80 if (earliest < now) {
81 (void) pthread_mutex_unlock(&dph->dph_lock);
82 return; /* sleep duration has already past */
83 }
84
85 tv.tv_sec = (earliest - now) / NANOSEC;
86 tv.tv_nsec = (earliest - now) % NANOSEC;
87
88 /*
89 * Wait for either 'tv' nanoseconds to pass or to receive notification
90 * that a process is in an interesting state. Regardless of why we
91 * awaken, iterate over any pending notifications and process them.
92 */
93 (void) pthread_cond_reltimedwait_np(&dph->dph_cv, &dph->dph_lock, &tv);
94
95 while ((dprn = dph->dph_notify) != NULL) {
96 if (dtp->dt_prochdlr != NULL) {
97 char *err = dprn->dprn_errmsg;
98 if (*err == '\0')
99 err = NULL;
100
101 dtp->dt_prochdlr(dprn->dprn_dpr->dpr_proc, err,
102 dtp->dt_procarg);
103 }
104
105 dph->dph_notify = dprn->dprn_next;
106 dt_free(dtp, dprn);
107 }
108
109 (void) pthread_mutex_unlock(&dph->dph_lock);
110 }
111
112 int
113 dtrace_status(dtrace_hdl_t *dtp)
114 {
115 int gen = dtp->dt_statusgen;
116 dtrace_optval_t interval = dtp->dt_options[DTRACEOPT_STATUSRATE];
117 hrtime_t now = gethrtime();
118
119 if (!dtp->dt_active)
120 return (DTRACE_STATUS_NONE);
121
122 if (dtp->dt_stopped)
123 return (DTRACE_STATUS_STOPPED);
124
125 if (dtp->dt_laststatus != 0) {
126 if (now - dtp->dt_laststatus < interval)
127 return (DTRACE_STATUS_NONE);
128
129 dtp->dt_laststatus += interval;
130 } else {
131 dtp->dt_laststatus = now;
132 }
133
134 if (dt_ioctl(dtp, DTRACEIOC_STATUS, &dtp->dt_status[gen]) == -1)
135 return (dt_set_errno(dtp, errno));
136
137 dtp->dt_statusgen ^= 1;
138
139 if (dt_handle_status(dtp, &dtp->dt_status[dtp->dt_statusgen],
140 &dtp->dt_status[gen]) == -1)
141 return (-1);
142
143 if (dtp->dt_status[gen].dtst_exiting) {
144 if (!dtp->dt_stopped)
145 (void) dtrace_stop(dtp);
146
147 return (DTRACE_STATUS_EXITED);
148 }
149
150 if (dtp->dt_status[gen].dtst_filled == 0)
151 return (DTRACE_STATUS_OKAY);
152
153 if (dtp->dt_options[DTRACEOPT_BUFPOLICY] != DTRACEOPT_BUFPOLICY_FILL)
154 return (DTRACE_STATUS_OKAY);
155
156 if (!dtp->dt_stopped) {
157 if (dtrace_stop(dtp) == -1)
158 return (-1);
159 }
160
161 return (DTRACE_STATUS_FILLED);
162 }
163
164 int
165 dtrace_go(dtrace_hdl_t *dtp)
166 {
167 void *dof;
168 int err;
169
170 if (dtp->dt_active)
171 return (dt_set_errno(dtp, EINVAL));
172
173 /*
174 * If a dtrace:::ERROR program and callback are registered, enable the
175 * program before we start tracing. If this fails for a vector open
176 * with ENOTTY, we permit dtrace_go() to succeed so that vector clients
177 * such as mdb's dtrace module can execute the rest of dtrace_go() even
178 * though they do not provide support for the DTRACEIOC_ENABLE ioctl.
179 */
180 if (dtp->dt_errprog != NULL &&
181 dtrace_program_exec(dtp, dtp->dt_errprog, NULL) == -1 && (
182 dtp->dt_errno != ENOTTY || dtp->dt_vector == NULL))
183 return (-1); /* dt_errno has been set for us */
184
185 if ((dof = dtrace_getopt_dof(dtp)) == NULL)
186 return (-1); /* dt_errno has been set for us */
187
188 err = dt_ioctl(dtp, DTRACEIOC_ENABLE, dof);
189 dtrace_dof_destroy(dtp, dof);
190
191 if (err == -1 && (errno != ENOTTY || dtp->dt_vector == NULL))
192 return (dt_set_errno(dtp, errno));
193
194 if (dt_ioctl(dtp, DTRACEIOC_GO, &dtp->dt_beganon) == -1) {
195 if (errno == EACCES)
196 return (dt_set_errno(dtp, EDT_DESTRUCTIVE));
197
198 if (errno == EALREADY)
199 return (dt_set_errno(dtp, EDT_ISANON));
200
201 if (errno == ENOENT)
202 return (dt_set_errno(dtp, EDT_NOANON));
203
204 if (errno == E2BIG)
205 return (dt_set_errno(dtp, EDT_ENDTOOBIG));
206
207 if (errno == ENOSPC)
208 return (dt_set_errno(dtp, EDT_BUFTOOSMALL));
209
210 return (dt_set_errno(dtp, errno));
211 }
212
213 dtp->dt_active = 1;
214
215 if (dt_options_load(dtp) == -1)
216 return (dt_set_errno(dtp, errno));
217
218 return (dt_aggregate_go(dtp));
219 }
220
221 int
222 dtrace_stop(dtrace_hdl_t *dtp)
223 {
224 int gen = dtp->dt_statusgen;
225
226 if (dtp->dt_stopped)
227 return (0);
228
229 if (dt_ioctl(dtp, DTRACEIOC_STOP, &dtp->dt_endedon) == -1)
230 return (dt_set_errno(dtp, errno));
231
232 dtp->dt_stopped = 1;
233
234 /*
235 * Now that we're stopped, we're going to get status one final time.
236 */
237 if (dt_ioctl(dtp, DTRACEIOC_STATUS, &dtp->dt_status[gen]) == -1)
238 return (dt_set_errno(dtp, errno));
239
240 if (dt_handle_status(dtp, &dtp->dt_status[gen ^ 1],
241 &dtp->dt_status[gen]) == -1)
242 return (-1);
243
244 return (0);
245 }
246
247
248 dtrace_workstatus_t
249 dtrace_work(dtrace_hdl_t *dtp, FILE *fp,
250 dtrace_consume_probe_f *pfunc, dtrace_consume_rec_f *rfunc, void *arg)
251 {
252 int status = dtrace_status(dtp);
253 dtrace_optval_t policy = dtp->dt_options[DTRACEOPT_BUFPOLICY];
254 dtrace_workstatus_t rval;
255
256 switch (status) {
257 case DTRACE_STATUS_EXITED:
258 case DTRACE_STATUS_FILLED:
259 case DTRACE_STATUS_STOPPED:
260 /*
261 * Tracing is stopped. We now want to force dtrace_consume()
262 * and dtrace_aggregate_snap() to proceed, regardless of
263 * switchrate and aggrate. We do this by clearing the times.
264 */
265 dtp->dt_lastswitch = 0;
266 dtp->dt_lastagg = 0;
267 rval = DTRACE_WORKSTATUS_DONE;
268 break;
269
270 case DTRACE_STATUS_NONE:
271 case DTRACE_STATUS_OKAY:
272 rval = DTRACE_WORKSTATUS_OKAY;
273 break;
274
275 case -1:
276 return (DTRACE_WORKSTATUS_ERROR);
277 }
278
279 if ((status == DTRACE_STATUS_NONE || status == DTRACE_STATUS_OKAY) &&
280 policy != DTRACEOPT_BUFPOLICY_SWITCH) {
281 /*
282 * There either isn't any status or things are fine -- and
283 * this is a "ring" or "fill" buffer. We don't want to consume
284 * any of the trace data or snapshot the aggregations; we just
285 * return.
286 */
287 assert(rval == DTRACE_WORKSTATUS_OKAY);
288 return (rval);
289 }
290
291 if (dtrace_aggregate_snap(dtp) == -1)
292 return (DTRACE_WORKSTATUS_ERROR);
293
294 if (dtrace_consume(dtp, fp, pfunc, rfunc, arg) == -1)
295 return (DTRACE_WORKSTATUS_ERROR);
296
297 return (rval);
298 }