[DTrace-devel] [PATCH 1/2] Add support for copyout() subroutine

[Kris Van Hees]

We also perform a bit of dead-code elimination.

Signed-off-by: Kris Van Hees <kris.van.hees at oracle.com>
---
 libdtrace/dt_cg.c                             | 70 ++++++++++++++-----
 .../err.D_ACT_SPEC.SpeculateWithCopyOut.d     |  2 +-
 2 files changed, 52 insertions(+), 20 deletions(-)

diff --git a/libdtrace/dt_cg.c b/libdtrace/dt_cg.c
index 4dffb7b1..490584f7 100644
--- a/libdtrace/dt_cg.c
+++ b/libdtrace/dt_cg.c
@@ -1215,20 +1215,6 @@ dt_cg_store_val(dt_pcb_t *pcb, dt_node_t *dnp, dtrace_actkind_t kind,
 	return -1;
 }
 
-#ifdef FIXME
-/*
- * Utility function to determine if a given action description is destructive.
- * The DIFOFLG_DESTRUCTIVE bit is set for us by the DIF assembler (see dt_as.c).
- */
-static int
-dt_action_destructive(const dtrace_actdesc_t *ap)
-{
-	return (DTRACEACT_ISDESTRUCTIVE(ap->dtad_kind) ||
-		(ap->dtad_kind == DTRACEACT_DIFEXPR &&
-		 (ap->dtad_difo->dtdo_flags & DIFOFLG_DESTRUCTIVE)));
-}
-#endif
-
 static void
 dt_cg_clsflags(dt_pcb_t *pcb, dtrace_actkind_t kind, const dt_node_t *dnp)
 {
@@ -1281,11 +1267,7 @@ dt_cg_clsflags(dt_pcb_t *pcb, dtrace_actkind_t kind, const dt_node_t *dnp)
 	}
 
 	if (*cfp & DT_CLSFLAG_SPECULATE) {
-#ifdef FIXME
-		if (dt_action_destructive(ap))
-#else
 		if (DTRACEACT_ISDESTRUCTIVE(kind))
-#endif
 			dnerror(dnp, D_ACT_SPEC, "destructive actions "
 			    "may not follow speculate( )\n");
 		if (kind == DTRACEACT_EXIT)
@@ -4583,6 +4565,56 @@ dt_cg_subr_copyinto(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
 	TRACE_REGSET("    subr-copyinto:End  ");
 }
 
+static void
+dt_cg_subr_copyout(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
+{
+	dt_node_t	*src = dnp->dn_args;
+	dt_node_t	*dst = src->dn_list;
+	dt_node_t	*size = dst->dn_list;
+	uint_t		lbl_ok = dt_irlist_label(dlp);
+
+	dt_cg_clsflags(yypcb, DTRACEACT_PROC_DESTRUCTIVE, dnp);
+
+	TRACE_REGSET("    subr-copyout:Begin");
+
+	/* Validate the source pointer. */
+	dt_cg_node(src, dlp, drp);
+	dt_cg_check_ptr_arg(dlp, drp, src);
+
+	/* Validate the destination pointer. */
+	dt_cg_node(dst, dlp, drp);
+	dt_cg_check_notnull(dlp, drp, dst->dn_reg);
+
+	/* Size for the copy operation. */
+	dt_cg_node(size, dlp, drp);
+
+	if (dt_regset_xalloc_args(drp) == -1)
+		longjmp(yypcb->pcb_jmpbuf, EDT_NOREG);
+
+	emit(dlp,  BPF_MOV_REG(BPF_REG_1, dst->dn_reg));
+	emit(dlp,  BPF_MOV_REG(BPF_REG_2, src->dn_reg));
+	emit(dlp,  BPF_MOV_REG(BPF_REG_3, size->dn_reg));
+	dt_regset_xalloc(drp, BPF_REG_0);
+	emit(dlp,  BPF_CALL_HELPER(BPF_FUNC_probe_write_user));
+
+	/*
+	 * At this point the src is validated, so any problem must be with
+	 * the dst address.
+	 */
+	emit(dlp,  BPF_BRANCH_IMM(BPF_JEQ, BPF_REG_0, 0, lbl_ok));
+	dt_regset_free(drp, BPF_REG_0);
+	dt_regset_free_args(drp);
+	dt_cg_probe_error(yypcb, DTRACEFLT_BADADDR, DT_ISREG, dst->dn_reg);
+	emitl(dlp, lbl_ok,
+		   BPF_NOP());
+
+	dt_regset_free(drp, src->dn_reg);
+	dt_regset_free(drp, dst->dn_reg);
+	dt_regset_free(drp, size->dn_reg);
+
+	TRACE_REGSET("    subr-copyout:End  ");
+}
+
 static void
 dt_cg_subr_strchr(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
 {
@@ -5059,7 +5091,7 @@ static dt_cg_subr_f *_dt_cg_subr[DIF_SUBR_MAX + 1] = {
 	[DIF_SUBR_SPECULATION]		= &dt_cg_subr_speculation,
 	[DIF_SUBR_PROGENYOF]		= &dt_cg_subr_progenyof,
 	[DIF_SUBR_STRLEN]		= &dt_cg_subr_strlen,
-	[DIF_SUBR_COPYOUT]		= NULL,
+	[DIF_SUBR_COPYOUT]		= &dt_cg_subr_copyout,
 	[DIF_SUBR_COPYOUTSTR]		= NULL,
 	[DIF_SUBR_ALLOCA]		= &dt_cg_subr_alloca,
 	[DIF_SUBR_BCOPY]		= &dt_cg_subr_bcopy,
diff --git a/test/unittest/speculation/err.D_ACT_SPEC.SpeculateWithCopyOut.d b/test/unittest/speculation/err.D_ACT_SPEC.SpeculateWithCopyOut.d
index 908e9b9c..14cc1d5c 100644
--- a/test/unittest/speculation/err.D_ACT_SPEC.SpeculateWithCopyOut.d
+++ b/test/unittest/speculation/err.D_ACT_SPEC.SpeculateWithCopyOut.d
@@ -5,7 +5,7 @@
  * Licensed under the Universal Permissive License v 1.0 as shown at
  * http://oss.oracle.com/licenses/upl.
  */
-/* @@skip: dtv2, no copyout yet */
+
 /*
  * ASSERTION: Destructive actions may never be speculative.
  *
-- 
2.31.1