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 "@(#)dt_work.c 1.8 06/02/08 SMI" 29 30#include <dt_impl.h> 31#include <stddef.h> 32#include <errno.h> 33#include <assert.h> 34#include <time.h> 35 36static 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 46void 47dtrace_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 112int 113dtrace_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 164int 165dtrace_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 221int 222dtrace_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 248dtrace_workstatus_t 249dtrace_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} 299 300#pragma mark vvv modified functions. test separate collect/analyze phases vvv 301int 302dtrace_setup(dtrace_hdl_t *dtp, dtrace_bufdesc_t ***agg_bufs) 303{ 304 void *dof; 305 int err; 306 307 if (dtp->dt_active) 308 return (dt_set_errno(dtp, EINVAL)); 309 310 /* 311 * If a dtrace:::ERROR program and callback are registered, enable the 312 * program before we start tracing. If this fails for a vector open 313 * with ENOTTY, we permit dtrace_go() to succeed so that vector clients 314 * such as mdb's dtrace module can execute the rest of dtrace_go() even 315 * though they do not provide support for the DTRACEIOC_ENABLE ioctl. 316 */ 317 if (dtp->dt_errprog != NULL && 318 dtrace_program_exec(dtp, dtp->dt_errprog, NULL) == -1 && ( 319 dtp->dt_errno != ENOTTY || dtp->dt_vector == NULL)) 320 return (-1); /* dt_errno has been set for us */ 321 322 if ((dof = dtrace_getopt_dof(dtp)) == NULL) 323 return (-1); /* dt_errno has been set for us */ 324 325 err = dt_ioctl(dtp, DTRACEIOC_ENABLE, dof); 326 dtrace_dof_destroy(dtp, dof); 327 328 if (err == -1 && (errno != ENOTTY || dtp->dt_vector == NULL)) 329 return (dt_set_errno(dtp, errno)); 330 331 if (dt_ioctl(dtp, DTRACEIOC_GO, &dtp->dt_beganon) == -1) { 332 if (errno == EACCES) 333 return (dt_set_errno(dtp, EDT_DESTRUCTIVE)); 334 335 if (errno == EALREADY) 336 return (dt_set_errno(dtp, EDT_ISANON)); 337 338 if (errno == ENOENT) 339 return (dt_set_errno(dtp, EDT_NOANON)); 340 341 if (errno == E2BIG) 342 return (dt_set_errno(dtp, EDT_ENDTOOBIG)); 343 344 if (errno == EBUSY) 345 return (dt_set_errno(dtp, EDT_ENABLING_ERR)); 346 347 if (errno == ENOSPC) 348 return (dt_set_errno(dtp, EDT_BUFTOOSMALL)); 349 350 return (dt_set_errno(dtp, errno)); 351 } 352 353 dtp->dt_active = 1; 354 355 if (dt_options_load(dtp) == -1) 356 return (dt_set_errno(dtp, errno)); 357 358 return (dt_aggregate_setup(dtp, agg_bufs)); 359} 360 361dtrace_workstatus_t 362dtrace_farm(dtrace_hdl_t *dtp, FILE *fp, dtrace_bufdesc_t ***cpu_bufs, dtrace_bufdesc_t ***agg_bufs, dtrace_consume_probe_f *cp, dtrace_consume_rec_f *cr, void *p) 363{ 364 int status = dtrace_status(dtp); 365 dtrace_optval_t policy = dtp->dt_options[DTRACEOPT_BUFPOLICY]; 366 dtrace_workstatus_t rval; 367 int aggcollect=0, regcollect=0; 368 369 switch (status) { 370 case DTRACE_STATUS_EXITED: 371 case DTRACE_STATUS_FILLED: 372 case DTRACE_STATUS_STOPPED: 373 /* 374 * Tracing is stopped. We now want to force dtrace_consume() 375 * and dtrace_aggregate_snap() to proceed, regardless of 376 * switchrate and aggrate. We do this by clearing the times. 377 */ 378 dtp->dt_lastswitch = 0; 379 dtp->dt_lastagg = 0; 380 rval = DTRACE_WORKSTATUS_DONE; 381 break; 382 383 case DTRACE_STATUS_NONE: 384 case DTRACE_STATUS_OKAY: 385 rval = DTRACE_WORKSTATUS_OKAY; 386 break; 387 388 case -1: 389////printf("work status error return\n"); 390 return (DTRACE_WORKSTATUS_ERROR); 391 } 392 393 if ((status == DTRACE_STATUS_NONE || status == DTRACE_STATUS_OKAY) && 394 policy != DTRACEOPT_BUFPOLICY_SWITCH) { 395 /* 396 * There either isn't any status or things are fine -- and 397 * this is a "ring" or "fill" buffer. We don't want to consume 398 * any of the trace data or snapshot the aggregations; we just 399 * return. 400 */ 401////printf("no status, or we don't 'want' to consume return\n"); 402 assert(rval == DTRACE_WORKSTATUS_OKAY); 403 return (rval); 404 } 405 406 aggcollect = dtrace_aggregate_collect(dtp, agg_bufs); 407 408 if (aggcollect < 0) { 409////printf("AGGCOLLECT work status error return\n"); 410 return (DTRACE_WORKSTATUS_ERROR); 411 } 412 413 regcollect = dtrace_collect(dtp, cpu_bufs); 414 if (regcollect < 0) { 415////printf("REGCOLLECT work status error return\n"); 416 return (DTRACE_WORKSTATUS_ERROR); 417 } 418 dtrace_analyze(dtp, fp, (regcollect>0)?*cpu_bufs:NULL, (aggcollect>0)? *agg_bufs : NULL, cp, cr, NULL); 419 420////printf("plain old return\n"); 421 return (rval); 422} 423#pragma mark ^^^ modified functions. test separate collect/analyze phases ^^^ 424