Lines Matching refs:data
265 dt_aggregate_usym(dtrace_hdl_t *dtp, uint64_t *data)
267 uint64_t pid = data[0];
268 uint64_t *pc = &data[1];
288 dt_aggregate_umod(dtrace_hdl_t *dtp, uint64_t *data)
290 uint64_t pid = data[0];
291 uint64_t *pc = &data[1];
311 dt_aggregate_sym(dtrace_hdl_t *dtp, uint64_t *data)
314 uint64_t *pc = data;
321 dt_aggregate_mod(dtrace_hdl_t *dtp, uint64_t *data)
323 uint64_t *pc = data;
351 caddr_t data = ent->dtahe_data.dtada_data;
362 agg->dtagd_varid = *((dtrace_aggvarid_t *)(uintptr_t)(data +
436 caddr_t addr, data;
556 data = aggdata->dtada_data;
563 if (addr[roffs + i] != data[roffs + i])
570 * action on the data here.
575 h->dtahe_aggregate((int64_t *)&data[roffs],
580 * If we're keeping per CPU data, apply the aggregating
584 data = aggdata->dtada_percpu[cpu];
587 h->dtahe_aggregate((int64_t *)data,
1156 dtrace_aggdata_t *data;
1171 data = &h->dtahe_data;
1178 bzero(&data->dtada_data[rec->dtrd_offset] + offs, size);
1180 if (data->dtada_percpu == NULL)
1184 bzero(data->dtada_percpu[i] + offs, size);
1247 * We're unlinked. We can safely destroy the data.
1447 const dtrace_aggdata_t **data;
1528 * We need to take two passes over the data to size our allocation, so
1529 * we'll use the first pass to also fill in the zero-filled data to be
1556 * Before we sort the data, we're going to look for any holes in our
1557 * zero-filled data. This will occur if an aggregation variable that
1610 caddr_t data;
1618 * is to format the data in the format of the
1631 data = zaggdata[i].dtahe_data.dtada_data;
1632 assert(data != NULL);
1638 * Now we need to allocate our zero-filled data for use for
1653 * If we failed to allocated some zero-filled data, we
1655 * to prevent the wrong data from being freed below.
1667 * data, we put that ID at the top of the zero-filled data.
1677 * is an lquantize() aggregating action, zero-filled data is
1685 * some prototype data -- in which case we
1694 * We don't have any prototype data. As a
1698 * zero-filled data would have prototype data
1724 * Now that we've dealt with setting up our zero-filled data, we can
1725 * allocate our sorted array, and take another pass over the data to
1803 * zero-filled data allocated earlier), check the
1807 * key; in this case, the aggregation data that we
1808 * copy will point to the zeroed data.
1835 data = alloca((naggvars + 1) * sizeof (dtrace_aggdata_t *));
1839 data[j + 1] = NULL;
1848 data[j + 1] = &bundle[i][ndx]->dtahe_data;
1852 assert(data[j + 1] != NULL);
1857 * element of data.
1860 data[0] = &bundle[i][j]->dtahe_data;
1862 if ((rval = func(data, naggvars + 1, arg)) == -1)
1909 dtrace_aggdata_t *data;
1917 data = &h->dtahe_data;
1919 bzero(&data->dtada_data[rec->dtrd_offset], rec->dtrd_size);
1921 if (data->dtada_percpu == NULL)
1925 bzero(data->dtada_percpu[i], rec->dtrd_size);