[DTrace-devel] [PATCH v2 2/2] cg: transition [u]stack() from action to subroutine
Kris Van Hees
kris.van.hees at oracle.com
Mon Sep 29 19:47:29 UTC 2025
In order to allow [u]stack() to be used in expressions, they must be
subroutines. An exception is added to allow them to retain their
original behaviour as data recording actions as well.
The implementation change requires a new internal type to be defined
(dt_stack) to hold stack trace data.
This patch does not allow [u]stack() to be used in assignments to
variables just yet, but it supports all previous uses of [u]stack().
Additional functionality will be added on top of this.
Signed-off-by: Kris Van Hees <kris.van.hees at oracle.com>
---
include/dtrace/dif_defines.h | 6 +-
libdtrace/dt_cg.c | 350 +++++++++++-------
libdtrace/dt_dctx.h | 4 +-
libdtrace/dt_open.c | 21 +-
libdtrace/dt_options.c | 44 ++-
libdtrace/dt_printf.c | 3 +-
test/unittest/funcs/tst.subr.d | 13 +-
.../printa/err.D_PRINTF_ARG_TYPE.stack.r | 2 +-
.../printa/err.D_PRINTF_ARG_TYPE.ustack.r | 2 +-
9 files changed, 289 insertions(+), 156 deletions(-)
diff --git a/include/dtrace/dif_defines.h b/include/dtrace/dif_defines.h
index 9f6e3b55..a18614d2 100644
--- a/include/dtrace/dif_defines.h
+++ b/include/dtrace/dif_defines.h
@@ -2,7 +2,7 @@
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*
- * Copyright (c) 2009, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 2025, Oracle and/or its affiliates. All rights reserved.
*/
/*
@@ -210,8 +210,10 @@
#define DIF_SUBR_INET_NTOA6 43
#define DIF_SUBR_D_PATH 44
#define DIF_SUBR_LINK_NTOP 45
+#define DIF_SUBR_STACK 46
+#define DIF_SUBR_USTACK 47
-#define DIF_SUBR_MAX 45
+#define DIF_SUBR_MAX 47
typedef uint32_t dif_instr_t;
diff --git a/libdtrace/dt_cg.c b/libdtrace/dt_cg.c
index 51473667..0299ccb1 100644
--- a/libdtrace/dt_cg.c
+++ b/libdtrace/dt_cg.c
@@ -2723,7 +2723,8 @@ dt_cg_stack_arg(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_actkind_t kind)
* The "kind" argument is either DTRACEACT_STACK or DTRACEACT_USTACK.
*/
static int
-dt_cg_act_stack_sub(dt_pcb_t *pcb, dt_node_t *dnp, int reg, int off, dtrace_actkind_t kind)
+dt_cg_act_stack_sub(dt_pcb_t *pcb, dt_node_t *dnp, int reg, int off,
+ dtrace_actkind_t kind)
{
dtrace_hdl_t *dtp = pcb->pcb_hdl;
dt_irlist_t *dlp = &pcb->pcb_ir;
@@ -2743,12 +2744,9 @@ dt_cg_act_stack_sub(dt_pcb_t *pcb, dt_node_t *dnp, int reg, int off, dtrace_actk
/* Handle alignment and reserve space in the output buffer. */
if (reg >= 0) {
- uint_t nextoff;
- nextoff = (off + (align - 1)) & ~(align - 1);
- if (off < nextoff)
- emit(dlp, BPF_ALU64_IMM(BPF_ADD, reg, nextoff - off));
- off = nextoff + prefsz + stacksize;
+ off = ALIGN(off, align);
} else {
+ reg = BPF_REG_9;
off = dt_rec_add(dtp, dt_cg_fill_gap, kind,
prefsz + stacksize, align, NULL, arg);
}
@@ -2762,11 +2760,7 @@ dt_cg_act_stack_sub(dt_pcb_t *pcb, dt_node_t *dnp, int reg, int off, dtrace_actk
dt_regset_free_args(drp);
/* mov32 %r0, %r0 effectively masks the lower 32 bits. */
emit(dlp, BPF_MOV32_REG(BPF_REG_0, BPF_REG_0));
-
- if (reg >= 0)
- emit(dlp, BPF_STORE(BPF_DW, reg, 0, BPF_REG_0));
- else
- emit(dlp, BPF_STORE(BPF_DW, BPF_REG_9, off, BPF_REG_0));
+ emit(dlp, BPF_STORE(BPF_DW, reg, off, BPF_REG_0));
dt_regset_free(drp, BPF_REG_0);
}
@@ -2774,14 +2768,8 @@ dt_cg_act_stack_sub(dt_pcb_t *pcb, dt_node_t *dnp, int reg, int off, dtrace_actk
if (dt_regset_xalloc_args(drp) == -1)
longjmp(yypcb->pcb_jmpbuf, EDT_NOREG);
dt_cg_access_dctx(BPF_REG_1, dlp, drp, DCTX_CTX);
- if (reg >= 0) {
- emit(dlp, BPF_MOV_REG(BPF_REG_2, reg));
- if (prefsz)
- emit(dlp, BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, prefsz));
- } else {
- emit(dlp, BPF_MOV_REG(BPF_REG_2, BPF_REG_9));
- emit(dlp, BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, off + prefsz));
- }
+ emit(dlp, BPF_MOV_REG(BPF_REG_2, reg));
+ emit(dlp, BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, off + prefsz));
emit(dlp, BPF_MOV_IMM(BPF_REG_3, stacksize));
if (kind == DTRACEACT_USTACK)
emit(dlp, BPF_MOV_IMM(BPF_REG_4, BPF_F_USER_STACK));
@@ -2798,11 +2786,7 @@ dt_cg_act_stack_sub(dt_pcb_t *pcb, dt_node_t *dnp, int reg, int off, dtrace_actk
emitl(dlp, lbl_valid,
BPF_NOP());
- /* Finish. */
- if (reg >= 0)
- emit(dlp, BPF_ALU64_IMM(BPF_ADD, reg, prefsz + stacksize));
-
- return off;
+ return prefsz + stacksize;
}
static void
@@ -3909,33 +3893,42 @@ dt_cg_arglist(dt_ident_t *idp, dt_node_t *args, dt_irlist_t *dlp,
longjmp(yypcb->pcb_jmpbuf, EDT_NOTUPREG);
/*
- * Handle actions that can be used as agg keys.
- * If we are not an aggregation, dt_cg_node(dnp, ...)
- * will alert us there is a problem.
+ * Some function calls (actions or subroutines) need special
+ * handling.
*/
- if (idp->di_kind == DT_IDENT_AGG &&
- dnp->dn_kind == DT_NODE_FUNC &&
- dnp->dn_ident != NULL)
- switch (dnp->dn_ident->di_id) {
- case DT_ACT_STACK:
- case DT_ACT_USTACK:
- /* If this is a stack()-like function, we can handle it later. */
- dt_cg_push_stack(BPF_REG_FP, dlp, drp);
- continue;
- case DT_ACT_JSTACK:
- dnerror(dnp, D_UNKNOWN, "jstack() is not implemented (yet)\n");
- /* FIXME: Needs implementation */
- case DT_ACT_SYM:
- case DT_ACT_MOD:
- case DT_ACT_UADDR:
- case DT_ACT_UMOD:
- case DT_ACT_USYM:
- /* Otherwise, use the action's arg, not its "return value". */
- dt_cg_node(dnp->dn_args, dlp, drp);
- dt_cg_push_stack(dnp->dn_args->dn_reg, dlp, drp);
- dt_regset_free(drp, dnp->dn_args->dn_reg);
- continue;
+ if (dnp->dn_kind == DT_NODE_FUNC) {
+ dt_ident_t *fidp = dnp->dn_ident;
+
+ assert(fidp != NULL);
+
+ /*
+ * For subroutines, stack() and ustack() don't need to
+ * be evaluated until we fill in the data of the tuple.
+ */
+ if (fidp->di_kind == DT_IDENT_FUNC) {
+ if (fidp->di_id == DIF_SUBR_STACK ||
+ fidp->di_id == DIF_SUBR_USTACK) {
+ dt_cg_push_stack(BPF_REG_FP, dlp, drp);
+ continue;
+ }
+ } else if (fidp->di_kind == DT_IDENT_ACTFUNC) {
+ switch (fidp->di_id) {
+ case DT_ACT_JSTACK:
+ dnerror(dnp, D_UNKNOWN, "jstack() is not implemented (yet)\n");
+ /* FIXME: Needs implementation */
+ case DT_ACT_SYM:
+ case DT_ACT_MOD:
+ case DT_ACT_UADDR:
+ case DT_ACT_UMOD:
+ case DT_ACT_USYM:
+ /* Otherwise, use the action's arg, not its "return value". */
+ dt_cg_node(dnp->dn_args, dlp, drp);
+ dt_cg_push_stack(dnp->dn_args->dn_reg, dlp, drp);
+ dt_regset_free(drp, dnp->dn_args->dn_reg);
+ continue;
+ }
}
+ }
/* Push the component (pointer or value) onto the tuple stack. */
dt_cg_node(dnp, dlp, drp);
@@ -3972,7 +3965,6 @@ empty_args:
dt_regset_free(drp, BPF_REG_0);
/* Reserve space for a uint32_t value at the beginning of the tuple. */
- emit(dlp, BPF_ALU64_IMM(BPF_ADD, treg, sizeof(uint32_t)));
tuplesize = sizeof(uint32_t);
if ((areg = dt_regset_alloc(drp)) == -1)
@@ -3986,53 +3978,62 @@ empty_args:
for (dnp = args, i = 0; dnp != NULL; dnp = dnp->dn_list, i++) {
dtrace_diftype_t t;
size_t size;
- uint_t nextoff;
int is_symmod = 0;
- if (dnp->dn_kind == DT_NODE_FUNC &&
- dnp->dn_ident != NULL)
- switch (dnp->dn_ident->di_id) {
- case DT_ACT_STACK:
- tuplesize = dt_cg_act_stack_sub(yypcb, dnp, treg, tuplesize, DTRACEACT_STACK);
- continue;
- case DT_ACT_USTACK:
- tuplesize = dt_cg_act_stack_sub(yypcb, dnp, treg, tuplesize, DTRACEACT_USTACK);
- continue;
- case DT_ACT_UADDR:
- case DT_ACT_USYM:
- case DT_ACT_UMOD:
- nextoff = (tuplesize + (8 - 1)) & ~(8 - 1);
- if (tuplesize < nextoff)
- emit(dlp, BPF_ALU64_IMM(BPF_ADD, treg, nextoff - tuplesize));
-
- /* Preface the value with the user process pid. */
- if (dt_regset_xalloc_args(drp) == -1)
- longjmp(yypcb->pcb_jmpbuf, EDT_NOREG);
- dt_regset_xalloc(drp, BPF_REG_0);
- emit(dlp, BPF_CALL_HELPER(BPF_FUNC_get_current_pid_tgid));
- dt_regset_free_args(drp);
- emit(dlp, BPF_ALU64_IMM(BPF_RSH, BPF_REG_0, 32));
- emit(dlp, BPF_STORE(BPF_DW, treg, 0, BPF_REG_0));
- dt_regset_free(drp, BPF_REG_0);
-
- /* Then store the value. */
- dt_regset_xalloc(drp, BPF_REG_0);
- emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, areg, -i * DT_STK_SLOT_SZ));
- emit(dlp, BPF_STORE(BPF_DW, treg, 8, BPF_REG_0));
- dt_regset_free(drp, BPF_REG_0);
-
- emit(dlp, BPF_ALU64_IMM(BPF_ADD, treg, 16));
- tuplesize = nextoff + 16;
-
- continue;
- case DT_ACT_SYM:
- case DT_ACT_MOD:
- is_symmod = 1;
- size = 8;
- dt_regset_xalloc(drp, BPF_REG_0);
- emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, areg, -i * DT_STK_SLOT_SZ));
- break;
+ if (dnp->dn_kind == DT_NODE_FUNC) {
+ dt_ident_t *fidp = dnp->dn_ident;
+
+ if (fidp->di_kind == DT_IDENT_FUNC) {
+ switch (fidp->di_id) {
+ case DIF_SUBR_STACK:
+ tuplesize += dt_cg_act_stack_sub(
+ yypcb, dnp, treg,
+ tuplesize,
+ DTRACEACT_STACK);
+ continue;
+ case DIF_SUBR_USTACK:
+ tuplesize += dt_cg_act_stack_sub(
+ yypcb, dnp, treg,
+ tuplesize,
+ DTRACEACT_USTACK);
+ continue;
+ }
+ } else if (fidp->di_kind == DT_IDENT_ACTFUNC) {
+ switch (fidp->di_id) {
+ case DT_ACT_UADDR:
+ case DT_ACT_USYM:
+ case DT_ACT_UMOD:
+ tuplesize = ALIGN(tuplesize, 8);
+
+ /* Preface the value with the user process pid. */
+ if (dt_regset_xalloc_args(drp) == -1)
+ longjmp(yypcb->pcb_jmpbuf, EDT_NOREG);
+ dt_regset_xalloc(drp, BPF_REG_0);
+ emit(dlp, BPF_CALL_HELPER(BPF_FUNC_get_current_pid_tgid));
+ dt_regset_free_args(drp);
+ emit(dlp, BPF_ALU64_IMM(BPF_RSH, BPF_REG_0, 32));
+ emit(dlp, BPF_STORE(BPF_DW, treg, tuplesize, BPF_REG_0));
+ dt_regset_free(drp, BPF_REG_0);
+
+ /* Then store the value. */
+ dt_regset_xalloc(drp, BPF_REG_0);
+ emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, areg, -i * DT_STK_SLOT_SZ));
+ emit(dlp, BPF_STORE(BPF_DW, treg, tuplesize + 8, BPF_REG_0));
+ dt_regset_free(drp, BPF_REG_0);
+
+ tuplesize += 16;
+
+ continue;
+ case DT_ACT_SYM:
+ case DT_ACT_MOD:
+ is_symmod = 1;
+ size = 8;
+ dt_regset_xalloc(drp, BPF_REG_0);
+ emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, areg, -i * DT_STK_SLOT_SZ));
+ break;
+ }
}
+ }
if (!is_symmod) {
dt_node_diftype(dtp, dnp, &t);
@@ -4052,15 +4053,12 @@ empty_args:
}
if (dt_node_is_scalar(dnp) || dt_node_is_float(dnp) || is_symmod) {
- nextoff = (tuplesize + (size - 1)) & ~(size - 1);
- if (tuplesize < nextoff)
- emit(dlp, BPF_ALU64_IMM(BPF_ADD, treg, nextoff - tuplesize));
+ tuplesize = ALIGN(tuplesize, size);
- emit(dlp, BPF_STOREX(size, treg, 0, BPF_REG_0));
+ emit(dlp, BPF_STOREX(size, treg, tuplesize, BPF_REG_0));
dt_regset_free(drp, BPF_REG_0);
- emit(dlp, BPF_ALU64_IMM(BPF_ADD, treg, size));
- tuplesize = nextoff + size;
+ tuplesize += size;
} else if (dt_node_is_string(dnp)) {
uint_t lbl_valid = dt_irlist_label(dlp);
@@ -4068,6 +4066,7 @@ empty_args:
longjmp(yypcb->pcb_jmpbuf, EDT_NOREG);
emit(dlp, BPF_MOV_REG(BPF_REG_1, treg));
+ emit(dlp, BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, tuplesize));
emit(dlp, BPF_MOV_IMM(BPF_REG_2, size + 1));
emit(dlp, BPF_MOV_REG(BPF_REG_3, BPF_REG_0));
dt_cg_tstring_free(yypcb, dnp);
@@ -4081,7 +4080,7 @@ empty_args:
DT_ISIMM, 128 + i);
emitl(dlp, lbl_valid,
- BPF_ALU64_IMM(BPF_ADD, treg, size + 1));
+ BPF_NOP());
tuplesize += size + 1;
} else if (t.dtdt_flags & DIF_TF_BYREF) {
uint_t lbl_valid = dt_irlist_label(dlp);
@@ -4090,6 +4089,7 @@ empty_args:
longjmp(yypcb->pcb_jmpbuf, EDT_NOREG);
emit(dlp, BPF_MOV_REG(BPF_REG_1, treg));
+ emit(dlp, BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, tuplesize));
emit(dlp, BPF_MOV_IMM(BPF_REG_2, size));
emit(dlp, BPF_MOV_REG(BPF_REG_3, BPF_REG_0));
dt_regset_free(drp, BPF_REG_0);
@@ -4102,7 +4102,7 @@ empty_args:
DT_ISIMM, 0);
emitl(dlp, lbl_valid,
- BPF_ALU64_IMM(BPF_ADD, treg, size));
+ BPF_NOP());
tuplesize += size;
} else
assert(0); /* We shouldn't be able to get here. */
@@ -4128,10 +4128,10 @@ empty_args:
dt_regset_xalloc(drp, BPF_REG_0);
emite(dlp, BPF_CALL_FUNC(idp->di_id), idp);
dt_regset_free_args(drp);
- emit(dlp, BPF_STORE(BPF_DW, treg, 0, BPF_REG_0));
+ emit(dlp, BPF_STORE(BPF_DW, treg, tuplesize, BPF_REG_0));
dt_regset_free(drp, BPF_REG_0);
} else
- emit(dlp, BPF_STORE_IMM(BPF_DW, treg, 0, 0));
+ emit(dlp, BPF_STORE_IMM(BPF_DW, treg, tuplesize, 0));
/* Account for the optional TLS key (or 0). */
tuplesize += sizeof(uint64_t);
@@ -6324,6 +6324,42 @@ dt_cg_subr_strchr(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
TRACE_REGSET(" subr-strchr:End ");
}
+static void
+dt_cg_subr_stack_common(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp,
+ dtrace_actkind_t kind)
+{
+ dtrace_hdl_t *dtp = yypcb->pcb_hdl;
+
+ if ((dnp->dn_reg = dt_regset_alloc(drp)) == -1)
+ longjmp(yypcb->pcb_jmpbuf, EDT_NOREG);
+
+ /*
+ * Collect the stack in the static buffer (because it is an invariant
+ * for a probe firing), and return a pointer to it.
+ */
+ dt_cg_access_dctx(dnp->dn_reg, dlp, drp, DCTX_MEM);
+ emit(dlp, BPF_ALU64_IMM(BPF_ADD, dnp->dn_reg, DMEM_STACK(dtp)));
+
+ /* Call the stack helper function to collect the stack. */
+ dt_cg_act_stack_sub(yypcb, dnp, dnp->dn_reg, 0, kind);
+}
+
+static void
+dt_cg_subr_stack(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
+{
+ TRACE_REGSET(" subr-stack:Begin");
+ dt_cg_subr_stack_common(dnp, dlp, drp, DTRACEACT_STACK);
+ TRACE_REGSET(" subr-stack:End ");
+}
+
+static void
+dt_cg_subr_ustack(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
+{
+ TRACE_REGSET(" subr-ustack:Begin");
+ dt_cg_subr_stack_common(dnp, dlp, drp, DTRACEACT_USTACK);
+ TRACE_REGSET(" subr-ustack:End ");
+}
+
static void
dt_cg_subr_strrchr(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
{
@@ -6953,6 +6989,8 @@ static dt_cg_subr_f *_dt_cg_subr[DIF_SUBR_MAX + 1] = {
[DIF_SUBR_INET_NTOA6] = &dt_cg_subr_inet_ntoa6,
[DIF_SUBR_D_PATH] = &dt_cg_subr_d_path,
[DIF_SUBR_LINK_NTOP] = &dt_cg_subr_link_ntop,
+ [DIF_SUBR_STACK] = &dt_cg_subr_stack,
+ [DIF_SUBR_USTACK] = &dt_cg_subr_ustack,
};
static void
@@ -8692,43 +8730,50 @@ dt_cg_agg(dt_pcb_t *pcb, dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
uint64_t arg = 0;
dt_ident_t *idp = knp->dn_ident;
- if (knp->dn_kind == DT_NODE_FUNC && idp != NULL &&
- idp->di_kind == DT_IDENT_ACTFUNC) {
- size = 16;
+ if (knp->dn_kind == DT_NODE_FUNC && idp != NULL) {
alignment = 8;
- switch (idp->di_id) {
- case DT_ACT_USTACK:
- arg = dt_cg_stack_arg(dtp, knp, DTRACEACT_USTACK);
- kind = DTRACEACT_USTACK;
- size = 8 + 8 * DTRACE_STACK_NFRAMES(arg);
- break;
- case DT_ACT_JSTACK:
- kind = DTRACEACT_JSTACK;
- break;
- case DT_ACT_USYM:
- kind = DTRACEACT_USYM;
- break;
- case DT_ACT_UMOD:
- kind = DTRACEACT_UMOD;
- break;
- case DT_ACT_UADDR:
- kind = DTRACEACT_UADDR;
- break;
- case DT_ACT_STACK:
- arg = dt_cg_stack_arg(dtp, knp, DTRACEACT_STACK);
- kind = DTRACEACT_STACK;
- size = 8 * arg;
- break;
- case DT_ACT_SYM:
- kind = DTRACEACT_SYM;
- size = 8;
- break;
- case DT_ACT_MOD:
- kind = DTRACEACT_MOD;
- size = 8;
- break;
+
+ if (idp->di_kind == DT_IDENT_FUNC) {
+ switch (idp->di_id) {
+ case DIF_SUBR_USTACK:
+ arg = dt_cg_stack_arg(dtp, knp, DTRACEACT_USTACK);
+ kind = DTRACEACT_USTACK;
+ size = 8 + 8 * DTRACE_STACK_NFRAMES(arg);
+ goto add_rec;
+ case DIF_SUBR_STACK:
+ arg = dt_cg_stack_arg(dtp, knp, DTRACEACT_STACK);
+ kind = DTRACEACT_STACK;
+ size = 8 * arg;
+ goto add_rec;
+ }
+ } else if (idp->di_kind == DT_IDENT_ACTFUNC) {
+ size = 16;
+ switch (idp->di_id) {
+ case DT_ACT_JSTACK:
+ kind = DTRACEACT_JSTACK;
+ goto add_rec;
+ case DT_ACT_USYM:
+ kind = DTRACEACT_USYM;
+ goto add_rec;
+ case DT_ACT_UMOD:
+ kind = DTRACEACT_UMOD;
+ goto add_rec;
+ case DT_ACT_UADDR:
+ kind = DTRACEACT_UADDR;
+ goto add_rec;
+ case DT_ACT_SYM:
+ kind = DTRACEACT_SYM;
+ size = 8;
+ goto add_rec;
+ case DT_ACT_MOD:
+ kind = DTRACEACT_MOD;
+ size = 8;
+ goto add_rec;
+ }
}
- } else if (dt_node_is_string(knp)) {
+ }
+
+ if (dt_node_is_string(knp)) {
size = dtp->dt_options[DTRACEOPT_STRSIZE] + 1;
alignment = 1;
} else {
@@ -8739,6 +8784,7 @@ dt_cg_agg(dt_pcb_t *pcb, dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
alignment = size;
}
+add_rec:
dt_aggid_rec_add(dtp, aid->di_id, kind, size, alignment, arg);
}
}
@@ -8822,10 +8868,34 @@ dt_cg(dt_pcb_t *pcb, dt_node_t *dnp)
if (enp->dn_kind == DT_NODE_AGG)
dt_cg_agg(pcb, enp, &pcb->pcb_ir,
pcb->pcb_regs);
- else
+ else {
+ /*
+ * Special case: [u]stack() in statement
+ * context is treated as data generating
+ * action.
+ */
+ if (enp->dn_kind == DT_NODE_FUNC) {
+ uint_t id;
+
+ id = enp->dn_ident->di_id;
+ if (id == DIF_SUBR_STACK)
+ id = DTRACEACT_STACK;
+ else if (id == DIF_SUBR_USTACK)
+ id = DTRACEACT_USTACK;
+ else
+ id = 0;
+
+ if (id) {
+ dt_cg_act_stack(pcb, enp, id);
+ pcb->pcb_stmt->dtsd_clauseflags |= DT_CLSFLAG_DATAREC;
+ goto done;
+ }
+ }
dt_cg_node(enp, &pcb->pcb_ir,
pcb->pcb_regs);
+ }
+done:
if (enp->dn_reg != -1) {
dt_regset_free(pcb->pcb_regs,
enp->dn_reg);
diff --git a/libdtrace/dt_dctx.h b/libdtrace/dt_dctx.h
index 9ff6cca5..b50a1395 100644
--- a/libdtrace/dt_dctx.h
+++ b/libdtrace/dt_dctx.h
@@ -1,6 +1,6 @@
/*
* Oracle Linux DTrace.
- * Copyright (c) 2020, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, 2025, 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.
*/
@@ -128,7 +128,7 @@ typedef struct dt_dctx {
* completed.
*/
#define DMEM_STACK_SZ(dtp) \
- (sizeof(uint64_t) * (dtp)->dt_options[DTRACEOPT_MAXFRAMES])
+ (sizeof(uint64_t) * (dtp)->dt_options[DTRACEOPT_MAXFRAMES] + 1)
#define DMEM_TSTR_SZ(dtp) \
(DT_TSTRING_SLOTS * DT_TSTRING_SIZE(dtp))
#define DMEM_STRTOK_SZ(dtp) \
diff --git a/libdtrace/dt_open.c b/libdtrace/dt_open.c
index 509f263d..ed0b14a1 100644
--- a/libdtrace/dt_open.c
+++ b/libdtrace/dt_open.c
@@ -175,7 +175,7 @@ static const dt_ident_t _dtrace_globals[] = {
{ "ipl", DT_IDENT_SCALAR, 0, DIF_VAR_IPL, DT_ATTR_STABCMN, DT_VERS_1_0,
&dt_idops_type, "uint_t" },
{ "jstack", DT_IDENT_ACTFUNC, 0, DT_ACT_JSTACK, DT_ATTR_STABCMN, DT_VERS_1_0,
- &dt_idops_func, "stack([uint32_t], [uint32_t])" },
+ &dt_idops_func, "dt_stack([uint32_t], [uint32_t])" },
{ "link_ntop", DT_IDENT_FUNC, 0, DIF_SUBR_LINK_NTOP, DT_ATTR_STABCMN,
DT_VERS_1_5, &dt_idops_func, "string(int, void *)" },
{ "llquantize", DT_IDENT_AGGFUNC, 0, DT_AGG_LLQUANTIZE,
@@ -273,8 +273,8 @@ static const dt_ident_t _dtrace_globals[] = {
{ "speculation", DT_IDENT_FUNC, 0, DIF_SUBR_SPECULATION,
DT_ATTR_STABCMN, DT_VERS_1_0,
&dt_idops_func, "int()" },
-{ "stack", DT_IDENT_ACTFUNC, 0, DT_ACT_STACK, DT_ATTR_STABCMN, DT_VERS_1_0,
- &dt_idops_func, "stack([uint32_t])" },
+{ "stack", DT_IDENT_FUNC, DT_IDFLG_DPTR, DIF_SUBR_STACK, DT_ATTR_STABCMN,
+ DT_VERS_1_0, &dt_idops_func, "dt_stack([uint32_t])" },
{ "stackdepth", DT_IDENT_SCALAR, 0, DIF_VAR_STACKDEPTH,
DT_ATTR_STABCMN, DT_VERS_1_0,
&dt_idops_type, "uint32_t" },
@@ -328,8 +328,8 @@ static const dt_ident_t _dtrace_globals[] = {
DT_VERS_1_2, &dt_idops_func, "_usymaddr(uintptr_t)" },
{ "uregs", DT_IDENT_ARRAY, 0, DIF_VAR_UREGS, DT_ATTR_STABCMN, DT_VERS_1_0,
&dt_idops_regs, NULL },
-{ "ustack", DT_IDENT_ACTFUNC, 0, DT_ACT_USTACK, DT_ATTR_STABCMN, DT_VERS_1_0,
- &dt_idops_func, "stack([uint32_t], [uint32_t])" },
+{ "ustack", DT_IDENT_FUNC, DT_IDFLG_DPTR, DIF_SUBR_USTACK, DT_ATTR_STABCMN,
+ DT_VERS_1_0, &dt_idops_func, "dt_stack([uint32_t], [uint32_t])" },
{ "ustackdepth", DT_IDENT_SCALAR, 0, DIF_VAR_USTACKDEPTH,
DT_ATTR_STABCMN, DT_VERS_1_2,
&dt_idops_type, "uint32_t" },
@@ -1054,8 +1054,17 @@ dt_vopen(int version, int flags, int *errp,
dtp->dt_type_dyn = ctf_add_typedef(dmp->dm_ctfp, CTF_ADD_ROOT,
"<DYN>", ctf_lookup_by_name(dmp->dm_ctfp, "void"));
+ /*
+ * The stack type is added as a typedef of uint64_t[MAXFRAMES]. The
+ * final value of MAXFRAMES may be adjusted with the "stackframes"
+ * option.
+ */
+ ctr.ctr_contents = ctf_lookup_by_name(dmp->dm_ctfp, "uint64_t");
+ ctr.ctr_index = ctf_lookup_by_name(dmp->dm_ctfp, "long");
+ ctr.ctr_nelems = _dtrace_stackframes;
+
dtp->dt_type_stack = ctf_add_typedef(dmp->dm_ctfp, CTF_ADD_ROOT,
- "stack", ctf_lookup_by_name(dmp->dm_ctfp, "void"));
+ "dt_stack", ctf_add_array(dmp->dm_ctfp, CTF_ADD_ROOT, &ctr));
dtp->dt_type_symaddr = ctf_add_typedef(dmp->dm_ctfp, CTF_ADD_ROOT,
"_symaddr", ctf_lookup_by_name(dmp->dm_ctfp, "void"));
diff --git a/libdtrace/dt_options.c b/libdtrace/dt_options.c
index 25e79979..7508f044 100644
--- a/libdtrace/dt_options.c
+++ b/libdtrace/dt_options.c
@@ -1,6 +1,6 @@
/*
* Oracle Linux DTrace.
- * Copyright (c) 2007, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 2025, 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.
*/
@@ -912,6 +912,46 @@ dt_opt_rate(dtrace_hdl_t *dtp, const char *arg, uintptr_t option)
return 0;
}
+/*
+ * When setting the maxframes option, set the option in the dt_options array
+ * using dt_opt_runtime() as usual, and then update the definition of the CTF
+ * type for "_stack" to be an array of the corresponding size.
+ * If any errors occur, reset dt_options[option] to its previous value.
+ */
+static int
+dt_opt_maxframes(dtrace_hdl_t *dtp, const char *arg, uintptr_t option)
+{
+ dtrace_optval_t val = dtp->dt_options[option];
+ ctf_file_t *fp = DT_STACK_CTFP(dtp);
+ ctf_id_t type = ctf_type_resolve(fp, DT_STACK_TYPE(dtp));
+ ctf_arinfo_t r;
+
+ if (dt_opt_runtime(dtp, arg, option) != 0)
+ return -1; /* dt_errno is set for us */
+
+ if (dtp->dt_options[option] > UINT_MAX) {
+ dtp->dt_options[option] = val;
+ return dt_set_errno(dtp, EOVERFLOW);
+ }
+
+ if (ctf_array_info(fp, type, &r) == CTF_ERR) {
+ dtp->dt_options[option] = val;
+ dtp->dt_ctferr = ctf_errno(fp);
+ return dt_set_errno(dtp, EDT_CTF);
+ }
+
+ r.ctr_nelems = (uint_t)dtp->dt_options[option];
+
+ if (ctf_set_array(fp, type, &r) == CTF_ERR ||
+ ctf_update(fp) == CTF_ERR) {
+ dtp->dt_options[option] = val;
+ dtp->dt_ctferr = ctf_errno(fp);
+ return dt_set_errno(dtp, EDT_CTF);
+ }
+
+ return 0;
+}
+
/*
* When setting the strsize option, set the option in the dt_options array
* using dt_opt_size() as usual, and then update the definition of the CTF
@@ -1157,7 +1197,7 @@ static const dt_option_t _dtrace_rtoptions[] = {
{ "jstackframes", dt_opt_runtime, DTRACEOPT_JSTACKFRAMES },
{ "jstackstrsize", dt_opt_size, DTRACEOPT_JSTACKSTRSIZE },
{ "lockmem", dt_opt_lockmem, DTRACEOPT_LOCKMEM },
- { "maxframes", dt_opt_runtime, DTRACEOPT_MAXFRAMES },
+ { "maxframes", dt_opt_maxframes, DTRACEOPT_MAXFRAMES },
{ "nusdtprobes", dt_opt_runtime, DTRACEOPT_NUSDTPROBES },
{ "nspec", dt_opt_runtime, DTRACEOPT_NSPEC },
{ "pcapsize", dt_opt_pcapsize, DTRACEOPT_PCAPSIZE },
diff --git a/libdtrace/dt_printf.c b/libdtrace/dt_printf.c
index 0d7c0bb4..a3e15397 100644
--- a/libdtrace/dt_printf.c
+++ b/libdtrace/dt_printf.c
@@ -24,7 +24,8 @@
static int
pfcheck_addr(dt_pfargv_t *pfv, dt_pfargd_t *pfd, dt_node_t *dnp)
{
- return dt_node_is_pointer(dnp) || dt_node_is_integer(dnp);
+ return (dt_node_is_pointer(dnp) && !dt_node_is_stack(dnp)) ||
+ dt_node_is_integer(dnp);
}
/*ARGSUSED*/
diff --git a/test/unittest/funcs/tst.subr.d b/test/unittest/funcs/tst.subr.d
index 9f7203c0..d97a0780 100644
--- a/test/unittest/funcs/tst.subr.d
+++ b/test/unittest/funcs/tst.subr.d
@@ -1,6 +1,6 @@
/*
* Oracle Linux DTrace.
- * Copyright (c) 2007, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 2025, 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.
*/
@@ -36,6 +36,15 @@
/*DSTYLED*/ \
}
+#define STKFUNC(x) \
+ BEGIN \
+ /*DSTYLED*/ \
+ { \
+ subr++; \
+ @stk[x] = sum(1); \
+ /*DSTYLED*/ \
+ }
+
#define NUM_UNIMPLEMENTED 7
INTFUNC(rand())
@@ -89,6 +98,8 @@ STRFUNC(inet_ntoa6((in6_addr_t *)alloca(sizeof(in6_addr_t))))
/* Not implemented yet.
STRFUNC(d_path(&(curthread->fs->root)))
STRFUNC(link_ntop(ARPHRD_ETHER, (void *)alloca(sizeof(ipaddr_t)))) */
+STKFUNC(stack(5))
+STKFUNC(ustack(5))
BEGIN
/subr == DIF_SUBR_MAX + 1 - NUM_UNIMPLEMENTED/
diff --git a/test/unittest/printa/err.D_PRINTF_ARG_TYPE.stack.r b/test/unittest/printa/err.D_PRINTF_ARG_TYPE.stack.r
index 50e884a0..95ac80da 100644
--- a/test/unittest/printa/err.D_PRINTF_ARG_TYPE.stack.r
+++ b/test/unittest/printa/err.D_PRINTF_ARG_TYPE.stack.r
@@ -2,4 +2,4 @@
dtrace: failed to compile script test/unittest/printa/err.D_PRINTF_ARG_TYPE.stack.d: [D_PRINTF_ARG_TYPE] line 12: printa( ) argument #2 is incompatible with conversion #1 prototype:
conversion: %p
prototype: pointer or integer
- argument: stack
+ argument: dt_stack
diff --git a/test/unittest/printa/err.D_PRINTF_ARG_TYPE.ustack.r b/test/unittest/printa/err.D_PRINTF_ARG_TYPE.ustack.r
index fc9e1512..5df10376 100644
--- a/test/unittest/printa/err.D_PRINTF_ARG_TYPE.ustack.r
+++ b/test/unittest/printa/err.D_PRINTF_ARG_TYPE.ustack.r
@@ -2,4 +2,4 @@
dtrace: failed to compile script test/unittest/printa/err.D_PRINTF_ARG_TYPE.ustack.d: [D_PRINTF_ARG_TYPE] line 12: printa( ) argument #2 is incompatible with conversion #1 prototype:
conversion: %p
prototype: pointer or integer
- argument: stack
+ argument: dt_stack
--
2.43.5
More information about the DTrace-devel
mailing list