Action clear() should clear only one aggregation
PATCH v2 1/1 Action clear() should clear only one aggregation
From: Eugene Loh <[email protected]>
In dt_clear(), we:
*) extract an aggregation ID (dtrace_aggid_t)
*) increment the gen counter for this aggregation ID
*) clear the consumer copy of the aggregation, using:
/* Also clear our own copy of the data, in case it gets printed. */
dtrace_aggregate_walk(dtp, dt_aggregate_clear_one, dtp);However, this clears all the aggregations. While the next snapshot of the aggregations will refresh our copies of the aggregations -- after all, dtrace_aggregate_snap() itself starts with a call to dtrace_aggregate_clear() -- if we print aggregations before the next snapshot, we would display an erroneously cleared aggregation.
Therefore, change dt_clear() to clear only those aggregations that correspond to the specified aggregation ID.
In order that only a specific aggregation ID can be cleared, we modify the last argument to dt_aggregate_clear_one() to be not simply the dtp, but a pointer to a struct that has both the dtp and the aggregation ID. The previous "clear all" behavior can be specified with an aggregation ID of DTRACE_AGGVARIDNONE.
Though trunc() appears not to be similarly afflicted, add a test for it too.
Orabug: 36900180
--- libdtrace/dt_aggregate.c | 17 ++++++++++++--- libdtrace/dt_aggregate.h | 24 ++++++++++++++++++++++ libdtrace/dt_consume.c | 5 ++++- test/unittest/aggs/tst.clear-one.d | 33 ++++++++++++++++++++++++++++++ test/unittest/aggs/tst.clear-one.r | 13 ++++++++++++ test/unittest/aggs/tst.trunc-one.d | 33 ++++++++++++++++++++++++++++++ test/unittest/aggs/tst.trunc-one.r | 10 +++++++++ 7 files changed, 131 insertions(+), 4 deletions(-) create mode 100644 libdtrace/dt_aggregate.h create mode 100644 test/unittest/aggs/tst.clear-one.d create mode 100644 test/unittest/aggs/tst.clear-one.r create mode 100644 test/unittest/aggs/tst.trunc-one.d create mode 100644 test/unittest/aggs/tst.trunc-one.r
libdtrace/dt_aggregate.c +14 -3
@@ -10,6 +10,7 @@#include <unistd.h> #include <dt_impl.h> #include <dtrace.h> +#include <dt_aggregate.h> #include <assert.h> #include <alloca.h> #include <limits.h>
@@ -465,7 +466,9 @@ dt_aggregate_clear_one_percpu(const dtrace_aggdata_t *agd,int dt_aggregate_clear_one (const dtrace_aggdata_t *agd,void *arg) { -dtrace_hdl_t *dtp = arg; +dt_clear_arg_t *dca = arg; +dtrace_hdl_t *dtp = dca->dtp; +dtrace_aggid_t aid = dca->aid;dtrace_aggdesc_t *agg = agd->dtada_desc;dtrace_recdesc_t *rec = &agg->dtagd_drecs[DT_AGGDATA_RECORD ]; int64_t *vals = (int64_t *)
@@ -473,6 +476,9 @@ dt_aggregate_clear_one(const dtrace_aggdata_t *agd, void *arg)uint64_t agen;int max_cpus = dtp->dt_conf.max_cpuid +1 ; +if (aid !=DTRACE_AGGVARIDNONE && aid != agg->dtagd_varid) +return DTRACE_AGGWALK_NEXT ; +/* * We can pass the entire key because we know that the first uint32_t * in the key is the aggregation ID we need.
@@ -570,7 +576,9 @@ dt_aggregate_snap_one(dtrace_hdl_t *dtp, int aggid, int cpu, const char *key,*/ hgen = *(int64_t *)agd->dtada_data;if (dgen > hgen) { -dt_aggregate_clear_one (agd, dtp); +dt_clear_arg_t arg = { dtp,DTRACE_AGGVARIDNONE }; + +dt_aggregate_clear_one (agd, &arg); hgen = *(int64_t *)agd->dtada_data; }
@@ -1820,10 +1828,13 @@ dtrace_aggregate_print(dtrace_hdl_t *dtp, FILE *fp,return 0 ; } +/* FIXME: dtrace_aggregate_clear() is called from only one site. Should we inline it? */ void dtrace_aggregate_clear (dtrace_hdl_t *dtp) { -dtrace_aggregate_walk (dtp, dt_aggregate_clear_one, dtp); +dt_clear_arg_t arg = { dtp,DTRACE_AGGVARIDNONE }; + +dtrace_aggregate_walk (dtp, dt_aggregate_clear_one, &arg); }void
libdtrace/dt_aggregate.h new file +24 -0
@@ -0,0 +1,24 @@ +/* +* Oracle Linux DTrace. +* Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. +* Licensed under the Universal Permissive License v 1.0 as shown at +* http://oss.oracle.com/licenses/upl. +*/ + +#ifndef _DT_AGGREGATE_H +#define _DT_AGGREGATE_H + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct dt_clear_arg { +dtrace_hdl_t *dtp; +dtrace_aggid_t aid; +}dt_clear_arg_t ; + +#ifdef __cplusplus +} +#endif + +#endif /* _DT_AGGREGATE_H */
libdtrace/dt_consume.c +4 -1
@@ -14,6 +14,7 @@#include <ctype.h> #include <alloca.h> #include <dt_impl.h> +#include <dt_aggregate.h> #include <dt_dctx.h> #include <dt_module.h> #include <dt_pcap.h>
@@ -1535,6 +1536,7 @@ dt_clear(dtrace_hdl_t *dtp, caddr_t base, dtrace_recdesc_t *rec)dtrace_aggid_t aid;uint64_t gen;caddr_t addr; +dt_clear_arg_t arg = { dtp,0 };/* We have just one record: the aggregation ID. */ addr = base + rec->dtrd_offset;
@@ -1551,7 +1553,8 @@ dt_clear(dtrace_hdl_t *dtp, caddr_t base, dtrace_recdesc_t *rec)return -1 ;/* Also clear our own copy of the data, in case it gets printed. */ -dtrace_aggregate_walk (dtp, dt_aggregate_clear_one, dtp); + arg.aid = aid; +dtrace_aggregate_walk (dtp, dt_aggregate_clear_one, &arg);return 0 ; }
test/unittest/aggs/tst.clear-one.d new file +33 -0
@@ -0,0 +1,33 @@ +/* + * Oracle Linux DTrace. + * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. + * Licensed under the Universal Permissive License v 1.0 as shown at + * http://oss.oracle.com/licenses/upl. + */ + +/* + * ASSERTION: Clearing one aggregation clears only that one. + * + * SECTION: Aggregations/Clearing aggregations + */ +/* @@nosort */ + +#pragma D option quiet + +BEGIN +{ + @a[1] = sum(100); + @a[2] = sum( 20); + @a[3] = sum( 3); + @b[4] = sum(400); + @b[5] = sum( 50); + @b[6] = sum( 6); + @c[7] = sum(700); + @c[8] = sum( 80); + @c[9] = sum( 9); + clear(@b); + printa(@a); + printa(@b); + printa(@c); + exit(0); +}
test/unittest/aggs/tst.clear-one.r new file +13 -0
@@ -0,0 +1,13 @@ + + 3 3 + 2 20 + 1 100 + + 4 0 + 5 0 + 6 0 + + 9 9 + 8 80 + 7 700 +
test/unittest/aggs/tst.trunc-one.d new file +33 -0
@@ -0,0 +1,33 @@ +/* + * Oracle Linux DTrace. + * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. + * Licensed under the Universal Permissive License v 1.0 as shown at + * http://oss.oracle.com/licenses/upl. + */ + +/* + * ASSERTION: Truncating one aggregation truncates only that one. + * + * SECTION: Aggregations/Clearing aggregations + */ +/* @@nosort */ + +#pragma D option quiet + +BEGIN +{ + @a[1] = sum(100); + @a[2] = sum( 20); + @a[3] = sum( 3); + @b[4] = sum(400); + @b[5] = sum( 50); + @b[6] = sum( 6); + @c[7] = sum(700); + @c[8] = sum( 80); + @c[9] = sum( 9); + trunc(@b); + printa(@a); + printa(@b); + printa(@c); + exit(0); +}
test/unittest/aggs/tst.trunc-one.r new file +10 -0
@@ -0,0 +1,10 @@ + + 3 3 + 2 20 + 1 100 + + + 9 9 + 8 80 + 7 700 +
Signature · 1 line
2.43.5