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); }