static void
dof_add_translator(dt_dof_t *ddo, const dt_xlator_t *dxp, uint_t type)
{
dtrace_hdl_t *dtp = ddo->ddo_hdl;
dof_xlmember_t dofxm;
dof_xlator_t dofxl;
dof_secidx_t *xst;
char buf[DT_TYPE_NAMELEN];
dt_node_t *dnp;
uint_t i = 0;
assert(type == DOF_SECT_XLIMPORT || type == DOF_SECT_XLEXPORT);
xst = type == DOF_SECT_XLIMPORT ? ddo->ddo_xlimport : ddo->ddo_xlexport;
if (xst[dxp->dx_id] != DOF_SECIDX_NONE)
return; /* translator has already been emitted */
dt_buf_reset(dtp, &ddo->ddo_xlms);
/*
* Generate an array of dof_xlmember_t's into ddo_xlms. If we are
* importing the translator, add only those members referenced by the
* program and set the dofxm_difo reference of each member to NONE. If
* we're exporting the translator, add all members and a DIFO for each.
*/
for (dnp = dxp->dx_members; dnp != NULL; dnp = dnp->dn_list, i++) {
if (type == DOF_SECT_XLIMPORT) {
if (!BT_TEST(ddo->ddo_pgp->dp_xrefs[dxp->dx_id], i))
continue; /* member is not referenced */
dofxm.dofxm_difo = DOF_SECIDX_NONE;
} else {
dofxm.dofxm_difo = dof_add_difo(ddo,
dxp->dx_membdif[dnp->dn_membid]);
}
dofxm.dofxm_name = dof_add_string(ddo, dnp->dn_membname);
dt_node_diftype(dtp, dnp, &dofxm.dofxm_type);
dt_buf_write(dtp, &ddo->ddo_xlms,
&dofxm, sizeof (dofxm), sizeof (uint32_t));
}
dofxl.dofxl_members = dof_add_lsect(ddo, NULL, DOF_SECT_XLMEMBERS,
sizeof (uint32_t), 0, sizeof (dofxm), dt_buf_len(&ddo->ddo_xlms));
dt_buf_concat(dtp, &ddo->ddo_ldata, &ddo->ddo_xlms, sizeof (uint32_t));
dofxl.dofxl_strtab = ddo->ddo_strsec;
dofxl.dofxl_argv = dof_add_string(ddo, ctf_type_name(
dxp->dx_src_ctfp, dxp->dx_src_type, buf, sizeof (buf)));
dofxl.dofxl_argc = 1;
dofxl.dofxl_type = dof_add_string(ddo, ctf_type_name(
dxp->dx_dst_ctfp, dxp->dx_dst_type, buf, sizeof (buf)));
dofxl.dofxl_attr = dof_attr(&dxp->dx_souid.di_attr);
xst[dxp->dx_id] = dof_add_lsect(ddo, &dofxl, type,
sizeof (uint32_t), 0, 0, sizeof (dofxl));
}
/*
* Add a string to the global string table associated with the DOF. The offset
* of the string is returned as an index into the string table.
*/
static dof_stridx_t
dof_add_string(dt_dof_t *ddo, const char *s)
{
dt_buf_t *bp = &ddo->ddo_strs;
dof_stridx_t i = VBDTCAST(dof_stridx_t)dt_buf_len(bp);
if (i != 0 && (s == NULL || *s == '\0'))
return (0); /* string table has \0 at offset 0 */
dt_buf_write(ddo->ddo_hdl, bp, s, strlen(s) + 1, sizeof (char));
return (i);
}
/*
* Add an unloadable DOF section to the file using the specified data buffer
* and DOF section attributes. DOF_SECF_LOAD must *not* be set in flags.
* If 'data' is NULL, the caller is responsible for manipulating the udata buf.
*/
static dof_secidx_t
dof_add_usect(dt_dof_t *ddo, const void *data, uint32_t type,
uint32_t align, uint32_t flags, uint32_t entsize, uint64_t size)
{
dtrace_hdl_t *dtp = ddo->ddo_hdl;
dof_sec_t s;
s.dofs_type = type;
s.dofs_align = align;
s.dofs_flags = flags & ~DOF_SECF_LOAD;
s.dofs_entsize = entsize;
s.dofs_offset = dt_buf_offset(&ddo->ddo_udata, align);
s.dofs_size = size;
dt_buf_write(dtp, &ddo->ddo_secs, &s, sizeof (s), sizeof (uint64_t));
if (data != NULL)
dt_buf_write(dtp, &ddo->ddo_udata, data, size, align);
return (ddo->ddo_nsecs++);
}
void
dt_buf_concat(dtrace_hdl_t *dtp, dt_buf_t *dst,
const dt_buf_t *src, size_t align)
{
if (dst->dbu_err == 0 && src->dbu_err != 0) {
(void) dt_set_errno(dtp, src->dbu_err);
dst->dbu_err = src->dbu_err;
} else {
dt_buf_write(dtp, dst, src->dbu_buf,
(size_t)(src->dbu_ptr - src->dbu_buf), align);
}
}
void *
dtrace_dof_create(dtrace_hdl_t *dtp, dtrace_prog_t *pgp, uint_t flags)
{
dt_dof_t *ddo = &dtp->dt_dof;
const dtrace_ecbdesc_t *edp, *last;
const dtrace_probedesc_t *pdp;
const dtrace_actdesc_t *ap;
const dt_stmt_t *stp;
uint_t maxacts = 0;
uint_t maxfmt = 0;
dt_provider_t *pvp;
dt_xlator_t *dxp;
dof_actdesc_t *dofa;
dof_sec_t *sp;
size_t ssize, lsize;
dof_hdr_t h;
dt_buf_t dof;
char *fmt;
uint_t i;
if (flags & ~DTRACE_D_MASK) {
(void) dt_set_errno(dtp, EINVAL);
return (NULL);
}
flags |= dtp->dt_dflags;
if (dof_hdr(dtp, pgp->dp_dofversion, &h) != 0)
return (NULL);
if (dt_dof_reset(dtp, pgp) != 0)
return (NULL);
/*
* Iterate through the statement list computing the maximum number of
* actions and the maximum format string for allocating local buffers.
*/
for (last = NULL, stp = dt_list_next(&pgp->dp_stmts);
stp != NULL; stp = dt_list_next(stp), last = edp) {
dtrace_stmtdesc_t *sdp = stp->ds_desc;
dtrace_actdesc_t *ap = sdp->dtsd_action;
if (sdp->dtsd_fmtdata != NULL) {
i = VBDTCAST(uint_t)dtrace_printf_format(dtp,
sdp->dtsd_fmtdata, NULL, 0);
maxfmt = MAX(maxfmt, i);
}
if ((edp = sdp->dtsd_ecbdesc) == last)
continue; /* same ecb as previous statement */
for (i = 0, ap = edp->dted_action; ap; ap = ap->dtad_next)
i++;
maxacts = MAX(maxacts, i);
}
dofa = alloca(sizeof (dof_actdesc_t) * maxacts);
fmt = alloca(maxfmt + 1);
ddo->ddo_strsec = dof_add_lsect(ddo, NULL, DOF_SECT_STRTAB, 1, 0, 0, 0);
(void) dof_add_string(ddo, "");
/*
* If there are references to dynamic translators in the program, add
* an imported translator table entry for each referenced translator.
*/
if (pgp->dp_xrefslen != 0) {
for (dxp = dt_list_next(&dtp->dt_xlators);
dxp != NULL; dxp = dt_list_next(dxp)) {
if (dxp->dx_id < pgp->dp_xrefslen &&
pgp->dp_xrefs[dxp->dx_id] != NULL)
dof_add_translator(ddo, dxp, DOF_SECT_XLIMPORT);
}
}
/*
* Now iterate through the statement list, creating the DOF section
* headers and data for each one and adding them to our buffers.
*/
for (last = NULL, stp = dt_list_next(&pgp->dp_stmts);
stp != NULL; stp = dt_list_next(stp), last = edp) {
dof_secidx_t probesec = DOF_SECIDX_NONE;
dof_secidx_t prdsec = DOF_SECIDX_NONE;
dof_secidx_t actsec = DOF_SECIDX_NONE;
const dt_stmt_t *next = stp;
dtrace_stmtdesc_t *sdp = stp->ds_desc;
dof_stridx_t strndx = 0;
dof_probedesc_t dofp;
dof_ecbdesc_t dofe;
uint_t i;
if ((edp = stp->ds_desc->dtsd_ecbdesc) == last)
continue; /* same ecb as previous statement */
pdp = &edp->dted_probe;
/*
* Add a DOF_SECT_PROBEDESC for the ECB's probe description,
* and copy the probe description strings into the string table.
*/
dofp.dofp_strtab = ddo->ddo_strsec;
dofp.dofp_provider = dof_add_string(ddo, pdp->dtpd_provider);
dofp.dofp_mod = dof_add_string(ddo, pdp->dtpd_mod);
dofp.dofp_func = dof_add_string(ddo, pdp->dtpd_func);
dofp.dofp_name = dof_add_string(ddo, pdp->dtpd_name);
dofp.dofp_id = pdp->dtpd_id;
probesec = dof_add_lsect(ddo, &dofp, DOF_SECT_PROBEDESC,
sizeof (dof_secidx_t), 0,
sizeof (dof_probedesc_t), sizeof (dof_probedesc_t));
/*
* If there is a predicate DIFO associated with the ecbdesc,
* write out the DIFO sections and save the DIFO section index.
*/
if (edp->dted_pred.dtpdd_difo != NULL)
prdsec = dof_add_difo(ddo, edp->dted_pred.dtpdd_difo);
/*
* Now iterate through the action list generating DIFOs as
* referenced therein and adding action descriptions to 'dofa'.
*/
for (i = 0, ap = edp->dted_action;
ap != NULL; ap = ap->dtad_next, i++) {
if (ap->dtad_difo != NULL) {
dofa[i].dofa_difo =
dof_add_difo(ddo, ap->dtad_difo);
} else
dofa[i].dofa_difo = DOF_SECIDX_NONE;
/*
* If the first action in a statement has format data,
* add the format string to the global string table.
*/
if (sdp != NULL && ap == sdp->dtsd_action) {
if (sdp->dtsd_fmtdata != NULL) {
(void) dtrace_printf_format(dtp,
sdp->dtsd_fmtdata, fmt, maxfmt + 1);
strndx = dof_add_string(ddo, fmt);
} else
strndx = 0; /* use dtad_arg instead */
if ((next = dt_list_next(next)) != NULL)
sdp = next->ds_desc;
else
sdp = NULL;
}
if (strndx != 0) {
dofa[i].dofa_arg = strndx;
dofa[i].dofa_strtab = ddo->ddo_strsec;
} else {
dofa[i].dofa_arg = ap->dtad_arg;
dofa[i].dofa_strtab = DOF_SECIDX_NONE;
}
dofa[i].dofa_kind = ap->dtad_kind;
dofa[i].dofa_ntuple = ap->dtad_ntuple;
dofa[i].dofa_uarg = ap->dtad_uarg;
}
if (i > 0) {
actsec = dof_add_lsect(ddo, dofa, DOF_SECT_ACTDESC,
sizeof (uint64_t), 0, sizeof (dof_actdesc_t),
sizeof (dof_actdesc_t) * i);
}
/*
* Now finally, add the DOF_SECT_ECBDESC referencing all the
* previously created sub-sections.
*/
dofe.dofe_probes = probesec;
dofe.dofe_pred = prdsec;
dofe.dofe_actions = actsec;
dofe.dofe_pad = 0;
dofe.dofe_uarg = edp->dted_uarg;
(void) dof_add_lsect(ddo, &dofe, DOF_SECT_ECBDESC,
sizeof (uint64_t), 0, 0, sizeof (dof_ecbdesc_t));
}
/*
* If any providers are user-defined, output DOF sections corresponding
* to the providers and the probes and arguments that they define.
*/
if (flags & DTRACE_D_PROBES) {
for (pvp = dt_list_next(&dtp->dt_provlist);
pvp != NULL; pvp = dt_list_next(pvp))
dof_add_provider(ddo, pvp);
}
/*
* If we're not stripping unloadable sections, generate compiler
* comments and any other unloadable miscellany.
*/
if (!(flags & DTRACE_D_STRIP)) {
(void) dof_add_usect(ddo, _dtrace_version, DOF_SECT_COMMENTS,
sizeof (char), 0, 0, strlen(_dtrace_version) + 1);
#ifndef VBOX
(void) dof_add_usect(ddo, &dtp->dt_uts, DOF_SECT_UTSNAME,
sizeof (char), 0, 0, sizeof (struct utsname));
#endif
}
/*
* Compute and fill in the appropriate values for the dof_hdr_t's
* dofh_secnum, dofh_loadsz, and dofh_filez values.
*/
h.dofh_secnum = ddo->ddo_nsecs;
ssize = sizeof (h) + dt_buf_len(&ddo->ddo_secs);
h.dofh_loadsz = ssize +
dt_buf_len(&ddo->ddo_ldata) +
dt_buf_len(&ddo->ddo_strs);
if (dt_buf_len(&ddo->ddo_udata) != 0) {
lsize = roundup(h.dofh_loadsz, sizeof (uint64_t));
h.dofh_filesz = lsize + dt_buf_len(&ddo->ddo_udata);
} else {
lsize = h.dofh_loadsz;
h.dofh_filesz = lsize;
}
/*
* Set the global DOF_SECT_STRTAB's offset to be after the header,
* section headers, and other loadable data. Since we're going to
* iterate over the buffer data directly, we must check for errors.
*/
if ((i = dt_buf_error(&ddo->ddo_secs)) != 0) {
(void) dt_set_errno(dtp, i);
return (NULL);
}
sp = dt_buf_ptr(&ddo->ddo_secs);
assert(sp[ddo->ddo_strsec].dofs_type == DOF_SECT_STRTAB);
assert(ssize == sizeof (h) + sizeof (dof_sec_t) * ddo->ddo_nsecs);
sp[ddo->ddo_strsec].dofs_offset = ssize + dt_buf_len(&ddo->ddo_ldata);
sp[ddo->ddo_strsec].dofs_size = dt_buf_len(&ddo->ddo_strs);
/*
* Now relocate all the other section headers by adding the appropriate
* delta to their respective dofs_offset values.
*/
for (i = 0; i < ddo->ddo_nsecs; i++, sp++) {
if (i == ddo->ddo_strsec)
continue; /* already relocated above */
if (sp->dofs_flags & DOF_SECF_LOAD)
sp->dofs_offset += ssize;
else
sp->dofs_offset += lsize;
}
/*
* Finally, assemble the complete in-memory DOF buffer by writing the
* header and then concatenating all our buffers. dt_buf_concat() will
* propagate any errors and cause dt_buf_claim() to return NULL.
*/
dt_buf_create(dtp, &dof, "dof", h.dofh_filesz);
dt_buf_write(dtp, &dof, &h, sizeof (h), sizeof (uint64_t));
dt_buf_concat(dtp, &dof, &ddo->ddo_secs, sizeof (uint64_t));
dt_buf_concat(dtp, &dof, &ddo->ddo_ldata, sizeof (uint64_t));
dt_buf_concat(dtp, &dof, &ddo->ddo_strs, sizeof (char));
dt_buf_concat(dtp, &dof, &ddo->ddo_udata, sizeof (uint64_t));
return (dt_buf_claim(dtp, &dof));
}
/*ARGSUSED*/
static int
dof_add_probe(dt_idhash_t *dhp, dt_ident_t *idp, void *data)
{
dt_dof_t *ddo = data;
dtrace_hdl_t *dtp = ddo->ddo_hdl;
dt_probe_t *prp = idp->di_data;
dof_probe_t dofpr;
dof_relodesc_t dofr;
dt_probe_instance_t *pip;
dt_node_t *dnp;
char buf[DT_TYPE_NAMELEN];
uint_t i;
dofpr.dofpr_addr = 0;
dofpr.dofpr_name = dof_add_string(ddo, prp->pr_name);
dofpr.dofpr_nargv = VBDTCAST(dof_stridx_t)dt_buf_len(&ddo->ddo_strs);
for (dnp = prp->pr_nargs; dnp != NULL; dnp = dnp->dn_list) {
(void) dof_add_string(ddo, ctf_type_name(dnp->dn_ctfp,
dnp->dn_type, buf, sizeof (buf)));
}
dofpr.dofpr_xargv = VBDTCAST(dof_stridx_t)dt_buf_len(&ddo->ddo_strs);
for (dnp = prp->pr_xargs; dnp != NULL; dnp = dnp->dn_list) {
(void) dof_add_string(ddo, ctf_type_name(dnp->dn_ctfp,
dnp->dn_type, buf, sizeof (buf)));
}
dofpr.dofpr_argidx = VBDTCAST(uint32_t)dt_buf_len(&ddo->ddo_args) / sizeof (uint8_t);
for (i = 0; i < prp->pr_xargc; i++) {
dt_buf_write(dtp, &ddo->ddo_args, &prp->pr_mapping[i],
sizeof (uint8_t), sizeof (uint8_t));
}
dofpr.dofpr_nargc = prp->pr_nargc;
dofpr.dofpr_xargc = prp->pr_xargc;
dofpr.dofpr_pad1 = 0;
dofpr.dofpr_pad2 = 0;
for (pip = prp->pr_inst; pip != NULL; pip = pip->pi_next) {
dt_dprintf("adding probe for %s:%s\n", pip->pi_fname,
prp->pr_name);
dofpr.dofpr_func = dof_add_string(ddo, pip->pi_fname);
/*
* There should be one probe offset or is-enabled probe offset
* or else this probe instance won't have been created. The
* kernel will reject DOF which has a probe with no offsets.
*/
assert(pip->pi_noffs + pip->pi_nenoffs > 0);
dofpr.dofpr_offidx =
VBDTCAST(uint32_t)(dt_buf_len(&ddo->ddo_offs) / sizeof (uint32_t));
dofpr.dofpr_noffs = pip->pi_noffs;
dt_buf_write(dtp, &ddo->ddo_offs, pip->pi_offs,
pip->pi_noffs * sizeof (uint32_t), sizeof (uint32_t));
dofpr.dofpr_enoffidx =
VBDTCAST(uint32_t)(dt_buf_len(&ddo->ddo_enoffs) / sizeof (uint32_t));
dofpr.dofpr_nenoffs = pip->pi_nenoffs;
dt_buf_write(dtp, &ddo->ddo_enoffs, pip->pi_enoffs,
pip->pi_nenoffs * sizeof (uint32_t), sizeof (uint32_t));
/*
* If pi_rname isn't set, the relocation will be against the
* function name. If it is, the relocation will be against
* pi_rname. This will be used if the function is scoped
* locally so an alternate symbol is added for the purpose
* of this relocation.
*/
if (pip->pi_rname[0] == '\0')
dofr.dofr_name = dofpr.dofpr_func;
else
dofr.dofr_name = dof_add_string(ddo, pip->pi_rname);
dofr.dofr_type = DOF_RELO_SETX;
dofr.dofr_offset = dt_buf_len(&ddo->ddo_probes);
dofr.dofr_data = 0;
dt_buf_write(dtp, &ddo->ddo_rels, &dofr,
sizeof (dofr), sizeof (uint64_t));
dt_buf_write(dtp, &ddo->ddo_probes, &dofpr,
sizeof (dofpr), sizeof (uint64_t));
}
return (0);
}
