905 want llquantize() support in DTrace

Reviewed by: Robert Mustacchi <robert.mustacchi@joyent.com>
Reviewed by: David Pacheco <dap@joyent.com>
Approved by: Garrett D'Amore <garrett@nexenta.com>

9 files changed, 403 insertions, 9 deletions

diff --git a/usr/src/lib/libdtrace/common/dt_aggregate.c b/usr/src/lib/libdtrace/common/dt_aggregate.c
index 2e66250b88..bb766f71c4 100644
--- a/usr/src/lib/libdtrace/common/dt_aggregate.c
+++ b/usr/src/lib/libdtrace/common/dt_aggregate.c
@@ -24,7 +24,9 @@
  * Use is subject to license terms.
  */
 
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
+/*
+ * Copyright (c) 2011, Joyent, Inc. All rights reserved.
+ */
 
 #include <stdlib.h>
 #include <strings.h>
@@ -204,6 +206,83 @@ dt_aggregate_lquantizedcmp(int64_t *lhs, int64_t *rhs)
 	return (0);
 }
 
+static void
+dt_aggregate_llquantize(int64_t *existing, int64_t *new, size_t size)
+{
+	int i;
+
+	for (i = 1; i < size / sizeof (int64_t); i++)
+		existing[i] = existing[i] + new[i];
+}
+
+static long double
+dt_aggregate_llquantizedsum(int64_t *llquanta)
+{
+	int64_t arg = *llquanta++;
+	uint16_t factor = DTRACE_LLQUANTIZE_FACTOR(arg);
+	uint16_t low = DTRACE_LLQUANTIZE_LOW(arg);
+	uint16_t high = DTRACE_LLQUANTIZE_HIGH(arg);
+	uint16_t nsteps = DTRACE_LLQUANTIZE_NSTEP(arg);
+	int bin = 0, order;
+	int64_t value = 1, next, step;
+	long double total;
+
+	assert(nsteps >= factor);
+	assert(nsteps % factor == 0);
+
+	for (order = 0; order < low; order++)
+		value *= factor;
+
+	total = (long double)llquanta[bin++] * (long double)(value - 1);
+
+	next = value * factor;
+	step = next > nsteps ? next / nsteps : 1;
+
+	while (order <= high) {
+		assert(value < next);
+		total += (long double)llquanta[bin++] * (long double)(value);
+
+		if ((value += step) != next)
+			continue;
+
+		next = value * factor;
+		step = next > nsteps ? next / nsteps : 1;
+		order++;
+	}
+
+	return (total + (long double)llquanta[bin] * (long double)value);
+}
+
+static int
+dt_aggregate_llquantizedcmp(int64_t *lhs, int64_t *rhs)
+{
+	long double lsum = dt_aggregate_llquantizedsum(lhs);
+	long double rsum = dt_aggregate_llquantizedsum(rhs);
+	int64_t lzero, rzero;
+
+	if (lsum < rsum)
+		return (DT_LESSTHAN);
+
+	if (lsum > rsum)
+		return (DT_GREATERTHAN);
+
+	/*
+	 * If they're both equal, then we will compare based on the weights at
+	 * zero.  If the weights at zero are equal, then this will be judged a
+	 * tie and will be resolved based on the key comparison.
+	 */
+	lzero = lhs[1];
+	rzero = rhs[1];
+
+	if (lzero < rzero)
+		return (DT_LESSTHAN);
+
+	if (lzero > rzero)
+		return (DT_GREATERTHAN);
+
+	return (0);
+}
+
 static int
 dt_aggregate_quantizedcmp(int64_t *lhs, int64_t *rhs)
 {
@@ -582,6 +661,10 @@ hashnext:
 			h->dtahe_aggregate = dt_aggregate_lquantize;
 			break;
 
+		case DTRACEAGG_LLQUANTIZE:
+			h->dtahe_aggregate = dt_aggregate_llquantize;
+			break;
+
 		case DTRACEAGG_COUNT:
 		case DTRACEAGG_SUM:
 		case DTRACEAGG_AVG:
@@ -849,6 +932,10 @@ dt_aggregate_valcmp(const void *lhs, const void *rhs)
 		rval = dt_aggregate_lquantizedcmp(laddr, raddr);
 		break;
 
+	case DTRACEAGG_LLQUANTIZE:
+		rval = dt_aggregate_llquantizedcmp(laddr, raddr);
+		break;
+
 	case DTRACEAGG_COUNT:
 	case DTRACEAGG_SUM:
 	case DTRACEAGG_MIN:
diff --git a/usr/src/lib/libdtrace/common/dt_cc.c b/usr/src/lib/libdtrace/common/dt_cc.c
index 56ea585320..e1b794edbf 100644
--- a/usr/src/lib/libdtrace/common/dt_cc.c
+++ b/usr/src/lib/libdtrace/common/dt_cc.c
@@ -83,6 +83,7 @@
 
 #include <sys/types.h>
 #include <sys/wait.h>
+#include <sys/sysmacros.h>
 
 #include <assert.h>
 #include <strings.h>
@@ -1292,6 +1293,145 @@ dt_compile_agg(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 		argmax = 5;
 	}
 
+	if (fid->di_id == DTRACEAGG_LLQUANTIZE) {
+		/*
+		 * For log/linear quantizations, we have between one and five
+		 * arguments in addition to the expression:
+		 *
+		 *    arg1 => Factor
+		 *    arg2 => Low magnitude
+		 *    arg3 => High magnitude
+		 *    arg4 => Number of steps per magnitude
+		 *    arg5 => Quantization increment value (defaults to 1)
+		 */
+		dt_node_t *llarg = dnp->dn_aggfun->dn_args->dn_list;
+		uint64_t oarg, order, v;
+		dt_idsig_t *isp;
+		int i;
+
+		struct {
+			char *str;		/* string identifier */
+			int badtype;		/* error on bad type */
+			int badval;		/* error on bad value */
+			int mismatch;		/* error on bad match */
+			int shift;		/* shift value */
+			uint16_t value;		/* value itself */
+		} args[] = {
+			{ "factor", D_LLQUANT_FACTORTYPE,
+			    D_LLQUANT_FACTORVAL, D_LLQUANT_FACTORMATCH,
+			    DTRACE_LLQUANTIZE_FACTORSHIFT },
+			{ "low magnitude", D_LLQUANT_LOWTYPE,
+			    D_LLQUANT_LOWVAL, D_LLQUANT_LOWMATCH,
+			    DTRACE_LLQUANTIZE_LOWSHIFT },
+			{ "high magnitude", D_LLQUANT_HIGHTYPE,
+			    D_LLQUANT_HIGHVAL, D_LLQUANT_HIGHMATCH,
+			    DTRACE_LLQUANTIZE_HIGHSHIFT },
+			{ "linear steps per magnitude", D_LLQUANT_NSTEPTYPE,
+			    D_LLQUANT_NSTEPVAL, D_LLQUANT_NSTEPMATCH,
+			    DTRACE_LLQUANTIZE_NSTEPSHIFT },
+			{ NULL }
+		};
+
+		assert(arg == 0);
+
+		for (i = 0; args[i].str != NULL; i++) {
+			if (llarg->dn_kind != DT_NODE_INT) {
+				dnerror(llarg, args[i].badtype, "llquantize( ) "
+				    "argument #%d (%s) must be an "
+				    "integer constant\n", i + 1, args[i].str);
+			}
+
+			if ((uint64_t)llarg->dn_value > UINT16_MAX) {
+				dnerror(llarg, args[i].badval, "llquantize( ) "
+				    "argument #%d (%s) must be an unsigned "
+				    "16-bit quantity\n", i + 1, args[i].str);
+			}
+
+			args[i].value = (uint16_t)llarg->dn_value;
+
+			assert(!(arg & (UINT16_MAX << args[i].shift)));
+			arg |= ((uint64_t)args[i].value << args[i].shift);
+			llarg = llarg->dn_list;
+		}
+
+		assert(arg != 0);
+
+		if (args[0].value < 2) {
+			dnerror(dnp, D_LLQUANT_FACTORSMALL, "llquantize( ) "
+			    "factor (argument #1) must be two or more\n");
+		}
+
+		if (args[1].value >= args[2].value) {
+			dnerror(dnp, D_LLQUANT_MAGRANGE, "llquantize( ) "
+			    "high magnitude (argument #3) must be greater "
+			    "than low magnitude (argument #2)\n");
+		}
+
+		if (args[3].value < args[0].value) {
+			dnerror(dnp, D_LLQUANT_FACTORNSTEPS, "llquantize( ) "
+			    "factor (argument #1) must be less than or "
+			    "equal to the number of linear steps per "
+			    "magnitude (argument #4)\n");
+		}
+
+		for (v = args[0].value; v < args[3].value; v *= args[0].value)
+			continue;
+
+		if ((args[3].value % args[0].value) || (v % args[3].value)) {
+			dnerror(dnp, D_LLQUANT_FACTOREVEN, "llquantize( ) "
+			    "factor (argument #1) must evenly divide the "
+			    "number of steps per magnitude (argument #4), "
+			    "and the number of steps per magnitude must evenly "
+			    "divide a power of the factor\n");
+		}
+
+		for (i = 0, order = 1; i < args[2].value; i++) {
+			if (order * args[0].value > order) {
+				order *= args[0].value;
+				continue;
+			}
+
+			dnerror(dnp, D_LLQUANT_MAGTOOBIG, "llquantize( ) "
+			    "factor (%d) raised to power of high magnitude "
+			    "(%d) overflows 64-bits\n", args[0].value,
+			    args[2].value);
+		}
+
+		isp = (dt_idsig_t *)aid->di_data;
+
+		if (isp->dis_auxinfo == 0) {
+			/*
+			 * This is the first time we've seen an llquantize()
+			 * for this aggregation; we'll store our argument
+			 * as the auxiliary signature information.
+			 */
+			isp->dis_auxinfo = arg;
+		} else if ((oarg = isp->dis_auxinfo) != arg) {
+			/*
+			 * If we have seen this llquantize() before and the
+			 * argument doesn't match the original argument, pick
+			 * the original argument apart to concisely report the
+			 * mismatch.
+			 */
+			int expected = 0, found = 0;
+
+			for (i = 0; expected == found; i++) {
+				assert(args[i].str != NULL);
+
+				expected = (oarg >> args[i].shift) & UINT16_MAX;
+				found = (arg >> args[i].shift) & UINT16_MAX;
+			}
+
+			dnerror(dnp, args[i - 1].mismatch, "llquantize( ) "
+			    "%s (argument #%d) doesn't match previous "
+			    "declaration: expected %d, found %d\n",
+			    args[i - 1].str, i, expected, found);
+		}
+
+		incr = llarg;
+		argmax = 6;
+	}
+
 	if (fid->di_id == DTRACEAGG_QUANTIZE) {
 		incr = dnp->dn_aggfun->dn_args->dn_list;
 		argmax = 2;
diff --git a/usr/src/lib/libdtrace/common/dt_consume.c b/usr/src/lib/libdtrace/common/dt_consume.c
index 564189a000..b8eb7cc344 100644
--- a/usr/src/lib/libdtrace/common/dt_consume.c
+++ b/usr/src/lib/libdtrace/common/dt_consume.c
@@ -23,6 +23,10 @@
  * Use is subject to license terms.
  */
 
+/*
+ * Copyright (c) 2011, Joyent, Inc. All rights reserved.
+ */
+
 #include <stdlib.h>
 #include <strings.h>
 #include <errno.h>
@@ -681,6 +685,121 @@ dt_print_lquantize(dtrace_hdl_t *dtp, FILE *fp, const void *addr,
 	return (0);
 }
 
+int
+dt_print_llquantize(dtrace_hdl_t *dtp, FILE *fp, const void *addr,
+    size_t size, uint64_t normal)
+{
+	int i, first_bin, last_bin, bin = 1, order, levels;
+	uint16_t factor, low, high, nsteps;
+	const int64_t *data = addr;
+	int64_t value = 1, next, step;
+	char positives = 0, negatives = 0;
+	long double total = 0;
+	uint64_t arg;
+	char c[32];
+
+	if (size < sizeof (uint64_t))
+		return (dt_set_errno(dtp, EDT_DMISMATCH));
+
+	arg = *data++;
+	size -= sizeof (uint64_t);
+
+	factor = DTRACE_LLQUANTIZE_FACTOR(arg);
+	low = DTRACE_LLQUANTIZE_LOW(arg);
+	high = DTRACE_LLQUANTIZE_HIGH(arg);
+	nsteps = DTRACE_LLQUANTIZE_NSTEP(arg);
+
+	/*
+	 * We don't expect to be handed invalid llquantize() parameters here,
+	 * but sanity check them (to a degree) nonetheless.
+	 */
+	if (size > INT32_MAX || factor < 2 || low >= high ||
+	    nsteps == 0 || factor > nsteps)
+		return (dt_set_errno(dtp, EDT_DMISMATCH));
+
+	levels = (int)size / sizeof (uint64_t);
+
+	first_bin = 0;
+	last_bin = levels - 1;
+
+	while (first_bin < levels && data[first_bin] == 0)
+		first_bin++;
+
+	if (first_bin == levels) {
+		first_bin = 0;
+		last_bin = 1;
+	} else {
+		if (first_bin > 0)
+			first_bin--;
+
+		while (last_bin > 0 && data[last_bin] == 0)
+			last_bin--;
+
+		if (last_bin < levels - 1)
+			last_bin++;
+	}
+
+	for (i = first_bin; i <= last_bin; i++) {
+		positives |= (data[i] > 0);
+		negatives |= (data[i] < 0);
+		total += dt_fabsl((long double)data[i]);
+	}
+
+	if (dt_printf(dtp, fp, "\n%16s %41s %-9s\n", "value",
+	    "------------- Distribution -------------", "count") < 0)
+		return (-1);
+
+	for (order = 0; order < low; order++)
+		value *= factor;
+
+	next = value * factor;
+	step = next > nsteps ? next / nsteps : 1;
+
+	if (first_bin == 0) {
+		(void) snprintf(c, sizeof (c), "< %lld", value);
+
+		if (dt_printf(dtp, fp, "%16s ", c) < 0)
+			return (-1);
+
+		if (dt_print_quantline(dtp, fp, data[0], normal,
+		    total, positives, negatives) < 0)
+			return (-1);
+	}
+
+	while (order <= high) {
+		if (bin >= first_bin && bin <= last_bin) {
+			if (dt_printf(dtp, fp, "%16lld ", (long long)value) < 0)
+				return (-1);
+
+			if (dt_print_quantline(dtp, fp, data[bin],
+			    normal, total, positives, negatives) < 0)
+				return (-1);
+		}
+
+		assert(value < next);
+		bin++;
+
+		if ((value += step) != next)
+			continue;
+
+		next = value * factor;
+		step = next > nsteps ? next / nsteps : 1;
+		order++;
+	}
+
+	if (last_bin < bin)
+		return (0);
+
+	assert(last_bin == bin);
+	(void) snprintf(c, sizeof (c), ">= %lld", value);
+
+	if (dt_printf(dtp, fp, "%16s ", c) < 0)
+		return (-1);
+
+	return (dt_print_quantline(dtp, fp, data[bin], normal,
+	    total, positives, negatives));
+}
+
 /*ARGSUSED*/
 static int
 dt_print_average(dtrace_hdl_t *dtp, FILE *fp, caddr_t addr,
@@ -1397,6 +1516,9 @@ dt_print_datum(dtrace_hdl_t *dtp, FILE *fp, dtrace_recdesc_t *rec,
 	case DTRACEAGG_LQUANTIZE:
 		return (dt_print_lquantize(dtp, fp, addr, size, normal));
 
+	case DTRACEAGG_LLQUANTIZE:
+		return (dt_print_llquantize(dtp, fp, addr, size, normal));
+
 	case DTRACEAGG_AVG:
 		return (dt_print_average(dtp, fp, addr, size, normal));
 
diff --git a/usr/src/lib/libdtrace/common/dt_errtags.h b/usr/src/lib/libdtrace/common/dt_errtags.h
index 9e32dfdf24..ed5d619de0 100644
--- a/usr/src/lib/libdtrace/common/dt_errtags.h
+++ b/usr/src/lib/libdtrace/common/dt_errtags.h
@@ -24,11 +24,13 @@
  * Use is subject to license terms.
  */
 
+/*
+ * Copyright (c) 2011, Joyent, Inc. All rights reserved.
+ */
+
 #ifndef	_DT_ERRTAGS_H
 #define	_DT_ERRTAGS_H
 
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
 #ifdef	__cplusplus
 extern "C" {
 #endif
@@ -235,7 +237,24 @@ typedef enum {
 	D_FREOPEN_INVALID,		/* frename() filename is invalid */
 	D_LQUANT_MATCHBASE,		/* lquantize() mismatch on base */
 	D_LQUANT_MATCHLIM,		/* lquantize() mismatch on limit */
-	D_LQUANT_MATCHSTEP		/* lquantize() mismatch on step */
+	D_LQUANT_MATCHSTEP,		/* lquantize() mismatch on step */
+	D_LLQUANT_FACTORTYPE,		/* llquantize() bad magnitude type */
+	D_LLQUANT_FACTORVAL,		/* llquantize() bad magnitude value */
+	D_LLQUANT_FACTORMATCH,		/* llquantize() mismatch on magnitude */
+	D_LLQUANT_LOWTYPE,		/* llquantize() bad low mag type */
+	D_LLQUANT_LOWVAL,		/* llquantize() bad low mag value */
+	D_LLQUANT_LOWMATCH,		/* llquantize() mismatch on low mag */
+	D_LLQUANT_HIGHTYPE,		/* llquantize() bad high mag type */
+	D_LLQUANT_HIGHVAL,		/* llquantize() bad high mag value */
+	D_LLQUANT_HIGHMATCH,		/* llquantize() mismatch on high mag */
+	D_LLQUANT_NSTEPTYPE,		/* llquantize() bad # steps type */
+	D_LLQUANT_NSTEPVAL,		/* llquantize() bad # steps value */
+	D_LLQUANT_NSTEPMATCH,		/* llquantize() mismatch on # steps */
+	D_LLQUANT_MAGRANGE,		/* llquantize() bad magnitude range */
+	D_LLQUANT_FACTORNSTEPS,		/* llquantize() # steps < factor */
+	D_LLQUANT_FACTOREVEN,		/* llquantize() bad # steps/factor */
+	D_LLQUANT_FACTORSMALL,		/* llquantize() magnitude too small */
+	D_LLQUANT_MAGTOOBIG		/* llquantize() high mag too large */
 } dt_errtag_t;
 
 extern const char *dt_errtag(dt_errtag_t);
diff --git a/usr/src/lib/libdtrace/common/dt_impl.h b/usr/src/lib/libdtrace/common/dt_impl.h
index 1937ce0647..bf513d7bd4 100644
--- a/usr/src/lib/libdtrace/common/dt_impl.h
+++ b/usr/src/lib/libdtrace/common/dt_impl.h
@@ -24,6 +24,10 @@
  * Use is subject to license terms.
  */
 
+/*
+ * Copyright (c) 2011, Joyent, Inc. All rights reserved.
+ */
+
 #ifndef	_DT_IMPL_H
 #define	_DT_IMPL_H
 
@@ -600,6 +604,8 @@ extern int dt_print_quantize(dtrace_hdl_t *, FILE *,
     const void *, size_t, uint64_t);
 extern int dt_print_lquantize(dtrace_hdl_t *, FILE *,
     const void *, size_t, uint64_t);
+extern int dt_print_llquantize(dtrace_hdl_t *, FILE *,
+    const void *, size_t, uint64_t);
 extern int dt_print_agg(const dtrace_aggdata_t *, void *);
 
 extern int dt_handle(dtrace_hdl_t *, dtrace_probedata_t *);
diff --git a/usr/src/lib/libdtrace/common/dt_open.c b/usr/src/lib/libdtrace/common/dt_open.c
index 2b9cd7c414..bd60702e49 100644
--- a/usr/src/lib/libdtrace/common/dt_open.c
+++ b/usr/src/lib/libdtrace/common/dt_open.c
@@ -21,6 +21,7 @@
 
 /*
  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, Joyent, Inc. All rights reserved.
  */
 
 #include <sys/types.h>
@@ -103,8 +104,9 @@
 #define	DT_VERS_1_6_1	DT_VERSION_NUMBER(1, 6, 1)
 #define	DT_VERS_1_6_2	DT_VERSION_NUMBER(1, 6, 2)
 #define	DT_VERS_1_6_3	DT_VERSION_NUMBER(1, 6, 3)
-#define	DT_VERS_LATEST	DT_VERS_1_6_3
-#define	DT_VERS_STRING	"Sun D 1.6.3"
+#define	DT_VERS_1_7	DT_VERSION_NUMBER(1, 7, 0)
+#define	DT_VERS_LATEST	DT_VERS_1_7
+#define	DT_VERS_STRING	"Sun D 1.7"
 
 const dt_version_t _dtrace_versions[] = {
 	DT_VERS_1_0,	/* D API 1.0.0 (PSARC 2001/466) Solaris 10 FCS */
@@ -120,6 +122,7 @@ const dt_version_t _dtrace_versions[] = {
 	DT_VERS_1_6_1,	/* D API 1.6.1 */
 	DT_VERS_1_6_2,	/* D API 1.6.2 */
 	DT_VERS_1_6_3,	/* D API 1.6.3 */
+	DT_VERS_1_7,	/* D API 1.7 */
 	0
 };
 
@@ -251,6 +254,9 @@ static const dt_ident_t _dtrace_globals[] = {
 	&dt_idops_func, "stack(...)" },
 { "lltostr", DT_IDENT_FUNC, 0, DIF_SUBR_LLTOSTR, DT_ATTR_STABCMN, DT_VERS_1_0,
 	&dt_idops_func, "string(int64_t)" },
+{ "llquantize", DT_IDENT_AGGFUNC, 0, DTRACEAGG_LLQUANTIZE, DT_ATTR_STABCMN,
+	DT_VERS_1_7, &dt_idops_func,
+	"void(@, int32_t, int32_t, int32_t, int32_t, ...)" },
 { "lquantize", DT_IDENT_AGGFUNC, 0, DTRACEAGG_LQUANTIZE,
 	DT_ATTR_STABCMN, DT_VERS_1_0,
 	&dt_idops_func, "void(@, int32_t, int32_t, ...)" },
diff --git a/usr/src/lib/libdtrace/common/dt_pragma.c b/usr/src/lib/libdtrace/common/dt_pragma.c
index 285d781fd5..9fae5ac42c 100644
--- a/usr/src/lib/libdtrace/common/dt_pragma.c
+++ b/usr/src/lib/libdtrace/common/dt_pragma.c
@@ -201,7 +201,7 @@ dt_pragma_binding(const char *prname, dt_node_t *dnp)
 		dtp->dt_globals->dh_defer = &dt_pragma_apply;
 }
 
-static void 
+static void
 dt_pragma_depends_finddep(dtrace_hdl_t *dtp, const char *lname, char *lib,
     size_t len)
 {
diff --git a/usr/src/lib/libdtrace/common/dt_printf.c b/usr/src/lib/libdtrace/common/dt_printf.c
index 52904789bc..eabc42338b 100644
--- a/usr/src/lib/libdtrace/common/dt_printf.c
+++ b/usr/src/lib/libdtrace/common/dt_printf.c
@@ -21,6 +21,7 @@
 
 /*
  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, Joyent, Inc. All rights reserved.
  */
 
 #include <sys/sysmacros.h>
@@ -1300,6 +1301,14 @@ pfprint_lquantize(dtrace_hdl_t *dtp, FILE *fp, const char *format,
 	return (dt_print_lquantize(dtp, fp, addr, size, normal));
 }
 
+/*ARGSUSED*/
+static int
+pfprint_llquantize(dtrace_hdl_t *dtp, FILE *fp, const char *format,
+    const dt_pfargd_t *pfd, const void *addr, size_t size, uint64_t normal)
+{
+	return (dt_print_llquantize(dtp, fp, addr, size, normal));
+}
+
 static int
 dt_printf_format(dtrace_hdl_t *dtp, FILE *fp, const dt_pfargv_t *pfv,
     const dtrace_recdesc_t *recs, uint_t nrecs, const void *buf,
@@ -1485,6 +1494,9 @@ dt_printf_format(dtrace_hdl_t *dtp, FILE *fp, const dt_pfargv_t *pfv,
 		case DTRACEAGG_LQUANTIZE:
 			func = pfprint_lquantize;
 			break;
+		case DTRACEAGG_LLQUANTIZE:
+			func = pfprint_llquantize;
+			break;
 		case DTRACEACT_MOD:
 			func = pfprint_mod;
 			break;
diff --git a/usr/src/lib/libdtrace/common/dtrace.h b/usr/src/lib/libdtrace/common/dtrace.h
index 1c041207c0..a5df05108d 100644
--- a/usr/src/lib/libdtrace/common/dtrace.h
+++ b/usr/src/lib/libdtrace/common/dtrace.h
@@ -24,11 +24,13 @@
  * Use is subject to license terms.
  */
 
+/*
+ * Copyright (c) 2011, Joyent, Inc. All rights reserved.
+ */
+
 #ifndef	_DTRACE_H
 #define	_DTRACE_H
 
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
 #include <sys/dtrace.h>
 #include <stdarg.h>
 #include <stdio.h>