#pragma ident "@(#)dt_consume.c 1.22 05/11/29 SMI"
#include <stdlib.h>
#include <strings.h>
#include <errno.h>
#include <unistd.h>
#include <limits.h>
#include <assert.h>
#include <ctype.h>
#include <alloca.h>
#include <dt_impl.h>
static long double
dt_fabsl(long double x)
{
if (x < 0)
return (-x);
return (x);
}
static int
dt_flowindent(dtrace_hdl_t *dtp, dtrace_probedata_t *data, dtrace_epid_t last,
dtrace_bufdesc_t *buf, size_t offs)
{
dtrace_probedesc_t *pd = data->dtpda_pdesc, *npd;
dtrace_eprobedesc_t *epd = data->dtpda_edesc, *nepd;
char *p = pd->dtpd_provider, *n = pd->dtpd_name, *sub;
dtrace_flowkind_t flow = DTRACEFLOW_NONE;
const char *str = NULL;
static const char *e_str[2] = { " -> ", " => " };
static const char *r_str[2] = { " <- ", " <= " };
static const char *ent = "entry", *ret = "return";
static int entlen = 0, retlen = 0;
dtrace_epid_t next, id = epd->dtepd_epid;
int rval;
if (entlen == 0) {
assert(retlen == 0);
entlen = strlen(ent);
retlen = strlen(ret);
}
if ((sub = strstr(n, ent)) != NULL && sub[entlen] == '\0' &&
(sub == n || sub[-1] == '-')) {
flow = DTRACEFLOW_ENTRY;
str = e_str[strcmp(p, "syscall") == 0];
} else if ((sub = strstr(n, ret)) != NULL && sub[retlen] == '\0' &&
(sub == n || sub[-1] == '-')) {
flow = DTRACEFLOW_RETURN;
str = r_str[strcmp(p, "syscall") == 0];
}
if (flow == DTRACEFLOW_ENTRY) {
if ((last != DTRACE_EPIDNONE && id != last &&
pd->dtpd_id == dtp->dt_pdesc[last]->dtpd_id))
flow = DTRACEFLOW_NONE;
}
if (flow == DTRACEFLOW_RETURN) {
offs += epd->dtepd_size;
do {
if (offs >= buf->dtbd_size) {
if (buf->dtbd_oldest != 0) {
offs = 0;
} else {
goto out;
}
}
next = *(uint32_t *)((uintptr_t)buf->dtbd_data + offs);
if (next == DTRACE_EPIDNONE)
offs += sizeof (id);
} while (next == DTRACE_EPIDNONE);
if ((rval = dt_epid_lookup(dtp, next, &nepd, &npd)) != 0)
return (rval);
if (next != id && npd->dtpd_id == pd->dtpd_id)
flow = DTRACEFLOW_NONE;
}
out:
if (flow == DTRACEFLOW_ENTRY || flow == DTRACEFLOW_RETURN) {
data->dtpda_prefix = str;
} else {
data->dtpda_prefix = "| ";
}
if (flow == DTRACEFLOW_RETURN && data->dtpda_indent > 0)
data->dtpda_indent -= 2;
data->dtpda_flow = flow;
return (0);
}
static int
dt_nullprobe()
{
return (DTRACE_CONSUME_THIS);
}
static int
dt_nullrec()
{
return (DTRACE_CONSUME_NEXT);
}
int
dt_print_quantline(dtrace_hdl_t *dtp, FILE *fp, int64_t val,
uint64_t normal, long double total, char positives, char negatives)
{
long double f;
uint_t depth, len = 40;
const char *ats = "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@";
const char *spaces = " ";
assert(strlen(ats) == len && strlen(spaces) == len);
assert(!(total == 0 && (positives || negatives)));
assert(!(val < 0 && !negatives));
assert(!(val > 0 && !positives));
assert(!(val != 0 && total == 0));
if (!negatives) {
if (positives) {
f = (dt_fabsl((long double)val) * len) / total;
depth = (uint_t)(f + 0.5);
} else {
depth = 0;
}
return (dt_printf(dtp, fp, "|%s%s %-9lld\n", ats + len - depth,
spaces + depth, (long long)val / normal));
}
if (!positives) {
f = (dt_fabsl((long double)val) * len) / total;
depth = (uint_t)(f + 0.5);
return (dt_printf(dtp, fp, "%s%s| %-9lld\n", spaces + depth,
ats + len - depth, (long long)val / normal));
}
len /= 2;
ats = &ats[len];
spaces = &spaces[len];
f = (dt_fabsl((long double)val) * len) / total;
depth = (uint_t)(f + 0.5);
if (val <= 0) {
return (dt_printf(dtp, fp, "%s%s|%*s %-9lld\n", spaces + depth,
ats + len - depth, len, "", (long long)val / normal));
} else {
return (dt_printf(dtp, fp, "%20s|%s%s %-9lld\n", "",
ats + len - depth, spaces + depth,
(long long)val / normal));
}
}
int
dt_print_quantize(dtrace_hdl_t *dtp, FILE *fp, const void *addr,
size_t size, uint64_t normal)
{
const int64_t *data = addr;
int i, first_bin = 0, last_bin = DTRACE_QUANTIZE_NBUCKETS - 1;
long double total = 0;
char positives = 0, negatives = 0;
if (size != DTRACE_QUANTIZE_NBUCKETS * sizeof (uint64_t))
return (dt_set_errno(dtp, EDT_DMISMATCH));
while (first_bin < DTRACE_QUANTIZE_NBUCKETS - 1 && data[first_bin] == 0)
first_bin++;
if (first_bin == DTRACE_QUANTIZE_NBUCKETS - 1) {
first_bin = DTRACE_QUANTIZE_ZEROBUCKET - 1;
last_bin = DTRACE_QUANTIZE_ZEROBUCKET + 1;
} else {
if (first_bin > 0)
first_bin--;
while (last_bin > 0 && data[last_bin] == 0)
last_bin--;
if (last_bin < DTRACE_QUANTIZE_NBUCKETS - 1)
last_bin++;
}
for (i = first_bin; i <= last_bin; i++) {
positives |= (data[i] > 0);
negatives |= (data[i] < 0);
total += dt_fabsl((long double)data[i]);
}
if (dt_printf(dtp, fp, "\n%16s %41s %-9s\n", "value",
"------------- Distribution -------------", "count") < 0)
return (-1);
for (i = first_bin; i <= last_bin; i++) {
if (dt_printf(dtp, fp, "%16lld ",
(long long)DTRACE_QUANTIZE_BUCKETVAL(i)) < 0)
return (-1);
if (dt_print_quantline(dtp, fp, data[i], normal, total,
positives, negatives) < 0)
return (-1);
}
return (0);
}
int
dt_print_lquantize(dtrace_hdl_t *dtp, FILE *fp, const void *addr,
size_t size, uint64_t normal)
{
const int64_t *data = addr;
int i, first_bin, last_bin, base;
uint64_t arg;
long double total = 0;
uint16_t step, levels;
char positives = 0, negatives = 0;
if (size < sizeof (uint64_t))
return (dt_set_errno(dtp, EDT_DMISMATCH));
arg = *data++;
size -= sizeof (uint64_t);
base = DTRACE_LQUANTIZE_BASE(arg);
step = DTRACE_LQUANTIZE_STEP(arg);
levels = DTRACE_LQUANTIZE_LEVELS(arg);
first_bin = 0;
last_bin = levels + 1;
if (size != sizeof (uint64_t) * (levels + 2))
return (dt_set_errno(dtp, EDT_DMISMATCH));
while (first_bin <= levels + 1 && data[first_bin] == 0)
first_bin++;
if (first_bin > levels + 1) {
first_bin = 0;
last_bin = 2;
} else {
if (first_bin > 0)
first_bin--;
while (last_bin > 0 && data[last_bin] == 0)
last_bin--;
if (last_bin < levels + 1)
last_bin++;
}
for (i = first_bin; i <= last_bin; i++) {
positives |= (data[i] > 0);
negatives |= (data[i] < 0);
total += dt_fabsl((long double)data[i]);
}
if (dt_printf(dtp, fp, "\n%16s %41s %-9s\n", "value",
"------------- Distribution -------------", "count") < 0)
return (-1);
for (i = first_bin; i <= last_bin; i++) {
char c[32];
int err;
if (i == 0) {
(void) snprintf(c, sizeof (c), "< %d",
base / (uint32_t)normal);
err = dt_printf(dtp, fp, "%16s ", c);
} else if (i == levels + 1) {
(void) snprintf(c, sizeof (c), ">= %d",
base + (levels * step));
err = dt_printf(dtp, fp, "%16s ", c);
} else {
err = dt_printf(dtp, fp, "%16d ",
base + (i - 1) * step);
}
if (err < 0 || dt_print_quantline(dtp, fp, data[i], normal,
total, positives, negatives) < 0)
return (-1);
}
return (0);
}
static int
dt_print_average(dtrace_hdl_t *dtp, FILE *fp, caddr_t addr,
size_t size, uint64_t normal)
{
uint64_t *data = (uint64_t *)addr;
return (dt_printf(dtp, fp, " %16lld", data[0] ?
(long long)(data[1] / normal / data[0]) : 0));
}
int
dt_print_bytes(dtrace_hdl_t *dtp, FILE *fp, caddr_t addr,
size_t nbytes, int width, int quiet)
{
int i, j, margin = 5;
char *c = (char *)addr;
if (nbytes == 0)
return (0);
if (dtp->dt_options[DTRACEOPT_RAWBYTES] != DTRACEOPT_UNSET)
goto raw;
for (i = 0; i < nbytes; i++) {
if (isprint(c[i]) || isspace(c[i]) ||
c[i] == '\b' || c[i] == '\a')
continue;
if (c[i] == '\0' && i > 0) {
for (j = i + 1; j < nbytes; j++) {
if (c[j] != '\0')
break;
}
if (j != nbytes)
break;
if (quiet)
return (dt_printf(dtp, fp, "%s", c));
else
return (dt_printf(dtp, fp, " %-*s", width, c));
}
break;
}
if (i == nbytes) {
char *s = alloca(nbytes + 1);
bcopy(c, s, nbytes);
s[nbytes] = '\0';
return (dt_printf(dtp, fp, " %-*s", width, s));
}
raw:
if (dt_printf(dtp, fp, "\n%*s ", margin, "") < 0)
return (-1);
for (i = 0; i < 16; i++)
if (dt_printf(dtp, fp, " %c", "0123456789abcdef"[i]) < 0)
return (-1);
if (dt_printf(dtp, fp, " 0123456789abcdef\n") < 0)
return (-1);
for (i = 0; i < nbytes; i += 16) {
if (dt_printf(dtp, fp, "%*s%5x:", margin, "", i) < 0)
return (-1);
for (j = i; j < i + 16 && j < nbytes; j++) {
if (dt_printf(dtp, fp, " %02x", (uchar_t)c[j]) < 0)
return (-1);
}
while (j++ % 16) {
if (dt_printf(dtp, fp, " ") < 0)
return (-1);
}
if (dt_printf(dtp, fp, " ") < 0)
return (-1);
for (j = i; j < i + 16 && j < nbytes; j++) {
if (dt_printf(dtp, fp, "%c",
c[j] < ' ' || c[j] > '~' ? '.' : c[j]) < 0)
return (-1);
}
if (dt_printf(dtp, fp, "\n") < 0)
return (-1);
}
return (0);
}
int
dt_print_stack(dtrace_hdl_t *dtp, FILE *fp, const char *format,
caddr_t addr, int depth, int size)
{
dtrace_syminfo_t dts;
GElf_Sym sym;
int i, indent;
char c[PATH_MAX * 2];
uint64_t pc;
if (dt_printf(dtp, fp, "\n") < 0)
return (-1);
if (format == NULL)
format = "%s";
if (dtp->dt_options[DTRACEOPT_STACKINDENT] != DTRACEOPT_UNSET)
indent = (int)dtp->dt_options[DTRACEOPT_STACKINDENT];
else
indent = _dtrace_stkindent;
for (i = 0; i < depth; i++) {
switch (size) {
case sizeof (uint32_t):
pc = *((uint32_t *)addr);
break;
case sizeof (uint64_t):
pc = *((uint64_t *)addr);
break;
default:
return (dt_set_errno(dtp, EDT_BADSTACKPC));
}
if (pc == NULL)
break;
addr += size;
if (dt_printf(dtp, fp, "%*s", indent, "") < 0)
return (-1);
#if defined(__APPLE__)
if ((dtp->dt_options[DTRACEOPT_STACKSYMBOLS] != DTRACEOPT_UNSET) && dtrace_lookup_by_addr(dtp, pc, &sym, &dts) == 0)
#else
if (dtrace_lookup_by_addr(dtp, pc, &sym, &dts) == 0)
#endif
{
if (pc > sym.st_value) {
(void) snprintf(c, sizeof (c), "%s`%s+0x%llx",
dts.dts_object, dts.dts_name,
pc - sym.st_value);
} else {
(void) snprintf(c, sizeof (c), "%s`%s",
dts.dts_object, dts.dts_name);
}
} else {
#if defined(__APPLE__)
if ((dtp->dt_options[DTRACEOPT_STACKSYMBOLS] != DTRACEOPT_UNSET) && dtrace_lookup_by_addr(dtp, pc, NULL, &dts) == 0)
#else
if (dtrace_lookup_by_addr(dtp, pc, NULL, &dts) == 0)
#endif
{
(void) snprintf(c, sizeof (c), "%s`0x%llx",
dts.dts_object, pc);
} else {
(void) snprintf(c, sizeof (c), "0x%llx", pc);
}
}
if (dt_printf(dtp, fp, format, c) < 0)
return (-1);
if (dt_printf(dtp, fp, "\n") < 0)
return (-1);
}
return (0);
}
int
dt_print_ustack(dtrace_hdl_t *dtp, FILE *fp, const char *format,
caddr_t addr, uint64_t arg)
{
uint64_t *pc = (uint64_t *)addr;
uint32_t depth = DTRACE_USTACK_NFRAMES(arg);
uint32_t strsize = DTRACE_USTACK_STRSIZE(arg);
const char *strbase = addr + (depth + 1) * sizeof (uint64_t);
const char *str = strsize ? strbase : NULL;
int err = 0;
char name[PATH_MAX], objname[PATH_MAX], c[PATH_MAX * 2];
struct ps_prochandle *P;
GElf_Sym sym;
int i, indent;
pid_t pid;
if (depth == 0)
return (0);
pid = (pid_t)*pc++;
if (dt_printf(dtp, fp, "\n") < 0)
return (-1);
if (format == NULL)
format = "%s";
if (dtp->dt_options[DTRACEOPT_STACKINDENT] != DTRACEOPT_UNSET)
indent = (int)dtp->dt_options[DTRACEOPT_STACKINDENT];
else
indent = _dtrace_stkindent;
#if defined(__APPLE__)
if ((dtp->dt_options[DTRACEOPT_STACKSYMBOLS] != DTRACEOPT_UNSET) && dtp->dt_vector == NULL)
#else
if (dtp->dt_vector == NULL)
#endif
P = dt_proc_grab(dtp, pid, PGRAB_RDONLY | PGRAB_FORCE, 0);
else
P = NULL;
if (P != NULL)
dt_proc_lock(dtp, P);
for (i = 0; i < depth && pc[i] != NULL; i++) {
const prmap_t *map;
if ((err = dt_printf(dtp, fp, "%*s", indent, "")) < 0)
break;
if (P != NULL && Plookup_by_addr(P, pc[i],
name, sizeof (name), &sym) == 0) {
(void) Pobjname(P, pc[i], objname, sizeof (objname));
if (pc[i] > sym.st_value) {
(void) snprintf(c, sizeof (c),
"%s`%s+0x%llx", dt_basename(objname), name,
(u_longlong_t)(pc[i] - sym.st_value));
} else {
(void) snprintf(c, sizeof (c),
"%s`%s", dt_basename(objname), name);
}
} else if (str != NULL && str[0] != '\0' && str[0] != '@' &&
(P != NULL && ((map = Paddr_to_map(P, pc[i])) == NULL ||
(map->pr_mflags & MA_WRITE)))) {
(void) snprintf(c, sizeof (c), "%s", str);
} else {
if (P != NULL && Pobjname(P, pc[i], objname,
sizeof (objname)) != NULL) {
(void) snprintf(c, sizeof (c), "%s`0x%llx",
dt_basename(objname), (u_longlong_t)pc[i]);
} else {
(void) snprintf(c, sizeof (c), "0x%llx",
(u_longlong_t)pc[i]);
}
}
if ((err = dt_printf(dtp, fp, format, c)) < 0)
break;
if ((err = dt_printf(dtp, fp, "\n")) < 0)
break;
if (str != NULL && str[0] == '@') {
if ((err = dt_printf(dtp, fp, "%*s", indent, "")) < 0)
break;
(void) snprintf(c, sizeof (c), " [ %s ]", &str[1]);
if ((err = dt_printf(dtp, fp, format, c)) < 0)
break;
if ((err = dt_printf(dtp, fp, "\n")) < 0)
break;
}
if (str != NULL) {
str += strlen(str) + 1;
if (str - strbase >= strsize)
str = NULL;
}
}
if (P != NULL) {
dt_proc_unlock(dtp, P);
dt_proc_release(dtp, P);
}
return (err);
}
static int
dt_print_usym(dtrace_hdl_t *dtp, FILE *fp, caddr_t addr, dtrace_actkind_t act)
{
uint64_t pid = ((uint64_t *)addr)[0];
uint64_t pc = ((uint64_t *)addr)[1];
const char *format = " %-50s";
char *s;
int n, len = 256;
if (act == DTRACEACT_USYM && dtp->dt_vector == NULL) {
struct ps_prochandle *P;
if ((P = dt_proc_grab(dtp, pid,
PGRAB_RDONLY | PGRAB_FORCE, 0)) != NULL) {
GElf_Sym sym;
dt_proc_lock(dtp, P);
if (Plookup_by_addr(P, pc, NULL, 0, &sym) == 0)
pc = sym.st_value;
dt_proc_unlock(dtp, P);
dt_proc_release(dtp, P);
}
}
do {
n = len;
s = alloca(n);
} while ((len = dtrace_uaddr2str(dtp, pid, pc, s, n)) >= n);
return (dt_printf(dtp, fp, format, s));
}
int
dt_print_umod(dtrace_hdl_t *dtp, FILE *fp, const char *format, caddr_t addr)
{
uint64_t pid = ((uint64_t *)addr)[0];
uint64_t pc = ((uint64_t *)addr)[1];
int err = 0;
char objname[PATH_MAX], c[PATH_MAX * 2];
struct ps_prochandle *P;
if (format == NULL)
format = " %-50s";
if (dtp->dt_vector == NULL)
P = dt_proc_grab(dtp, pid, PGRAB_RDONLY | PGRAB_FORCE, 0);
else
P = NULL;
if (P != NULL)
dt_proc_lock(dtp, P);
if (P != NULL && Pobjname(P, pc, objname, sizeof (objname)) != NULL) {
(void) snprintf(c, sizeof (c), "%s", dt_basename(objname));
} else {
(void) snprintf(c, sizeof (c), "0x%llx", (u_longlong_t)pc);
}
err = dt_printf(dtp, fp, format, c);
if (P != NULL) {
dt_proc_unlock(dtp, P);
dt_proc_release(dtp, P);
}
return (err);
}
static int
dt_print_sym(dtrace_hdl_t *dtp, FILE *fp, const char *format, caddr_t addr)
{
uint64_t pc = *((uint64_t *)addr);
dtrace_syminfo_t dts;
GElf_Sym sym;
char c[PATH_MAX * 2];
if (format == NULL)
format = " %-50s";
if (dtrace_lookup_by_addr(dtp, pc, &sym, &dts) == 0) {
(void) snprintf(c, sizeof (c), "%s`%s",
dts.dts_object, dts.dts_name);
} else {
if (dtrace_lookup_by_addr(dtp, pc, NULL, &dts) == 0) {
(void) snprintf(c, sizeof (c), "%s`0x%llx",
dts.dts_object, (u_longlong_t)pc);
} else {
(void) snprintf(c, sizeof (c), "0x%llx",
(u_longlong_t)pc);
}
}
if (dt_printf(dtp, fp, format, c) < 0)
return (-1);
return (0);
}
int
dt_print_mod(dtrace_hdl_t *dtp, FILE *fp, const char *format, caddr_t addr)
{
uint64_t pc = *((uint64_t *)addr);
dtrace_syminfo_t dts;
char c[PATH_MAX * 2];
if (format == NULL)
format = " %-50s";
if (dtrace_lookup_by_addr(dtp, pc, NULL, &dts) == 0) {
(void) snprintf(c, sizeof (c), "%s", dts.dts_object);
} else {
(void) snprintf(c, sizeof (c), "0x%llx", (u_longlong_t)pc);
}
if (dt_printf(dtp, fp, format, c) < 0)
return (-1);
return (0);
}
typedef struct dt_normal {
dtrace_aggvarid_t dtnd_id;
uint64_t dtnd_normal;
} dt_normal_t;
static int
dt_normalize_agg(const dtrace_aggdata_t *aggdata, void *arg)
{
dt_normal_t *normal = arg;
dtrace_aggdesc_t *agg = aggdata->dtada_desc;
dtrace_aggvarid_t id = normal->dtnd_id;
if (agg->dtagd_nrecs == 0)
return (DTRACE_AGGWALK_NEXT);
if (agg->dtagd_varid != id)
return (DTRACE_AGGWALK_NEXT);
((dtrace_aggdata_t *)aggdata)->dtada_normal = normal->dtnd_normal;
return (DTRACE_AGGWALK_NORMALIZE);
}
static int
dt_normalize(dtrace_hdl_t *dtp, caddr_t base, dtrace_recdesc_t *rec)
{
dt_normal_t normal;
caddr_t addr;
addr = base + rec->dtrd_offset;
if (rec->dtrd_size != sizeof (dtrace_aggvarid_t))
return (dt_set_errno(dtp, EDT_BADNORMAL));
normal.dtnd_id = *((dtrace_aggvarid_t *)addr);
rec++;
if (rec->dtrd_action != DTRACEACT_LIBACT)
return (dt_set_errno(dtp, EDT_BADNORMAL));
if (rec->dtrd_arg != DT_ACT_NORMALIZE)
return (dt_set_errno(dtp, EDT_BADNORMAL));
addr = base + rec->dtrd_offset;
switch (rec->dtrd_size) {
case sizeof (uint64_t):
normal.dtnd_normal = *((uint64_t *)addr);
break;
case sizeof (uint32_t):
normal.dtnd_normal = *((uint32_t *)addr);
break;
case sizeof (uint16_t):
normal.dtnd_normal = *((uint16_t *)addr);
break;
case sizeof (uint8_t):
normal.dtnd_normal = *((uint8_t *)addr);
break;
default:
return (dt_set_errno(dtp, EDT_BADNORMAL));
}
(void) dtrace_aggregate_walk(dtp, dt_normalize_agg, &normal);
return (0);
}
static int
dt_denormalize_agg(const dtrace_aggdata_t *aggdata, void *arg)
{
dtrace_aggdesc_t *agg = aggdata->dtada_desc;
dtrace_aggvarid_t id = *((dtrace_aggvarid_t *)arg);
if (agg->dtagd_nrecs == 0)
return (DTRACE_AGGWALK_NEXT);
if (agg->dtagd_varid != id)
return (DTRACE_AGGWALK_NEXT);
return (DTRACE_AGGWALK_DENORMALIZE);
}
static int
dt_clear_agg(const dtrace_aggdata_t *aggdata, void *arg)
{
dtrace_aggdesc_t *agg = aggdata->dtada_desc;
dtrace_aggvarid_t id = *((dtrace_aggvarid_t *)arg);
if (agg->dtagd_nrecs == 0)
return (DTRACE_AGGWALK_NEXT);
if (agg->dtagd_varid != id)
return (DTRACE_AGGWALK_NEXT);
return (DTRACE_AGGWALK_CLEAR);
}
typedef struct dt_trunc {
dtrace_aggvarid_t dttd_id;
uint64_t dttd_remaining;
} dt_trunc_t;
static int
dt_trunc_agg(const dtrace_aggdata_t *aggdata, void *arg)
{
dt_trunc_t *trunc = arg;
dtrace_aggdesc_t *agg = aggdata->dtada_desc;
dtrace_aggvarid_t id = trunc->dttd_id;
if (agg->dtagd_nrecs == 0)
return (DTRACE_AGGWALK_NEXT);
if (agg->dtagd_varid != id)
return (DTRACE_AGGWALK_NEXT);
if (trunc->dttd_remaining == 0)
return (DTRACE_AGGWALK_REMOVE);
trunc->dttd_remaining--;
return (DTRACE_AGGWALK_NEXT);
}
static int
dt_trunc(dtrace_hdl_t *dtp, caddr_t base, dtrace_recdesc_t *rec)
{
dt_trunc_t trunc;
caddr_t addr;
int64_t remaining;
int (*func)(dtrace_hdl_t *, dtrace_aggregate_f *, void *);
addr = base + rec->dtrd_offset;
if (rec->dtrd_size != sizeof (dtrace_aggvarid_t))
return (dt_set_errno(dtp, EDT_BADTRUNC));
trunc.dttd_id = *((dtrace_aggvarid_t *)addr);
rec++;
if (rec->dtrd_action != DTRACEACT_LIBACT)
return (dt_set_errno(dtp, EDT_BADTRUNC));
if (rec->dtrd_arg != DT_ACT_TRUNC)
return (dt_set_errno(dtp, EDT_BADTRUNC));
addr = base + rec->dtrd_offset;
switch (rec->dtrd_size) {
case sizeof (uint64_t):
remaining = *((int64_t *)addr);
break;
case sizeof (uint32_t):
remaining = *((int32_t *)addr);
break;
case sizeof (uint16_t):
remaining = *((int16_t *)addr);
break;
case sizeof (uint8_t):
remaining = *((int8_t *)addr);
break;
default:
return (dt_set_errno(dtp, EDT_BADNORMAL));
}
if (remaining < 0) {
func = dtrace_aggregate_walk_valsorted;
remaining = -remaining;
} else {
func = dtrace_aggregate_walk_valrevsorted;
}
assert(remaining >= 0);
trunc.dttd_remaining = remaining;
(void) func(dtp, dt_trunc_agg, &trunc);
return (0);
}
static int
dt_print_datum(dtrace_hdl_t *dtp, FILE *fp, dtrace_recdesc_t *rec,
caddr_t addr, size_t size, uint64_t normal)
{
int err;
dtrace_actkind_t act = rec->dtrd_action;
switch (act) {
case DTRACEACT_STACK:
return (dt_print_stack(dtp, fp, NULL, addr,
rec->dtrd_arg, rec->dtrd_size / rec->dtrd_arg));
case DTRACEACT_USTACK:
case DTRACEACT_JSTACK:
return (dt_print_ustack(dtp, fp, NULL, addr, rec->dtrd_arg));
case DTRACEACT_USYM:
case DTRACEACT_UADDR:
return (dt_print_usym(dtp, fp, addr, act));
case DTRACEACT_UMOD:
return (dt_print_umod(dtp, fp, NULL, addr));
case DTRACEACT_SYM:
return (dt_print_sym(dtp, fp, NULL, addr));
case DTRACEACT_MOD:
return (dt_print_mod(dtp, fp, NULL, addr));
case DTRACEAGG_QUANTIZE:
return (dt_print_quantize(dtp, fp, addr, size, normal));
case DTRACEAGG_LQUANTIZE:
return (dt_print_lquantize(dtp, fp, addr, size, normal));
case DTRACEAGG_AVG:
return (dt_print_average(dtp, fp, addr, size, normal));
default:
break;
}
switch (size) {
case sizeof (uint64_t):
err = dt_printf(dtp, fp, " %16lld",
(long long)*((uint64_t *)addr) / normal);
break;
case sizeof (uint32_t):
err = dt_printf(dtp, fp, " %8d", *((uint32_t *)addr) /
(uint32_t)normal);
break;
case sizeof (uint16_t):
err = dt_printf(dtp, fp, " %5d", *((uint16_t *)addr) /
(uint32_t)normal);
break;
case sizeof (uint8_t):
err = dt_printf(dtp, fp, " %3d", *((uint8_t *)addr) /
(uint32_t)normal);
break;
default:
err = dt_print_bytes(dtp, fp, addr, size, 50, 0);
break;
}
return (err);
}
int
dt_print_aggs(const dtrace_aggdata_t **aggsdata, int naggvars, void *arg)
{
int i, aggact = 0;
dt_print_aggdata_t *pd = arg;
const dtrace_aggdata_t *aggdata = aggsdata[0];
dtrace_aggdesc_t *agg = aggdata->dtada_desc;
FILE *fp = pd->dtpa_fp;
dtrace_hdl_t *dtp = pd->dtpa_dtp;
dtrace_recdesc_t *rec;
dtrace_actkind_t act;
caddr_t addr;
size_t size;
for (i = 1; i < agg->dtagd_nrecs; i++) {
rec = &agg->dtagd_rec[i];
act = rec->dtrd_action;
addr = aggdata->dtada_data + rec->dtrd_offset;
size = rec->dtrd_size;
if (DTRACEACT_ISAGG(act)) {
aggact = i;
break;
}
if (dt_print_datum(dtp, fp, rec, addr, size, 1) < 0)
return (-1);
if (dt_buffered_flush(dtp, NULL, rec, aggdata,
DTRACE_BUFDATA_AGGKEY) < 0)
return (-1);
}
assert(aggact != 0);
for (i = (naggvars == 1 ? 0 : 1); i < naggvars; i++) {
uint64_t normal;
aggdata = aggsdata[i];
agg = aggdata->dtada_desc;
rec = &agg->dtagd_rec[aggact];
act = rec->dtrd_action;
addr = aggdata->dtada_data + rec->dtrd_offset;
size = rec->dtrd_size;
assert(DTRACEACT_ISAGG(act));
normal = aggdata->dtada_normal;
if (dt_print_datum(dtp, fp, rec, addr, size, normal) < 0)
return (-1);
if (dt_buffered_flush(dtp, NULL, rec, aggdata,
DTRACE_BUFDATA_AGGVAL) < 0)
return (-1);
if (!pd->dtpa_allunprint)
agg->dtagd_flags |= DTRACE_AGD_PRINTED;
}
if (dt_printf(dtp, fp, "\n") < 0)
return (-1);
if (dt_buffered_flush(dtp, NULL, NULL, aggdata,
DTRACE_BUFDATA_AGGFORMAT | DTRACE_BUFDATA_AGGLAST) < 0)
return (-1);
return (0);
}
int
dt_print_agg(const dtrace_aggdata_t *aggdata, void *arg)
{
dt_print_aggdata_t *pd = arg;
dtrace_aggdesc_t *agg = aggdata->dtada_desc;
dtrace_aggvarid_t aggvarid = pd->dtpa_id;
if (pd->dtpa_allunprint) {
if (agg->dtagd_flags & DTRACE_AGD_PRINTED)
return (0);
} else {
if (agg->dtagd_nrecs == 0)
return (0);
if (aggvarid != agg->dtagd_varid)
return (0);
}
return (dt_print_aggs(&aggdata, 1, arg));
}
int
dt_setopt(dtrace_hdl_t *dtp, const dtrace_probedata_t *data,
const char *option, const char *value)
{
int len, rval;
char *msg;
const char *errstr;
dtrace_setoptdata_t optdata;
bzero(&optdata, sizeof (optdata));
(void) dtrace_getopt(dtp, option, &optdata.dtsda_oldval);
if (dtrace_setopt(dtp, option, value) == 0) {
(void) dtrace_getopt(dtp, option, &optdata.dtsda_newval);
optdata.dtsda_probe = data;
optdata.dtsda_option = option;
optdata.dtsda_handle = dtp;
if ((rval = dt_handle_setopt(dtp, &optdata)) != 0)
return (rval);
return (0);
}
errstr = dtrace_errmsg(dtp, dtrace_errno(dtp));
len = strlen(option) + strlen(value) + strlen(errstr) + 80;
msg = alloca(len);
(void) snprintf(msg, len, "couldn't set option \"%s\" to \"%s\": %s\n",
option, value, errstr);
if ((rval = dt_handle_liberr(dtp, data, msg)) == 0)
return (0);
return (rval);
}
static int
dt_consume_cpu(dtrace_hdl_t *dtp, FILE *fp, int cpu, dtrace_bufdesc_t *buf,
dtrace_consume_probe_f *efunc, dtrace_consume_rec_f *rfunc, void *arg)
{
dtrace_epid_t id=0;
size_t offs=0, start = buf->dtbd_oldest, end = buf->dtbd_size;
int flow = (dtp->dt_options[DTRACEOPT_FLOWINDENT] != DTRACEOPT_UNSET);
int quiet = (dtp->dt_options[DTRACEOPT_QUIET] != DTRACEOPT_UNSET);
int rval=-1, i=0, n=0;
dtrace_epid_t last = DTRACE_EPIDNONE;
dtrace_probedata_t data;
uint64_t drops=0;
caddr_t addr=NULL;
bzero(&data, sizeof (data));
data.dtpda_handle = dtp;
data.dtpda_cpu = cpu;
again:
#if defined(__APPLE__)
#endif
for (offs = start; offs < end; ) {
dtrace_eprobedesc_t *epd;
id = *(uint32_t *)((uintptr_t)buf->dtbd_data + offs);
#if defined(__APPLE__)
#endif
if (id == DTRACE_EPIDNONE) {
offs += sizeof (id);
continue;
}
if ((rval = dt_epid_lookup(dtp, id, &data.dtpda_edesc,
&data.dtpda_pdesc)) != 0)
return (rval);
#if defined(__APPLE__)
#endif
epd = data.dtpda_edesc;
data.dtpda_data = buf->dtbd_data + offs;
if (data.dtpda_edesc->dtepd_uarg != DT_ECB_DEFAULT) {
rval = dt_handle(dtp, &data);
if (rval == DTRACE_CONSUME_NEXT)
goto nextepid;
if (rval == DTRACE_CONSUME_ERROR)
return (-1);
}
if (flow)
(void) dt_flowindent(dtp, &data, last, buf, offs);
rval = (*efunc)(&data, arg);
if (flow) {
if (data.dtpda_flow == DTRACEFLOW_ENTRY)
data.dtpda_indent += 2;
}
if (rval == DTRACE_CONSUME_NEXT)
goto nextepid;
if (rval == DTRACE_CONSUME_ABORT)
return (dt_set_errno(dtp, EDT_DIRABORT));
if (rval != DTRACE_CONSUME_THIS)
return (dt_set_errno(dtp, EDT_BADRVAL));
for (i = 0; i < epd->dtepd_nrecs; i++) {
dtrace_recdesc_t *rec = &epd->dtepd_rec[i];
dtrace_actkind_t act = rec->dtrd_action;
#if defined(__APPLE__)
#endif
data.dtpda_data = buf->dtbd_data + offs +
rec->dtrd_offset;
addr = data.dtpda_data;
if (act == DTRACEACT_LIBACT) {
uint64_t arg = rec->dtrd_arg;
dtrace_aggvarid_t id;
switch (arg) {
case DT_ACT_CLEAR:
id = *((dtrace_aggvarid_t *)addr);
(void) dtrace_aggregate_walk(dtp,
dt_clear_agg, &id);
continue;
case DT_ACT_DENORMALIZE:
id = *((dtrace_aggvarid_t *)addr);
(void) dtrace_aggregate_walk(dtp,
dt_denormalize_agg, &id);
continue;
case DT_ACT_FTRUNCATE:
if (fp == NULL)
continue;
(void) fflush(fp);
(void) ftruncate(fileno(fp), 0);
(void) fseeko(fp, 0, SEEK_SET);
continue;
case DT_ACT_NORMALIZE:
if (i == epd->dtepd_nrecs - 1)
return (dt_set_errno(dtp,
EDT_BADNORMAL));
if (dt_normalize(dtp,
buf->dtbd_data + offs, rec) != 0)
return (-1);
i++;
continue;
case DT_ACT_SETOPT: {
uint64_t *opts = dtp->dt_options;
dtrace_recdesc_t *valrec;
uint32_t valsize;
caddr_t val;
int rv;
if (i == epd->dtepd_nrecs - 1) {
return (dt_set_errno(dtp,
EDT_BADSETOPT));
}
valrec = &epd->dtepd_rec[++i];
valsize = valrec->dtrd_size;
if (valrec->dtrd_action != act ||
valrec->dtrd_arg != arg) {
return (dt_set_errno(dtp,
EDT_BADSETOPT));
}
if (valsize > sizeof (uint64_t)) {
val = buf->dtbd_data + offs +
valrec->dtrd_offset;
} else {
val = "1";
}
rv = dt_setopt(dtp, &data, addr, val);
if (rv != 0)
return (-1);
flow = (opts[DTRACEOPT_FLOWINDENT] !=
DTRACEOPT_UNSET);
quiet = (opts[DTRACEOPT_QUIET] !=
DTRACEOPT_UNSET);
continue;
}
case DT_ACT_TRUNC:
if (i == epd->dtepd_nrecs - 1)
return (dt_set_errno(dtp,
EDT_BADTRUNC));
if (dt_trunc(dtp,
buf->dtbd_data + offs, rec) != 0)
return (-1);
i++;
continue;
default:
continue;
}
}
rval = (*rfunc)(&data, rec, arg);
if (rval == DTRACE_CONSUME_NEXT)
continue;
if (rval == DTRACE_CONSUME_ABORT)
return (dt_set_errno(dtp, EDT_DIRABORT));
if (rval != DTRACE_CONSUME_THIS)
return (dt_set_errno(dtp, EDT_BADRVAL));
if (act == DTRACEACT_STACK) {
int depth = rec->dtrd_arg;
if (dt_print_stack(dtp, fp, NULL, addr, depth,
rec->dtrd_size / depth) < 0)
return (-1);
goto nextrec;
}
if (act == DTRACEACT_USTACK ||
act == DTRACEACT_JSTACK) {
if (dt_print_ustack(dtp, fp, NULL,
addr, rec->dtrd_arg) < 0)
return (-1);
goto nextrec;
}
if (act == DTRACEACT_SYM) {
if (dt_print_sym(dtp, fp, NULL, addr) < 0)
return (-1);
goto nextrec;
}
if (act == DTRACEACT_MOD) {
if (dt_print_mod(dtp, fp, NULL, addr) < 0)
return (-1);
goto nextrec;
}
if (act == DTRACEACT_USYM || act == DTRACEACT_UADDR) {
if (dt_print_usym(dtp, fp, addr, act) < 0)
return (-1);
goto nextrec;
}
if (act == DTRACEACT_UMOD) {
if (dt_print_umod(dtp, fp, NULL, addr) < 0)
return (-1);
goto nextrec;
}
if (DTRACEACT_ISPRINTFLIKE(act)) {
void *fmtdata;
int (*func)(dtrace_hdl_t *, FILE *, void *,
const dtrace_probedata_t *,
const dtrace_recdesc_t *, uint_t,
const void *buf, size_t);
if ((fmtdata = dt_format_lookup(dtp,
rec->dtrd_format)) == NULL)
goto nofmt;
switch (act) {
case DTRACEACT_PRINTF:
func = dtrace_fprintf;
break;
case DTRACEACT_PRINTA:
func = dtrace_fprinta;
break;
case DTRACEACT_SYSTEM:
func = dtrace_system;
break;
case DTRACEACT_FREOPEN:
func = dtrace_freopen;
break;
}
n = (*func)(dtp, fp, fmtdata, &data,
rec, epd->dtepd_nrecs - i,
(uchar_t *)buf->dtbd_data + offs,
buf->dtbd_size - offs);
if (n < 0)
return (-1);
if (n > 0)
i += n - 1;
goto nextrec;
}
nofmt:
if (act == DTRACEACT_PRINTA) {
dt_print_aggdata_t pd;
dtrace_aggvarid_t *aggvars;
int j, naggvars = 0;
size_t size = ((epd->dtepd_nrecs - i) *
sizeof (dtrace_aggvarid_t));
if ((aggvars = dt_alloc(dtp, size)) == NULL)
return (-1);
for (j = i; j < epd->dtepd_nrecs; j++) {
dtrace_recdesc_t *nrec;
caddr_t naddr;
nrec = &epd->dtepd_rec[j];
if (nrec->dtrd_uarg != rec->dtrd_uarg)
break;
if (nrec->dtrd_action != act) {
return (dt_set_errno(dtp,
EDT_BADAGG));
}
naddr = buf->dtbd_data + offs +
nrec->dtrd_offset;
aggvars[naggvars++] =
*((dtrace_aggvarid_t *)naddr);
}
i = j - 1;
bzero(&pd, sizeof (pd));
pd.dtpa_dtp = dtp;
pd.dtpa_fp = fp;
assert(naggvars >= 1);
if (naggvars == 1) {
pd.dtpa_id = aggvars[0];
dt_free(dtp, aggvars);
if (dt_printf(dtp, fp, "\n") < 0 ||
dtrace_aggregate_walk_sorted(dtp,
dt_print_agg, &pd) < 0)
return (-1);
goto nextrec;
}
if (dt_printf(dtp, fp, "\n") < 0 ||
dtrace_aggregate_walk_joined(dtp, aggvars,
naggvars, dt_print_aggs, &pd) < 0) {
dt_free(dtp, aggvars);
return (-1);
}
dt_free(dtp, aggvars);
goto nextrec;
}
switch (rec->dtrd_size) {
case sizeof (uint64_t):
n = dt_printf(dtp, fp,
quiet ? "%lld" : " %16lld",
*((unsigned long long *)addr));
break;
case sizeof (uint32_t):
n = dt_printf(dtp, fp, quiet ? "%d" : " %8d",
*((uint32_t *)addr));
break;
case sizeof (uint16_t):
n = dt_printf(dtp, fp, quiet ? "%d" : " %5d",
*((uint16_t *)addr));
break;
case sizeof (uint8_t):
n = dt_printf(dtp, fp, quiet ? "%d" : " %3d",
*((uint8_t *)addr));
break;
default:
n = dt_print_bytes(dtp, fp, addr,
rec->dtrd_size, 33, quiet);
break;
}
if (n < 0)
return (-1);
nextrec:
if (dt_buffered_flush(dtp, &data, rec, NULL, 0) < 0)
return (-1);
}
rval = (*rfunc)(&data, NULL, arg);
nextepid:
offs += epd->dtepd_size;
last = id;
#if defined(__APPLE__)
#endif
}
if (buf->dtbd_oldest != 0 && start == buf->dtbd_oldest) {
end = buf->dtbd_oldest;
start = 0;
#if defined(__APPLE__)
#endif
goto again;
}
if ((drops = buf->dtbd_drops) == 0)
return (0);
buf->dtbd_drops = 0;
#if defined(__APPLE__)
#endif
return (dt_handle_cpudrop(dtp, cpu, DTRACEDROP_PRINCIPAL, drops));
}
typedef struct dt_begin {
dtrace_consume_probe_f *dtbgn_probefunc;
dtrace_consume_rec_f *dtbgn_recfunc;
void *dtbgn_arg;
dtrace_handle_err_f *dtbgn_errhdlr;
void *dtbgn_errarg;
int dtbgn_beginonly;
} dt_begin_t;
static int
dt_consume_begin_probe(const dtrace_probedata_t *data, void *arg)
{
dt_begin_t *begin = (dt_begin_t *)arg;
dtrace_probedesc_t *pd = data->dtpda_pdesc;
int r1 = (strcmp(pd->dtpd_provider, "dtrace") == 0);
int r2 = (strcmp(pd->dtpd_name, "BEGIN") == 0);
if (begin->dtbgn_beginonly) {
if (!(r1 && r2))
return (DTRACE_CONSUME_NEXT);
} else {
if (r1 && r2)
return (DTRACE_CONSUME_NEXT);
}
return (begin->dtbgn_probefunc(data, begin->dtbgn_arg));
}
static int
dt_consume_begin_record(const dtrace_probedata_t *data,
const dtrace_recdesc_t *rec, void *arg)
{
dt_begin_t *begin = (dt_begin_t *)arg;
return (begin->dtbgn_recfunc(data, rec, begin->dtbgn_arg));
}
static int
dt_consume_begin_error(const dtrace_errdata_t *data, void *arg)
{
dt_begin_t *begin = (dt_begin_t *)arg;
dtrace_probedesc_t *pd = data->dteda_pdesc;
int r1 = (strcmp(pd->dtpd_provider, "dtrace") == 0);
int r2 = (strcmp(pd->dtpd_name, "BEGIN") == 0);
if (begin->dtbgn_beginonly) {
if (!(r1 && r2))
return (DTRACE_HANDLE_OK);
} else {
if (r1 && r2)
return (DTRACE_HANDLE_OK);
}
return (begin->dtbgn_errhdlr(data, begin->dtbgn_errarg));
}
static int
dt_consume_begin(dtrace_hdl_t *dtp, FILE *fp, dtrace_bufdesc_t *buf,
dtrace_consume_probe_f *pf, dtrace_consume_rec_f *rf, void *arg)
{
dt_begin_t begin;
processorid_t cpu = dtp->dt_beganon;
dtrace_bufdesc_t nbuf;
int rval, i;
static int max_ncpus;
dtrace_optval_t size;
dtp->dt_beganon = -1;
if (dt_ioctl(dtp, DTRACEIOC_BUFSNAP, buf) == -1) {
if (errno == ENOENT)
return (0);
#if defined(__APPLE__)
#endif
return (dt_set_errno(dtp, errno));
}
if (!dtp->dt_stopped || buf->dtbd_cpu != dtp->dt_endedon) {
#if defined(__APPLE__)
#endif
return (dt_consume_cpu(dtp, fp, cpu, buf, pf, rf, arg));
}
begin.dtbgn_probefunc = pf;
begin.dtbgn_recfunc = rf;
begin.dtbgn_arg = arg;
begin.dtbgn_beginonly = 1;
begin.dtbgn_errhdlr = dtp->dt_errhdlr;
begin.dtbgn_errarg = dtp->dt_errarg;
dtp->dt_errhdlr = dt_consume_begin_error;
dtp->dt_errarg = &begin;
#if defined(__APPLE__)
#endif
rval = dt_consume_cpu(dtp, fp, cpu, buf, dt_consume_begin_probe,
dt_consume_begin_record, &begin);
dtp->dt_errhdlr = begin.dtbgn_errhdlr;
dtp->dt_errarg = begin.dtbgn_errarg;
bzero(&nbuf, sizeof (dtrace_bufdesc_t));
(void) dtrace_getopt(dtp, "bufsize", &size);
if ((nbuf.dtbd_data = malloc(size)) == NULL)
return (dt_set_errno(dtp, EDT_NOMEM));
if (max_ncpus == 0)
max_ncpus = dt_sysconf(dtp, _SC_CPUID_MAX) + 1;
for (i = 0; i < max_ncpus; i++) {
nbuf.dtbd_cpu = i;
if (i == cpu)
continue;
if (dt_ioctl(dtp, DTRACEIOC_BUFSNAP, &nbuf) == -1) {
if (errno == ENOENT)
continue;
#if defined(__APPLE__)
#endif
free(nbuf.dtbd_data);
return (dt_set_errno(dtp, errno));
}
#if defined(__APPLE__)
#endif
if ((rval = dt_consume_cpu(dtp, fp,
i, &nbuf, pf, rf, arg)) != 0) {
free(nbuf.dtbd_data);
return (rval);
}
}
free(nbuf.dtbd_data);
begin.dtbgn_beginonly = 0;
assert(begin.dtbgn_errhdlr == dtp->dt_errhdlr);
assert(begin.dtbgn_errarg == dtp->dt_errarg);
dtp->dt_errhdlr = dt_consume_begin_error;
dtp->dt_errarg = &begin;
#if defined(__APPLE__)
#endif
rval = dt_consume_cpu(dtp, fp, cpu, buf, dt_consume_begin_probe,
dt_consume_begin_record, &begin);
dtp->dt_errhdlr = begin.dtbgn_errhdlr;
dtp->dt_errarg = begin.dtbgn_errarg;
return (rval);
}
int
dtrace_consume(dtrace_hdl_t *dtp, FILE *fp,
dtrace_consume_probe_f *pf, dtrace_consume_rec_f *rf, void *arg)
{
dtrace_bufdesc_t *buf = &dtp->dt_buf;
dtrace_optval_t size;
static int max_ncpus;
int i, rval;
dtrace_optval_t interval = dtp->dt_options[DTRACEOPT_SWITCHRATE];
hrtime_t now = gethrtime();
if (dtp->dt_lastswitch != 0) {
if (now - dtp->dt_lastswitch < interval) {
#if defined(__APPLE__)
#endif
return (0);
}
dtp->dt_lastswitch += interval;
} else {
dtp->dt_lastswitch = now;
}
if (!dtp->dt_active) {
#if defined(__APPLE__)
#endif
return (dt_set_errno(dtp, EINVAL));
}
if (max_ncpus == 0)
max_ncpus = dt_sysconf(dtp, _SC_CPUID_MAX) + 1;
if (pf == NULL)
pf = (dtrace_consume_probe_f *)dt_nullprobe;
if (rf == NULL)
rf = (dtrace_consume_rec_f *)dt_nullrec;
if (buf->dtbd_data == NULL) {
(void) dtrace_getopt(dtp, "bufsize", &size);
if ((buf->dtbd_data = malloc(size)) == NULL)
return (dt_set_errno(dtp, EDT_NOMEM));
buf->dtbd_size = size;
}
#if defined(__APPLE__)
#endif
if (dtp->dt_active && dtp->dt_beganon != -1) {
buf->dtbd_cpu = dtp->dt_beganon;
if ((rval = dt_consume_begin(dtp, fp, buf, pf, rf, arg)) != 0)
return (rval);
}
for (i = 0; i < max_ncpus; i++) {
buf->dtbd_cpu = i;
if (dtp->dt_stopped && (i == dtp->dt_endedon))
continue;
if (dt_ioctl(dtp, DTRACEIOC_BUFSNAP, buf) == -1) {
if (errno == ENOENT)
continue;
#if defined(__APPLE__)
#endif
return (dt_set_errno(dtp, errno));
}
#if defined(__APPLE__)
#endif
if ((rval = dt_consume_cpu(dtp, fp, i, buf, pf, rf, arg)) != 0)
return (rval);
}
if (!dtp->dt_stopped)
return (0);
buf->dtbd_cpu = dtp->dt_endedon;
if (dt_ioctl(dtp, DTRACEIOC_BUFSNAP, buf) == -1) {
if (errno == ENOENT)
return (0);
#if defined(__APPLE__)
#endif
return (dt_set_errno(dtp, errno));
}
#if defined(__APPLE__)
#endif
return (dt_consume_cpu(dtp, fp, dtp->dt_endedon, buf, pf, rf, arg));
}
#if defined(__APPLE__)
#pragma mark vvv modified functions. separate collect/analyze phases vvv
int
dtrace_collect(dtrace_hdl_t *dtp, dtrace_bufdesc_t ***cpu_bufs)
{
dtrace_bufdesc_t *buf;
dtrace_optval_t size;
static int max_ncpus = 0;
int i, cpuct=0;
dtrace_optval_t interval = dtp->dt_options[DTRACEOPT_SWITCHRATE];
hrtime_t now;
hrtime_t elapsed = 0ULL;
get_time:
now = gethrtime();
if (dtp->dt_lastswitch != 0) {
elapsed = now - dtp->dt_lastswitch;
i=0;
#if should_force_interval_compliance
while (elapsed < interval) {
usleep((interval-elapsed)/1000); now = gethrtime();
elapsed = now - dtp->dt_lastswitch;
i++;
}
#endif //should_force_interval_compliance
if (elapsed < interval) {
#if defined(__APPLE__)
dt_dprintf("RRRRR collect: It's not time to collect yet...%lld < %lld returning\n",elapsed, interval);
#endif
return (0);
}
dtp->dt_lastswitch += interval;
} else {
dtp->dt_lastswitch = now;
}
if (!dtp->dt_active) {
#if defined(__APPLE__)
dt_dprintf("NANA collect: It's not active anymore... returning\n");
#endif
return (dt_set_errno(dtp, EINVAL));
}
if (max_ncpus == 0)
max_ncpus = dt_sysconf(dtp, _SC_CPUID_MAX) + 1;
#if defined(__APPLE__)
dt_dprintf("Time: collect: timing (%d)...E %lld : I %lld\n",i,now - dtp->dt_lastswitch, interval);
#endif
(void) dtrace_getopt(dtp, "bufsize", &size);
if(*cpu_bufs == NULL) {
*cpu_bufs = calloc(max_ncpus+1,sizeof(dtrace_bufdesc_t *));
for (i = 0; i < max_ncpus+1; i++) {
if((*cpu_bufs)[i] == NULL) {
(*cpu_bufs)[i] = calloc(1, sizeof(dtrace_bufdesc_t));
if((*cpu_bufs)[i]==NULL)
return (dt_set_errno(dtp, EDT_NOMEM));
if(i>0) {
(*cpu_bufs)[i]->dtbd_data = malloc(size);
if((*cpu_bufs)[i]->dtbd_data==NULL)
return (dt_set_errno(dtp, EDT_NOMEM));
} else {
(*cpu_bufs)[i]->dtbd_data = NULL; }
}
}
}
for (i = 1; i < max_ncpus+1; i++) {
buf = (*cpu_bufs)[i];
buf->dtbd_size = size; buf->dtbd_cpu = i-1;
if (dt_ioctl(dtp, DTRACEIOC_BUFSNAP, buf) == -1) {
if (errno == ENOENT)
continue;
#if defined(__APPLE__)
dt_dprintf("IOIOIO collect: buf snap failed... returning\n",i-1,buf->dtbd_size);
#endif
return (dt_set_errno(dtp, errno));
}
cpuct++;
#if defined(__APPLE__)
dt_dprintf("**** collect: cpu:%d, sz: %d\n",i-1,buf->dtbd_size);
#endif
if(dtp->dt_beganon > -1 && (*cpu_bufs)[0]->dtbd_data==NULL && buf->dtbd_size > 0) {
#if defined(__APPLE__)
dt_dprintf("**B** collect: begincpu:%d, sz: %d\n",dtp->dt_beganon,buf->dtbd_size);
#endif
(*cpu_bufs)[0]->dtbd_data = malloc(size);
if((*cpu_bufs)[0]->dtbd_data==NULL)
return (dt_set_errno(dtp, EDT_NOMEM));
(*cpu_bufs)[0]->dtbd_cpu = dtp->dt_beganon;
(*cpu_bufs)[0]->dtbd_size = buf->dtbd_size;
bcopy(buf->dtbd_data,(*cpu_bufs)[0]->dtbd_data,buf->dtbd_size);
}
}
return (cpuct);
}
static int
dt_analyze_begin(dtrace_hdl_t *dtp, FILE *fp, dtrace_bufdesc_t *beginbuf, dtrace_bufdesc_t **otherbufs,
dtrace_consume_probe_f *pf, dtrace_consume_rec_f *rf, void *arg)
{
dt_begin_t begin;
processorid_t cpu = dtp->dt_beganon;
int rval;
begin.dtbgn_probefunc = pf;
begin.dtbgn_recfunc = rf;
begin.dtbgn_arg = arg;
begin.dtbgn_beginonly = 1;
begin.dtbgn_errhdlr = dtp->dt_errhdlr;
begin.dtbgn_errarg = dtp->dt_errarg;
dtp->dt_errhdlr = dt_consume_begin_error;
dtp->dt_errarg = &begin;
#if defined(__APPLE__)
dt_dprintf(">>>>>>> in analyze_begin: calling dt_consume_cpu = %d (begin bits)\n",cpu);
#endif
rval = dt_consume_cpu(dtp, fp, cpu, beginbuf, dt_consume_begin_probe,
dt_consume_begin_record, &begin);
dtp->dt_beganon = -1;
dtp->dt_errhdlr = begin.dtbgn_errhdlr;
dtp->dt_errarg = begin.dtbgn_errarg;
return (rval);
}
int
dtrace_analyze(dtrace_hdl_t *dtp, FILE *fp, dtrace_bufdesc_t **cpu_bufs,
dtrace_bufdesc_t **agg_bufs, dtrace_consume_probe_f *pf, dtrace_consume_rec_f *rf, void *arg)
{
static int max_ncpus=0;
int i, rval;
static int begincpu=-1;
dtrace_bufdesc_t *buf = NULL;
dt_begin_t begin;
if (max_ncpus == 0)
max_ncpus = dt_sysconf(dtp, _SC_CPUID_MAX) + 1;
if (pf == NULL)
pf = (dtrace_consume_probe_f *)dt_nullprobe;
if (rf == NULL)
rf = (dtrace_consume_rec_f *)dt_nullrec;
if(agg_bufs)
if (dtrace_aggregate_hash(dtp, agg_bufs) == -1)
return (DTRACE_WORKSTATUS_ERROR);
if(cpu_bufs) {
for (i = 1; i < max_ncpus+1; i++) {
#if defined(__APPLE__)
dt_dprintf("XX cpu:%d, stopped:%d, end:%d\n",i-1,dtp->dt_stopped,dtp->dt_endedon);
dt_dprintf("XXX cpu:%d sz:%d\n",i-1,(cpu_bufs[i])->dtbd_size);
#endif
if (dtp->dt_stopped) {
if (dtp->dt_beganon > -1) begincpu = dtp->dt_beganon;
#if defined(__APPLE__)
dt_dprintf("XXXX cpu:%d, bgn: %d(%d) sz: %d\n",
i-1,begincpu,dtp->dt_beganon,(cpu_bufs[begincpu+1])->dtbd_size);
dt_dprintf("---- end:%d sz: %d\n",dtp->dt_endedon,(cpu_bufs[dtp->dt_endedon+1])->dtbd_size);
#endif
if (i == dtp->dt_beganon+1) {
if((cpu_bufs[begincpu+1])->dtbd_size == 0) { #if defined(__APPLE__)
dt_dprintf(">>false positive begin: %d\n",begincpu);
#endif
dtp->dt_beganon = -1;
begincpu = -1;
continue;
}
buf = cpu_bufs[0]; if(buf->dtbd_size > 0)
if ((rval = dt_analyze_begin(dtp, fp, buf, cpu_bufs, pf, rf, arg)) != 0)
return (rval);
if(i != dtp->dt_endedon+1)
continue;
}
if(i == dtp->dt_endedon+1) {
if(i != max_ncpus)
continue;
else
break;
}
}
buf = cpu_bufs[i];
if(!dtp->dt_stopped && buf->dtbd_size > 0) {
#if defined(__APPLE__)
dt_dprintf(">>>>> calling dt_consume_cpu = %d (loop)\n",i-1);
#endif
if ((rval = dt_consume_cpu(dtp, fp, i-1, buf, pf, rf, arg)) != 0) {
return (rval);
}
if(dtp->dt_beganon == i-1) { dtp->dt_beganon = -1;
begincpu = -1;
#if defined(__APPLE__)
dt_dprintf(">>>>> consumed the begin buffer:%d (loop)\n",i-1);
#endif
}
}
}
if(dtp->dt_stopped && dtp->dt_beganon == -1 && begincpu > -1) {
buf = cpu_bufs[0];
begin.dtbgn_probefunc = pf;
begin.dtbgn_recfunc = rf;
begin.dtbgn_beginonly = 0;
begin.dtbgn_arg = arg;
begin.dtbgn_errhdlr = dtp->dt_errhdlr;
begin.dtbgn_errarg = dtp->dt_errarg;
dtp->dt_errhdlr = dt_consume_begin_error;
dtp->dt_errarg = &begin;
#if defined(__APPLE__)
dt_dprintf(">>>>>>> analyze: calling dt_consume_cpu - remainder of: %d\n",begincpu);
#endif
rval = dt_consume_cpu(dtp, fp, begincpu, buf, dt_consume_begin_probe,
dt_consume_begin_record, &begin);
if (rval != 0) {
return (rval);
}
dtp->dt_errhdlr = begin.dtbgn_errhdlr;
dtp->dt_errarg = begin.dtbgn_errarg;
if(dtp->dt_endedon == begincpu) { dtp->dt_endedon = -1;
#if defined(__APPLE__)
dt_dprintf(">>>>>>> analyze: just handled the end condition on cpu: %d (same as begin cpu)\n",begincpu);
#endif
}
begincpu = -1; }
if(dtp->dt_stopped && dtp->dt_endedon > -1 && dtp->dt_endedon != begincpu) {
buf = cpu_bufs[dtp->dt_endedon+1];
#if defined(__APPLE__)
dt_dprintf(">>>>>>> calling dt_consume_cpu = %d (ended on)\n",dtp->dt_endedon);
#endif
return (dt_consume_cpu(dtp, fp, dtp->dt_endedon, buf, pf, rf, arg));
}
}
return (0);
}
#pragma mark ^^^ modified functions. test separate collect/analyze phases ^^^
#endif //defined(__APPLE__)