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 5127bbe13Stomee * Common Development and Distribution License (the "License"). 6127bbe13Stomee * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 21127bbe13Stomee 227c478bd9Sstevel@tonic-gate /* 236e0bee74Sjhaslam * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 27*2b6389efSBryan Cantrill /* 28*2b6389efSBryan Cantrill * Copyright (c) 2011, Joyent, Inc. All rights reserved. 29*2b6389efSBryan Cantrill */ 307c478bd9Sstevel@tonic-gate 317c478bd9Sstevel@tonic-gate #include <stdlib.h> 327c478bd9Sstevel@tonic-gate #include <strings.h> 337c478bd9Sstevel@tonic-gate #include <errno.h> 347c478bd9Sstevel@tonic-gate #include <unistd.h> 357c478bd9Sstevel@tonic-gate #include <dt_impl.h> 367c478bd9Sstevel@tonic-gate #include <assert.h> 3730ef842dSbmc #include <alloca.h> 3830ef842dSbmc #include <limits.h> 397c478bd9Sstevel@tonic-gate 407c478bd9Sstevel@tonic-gate #define DTRACE_AHASHSIZE 32779 /* big 'ol prime */ 417c478bd9Sstevel@tonic-gate 4230ef842dSbmc /* 4330ef842dSbmc * Because qsort(3C) does not allow an argument to be passed to a comparison 4430ef842dSbmc * function, the variables that affect comparison must regrettably be global; 4530ef842dSbmc * they are protected by a global static lock, dt_qsort_lock. 4630ef842dSbmc */ 4730ef842dSbmc static pthread_mutex_t dt_qsort_lock = PTHREAD_MUTEX_INITIALIZER; 4830ef842dSbmc 4930ef842dSbmc static int dt_revsort; 5030ef842dSbmc static int dt_keysort; 5130ef842dSbmc static int dt_keypos; 5230ef842dSbmc 5330ef842dSbmc #define DT_LESSTHAN (dt_revsort == 0 ? -1 : 1) 5430ef842dSbmc #define DT_GREATERTHAN (dt_revsort == 0 ? 1 : -1) 5530ef842dSbmc 567c478bd9Sstevel@tonic-gate static void 57187eccf8Sbmc dt_aggregate_count(int64_t *existing, int64_t *new, size_t size) 587c478bd9Sstevel@tonic-gate { 597c478bd9Sstevel@tonic-gate int i; 607c478bd9Sstevel@tonic-gate 61187eccf8Sbmc for (i = 0; i < size / sizeof (int64_t); i++) 627c478bd9Sstevel@tonic-gate existing[i] = existing[i] + new[i]; 637c478bd9Sstevel@tonic-gate } 647c478bd9Sstevel@tonic-gate 657c478bd9Sstevel@tonic-gate static int 66187eccf8Sbmc dt_aggregate_countcmp(int64_t *lhs, int64_t *rhs) 677c478bd9Sstevel@tonic-gate { 68187eccf8Sbmc int64_t lvar = *lhs; 69187eccf8Sbmc int64_t rvar = *rhs; 707c478bd9Sstevel@tonic-gate 717c478bd9Sstevel@tonic-gate if (lvar < rvar) 7230ef842dSbmc return (DT_LESSTHAN); 7330ef842dSbmc 7430ef842dSbmc if (lvar > rvar) 7530ef842dSbmc return (DT_GREATERTHAN); 767c478bd9Sstevel@tonic-gate 777c478bd9Sstevel@tonic-gate return (0); 787c478bd9Sstevel@tonic-gate } 797c478bd9Sstevel@tonic-gate 807c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 817c478bd9Sstevel@tonic-gate static void 82187eccf8Sbmc dt_aggregate_min(int64_t *existing, int64_t *new, size_t size) 837c478bd9Sstevel@tonic-gate { 847c478bd9Sstevel@tonic-gate if (*new < *existing) 857c478bd9Sstevel@tonic-gate *existing = *new; 867c478bd9Sstevel@tonic-gate } 877c478bd9Sstevel@tonic-gate 887c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 897c478bd9Sstevel@tonic-gate static void 90187eccf8Sbmc dt_aggregate_max(int64_t *existing, int64_t *new, size_t size) 917c478bd9Sstevel@tonic-gate { 927c478bd9Sstevel@tonic-gate if (*new > *existing) 937c478bd9Sstevel@tonic-gate *existing = *new; 947c478bd9Sstevel@tonic-gate } 957c478bd9Sstevel@tonic-gate 967c478bd9Sstevel@tonic-gate static int 97187eccf8Sbmc dt_aggregate_averagecmp(int64_t *lhs, int64_t *rhs) 987c478bd9Sstevel@tonic-gate { 99187eccf8Sbmc int64_t lavg = lhs[0] ? (lhs[1] / lhs[0]) : 0; 100187eccf8Sbmc int64_t ravg = rhs[0] ? (rhs[1] / rhs[0]) : 0; 1017c478bd9Sstevel@tonic-gate 1027c478bd9Sstevel@tonic-gate if (lavg < ravg) 10330ef842dSbmc return (DT_LESSTHAN); 10430ef842dSbmc 10530ef842dSbmc if (lavg > ravg) 10630ef842dSbmc return (DT_GREATERTHAN); 1077c478bd9Sstevel@tonic-gate 1087c478bd9Sstevel@tonic-gate return (0); 1097c478bd9Sstevel@tonic-gate } 1107c478bd9Sstevel@tonic-gate 1116e0bee74Sjhaslam static int 1126e0bee74Sjhaslam dt_aggregate_stddevcmp(int64_t *lhs, int64_t *rhs) 1136e0bee74Sjhaslam { 1146e0bee74Sjhaslam uint64_t lsd = dt_stddev((uint64_t *)lhs, 1); 1156e0bee74Sjhaslam uint64_t rsd = dt_stddev((uint64_t *)rhs, 1); 1166e0bee74Sjhaslam 1176e0bee74Sjhaslam if (lsd < rsd) 1186e0bee74Sjhaslam return (DT_LESSTHAN); 1196e0bee74Sjhaslam 1206e0bee74Sjhaslam if (lsd > rsd) 1216e0bee74Sjhaslam return (DT_GREATERTHAN); 1226e0bee74Sjhaslam 1236e0bee74Sjhaslam return (0); 1246e0bee74Sjhaslam } 1256e0bee74Sjhaslam 1267c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1277c478bd9Sstevel@tonic-gate static void 128187eccf8Sbmc dt_aggregate_lquantize(int64_t *existing, int64_t *new, size_t size) 1297c478bd9Sstevel@tonic-gate { 130187eccf8Sbmc int64_t arg = *existing++; 1317c478bd9Sstevel@tonic-gate uint16_t levels = DTRACE_LQUANTIZE_LEVELS(arg); 1327c478bd9Sstevel@tonic-gate int i; 1337c478bd9Sstevel@tonic-gate 1347c478bd9Sstevel@tonic-gate for (i = 0; i <= levels + 1; i++) 1357c478bd9Sstevel@tonic-gate existing[i] = existing[i] + new[i + 1]; 1367c478bd9Sstevel@tonic-gate } 1377c478bd9Sstevel@tonic-gate 138a1b5e537Sbmc static long double 139187eccf8Sbmc dt_aggregate_lquantizedsum(int64_t *lquanta) 1407c478bd9Sstevel@tonic-gate { 141187eccf8Sbmc int64_t arg = *lquanta++; 1427c478bd9Sstevel@tonic-gate int32_t base = DTRACE_LQUANTIZE_BASE(arg); 1437c478bd9Sstevel@tonic-gate uint16_t step = DTRACE_LQUANTIZE_STEP(arg); 1447c478bd9Sstevel@tonic-gate uint16_t levels = DTRACE_LQUANTIZE_LEVELS(arg), i; 145a1b5e537Sbmc long double total = (long double)lquanta[0] * (long double)(base - 1); 1467c478bd9Sstevel@tonic-gate 1477c478bd9Sstevel@tonic-gate for (i = 0; i < levels; base += step, i++) 148a1b5e537Sbmc total += (long double)lquanta[i + 1] * (long double)base; 1497c478bd9Sstevel@tonic-gate 150a1b5e537Sbmc return (total + (long double)lquanta[levels + 1] * 151a1b5e537Sbmc (long double)(base + 1)); 1527c478bd9Sstevel@tonic-gate } 1537c478bd9Sstevel@tonic-gate 154187eccf8Sbmc static int64_t 155187eccf8Sbmc dt_aggregate_lquantizedzero(int64_t *lquanta) 156187eccf8Sbmc { 157187eccf8Sbmc int64_t arg = *lquanta++; 158187eccf8Sbmc int32_t base = DTRACE_LQUANTIZE_BASE(arg); 159187eccf8Sbmc uint16_t step = DTRACE_LQUANTIZE_STEP(arg); 160187eccf8Sbmc uint16_t levels = DTRACE_LQUANTIZE_LEVELS(arg), i; 161187eccf8Sbmc 162187eccf8Sbmc if (base - 1 == 0) 163187eccf8Sbmc return (lquanta[0]); 164187eccf8Sbmc 165187eccf8Sbmc for (i = 0; i < levels; base += step, i++) { 166187eccf8Sbmc if (base != 0) 167187eccf8Sbmc continue; 168187eccf8Sbmc 169187eccf8Sbmc return (lquanta[i + 1]); 170187eccf8Sbmc } 171187eccf8Sbmc 172187eccf8Sbmc if (base + 1 == 0) 173187eccf8Sbmc return (lquanta[levels + 1]); 174187eccf8Sbmc 175187eccf8Sbmc return (0); 176187eccf8Sbmc } 177187eccf8Sbmc 1787c478bd9Sstevel@tonic-gate static int 179187eccf8Sbmc dt_aggregate_lquantizedcmp(int64_t *lhs, int64_t *rhs) 1807c478bd9Sstevel@tonic-gate { 181a1b5e537Sbmc long double lsum = dt_aggregate_lquantizedsum(lhs); 182a1b5e537Sbmc long double rsum = dt_aggregate_lquantizedsum(rhs); 183187eccf8Sbmc int64_t lzero, rzero; 1847c478bd9Sstevel@tonic-gate 1857c478bd9Sstevel@tonic-gate if (lsum < rsum) 18630ef842dSbmc return (DT_LESSTHAN); 18730ef842dSbmc 18830ef842dSbmc if (lsum > rsum) 18930ef842dSbmc return (DT_GREATERTHAN); 1907c478bd9Sstevel@tonic-gate 191187eccf8Sbmc /* 192187eccf8Sbmc * If they're both equal, then we will compare based on the weights at 193187eccf8Sbmc * zero. If the weights at zero are equal (or if zero is not within 194187eccf8Sbmc * the range of the linear quantization), then this will be judged a 195187eccf8Sbmc * tie and will be resolved based on the key comparison. 196187eccf8Sbmc */ 197187eccf8Sbmc lzero = dt_aggregate_lquantizedzero(lhs); 198187eccf8Sbmc rzero = dt_aggregate_lquantizedzero(rhs); 199187eccf8Sbmc 200187eccf8Sbmc if (lzero < rzero) 20130ef842dSbmc return (DT_LESSTHAN); 20230ef842dSbmc 20330ef842dSbmc if (lzero > rzero) 20430ef842dSbmc return (DT_GREATERTHAN); 205187eccf8Sbmc 2067c478bd9Sstevel@tonic-gate return (0); 2077c478bd9Sstevel@tonic-gate } 2087c478bd9Sstevel@tonic-gate 209*2b6389efSBryan Cantrill static void 210*2b6389efSBryan Cantrill dt_aggregate_llquantize(int64_t *existing, int64_t *new, size_t size) 211*2b6389efSBryan Cantrill { 212*2b6389efSBryan Cantrill int i; 213*2b6389efSBryan Cantrill 214*2b6389efSBryan Cantrill for (i = 1; i < size / sizeof (int64_t); i++) 215*2b6389efSBryan Cantrill existing[i] = existing[i] + new[i]; 216*2b6389efSBryan Cantrill } 217*2b6389efSBryan Cantrill 218*2b6389efSBryan Cantrill static long double 219*2b6389efSBryan Cantrill dt_aggregate_llquantizedsum(int64_t *llquanta) 220*2b6389efSBryan Cantrill { 221*2b6389efSBryan Cantrill int64_t arg = *llquanta++; 222*2b6389efSBryan Cantrill uint16_t factor = DTRACE_LLQUANTIZE_FACTOR(arg); 223*2b6389efSBryan Cantrill uint16_t low = DTRACE_LLQUANTIZE_LOW(arg); 224*2b6389efSBryan Cantrill uint16_t high = DTRACE_LLQUANTIZE_HIGH(arg); 225*2b6389efSBryan Cantrill uint16_t nsteps = DTRACE_LLQUANTIZE_NSTEP(arg); 226*2b6389efSBryan Cantrill int bin = 0, order; 227*2b6389efSBryan Cantrill int64_t value = 1, next, step; 228*2b6389efSBryan Cantrill long double total; 229*2b6389efSBryan Cantrill 230*2b6389efSBryan Cantrill assert(nsteps >= factor); 231*2b6389efSBryan Cantrill assert(nsteps % factor == 0); 232*2b6389efSBryan Cantrill 233*2b6389efSBryan Cantrill for (order = 0; order < low; order++) 234*2b6389efSBryan Cantrill value *= factor; 235*2b6389efSBryan Cantrill 236*2b6389efSBryan Cantrill total = (long double)llquanta[bin++] * (long double)(value - 1); 237*2b6389efSBryan Cantrill 238*2b6389efSBryan Cantrill next = value * factor; 239*2b6389efSBryan Cantrill step = next > nsteps ? next / nsteps : 1; 240*2b6389efSBryan Cantrill 241*2b6389efSBryan Cantrill while (order <= high) { 242*2b6389efSBryan Cantrill assert(value < next); 243*2b6389efSBryan Cantrill total += (long double)llquanta[bin++] * (long double)(value); 244*2b6389efSBryan Cantrill 245*2b6389efSBryan Cantrill if ((value += step) != next) 246*2b6389efSBryan Cantrill continue; 247*2b6389efSBryan Cantrill 248*2b6389efSBryan Cantrill next = value * factor; 249*2b6389efSBryan Cantrill step = next > nsteps ? next / nsteps : 1; 250*2b6389efSBryan Cantrill order++; 251*2b6389efSBryan Cantrill } 252*2b6389efSBryan Cantrill 253*2b6389efSBryan Cantrill return (total + (long double)llquanta[bin] * (long double)value); 254*2b6389efSBryan Cantrill } 255*2b6389efSBryan Cantrill 256*2b6389efSBryan Cantrill static int 257*2b6389efSBryan Cantrill dt_aggregate_llquantizedcmp(int64_t *lhs, int64_t *rhs) 258*2b6389efSBryan Cantrill { 259*2b6389efSBryan Cantrill long double lsum = dt_aggregate_llquantizedsum(lhs); 260*2b6389efSBryan Cantrill long double rsum = dt_aggregate_llquantizedsum(rhs); 261*2b6389efSBryan Cantrill int64_t lzero, rzero; 262*2b6389efSBryan Cantrill 263*2b6389efSBryan Cantrill if (lsum < rsum) 264*2b6389efSBryan Cantrill return (DT_LESSTHAN); 265*2b6389efSBryan Cantrill 266*2b6389efSBryan Cantrill if (lsum > rsum) 267*2b6389efSBryan Cantrill return (DT_GREATERTHAN); 268*2b6389efSBryan Cantrill 269*2b6389efSBryan Cantrill /* 270*2b6389efSBryan Cantrill * If they're both equal, then we will compare based on the weights at 271*2b6389efSBryan Cantrill * zero. If the weights at zero are equal, then this will be judged a 272*2b6389efSBryan Cantrill * tie and will be resolved based on the key comparison. 273*2b6389efSBryan Cantrill */ 274*2b6389efSBryan Cantrill lzero = lhs[1]; 275*2b6389efSBryan Cantrill rzero = rhs[1]; 276*2b6389efSBryan Cantrill 277*2b6389efSBryan Cantrill if (lzero < rzero) 278*2b6389efSBryan Cantrill return (DT_LESSTHAN); 279*2b6389efSBryan Cantrill 280*2b6389efSBryan Cantrill if (lzero > rzero) 281*2b6389efSBryan Cantrill return (DT_GREATERTHAN); 282*2b6389efSBryan Cantrill 283*2b6389efSBryan Cantrill return (0); 284*2b6389efSBryan Cantrill } 285*2b6389efSBryan Cantrill 2867c478bd9Sstevel@tonic-gate static int 287187eccf8Sbmc dt_aggregate_quantizedcmp(int64_t *lhs, int64_t *rhs) 2887c478bd9Sstevel@tonic-gate { 2897c478bd9Sstevel@tonic-gate int nbuckets = DTRACE_QUANTIZE_NBUCKETS, i; 290a1b5e537Sbmc long double ltotal = 0, rtotal = 0; 291187eccf8Sbmc int64_t lzero, rzero; 2927c478bd9Sstevel@tonic-gate 2937c478bd9Sstevel@tonic-gate for (i = 0; i < nbuckets; i++) { 2947c478bd9Sstevel@tonic-gate int64_t bucketval = DTRACE_QUANTIZE_BUCKETVAL(i); 2957c478bd9Sstevel@tonic-gate 296187eccf8Sbmc if (bucketval == 0) { 297187eccf8Sbmc lzero = lhs[i]; 298187eccf8Sbmc rzero = rhs[i]; 299187eccf8Sbmc } 300187eccf8Sbmc 301a1b5e537Sbmc ltotal += (long double)bucketval * (long double)lhs[i]; 302a1b5e537Sbmc rtotal += (long double)bucketval * (long double)rhs[i]; 3037c478bd9Sstevel@tonic-gate } 3047c478bd9Sstevel@tonic-gate 3057c478bd9Sstevel@tonic-gate if (ltotal < rtotal) 30630ef842dSbmc return (DT_LESSTHAN); 30730ef842dSbmc 30830ef842dSbmc if (ltotal > rtotal) 30930ef842dSbmc return (DT_GREATERTHAN); 3107c478bd9Sstevel@tonic-gate 311187eccf8Sbmc /* 312187eccf8Sbmc * If they're both equal, then we will compare based on the weights at 313187eccf8Sbmc * zero. If the weights at zero are equal, then this will be judged a 314187eccf8Sbmc * tie and will be resolved based on the key comparison. 315187eccf8Sbmc */ 316187eccf8Sbmc if (lzero < rzero) 31730ef842dSbmc return (DT_LESSTHAN); 31830ef842dSbmc 31930ef842dSbmc if (lzero > rzero) 32030ef842dSbmc return (DT_GREATERTHAN); 321187eccf8Sbmc 3227c478bd9Sstevel@tonic-gate return (0); 3237c478bd9Sstevel@tonic-gate } 3247c478bd9Sstevel@tonic-gate 325a1b5e537Sbmc static void 326a1b5e537Sbmc dt_aggregate_usym(dtrace_hdl_t *dtp, uint64_t *data) 327a1b5e537Sbmc { 328a1b5e537Sbmc uint64_t pid = data[0]; 329a1b5e537Sbmc uint64_t *pc = &data[1]; 330a1b5e537Sbmc struct ps_prochandle *P; 331a1b5e537Sbmc GElf_Sym sym; 332a1b5e537Sbmc 333a1b5e537Sbmc if (dtp->dt_vector != NULL) 334a1b5e537Sbmc return; 335a1b5e537Sbmc 336a1b5e537Sbmc if ((P = dt_proc_grab(dtp, pid, PGRAB_RDONLY | PGRAB_FORCE, 0)) == NULL) 337a1b5e537Sbmc return; 338a1b5e537Sbmc 339a1b5e537Sbmc dt_proc_lock(dtp, P); 340a1b5e537Sbmc 341a1b5e537Sbmc if (Plookup_by_addr(P, *pc, NULL, 0, &sym) == 0) 342a1b5e537Sbmc *pc = sym.st_value; 343a1b5e537Sbmc 344a1b5e537Sbmc dt_proc_unlock(dtp, P); 345a1b5e537Sbmc dt_proc_release(dtp, P); 346a1b5e537Sbmc } 347a1b5e537Sbmc 348a1b5e537Sbmc static void 349a1b5e537Sbmc dt_aggregate_umod(dtrace_hdl_t *dtp, uint64_t *data) 350a1b5e537Sbmc { 351a1b5e537Sbmc uint64_t pid = data[0]; 352a1b5e537Sbmc uint64_t *pc = &data[1]; 353a1b5e537Sbmc struct ps_prochandle *P; 354a1b5e537Sbmc const prmap_t *map; 355a1b5e537Sbmc 356a1b5e537Sbmc if (dtp->dt_vector != NULL) 357a1b5e537Sbmc return; 358a1b5e537Sbmc 359a1b5e537Sbmc if ((P = dt_proc_grab(dtp, pid, PGRAB_RDONLY | PGRAB_FORCE, 0)) == NULL) 360a1b5e537Sbmc return; 361a1b5e537Sbmc 362a1b5e537Sbmc dt_proc_lock(dtp, P); 363a1b5e537Sbmc 364a1b5e537Sbmc if ((map = Paddr_to_map(P, *pc)) != NULL) 365a1b5e537Sbmc *pc = map->pr_vaddr; 366a1b5e537Sbmc 367a1b5e537Sbmc dt_proc_unlock(dtp, P); 368a1b5e537Sbmc dt_proc_release(dtp, P); 369a1b5e537Sbmc } 370a1b5e537Sbmc 371a1b5e537Sbmc static void 372a1b5e537Sbmc dt_aggregate_sym(dtrace_hdl_t *dtp, uint64_t *data) 373a1b5e537Sbmc { 374a1b5e537Sbmc GElf_Sym sym; 375a1b5e537Sbmc uint64_t *pc = data; 376a1b5e537Sbmc 377a1b5e537Sbmc if (dtrace_lookup_by_addr(dtp, *pc, &sym, NULL) == 0) 378a1b5e537Sbmc *pc = sym.st_value; 379a1b5e537Sbmc } 380a1b5e537Sbmc 381a1b5e537Sbmc static void 382a1b5e537Sbmc dt_aggregate_mod(dtrace_hdl_t *dtp, uint64_t *data) 383a1b5e537Sbmc { 384a1b5e537Sbmc uint64_t *pc = data; 385a1b5e537Sbmc dt_module_t *dmp; 386a1b5e537Sbmc 387a1b5e537Sbmc if (dtp->dt_vector != NULL) { 388a1b5e537Sbmc /* 389a1b5e537Sbmc * We don't have a way of just getting the module for a 390a1b5e537Sbmc * vectored open, and it doesn't seem to be worth defining 391a1b5e537Sbmc * one. This means that use of mod() won't get true 392a1b5e537Sbmc * aggregation in the postmortem case (some modules may 393a1b5e537Sbmc * appear more than once in aggregation output). It seems 394a1b5e537Sbmc * unlikely that anyone will ever notice or care... 395a1b5e537Sbmc */ 396a1b5e537Sbmc return; 397a1b5e537Sbmc } 398a1b5e537Sbmc 399a1b5e537Sbmc for (dmp = dt_list_next(&dtp->dt_modlist); dmp != NULL; 400a1b5e537Sbmc dmp = dt_list_next(dmp)) { 401a1b5e537Sbmc if (*pc - dmp->dm_text_va < dmp->dm_text_size) { 402a1b5e537Sbmc *pc = dmp->dm_text_va; 403a1b5e537Sbmc return; 404a1b5e537Sbmc } 405a1b5e537Sbmc } 406a1b5e537Sbmc } 407a1b5e537Sbmc 40830ef842dSbmc static dtrace_aggvarid_t 40930ef842dSbmc dt_aggregate_aggvarid(dt_ahashent_t *ent) 41030ef842dSbmc { 41130ef842dSbmc dtrace_aggdesc_t *agg = ent->dtahe_data.dtada_desc; 41230ef842dSbmc caddr_t data = ent->dtahe_data.dtada_data; 41330ef842dSbmc dtrace_recdesc_t *rec = agg->dtagd_rec; 41430ef842dSbmc 41530ef842dSbmc /* 41630ef842dSbmc * First, we'll check the variable ID in the aggdesc. If it's valid, 41730ef842dSbmc * we'll return it. If not, we'll use the compiler-generated ID 41830ef842dSbmc * present as the first record. 41930ef842dSbmc */ 42030ef842dSbmc if (agg->dtagd_varid != DTRACE_AGGVARIDNONE) 42130ef842dSbmc return (agg->dtagd_varid); 42230ef842dSbmc 42330ef842dSbmc agg->dtagd_varid = *((dtrace_aggvarid_t *)(uintptr_t)(data + 42430ef842dSbmc rec->dtrd_offset)); 42530ef842dSbmc 42630ef842dSbmc return (agg->dtagd_varid); 42730ef842dSbmc } 42830ef842dSbmc 42930ef842dSbmc 4307c478bd9Sstevel@tonic-gate static int 4317c478bd9Sstevel@tonic-gate dt_aggregate_snap_cpu(dtrace_hdl_t *dtp, processorid_t cpu) 4327c478bd9Sstevel@tonic-gate { 4337c478bd9Sstevel@tonic-gate dtrace_epid_t id; 4347c478bd9Sstevel@tonic-gate uint64_t hashval; 4357c478bd9Sstevel@tonic-gate size_t offs, roffs, size, ndx; 4367c478bd9Sstevel@tonic-gate int i, j, rval; 4377c478bd9Sstevel@tonic-gate caddr_t addr, data; 4387c478bd9Sstevel@tonic-gate dtrace_recdesc_t *rec; 4397c478bd9Sstevel@tonic-gate dt_aggregate_t *agp = &dtp->dt_aggregate; 4407c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *agg; 4417c478bd9Sstevel@tonic-gate dt_ahash_t *hash = &agp->dtat_hash; 4427c478bd9Sstevel@tonic-gate dt_ahashent_t *h; 4437c478bd9Sstevel@tonic-gate dtrace_bufdesc_t b = agp->dtat_buf, *buf = &b; 4447c478bd9Sstevel@tonic-gate dtrace_aggdata_t *aggdata; 4457c478bd9Sstevel@tonic-gate int flags = agp->dtat_flags; 4467c478bd9Sstevel@tonic-gate 4477c478bd9Sstevel@tonic-gate buf->dtbd_cpu = cpu; 4487c478bd9Sstevel@tonic-gate 4497c478bd9Sstevel@tonic-gate if (dt_ioctl(dtp, DTRACEIOC_AGGSNAP, buf) == -1) { 4507c478bd9Sstevel@tonic-gate if (errno == ENOENT) { 4517c478bd9Sstevel@tonic-gate /* 4527c478bd9Sstevel@tonic-gate * If that failed with ENOENT, it may be because the 4537c478bd9Sstevel@tonic-gate * CPU was unconfigured. This is okay; we'll just 4547c478bd9Sstevel@tonic-gate * do nothing but return success. 4557c478bd9Sstevel@tonic-gate */ 4567c478bd9Sstevel@tonic-gate return (0); 4577c478bd9Sstevel@tonic-gate } 4587c478bd9Sstevel@tonic-gate 4597c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, errno)); 4607c478bd9Sstevel@tonic-gate } 4617c478bd9Sstevel@tonic-gate 4627c478bd9Sstevel@tonic-gate if (buf->dtbd_drops != 0) { 4637c478bd9Sstevel@tonic-gate if (dt_handle_cpudrop(dtp, cpu, 4647c478bd9Sstevel@tonic-gate DTRACEDROP_AGGREGATION, buf->dtbd_drops) == -1) 4657c478bd9Sstevel@tonic-gate return (-1); 4667c478bd9Sstevel@tonic-gate } 4677c478bd9Sstevel@tonic-gate 4687c478bd9Sstevel@tonic-gate if (buf->dtbd_size == 0) 4697c478bd9Sstevel@tonic-gate return (0); 4707c478bd9Sstevel@tonic-gate 4717c478bd9Sstevel@tonic-gate if (hash->dtah_hash == NULL) { 4727c478bd9Sstevel@tonic-gate size_t size; 4737c478bd9Sstevel@tonic-gate 4747c478bd9Sstevel@tonic-gate hash->dtah_size = DTRACE_AHASHSIZE; 4757c478bd9Sstevel@tonic-gate size = hash->dtah_size * sizeof (dt_ahashent_t *); 4767c478bd9Sstevel@tonic-gate 4777c478bd9Sstevel@tonic-gate if ((hash->dtah_hash = malloc(size)) == NULL) 4787c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_NOMEM)); 4797c478bd9Sstevel@tonic-gate 4807c478bd9Sstevel@tonic-gate bzero(hash->dtah_hash, size); 4817c478bd9Sstevel@tonic-gate } 4827c478bd9Sstevel@tonic-gate 4837c478bd9Sstevel@tonic-gate for (offs = 0; offs < buf->dtbd_size; ) { 4847c478bd9Sstevel@tonic-gate /* 4857c478bd9Sstevel@tonic-gate * We're guaranteed to have an ID. 4867c478bd9Sstevel@tonic-gate */ 4877c478bd9Sstevel@tonic-gate id = *((dtrace_epid_t *)((uintptr_t)buf->dtbd_data + 4887c478bd9Sstevel@tonic-gate (uintptr_t)offs)); 4897c478bd9Sstevel@tonic-gate 4907c478bd9Sstevel@tonic-gate if (id == DTRACE_AGGIDNONE) { 4917c478bd9Sstevel@tonic-gate /* 4927c478bd9Sstevel@tonic-gate * This is filler to assure proper alignment of the 4937c478bd9Sstevel@tonic-gate * next record; we simply ignore it. 4947c478bd9Sstevel@tonic-gate */ 4957c478bd9Sstevel@tonic-gate offs += sizeof (id); 4967c478bd9Sstevel@tonic-gate continue; 4977c478bd9Sstevel@tonic-gate } 4987c478bd9Sstevel@tonic-gate 4997c478bd9Sstevel@tonic-gate if ((rval = dt_aggid_lookup(dtp, id, &agg)) != 0) 5007c478bd9Sstevel@tonic-gate return (rval); 5017c478bd9Sstevel@tonic-gate 5027c478bd9Sstevel@tonic-gate addr = buf->dtbd_data + offs; 5037c478bd9Sstevel@tonic-gate size = agg->dtagd_size; 5047c478bd9Sstevel@tonic-gate hashval = 0; 5057c478bd9Sstevel@tonic-gate 5067c478bd9Sstevel@tonic-gate for (j = 0; j < agg->dtagd_nrecs - 1; j++) { 5077c478bd9Sstevel@tonic-gate rec = &agg->dtagd_rec[j]; 5087c478bd9Sstevel@tonic-gate roffs = rec->dtrd_offset; 5097c478bd9Sstevel@tonic-gate 510a1b5e537Sbmc switch (rec->dtrd_action) { 511a1b5e537Sbmc case DTRACEACT_USYM: 512a1b5e537Sbmc dt_aggregate_usym(dtp, 513a1b5e537Sbmc /* LINTED - alignment */ 514a1b5e537Sbmc (uint64_t *)&addr[roffs]); 515a1b5e537Sbmc break; 516a1b5e537Sbmc 517a1b5e537Sbmc case DTRACEACT_UMOD: 518a1b5e537Sbmc dt_aggregate_umod(dtp, 519a1b5e537Sbmc /* LINTED - alignment */ 520a1b5e537Sbmc (uint64_t *)&addr[roffs]); 521a1b5e537Sbmc break; 522a1b5e537Sbmc 523a1b5e537Sbmc case DTRACEACT_SYM: 524a1b5e537Sbmc /* LINTED - alignment */ 525a1b5e537Sbmc dt_aggregate_sym(dtp, (uint64_t *)&addr[roffs]); 526a1b5e537Sbmc break; 527a1b5e537Sbmc 528a1b5e537Sbmc case DTRACEACT_MOD: 529a1b5e537Sbmc /* LINTED - alignment */ 530a1b5e537Sbmc dt_aggregate_mod(dtp, (uint64_t *)&addr[roffs]); 531a1b5e537Sbmc break; 532a1b5e537Sbmc 533a1b5e537Sbmc default: 534a1b5e537Sbmc break; 535a1b5e537Sbmc } 536a1b5e537Sbmc 5377c478bd9Sstevel@tonic-gate for (i = 0; i < rec->dtrd_size; i++) 5387c478bd9Sstevel@tonic-gate hashval += addr[roffs + i]; 5397c478bd9Sstevel@tonic-gate } 5407c478bd9Sstevel@tonic-gate 5417c478bd9Sstevel@tonic-gate ndx = hashval % hash->dtah_size; 5427c478bd9Sstevel@tonic-gate 5437c478bd9Sstevel@tonic-gate for (h = hash->dtah_hash[ndx]; h != NULL; h = h->dtahe_next) { 5447c478bd9Sstevel@tonic-gate if (h->dtahe_hashval != hashval) 5457c478bd9Sstevel@tonic-gate continue; 5467c478bd9Sstevel@tonic-gate 5477c478bd9Sstevel@tonic-gate if (h->dtahe_size != size) 5487c478bd9Sstevel@tonic-gate continue; 5497c478bd9Sstevel@tonic-gate 5507c478bd9Sstevel@tonic-gate aggdata = &h->dtahe_data; 5517c478bd9Sstevel@tonic-gate data = aggdata->dtada_data; 5527c478bd9Sstevel@tonic-gate 5537c478bd9Sstevel@tonic-gate for (j = 0; j < agg->dtagd_nrecs - 1; j++) { 5547c478bd9Sstevel@tonic-gate rec = &agg->dtagd_rec[j]; 5557c478bd9Sstevel@tonic-gate roffs = rec->dtrd_offset; 5567c478bd9Sstevel@tonic-gate 5577c478bd9Sstevel@tonic-gate for (i = 0; i < rec->dtrd_size; i++) 5587c478bd9Sstevel@tonic-gate if (addr[roffs + i] != data[roffs + i]) 5597c478bd9Sstevel@tonic-gate goto hashnext; 5607c478bd9Sstevel@tonic-gate } 5617c478bd9Sstevel@tonic-gate 5627c478bd9Sstevel@tonic-gate /* 5637c478bd9Sstevel@tonic-gate * We found it. Now we need to apply the aggregating 5647c478bd9Sstevel@tonic-gate * action on the data here. 5657c478bd9Sstevel@tonic-gate */ 5667c478bd9Sstevel@tonic-gate rec = &agg->dtagd_rec[agg->dtagd_nrecs - 1]; 5677c478bd9Sstevel@tonic-gate roffs = rec->dtrd_offset; 5687c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 569187eccf8Sbmc h->dtahe_aggregate((int64_t *)&data[roffs], 5707c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 571187eccf8Sbmc (int64_t *)&addr[roffs], rec->dtrd_size); 5727c478bd9Sstevel@tonic-gate 5737c478bd9Sstevel@tonic-gate /* 5747c478bd9Sstevel@tonic-gate * If we're keeping per CPU data, apply the aggregating 5757c478bd9Sstevel@tonic-gate * action there as well. 5767c478bd9Sstevel@tonic-gate */ 5777c478bd9Sstevel@tonic-gate if (aggdata->dtada_percpu != NULL) { 5787c478bd9Sstevel@tonic-gate data = aggdata->dtada_percpu[cpu]; 5797c478bd9Sstevel@tonic-gate 5807c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 581187eccf8Sbmc h->dtahe_aggregate((int64_t *)data, 5827c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 583187eccf8Sbmc (int64_t *)&addr[roffs], rec->dtrd_size); 5847c478bd9Sstevel@tonic-gate } 5857c478bd9Sstevel@tonic-gate 5867c478bd9Sstevel@tonic-gate goto bufnext; 5877c478bd9Sstevel@tonic-gate hashnext: 5887c478bd9Sstevel@tonic-gate continue; 5897c478bd9Sstevel@tonic-gate } 5907c478bd9Sstevel@tonic-gate 5917c478bd9Sstevel@tonic-gate /* 5927c478bd9Sstevel@tonic-gate * If we're here, we couldn't find an entry for this record. 5937c478bd9Sstevel@tonic-gate */ 5947c478bd9Sstevel@tonic-gate if ((h = malloc(sizeof (dt_ahashent_t))) == NULL) 5957c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_NOMEM)); 5967c478bd9Sstevel@tonic-gate bzero(h, sizeof (dt_ahashent_t)); 5977c478bd9Sstevel@tonic-gate aggdata = &h->dtahe_data; 5987c478bd9Sstevel@tonic-gate 5997c478bd9Sstevel@tonic-gate if ((aggdata->dtada_data = malloc(size)) == NULL) { 6007c478bd9Sstevel@tonic-gate free(h); 6017c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_NOMEM)); 6027c478bd9Sstevel@tonic-gate } 6037c478bd9Sstevel@tonic-gate 6047c478bd9Sstevel@tonic-gate bcopy(addr, aggdata->dtada_data, size); 6057c478bd9Sstevel@tonic-gate aggdata->dtada_size = size; 6067c478bd9Sstevel@tonic-gate aggdata->dtada_desc = agg; 6077c478bd9Sstevel@tonic-gate aggdata->dtada_handle = dtp; 6087c478bd9Sstevel@tonic-gate (void) dt_epid_lookup(dtp, agg->dtagd_epid, 6097c478bd9Sstevel@tonic-gate &aggdata->dtada_edesc, &aggdata->dtada_pdesc); 6107c478bd9Sstevel@tonic-gate aggdata->dtada_normal = 1; 6117c478bd9Sstevel@tonic-gate 6127c478bd9Sstevel@tonic-gate h->dtahe_hashval = hashval; 6137c478bd9Sstevel@tonic-gate h->dtahe_size = size; 61430ef842dSbmc (void) dt_aggregate_aggvarid(h); 6157c478bd9Sstevel@tonic-gate 6167c478bd9Sstevel@tonic-gate rec = &agg->dtagd_rec[agg->dtagd_nrecs - 1]; 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate if (flags & DTRACE_A_PERCPU) { 6197c478bd9Sstevel@tonic-gate int max_cpus = agp->dtat_maxcpu; 6207c478bd9Sstevel@tonic-gate caddr_t *percpu = malloc(max_cpus * sizeof (caddr_t)); 6217c478bd9Sstevel@tonic-gate 6227c478bd9Sstevel@tonic-gate if (percpu == NULL) { 6237c478bd9Sstevel@tonic-gate free(aggdata->dtada_data); 6247c478bd9Sstevel@tonic-gate free(h); 6257c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_NOMEM)); 6267c478bd9Sstevel@tonic-gate } 6277c478bd9Sstevel@tonic-gate 6287c478bd9Sstevel@tonic-gate for (j = 0; j < max_cpus; j++) { 6297c478bd9Sstevel@tonic-gate percpu[j] = malloc(rec->dtrd_size); 6307c478bd9Sstevel@tonic-gate 6317c478bd9Sstevel@tonic-gate if (percpu[j] == NULL) { 6327c478bd9Sstevel@tonic-gate while (--j >= 0) 6337c478bd9Sstevel@tonic-gate free(percpu[j]); 6347c478bd9Sstevel@tonic-gate 6357c478bd9Sstevel@tonic-gate free(aggdata->dtada_data); 6367c478bd9Sstevel@tonic-gate free(h); 6377c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_NOMEM)); 6387c478bd9Sstevel@tonic-gate } 6397c478bd9Sstevel@tonic-gate 6407c478bd9Sstevel@tonic-gate if (j == cpu) { 6417c478bd9Sstevel@tonic-gate bcopy(&addr[rec->dtrd_offset], 6427c478bd9Sstevel@tonic-gate percpu[j], rec->dtrd_size); 6437c478bd9Sstevel@tonic-gate } else { 6447c478bd9Sstevel@tonic-gate bzero(percpu[j], rec->dtrd_size); 6457c478bd9Sstevel@tonic-gate } 6467c478bd9Sstevel@tonic-gate } 6477c478bd9Sstevel@tonic-gate 6487c478bd9Sstevel@tonic-gate aggdata->dtada_percpu = percpu; 6497c478bd9Sstevel@tonic-gate } 6507c478bd9Sstevel@tonic-gate 6517c478bd9Sstevel@tonic-gate switch (rec->dtrd_action) { 6527c478bd9Sstevel@tonic-gate case DTRACEAGG_MIN: 6537c478bd9Sstevel@tonic-gate h->dtahe_aggregate = dt_aggregate_min; 6547c478bd9Sstevel@tonic-gate break; 6557c478bd9Sstevel@tonic-gate 6567c478bd9Sstevel@tonic-gate case DTRACEAGG_MAX: 6577c478bd9Sstevel@tonic-gate h->dtahe_aggregate = dt_aggregate_max; 6587c478bd9Sstevel@tonic-gate break; 6597c478bd9Sstevel@tonic-gate 6607c478bd9Sstevel@tonic-gate case DTRACEAGG_LQUANTIZE: 6617c478bd9Sstevel@tonic-gate h->dtahe_aggregate = dt_aggregate_lquantize; 6627c478bd9Sstevel@tonic-gate break; 6637c478bd9Sstevel@tonic-gate 664*2b6389efSBryan Cantrill case DTRACEAGG_LLQUANTIZE: 665*2b6389efSBryan Cantrill h->dtahe_aggregate = dt_aggregate_llquantize; 666*2b6389efSBryan Cantrill break; 667*2b6389efSBryan Cantrill 6687c478bd9Sstevel@tonic-gate case DTRACEAGG_COUNT: 6697c478bd9Sstevel@tonic-gate case DTRACEAGG_SUM: 6707c478bd9Sstevel@tonic-gate case DTRACEAGG_AVG: 6716e0bee74Sjhaslam case DTRACEAGG_STDDEV: 6727c478bd9Sstevel@tonic-gate case DTRACEAGG_QUANTIZE: 6737c478bd9Sstevel@tonic-gate h->dtahe_aggregate = dt_aggregate_count; 6747c478bd9Sstevel@tonic-gate break; 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate default: 6777c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_BADAGG)); 6787c478bd9Sstevel@tonic-gate } 6797c478bd9Sstevel@tonic-gate 6807c478bd9Sstevel@tonic-gate if (hash->dtah_hash[ndx] != NULL) 6817c478bd9Sstevel@tonic-gate hash->dtah_hash[ndx]->dtahe_prev = h; 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate h->dtahe_next = hash->dtah_hash[ndx]; 6847c478bd9Sstevel@tonic-gate hash->dtah_hash[ndx] = h; 6857c478bd9Sstevel@tonic-gate 6867c478bd9Sstevel@tonic-gate if (hash->dtah_all != NULL) 6877c478bd9Sstevel@tonic-gate hash->dtah_all->dtahe_prevall = h; 6887c478bd9Sstevel@tonic-gate 6897c478bd9Sstevel@tonic-gate h->dtahe_nextall = hash->dtah_all; 6907c478bd9Sstevel@tonic-gate hash->dtah_all = h; 6917c478bd9Sstevel@tonic-gate bufnext: 6927c478bd9Sstevel@tonic-gate offs += agg->dtagd_size; 6937c478bd9Sstevel@tonic-gate } 6947c478bd9Sstevel@tonic-gate 6957c478bd9Sstevel@tonic-gate return (0); 6967c478bd9Sstevel@tonic-gate } 6977c478bd9Sstevel@tonic-gate 6987c478bd9Sstevel@tonic-gate int 6997c478bd9Sstevel@tonic-gate dtrace_aggregate_snap(dtrace_hdl_t *dtp) 7007c478bd9Sstevel@tonic-gate { 7017c478bd9Sstevel@tonic-gate int i, rval; 7027c478bd9Sstevel@tonic-gate dt_aggregate_t *agp = &dtp->dt_aggregate; 7037c478bd9Sstevel@tonic-gate hrtime_t now = gethrtime(); 7047c478bd9Sstevel@tonic-gate dtrace_optval_t interval = dtp->dt_options[DTRACEOPT_AGGRATE]; 7057c478bd9Sstevel@tonic-gate 7067c478bd9Sstevel@tonic-gate if (dtp->dt_lastagg != 0) { 7077c478bd9Sstevel@tonic-gate if (now - dtp->dt_lastagg < interval) 7087c478bd9Sstevel@tonic-gate return (0); 7097c478bd9Sstevel@tonic-gate 7107c478bd9Sstevel@tonic-gate dtp->dt_lastagg += interval; 7117c478bd9Sstevel@tonic-gate } else { 7127c478bd9Sstevel@tonic-gate dtp->dt_lastagg = now; 7137c478bd9Sstevel@tonic-gate } 7147c478bd9Sstevel@tonic-gate 7157c478bd9Sstevel@tonic-gate if (!dtp->dt_active) 7167c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EINVAL)); 7177c478bd9Sstevel@tonic-gate 7187c478bd9Sstevel@tonic-gate if (agp->dtat_buf.dtbd_size == 0) 7197c478bd9Sstevel@tonic-gate return (0); 7207c478bd9Sstevel@tonic-gate 7217c478bd9Sstevel@tonic-gate for (i = 0; i < agp->dtat_ncpus; i++) { 7227c478bd9Sstevel@tonic-gate if (rval = dt_aggregate_snap_cpu(dtp, agp->dtat_cpus[i])) 7237c478bd9Sstevel@tonic-gate return (rval); 7247c478bd9Sstevel@tonic-gate } 7257c478bd9Sstevel@tonic-gate 7267c478bd9Sstevel@tonic-gate return (0); 7277c478bd9Sstevel@tonic-gate } 7287c478bd9Sstevel@tonic-gate 7297c478bd9Sstevel@tonic-gate static int 7307c478bd9Sstevel@tonic-gate dt_aggregate_hashcmp(const void *lhs, const void *rhs) 7317c478bd9Sstevel@tonic-gate { 7327c478bd9Sstevel@tonic-gate dt_ahashent_t *lh = *((dt_ahashent_t **)lhs); 7337c478bd9Sstevel@tonic-gate dt_ahashent_t *rh = *((dt_ahashent_t **)rhs); 7347c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *lagg = lh->dtahe_data.dtada_desc; 7357c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *ragg = rh->dtahe_data.dtada_desc; 7367c478bd9Sstevel@tonic-gate 7377c478bd9Sstevel@tonic-gate if (lagg->dtagd_nrecs < ragg->dtagd_nrecs) 73830ef842dSbmc return (DT_LESSTHAN); 7397c478bd9Sstevel@tonic-gate 7407c478bd9Sstevel@tonic-gate if (lagg->dtagd_nrecs > ragg->dtagd_nrecs) 74130ef842dSbmc return (DT_GREATERTHAN); 7427c478bd9Sstevel@tonic-gate 7437c478bd9Sstevel@tonic-gate return (0); 7447c478bd9Sstevel@tonic-gate } 7457c478bd9Sstevel@tonic-gate 7467c478bd9Sstevel@tonic-gate static int 7477c478bd9Sstevel@tonic-gate dt_aggregate_varcmp(const void *lhs, const void *rhs) 7487c478bd9Sstevel@tonic-gate { 7497c478bd9Sstevel@tonic-gate dt_ahashent_t *lh = *((dt_ahashent_t **)lhs); 7507c478bd9Sstevel@tonic-gate dt_ahashent_t *rh = *((dt_ahashent_t **)rhs); 75130ef842dSbmc dtrace_aggvarid_t lid, rid; 7527c478bd9Sstevel@tonic-gate 75330ef842dSbmc lid = dt_aggregate_aggvarid(lh); 75430ef842dSbmc rid = dt_aggregate_aggvarid(rh); 7557c478bd9Sstevel@tonic-gate 7567c478bd9Sstevel@tonic-gate if (lid < rid) 75730ef842dSbmc return (DT_LESSTHAN); 7587c478bd9Sstevel@tonic-gate 7597c478bd9Sstevel@tonic-gate if (lid > rid) 76030ef842dSbmc return (DT_GREATERTHAN); 7617c478bd9Sstevel@tonic-gate 7627c478bd9Sstevel@tonic-gate return (0); 7637c478bd9Sstevel@tonic-gate } 7647c478bd9Sstevel@tonic-gate 7657c478bd9Sstevel@tonic-gate static int 7667c478bd9Sstevel@tonic-gate dt_aggregate_keycmp(const void *lhs, const void *rhs) 7677c478bd9Sstevel@tonic-gate { 7687c478bd9Sstevel@tonic-gate dt_ahashent_t *lh = *((dt_ahashent_t **)lhs); 7697c478bd9Sstevel@tonic-gate dt_ahashent_t *rh = *((dt_ahashent_t **)rhs); 7707c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *lagg = lh->dtahe_data.dtada_desc; 7717c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *ragg = rh->dtahe_data.dtada_desc; 7727c478bd9Sstevel@tonic-gate dtrace_recdesc_t *lrec, *rrec; 7737c478bd9Sstevel@tonic-gate char *ldata, *rdata; 77430ef842dSbmc int rval, i, j, keypos, nrecs; 7757c478bd9Sstevel@tonic-gate 7767c478bd9Sstevel@tonic-gate if ((rval = dt_aggregate_hashcmp(lhs, rhs)) != 0) 7777c478bd9Sstevel@tonic-gate return (rval); 7787c478bd9Sstevel@tonic-gate 77930ef842dSbmc nrecs = lagg->dtagd_nrecs - 1; 78030ef842dSbmc assert(nrecs == ragg->dtagd_nrecs - 1); 78130ef842dSbmc 78230ef842dSbmc keypos = dt_keypos + 1 >= nrecs ? 0 : dt_keypos; 78330ef842dSbmc 78430ef842dSbmc for (i = 1; i < nrecs; i++) { 7857c478bd9Sstevel@tonic-gate uint64_t lval, rval; 78630ef842dSbmc int ndx = i + keypos; 7877c478bd9Sstevel@tonic-gate 78830ef842dSbmc if (ndx >= nrecs) 78930ef842dSbmc ndx = ndx - nrecs + 1; 79030ef842dSbmc 79130ef842dSbmc lrec = &lagg->dtagd_rec[ndx]; 79230ef842dSbmc rrec = &ragg->dtagd_rec[ndx]; 7937c478bd9Sstevel@tonic-gate 7947c478bd9Sstevel@tonic-gate ldata = lh->dtahe_data.dtada_data + lrec->dtrd_offset; 7957c478bd9Sstevel@tonic-gate rdata = rh->dtahe_data.dtada_data + rrec->dtrd_offset; 7967c478bd9Sstevel@tonic-gate 7977c478bd9Sstevel@tonic-gate if (lrec->dtrd_size < rrec->dtrd_size) 79830ef842dSbmc return (DT_LESSTHAN); 7997c478bd9Sstevel@tonic-gate 8007c478bd9Sstevel@tonic-gate if (lrec->dtrd_size > rrec->dtrd_size) 80130ef842dSbmc return (DT_GREATERTHAN); 8027c478bd9Sstevel@tonic-gate 8037c478bd9Sstevel@tonic-gate switch (lrec->dtrd_size) { 8047c478bd9Sstevel@tonic-gate case sizeof (uint64_t): 8057c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 8067c478bd9Sstevel@tonic-gate lval = *((uint64_t *)ldata); 8077c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 8087c478bd9Sstevel@tonic-gate rval = *((uint64_t *)rdata); 8097c478bd9Sstevel@tonic-gate break; 8107c478bd9Sstevel@tonic-gate 8117c478bd9Sstevel@tonic-gate case sizeof (uint32_t): 8127c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 8137c478bd9Sstevel@tonic-gate lval = *((uint32_t *)ldata); 8147c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 8157c478bd9Sstevel@tonic-gate rval = *((uint32_t *)rdata); 8167c478bd9Sstevel@tonic-gate break; 8177c478bd9Sstevel@tonic-gate 8187c478bd9Sstevel@tonic-gate case sizeof (uint16_t): 8197c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 8207c478bd9Sstevel@tonic-gate lval = *((uint16_t *)ldata); 8217c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 8227c478bd9Sstevel@tonic-gate rval = *((uint16_t *)rdata); 8237c478bd9Sstevel@tonic-gate break; 8247c478bd9Sstevel@tonic-gate 8257c478bd9Sstevel@tonic-gate case sizeof (uint8_t): 8267c478bd9Sstevel@tonic-gate lval = *((uint8_t *)ldata); 8277c478bd9Sstevel@tonic-gate rval = *((uint8_t *)rdata); 8287c478bd9Sstevel@tonic-gate break; 8297c478bd9Sstevel@tonic-gate 8307c478bd9Sstevel@tonic-gate default: 831127bbe13Stomee switch (lrec->dtrd_action) { 832127bbe13Stomee case DTRACEACT_UMOD: 833127bbe13Stomee case DTRACEACT_UADDR: 834127bbe13Stomee case DTRACEACT_USYM: 835127bbe13Stomee for (j = 0; j < 2; j++) { 836127bbe13Stomee /* LINTED - alignment */ 837127bbe13Stomee lval = ((uint64_t *)ldata)[j]; 838127bbe13Stomee /* LINTED - alignment */ 839127bbe13Stomee rval = ((uint64_t *)rdata)[j]; 840127bbe13Stomee 841127bbe13Stomee if (lval < rval) 842127bbe13Stomee return (DT_LESSTHAN); 843127bbe13Stomee 844127bbe13Stomee if (lval > rval) 845127bbe13Stomee return (DT_GREATERTHAN); 846127bbe13Stomee } 8477c478bd9Sstevel@tonic-gate 848127bbe13Stomee break; 8497c478bd9Sstevel@tonic-gate 850127bbe13Stomee default: 851127bbe13Stomee for (j = 0; j < lrec->dtrd_size; j++) { 852127bbe13Stomee lval = ((uint8_t *)ldata)[j]; 853127bbe13Stomee rval = ((uint8_t *)rdata)[j]; 85430ef842dSbmc 855127bbe13Stomee if (lval < rval) 856127bbe13Stomee return (DT_LESSTHAN); 857127bbe13Stomee 858127bbe13Stomee if (lval > rval) 859127bbe13Stomee return (DT_GREATERTHAN); 860127bbe13Stomee } 8617c478bd9Sstevel@tonic-gate } 8627c478bd9Sstevel@tonic-gate 8637c478bd9Sstevel@tonic-gate continue; 8647c478bd9Sstevel@tonic-gate } 8657c478bd9Sstevel@tonic-gate 8667c478bd9Sstevel@tonic-gate if (lval < rval) 86730ef842dSbmc return (DT_LESSTHAN); 8687c478bd9Sstevel@tonic-gate 8697c478bd9Sstevel@tonic-gate if (lval > rval) 87030ef842dSbmc return (DT_GREATERTHAN); 8717c478bd9Sstevel@tonic-gate } 8727c478bd9Sstevel@tonic-gate 8737c478bd9Sstevel@tonic-gate return (0); 8747c478bd9Sstevel@tonic-gate } 8757c478bd9Sstevel@tonic-gate 8767c478bd9Sstevel@tonic-gate static int 8777c478bd9Sstevel@tonic-gate dt_aggregate_valcmp(const void *lhs, const void *rhs) 8787c478bd9Sstevel@tonic-gate { 8797c478bd9Sstevel@tonic-gate dt_ahashent_t *lh = *((dt_ahashent_t **)lhs); 8807c478bd9Sstevel@tonic-gate dt_ahashent_t *rh = *((dt_ahashent_t **)rhs); 8817c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *lagg = lh->dtahe_data.dtada_desc; 8827c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *ragg = rh->dtahe_data.dtada_desc; 8837c478bd9Sstevel@tonic-gate caddr_t ldata = lh->dtahe_data.dtada_data; 8847c478bd9Sstevel@tonic-gate caddr_t rdata = rh->dtahe_data.dtada_data; 8857c478bd9Sstevel@tonic-gate dtrace_recdesc_t *lrec, *rrec; 886187eccf8Sbmc int64_t *laddr, *raddr; 8877c478bd9Sstevel@tonic-gate int rval, i; 8887c478bd9Sstevel@tonic-gate 8897c478bd9Sstevel@tonic-gate if ((rval = dt_aggregate_hashcmp(lhs, rhs)) != 0) 8907c478bd9Sstevel@tonic-gate return (rval); 8917c478bd9Sstevel@tonic-gate 8927c478bd9Sstevel@tonic-gate if (lagg->dtagd_nrecs > ragg->dtagd_nrecs) 89330ef842dSbmc return (DT_GREATERTHAN); 89430ef842dSbmc 89530ef842dSbmc if (lagg->dtagd_nrecs < ragg->dtagd_nrecs) 89630ef842dSbmc return (DT_LESSTHAN); 8977c478bd9Sstevel@tonic-gate 8987c478bd9Sstevel@tonic-gate for (i = 0; i < lagg->dtagd_nrecs; i++) { 8997c478bd9Sstevel@tonic-gate lrec = &lagg->dtagd_rec[i]; 9007c478bd9Sstevel@tonic-gate rrec = &ragg->dtagd_rec[i]; 9017c478bd9Sstevel@tonic-gate 9027c478bd9Sstevel@tonic-gate if (lrec->dtrd_offset < rrec->dtrd_offset) 90330ef842dSbmc return (DT_LESSTHAN); 9047c478bd9Sstevel@tonic-gate 9057c478bd9Sstevel@tonic-gate if (lrec->dtrd_offset > rrec->dtrd_offset) 90630ef842dSbmc return (DT_GREATERTHAN); 9077c478bd9Sstevel@tonic-gate 9087c478bd9Sstevel@tonic-gate if (lrec->dtrd_action < rrec->dtrd_action) 90930ef842dSbmc return (DT_LESSTHAN); 9107c478bd9Sstevel@tonic-gate 9117c478bd9Sstevel@tonic-gate if (lrec->dtrd_action > rrec->dtrd_action) 91230ef842dSbmc return (DT_GREATERTHAN); 9137c478bd9Sstevel@tonic-gate } 9147c478bd9Sstevel@tonic-gate 915187eccf8Sbmc laddr = (int64_t *)(uintptr_t)(ldata + lrec->dtrd_offset); 916187eccf8Sbmc raddr = (int64_t *)(uintptr_t)(rdata + rrec->dtrd_offset); 9177c478bd9Sstevel@tonic-gate 9187c478bd9Sstevel@tonic-gate switch (lrec->dtrd_action) { 9197c478bd9Sstevel@tonic-gate case DTRACEAGG_AVG: 9207c478bd9Sstevel@tonic-gate rval = dt_aggregate_averagecmp(laddr, raddr); 9217c478bd9Sstevel@tonic-gate break; 9227c478bd9Sstevel@tonic-gate 9236e0bee74Sjhaslam case DTRACEAGG_STDDEV: 9246e0bee74Sjhaslam rval = dt_aggregate_stddevcmp(laddr, raddr); 9256e0bee74Sjhaslam break; 9266e0bee74Sjhaslam 9277c478bd9Sstevel@tonic-gate case DTRACEAGG_QUANTIZE: 9287c478bd9Sstevel@tonic-gate rval = dt_aggregate_quantizedcmp(laddr, raddr); 9297c478bd9Sstevel@tonic-gate break; 9307c478bd9Sstevel@tonic-gate 9317c478bd9Sstevel@tonic-gate case DTRACEAGG_LQUANTIZE: 9327c478bd9Sstevel@tonic-gate rval = dt_aggregate_lquantizedcmp(laddr, raddr); 9337c478bd9Sstevel@tonic-gate break; 9347c478bd9Sstevel@tonic-gate 935*2b6389efSBryan Cantrill case DTRACEAGG_LLQUANTIZE: 936*2b6389efSBryan Cantrill rval = dt_aggregate_llquantizedcmp(laddr, raddr); 937*2b6389efSBryan Cantrill break; 938*2b6389efSBryan Cantrill 9397c478bd9Sstevel@tonic-gate case DTRACEAGG_COUNT: 9407c478bd9Sstevel@tonic-gate case DTRACEAGG_SUM: 9417c478bd9Sstevel@tonic-gate case DTRACEAGG_MIN: 9427c478bd9Sstevel@tonic-gate case DTRACEAGG_MAX: 9437c478bd9Sstevel@tonic-gate rval = dt_aggregate_countcmp(laddr, raddr); 9447c478bd9Sstevel@tonic-gate break; 9457c478bd9Sstevel@tonic-gate 9467c478bd9Sstevel@tonic-gate default: 9477c478bd9Sstevel@tonic-gate assert(0); 9487c478bd9Sstevel@tonic-gate } 9497c478bd9Sstevel@tonic-gate 95030ef842dSbmc return (rval); 95130ef842dSbmc } 95230ef842dSbmc 95330ef842dSbmc static int 95430ef842dSbmc dt_aggregate_valkeycmp(const void *lhs, const void *rhs) 95530ef842dSbmc { 95630ef842dSbmc int rval; 95730ef842dSbmc 95830ef842dSbmc if ((rval = dt_aggregate_valcmp(lhs, rhs)) != 0) 9597c478bd9Sstevel@tonic-gate return (rval); 9607c478bd9Sstevel@tonic-gate 9617c478bd9Sstevel@tonic-gate /* 9627c478bd9Sstevel@tonic-gate * If we're here, the values for the two aggregation elements are 9637c478bd9Sstevel@tonic-gate * equal. We already know that the key layout is the same for the two 9647c478bd9Sstevel@tonic-gate * elements; we must now compare the keys themselves as a tie-breaker. 9657c478bd9Sstevel@tonic-gate */ 9667c478bd9Sstevel@tonic-gate return (dt_aggregate_keycmp(lhs, rhs)); 9677c478bd9Sstevel@tonic-gate } 9687c478bd9Sstevel@tonic-gate 9697c478bd9Sstevel@tonic-gate static int 9707c478bd9Sstevel@tonic-gate dt_aggregate_keyvarcmp(const void *lhs, const void *rhs) 9717c478bd9Sstevel@tonic-gate { 9727c478bd9Sstevel@tonic-gate int rval; 9737c478bd9Sstevel@tonic-gate 9747c478bd9Sstevel@tonic-gate if ((rval = dt_aggregate_keycmp(lhs, rhs)) != 0) 9757c478bd9Sstevel@tonic-gate return (rval); 9767c478bd9Sstevel@tonic-gate 9777c478bd9Sstevel@tonic-gate return (dt_aggregate_varcmp(lhs, rhs)); 9787c478bd9Sstevel@tonic-gate } 9797c478bd9Sstevel@tonic-gate 9807c478bd9Sstevel@tonic-gate static int 9817c478bd9Sstevel@tonic-gate dt_aggregate_varkeycmp(const void *lhs, const void *rhs) 9827c478bd9Sstevel@tonic-gate { 9837c478bd9Sstevel@tonic-gate int rval; 9847c478bd9Sstevel@tonic-gate 9857c478bd9Sstevel@tonic-gate if ((rval = dt_aggregate_varcmp(lhs, rhs)) != 0) 9867c478bd9Sstevel@tonic-gate return (rval); 9877c478bd9Sstevel@tonic-gate 9887c478bd9Sstevel@tonic-gate return (dt_aggregate_keycmp(lhs, rhs)); 9897c478bd9Sstevel@tonic-gate } 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate static int 9927c478bd9Sstevel@tonic-gate dt_aggregate_valvarcmp(const void *lhs, const void *rhs) 9937c478bd9Sstevel@tonic-gate { 9947c478bd9Sstevel@tonic-gate int rval; 9957c478bd9Sstevel@tonic-gate 99630ef842dSbmc if ((rval = dt_aggregate_valkeycmp(lhs, rhs)) != 0) 9977c478bd9Sstevel@tonic-gate return (rval); 9987c478bd9Sstevel@tonic-gate 9997c478bd9Sstevel@tonic-gate return (dt_aggregate_varcmp(lhs, rhs)); 10007c478bd9Sstevel@tonic-gate } 10017c478bd9Sstevel@tonic-gate 10027c478bd9Sstevel@tonic-gate static int 10037c478bd9Sstevel@tonic-gate dt_aggregate_varvalcmp(const void *lhs, const void *rhs) 10047c478bd9Sstevel@tonic-gate { 10057c478bd9Sstevel@tonic-gate int rval; 10067c478bd9Sstevel@tonic-gate 10077c478bd9Sstevel@tonic-gate if ((rval = dt_aggregate_varcmp(lhs, rhs)) != 0) 10087c478bd9Sstevel@tonic-gate return (rval); 10097c478bd9Sstevel@tonic-gate 101030ef842dSbmc return (dt_aggregate_valkeycmp(lhs, rhs)); 10117c478bd9Sstevel@tonic-gate } 10127c478bd9Sstevel@tonic-gate 10137c478bd9Sstevel@tonic-gate static int 10147c478bd9Sstevel@tonic-gate dt_aggregate_keyvarrevcmp(const void *lhs, const void *rhs) 10157c478bd9Sstevel@tonic-gate { 10167c478bd9Sstevel@tonic-gate return (dt_aggregate_keyvarcmp(rhs, lhs)); 10177c478bd9Sstevel@tonic-gate } 10187c478bd9Sstevel@tonic-gate 10197c478bd9Sstevel@tonic-gate static int 10207c478bd9Sstevel@tonic-gate dt_aggregate_varkeyrevcmp(const void *lhs, const void *rhs) 10217c478bd9Sstevel@tonic-gate { 10227c478bd9Sstevel@tonic-gate return (dt_aggregate_varkeycmp(rhs, lhs)); 10237c478bd9Sstevel@tonic-gate } 10247c478bd9Sstevel@tonic-gate 10257c478bd9Sstevel@tonic-gate static int 10267c478bd9Sstevel@tonic-gate dt_aggregate_valvarrevcmp(const void *lhs, const void *rhs) 10277c478bd9Sstevel@tonic-gate { 10287c478bd9Sstevel@tonic-gate return (dt_aggregate_valvarcmp(rhs, lhs)); 10297c478bd9Sstevel@tonic-gate } 10307c478bd9Sstevel@tonic-gate 10317c478bd9Sstevel@tonic-gate static int 10327c478bd9Sstevel@tonic-gate dt_aggregate_varvalrevcmp(const void *lhs, const void *rhs) 10337c478bd9Sstevel@tonic-gate { 10347c478bd9Sstevel@tonic-gate return (dt_aggregate_varvalcmp(rhs, lhs)); 10357c478bd9Sstevel@tonic-gate } 10367c478bd9Sstevel@tonic-gate 103730ef842dSbmc static int 103830ef842dSbmc dt_aggregate_bundlecmp(const void *lhs, const void *rhs) 103930ef842dSbmc { 104030ef842dSbmc dt_ahashent_t **lh = *((dt_ahashent_t ***)lhs); 104130ef842dSbmc dt_ahashent_t **rh = *((dt_ahashent_t ***)rhs); 104230ef842dSbmc int i, rval; 104330ef842dSbmc 104430ef842dSbmc if (dt_keysort) { 104530ef842dSbmc /* 104630ef842dSbmc * If we're sorting on keys, we need to scan until we find the 104730ef842dSbmc * last entry -- that's the representative key. (The order of 104830ef842dSbmc * the bundle is values followed by key to accommodate the 104930ef842dSbmc * default behavior of sorting by value.) If the keys are 105030ef842dSbmc * equal, we'll fall into the value comparison loop, below. 105130ef842dSbmc */ 105230ef842dSbmc for (i = 0; lh[i + 1] != NULL; i++) 105330ef842dSbmc continue; 105430ef842dSbmc 105530ef842dSbmc assert(i != 0); 105630ef842dSbmc assert(rh[i + 1] == NULL); 105730ef842dSbmc 105830ef842dSbmc if ((rval = dt_aggregate_keycmp(&lh[i], &rh[i])) != 0) 105930ef842dSbmc return (rval); 106030ef842dSbmc } 106130ef842dSbmc 106230ef842dSbmc for (i = 0; ; i++) { 106330ef842dSbmc if (lh[i + 1] == NULL) { 106430ef842dSbmc /* 106530ef842dSbmc * All of the values are equal; if we're sorting on 106630ef842dSbmc * keys, then we're only here because the keys were 106730ef842dSbmc * found to be equal and these records are therefore 106830ef842dSbmc * equal. If we're not sorting on keys, we'll use the 106930ef842dSbmc * key comparison from the representative key as the 107030ef842dSbmc * tie-breaker. 107130ef842dSbmc */ 107230ef842dSbmc if (dt_keysort) 107330ef842dSbmc return (0); 107430ef842dSbmc 107530ef842dSbmc assert(i != 0); 107630ef842dSbmc assert(rh[i + 1] == NULL); 107730ef842dSbmc return (dt_aggregate_keycmp(&lh[i], &rh[i])); 107830ef842dSbmc } else { 107930ef842dSbmc if ((rval = dt_aggregate_valcmp(&lh[i], &rh[i])) != 0) 108030ef842dSbmc return (rval); 108130ef842dSbmc } 108230ef842dSbmc } 108330ef842dSbmc } 108430ef842dSbmc 10857c478bd9Sstevel@tonic-gate int 10867c478bd9Sstevel@tonic-gate dt_aggregate_go(dtrace_hdl_t *dtp) 10877c478bd9Sstevel@tonic-gate { 10887c478bd9Sstevel@tonic-gate dt_aggregate_t *agp = &dtp->dt_aggregate; 10897c478bd9Sstevel@tonic-gate dtrace_optval_t size, cpu; 10907c478bd9Sstevel@tonic-gate dtrace_bufdesc_t *buf = &agp->dtat_buf; 10917c478bd9Sstevel@tonic-gate int rval, i; 10927c478bd9Sstevel@tonic-gate 10937c478bd9Sstevel@tonic-gate assert(agp->dtat_maxcpu == 0); 10947c478bd9Sstevel@tonic-gate assert(agp->dtat_ncpu == 0); 10957c478bd9Sstevel@tonic-gate assert(agp->dtat_cpus == NULL); 10967c478bd9Sstevel@tonic-gate 10977c478bd9Sstevel@tonic-gate agp->dtat_maxcpu = dt_sysconf(dtp, _SC_CPUID_MAX) + 1; 10987c478bd9Sstevel@tonic-gate agp->dtat_ncpu = dt_sysconf(dtp, _SC_NPROCESSORS_MAX); 10997c478bd9Sstevel@tonic-gate agp->dtat_cpus = malloc(agp->dtat_ncpu * sizeof (processorid_t)); 11007c478bd9Sstevel@tonic-gate 11017c478bd9Sstevel@tonic-gate if (agp->dtat_cpus == NULL) 11027c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_NOMEM)); 11037c478bd9Sstevel@tonic-gate 11047c478bd9Sstevel@tonic-gate /* 11057c478bd9Sstevel@tonic-gate * Use the aggregation buffer size as reloaded from the kernel. 11067c478bd9Sstevel@tonic-gate */ 11077c478bd9Sstevel@tonic-gate size = dtp->dt_options[DTRACEOPT_AGGSIZE]; 11087c478bd9Sstevel@tonic-gate 11097c478bd9Sstevel@tonic-gate rval = dtrace_getopt(dtp, "aggsize", &size); 11107c478bd9Sstevel@tonic-gate assert(rval == 0); 11117c478bd9Sstevel@tonic-gate 11127c478bd9Sstevel@tonic-gate if (size == 0 || size == DTRACEOPT_UNSET) 11137c478bd9Sstevel@tonic-gate return (0); 11147c478bd9Sstevel@tonic-gate 11157c478bd9Sstevel@tonic-gate buf = &agp->dtat_buf; 11167c478bd9Sstevel@tonic-gate buf->dtbd_size = size; 11177c478bd9Sstevel@tonic-gate 11187c478bd9Sstevel@tonic-gate if ((buf->dtbd_data = malloc(buf->dtbd_size)) == NULL) 11197c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_NOMEM)); 11207c478bd9Sstevel@tonic-gate 11217c478bd9Sstevel@tonic-gate /* 11227c478bd9Sstevel@tonic-gate * Now query for the CPUs enabled. 11237c478bd9Sstevel@tonic-gate */ 11247c478bd9Sstevel@tonic-gate rval = dtrace_getopt(dtp, "cpu", &cpu); 11257c478bd9Sstevel@tonic-gate assert(rval == 0 && cpu != DTRACEOPT_UNSET); 11267c478bd9Sstevel@tonic-gate 11277c478bd9Sstevel@tonic-gate if (cpu != DTRACE_CPUALL) { 11287c478bd9Sstevel@tonic-gate assert(cpu < agp->dtat_ncpu); 11297c478bd9Sstevel@tonic-gate agp->dtat_cpus[agp->dtat_ncpus++] = (processorid_t)cpu; 11307c478bd9Sstevel@tonic-gate 11317c478bd9Sstevel@tonic-gate return (0); 11327c478bd9Sstevel@tonic-gate } 11337c478bd9Sstevel@tonic-gate 11347c478bd9Sstevel@tonic-gate agp->dtat_ncpus = 0; 11357c478bd9Sstevel@tonic-gate for (i = 0; i < agp->dtat_maxcpu; i++) { 11367c478bd9Sstevel@tonic-gate if (dt_status(dtp, i) == -1) 11377c478bd9Sstevel@tonic-gate continue; 11387c478bd9Sstevel@tonic-gate 11397c478bd9Sstevel@tonic-gate agp->dtat_cpus[agp->dtat_ncpus++] = i; 11407c478bd9Sstevel@tonic-gate } 11417c478bd9Sstevel@tonic-gate 11427c478bd9Sstevel@tonic-gate return (0); 11437c478bd9Sstevel@tonic-gate } 11447c478bd9Sstevel@tonic-gate 11457c478bd9Sstevel@tonic-gate static int 11467c478bd9Sstevel@tonic-gate dt_aggwalk_rval(dtrace_hdl_t *dtp, dt_ahashent_t *h, int rval) 11477c478bd9Sstevel@tonic-gate { 11487c478bd9Sstevel@tonic-gate dt_aggregate_t *agp = &dtp->dt_aggregate; 11497c478bd9Sstevel@tonic-gate dtrace_aggdata_t *data; 11507c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *aggdesc; 11517c478bd9Sstevel@tonic-gate dtrace_recdesc_t *rec; 11527c478bd9Sstevel@tonic-gate int i; 11537c478bd9Sstevel@tonic-gate 11547c478bd9Sstevel@tonic-gate switch (rval) { 11557c478bd9Sstevel@tonic-gate case DTRACE_AGGWALK_NEXT: 11567c478bd9Sstevel@tonic-gate break; 11577c478bd9Sstevel@tonic-gate 11587c478bd9Sstevel@tonic-gate case DTRACE_AGGWALK_CLEAR: { 11597c478bd9Sstevel@tonic-gate uint32_t size, offs = 0; 11607c478bd9Sstevel@tonic-gate 11617c478bd9Sstevel@tonic-gate aggdesc = h->dtahe_data.dtada_desc; 11627c478bd9Sstevel@tonic-gate rec = &aggdesc->dtagd_rec[aggdesc->dtagd_nrecs - 1]; 11637c478bd9Sstevel@tonic-gate size = rec->dtrd_size; 11647c478bd9Sstevel@tonic-gate data = &h->dtahe_data; 11657c478bd9Sstevel@tonic-gate 11667c478bd9Sstevel@tonic-gate if (rec->dtrd_action == DTRACEAGG_LQUANTIZE) { 11677c478bd9Sstevel@tonic-gate offs = sizeof (uint64_t); 11687c478bd9Sstevel@tonic-gate size -= sizeof (uint64_t); 11697c478bd9Sstevel@tonic-gate } 11707c478bd9Sstevel@tonic-gate 11717c478bd9Sstevel@tonic-gate bzero(&data->dtada_data[rec->dtrd_offset] + offs, size); 11727c478bd9Sstevel@tonic-gate 11737c478bd9Sstevel@tonic-gate if (data->dtada_percpu == NULL) 11747c478bd9Sstevel@tonic-gate break; 11757c478bd9Sstevel@tonic-gate 11767c478bd9Sstevel@tonic-gate for (i = 0; i < dtp->dt_aggregate.dtat_maxcpu; i++) 11777c478bd9Sstevel@tonic-gate bzero(data->dtada_percpu[i] + offs, size); 11787c478bd9Sstevel@tonic-gate break; 11797c478bd9Sstevel@tonic-gate } 11807c478bd9Sstevel@tonic-gate 11817c478bd9Sstevel@tonic-gate case DTRACE_AGGWALK_ERROR: 11827c478bd9Sstevel@tonic-gate /* 11837c478bd9Sstevel@tonic-gate * We assume that errno is already set in this case. 11847c478bd9Sstevel@tonic-gate */ 11857c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, errno)); 11867c478bd9Sstevel@tonic-gate 11877c478bd9Sstevel@tonic-gate case DTRACE_AGGWALK_ABORT: 11887c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_DIRABORT)); 11897c478bd9Sstevel@tonic-gate 11907c478bd9Sstevel@tonic-gate case DTRACE_AGGWALK_DENORMALIZE: 11917c478bd9Sstevel@tonic-gate h->dtahe_data.dtada_normal = 1; 11927c478bd9Sstevel@tonic-gate return (0); 11937c478bd9Sstevel@tonic-gate 11947c478bd9Sstevel@tonic-gate case DTRACE_AGGWALK_NORMALIZE: 11957c478bd9Sstevel@tonic-gate if (h->dtahe_data.dtada_normal == 0) { 11967c478bd9Sstevel@tonic-gate h->dtahe_data.dtada_normal = 1; 11977c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_BADRVAL)); 11987c478bd9Sstevel@tonic-gate } 11997c478bd9Sstevel@tonic-gate 12007c478bd9Sstevel@tonic-gate return (0); 12017c478bd9Sstevel@tonic-gate 12027c478bd9Sstevel@tonic-gate case DTRACE_AGGWALK_REMOVE: { 12037c478bd9Sstevel@tonic-gate dtrace_aggdata_t *aggdata = &h->dtahe_data; 12047c478bd9Sstevel@tonic-gate int i, max_cpus = agp->dtat_maxcpu; 12057c478bd9Sstevel@tonic-gate 12067c478bd9Sstevel@tonic-gate /* 12077c478bd9Sstevel@tonic-gate * First, remove this hash entry from its hash chain. 12087c478bd9Sstevel@tonic-gate */ 12097c478bd9Sstevel@tonic-gate if (h->dtahe_prev != NULL) { 12107c478bd9Sstevel@tonic-gate h->dtahe_prev->dtahe_next = h->dtahe_next; 12117c478bd9Sstevel@tonic-gate } else { 12127c478bd9Sstevel@tonic-gate dt_ahash_t *hash = &agp->dtat_hash; 12137c478bd9Sstevel@tonic-gate size_t ndx = h->dtahe_hashval % hash->dtah_size; 12147c478bd9Sstevel@tonic-gate 12157c478bd9Sstevel@tonic-gate assert(hash->dtah_hash[ndx] == h); 12167c478bd9Sstevel@tonic-gate hash->dtah_hash[ndx] = h->dtahe_next; 12177c478bd9Sstevel@tonic-gate } 12187c478bd9Sstevel@tonic-gate 12197c478bd9Sstevel@tonic-gate if (h->dtahe_next != NULL) 12207c478bd9Sstevel@tonic-gate h->dtahe_next->dtahe_prev = h->dtahe_prev; 12217c478bd9Sstevel@tonic-gate 12227c478bd9Sstevel@tonic-gate /* 12237c478bd9Sstevel@tonic-gate * Now remove it from the list of all hash entries. 12247c478bd9Sstevel@tonic-gate */ 12257c478bd9Sstevel@tonic-gate if (h->dtahe_prevall != NULL) { 12267c478bd9Sstevel@tonic-gate h->dtahe_prevall->dtahe_nextall = h->dtahe_nextall; 12277c478bd9Sstevel@tonic-gate } else { 12287c478bd9Sstevel@tonic-gate dt_ahash_t *hash = &agp->dtat_hash; 12297c478bd9Sstevel@tonic-gate 12307c478bd9Sstevel@tonic-gate assert(hash->dtah_all == h); 12317c478bd9Sstevel@tonic-gate hash->dtah_all = h->dtahe_nextall; 12327c478bd9Sstevel@tonic-gate } 12337c478bd9Sstevel@tonic-gate 12347c478bd9Sstevel@tonic-gate if (h->dtahe_nextall != NULL) 12357c478bd9Sstevel@tonic-gate h->dtahe_nextall->dtahe_prevall = h->dtahe_prevall; 12367c478bd9Sstevel@tonic-gate 12377c478bd9Sstevel@tonic-gate /* 12387c478bd9Sstevel@tonic-gate * We're unlinked. We can safely destroy the data. 12397c478bd9Sstevel@tonic-gate */ 12407c478bd9Sstevel@tonic-gate if (aggdata->dtada_percpu != NULL) { 12417c478bd9Sstevel@tonic-gate for (i = 0; i < max_cpus; i++) 12427c478bd9Sstevel@tonic-gate free(aggdata->dtada_percpu[i]); 12437c478bd9Sstevel@tonic-gate free(aggdata->dtada_percpu); 12447c478bd9Sstevel@tonic-gate } 12457c478bd9Sstevel@tonic-gate 12467c478bd9Sstevel@tonic-gate free(aggdata->dtada_data); 12477c478bd9Sstevel@tonic-gate free(h); 12487c478bd9Sstevel@tonic-gate 12497c478bd9Sstevel@tonic-gate return (0); 12507c478bd9Sstevel@tonic-gate } 12517c478bd9Sstevel@tonic-gate 12527c478bd9Sstevel@tonic-gate default: 12537c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_BADRVAL)); 12547c478bd9Sstevel@tonic-gate } 12557c478bd9Sstevel@tonic-gate 12567c478bd9Sstevel@tonic-gate return (0); 12577c478bd9Sstevel@tonic-gate } 12587c478bd9Sstevel@tonic-gate 125930ef842dSbmc void 126030ef842dSbmc dt_aggregate_qsort(dtrace_hdl_t *dtp, void *base, size_t nel, size_t width, 126130ef842dSbmc int (*compar)(const void *, const void *)) 126230ef842dSbmc { 126330ef842dSbmc int rev = dt_revsort, key = dt_keysort, keypos = dt_keypos; 126430ef842dSbmc dtrace_optval_t keyposopt = dtp->dt_options[DTRACEOPT_AGGSORTKEYPOS]; 126530ef842dSbmc 126630ef842dSbmc dt_revsort = (dtp->dt_options[DTRACEOPT_AGGSORTREV] != DTRACEOPT_UNSET); 126730ef842dSbmc dt_keysort = (dtp->dt_options[DTRACEOPT_AGGSORTKEY] != DTRACEOPT_UNSET); 126830ef842dSbmc 126930ef842dSbmc if (keyposopt != DTRACEOPT_UNSET && keyposopt <= INT_MAX) { 127030ef842dSbmc dt_keypos = (int)keyposopt; 127130ef842dSbmc } else { 127230ef842dSbmc dt_keypos = 0; 127330ef842dSbmc } 127430ef842dSbmc 127530ef842dSbmc if (compar == NULL) { 127630ef842dSbmc if (!dt_keysort) { 127730ef842dSbmc compar = dt_aggregate_varvalcmp; 127830ef842dSbmc } else { 127930ef842dSbmc compar = dt_aggregate_varkeycmp; 128030ef842dSbmc } 128130ef842dSbmc } 128230ef842dSbmc 128330ef842dSbmc qsort(base, nel, width, compar); 128430ef842dSbmc 128530ef842dSbmc dt_revsort = rev; 128630ef842dSbmc dt_keysort = key; 128730ef842dSbmc dt_keypos = keypos; 128830ef842dSbmc } 128930ef842dSbmc 12907c478bd9Sstevel@tonic-gate int 12917c478bd9Sstevel@tonic-gate dtrace_aggregate_walk(dtrace_hdl_t *dtp, dtrace_aggregate_f *func, void *arg) 12927c478bd9Sstevel@tonic-gate { 12937c478bd9Sstevel@tonic-gate dt_ahashent_t *h, *next; 12947c478bd9Sstevel@tonic-gate dt_ahash_t *hash = &dtp->dt_aggregate.dtat_hash; 12957c478bd9Sstevel@tonic-gate 12967c478bd9Sstevel@tonic-gate for (h = hash->dtah_all; h != NULL; h = next) { 12977c478bd9Sstevel@tonic-gate /* 12987c478bd9Sstevel@tonic-gate * dt_aggwalk_rval() can potentially remove the current hash 12997c478bd9Sstevel@tonic-gate * entry; we need to load the next hash entry before calling 13007c478bd9Sstevel@tonic-gate * into it. 13017c478bd9Sstevel@tonic-gate */ 13027c478bd9Sstevel@tonic-gate next = h->dtahe_nextall; 13037c478bd9Sstevel@tonic-gate 13047c478bd9Sstevel@tonic-gate if (dt_aggwalk_rval(dtp, h, func(&h->dtahe_data, arg)) == -1) 13057c478bd9Sstevel@tonic-gate return (-1); 13067c478bd9Sstevel@tonic-gate } 13077c478bd9Sstevel@tonic-gate 13087c478bd9Sstevel@tonic-gate return (0); 13097c478bd9Sstevel@tonic-gate } 13107c478bd9Sstevel@tonic-gate 13117c478bd9Sstevel@tonic-gate static int 13127c478bd9Sstevel@tonic-gate dt_aggregate_walk_sorted(dtrace_hdl_t *dtp, 13137c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg, 13147c478bd9Sstevel@tonic-gate int (*sfunc)(const void *, const void *)) 13157c478bd9Sstevel@tonic-gate { 13167c478bd9Sstevel@tonic-gate dt_aggregate_t *agp = &dtp->dt_aggregate; 13177c478bd9Sstevel@tonic-gate dt_ahashent_t *h, **sorted; 13187c478bd9Sstevel@tonic-gate dt_ahash_t *hash = &agp->dtat_hash; 13197c478bd9Sstevel@tonic-gate size_t i, nentries = 0; 13207c478bd9Sstevel@tonic-gate 13217c478bd9Sstevel@tonic-gate for (h = hash->dtah_all; h != NULL; h = h->dtahe_nextall) 13227c478bd9Sstevel@tonic-gate nentries++; 13237c478bd9Sstevel@tonic-gate 132430ef842dSbmc sorted = dt_alloc(dtp, nentries * sizeof (dt_ahashent_t *)); 13257c478bd9Sstevel@tonic-gate 13267c478bd9Sstevel@tonic-gate if (sorted == NULL) 132730ef842dSbmc return (-1); 13287c478bd9Sstevel@tonic-gate 13297c478bd9Sstevel@tonic-gate for (h = hash->dtah_all, i = 0; h != NULL; h = h->dtahe_nextall) 13307c478bd9Sstevel@tonic-gate sorted[i++] = h; 13317c478bd9Sstevel@tonic-gate 133230ef842dSbmc (void) pthread_mutex_lock(&dt_qsort_lock); 133330ef842dSbmc 133430ef842dSbmc if (sfunc == NULL) { 133530ef842dSbmc dt_aggregate_qsort(dtp, sorted, nentries, 133630ef842dSbmc sizeof (dt_ahashent_t *), NULL); 133730ef842dSbmc } else { 133830ef842dSbmc /* 133930ef842dSbmc * If we've been explicitly passed a sorting function, 134030ef842dSbmc * we'll use that -- ignoring the values of the "aggsortrev", 134130ef842dSbmc * "aggsortkey" and "aggsortkeypos" options. 134230ef842dSbmc */ 134330ef842dSbmc qsort(sorted, nentries, sizeof (dt_ahashent_t *), sfunc); 134430ef842dSbmc } 134530ef842dSbmc 134630ef842dSbmc (void) pthread_mutex_unlock(&dt_qsort_lock); 13477c478bd9Sstevel@tonic-gate 13487c478bd9Sstevel@tonic-gate for (i = 0; i < nentries; i++) { 13497c478bd9Sstevel@tonic-gate h = sorted[i]; 13507c478bd9Sstevel@tonic-gate 135130ef842dSbmc if (dt_aggwalk_rval(dtp, h, func(&h->dtahe_data, arg)) == -1) { 135230ef842dSbmc dt_free(dtp, sorted); 13537c478bd9Sstevel@tonic-gate return (-1); 135430ef842dSbmc } 13557c478bd9Sstevel@tonic-gate } 13567c478bd9Sstevel@tonic-gate 135730ef842dSbmc dt_free(dtp, sorted); 13587c478bd9Sstevel@tonic-gate return (0); 13597c478bd9Sstevel@tonic-gate } 13607c478bd9Sstevel@tonic-gate 136130ef842dSbmc int 136230ef842dSbmc dtrace_aggregate_walk_sorted(dtrace_hdl_t *dtp, 136330ef842dSbmc dtrace_aggregate_f *func, void *arg) 136430ef842dSbmc { 136530ef842dSbmc return (dt_aggregate_walk_sorted(dtp, func, arg, NULL)); 136630ef842dSbmc } 136730ef842dSbmc 13687c478bd9Sstevel@tonic-gate int 13697c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_keysorted(dtrace_hdl_t *dtp, 13707c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 13717c478bd9Sstevel@tonic-gate { 13727c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 13737c478bd9Sstevel@tonic-gate arg, dt_aggregate_varkeycmp)); 13747c478bd9Sstevel@tonic-gate } 13757c478bd9Sstevel@tonic-gate 13767c478bd9Sstevel@tonic-gate int 13777c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_valsorted(dtrace_hdl_t *dtp, 13787c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 13797c478bd9Sstevel@tonic-gate { 13807c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 13817c478bd9Sstevel@tonic-gate arg, dt_aggregate_varvalcmp)); 13827c478bd9Sstevel@tonic-gate } 13837c478bd9Sstevel@tonic-gate 13847c478bd9Sstevel@tonic-gate int 13857c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_keyvarsorted(dtrace_hdl_t *dtp, 13867c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 13877c478bd9Sstevel@tonic-gate { 13887c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 13897c478bd9Sstevel@tonic-gate arg, dt_aggregate_keyvarcmp)); 13907c478bd9Sstevel@tonic-gate } 13917c478bd9Sstevel@tonic-gate 13927c478bd9Sstevel@tonic-gate int 13937c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_valvarsorted(dtrace_hdl_t *dtp, 13947c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 13957c478bd9Sstevel@tonic-gate { 13967c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 13977c478bd9Sstevel@tonic-gate arg, dt_aggregate_valvarcmp)); 13987c478bd9Sstevel@tonic-gate } 13997c478bd9Sstevel@tonic-gate 14007c478bd9Sstevel@tonic-gate int 14017c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_keyrevsorted(dtrace_hdl_t *dtp, 14027c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 14037c478bd9Sstevel@tonic-gate { 14047c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 14057c478bd9Sstevel@tonic-gate arg, dt_aggregate_varkeyrevcmp)); 14067c478bd9Sstevel@tonic-gate } 14077c478bd9Sstevel@tonic-gate 14087c478bd9Sstevel@tonic-gate int 14097c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_valrevsorted(dtrace_hdl_t *dtp, 14107c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 14117c478bd9Sstevel@tonic-gate { 14127c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 14137c478bd9Sstevel@tonic-gate arg, dt_aggregate_varvalrevcmp)); 14147c478bd9Sstevel@tonic-gate } 14157c478bd9Sstevel@tonic-gate 14167c478bd9Sstevel@tonic-gate int 14177c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_keyvarrevsorted(dtrace_hdl_t *dtp, 14187c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 14197c478bd9Sstevel@tonic-gate { 14207c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 14217c478bd9Sstevel@tonic-gate arg, dt_aggregate_keyvarrevcmp)); 14227c478bd9Sstevel@tonic-gate } 14237c478bd9Sstevel@tonic-gate 14247c478bd9Sstevel@tonic-gate int 14257c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_valvarrevsorted(dtrace_hdl_t *dtp, 14267c478bd9Sstevel@tonic-gate dtrace_aggregate_f *func, void *arg) 14277c478bd9Sstevel@tonic-gate { 14287c478bd9Sstevel@tonic-gate return (dt_aggregate_walk_sorted(dtp, func, 14297c478bd9Sstevel@tonic-gate arg, dt_aggregate_valvarrevcmp)); 14307c478bd9Sstevel@tonic-gate } 14317c478bd9Sstevel@tonic-gate 143230ef842dSbmc int 143330ef842dSbmc dtrace_aggregate_walk_joined(dtrace_hdl_t *dtp, dtrace_aggvarid_t *aggvars, 143430ef842dSbmc int naggvars, dtrace_aggregate_walk_joined_f *func, void *arg) 143530ef842dSbmc { 143630ef842dSbmc dt_aggregate_t *agp = &dtp->dt_aggregate; 143730ef842dSbmc dt_ahashent_t *h, **sorted = NULL, ***bundle, **nbundle; 143830ef842dSbmc const dtrace_aggdata_t **data; 143930ef842dSbmc dt_ahashent_t *zaggdata = NULL; 144030ef842dSbmc dt_ahash_t *hash = &agp->dtat_hash; 144130ef842dSbmc size_t nentries = 0, nbundles = 0, start, zsize = 0, bundlesize; 144230ef842dSbmc dtrace_aggvarid_t max = 0, aggvar; 144330ef842dSbmc int rval = -1, *map, *remap = NULL; 144430ef842dSbmc int i, j; 144530ef842dSbmc dtrace_optval_t sortpos = dtp->dt_options[DTRACEOPT_AGGSORTPOS]; 144630ef842dSbmc 144730ef842dSbmc /* 144830ef842dSbmc * If the sorting position is greater than the number of aggregation 144930ef842dSbmc * variable IDs, we silently set it to 0. 145030ef842dSbmc */ 145130ef842dSbmc if (sortpos == DTRACEOPT_UNSET || sortpos >= naggvars) 145230ef842dSbmc sortpos = 0; 145330ef842dSbmc 145430ef842dSbmc /* 145530ef842dSbmc * First we need to translate the specified aggregation variable IDs 145630ef842dSbmc * into a linear map that will allow us to translate an aggregation 145730ef842dSbmc * variable ID into its position in the specified aggvars. 145830ef842dSbmc */ 145930ef842dSbmc for (i = 0; i < naggvars; i++) { 146030ef842dSbmc if (aggvars[i] == DTRACE_AGGVARIDNONE || aggvars[i] < 0) 146130ef842dSbmc return (dt_set_errno(dtp, EDT_BADAGGVAR)); 146230ef842dSbmc 146330ef842dSbmc if (aggvars[i] > max) 146430ef842dSbmc max = aggvars[i]; 146530ef842dSbmc } 146630ef842dSbmc 146730ef842dSbmc if ((map = dt_zalloc(dtp, (max + 1) * sizeof (int))) == NULL) 146830ef842dSbmc return (-1); 146930ef842dSbmc 147030ef842dSbmc zaggdata = dt_zalloc(dtp, naggvars * sizeof (dt_ahashent_t)); 147130ef842dSbmc 147230ef842dSbmc if (zaggdata == NULL) 147330ef842dSbmc goto out; 147430ef842dSbmc 147530ef842dSbmc for (i = 0; i < naggvars; i++) { 147630ef842dSbmc int ndx = i + sortpos; 147730ef842dSbmc 147830ef842dSbmc if (ndx >= naggvars) 147930ef842dSbmc ndx -= naggvars; 148030ef842dSbmc 148130ef842dSbmc aggvar = aggvars[ndx]; 148230ef842dSbmc assert(aggvar <= max); 148330ef842dSbmc 148430ef842dSbmc if (map[aggvar]) { 148530ef842dSbmc /* 148630ef842dSbmc * We have an aggregation variable that is present 148730ef842dSbmc * more than once in the array of aggregation 148830ef842dSbmc * variables. While it's unclear why one might want 148930ef842dSbmc * to do this, it's legal. To support this construct, 149030ef842dSbmc * we will allocate a remap that will indicate the 149130ef842dSbmc * position from which this aggregation variable 149230ef842dSbmc * should be pulled. (That is, where the remap will 149330ef842dSbmc * map from one position to another.) 149430ef842dSbmc */ 149530ef842dSbmc if (remap == NULL) { 149630ef842dSbmc remap = dt_zalloc(dtp, naggvars * sizeof (int)); 149730ef842dSbmc 149830ef842dSbmc if (remap == NULL) 149930ef842dSbmc goto out; 150030ef842dSbmc } 150130ef842dSbmc 150230ef842dSbmc /* 150330ef842dSbmc * Given that the variable is already present, assert 150430ef842dSbmc * that following through the mapping and adjusting 150530ef842dSbmc * for the sort position yields the same aggregation 150630ef842dSbmc * variable ID. 150730ef842dSbmc */ 150830ef842dSbmc assert(aggvars[(map[aggvar] - 1 + sortpos) % 150930ef842dSbmc naggvars] == aggvars[ndx]); 151030ef842dSbmc 151130ef842dSbmc remap[i] = map[aggvar]; 151230ef842dSbmc continue; 151330ef842dSbmc } 151430ef842dSbmc 151530ef842dSbmc map[aggvar] = i + 1; 151630ef842dSbmc } 151730ef842dSbmc 151830ef842dSbmc /* 151930ef842dSbmc * We need to take two passes over the data to size our allocation, so 152030ef842dSbmc * we'll use the first pass to also fill in the zero-filled data to be 152130ef842dSbmc * used to properly format a zero-valued aggregation. 152230ef842dSbmc */ 152330ef842dSbmc for (h = hash->dtah_all; h != NULL; h = h->dtahe_nextall) { 152430ef842dSbmc dtrace_aggvarid_t id; 152530ef842dSbmc int ndx; 152630ef842dSbmc 152730ef842dSbmc if ((id = dt_aggregate_aggvarid(h)) > max || !(ndx = map[id])) 152830ef842dSbmc continue; 152930ef842dSbmc 153030ef842dSbmc if (zaggdata[ndx - 1].dtahe_size == 0) { 153130ef842dSbmc zaggdata[ndx - 1].dtahe_size = h->dtahe_size; 153230ef842dSbmc zaggdata[ndx - 1].dtahe_data = h->dtahe_data; 153330ef842dSbmc } 153430ef842dSbmc 153530ef842dSbmc nentries++; 153630ef842dSbmc } 153730ef842dSbmc 153830ef842dSbmc if (nentries == 0) { 153930ef842dSbmc /* 154030ef842dSbmc * We couldn't find any entries; there is nothing else to do. 154130ef842dSbmc */ 154230ef842dSbmc rval = 0; 154330ef842dSbmc goto out; 154430ef842dSbmc } 154530ef842dSbmc 154630ef842dSbmc /* 154730ef842dSbmc * Before we sort the data, we're going to look for any holes in our 154830ef842dSbmc * zero-filled data. This will occur if an aggregation variable that 154930ef842dSbmc * we are being asked to print has not yet been assigned the result of 155030ef842dSbmc * any aggregating action for _any_ tuple. The issue becomes that we 155130ef842dSbmc * would like a zero value to be printed for all columns for this 155230ef842dSbmc * aggregation, but without any record description, we don't know the 155330ef842dSbmc * aggregating action that corresponds to the aggregation variable. To 155430ef842dSbmc * try to find a match, we're simply going to lookup aggregation IDs 155530ef842dSbmc * (which are guaranteed to be contiguous and to start from 1), looking 155630ef842dSbmc * for the specified aggregation variable ID. If we find a match, 155730ef842dSbmc * we'll use that. If we iterate over all aggregation IDs and don't 155830ef842dSbmc * find a match, then we must be an anonymous enabling. (Anonymous 155930ef842dSbmc * enablings can't currently derive either aggregation variable IDs or 156030ef842dSbmc * aggregation variable names given only an aggregation ID.) In this 156130ef842dSbmc * obscure case (anonymous enabling, multiple aggregation printa() with 156230ef842dSbmc * some aggregations not represented for any tuple), our defined 156330ef842dSbmc * behavior is that the zero will be printed in the format of the first 156430ef842dSbmc * aggregation variable that contains any non-zero value. 156530ef842dSbmc */ 156630ef842dSbmc for (i = 0; i < naggvars; i++) { 156730ef842dSbmc if (zaggdata[i].dtahe_size == 0) { 156830ef842dSbmc dtrace_aggvarid_t aggvar; 156930ef842dSbmc 157030ef842dSbmc aggvar = aggvars[(i - sortpos + naggvars) % naggvars]; 157130ef842dSbmc assert(zaggdata[i].dtahe_data.dtada_data == NULL); 157230ef842dSbmc 157330ef842dSbmc for (j = DTRACE_AGGIDNONE + 1; ; j++) { 157430ef842dSbmc dtrace_aggdesc_t *agg; 157530ef842dSbmc dtrace_aggdata_t *aggdata; 157630ef842dSbmc 157730ef842dSbmc if (dt_aggid_lookup(dtp, j, &agg) != 0) 157830ef842dSbmc break; 157930ef842dSbmc 158030ef842dSbmc if (agg->dtagd_varid != aggvar) 158130ef842dSbmc continue; 158230ef842dSbmc 158330ef842dSbmc /* 158430ef842dSbmc * We have our description -- now we need to 158530ef842dSbmc * cons up the zaggdata entry for it. 158630ef842dSbmc */ 158730ef842dSbmc aggdata = &zaggdata[i].dtahe_data; 158830ef842dSbmc aggdata->dtada_size = agg->dtagd_size; 158930ef842dSbmc aggdata->dtada_desc = agg; 159030ef842dSbmc aggdata->dtada_handle = dtp; 159130ef842dSbmc (void) dt_epid_lookup(dtp, agg->dtagd_epid, 159230ef842dSbmc &aggdata->dtada_edesc, 159330ef842dSbmc &aggdata->dtada_pdesc); 159430ef842dSbmc aggdata->dtada_normal = 1; 159530ef842dSbmc zaggdata[i].dtahe_hashval = 0; 159630ef842dSbmc zaggdata[i].dtahe_size = agg->dtagd_size; 159730ef842dSbmc break; 159830ef842dSbmc } 159930ef842dSbmc 160030ef842dSbmc if (zaggdata[i].dtahe_size == 0) { 160130ef842dSbmc caddr_t data; 160230ef842dSbmc 160330ef842dSbmc /* 160430ef842dSbmc * We couldn't find this aggregation, meaning 160530ef842dSbmc * that we have never seen it before for any 160630ef842dSbmc * tuple _and_ this is an anonymous enabling. 160730ef842dSbmc * That is, we're in the obscure case outlined 160830ef842dSbmc * above. In this case, our defined behavior 160930ef842dSbmc * is to format the data in the format of the 161030ef842dSbmc * first non-zero aggregation -- of which, of 161130ef842dSbmc * course, we know there to be at least one 161230ef842dSbmc * (or nentries would have been zero). 161330ef842dSbmc */ 161430ef842dSbmc for (j = 0; j < naggvars; j++) { 161530ef842dSbmc if (zaggdata[j].dtahe_size != 0) 161630ef842dSbmc break; 161730ef842dSbmc } 161830ef842dSbmc 161930ef842dSbmc assert(j < naggvars); 162030ef842dSbmc zaggdata[i] = zaggdata[j]; 162130ef842dSbmc 162230ef842dSbmc data = zaggdata[i].dtahe_data.dtada_data; 162330ef842dSbmc assert(data != NULL); 162430ef842dSbmc } 162530ef842dSbmc } 162630ef842dSbmc } 162730ef842dSbmc 162830ef842dSbmc /* 162930ef842dSbmc * Now we need to allocate our zero-filled data for use for 163030ef842dSbmc * aggregations that don't have a value corresponding to a given key. 163130ef842dSbmc */ 163230ef842dSbmc for (i = 0; i < naggvars; i++) { 163330ef842dSbmc dtrace_aggdata_t *aggdata = &zaggdata[i].dtahe_data; 163430ef842dSbmc dtrace_aggdesc_t *aggdesc = aggdata->dtada_desc; 163530ef842dSbmc dtrace_recdesc_t *rec; 163630ef842dSbmc uint64_t larg; 163730ef842dSbmc caddr_t zdata; 163830ef842dSbmc 163930ef842dSbmc zsize = zaggdata[i].dtahe_size; 164030ef842dSbmc assert(zsize != 0); 164130ef842dSbmc 164230ef842dSbmc if ((zdata = dt_zalloc(dtp, zsize)) == NULL) { 164330ef842dSbmc /* 164430ef842dSbmc * If we failed to allocated some zero-filled data, we 164530ef842dSbmc * need to zero out the remaining dtada_data pointers 164630ef842dSbmc * to prevent the wrong data from being freed below. 164730ef842dSbmc */ 164830ef842dSbmc for (j = i; j < naggvars; j++) 164930ef842dSbmc zaggdata[j].dtahe_data.dtada_data = NULL; 165030ef842dSbmc goto out; 165130ef842dSbmc } 165230ef842dSbmc 165330ef842dSbmc aggvar = aggvars[(i - sortpos + naggvars) % naggvars]; 165430ef842dSbmc 165530ef842dSbmc /* 165630ef842dSbmc * First, the easy bit. To maintain compatibility with 165730ef842dSbmc * consumers that pull the compiler-generated ID out of the 165830ef842dSbmc * data, we put that ID at the top of the zero-filled data. 165930ef842dSbmc */ 166030ef842dSbmc rec = &aggdesc->dtagd_rec[0]; 166130ef842dSbmc /* LINTED - alignment */ 166230ef842dSbmc *((dtrace_aggvarid_t *)(zdata + rec->dtrd_offset)) = aggvar; 166330ef842dSbmc 166430ef842dSbmc rec = &aggdesc->dtagd_rec[aggdesc->dtagd_nrecs - 1]; 166530ef842dSbmc 166630ef842dSbmc /* 166730ef842dSbmc * Now for the more complicated part. If (and only if) this 166830ef842dSbmc * is an lquantize() aggregating action, zero-filled data is 166930ef842dSbmc * not equivalent to an empty record: we must also get the 167030ef842dSbmc * parameters for the lquantize(). 167130ef842dSbmc */ 167230ef842dSbmc if (rec->dtrd_action == DTRACEAGG_LQUANTIZE) { 167330ef842dSbmc if (aggdata->dtada_data != NULL) { 167430ef842dSbmc /* 167530ef842dSbmc * The easier case here is if we actually have 167630ef842dSbmc * some prototype data -- in which case we 167730ef842dSbmc * manually dig it out of the aggregation 167830ef842dSbmc * record. 167930ef842dSbmc */ 168030ef842dSbmc /* LINTED - alignment */ 168130ef842dSbmc larg = *((uint64_t *)(aggdata->dtada_data + 168230ef842dSbmc rec->dtrd_offset)); 168330ef842dSbmc } else { 168430ef842dSbmc /* 168530ef842dSbmc * We don't have any prototype data. As a 168630ef842dSbmc * result, we know that we _do_ have the 168730ef842dSbmc * compiler-generated information. (If this 168830ef842dSbmc * were an anonymous enabling, all of our 168930ef842dSbmc * zero-filled data would have prototype data 169030ef842dSbmc * -- either directly or indirectly.) So as 169130ef842dSbmc * gross as it is, we'll grovel around in the 169230ef842dSbmc * compiler-generated information to find the 169330ef842dSbmc * lquantize() parameters. 169430ef842dSbmc */ 169530ef842dSbmc dtrace_stmtdesc_t *sdp; 169630ef842dSbmc dt_ident_t *aid; 169730ef842dSbmc dt_idsig_t *isp; 169830ef842dSbmc 169930ef842dSbmc sdp = (dtrace_stmtdesc_t *)(uintptr_t) 170030ef842dSbmc aggdesc->dtagd_rec[0].dtrd_uarg; 170130ef842dSbmc aid = sdp->dtsd_aggdata; 170230ef842dSbmc isp = (dt_idsig_t *)aid->di_data; 170330ef842dSbmc assert(isp->dis_auxinfo != 0); 170430ef842dSbmc larg = isp->dis_auxinfo; 170530ef842dSbmc } 170630ef842dSbmc 170730ef842dSbmc /* LINTED - alignment */ 170830ef842dSbmc *((uint64_t *)(zdata + rec->dtrd_offset)) = larg; 170930ef842dSbmc } 171030ef842dSbmc 171130ef842dSbmc aggdata->dtada_data = zdata; 171230ef842dSbmc } 171330ef842dSbmc 171430ef842dSbmc /* 171530ef842dSbmc * Now that we've dealt with setting up our zero-filled data, we can 171630ef842dSbmc * allocate our sorted array, and take another pass over the data to 171730ef842dSbmc * fill it. 171830ef842dSbmc */ 171930ef842dSbmc sorted = dt_alloc(dtp, nentries * sizeof (dt_ahashent_t *)); 172030ef842dSbmc 172130ef842dSbmc if (sorted == NULL) 172230ef842dSbmc goto out; 172330ef842dSbmc 172430ef842dSbmc for (h = hash->dtah_all, i = 0; h != NULL; h = h->dtahe_nextall) { 172530ef842dSbmc dtrace_aggvarid_t id; 172630ef842dSbmc 172730ef842dSbmc if ((id = dt_aggregate_aggvarid(h)) > max || !map[id]) 172830ef842dSbmc continue; 172930ef842dSbmc 173030ef842dSbmc sorted[i++] = h; 173130ef842dSbmc } 173230ef842dSbmc 173330ef842dSbmc assert(i == nentries); 173430ef842dSbmc 173530ef842dSbmc /* 173630ef842dSbmc * We've loaded our array; now we need to sort by value to allow us 173730ef842dSbmc * to create bundles of like value. We're going to acquire the 173830ef842dSbmc * dt_qsort_lock here, and hold it across all of our subsequent 173930ef842dSbmc * comparison and sorting. 174030ef842dSbmc */ 174130ef842dSbmc (void) pthread_mutex_lock(&dt_qsort_lock); 174230ef842dSbmc 174330ef842dSbmc qsort(sorted, nentries, sizeof (dt_ahashent_t *), 174430ef842dSbmc dt_aggregate_keyvarcmp); 174530ef842dSbmc 174630ef842dSbmc /* 174730ef842dSbmc * Now we need to go through and create bundles. Because the number 174830ef842dSbmc * of bundles is bounded by the size of the sorted array, we're going 174930ef842dSbmc * to reuse the underlying storage. And note that "bundle" is an 175030ef842dSbmc * array of pointers to arrays of pointers to dt_ahashent_t -- making 175130ef842dSbmc * its type (regrettably) "dt_ahashent_t ***". (Regrettable because 175230ef842dSbmc * '*' -- like '_' and 'X' -- should never appear in triplicate in 175330ef842dSbmc * an ideal world.) 175430ef842dSbmc */ 175530ef842dSbmc bundle = (dt_ahashent_t ***)sorted; 175630ef842dSbmc 175730ef842dSbmc for (i = 1, start = 0; i <= nentries; i++) { 175830ef842dSbmc if (i < nentries && 175930ef842dSbmc dt_aggregate_keycmp(&sorted[i], &sorted[i - 1]) == 0) 176030ef842dSbmc continue; 176130ef842dSbmc 176230ef842dSbmc /* 176330ef842dSbmc * We have a bundle boundary. Everything from start to 176430ef842dSbmc * (i - 1) belongs in one bundle. 176530ef842dSbmc */ 176630ef842dSbmc assert(i - start <= naggvars); 176730ef842dSbmc bundlesize = (naggvars + 2) * sizeof (dt_ahashent_t *); 176830ef842dSbmc 176930ef842dSbmc if ((nbundle = dt_zalloc(dtp, bundlesize)) == NULL) { 177030ef842dSbmc (void) pthread_mutex_unlock(&dt_qsort_lock); 177130ef842dSbmc goto out; 177230ef842dSbmc } 177330ef842dSbmc 177430ef842dSbmc for (j = start; j < i; j++) { 177530ef842dSbmc dtrace_aggvarid_t id = dt_aggregate_aggvarid(sorted[j]); 177630ef842dSbmc 177730ef842dSbmc assert(id <= max); 177830ef842dSbmc assert(map[id] != 0); 177930ef842dSbmc assert(map[id] - 1 < naggvars); 178030ef842dSbmc assert(nbundle[map[id] - 1] == NULL); 178130ef842dSbmc nbundle[map[id] - 1] = sorted[j]; 178230ef842dSbmc 178330ef842dSbmc if (nbundle[naggvars] == NULL) 178430ef842dSbmc nbundle[naggvars] = sorted[j]; 178530ef842dSbmc } 178630ef842dSbmc 178730ef842dSbmc for (j = 0; j < naggvars; j++) { 178830ef842dSbmc if (nbundle[j] != NULL) 178930ef842dSbmc continue; 179030ef842dSbmc 179130ef842dSbmc /* 179230ef842dSbmc * Before we assume that this aggregation variable 179330ef842dSbmc * isn't present (and fall back to using the 179430ef842dSbmc * zero-filled data allocated earlier), check the 179530ef842dSbmc * remap. If we have a remapping, we'll drop it in 179630ef842dSbmc * here. Note that we might be remapping an 179730ef842dSbmc * aggregation variable that isn't present for this 179830ef842dSbmc * key; in this case, the aggregation data that we 179930ef842dSbmc * copy will point to the zeroed data. 180030ef842dSbmc */ 180130ef842dSbmc if (remap != NULL && remap[j]) { 180230ef842dSbmc assert(remap[j] - 1 < j); 180330ef842dSbmc assert(nbundle[remap[j] - 1] != NULL); 180430ef842dSbmc nbundle[j] = nbundle[remap[j] - 1]; 180530ef842dSbmc } else { 180630ef842dSbmc nbundle[j] = &zaggdata[j]; 180730ef842dSbmc } 180830ef842dSbmc } 180930ef842dSbmc 181030ef842dSbmc bundle[nbundles++] = nbundle; 181130ef842dSbmc start = i; 181230ef842dSbmc } 181330ef842dSbmc 181430ef842dSbmc /* 181530ef842dSbmc * Now we need to re-sort based on the first value. 181630ef842dSbmc */ 181730ef842dSbmc dt_aggregate_qsort(dtp, bundle, nbundles, sizeof (dt_ahashent_t **), 181830ef842dSbmc dt_aggregate_bundlecmp); 181930ef842dSbmc 182030ef842dSbmc (void) pthread_mutex_unlock(&dt_qsort_lock); 182130ef842dSbmc 182230ef842dSbmc /* 182330ef842dSbmc * We're done! Now we just need to go back over the sorted bundles, 182430ef842dSbmc * calling the function. 182530ef842dSbmc */ 182630ef842dSbmc data = alloca((naggvars + 1) * sizeof (dtrace_aggdata_t *)); 182730ef842dSbmc 182830ef842dSbmc for (i = 0; i < nbundles; i++) { 182930ef842dSbmc for (j = 0; j < naggvars; j++) 183030ef842dSbmc data[j + 1] = NULL; 183130ef842dSbmc 183230ef842dSbmc for (j = 0; j < naggvars; j++) { 183330ef842dSbmc int ndx = j - sortpos; 183430ef842dSbmc 183530ef842dSbmc if (ndx < 0) 183630ef842dSbmc ndx += naggvars; 183730ef842dSbmc 183830ef842dSbmc assert(bundle[i][ndx] != NULL); 183930ef842dSbmc data[j + 1] = &bundle[i][ndx]->dtahe_data; 184030ef842dSbmc } 184130ef842dSbmc 184230ef842dSbmc for (j = 0; j < naggvars; j++) 184330ef842dSbmc assert(data[j + 1] != NULL); 184430ef842dSbmc 184530ef842dSbmc /* 184630ef842dSbmc * The representative key is the last element in the bundle. 184730ef842dSbmc * Assert that we have one, and then set it to be the first 184830ef842dSbmc * element of data. 184930ef842dSbmc */ 185030ef842dSbmc assert(bundle[i][j] != NULL); 185130ef842dSbmc data[0] = &bundle[i][j]->dtahe_data; 185230ef842dSbmc 185330ef842dSbmc if ((rval = func(data, naggvars + 1, arg)) == -1) 185430ef842dSbmc goto out; 185530ef842dSbmc } 185630ef842dSbmc 185730ef842dSbmc rval = 0; 185830ef842dSbmc out: 185930ef842dSbmc for (i = 0; i < nbundles; i++) 186030ef842dSbmc dt_free(dtp, bundle[i]); 186130ef842dSbmc 186230ef842dSbmc if (zaggdata != NULL) { 186330ef842dSbmc for (i = 0; i < naggvars; i++) 186430ef842dSbmc dt_free(dtp, zaggdata[i].dtahe_data.dtada_data); 186530ef842dSbmc } 186630ef842dSbmc 186730ef842dSbmc dt_free(dtp, zaggdata); 186830ef842dSbmc dt_free(dtp, sorted); 186930ef842dSbmc dt_free(dtp, remap); 187030ef842dSbmc dt_free(dtp, map); 187130ef842dSbmc 187230ef842dSbmc return (rval); 187330ef842dSbmc } 187430ef842dSbmc 18757c478bd9Sstevel@tonic-gate int 18767c478bd9Sstevel@tonic-gate dtrace_aggregate_print(dtrace_hdl_t *dtp, FILE *fp, 18777c478bd9Sstevel@tonic-gate dtrace_aggregate_walk_f *func) 18787c478bd9Sstevel@tonic-gate { 18797c478bd9Sstevel@tonic-gate dt_print_aggdata_t pd; 18807c478bd9Sstevel@tonic-gate 18817c478bd9Sstevel@tonic-gate pd.dtpa_dtp = dtp; 18827c478bd9Sstevel@tonic-gate pd.dtpa_fp = fp; 18837c478bd9Sstevel@tonic-gate pd.dtpa_allunprint = 1; 18847c478bd9Sstevel@tonic-gate 18857c478bd9Sstevel@tonic-gate if (func == NULL) 188630ef842dSbmc func = dtrace_aggregate_walk_sorted; 18877c478bd9Sstevel@tonic-gate 18887c478bd9Sstevel@tonic-gate if ((*func)(dtp, dt_print_agg, &pd) == -1) 18897c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, dtp->dt_errno)); 18907c478bd9Sstevel@tonic-gate 18917c478bd9Sstevel@tonic-gate return (0); 18927c478bd9Sstevel@tonic-gate } 18937c478bd9Sstevel@tonic-gate 18947c478bd9Sstevel@tonic-gate void 18957c478bd9Sstevel@tonic-gate dtrace_aggregate_clear(dtrace_hdl_t *dtp) 18967c478bd9Sstevel@tonic-gate { 18977c478bd9Sstevel@tonic-gate dt_aggregate_t *agp = &dtp->dt_aggregate; 18987c478bd9Sstevel@tonic-gate dt_ahash_t *hash = &agp->dtat_hash; 18997c478bd9Sstevel@tonic-gate dt_ahashent_t *h; 19007c478bd9Sstevel@tonic-gate dtrace_aggdata_t *data; 19017c478bd9Sstevel@tonic-gate dtrace_aggdesc_t *aggdesc; 19027c478bd9Sstevel@tonic-gate dtrace_recdesc_t *rec; 19037c478bd9Sstevel@tonic-gate int i, max_cpus = agp->dtat_maxcpu; 19047c478bd9Sstevel@tonic-gate 19057c478bd9Sstevel@tonic-gate for (h = hash->dtah_all; h != NULL; h = h->dtahe_nextall) { 19067c478bd9Sstevel@tonic-gate aggdesc = h->dtahe_data.dtada_desc; 19077c478bd9Sstevel@tonic-gate rec = &aggdesc->dtagd_rec[aggdesc->dtagd_nrecs - 1]; 19087c478bd9Sstevel@tonic-gate data = &h->dtahe_data; 19097c478bd9Sstevel@tonic-gate 19107c478bd9Sstevel@tonic-gate bzero(&data->dtada_data[rec->dtrd_offset], rec->dtrd_size); 19117c478bd9Sstevel@tonic-gate 19127c478bd9Sstevel@tonic-gate if (data->dtada_percpu == NULL) 19137c478bd9Sstevel@tonic-gate continue; 19147c478bd9Sstevel@tonic-gate 19157c478bd9Sstevel@tonic-gate for (i = 0; i < max_cpus; i++) 19167c478bd9Sstevel@tonic-gate bzero(data->dtada_percpu[i], rec->dtrd_size); 19177c478bd9Sstevel@tonic-gate } 19187c478bd9Sstevel@tonic-gate } 19197c478bd9Sstevel@tonic-gate 19207c478bd9Sstevel@tonic-gate void 19217c478bd9Sstevel@tonic-gate dt_aggregate_destroy(dtrace_hdl_t *dtp) 19227c478bd9Sstevel@tonic-gate { 19237c478bd9Sstevel@tonic-gate dt_aggregate_t *agp = &dtp->dt_aggregate; 19247c478bd9Sstevel@tonic-gate dt_ahash_t *hash = &agp->dtat_hash; 19257c478bd9Sstevel@tonic-gate dt_ahashent_t *h, *next; 19267c478bd9Sstevel@tonic-gate dtrace_aggdata_t *aggdata; 19277c478bd9Sstevel@tonic-gate int i, max_cpus = agp->dtat_maxcpu; 19287c478bd9Sstevel@tonic-gate 19297c478bd9Sstevel@tonic-gate if (hash->dtah_hash == NULL) { 19307c478bd9Sstevel@tonic-gate assert(hash->dtah_all == NULL); 19317c478bd9Sstevel@tonic-gate } else { 19327c478bd9Sstevel@tonic-gate free(hash->dtah_hash); 19337c478bd9Sstevel@tonic-gate 19347c478bd9Sstevel@tonic-gate for (h = hash->dtah_all; h != NULL; h = next) { 19357c478bd9Sstevel@tonic-gate next = h->dtahe_nextall; 19367c478bd9Sstevel@tonic-gate 19377c478bd9Sstevel@tonic-gate aggdata = &h->dtahe_data; 19387c478bd9Sstevel@tonic-gate 19397c478bd9Sstevel@tonic-gate if (aggdata->dtada_percpu != NULL) { 19407c478bd9Sstevel@tonic-gate for (i = 0; i < max_cpus; i++) 19417c478bd9Sstevel@tonic-gate free(aggdata->dtada_percpu[i]); 19427c478bd9Sstevel@tonic-gate free(aggdata->dtada_percpu); 19437c478bd9Sstevel@tonic-gate } 19447c478bd9Sstevel@tonic-gate 19457c478bd9Sstevel@tonic-gate free(aggdata->dtada_data); 19467c478bd9Sstevel@tonic-gate free(h); 19477c478bd9Sstevel@tonic-gate } 19487c478bd9Sstevel@tonic-gate 19497c478bd9Sstevel@tonic-gate hash->dtah_hash = NULL; 19507c478bd9Sstevel@tonic-gate hash->dtah_all = NULL; 19517c478bd9Sstevel@tonic-gate hash->dtah_size = 0; 19527c478bd9Sstevel@tonic-gate } 19537c478bd9Sstevel@tonic-gate 19547c478bd9Sstevel@tonic-gate free(agp->dtat_buf.dtbd_data); 19557c478bd9Sstevel@tonic-gate free(agp->dtat_cpus); 19567c478bd9Sstevel@tonic-gate } 1957