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