17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 227c478bd9Sstevel@tonic-gate /* 237c478bd9Sstevel@tonic-gate * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate #include <stdlib.h> 307c478bd9Sstevel@tonic-gate #include <strings.h> 317c478bd9Sstevel@tonic-gate #include <errno.h> 327c478bd9Sstevel@tonic-gate #include <unistd.h> 337c478bd9Sstevel@tonic-gate #include <dt_impl.h> 347c478bd9Sstevel@tonic-gate #include <assert.h> 35*30ef842dSbmc #include <alloca.h> 36*30ef842dSbmc #include <limits.h> 377c478bd9Sstevel@tonic-gate 387c478bd9Sstevel@tonic-gate #define DTRACE_AHASHSIZE 32779 /* big 'ol prime */ 397c478bd9Sstevel@tonic-gate 40*30ef842dSbmc /* 41*30ef842dSbmc * Because qsort(3C) does not allow an argument to be passed to a comparison 42*30ef842dSbmc * function, the variables that affect comparison must regrettably be global; 43*30ef842dSbmc * they are protected by a global static lock, dt_qsort_lock. 44*30ef842dSbmc */ 45*30ef842dSbmc static pthread_mutex_t dt_qsort_lock = PTHREAD_MUTEX_INITIALIZER; 46*30ef842dSbmc 47*30ef842dSbmc static int dt_revsort; 48*30ef842dSbmc static int dt_keysort; 49*30ef842dSbmc static int dt_keypos; 50*30ef842dSbmc 51*30ef842dSbmc #define DT_LESSTHAN (dt_revsort == 0 ? -1 : 1) 52*30ef842dSbmc #define DT_GREATERTHAN (dt_revsort == 0 ? 1 : -1) 53*30ef842dSbmc 547c478bd9Sstevel@tonic-gate static void 55187eccf8Sbmc dt_aggregate_count(int64_t *existing, int64_t *new, size_t size) 567c478bd9Sstevel@tonic-gate { 577c478bd9Sstevel@tonic-gate int i; 587c478bd9Sstevel@tonic-gate 59187eccf8Sbmc for (i = 0; i < size / sizeof (int64_t); i++) 607c478bd9Sstevel@tonic-gate existing[i] = existing[i] + new[i]; 617c478bd9Sstevel@tonic-gate } 627c478bd9Sstevel@tonic-gate 637c478bd9Sstevel@tonic-gate static int 64187eccf8Sbmc dt_aggregate_countcmp(int64_t *lhs, int64_t *rhs) 657c478bd9Sstevel@tonic-gate { 66187eccf8Sbmc int64_t lvar = *lhs; 67187eccf8Sbmc int64_t rvar = *rhs; 687c478bd9Sstevel@tonic-gate 697c478bd9Sstevel@tonic-gate if (lvar < rvar) 70*30ef842dSbmc return (DT_LESSTHAN); 71*30ef842dSbmc 72*30ef842dSbmc if (lvar > rvar) 73*30ef842dSbmc return (DT_GREATERTHAN); 747c478bd9Sstevel@tonic-gate 757c478bd9Sstevel@tonic-gate return (0); 767c478bd9Sstevel@tonic-gate } 777c478bd9Sstevel@tonic-gate 787c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 797c478bd9Sstevel@tonic-gate static void 80187eccf8Sbmc dt_aggregate_min(int64_t *existing, int64_t *new, size_t size) 817c478bd9Sstevel@tonic-gate { 827c478bd9Sstevel@tonic-gate if (*new < *existing) 837c478bd9Sstevel@tonic-gate *existing = *new; 847c478bd9Sstevel@tonic-gate } 857c478bd9Sstevel@tonic-gate 867c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 877c478bd9Sstevel@tonic-gate static void 88187eccf8Sbmc dt_aggregate_max(int64_t *existing, int64_t *new, size_t size) 897c478bd9Sstevel@tonic-gate { 907c478bd9Sstevel@tonic-gate if (*new > *existing) 917c478bd9Sstevel@tonic-gate *existing = *new; 927c478bd9Sstevel@tonic-gate } 937c478bd9Sstevel@tonic-gate 947c478bd9Sstevel@tonic-gate static int 95187eccf8Sbmc dt_aggregate_averagecmp(int64_t *lhs, int64_t *rhs) 967c478bd9Sstevel@tonic-gate { 97187eccf8Sbmc int64_t lavg = lhs[0] ? (lhs[1] / lhs[0]) : 0; 98187eccf8Sbmc int64_t ravg = rhs[0] ? (rhs[1] / rhs[0]) : 0; 997c478bd9Sstevel@tonic-gate 1007c478bd9Sstevel@tonic-gate if (lavg < ravg) 101*30ef842dSbmc return (DT_LESSTHAN); 102*30ef842dSbmc 103*30ef842dSbmc if (lavg > ravg) 104*30ef842dSbmc return (DT_GREATERTHAN); 1057c478bd9Sstevel@tonic-gate 1067c478bd9Sstevel@tonic-gate return (0); 1077c478bd9Sstevel@tonic-gate } 1087c478bd9Sstevel@tonic-gate 1097c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1107c478bd9Sstevel@tonic-gate static void 111187eccf8Sbmc dt_aggregate_lquantize(int64_t *existing, int64_t *new, size_t size) 1127c478bd9Sstevel@tonic-gate { 113187eccf8Sbmc int64_t arg = *existing++; 1147c478bd9Sstevel@tonic-gate uint16_t levels = DTRACE_LQUANTIZE_LEVELS(arg); 1157c478bd9Sstevel@tonic-gate int i; 1167c478bd9Sstevel@tonic-gate 1177c478bd9Sstevel@tonic-gate for (i = 0; i <= levels + 1; i++) 1187c478bd9Sstevel@tonic-gate existing[i] = existing[i] + new[i + 1]; 1197c478bd9Sstevel@tonic-gate } 1207c478bd9Sstevel@tonic-gate 121a1b5e537Sbmc static long double 122187eccf8Sbmc dt_aggregate_lquantizedsum(int64_t *lquanta) 1237c478bd9Sstevel@tonic-gate { 124187eccf8Sbmc int64_t arg = *lquanta++; 1257c478bd9Sstevel@tonic-gate int32_t base = DTRACE_LQUANTIZE_BASE(arg); 1267c478bd9Sstevel@tonic-gate uint16_t step = DTRACE_LQUANTIZE_STEP(arg); 1277c478bd9Sstevel@tonic-gate uint16_t levels = DTRACE_LQUANTIZE_LEVELS(arg), i; 128a1b5e537Sbmc long double total = (long double)lquanta[0] * (long double)(base - 1); 1297c478bd9Sstevel@tonic-gate 1307c478bd9Sstevel@tonic-gate for (i = 0; i < levels; base += step, i++) 131a1b5e537Sbmc total += (long double)lquanta[i + 1] * (long double)base; 1327c478bd9Sstevel@tonic-gate 133a1b5e537Sbmc return (total + (long double)lquanta[levels + 1] * 134a1b5e537Sbmc (long double)(base + 1)); 1357c478bd9Sstevel@tonic-gate } 1367c478bd9Sstevel@tonic-gate 137187eccf8Sbmc static int64_t 138187eccf8Sbmc dt_aggregate_lquantizedzero(int64_t *lquanta) 139187eccf8Sbmc { 140187eccf8Sbmc int64_t arg = *lquanta++; 141187eccf8Sbmc int32_t base = DTRACE_LQUANTIZE_BASE(arg); 142187eccf8Sbmc uint16_t step = DTRACE_LQUANTIZE_STEP(arg); 143187eccf8Sbmc uint16_t levels = DTRACE_LQUANTIZE_LEVELS(arg), i; 144187eccf8Sbmc 145187eccf8Sbmc if (base - 1 == 0) 146187eccf8Sbmc return (lquanta[0]); 147187eccf8Sbmc 148187eccf8Sbmc for (i = 0; i < levels; base += step, i++) { 149187eccf8Sbmc if (base != 0) 150187eccf8Sbmc continue; 151187eccf8Sbmc 152187eccf8Sbmc return (lquanta[i + 1]); 153187eccf8Sbmc } 154187eccf8Sbmc 155187eccf8Sbmc if (base + 1 == 0) 156187eccf8Sbmc return (lquanta[levels + 1]); 157187eccf8Sbmc 158187eccf8Sbmc return (0); 159187eccf8Sbmc } 160187eccf8Sbmc 1617c478bd9Sstevel@tonic-gate static int 162187eccf8Sbmc dt_aggregate_lquantizedcmp(int64_t *lhs, int64_t *rhs) 1637c478bd9Sstevel@tonic-gate { 164a1b5e537Sbmc long double lsum = dt_aggregate_lquantizedsum(lhs); 165a1b5e537Sbmc long double rsum = dt_aggregate_lquantizedsum(rhs); 166187eccf8Sbmc int64_t lzero, rzero; 1677c478bd9Sstevel@tonic-gate 1687c478bd9Sstevel@tonic-gate if (lsum < rsum) 169*30ef842dSbmc return (DT_LESSTHAN); 170*30ef842dSbmc 171*30ef842dSbmc if (lsum > rsum) 172*30ef842dSbmc return (DT_GREATERTHAN); 1737c478bd9Sstevel@tonic-gate 174187eccf8Sbmc /* 175187eccf8Sbmc * If they're both equal, then we will compare based on the weights at 176187eccf8Sbmc * zero. If the weights at zero are equal (or if zero is not within 177187eccf8Sbmc * the range of the linear quantization), then this will be judged a 178187eccf8Sbmc * tie and will be resolved based on the key comparison. 179187eccf8Sbmc */ 180187eccf8Sbmc lzero = dt_aggregate_lquantizedzero(lhs); 181187eccf8Sbmc rzero = dt_aggregate_lquantizedzero(rhs); 182187eccf8Sbmc 183187eccf8Sbmc if (lzero < rzero) 184*30ef842dSbmc return (DT_LESSTHAN); 185*30ef842dSbmc 186*30ef842dSbmc if (lzero > rzero) 187*30ef842dSbmc return (DT_GREATERTHAN); 188187eccf8Sbmc 1897c478bd9Sstevel@tonic-gate return (0); 1907c478bd9Sstevel@tonic-gate } 1917c478bd9Sstevel@tonic-gate 1927c478bd9Sstevel@tonic-gate static int 193187eccf8Sbmc dt_aggregate_quantizedcmp(int64_t *lhs, int64_t *rhs) 1947c478bd9Sstevel@tonic-gate { 1957c478bd9Sstevel@tonic-gate int nbuckets = DTRACE_QUANTIZE_NBUCKETS, i; 196a1b5e537Sbmc long double ltotal = 0, rtotal = 0; 197187eccf8Sbmc int64_t lzero, rzero; 1987c478bd9Sstevel@tonic-gate 1997c478bd9Sstevel@tonic-gate for (i = 0; i < nbuckets; i++) { 2007c478bd9Sstevel@tonic-gate int64_t bucketval = DTRACE_QUANTIZE_BUCKETVAL(i); 2017c478bd9Sstevel@tonic-gate 202187eccf8Sbmc if (bucketval == 0) { 203187eccf8Sbmc lzero = lhs[i]; 204187eccf8Sbmc rzero = rhs[i]; 205187eccf8Sbmc } 206187eccf8Sbmc 207a1b5e537Sbmc ltotal += (long double)bucketval * (long double)lhs[i]; 208a1b5e537Sbmc rtotal += (long double)bucketval * (long double)rhs[i]; 2097c478bd9Sstevel@tonic-gate } 2107c478bd9Sstevel@tonic-gate 2117c478bd9Sstevel@tonic-gate if (ltotal < rtotal) 212*30ef842dSbmc return (DT_LESSTHAN); 213*30ef842dSbmc 214*30ef842dSbmc if (ltotal > rtotal) 215*30ef842dSbmc return (DT_GREATERTHAN); 2167c478bd9Sstevel@tonic-gate 217187eccf8Sbmc /* 218187eccf8Sbmc * If they're both equal, then we will compare based on the weights at 219187eccf8Sbmc * zero. If the weights at zero are equal, then this will be judged a 220187eccf8Sbmc * tie and will be resolved based on the key comparison. 221187eccf8Sbmc */ 222187eccf8Sbmc if (lzero < rzero) 223*30ef842dSbmc return (DT_LESSTHAN); 224*30ef842dSbmc 225*30ef842dSbmc if (lzero > rzero) 226*30ef842dSbmc return (DT_GREATERTHAN); 227187eccf8Sbmc 2287c478bd9Sstevel@tonic-gate return (0); 2297c478bd9Sstevel@tonic-gate } 2307c478bd9Sstevel@tonic-gate 231a1b5e537Sbmc static void 232a1b5e537Sbmc dt_aggregate_usym(dtrace_hdl_t *dtp, uint64_t *data) 233a1b5e537Sbmc { 234a1b5e537Sbmc uint64_t pid = data[0]; 235a1b5e537Sbmc uint64_t *pc = &data[1]; 236a1b5e537Sbmc struct ps_prochandle *P; 237a1b5e537Sbmc GElf_Sym sym; 238a1b5e537Sbmc 239a1b5e537Sbmc if (dtp->dt_vector != NULL) 240a1b5e537Sbmc return; 241a1b5e537Sbmc 242a1b5e537Sbmc if ((P = dt_proc_grab(dtp, pid, PGRAB_RDONLY | PGRAB_FORCE, 0)) == NULL) 243a1b5e537Sbmc return; 244a1b5e537Sbmc 245a1b5e537Sbmc dt_proc_lock(dtp, P); 246a1b5e537Sbmc 247a1b5e537Sbmc if (Plookup_by_addr(P, *pc, NULL, 0, &sym) == 0) 248a1b5e537Sbmc *pc = sym.st_value; 249a1b5e537Sbmc 250a1b5e537Sbmc dt_proc_unlock(dtp, P); 251a1b5e537Sbmc dt_proc_release(dtp, P); 252a1b5e537Sbmc } 253a1b5e537Sbmc 254a1b5e537Sbmc static void 255a1b5e537Sbmc dt_aggregate_umod(dtrace_hdl_t *dtp, uint64_t *data) 256a1b5e537Sbmc { 257a1b5e537Sbmc uint64_t pid = data[0]; 258a1b5e537Sbmc uint64_t *pc = &data[1]; 259a1b5e537Sbmc struct ps_prochandle *P; 260a1b5e537Sbmc const prmap_t *map; 261a1b5e537Sbmc 262a1b5e537Sbmc if (dtp->dt_vector != NULL) 263a1b5e537Sbmc return; 264a1b5e537Sbmc 265a1b5e537Sbmc if ((P = dt_proc_grab(dtp, pid, PGRAB_RDONLY | PGRAB_FORCE, 0)) == NULL) 266a1b5e537Sbmc return; 267a1b5e537Sbmc 268a1b5e537Sbmc dt_proc_lock(dtp, P); 269a1b5e537Sbmc 270a1b5e537Sbmc if ((map = Paddr_to_map(P, *pc)) != NULL) 271a1b5e537Sbmc *pc = map->pr_vaddr; 272a1b5e537Sbmc 273a1b5e537Sbmc dt_proc_unlock(dtp, P); 274a1b5e537Sbmc dt_proc_release(dtp, P); 275a1b5e537Sbmc } 276a1b5e537Sbmc 277a1b5e537Sbmc static void 278a1b5e537Sbmc dt_aggregate_sym(dtrace_hdl_t *dtp, uint64_t *data) 279a1b5e537Sbmc { 280a1b5e537Sbmc GElf_Sym sym; 281a1b5e537Sbmc uint64_t *pc = data; 282a1b5e537Sbmc 283a1b5e537Sbmc if (dtrace_lookup_by_addr(dtp, *pc, &sym, NULL) == 0) 284a1b5e537Sbmc *pc = sym.st_value; 285a1b5e537Sbmc } 286a1b5e537Sbmc 287a1b5e537Sbmc static void 288a1b5e537Sbmc dt_aggregate_mod(dtrace_hdl_t *dtp, uint64_t *data) 289a1b5e537Sbmc { 290a1b5e537Sbmc uint64_t *pc = data; 291a1b5e537Sbmc dt_module_t *dmp; 292a1b5e537Sbmc 293a1b5e537Sbmc if (dtp->dt_vector != NULL) { 294a1b5e537Sbmc /* 295a1b5e537Sbmc * We don't have a way of just getting the module for a 296a1b5e537Sbmc * vectored open, and it doesn't seem to be worth defining 297a1b5e537Sbmc * one. This means that use of mod() won't get true 298a1b5e537Sbmc * aggregation in the postmortem case (some modules may 299a1b5e537Sbmc * appear more than once in aggregation output). It seems 300a1b5e537Sbmc * unlikely that anyone will ever notice or care... 301a1b5e537Sbmc */ 302a1b5e537Sbmc return; 303a1b5e537Sbmc } 304a1b5e537Sbmc 305a1b5e537Sbmc for (dmp = dt_list_next(&dtp->dt_modlist); dmp != NULL; 306a1b5e537Sbmc dmp = dt_list_next(dmp)) { 307a1b5e537Sbmc if (*pc - dmp->dm_text_va < dmp->dm_text_size) { 308a1b5e537Sbmc *pc = dmp->dm_text_va; 309a1b5e537Sbmc return; 310a1b5e537Sbmc } 311a1b5e537Sbmc } 312a1b5e537Sbmc } 313a1b5e537Sbmc 314*30ef842dSbmc static dtrace_aggvarid_t 315*30ef842dSbmc dt_aggregate_aggvarid(dt_ahashent_t *ent) 316*30ef842dSbmc { 317*30ef842dSbmc dtrace_aggdesc_t *agg = ent->dtahe_data.dtada_desc; 318*30ef842dSbmc caddr_t data = ent->dtahe_data.dtada_data; 319*30ef842dSbmc dtrace_recdesc_t *rec = agg->dtagd_rec; 320*30ef842dSbmc 321*30ef842dSbmc /* 322*30ef842dSbmc * First, we'll check the variable ID in the aggdesc. If it's valid, 323*30ef842dSbmc * we'll return it. If not, we'll use the compiler-generated ID 324*30ef842dSbmc * present as the first record. 325*30ef842dSbmc */ 326*30ef842dSbmc if (agg->dtagd_varid != DTRACE_AGGVARIDNONE) 327*30ef842dSbmc return (agg->dtagd_varid); 328*30ef842dSbmc 329*30ef842dSbmc agg->dtagd_varid = *((dtrace_aggvarid_t *)(uintptr_t)(data + 330*30ef842dSbmc rec->dtrd_offset)); 331*30ef842dSbmc 332*30ef842dSbmc return (agg->dtagd_varid); 333*30ef842dSbmc } 334*30ef842dSbmc 335*30ef842dSbmc 3367c478bd9Sstevel@tonic-gate static int 3377c478bd9Sstevel@tonic-gate dt_aggregate_snap_cpu(dtrace_hdl_t *dtp, processorid_t cpu) 3387c478bd9Sstevel@tonic-gate { 3397c478bd9Sstevel@tonic-gate dtrace_epid_t id; 3407c478bd9Sstevel@tonic-gate uint64_t hashval; 3417c478bd9Sstevel@tonic-gate size_t offs, roffs, size, ndx; 3427c478bd9Sstevel@tonic-gate int i, j, rval; 3437c478bd9Sstevel@tonic-gate caddr_t addr, data; 3447c478bd9Sstevel@tonic-gate dtrace_recdesc_t *rec; 3457c478bd9Sstevel@tonic-gate dt_aggregate_t *agp = &dtp->dt_aggregate; 3467c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *agg; 3477c478bd9Sstevel@tonic-gate dt_ahash_t *hash = &agp->dtat_hash; 3487c478bd9Sstevel@tonic-gate dt_ahashent_t *h; 3497c478bd9Sstevel@tonic-gate dtrace_bufdesc_t b = agp->dtat_buf, *buf = &b; 3507c478bd9Sstevel@tonic-gate dtrace_aggdata_t *aggdata; 3517c478bd9Sstevel@tonic-gate int flags = agp->dtat_flags; 3527c478bd9Sstevel@tonic-gate 3537c478bd9Sstevel@tonic-gate buf->dtbd_cpu = cpu; 3547c478bd9Sstevel@tonic-gate 3557c478bd9Sstevel@tonic-gate if (dt_ioctl(dtp, DTRACEIOC_AGGSNAP, buf) == -1) { 3567c478bd9Sstevel@tonic-gate if (errno == ENOENT) { 3577c478bd9Sstevel@tonic-gate /* 3587c478bd9Sstevel@tonic-gate * If that failed with ENOENT, it may be because the 3597c478bd9Sstevel@tonic-gate * CPU was unconfigured. This is okay; we'll just 3607c478bd9Sstevel@tonic-gate * do nothing but return success. 3617c478bd9Sstevel@tonic-gate */ 3627c478bd9Sstevel@tonic-gate return (0); 3637c478bd9Sstevel@tonic-gate } 3647c478bd9Sstevel@tonic-gate 3657c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, errno)); 3667c478bd9Sstevel@tonic-gate } 3677c478bd9Sstevel@tonic-gate 3687c478bd9Sstevel@tonic-gate if (buf->dtbd_drops != 0) { 3697c478bd9Sstevel@tonic-gate if (dt_handle_cpudrop(dtp, cpu, 3707c478bd9Sstevel@tonic-gate DTRACEDROP_AGGREGATION, buf->dtbd_drops) == -1) 3717c478bd9Sstevel@tonic-gate return (-1); 3727c478bd9Sstevel@tonic-gate } 3737c478bd9Sstevel@tonic-gate 3747c478bd9Sstevel@tonic-gate if (buf->dtbd_size == 0) 3757c478bd9Sstevel@tonic-gate return (0); 3767c478bd9Sstevel@tonic-gate 3777c478bd9Sstevel@tonic-gate if (hash->dtah_hash == NULL) { 3787c478bd9Sstevel@tonic-gate size_t size; 3797c478bd9Sstevel@tonic-gate 3807c478bd9Sstevel@tonic-gate hash->dtah_size = DTRACE_AHASHSIZE; 3817c478bd9Sstevel@tonic-gate size = hash->dtah_size * sizeof (dt_ahashent_t *); 3827c478bd9Sstevel@tonic-gate 3837c478bd9Sstevel@tonic-gate if ((hash->dtah_hash = malloc(size)) == NULL) 3847c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_NOMEM)); 3857c478bd9Sstevel@tonic-gate 3867c478bd9Sstevel@tonic-gate bzero(hash->dtah_hash, size); 3877c478bd9Sstevel@tonic-gate } 3887c478bd9Sstevel@tonic-gate 3897c478bd9Sstevel@tonic-gate for (offs = 0; offs < buf->dtbd_size; ) { 3907c478bd9Sstevel@tonic-gate /* 3917c478bd9Sstevel@tonic-gate * We're guaranteed to have an ID. 3927c478bd9Sstevel@tonic-gate */ 3937c478bd9Sstevel@tonic-gate id = *((dtrace_epid_t *)((uintptr_t)buf->dtbd_data + 3947c478bd9Sstevel@tonic-gate (uintptr_t)offs)); 3957c478bd9Sstevel@tonic-gate 3967c478bd9Sstevel@tonic-gate if (id == DTRACE_AGGIDNONE) { 3977c478bd9Sstevel@tonic-gate /* 3987c478bd9Sstevel@tonic-gate * This is filler to assure proper alignment of the 3997c478bd9Sstevel@tonic-gate * next record; we simply ignore it. 4007c478bd9Sstevel@tonic-gate */ 4017c478bd9Sstevel@tonic-gate offs += sizeof (id); 4027c478bd9Sstevel@tonic-gate continue; 4037c478bd9Sstevel@tonic-gate } 4047c478bd9Sstevel@tonic-gate 4057c478bd9Sstevel@tonic-gate if ((rval = dt_aggid_lookup(dtp, id, &agg)) != 0) 4067c478bd9Sstevel@tonic-gate return (rval); 4077c478bd9Sstevel@tonic-gate 4087c478bd9Sstevel@tonic-gate addr = buf->dtbd_data + offs; 4097c478bd9Sstevel@tonic-gate size = agg->dtagd_size; 4107c478bd9Sstevel@tonic-gate hashval = 0; 4117c478bd9Sstevel@tonic-gate 4127c478bd9Sstevel@tonic-gate for (j = 0; j < agg->dtagd_nrecs - 1; j++) { 4137c478bd9Sstevel@tonic-gate rec = &agg->dtagd_rec[j]; 4147c478bd9Sstevel@tonic-gate roffs = rec->dtrd_offset; 4157c478bd9Sstevel@tonic-gate 416a1b5e537Sbmc switch (rec->dtrd_action) { 417a1b5e537Sbmc case DTRACEACT_USYM: 418a1b5e537Sbmc dt_aggregate_usym(dtp, 419a1b5e537Sbmc /* LINTED - alignment */ 420a1b5e537Sbmc (uint64_t *)&addr[roffs]); 421a1b5e537Sbmc break; 422a1b5e537Sbmc 423a1b5e537Sbmc case DTRACEACT_UMOD: 424a1b5e537Sbmc dt_aggregate_umod(dtp, 425a1b5e537Sbmc /* LINTED - alignment */ 426a1b5e537Sbmc (uint64_t *)&addr[roffs]); 427a1b5e537Sbmc break; 428a1b5e537Sbmc 429a1b5e537Sbmc case DTRACEACT_SYM: 430a1b5e537Sbmc /* LINTED - alignment */ 431a1b5e537Sbmc dt_aggregate_sym(dtp, (uint64_t *)&addr[roffs]); 432a1b5e537Sbmc break; 433a1b5e537Sbmc 434a1b5e537Sbmc case DTRACEACT_MOD: 435a1b5e537Sbmc /* LINTED - alignment */ 436a1b5e537Sbmc dt_aggregate_mod(dtp, (uint64_t *)&addr[roffs]); 437a1b5e537Sbmc break; 438a1b5e537Sbmc 439a1b5e537Sbmc default: 440a1b5e537Sbmc break; 441a1b5e537Sbmc } 442a1b5e537Sbmc 4437c478bd9Sstevel@tonic-gate for (i = 0; i < rec->dtrd_size; i++) 4447c478bd9Sstevel@tonic-gate hashval += addr[roffs + i]; 4457c478bd9Sstevel@tonic-gate } 4467c478bd9Sstevel@tonic-gate 4477c478bd9Sstevel@tonic-gate ndx = hashval % hash->dtah_size; 4487c478bd9Sstevel@tonic-gate 4497c478bd9Sstevel@tonic-gate for (h = hash->dtah_hash[ndx]; h != NULL; h = h->dtahe_next) { 4507c478bd9Sstevel@tonic-gate if (h->dtahe_hashval != hashval) 4517c478bd9Sstevel@tonic-gate continue; 4527c478bd9Sstevel@tonic-gate 4537c478bd9Sstevel@tonic-gate if (h->dtahe_size != size) 4547c478bd9Sstevel@tonic-gate continue; 4557c478bd9Sstevel@tonic-gate 4567c478bd9Sstevel@tonic-gate aggdata = &h->dtahe_data; 4577c478bd9Sstevel@tonic-gate data = aggdata->dtada_data; 4587c478bd9Sstevel@tonic-gate 4597c478bd9Sstevel@tonic-gate for (j = 0; j < agg->dtagd_nrecs - 1; j++) { 4607c478bd9Sstevel@tonic-gate rec = &agg->dtagd_rec[j]; 4617c478bd9Sstevel@tonic-gate roffs = rec->dtrd_offset; 4627c478bd9Sstevel@tonic-gate 4637c478bd9Sstevel@tonic-gate for (i = 0; i < rec->dtrd_size; i++) 4647c478bd9Sstevel@tonic-gate if (addr[roffs + i] != data[roffs + i]) 4657c478bd9Sstevel@tonic-gate goto hashnext; 4667c478bd9Sstevel@tonic-gate } 4677c478bd9Sstevel@tonic-gate 4687c478bd9Sstevel@tonic-gate /* 4697c478bd9Sstevel@tonic-gate * We found it. Now we need to apply the aggregating 4707c478bd9Sstevel@tonic-gate * action on the data here. 4717c478bd9Sstevel@tonic-gate */ 4727c478bd9Sstevel@tonic-gate rec = &agg->dtagd_rec[agg->dtagd_nrecs - 1]; 4737c478bd9Sstevel@tonic-gate roffs = rec->dtrd_offset; 4747c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 475187eccf8Sbmc h->dtahe_aggregate((int64_t *)&data[roffs], 4767c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 477187eccf8Sbmc (int64_t *)&addr[roffs], rec->dtrd_size); 4787c478bd9Sstevel@tonic-gate 4797c478bd9Sstevel@tonic-gate /* 4807c478bd9Sstevel@tonic-gate * If we're keeping per CPU data, apply the aggregating 4817c478bd9Sstevel@tonic-gate * action there as well. 4827c478bd9Sstevel@tonic-gate */ 4837c478bd9Sstevel@tonic-gate if (aggdata->dtada_percpu != NULL) { 4847c478bd9Sstevel@tonic-gate data = aggdata->dtada_percpu[cpu]; 4857c478bd9Sstevel@tonic-gate 4867c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 487187eccf8Sbmc h->dtahe_aggregate((int64_t *)data, 4887c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 489187eccf8Sbmc (int64_t *)&addr[roffs], rec->dtrd_size); 4907c478bd9Sstevel@tonic-gate } 4917c478bd9Sstevel@tonic-gate 4927c478bd9Sstevel@tonic-gate goto bufnext; 4937c478bd9Sstevel@tonic-gate hashnext: 4947c478bd9Sstevel@tonic-gate continue; 4957c478bd9Sstevel@tonic-gate } 4967c478bd9Sstevel@tonic-gate 4977c478bd9Sstevel@tonic-gate /* 4987c478bd9Sstevel@tonic-gate * If we're here, we couldn't find an entry for this record. 4997c478bd9Sstevel@tonic-gate */ 5007c478bd9Sstevel@tonic-gate if ((h = malloc(sizeof (dt_ahashent_t))) == NULL) 5017c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_NOMEM)); 5027c478bd9Sstevel@tonic-gate bzero(h, sizeof (dt_ahashent_t)); 5037c478bd9Sstevel@tonic-gate aggdata = &h->dtahe_data; 5047c478bd9Sstevel@tonic-gate 5057c478bd9Sstevel@tonic-gate if ((aggdata->dtada_data = malloc(size)) == NULL) { 5067c478bd9Sstevel@tonic-gate free(h); 5077c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_NOMEM)); 5087c478bd9Sstevel@tonic-gate } 5097c478bd9Sstevel@tonic-gate 5107c478bd9Sstevel@tonic-gate bcopy(addr, aggdata->dtada_data, size); 5117c478bd9Sstevel@tonic-gate aggdata->dtada_size = size; 5127c478bd9Sstevel@tonic-gate aggdata->dtada_desc = agg; 5137c478bd9Sstevel@tonic-gate aggdata->dtada_handle = dtp; 5147c478bd9Sstevel@tonic-gate (void) dt_epid_lookup(dtp, agg->dtagd_epid, 5157c478bd9Sstevel@tonic-gate &aggdata->dtada_edesc, &aggdata->dtada_pdesc); 5167c478bd9Sstevel@tonic-gate aggdata->dtada_normal = 1; 5177c478bd9Sstevel@tonic-gate 5187c478bd9Sstevel@tonic-gate h->dtahe_hashval = hashval; 5197c478bd9Sstevel@tonic-gate h->dtahe_size = size; 520*30ef842dSbmc (void) dt_aggregate_aggvarid(h); 5217c478bd9Sstevel@tonic-gate 5227c478bd9Sstevel@tonic-gate rec = &agg->dtagd_rec[agg->dtagd_nrecs - 1]; 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate if (flags & DTRACE_A_PERCPU) { 5257c478bd9Sstevel@tonic-gate int max_cpus = agp->dtat_maxcpu; 5267c478bd9Sstevel@tonic-gate caddr_t *percpu = malloc(max_cpus * sizeof (caddr_t)); 5277c478bd9Sstevel@tonic-gate 5287c478bd9Sstevel@tonic-gate if (percpu == NULL) { 5297c478bd9Sstevel@tonic-gate free(aggdata->dtada_data); 5307c478bd9Sstevel@tonic-gate free(h); 5317c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_NOMEM)); 5327c478bd9Sstevel@tonic-gate } 5337c478bd9Sstevel@tonic-gate 5347c478bd9Sstevel@tonic-gate for (j = 0; j < max_cpus; j++) { 5357c478bd9Sstevel@tonic-gate percpu[j] = malloc(rec->dtrd_size); 5367c478bd9Sstevel@tonic-gate 5377c478bd9Sstevel@tonic-gate if (percpu[j] == NULL) { 5387c478bd9Sstevel@tonic-gate while (--j >= 0) 5397c478bd9Sstevel@tonic-gate free(percpu[j]); 5407c478bd9Sstevel@tonic-gate 5417c478bd9Sstevel@tonic-gate free(aggdata->dtada_data); 5427c478bd9Sstevel@tonic-gate free(h); 5437c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_NOMEM)); 5447c478bd9Sstevel@tonic-gate } 5457c478bd9Sstevel@tonic-gate 5467c478bd9Sstevel@tonic-gate if (j == cpu) { 5477c478bd9Sstevel@tonic-gate bcopy(&addr[rec->dtrd_offset], 5487c478bd9Sstevel@tonic-gate percpu[j], rec->dtrd_size); 5497c478bd9Sstevel@tonic-gate } else { 5507c478bd9Sstevel@tonic-gate bzero(percpu[j], rec->dtrd_size); 5517c478bd9Sstevel@tonic-gate } 5527c478bd9Sstevel@tonic-gate } 5537c478bd9Sstevel@tonic-gate 5547c478bd9Sstevel@tonic-gate aggdata->dtada_percpu = percpu; 5557c478bd9Sstevel@tonic-gate } 5567c478bd9Sstevel@tonic-gate 5577c478bd9Sstevel@tonic-gate switch (rec->dtrd_action) { 5587c478bd9Sstevel@tonic-gate case DTRACEAGG_MIN: 5597c478bd9Sstevel@tonic-gate h->dtahe_aggregate = dt_aggregate_min; 5607c478bd9Sstevel@tonic-gate break; 5617c478bd9Sstevel@tonic-gate 5627c478bd9Sstevel@tonic-gate case DTRACEAGG_MAX: 5637c478bd9Sstevel@tonic-gate h->dtahe_aggregate = dt_aggregate_max; 5647c478bd9Sstevel@tonic-gate break; 5657c478bd9Sstevel@tonic-gate 5667c478bd9Sstevel@tonic-gate case DTRACEAGG_LQUANTIZE: 5677c478bd9Sstevel@tonic-gate h->dtahe_aggregate = dt_aggregate_lquantize; 5687c478bd9Sstevel@tonic-gate break; 5697c478bd9Sstevel@tonic-gate 5707c478bd9Sstevel@tonic-gate case DTRACEAGG_COUNT: 5717c478bd9Sstevel@tonic-gate case DTRACEAGG_SUM: 5727c478bd9Sstevel@tonic-gate case DTRACEAGG_AVG: 5737c478bd9Sstevel@tonic-gate case DTRACEAGG_QUANTIZE: 5747c478bd9Sstevel@tonic-gate h->dtahe_aggregate = dt_aggregate_count; 5757c478bd9Sstevel@tonic-gate break; 5767c478bd9Sstevel@tonic-gate 5777c478bd9Sstevel@tonic-gate default: 5787c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_BADAGG)); 5797c478bd9Sstevel@tonic-gate } 5807c478bd9Sstevel@tonic-gate 5817c478bd9Sstevel@tonic-gate if (hash->dtah_hash[ndx] != NULL) 5827c478bd9Sstevel@tonic-gate hash->dtah_hash[ndx]->dtahe_prev = h; 5837c478bd9Sstevel@tonic-gate 5847c478bd9Sstevel@tonic-gate h->dtahe_next = hash->dtah_hash[ndx]; 5857c478bd9Sstevel@tonic-gate hash->dtah_hash[ndx] = h; 5867c478bd9Sstevel@tonic-gate 5877c478bd9Sstevel@tonic-gate if (hash->dtah_all != NULL) 5887c478bd9Sstevel@tonic-gate hash->dtah_all->dtahe_prevall = h; 5897c478bd9Sstevel@tonic-gate 5907c478bd9Sstevel@tonic-gate h->dtahe_nextall = hash->dtah_all; 5917c478bd9Sstevel@tonic-gate hash->dtah_all = h; 5927c478bd9Sstevel@tonic-gate bufnext: 5937c478bd9Sstevel@tonic-gate offs += agg->dtagd_size; 5947c478bd9Sstevel@tonic-gate } 5957c478bd9Sstevel@tonic-gate 5967c478bd9Sstevel@tonic-gate return (0); 5977c478bd9Sstevel@tonic-gate } 5987c478bd9Sstevel@tonic-gate 5997c478bd9Sstevel@tonic-gate int 6007c478bd9Sstevel@tonic-gate dtrace_aggregate_snap(dtrace_hdl_t *dtp) 6017c478bd9Sstevel@tonic-gate { 6027c478bd9Sstevel@tonic-gate int i, rval; 6037c478bd9Sstevel@tonic-gate dt_aggregate_t *agp = &dtp->dt_aggregate; 6047c478bd9Sstevel@tonic-gate hrtime_t now = gethrtime(); 6057c478bd9Sstevel@tonic-gate dtrace_optval_t interval = dtp->dt_options[DTRACEOPT_AGGRATE]; 6067c478bd9Sstevel@tonic-gate 6077c478bd9Sstevel@tonic-gate if (dtp->dt_lastagg != 0) { 6087c478bd9Sstevel@tonic-gate if (now - dtp->dt_lastagg < interval) 6097c478bd9Sstevel@tonic-gate return (0); 6107c478bd9Sstevel@tonic-gate 6117c478bd9Sstevel@tonic-gate dtp->dt_lastagg += interval; 6127c478bd9Sstevel@tonic-gate } else { 6137c478bd9Sstevel@tonic-gate dtp->dt_lastagg = now; 6147c478bd9Sstevel@tonic-gate } 6157c478bd9Sstevel@tonic-gate 6167c478bd9Sstevel@tonic-gate if (!dtp->dt_active) 6177c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EINVAL)); 6187c478bd9Sstevel@tonic-gate 6197c478bd9Sstevel@tonic-gate if (agp->dtat_buf.dtbd_size == 0) 6207c478bd9Sstevel@tonic-gate return (0); 6217c478bd9Sstevel@tonic-gate 6227c478bd9Sstevel@tonic-gate for (i = 0; i < agp->dtat_ncpus; i++) { 6237c478bd9Sstevel@tonic-gate if (rval = dt_aggregate_snap_cpu(dtp, agp->dtat_cpus[i])) 6247c478bd9Sstevel@tonic-gate return (rval); 6257c478bd9Sstevel@tonic-gate } 6267c478bd9Sstevel@tonic-gate 6277c478bd9Sstevel@tonic-gate return (0); 6287c478bd9Sstevel@tonic-gate } 6297c478bd9Sstevel@tonic-gate 6307c478bd9Sstevel@tonic-gate static int 6317c478bd9Sstevel@tonic-gate dt_aggregate_hashcmp(const void *lhs, const void *rhs) 6327c478bd9Sstevel@tonic-gate { 6337c478bd9Sstevel@tonic-gate dt_ahashent_t *lh = *((dt_ahashent_t **)lhs); 6347c478bd9Sstevel@tonic-gate dt_ahashent_t *rh = *((dt_ahashent_t **)rhs); 6357c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *lagg = lh->dtahe_data.dtada_desc; 6367c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *ragg = rh->dtahe_data.dtada_desc; 6377c478bd9Sstevel@tonic-gate 6387c478bd9Sstevel@tonic-gate if (lagg->dtagd_nrecs < ragg->dtagd_nrecs) 639*30ef842dSbmc return (DT_LESSTHAN); 6407c478bd9Sstevel@tonic-gate 6417c478bd9Sstevel@tonic-gate if (lagg->dtagd_nrecs > ragg->dtagd_nrecs) 642*30ef842dSbmc return (DT_GREATERTHAN); 6437c478bd9Sstevel@tonic-gate 6447c478bd9Sstevel@tonic-gate return (0); 6457c478bd9Sstevel@tonic-gate } 6467c478bd9Sstevel@tonic-gate 6477c478bd9Sstevel@tonic-gate static int 6487c478bd9Sstevel@tonic-gate dt_aggregate_varcmp(const void *lhs, const void *rhs) 6497c478bd9Sstevel@tonic-gate { 6507c478bd9Sstevel@tonic-gate dt_ahashent_t *lh = *((dt_ahashent_t **)lhs); 6517c478bd9Sstevel@tonic-gate dt_ahashent_t *rh = *((dt_ahashent_t **)rhs); 652*30ef842dSbmc dtrace_aggvarid_t lid, rid; 6537c478bd9Sstevel@tonic-gate 654*30ef842dSbmc lid = dt_aggregate_aggvarid(lh); 655*30ef842dSbmc rid = dt_aggregate_aggvarid(rh); 6567c478bd9Sstevel@tonic-gate 6577c478bd9Sstevel@tonic-gate if (lid < rid) 658*30ef842dSbmc return (DT_LESSTHAN); 6597c478bd9Sstevel@tonic-gate 6607c478bd9Sstevel@tonic-gate if (lid > rid) 661*30ef842dSbmc return (DT_GREATERTHAN); 6627c478bd9Sstevel@tonic-gate 6637c478bd9Sstevel@tonic-gate return (0); 6647c478bd9Sstevel@tonic-gate } 6657c478bd9Sstevel@tonic-gate 6667c478bd9Sstevel@tonic-gate static int 6677c478bd9Sstevel@tonic-gate dt_aggregate_keycmp(const void *lhs, const void *rhs) 6687c478bd9Sstevel@tonic-gate { 6697c478bd9Sstevel@tonic-gate dt_ahashent_t *lh = *((dt_ahashent_t **)lhs); 6707c478bd9Sstevel@tonic-gate dt_ahashent_t *rh = *((dt_ahashent_t **)rhs); 6717c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *lagg = lh->dtahe_data.dtada_desc; 6727c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *ragg = rh->dtahe_data.dtada_desc; 6737c478bd9Sstevel@tonic-gate dtrace_recdesc_t *lrec, *rrec; 6747c478bd9Sstevel@tonic-gate char *ldata, *rdata; 675*30ef842dSbmc int rval, i, j, keypos, nrecs; 6767c478bd9Sstevel@tonic-gate 6777c478bd9Sstevel@tonic-gate if ((rval = dt_aggregate_hashcmp(lhs, rhs)) != 0) 6787c478bd9Sstevel@tonic-gate return (rval); 6797c478bd9Sstevel@tonic-gate 680*30ef842dSbmc nrecs = lagg->dtagd_nrecs - 1; 681*30ef842dSbmc assert(nrecs == ragg->dtagd_nrecs - 1); 682*30ef842dSbmc 683*30ef842dSbmc keypos = dt_keypos + 1 >= nrecs ? 0 : dt_keypos; 684*30ef842dSbmc 685*30ef842dSbmc for (i = 1; i < nrecs; i++) { 6867c478bd9Sstevel@tonic-gate uint64_t lval, rval; 687*30ef842dSbmc int ndx = i + keypos; 6887c478bd9Sstevel@tonic-gate 689*30ef842dSbmc if (ndx >= nrecs) 690*30ef842dSbmc ndx = ndx - nrecs + 1; 691*30ef842dSbmc 692*30ef842dSbmc lrec = &lagg->dtagd_rec[ndx]; 693*30ef842dSbmc rrec = &ragg->dtagd_rec[ndx]; 6947c478bd9Sstevel@tonic-gate 6957c478bd9Sstevel@tonic-gate ldata = lh->dtahe_data.dtada_data + lrec->dtrd_offset; 6967c478bd9Sstevel@tonic-gate rdata = rh->dtahe_data.dtada_data + rrec->dtrd_offset; 6977c478bd9Sstevel@tonic-gate 6987c478bd9Sstevel@tonic-gate if (lrec->dtrd_size < rrec->dtrd_size) 699*30ef842dSbmc return (DT_LESSTHAN); 7007c478bd9Sstevel@tonic-gate 7017c478bd9Sstevel@tonic-gate if (lrec->dtrd_size > rrec->dtrd_size) 702*30ef842dSbmc return (DT_GREATERTHAN); 7037c478bd9Sstevel@tonic-gate 7047c478bd9Sstevel@tonic-gate switch (lrec->dtrd_size) { 7057c478bd9Sstevel@tonic-gate case sizeof (uint64_t): 7067c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 7077c478bd9Sstevel@tonic-gate lval = *((uint64_t *)ldata); 7087c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 7097c478bd9Sstevel@tonic-gate rval = *((uint64_t *)rdata); 7107c478bd9Sstevel@tonic-gate break; 7117c478bd9Sstevel@tonic-gate 7127c478bd9Sstevel@tonic-gate case sizeof (uint32_t): 7137c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 7147c478bd9Sstevel@tonic-gate lval = *((uint32_t *)ldata); 7157c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 7167c478bd9Sstevel@tonic-gate rval = *((uint32_t *)rdata); 7177c478bd9Sstevel@tonic-gate break; 7187c478bd9Sstevel@tonic-gate 7197c478bd9Sstevel@tonic-gate case sizeof (uint16_t): 7207c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 7217c478bd9Sstevel@tonic-gate lval = *((uint16_t *)ldata); 7227c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 7237c478bd9Sstevel@tonic-gate rval = *((uint16_t *)rdata); 7247c478bd9Sstevel@tonic-gate break; 7257c478bd9Sstevel@tonic-gate 7267c478bd9Sstevel@tonic-gate case sizeof (uint8_t): 7277c478bd9Sstevel@tonic-gate lval = *((uint8_t *)ldata); 7287c478bd9Sstevel@tonic-gate rval = *((uint8_t *)rdata); 7297c478bd9Sstevel@tonic-gate break; 7307c478bd9Sstevel@tonic-gate 7317c478bd9Sstevel@tonic-gate default: 732a67d40caSbmc for (j = 0; j < lrec->dtrd_size; j++) { 733a67d40caSbmc lval = ((uint8_t *)ldata)[j]; 734a67d40caSbmc rval = ((uint8_t *)rdata)[j]; 7357c478bd9Sstevel@tonic-gate 7367c478bd9Sstevel@tonic-gate if (lval < rval) 737*30ef842dSbmc return (DT_LESSTHAN); 7387c478bd9Sstevel@tonic-gate 7397c478bd9Sstevel@tonic-gate if (lval > rval) 740*30ef842dSbmc return (DT_GREATERTHAN); 741*30ef842dSbmc 7427c478bd9Sstevel@tonic-gate } 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate continue; 7457c478bd9Sstevel@tonic-gate } 7467c478bd9Sstevel@tonic-gate 7477c478bd9Sstevel@tonic-gate if (lval < rval) 748*30ef842dSbmc return (DT_LESSTHAN); 7497c478bd9Sstevel@tonic-gate 7507c478bd9Sstevel@tonic-gate if (lval > rval) 751*30ef842dSbmc return (DT_GREATERTHAN); 7527c478bd9Sstevel@tonic-gate } 7537c478bd9Sstevel@tonic-gate 7547c478bd9Sstevel@tonic-gate return (0); 7557c478bd9Sstevel@tonic-gate } 7567c478bd9Sstevel@tonic-gate 7577c478bd9Sstevel@tonic-gate static int 7587c478bd9Sstevel@tonic-gate dt_aggregate_valcmp(const void *lhs, const void *rhs) 7597c478bd9Sstevel@tonic-gate { 7607c478bd9Sstevel@tonic-gate dt_ahashent_t *lh = *((dt_ahashent_t **)lhs); 7617c478bd9Sstevel@tonic-gate dt_ahashent_t *rh = *((dt_ahashent_t **)rhs); 7627c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *lagg = lh->dtahe_data.dtada_desc; 7637c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *ragg = rh->dtahe_data.dtada_desc; 7647c478bd9Sstevel@tonic-gate caddr_t ldata = lh->dtahe_data.dtada_data; 7657c478bd9Sstevel@tonic-gate caddr_t rdata = rh->dtahe_data.dtada_data; 7667c478bd9Sstevel@tonic-gate dtrace_recdesc_t *lrec, *rrec; 767187eccf8Sbmc int64_t *laddr, *raddr; 7687c478bd9Sstevel@tonic-gate int rval, i; 7697c478bd9Sstevel@tonic-gate 7707c478bd9Sstevel@tonic-gate if ((rval = dt_aggregate_hashcmp(lhs, rhs)) != 0) 7717c478bd9Sstevel@tonic-gate return (rval); 7727c478bd9Sstevel@tonic-gate 7737c478bd9Sstevel@tonic-gate if (lagg->dtagd_nrecs > ragg->dtagd_nrecs) 774*30ef842dSbmc return (DT_GREATERTHAN); 775*30ef842dSbmc 776*30ef842dSbmc if (lagg->dtagd_nrecs < ragg->dtagd_nrecs) 777*30ef842dSbmc return (DT_LESSTHAN); 7787c478bd9Sstevel@tonic-gate 7797c478bd9Sstevel@tonic-gate for (i = 0; i < lagg->dtagd_nrecs; i++) { 7807c478bd9Sstevel@tonic-gate lrec = &lagg->dtagd_rec[i]; 7817c478bd9Sstevel@tonic-gate rrec = &ragg->dtagd_rec[i]; 7827c478bd9Sstevel@tonic-gate 7837c478bd9Sstevel@tonic-gate if (lrec->dtrd_offset < rrec->dtrd_offset) 784*30ef842dSbmc return (DT_LESSTHAN); 7857c478bd9Sstevel@tonic-gate 7867c478bd9Sstevel@tonic-gate if (lrec->dtrd_offset > rrec->dtrd_offset) 787*30ef842dSbmc return (DT_GREATERTHAN); 7887c478bd9Sstevel@tonic-gate 7897c478bd9Sstevel@tonic-gate if (lrec->dtrd_action < rrec->dtrd_action) 790*30ef842dSbmc return (DT_LESSTHAN); 7917c478bd9Sstevel@tonic-gate 7927c478bd9Sstevel@tonic-gate if (lrec->dtrd_action > rrec->dtrd_action) 793*30ef842dSbmc return (DT_GREATERTHAN); 7947c478bd9Sstevel@tonic-gate } 7957c478bd9Sstevel@tonic-gate 796187eccf8Sbmc laddr = (int64_t *)(uintptr_t)(ldata + lrec->dtrd_offset); 797187eccf8Sbmc raddr = (int64_t *)(uintptr_t)(rdata + rrec->dtrd_offset); 7987c478bd9Sstevel@tonic-gate 7997c478bd9Sstevel@tonic-gate switch (lrec->dtrd_action) { 8007c478bd9Sstevel@tonic-gate case DTRACEAGG_AVG: 8017c478bd9Sstevel@tonic-gate rval = dt_aggregate_averagecmp(laddr, raddr); 8027c478bd9Sstevel@tonic-gate break; 8037c478bd9Sstevel@tonic-gate 8047c478bd9Sstevel@tonic-gate case DTRACEAGG_QUANTIZE: 8057c478bd9Sstevel@tonic-gate rval = dt_aggregate_quantizedcmp(laddr, raddr); 8067c478bd9Sstevel@tonic-gate break; 8077c478bd9Sstevel@tonic-gate 8087c478bd9Sstevel@tonic-gate case DTRACEAGG_LQUANTIZE: 8097c478bd9Sstevel@tonic-gate rval = dt_aggregate_lquantizedcmp(laddr, raddr); 8107c478bd9Sstevel@tonic-gate break; 8117c478bd9Sstevel@tonic-gate 8127c478bd9Sstevel@tonic-gate case DTRACEAGG_COUNT: 8137c478bd9Sstevel@tonic-gate case DTRACEAGG_SUM: 8147c478bd9Sstevel@tonic-gate case DTRACEAGG_MIN: 8157c478bd9Sstevel@tonic-gate case DTRACEAGG_MAX: 8167c478bd9Sstevel@tonic-gate rval = dt_aggregate_countcmp(laddr, raddr); 8177c478bd9Sstevel@tonic-gate break; 8187c478bd9Sstevel@tonic-gate 8197c478bd9Sstevel@tonic-gate default: 8207c478bd9Sstevel@tonic-gate assert(0); 8217c478bd9Sstevel@tonic-gate } 8227c478bd9Sstevel@tonic-gate 823*30ef842dSbmc return (rval); 824*30ef842dSbmc } 825*30ef842dSbmc 826*30ef842dSbmc static int 827*30ef842dSbmc dt_aggregate_valkeycmp(const void *lhs, const void *rhs) 828*30ef842dSbmc { 829*30ef842dSbmc int rval; 830*30ef842dSbmc 831*30ef842dSbmc if ((rval = dt_aggregate_valcmp(lhs, rhs)) != 0) 8327c478bd9Sstevel@tonic-gate return (rval); 8337c478bd9Sstevel@tonic-gate 8347c478bd9Sstevel@tonic-gate /* 8357c478bd9Sstevel@tonic-gate * If we're here, the values for the two aggregation elements are 8367c478bd9Sstevel@tonic-gate * equal. We already know that the key layout is the same for the two 8377c478bd9Sstevel@tonic-gate * elements; we must now compare the keys themselves as a tie-breaker. 8387c478bd9Sstevel@tonic-gate */ 8397c478bd9Sstevel@tonic-gate return (dt_aggregate_keycmp(lhs, rhs)); 8407c478bd9Sstevel@tonic-gate } 8417c478bd9Sstevel@tonic-gate 8427c478bd9Sstevel@tonic-gate static int 8437c478bd9Sstevel@tonic-gate dt_aggregate_keyvarcmp(const void *lhs, const void *rhs) 8447c478bd9Sstevel@tonic-gate { 8457c478bd9Sstevel@tonic-gate int rval; 8467c478bd9Sstevel@tonic-gate 8477c478bd9Sstevel@tonic-gate if ((rval = dt_aggregate_keycmp(lhs, rhs)) != 0) 8487c478bd9Sstevel@tonic-gate return (rval); 8497c478bd9Sstevel@tonic-gate 8507c478bd9Sstevel@tonic-gate return (dt_aggregate_varcmp(lhs, rhs)); 8517c478bd9Sstevel@tonic-gate } 8527c478bd9Sstevel@tonic-gate 8537c478bd9Sstevel@tonic-gate static int 8547c478bd9Sstevel@tonic-gate dt_aggregate_varkeycmp(const void *lhs, const void *rhs) 8557c478bd9Sstevel@tonic-gate { 8567c478bd9Sstevel@tonic-gate int rval; 8577c478bd9Sstevel@tonic-gate 8587c478bd9Sstevel@tonic-gate if ((rval = dt_aggregate_varcmp(lhs, rhs)) != 0) 8597c478bd9Sstevel@tonic-gate return (rval); 8607c478bd9Sstevel@tonic-gate 8617c478bd9Sstevel@tonic-gate return (dt_aggregate_keycmp(lhs, rhs)); 8627c478bd9Sstevel@tonic-gate } 8637c478bd9Sstevel@tonic-gate 8647c478bd9Sstevel@tonic-gate static int 8657c478bd9Sstevel@tonic-gate dt_aggregate_valvarcmp(const void *lhs, const void *rhs) 8667c478bd9Sstevel@tonic-gate { 8677c478bd9Sstevel@tonic-gate int rval; 8687c478bd9Sstevel@tonic-gate 869*30ef842dSbmc if ((rval = dt_aggregate_valkeycmp(lhs, rhs)) != 0) 8707c478bd9Sstevel@tonic-gate return (rval); 8717c478bd9Sstevel@tonic-gate 8727c478bd9Sstevel@tonic-gate return (dt_aggregate_varcmp(lhs, rhs)); 8737c478bd9Sstevel@tonic-gate } 8747c478bd9Sstevel@tonic-gate 8757c478bd9Sstevel@tonic-gate static int 8767c478bd9Sstevel@tonic-gate dt_aggregate_varvalcmp(const void *lhs, const void *rhs) 8777c478bd9Sstevel@tonic-gate { 8787c478bd9Sstevel@tonic-gate int rval; 8797c478bd9Sstevel@tonic-gate 8807c478bd9Sstevel@tonic-gate if ((rval = dt_aggregate_varcmp(lhs, rhs)) != 0) 8817c478bd9Sstevel@tonic-gate return (rval); 8827c478bd9Sstevel@tonic-gate 883*30ef842dSbmc return (dt_aggregate_valkeycmp(lhs, rhs)); 8847c478bd9Sstevel@tonic-gate } 8857c478bd9Sstevel@tonic-gate 8867c478bd9Sstevel@tonic-gate static int 8877c478bd9Sstevel@tonic-gate dt_aggregate_keyvarrevcmp(const void *lhs, const void *rhs) 8887c478bd9Sstevel@tonic-gate { 8897c478bd9Sstevel@tonic-gate return (dt_aggregate_keyvarcmp(rhs, lhs)); 8907c478bd9Sstevel@tonic-gate } 8917c478bd9Sstevel@tonic-gate 8927c478bd9Sstevel@tonic-gate static int 8937c478bd9Sstevel@tonic-gate dt_aggregate_varkeyrevcmp(const void *lhs, const void *rhs) 8947c478bd9Sstevel@tonic-gate { 8957c478bd9Sstevel@tonic-gate return (dt_aggregate_varkeycmp(rhs, lhs)); 8967c478bd9Sstevel@tonic-gate } 8977c478bd9Sstevel@tonic-gate 8987c478bd9Sstevel@tonic-gate static int 8997c478bd9Sstevel@tonic-gate dt_aggregate_valvarrevcmp(const void *lhs, const void *rhs) 9007c478bd9Sstevel@tonic-gate { 9017c478bd9Sstevel@tonic-gate return (dt_aggregate_valvarcmp(rhs, lhs)); 9027c478bd9Sstevel@tonic-gate } 9037c478bd9Sstevel@tonic-gate 9047c478bd9Sstevel@tonic-gate static int 9057c478bd9Sstevel@tonic-gate dt_aggregate_varvalrevcmp(const void *lhs, const void *rhs) 9067c478bd9Sstevel@tonic-gate { 9077c478bd9Sstevel@tonic-gate return (dt_aggregate_varvalcmp(rhs, lhs)); 9087c478bd9Sstevel@tonic-gate } 9097c478bd9Sstevel@tonic-gate 910*30ef842dSbmc static int 911*30ef842dSbmc dt_aggregate_bundlecmp(const void *lhs, const void *rhs) 912*30ef842dSbmc { 913*30ef842dSbmc dt_ahashent_t **lh = *((dt_ahashent_t ***)lhs); 914*30ef842dSbmc dt_ahashent_t **rh = *((dt_ahashent_t ***)rhs); 915*30ef842dSbmc int i, rval; 916*30ef842dSbmc 917*30ef842dSbmc if (dt_keysort) { 918*30ef842dSbmc /* 919*30ef842dSbmc * If we're sorting on keys, we need to scan until we find the 920*30ef842dSbmc * last entry -- that's the representative key. (The order of 921*30ef842dSbmc * the bundle is values followed by key to accommodate the 922*30ef842dSbmc * default behavior of sorting by value.) If the keys are 923*30ef842dSbmc * equal, we'll fall into the value comparison loop, below. 924*30ef842dSbmc */ 925*30ef842dSbmc for (i = 0; lh[i + 1] != NULL; i++) 926*30ef842dSbmc continue; 927*30ef842dSbmc 928*30ef842dSbmc assert(i != 0); 929*30ef842dSbmc assert(rh[i + 1] == NULL); 930*30ef842dSbmc 931*30ef842dSbmc if ((rval = dt_aggregate_keycmp(&lh[i], &rh[i])) != 0) 932*30ef842dSbmc return (rval); 933*30ef842dSbmc } 934*30ef842dSbmc 935*30ef842dSbmc for (i = 0; ; i++) { 936*30ef842dSbmc if (lh[i + 1] == NULL) { 937*30ef842dSbmc /* 938*30ef842dSbmc * All of the values are equal; if we're sorting on 939*30ef842dSbmc * keys, then we're only here because the keys were 940*30ef842dSbmc * found to be equal and these records are therefore 941*30ef842dSbmc * equal. If we're not sorting on keys, we'll use the 942*30ef842dSbmc * key comparison from the representative key as the 943*30ef842dSbmc * tie-breaker. 944*30ef842dSbmc */ 945*30ef842dSbmc if (dt_keysort) 946*30ef842dSbmc return (0); 947*30ef842dSbmc 948*30ef842dSbmc assert(i != 0); 949*30ef842dSbmc assert(rh[i + 1] == NULL); 950*30ef842dSbmc return (dt_aggregate_keycmp(&lh[i], &rh[i])); 951*30ef842dSbmc } else { 952*30ef842dSbmc if ((rval = dt_aggregate_valcmp(&lh[i], &rh[i])) != 0) 953*30ef842dSbmc return (rval); 954*30ef842dSbmc } 955*30ef842dSbmc } 956*30ef842dSbmc } 957*30ef842dSbmc 9587c478bd9Sstevel@tonic-gate int 9597c478bd9Sstevel@tonic-gate dt_aggregate_go(dtrace_hdl_t *dtp) 9607c478bd9Sstevel@tonic-gate { 9617c478bd9Sstevel@tonic-gate dt_aggregate_t *agp = &dtp->dt_aggregate; 9627c478bd9Sstevel@tonic-gate dtrace_optval_t size, cpu; 9637c478bd9Sstevel@tonic-gate dtrace_bufdesc_t *buf = &agp->dtat_buf; 9647c478bd9Sstevel@tonic-gate int rval, i; 9657c478bd9Sstevel@tonic-gate 9667c478bd9Sstevel@tonic-gate assert(agp->dtat_maxcpu == 0); 9677c478bd9Sstevel@tonic-gate assert(agp->dtat_ncpu == 0); 9687c478bd9Sstevel@tonic-gate assert(agp->dtat_cpus == NULL); 9697c478bd9Sstevel@tonic-gate 9707c478bd9Sstevel@tonic-gate agp->dtat_maxcpu = dt_sysconf(dtp, _SC_CPUID_MAX) + 1; 9717c478bd9Sstevel@tonic-gate agp->dtat_ncpu = dt_sysconf(dtp, _SC_NPROCESSORS_MAX); 9727c478bd9Sstevel@tonic-gate agp->dtat_cpus = malloc(agp->dtat_ncpu * sizeof (processorid_t)); 9737c478bd9Sstevel@tonic-gate 9747c478bd9Sstevel@tonic-gate if (agp->dtat_cpus == NULL) 9757c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_NOMEM)); 9767c478bd9Sstevel@tonic-gate 9777c478bd9Sstevel@tonic-gate /* 9787c478bd9Sstevel@tonic-gate * Use the aggregation buffer size as reloaded from the kernel. 9797c478bd9Sstevel@tonic-gate */ 9807c478bd9Sstevel@tonic-gate size = dtp->dt_options[DTRACEOPT_AGGSIZE]; 9817c478bd9Sstevel@tonic-gate 9827c478bd9Sstevel@tonic-gate rval = dtrace_getopt(dtp, "aggsize", &size); 9837c478bd9Sstevel@tonic-gate assert(rval == 0); 9847c478bd9Sstevel@tonic-gate 9857c478bd9Sstevel@tonic-gate if (size == 0 || size == DTRACEOPT_UNSET) 9867c478bd9Sstevel@tonic-gate return (0); 9877c478bd9Sstevel@tonic-gate 9887c478bd9Sstevel@tonic-gate buf = &agp->dtat_buf; 9897c478bd9Sstevel@tonic-gate buf->dtbd_size = size; 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate if ((buf->dtbd_data = malloc(buf->dtbd_size)) == NULL) 9927c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_NOMEM)); 9937c478bd9Sstevel@tonic-gate 9947c478bd9Sstevel@tonic-gate /* 9957c478bd9Sstevel@tonic-gate * Now query for the CPUs enabled. 9967c478bd9Sstevel@tonic-gate */ 9977c478bd9Sstevel@tonic-gate rval = dtrace_getopt(dtp, "cpu", &cpu); 9987c478bd9Sstevel@tonic-gate assert(rval == 0 && cpu != DTRACEOPT_UNSET); 9997c478bd9Sstevel@tonic-gate 10007c478bd9Sstevel@tonic-gate if (cpu != DTRACE_CPUALL) { 10017c478bd9Sstevel@tonic-gate assert(cpu < agp->dtat_ncpu); 10027c478bd9Sstevel@tonic-gate agp->dtat_cpus[agp->dtat_ncpus++] = (processorid_t)cpu; 10037c478bd9Sstevel@tonic-gate 10047c478bd9Sstevel@tonic-gate return (0); 10057c478bd9Sstevel@tonic-gate } 10067c478bd9Sstevel@tonic-gate 10077c478bd9Sstevel@tonic-gate agp->dtat_ncpus = 0; 10087c478bd9Sstevel@tonic-gate for (i = 0; i < agp->dtat_maxcpu; i++) { 10097c478bd9Sstevel@tonic-gate if (dt_status(dtp, i) == -1) 10107c478bd9Sstevel@tonic-gate continue; 10117c478bd9Sstevel@tonic-gate 10127c478bd9Sstevel@tonic-gate agp->dtat_cpus[agp->dtat_ncpus++] = i; 10137c478bd9Sstevel@tonic-gate } 10147c478bd9Sstevel@tonic-gate 10157c478bd9Sstevel@tonic-gate return (0); 10167c478bd9Sstevel@tonic-gate } 10177c478bd9Sstevel@tonic-gate 10187c478bd9Sstevel@tonic-gate static int 10197c478bd9Sstevel@tonic-gate dt_aggwalk_rval(dtrace_hdl_t *dtp, dt_ahashent_t *h, int rval) 10207c478bd9Sstevel@tonic-gate { 10217c478bd9Sstevel@tonic-gate dt_aggregate_t *agp = &dtp->dt_aggregate; 10227c478bd9Sstevel@tonic-gate dtrace_aggdata_t *data; 10237c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *aggdesc; 10247c478bd9Sstevel@tonic-gate dtrace_recdesc_t *rec; 10257c478bd9Sstevel@tonic-gate int i; 10267c478bd9Sstevel@tonic-gate 10277c478bd9Sstevel@tonic-gate switch (rval) { 10287c478bd9Sstevel@tonic-gate case DTRACE_AGGWALK_NEXT: 10297c478bd9Sstevel@tonic-gate break; 10307c478bd9Sstevel@tonic-gate 10317c478bd9Sstevel@tonic-gate case DTRACE_AGGWALK_CLEAR: { 10327c478bd9Sstevel@tonic-gate uint32_t size, offs = 0; 10337c478bd9Sstevel@tonic-gate 10347c478bd9Sstevel@tonic-gate aggdesc = h->dtahe_data.dtada_desc; 10357c478bd9Sstevel@tonic-gate rec = &aggdesc->dtagd_rec[aggdesc->dtagd_nrecs - 1]; 10367c478bd9Sstevel@tonic-gate size = rec->dtrd_size; 10377c478bd9Sstevel@tonic-gate data = &h->dtahe_data; 10387c478bd9Sstevel@tonic-gate 10397c478bd9Sstevel@tonic-gate if (rec->dtrd_action == DTRACEAGG_LQUANTIZE) { 10407c478bd9Sstevel@tonic-gate offs = sizeof (uint64_t); 10417c478bd9Sstevel@tonic-gate size -= sizeof (uint64_t); 10427c478bd9Sstevel@tonic-gate } 10437c478bd9Sstevel@tonic-gate 10447c478bd9Sstevel@tonic-gate bzero(&data->dtada_data[rec->dtrd_offset] + offs, size); 10457c478bd9Sstevel@tonic-gate 10467c478bd9Sstevel@tonic-gate if (data->dtada_percpu == NULL) 10477c478bd9Sstevel@tonic-gate break; 10487c478bd9Sstevel@tonic-gate 10497c478bd9Sstevel@tonic-gate for (i = 0; i < dtp->dt_aggregate.dtat_maxcpu; i++) 10507c478bd9Sstevel@tonic-gate bzero(data->dtada_percpu[i] + offs, size); 10517c478bd9Sstevel@tonic-gate break; 10527c478bd9Sstevel@tonic-gate } 10537c478bd9Sstevel@tonic-gate 10547c478bd9Sstevel@tonic-gate case DTRACE_AGGWALK_ERROR: 10557c478bd9Sstevel@tonic-gate /* 10567c478bd9Sstevel@tonic-gate * We assume that errno is already set in this case. 10577c478bd9Sstevel@tonic-gate */ 10587c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, errno)); 10597c478bd9Sstevel@tonic-gate 10607c478bd9Sstevel@tonic-gate case DTRACE_AGGWALK_ABORT: 10617c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_DIRABORT)); 10627c478bd9Sstevel@tonic-gate 10637c478bd9Sstevel@tonic-gate case DTRACE_AGGWALK_DENORMALIZE: 10647c478bd9Sstevel@tonic-gate h->dtahe_data.dtada_normal = 1; 10657c478bd9Sstevel@tonic-gate return (0); 10667c478bd9Sstevel@tonic-gate 10677c478bd9Sstevel@tonic-gate case DTRACE_AGGWALK_NORMALIZE: 10687c478bd9Sstevel@tonic-gate if (h->dtahe_data.dtada_normal == 0) { 10697c478bd9Sstevel@tonic-gate h->dtahe_data.dtada_normal = 1; 10707c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_BADRVAL)); 10717c478bd9Sstevel@tonic-gate } 10727c478bd9Sstevel@tonic-gate 10737c478bd9Sstevel@tonic-gate return (0); 10747c478bd9Sstevel@tonic-gate 10757c478bd9Sstevel@tonic-gate case DTRACE_AGGWALK_REMOVE: { 10767c478bd9Sstevel@tonic-gate dtrace_aggdata_t *aggdata = &h->dtahe_data; 10777c478bd9Sstevel@tonic-gate int i, max_cpus = agp->dtat_maxcpu; 10787c478bd9Sstevel@tonic-gate 10797c478bd9Sstevel@tonic-gate /* 10807c478bd9Sstevel@tonic-gate * First, remove this hash entry from its hash chain. 10817c478bd9Sstevel@tonic-gate */ 10827c478bd9Sstevel@tonic-gate if (h->dtahe_prev != NULL) { 10837c478bd9Sstevel@tonic-gate h->dtahe_prev->dtahe_next = h->dtahe_next; 10847c478bd9Sstevel@tonic-gate } else { 10857c478bd9Sstevel@tonic-gate dt_ahash_t *hash = &agp->dtat_hash; 10867c478bd9Sstevel@tonic-gate size_t ndx = h->dtahe_hashval % hash->dtah_size; 10877c478bd9Sstevel@tonic-gate 10887c478bd9Sstevel@tonic-gate assert(hash->dtah_hash[ndx] == h); 10897c478bd9Sstevel@tonic-gate hash->dtah_hash[ndx] = h->dtahe_next; 10907c478bd9Sstevel@tonic-gate } 10917c478bd9Sstevel@tonic-gate 10927c478bd9Sstevel@tonic-gate if (h->dtahe_next != NULL) 10937c478bd9Sstevel@tonic-gate h->dtahe_next->dtahe_prev = h->dtahe_prev; 10947c478bd9Sstevel@tonic-gate 10957c478bd9Sstevel@tonic-gate /* 10967c478bd9Sstevel@tonic-gate * Now remove it from the list of all hash entries. 10977c478bd9Sstevel@tonic-gate */ 10987c478bd9Sstevel@tonic-gate if (h->dtahe_prevall != NULL) { 10997c478bd9Sstevel@tonic-gate h->dtahe_prevall->dtahe_nextall = h->dtahe_nextall; 11007c478bd9Sstevel@tonic-gate } else { 11017c478bd9Sstevel@tonic-gate dt_ahash_t *hash = &agp->dtat_hash; 11027c478bd9Sstevel@tonic-gate 11037c478bd9Sstevel@tonic-gate assert(hash->dtah_all == h); 11047c478bd9Sstevel@tonic-gate hash->dtah_all = h->dtahe_nextall; 11057c478bd9Sstevel@tonic-gate } 11067c478bd9Sstevel@tonic-gate 11077c478bd9Sstevel@tonic-gate if (h->dtahe_nextall != NULL) 11087c478bd9Sstevel@tonic-gate h->dtahe_nextall->dtahe_prevall = h->dtahe_prevall; 11097c478bd9Sstevel@tonic-gate 11107c478bd9Sstevel@tonic-gate /* 11117c478bd9Sstevel@tonic-gate * We're unlinked. We can safely destroy the data. 11127c478bd9Sstevel@tonic-gate */ 11137c478bd9Sstevel@tonic-gate if (aggdata->dtada_percpu != NULL) { 11147c478bd9Sstevel@tonic-gate for (i = 0; i < max_cpus; i++) 11157c478bd9Sstevel@tonic-gate free(aggdata->dtada_percpu[i]); 11167c478bd9Sstevel@tonic-gate free(aggdata->dtada_percpu); 11177c478bd9Sstevel@tonic-gate } 11187c478bd9Sstevel@tonic-gate 11197c478bd9Sstevel@tonic-gate free(aggdata->dtada_data); 11207c478bd9Sstevel@tonic-gate free(h); 11217c478bd9Sstevel@tonic-gate 11227c478bd9Sstevel@tonic-gate return (0); 11237c478bd9Sstevel@tonic-gate } 11247c478bd9Sstevel@tonic-gate 11257c478bd9Sstevel@tonic-gate default: 11267c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_BADRVAL)); 11277c478bd9Sstevel@tonic-gate } 11287c478bd9Sstevel@tonic-gate 11297c478bd9Sstevel@tonic-gate return (0); 11307c478bd9Sstevel@tonic-gate } 11317c478bd9Sstevel@tonic-gate 1132*30ef842dSbmc void 1133*30ef842dSbmc dt_aggregate_qsort(dtrace_hdl_t *dtp, void *base, size_t nel, size_t width, 1134*30ef842dSbmc int (*compar)(const void *, const void *)) 1135*30ef842dSbmc { 1136*30ef842dSbmc int rev = dt_revsort, key = dt_keysort, keypos = dt_keypos; 1137*30ef842dSbmc dtrace_optval_t keyposopt = dtp->dt_options[DTRACEOPT_AGGSORTKEYPOS]; 1138*30ef842dSbmc 1139*30ef842dSbmc dt_revsort = (dtp->dt_options[DTRACEOPT_AGGSORTREV] != DTRACEOPT_UNSET); 1140*30ef842dSbmc dt_keysort = (dtp->dt_options[DTRACEOPT_AGGSORTKEY] != DTRACEOPT_UNSET); 1141*30ef842dSbmc 1142*30ef842dSbmc if (keyposopt != DTRACEOPT_UNSET && keyposopt <= INT_MAX) { 1143*30ef842dSbmc dt_keypos = (int)keyposopt; 1144*30ef842dSbmc } else { 1145*30ef842dSbmc dt_keypos = 0; 1146*30ef842dSbmc } 1147*30ef842dSbmc 1148*30ef842dSbmc if (compar == NULL) { 1149*30ef842dSbmc if (!dt_keysort) { 1150*30ef842dSbmc compar = dt_aggregate_varvalcmp; 1151*30ef842dSbmc } else { 1152*30ef842dSbmc compar = dt_aggregate_varkeycmp; 1153*30ef842dSbmc } 1154*30ef842dSbmc } 1155*30ef842dSbmc 1156*30ef842dSbmc qsort(base, nel, width, compar); 1157*30ef842dSbmc 1158*30ef842dSbmc dt_revsort = rev; 1159*30ef842dSbmc dt_keysort = key; 1160*30ef842dSbmc dt_keypos = keypos; 1161*30ef842dSbmc } 1162*30ef842dSbmc 11637c478bd9Sstevel@tonic-gate int 11647c478bd9Sstevel@tonic-gate dtrace_aggregate_walk(dtrace_hdl_t *dtp, dtrace_aggregate_f *func, void *arg) 11657c478bd9Sstevel@tonic-gate { 11667c478bd9Sstevel@tonic-gate dt_ahashent_t *h, *next; 11677c478bd9Sstevel@tonic-gate dt_ahash_t *hash = &dtp->dt_aggregate.dtat_hash; 11687c478bd9Sstevel@tonic-gate 11697c478bd9Sstevel@tonic-gate for (h = hash->dtah_all; h != NULL; h = next) { 11707c478bd9Sstevel@tonic-gate /* 11717c478bd9Sstevel@tonic-gate * dt_aggwalk_rval() can potentially remove the current hash 11727c478bd9Sstevel@tonic-gate * entry; we need to load the next hash entry before calling 11737c478bd9Sstevel@tonic-gate * into it. 11747c478bd9Sstevel@tonic-gate */ 11757c478bd9Sstevel@tonic-gate next = h->dtahe_nextall; 11767c478bd9Sstevel@tonic-gate 11777c478bd9Sstevel@tonic-gate if (dt_aggwalk_rval(dtp, h, func(&h->dtahe_data, arg)) == -1) 11787c478bd9Sstevel@tonic-gate return (-1); 11797c478bd9Sstevel@tonic-gate } 11807c478bd9Sstevel@tonic-gate 11817c478bd9Sstevel@tonic-gate return (0); 11827c478bd9Sstevel@tonic-gate } 11837c478bd9Sstevel@tonic-gate 11847c478bd9Sstevel@tonic-gate static int 11857c478bd9Sstevel@tonic-gate dt_aggregate_walk_sorted(dtrace_hdl_t *dtp, 11867c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg, 11877c478bd9Sstevel@tonic-gate int (*sfunc)(const void *, const void *)) 11887c478bd9Sstevel@tonic-gate { 11897c478bd9Sstevel@tonic-gate dt_aggregate_t *agp = &dtp->dt_aggregate; 11907c478bd9Sstevel@tonic-gate dt_ahashent_t *h, **sorted; 11917c478bd9Sstevel@tonic-gate dt_ahash_t *hash = &agp->dtat_hash; 11927c478bd9Sstevel@tonic-gate size_t i, nentries = 0; 11937c478bd9Sstevel@tonic-gate 11947c478bd9Sstevel@tonic-gate for (h = hash->dtah_all; h != NULL; h = h->dtahe_nextall) 11957c478bd9Sstevel@tonic-gate nentries++; 11967c478bd9Sstevel@tonic-gate 1197*30ef842dSbmc sorted = dt_alloc(dtp, nentries * sizeof (dt_ahashent_t *)); 11987c478bd9Sstevel@tonic-gate 11997c478bd9Sstevel@tonic-gate if (sorted == NULL) 1200*30ef842dSbmc return (-1); 12017c478bd9Sstevel@tonic-gate 12027c478bd9Sstevel@tonic-gate for (h = hash->dtah_all, i = 0; h != NULL; h = h->dtahe_nextall) 12037c478bd9Sstevel@tonic-gate sorted[i++] = h; 12047c478bd9Sstevel@tonic-gate 1205*30ef842dSbmc (void) pthread_mutex_lock(&dt_qsort_lock); 1206*30ef842dSbmc 1207*30ef842dSbmc if (sfunc == NULL) { 1208*30ef842dSbmc dt_aggregate_qsort(dtp, sorted, nentries, 1209*30ef842dSbmc sizeof (dt_ahashent_t *), NULL); 1210*30ef842dSbmc } else { 1211*30ef842dSbmc /* 1212*30ef842dSbmc * If we've been explicitly passed a sorting function, 1213*30ef842dSbmc * we'll use that -- ignoring the values of the "aggsortrev", 1214*30ef842dSbmc * "aggsortkey" and "aggsortkeypos" options. 1215*30ef842dSbmc */ 1216*30ef842dSbmc qsort(sorted, nentries, sizeof (dt_ahashent_t *), sfunc); 1217*30ef842dSbmc } 1218*30ef842dSbmc 1219*30ef842dSbmc (void) pthread_mutex_unlock(&dt_qsort_lock); 12207c478bd9Sstevel@tonic-gate 12217c478bd9Sstevel@tonic-gate for (i = 0; i < nentries; i++) { 12227c478bd9Sstevel@tonic-gate h = sorted[i]; 12237c478bd9Sstevel@tonic-gate 1224*30ef842dSbmc if (dt_aggwalk_rval(dtp, h, func(&h->dtahe_data, arg)) == -1) { 1225*30ef842dSbmc dt_free(dtp, sorted); 12267c478bd9Sstevel@tonic-gate return (-1); 1227*30ef842dSbmc } 12287c478bd9Sstevel@tonic-gate } 12297c478bd9Sstevel@tonic-gate 1230*30ef842dSbmc dt_free(dtp, sorted); 12317c478bd9Sstevel@tonic-gate return (0); 12327c478bd9Sstevel@tonic-gate } 12337c478bd9Sstevel@tonic-gate 1234*30ef842dSbmc int 1235*30ef842dSbmc dtrace_aggregate_walk_sorted(dtrace_hdl_t *dtp, 1236*30ef842dSbmc dtrace_aggregate_f *func, void *arg) 1237*30ef842dSbmc { 1238*30ef842dSbmc return (dt_aggregate_walk_sorted(dtp, func, arg, NULL)); 1239*30ef842dSbmc } 1240*30ef842dSbmc 12417c478bd9Sstevel@tonic-gate int 12427c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_keysorted(dtrace_hdl_t *dtp, 12437c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 12447c478bd9Sstevel@tonic-gate { 12457c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 12467c478bd9Sstevel@tonic-gate arg, dt_aggregate_varkeycmp)); 12477c478bd9Sstevel@tonic-gate } 12487c478bd9Sstevel@tonic-gate 12497c478bd9Sstevel@tonic-gate int 12507c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_valsorted(dtrace_hdl_t *dtp, 12517c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 12527c478bd9Sstevel@tonic-gate { 12537c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 12547c478bd9Sstevel@tonic-gate arg, dt_aggregate_varvalcmp)); 12557c478bd9Sstevel@tonic-gate } 12567c478bd9Sstevel@tonic-gate 12577c478bd9Sstevel@tonic-gate int 12587c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_keyvarsorted(dtrace_hdl_t *dtp, 12597c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 12607c478bd9Sstevel@tonic-gate { 12617c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 12627c478bd9Sstevel@tonic-gate arg, dt_aggregate_keyvarcmp)); 12637c478bd9Sstevel@tonic-gate } 12647c478bd9Sstevel@tonic-gate 12657c478bd9Sstevel@tonic-gate int 12667c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_valvarsorted(dtrace_hdl_t *dtp, 12677c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 12687c478bd9Sstevel@tonic-gate { 12697c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 12707c478bd9Sstevel@tonic-gate arg, dt_aggregate_valvarcmp)); 12717c478bd9Sstevel@tonic-gate } 12727c478bd9Sstevel@tonic-gate 12737c478bd9Sstevel@tonic-gate int 12747c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_keyrevsorted(dtrace_hdl_t *dtp, 12757c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 12767c478bd9Sstevel@tonic-gate { 12777c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 12787c478bd9Sstevel@tonic-gate arg, dt_aggregate_varkeyrevcmp)); 12797c478bd9Sstevel@tonic-gate } 12807c478bd9Sstevel@tonic-gate 12817c478bd9Sstevel@tonic-gate int 12827c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_valrevsorted(dtrace_hdl_t *dtp, 12837c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 12847c478bd9Sstevel@tonic-gate { 12857c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 12867c478bd9Sstevel@tonic-gate arg, dt_aggregate_varvalrevcmp)); 12877c478bd9Sstevel@tonic-gate } 12887c478bd9Sstevel@tonic-gate 12897c478bd9Sstevel@tonic-gate int 12907c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_keyvarrevsorted(dtrace_hdl_t *dtp, 12917c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 12927c478bd9Sstevel@tonic-gate { 12937c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 12947c478bd9Sstevel@tonic-gate arg, dt_aggregate_keyvarrevcmp)); 12957c478bd9Sstevel@tonic-gate } 12967c478bd9Sstevel@tonic-gate 12977c478bd9Sstevel@tonic-gate int 12987c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_valvarrevsorted(dtrace_hdl_t *dtp, 12997c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 13007c478bd9Sstevel@tonic-gate { 13017c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 13027c478bd9Sstevel@tonic-gate arg, dt_aggregate_valvarrevcmp)); 13037c478bd9Sstevel@tonic-gate } 13047c478bd9Sstevel@tonic-gate 1305*30ef842dSbmc int 1306*30ef842dSbmc dtrace_aggregate_walk_joined(dtrace_hdl_t *dtp, dtrace_aggvarid_t *aggvars, 1307*30ef842dSbmc int naggvars, dtrace_aggregate_walk_joined_f *func, void *arg) 1308*30ef842dSbmc { 1309*30ef842dSbmc dt_aggregate_t *agp = &dtp->dt_aggregate; 1310*30ef842dSbmc dt_ahashent_t *h, **sorted = NULL, ***bundle, **nbundle; 1311*30ef842dSbmc const dtrace_aggdata_t **data; 1312*30ef842dSbmc dt_ahashent_t *zaggdata = NULL; 1313*30ef842dSbmc dt_ahash_t *hash = &agp->dtat_hash; 1314*30ef842dSbmc size_t nentries = 0, nbundles = 0, start, zsize = 0, bundlesize; 1315*30ef842dSbmc dtrace_aggvarid_t max = 0, aggvar; 1316*30ef842dSbmc int rval = -1, *map, *remap = NULL; 1317*30ef842dSbmc int i, j; 1318*30ef842dSbmc dtrace_optval_t sortpos = dtp->dt_options[DTRACEOPT_AGGSORTPOS]; 1319*30ef842dSbmc 1320*30ef842dSbmc /* 1321*30ef842dSbmc * If the sorting position is greater than the number of aggregation 1322*30ef842dSbmc * variable IDs, we silently set it to 0. 1323*30ef842dSbmc */ 1324*30ef842dSbmc if (sortpos == DTRACEOPT_UNSET || sortpos >= naggvars) 1325*30ef842dSbmc sortpos = 0; 1326*30ef842dSbmc 1327*30ef842dSbmc /* 1328*30ef842dSbmc * First we need to translate the specified aggregation variable IDs 1329*30ef842dSbmc * into a linear map that will allow us to translate an aggregation 1330*30ef842dSbmc * variable ID into its position in the specified aggvars. 1331*30ef842dSbmc */ 1332*30ef842dSbmc for (i = 0; i < naggvars; i++) { 1333*30ef842dSbmc if (aggvars[i] == DTRACE_AGGVARIDNONE || aggvars[i] < 0) 1334*30ef842dSbmc return (dt_set_errno(dtp, EDT_BADAGGVAR)); 1335*30ef842dSbmc 1336*30ef842dSbmc if (aggvars[i] > max) 1337*30ef842dSbmc max = aggvars[i]; 1338*30ef842dSbmc } 1339*30ef842dSbmc 1340*30ef842dSbmc if ((map = dt_zalloc(dtp, (max + 1) * sizeof (int))) == NULL) 1341*30ef842dSbmc return (-1); 1342*30ef842dSbmc 1343*30ef842dSbmc zaggdata = dt_zalloc(dtp, naggvars * sizeof (dt_ahashent_t)); 1344*30ef842dSbmc 1345*30ef842dSbmc if (zaggdata == NULL) 1346*30ef842dSbmc goto out; 1347*30ef842dSbmc 1348*30ef842dSbmc for (i = 0; i < naggvars; i++) { 1349*30ef842dSbmc int ndx = i + sortpos; 1350*30ef842dSbmc 1351*30ef842dSbmc if (ndx >= naggvars) 1352*30ef842dSbmc ndx -= naggvars; 1353*30ef842dSbmc 1354*30ef842dSbmc aggvar = aggvars[ndx]; 1355*30ef842dSbmc assert(aggvar <= max); 1356*30ef842dSbmc 1357*30ef842dSbmc if (map[aggvar]) { 1358*30ef842dSbmc /* 1359*30ef842dSbmc * We have an aggregation variable that is present 1360*30ef842dSbmc * more than once in the array of aggregation 1361*30ef842dSbmc * variables. While it's unclear why one might want 1362*30ef842dSbmc * to do this, it's legal. To support this construct, 1363*30ef842dSbmc * we will allocate a remap that will indicate the 1364*30ef842dSbmc * position from which this aggregation variable 1365*30ef842dSbmc * should be pulled. (That is, where the remap will 1366*30ef842dSbmc * map from one position to another.) 1367*30ef842dSbmc */ 1368*30ef842dSbmc if (remap == NULL) { 1369*30ef842dSbmc remap = dt_zalloc(dtp, naggvars * sizeof (int)); 1370*30ef842dSbmc 1371*30ef842dSbmc if (remap == NULL) 1372*30ef842dSbmc goto out; 1373*30ef842dSbmc } 1374*30ef842dSbmc 1375*30ef842dSbmc /* 1376*30ef842dSbmc * Given that the variable is already present, assert 1377*30ef842dSbmc * that following through the mapping and adjusting 1378*30ef842dSbmc * for the sort position yields the same aggregation 1379*30ef842dSbmc * variable ID. 1380*30ef842dSbmc */ 1381*30ef842dSbmc assert(aggvars[(map[aggvar] - 1 + sortpos) % 1382*30ef842dSbmc naggvars] == aggvars[ndx]); 1383*30ef842dSbmc 1384*30ef842dSbmc remap[i] = map[aggvar]; 1385*30ef842dSbmc continue; 1386*30ef842dSbmc } 1387*30ef842dSbmc 1388*30ef842dSbmc map[aggvar] = i + 1; 1389*30ef842dSbmc } 1390*30ef842dSbmc 1391*30ef842dSbmc /* 1392*30ef842dSbmc * We need to take two passes over the data to size our allocation, so 1393*30ef842dSbmc * we'll use the first pass to also fill in the zero-filled data to be 1394*30ef842dSbmc * used to properly format a zero-valued aggregation. 1395*30ef842dSbmc */ 1396*30ef842dSbmc for (h = hash->dtah_all; h != NULL; h = h->dtahe_nextall) { 1397*30ef842dSbmc dtrace_aggvarid_t id; 1398*30ef842dSbmc int ndx; 1399*30ef842dSbmc 1400*30ef842dSbmc if ((id = dt_aggregate_aggvarid(h)) > max || !(ndx = map[id])) 1401*30ef842dSbmc continue; 1402*30ef842dSbmc 1403*30ef842dSbmc if (zaggdata[ndx - 1].dtahe_size == 0) { 1404*30ef842dSbmc zaggdata[ndx - 1].dtahe_size = h->dtahe_size; 1405*30ef842dSbmc zaggdata[ndx - 1].dtahe_data = h->dtahe_data; 1406*30ef842dSbmc } 1407*30ef842dSbmc 1408*30ef842dSbmc nentries++; 1409*30ef842dSbmc } 1410*30ef842dSbmc 1411*30ef842dSbmc if (nentries == 0) { 1412*30ef842dSbmc /* 1413*30ef842dSbmc * We couldn't find any entries; there is nothing else to do. 1414*30ef842dSbmc */ 1415*30ef842dSbmc rval = 0; 1416*30ef842dSbmc goto out; 1417*30ef842dSbmc } 1418*30ef842dSbmc 1419*30ef842dSbmc /* 1420*30ef842dSbmc * Before we sort the data, we're going to look for any holes in our 1421*30ef842dSbmc * zero-filled data. This will occur if an aggregation variable that 1422*30ef842dSbmc * we are being asked to print has not yet been assigned the result of 1423*30ef842dSbmc * any aggregating action for _any_ tuple. The issue becomes that we 1424*30ef842dSbmc * would like a zero value to be printed for all columns for this 1425*30ef842dSbmc * aggregation, but without any record description, we don't know the 1426*30ef842dSbmc * aggregating action that corresponds to the aggregation variable. To 1427*30ef842dSbmc * try to find a match, we're simply going to lookup aggregation IDs 1428*30ef842dSbmc * (which are guaranteed to be contiguous and to start from 1), looking 1429*30ef842dSbmc * for the specified aggregation variable ID. If we find a match, 1430*30ef842dSbmc * we'll use that. If we iterate over all aggregation IDs and don't 1431*30ef842dSbmc * find a match, then we must be an anonymous enabling. (Anonymous 1432*30ef842dSbmc * enablings can't currently derive either aggregation variable IDs or 1433*30ef842dSbmc * aggregation variable names given only an aggregation ID.) In this 1434*30ef842dSbmc * obscure case (anonymous enabling, multiple aggregation printa() with 1435*30ef842dSbmc * some aggregations not represented for any tuple), our defined 1436*30ef842dSbmc * behavior is that the zero will be printed in the format of the first 1437*30ef842dSbmc * aggregation variable that contains any non-zero value. 1438*30ef842dSbmc */ 1439*30ef842dSbmc for (i = 0; i < naggvars; i++) { 1440*30ef842dSbmc if (zaggdata[i].dtahe_size == 0) { 1441*30ef842dSbmc dtrace_aggvarid_t aggvar; 1442*30ef842dSbmc 1443*30ef842dSbmc aggvar = aggvars[(i - sortpos + naggvars) % naggvars]; 1444*30ef842dSbmc assert(zaggdata[i].dtahe_data.dtada_data == NULL); 1445*30ef842dSbmc 1446*30ef842dSbmc for (j = DTRACE_AGGIDNONE + 1; ; j++) { 1447*30ef842dSbmc dtrace_aggdesc_t *agg; 1448*30ef842dSbmc dtrace_aggdata_t *aggdata; 1449*30ef842dSbmc 1450*30ef842dSbmc if (dt_aggid_lookup(dtp, j, &agg) != 0) 1451*30ef842dSbmc break; 1452*30ef842dSbmc 1453*30ef842dSbmc if (agg->dtagd_varid != aggvar) 1454*30ef842dSbmc continue; 1455*30ef842dSbmc 1456*30ef842dSbmc /* 1457*30ef842dSbmc * We have our description -- now we need to 1458*30ef842dSbmc * cons up the zaggdata entry for it. 1459*30ef842dSbmc */ 1460*30ef842dSbmc aggdata = &zaggdata[i].dtahe_data; 1461*30ef842dSbmc aggdata->dtada_size = agg->dtagd_size; 1462*30ef842dSbmc aggdata->dtada_desc = agg; 1463*30ef842dSbmc aggdata->dtada_handle = dtp; 1464*30ef842dSbmc (void) dt_epid_lookup(dtp, agg->dtagd_epid, 1465*30ef842dSbmc &aggdata->dtada_edesc, 1466*30ef842dSbmc &aggdata->dtada_pdesc); 1467*30ef842dSbmc aggdata->dtada_normal = 1; 1468*30ef842dSbmc zaggdata[i].dtahe_hashval = 0; 1469*30ef842dSbmc zaggdata[i].dtahe_size = agg->dtagd_size; 1470*30ef842dSbmc break; 1471*30ef842dSbmc } 1472*30ef842dSbmc 1473*30ef842dSbmc if (zaggdata[i].dtahe_size == 0) { 1474*30ef842dSbmc caddr_t data; 1475*30ef842dSbmc 1476*30ef842dSbmc /* 1477*30ef842dSbmc * We couldn't find this aggregation, meaning 1478*30ef842dSbmc * that we have never seen it before for any 1479*30ef842dSbmc * tuple _and_ this is an anonymous enabling. 1480*30ef842dSbmc * That is, we're in the obscure case outlined 1481*30ef842dSbmc * above. In this case, our defined behavior 1482*30ef842dSbmc * is to format the data in the format of the 1483*30ef842dSbmc * first non-zero aggregation -- of which, of 1484*30ef842dSbmc * course, we know there to be at least one 1485*30ef842dSbmc * (or nentries would have been zero). 1486*30ef842dSbmc */ 1487*30ef842dSbmc for (j = 0; j < naggvars; j++) { 1488*30ef842dSbmc if (zaggdata[j].dtahe_size != 0) 1489*30ef842dSbmc break; 1490*30ef842dSbmc } 1491*30ef842dSbmc 1492*30ef842dSbmc assert(j < naggvars); 1493*30ef842dSbmc zaggdata[i] = zaggdata[j]; 1494*30ef842dSbmc 1495*30ef842dSbmc data = zaggdata[i].dtahe_data.dtada_data; 1496*30ef842dSbmc assert(data != NULL); 1497*30ef842dSbmc } 1498*30ef842dSbmc } 1499*30ef842dSbmc } 1500*30ef842dSbmc 1501*30ef842dSbmc /* 1502*30ef842dSbmc * Now we need to allocate our zero-filled data for use for 1503*30ef842dSbmc * aggregations that don't have a value corresponding to a given key. 1504*30ef842dSbmc */ 1505*30ef842dSbmc for (i = 0; i < naggvars; i++) { 1506*30ef842dSbmc dtrace_aggdata_t *aggdata = &zaggdata[i].dtahe_data; 1507*30ef842dSbmc dtrace_aggdesc_t *aggdesc = aggdata->dtada_desc; 1508*30ef842dSbmc dtrace_recdesc_t *rec; 1509*30ef842dSbmc uint64_t larg; 1510*30ef842dSbmc caddr_t zdata; 1511*30ef842dSbmc 1512*30ef842dSbmc zsize = zaggdata[i].dtahe_size; 1513*30ef842dSbmc assert(zsize != 0); 1514*30ef842dSbmc 1515*30ef842dSbmc if ((zdata = dt_zalloc(dtp, zsize)) == NULL) { 1516*30ef842dSbmc /* 1517*30ef842dSbmc * If we failed to allocated some zero-filled data, we 1518*30ef842dSbmc * need to zero out the remaining dtada_data pointers 1519*30ef842dSbmc * to prevent the wrong data from being freed below. 1520*30ef842dSbmc */ 1521*30ef842dSbmc for (j = i; j < naggvars; j++) 1522*30ef842dSbmc zaggdata[j].dtahe_data.dtada_data = NULL; 1523*30ef842dSbmc goto out; 1524*30ef842dSbmc } 1525*30ef842dSbmc 1526*30ef842dSbmc aggvar = aggvars[(i - sortpos + naggvars) % naggvars]; 1527*30ef842dSbmc 1528*30ef842dSbmc /* 1529*30ef842dSbmc * First, the easy bit. To maintain compatibility with 1530*30ef842dSbmc * consumers that pull the compiler-generated ID out of the 1531*30ef842dSbmc * data, we put that ID at the top of the zero-filled data. 1532*30ef842dSbmc */ 1533*30ef842dSbmc rec = &aggdesc->dtagd_rec[0]; 1534*30ef842dSbmc /* LINTED - alignment */ 1535*30ef842dSbmc *((dtrace_aggvarid_t *)(zdata + rec->dtrd_offset)) = aggvar; 1536*30ef842dSbmc 1537*30ef842dSbmc rec = &aggdesc->dtagd_rec[aggdesc->dtagd_nrecs - 1]; 1538*30ef842dSbmc 1539*30ef842dSbmc /* 1540*30ef842dSbmc * Now for the more complicated part. If (and only if) this 1541*30ef842dSbmc * is an lquantize() aggregating action, zero-filled data is 1542*30ef842dSbmc * not equivalent to an empty record: we must also get the 1543*30ef842dSbmc * parameters for the lquantize(). 1544*30ef842dSbmc */ 1545*30ef842dSbmc if (rec->dtrd_action == DTRACEAGG_LQUANTIZE) { 1546*30ef842dSbmc if (aggdata->dtada_data != NULL) { 1547*30ef842dSbmc /* 1548*30ef842dSbmc * The easier case here is if we actually have 1549*30ef842dSbmc * some prototype data -- in which case we 1550*30ef842dSbmc * manually dig it out of the aggregation 1551*30ef842dSbmc * record. 1552*30ef842dSbmc */ 1553*30ef842dSbmc /* LINTED - alignment */ 1554*30ef842dSbmc larg = *((uint64_t *)(aggdata->dtada_data + 1555*30ef842dSbmc rec->dtrd_offset)); 1556*30ef842dSbmc } else { 1557*30ef842dSbmc /* 1558*30ef842dSbmc * We don't have any prototype data. As a 1559*30ef842dSbmc * result, we know that we _do_ have the 1560*30ef842dSbmc * compiler-generated information. (If this 1561*30ef842dSbmc * were an anonymous enabling, all of our 1562*30ef842dSbmc * zero-filled data would have prototype data 1563*30ef842dSbmc * -- either directly or indirectly.) So as 1564*30ef842dSbmc * gross as it is, we'll grovel around in the 1565*30ef842dSbmc * compiler-generated information to find the 1566*30ef842dSbmc * lquantize() parameters. 1567*30ef842dSbmc */ 1568*30ef842dSbmc dtrace_stmtdesc_t *sdp; 1569*30ef842dSbmc dt_ident_t *aid; 1570*30ef842dSbmc dt_idsig_t *isp; 1571*30ef842dSbmc 1572*30ef842dSbmc sdp = (dtrace_stmtdesc_t *)(uintptr_t) 1573*30ef842dSbmc aggdesc->dtagd_rec[0].dtrd_uarg; 1574*30ef842dSbmc aid = sdp->dtsd_aggdata; 1575*30ef842dSbmc isp = (dt_idsig_t *)aid->di_data; 1576*30ef842dSbmc assert(isp->dis_auxinfo != 0); 1577*30ef842dSbmc larg = isp->dis_auxinfo; 1578*30ef842dSbmc } 1579*30ef842dSbmc 1580*30ef842dSbmc /* LINTED - alignment */ 1581*30ef842dSbmc *((uint64_t *)(zdata + rec->dtrd_offset)) = larg; 1582*30ef842dSbmc } 1583*30ef842dSbmc 1584*30ef842dSbmc aggdata->dtada_data = zdata; 1585*30ef842dSbmc } 1586*30ef842dSbmc 1587*30ef842dSbmc /* 1588*30ef842dSbmc * Now that we've dealt with setting up our zero-filled data, we can 1589*30ef842dSbmc * allocate our sorted array, and take another pass over the data to 1590*30ef842dSbmc * fill it. 1591*30ef842dSbmc */ 1592*30ef842dSbmc sorted = dt_alloc(dtp, nentries * sizeof (dt_ahashent_t *)); 1593*30ef842dSbmc 1594*30ef842dSbmc if (sorted == NULL) 1595*30ef842dSbmc goto out; 1596*30ef842dSbmc 1597*30ef842dSbmc for (h = hash->dtah_all, i = 0; h != NULL; h = h->dtahe_nextall) { 1598*30ef842dSbmc dtrace_aggvarid_t id; 1599*30ef842dSbmc 1600*30ef842dSbmc if ((id = dt_aggregate_aggvarid(h)) > max || !map[id]) 1601*30ef842dSbmc continue; 1602*30ef842dSbmc 1603*30ef842dSbmc sorted[i++] = h; 1604*30ef842dSbmc } 1605*30ef842dSbmc 1606*30ef842dSbmc assert(i == nentries); 1607*30ef842dSbmc 1608*30ef842dSbmc /* 1609*30ef842dSbmc * We've loaded our array; now we need to sort by value to allow us 1610*30ef842dSbmc * to create bundles of like value. We're going to acquire the 1611*30ef842dSbmc * dt_qsort_lock here, and hold it across all of our subsequent 1612*30ef842dSbmc * comparison and sorting. 1613*30ef842dSbmc */ 1614*30ef842dSbmc (void) pthread_mutex_lock(&dt_qsort_lock); 1615*30ef842dSbmc 1616*30ef842dSbmc qsort(sorted, nentries, sizeof (dt_ahashent_t *), 1617*30ef842dSbmc dt_aggregate_keyvarcmp); 1618*30ef842dSbmc 1619*30ef842dSbmc /* 1620*30ef842dSbmc * Now we need to go through and create bundles. Because the number 1621*30ef842dSbmc * of bundles is bounded by the size of the sorted array, we're going 1622*30ef842dSbmc * to reuse the underlying storage. And note that "bundle" is an 1623*30ef842dSbmc * array of pointers to arrays of pointers to dt_ahashent_t -- making 1624*30ef842dSbmc * its type (regrettably) "dt_ahashent_t ***". (Regrettable because 1625*30ef842dSbmc * '*' -- like '_' and 'X' -- should never appear in triplicate in 1626*30ef842dSbmc * an ideal world.) 1627*30ef842dSbmc */ 1628*30ef842dSbmc bundle = (dt_ahashent_t ***)sorted; 1629*30ef842dSbmc 1630*30ef842dSbmc for (i = 1, start = 0; i <= nentries; i++) { 1631*30ef842dSbmc if (i < nentries && 1632*30ef842dSbmc dt_aggregate_keycmp(&sorted[i], &sorted[i - 1]) == 0) 1633*30ef842dSbmc continue; 1634*30ef842dSbmc 1635*30ef842dSbmc /* 1636*30ef842dSbmc * We have a bundle boundary. Everything from start to 1637*30ef842dSbmc * (i - 1) belongs in one bundle. 1638*30ef842dSbmc */ 1639*30ef842dSbmc assert(i - start <= naggvars); 1640*30ef842dSbmc bundlesize = (naggvars + 2) * sizeof (dt_ahashent_t *); 1641*30ef842dSbmc 1642*30ef842dSbmc if ((nbundle = dt_zalloc(dtp, bundlesize)) == NULL) { 1643*30ef842dSbmc (void) pthread_mutex_unlock(&dt_qsort_lock); 1644*30ef842dSbmc goto out; 1645*30ef842dSbmc } 1646*30ef842dSbmc 1647*30ef842dSbmc for (j = start; j < i; j++) { 1648*30ef842dSbmc dtrace_aggvarid_t id = dt_aggregate_aggvarid(sorted[j]); 1649*30ef842dSbmc 1650*30ef842dSbmc assert(id <= max); 1651*30ef842dSbmc assert(map[id] != 0); 1652*30ef842dSbmc assert(map[id] - 1 < naggvars); 1653*30ef842dSbmc assert(nbundle[map[id] - 1] == NULL); 1654*30ef842dSbmc nbundle[map[id] - 1] = sorted[j]; 1655*30ef842dSbmc 1656*30ef842dSbmc if (nbundle[naggvars] == NULL) 1657*30ef842dSbmc nbundle[naggvars] = sorted[j]; 1658*30ef842dSbmc } 1659*30ef842dSbmc 1660*30ef842dSbmc for (j = 0; j < naggvars; j++) { 1661*30ef842dSbmc if (nbundle[j] != NULL) 1662*30ef842dSbmc continue; 1663*30ef842dSbmc 1664*30ef842dSbmc /* 1665*30ef842dSbmc * Before we assume that this aggregation variable 1666*30ef842dSbmc * isn't present (and fall back to using the 1667*30ef842dSbmc * zero-filled data allocated earlier), check the 1668*30ef842dSbmc * remap. If we have a remapping, we'll drop it in 1669*30ef842dSbmc * here. Note that we might be remapping an 1670*30ef842dSbmc * aggregation variable that isn't present for this 1671*30ef842dSbmc * key; in this case, the aggregation data that we 1672*30ef842dSbmc * copy will point to the zeroed data. 1673*30ef842dSbmc */ 1674*30ef842dSbmc if (remap != NULL && remap[j]) { 1675*30ef842dSbmc assert(remap[j] - 1 < j); 1676*30ef842dSbmc assert(nbundle[remap[j] - 1] != NULL); 1677*30ef842dSbmc nbundle[j] = nbundle[remap[j] - 1]; 1678*30ef842dSbmc } else { 1679*30ef842dSbmc nbundle[j] = &zaggdata[j]; 1680*30ef842dSbmc } 1681*30ef842dSbmc } 1682*30ef842dSbmc 1683*30ef842dSbmc bundle[nbundles++] = nbundle; 1684*30ef842dSbmc start = i; 1685*30ef842dSbmc } 1686*30ef842dSbmc 1687*30ef842dSbmc /* 1688*30ef842dSbmc * Now we need to re-sort based on the first value. 1689*30ef842dSbmc */ 1690*30ef842dSbmc dt_aggregate_qsort(dtp, bundle, nbundles, sizeof (dt_ahashent_t **), 1691*30ef842dSbmc dt_aggregate_bundlecmp); 1692*30ef842dSbmc 1693*30ef842dSbmc (void) pthread_mutex_unlock(&dt_qsort_lock); 1694*30ef842dSbmc 1695*30ef842dSbmc /* 1696*30ef842dSbmc * We're done! Now we just need to go back over the sorted bundles, 1697*30ef842dSbmc * calling the function. 1698*30ef842dSbmc */ 1699*30ef842dSbmc data = alloca((naggvars + 1) * sizeof (dtrace_aggdata_t *)); 1700*30ef842dSbmc 1701*30ef842dSbmc for (i = 0; i < nbundles; i++) { 1702*30ef842dSbmc for (j = 0; j < naggvars; j++) 1703*30ef842dSbmc data[j + 1] = NULL; 1704*30ef842dSbmc 1705*30ef842dSbmc for (j = 0; j < naggvars; j++) { 1706*30ef842dSbmc int ndx = j - sortpos; 1707*30ef842dSbmc 1708*30ef842dSbmc if (ndx < 0) 1709*30ef842dSbmc ndx += naggvars; 1710*30ef842dSbmc 1711*30ef842dSbmc assert(bundle[i][ndx] != NULL); 1712*30ef842dSbmc data[j + 1] = &bundle[i][ndx]->dtahe_data; 1713*30ef842dSbmc } 1714*30ef842dSbmc 1715*30ef842dSbmc for (j = 0; j < naggvars; j++) 1716*30ef842dSbmc assert(data[j + 1] != NULL); 1717*30ef842dSbmc 1718*30ef842dSbmc /* 1719*30ef842dSbmc * The representative key is the last element in the bundle. 1720*30ef842dSbmc * Assert that we have one, and then set it to be the first 1721*30ef842dSbmc * element of data. 1722*30ef842dSbmc */ 1723*30ef842dSbmc assert(bundle[i][j] != NULL); 1724*30ef842dSbmc data[0] = &bundle[i][j]->dtahe_data; 1725*30ef842dSbmc 1726*30ef842dSbmc if ((rval = func(data, naggvars + 1, arg)) == -1) 1727*30ef842dSbmc goto out; 1728*30ef842dSbmc } 1729*30ef842dSbmc 1730*30ef842dSbmc rval = 0; 1731*30ef842dSbmc out: 1732*30ef842dSbmc for (i = 0; i < nbundles; i++) 1733*30ef842dSbmc dt_free(dtp, bundle[i]); 1734*30ef842dSbmc 1735*30ef842dSbmc if (zaggdata != NULL) { 1736*30ef842dSbmc for (i = 0; i < naggvars; i++) 1737*30ef842dSbmc dt_free(dtp, zaggdata[i].dtahe_data.dtada_data); 1738*30ef842dSbmc } 1739*30ef842dSbmc 1740*30ef842dSbmc dt_free(dtp, zaggdata); 1741*30ef842dSbmc dt_free(dtp, sorted); 1742*30ef842dSbmc dt_free(dtp, remap); 1743*30ef842dSbmc dt_free(dtp, map); 1744*30ef842dSbmc 1745*30ef842dSbmc return (rval); 1746*30ef842dSbmc } 1747*30ef842dSbmc 17487c478bd9Sstevel@tonic-gate int 17497c478bd9Sstevel@tonic-gate dtrace_aggregate_print(dtrace_hdl_t *dtp, FILE *fp, 17507c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_f *func) 17517c478bd9Sstevel@tonic-gate { 17527c478bd9Sstevel@tonic-gate dt_print_aggdata_t pd; 17537c478bd9Sstevel@tonic-gate 17547c478bd9Sstevel@tonic-gate pd.dtpa_dtp = dtp; 17557c478bd9Sstevel@tonic-gate pd.dtpa_fp = fp; 17567c478bd9Sstevel@tonic-gate pd.dtpa_allunprint = 1; 17577c478bd9Sstevel@tonic-gate 17587c478bd9Sstevel@tonic-gate if (func == NULL) 1759*30ef842dSbmc func = dtrace_aggregate_walk_sorted; 17607c478bd9Sstevel@tonic-gate 17617c478bd9Sstevel@tonic-gate if ((*func)(dtp, dt_print_agg, &pd) == -1) 17627c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, dtp->dt_errno)); 17637c478bd9Sstevel@tonic-gate 17647c478bd9Sstevel@tonic-gate return (0); 17657c478bd9Sstevel@tonic-gate } 17667c478bd9Sstevel@tonic-gate 17677c478bd9Sstevel@tonic-gate void 17687c478bd9Sstevel@tonic-gate dtrace_aggregate_clear(dtrace_hdl_t *dtp) 17697c478bd9Sstevel@tonic-gate { 17707c478bd9Sstevel@tonic-gate dt_aggregate_t *agp = &dtp->dt_aggregate; 17717c478bd9Sstevel@tonic-gate dt_ahash_t *hash = &agp->dtat_hash; 17727c478bd9Sstevel@tonic-gate dt_ahashent_t *h; 17737c478bd9Sstevel@tonic-gate dtrace_aggdata_t *data; 17747c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *aggdesc; 17757c478bd9Sstevel@tonic-gate dtrace_recdesc_t *rec; 17767c478bd9Sstevel@tonic-gate int i, max_cpus = agp->dtat_maxcpu; 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate for (h = hash->dtah_all; h != NULL; h = h->dtahe_nextall) { 17797c478bd9Sstevel@tonic-gate aggdesc = h->dtahe_data.dtada_desc; 17807c478bd9Sstevel@tonic-gate rec = &aggdesc->dtagd_rec[aggdesc->dtagd_nrecs - 1]; 17817c478bd9Sstevel@tonic-gate data = &h->dtahe_data; 17827c478bd9Sstevel@tonic-gate 17837c478bd9Sstevel@tonic-gate bzero(&data->dtada_data[rec->dtrd_offset], rec->dtrd_size); 17847c478bd9Sstevel@tonic-gate 17857c478bd9Sstevel@tonic-gate if (data->dtada_percpu == NULL) 17867c478bd9Sstevel@tonic-gate continue; 17877c478bd9Sstevel@tonic-gate 17887c478bd9Sstevel@tonic-gate for (i = 0; i < max_cpus; i++) 17897c478bd9Sstevel@tonic-gate bzero(data->dtada_percpu[i], rec->dtrd_size); 17907c478bd9Sstevel@tonic-gate } 17917c478bd9Sstevel@tonic-gate } 17927c478bd9Sstevel@tonic-gate 17937c478bd9Sstevel@tonic-gate void 17947c478bd9Sstevel@tonic-gate dt_aggregate_destroy(dtrace_hdl_t *dtp) 17957c478bd9Sstevel@tonic-gate { 17967c478bd9Sstevel@tonic-gate dt_aggregate_t *agp = &dtp->dt_aggregate; 17977c478bd9Sstevel@tonic-gate dt_ahash_t *hash = &agp->dtat_hash; 17987c478bd9Sstevel@tonic-gate dt_ahashent_t *h, *next; 17997c478bd9Sstevel@tonic-gate dtrace_aggdata_t *aggdata; 18007c478bd9Sstevel@tonic-gate int i, max_cpus = agp->dtat_maxcpu; 18017c478bd9Sstevel@tonic-gate 18027c478bd9Sstevel@tonic-gate if (hash->dtah_hash == NULL) { 18037c478bd9Sstevel@tonic-gate assert(hash->dtah_all == NULL); 18047c478bd9Sstevel@tonic-gate } else { 18057c478bd9Sstevel@tonic-gate free(hash->dtah_hash); 18067c478bd9Sstevel@tonic-gate 18077c478bd9Sstevel@tonic-gate for (h = hash->dtah_all; h != NULL; h = next) { 18087c478bd9Sstevel@tonic-gate next = h->dtahe_nextall; 18097c478bd9Sstevel@tonic-gate 18107c478bd9Sstevel@tonic-gate aggdata = &h->dtahe_data; 18117c478bd9Sstevel@tonic-gate 18127c478bd9Sstevel@tonic-gate if (aggdata->dtada_percpu != NULL) { 18137c478bd9Sstevel@tonic-gate for (i = 0; i < max_cpus; i++) 18147c478bd9Sstevel@tonic-gate free(aggdata->dtada_percpu[i]); 18157c478bd9Sstevel@tonic-gate free(aggdata->dtada_percpu); 18167c478bd9Sstevel@tonic-gate } 18177c478bd9Sstevel@tonic-gate 18187c478bd9Sstevel@tonic-gate free(aggdata->dtada_data); 18197c478bd9Sstevel@tonic-gate free(h); 18207c478bd9Sstevel@tonic-gate } 18217c478bd9Sstevel@tonic-gate 18227c478bd9Sstevel@tonic-gate hash->dtah_hash = NULL; 18237c478bd9Sstevel@tonic-gate hash->dtah_all = NULL; 18247c478bd9Sstevel@tonic-gate hash->dtah_size = 0; 18257c478bd9Sstevel@tonic-gate } 18267c478bd9Sstevel@tonic-gate 18277c478bd9Sstevel@tonic-gate free(agp->dtat_buf.dtbd_data); 18287c478bd9Sstevel@tonic-gate free(agp->dtat_cpus); 18297c478bd9Sstevel@tonic-gate } 1830