static char *
nm_func_signature(ctf_file_t *fp, uint_t index, char *buf, size_t len)
{
int n;
ctf_funcinfo_t f;
ctf_id_t argv[32];
char arg[32];
char *start = buf;
char *sep = "";
int i;
if (ctf_func_info(fp, index, &f) == CTF_ERR)
return (NULL);
if (ctf_type_name(fp, f.ctc_return, arg, sizeof (arg)) != NULL)
n = mdb_snprintf(buf, len, "%s (*)(", arg);
else
n = mdb_snprintf(buf, len, "<%ld> (*)(", f.ctc_return);
if (len <= n)
return (start);
buf += n;
len -= n;
(void) ctf_func_args(fp, index, sizeof (argv) / sizeof (argv[0]), argv);
for (i = 0; i < f.ctc_argc; i++) {
if (ctf_type_name(fp, argv[i], arg, sizeof (arg)) != NULL)
n = mdb_snprintf(buf, len, "%s%s", sep, arg);
else
n = mdb_snprintf(buf, len, "%s<%ld>", sep, argv[i]);
if (len <= n)
return (start);
buf += n;
len -= n;
sep = ", ";
}
if (f.ctc_flags & CTF_FUNC_VARARG) {
n = mdb_snprintf(buf, len, "%s...", sep);
if (len <= n)
return (start);
buf += n;
len -= n;
} else if (f.ctc_argc == 0) {
n = mdb_snprintf(buf, len, "void");
if (len <= n)
return (start);
buf += n;
len -= n;
}
(void) mdb_snprintf(buf, len, ")");
return (start);
}
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));
}
int
mdb_ctf_type_resolve(mdb_ctf_id_t mid, mdb_ctf_id_t *outp)
{
ctf_id_t id;
mdb_ctf_impl_t *idp = (mdb_ctf_impl_t *)∣
if ((id = ctf_type_resolve(idp->mci_fp, idp->mci_id)) == CTF_ERR) {
if (outp)
mdb_ctf_type_invalidate(outp);
return (set_errno(ctf_to_errno(ctf_errno(idp->mci_fp))));
}
if (ctf_type_kind(idp->mci_fp, id) == CTF_K_FORWARD) {
char name[MDB_SYM_NAMLEN];
mdb_ctf_id_t lookup_id;
if (ctf_type_name(idp->mci_fp, id, name, sizeof (name)) !=
NULL &&
mdb_ctf_lookup_by_name(name, &lookup_id) == 0 &&
outp != NULL) {
*outp = lookup_id;
return (0);
}
}
if (outp != NULL)
set_ctf_id(outp, idp->mci_fp, id);
return (0);
}
static int
ctfsrc_collect_types_cb(ctf_id_t id, boolean_t root, void *arg)
{
_NOTE(ARGUNUSED(root, arg));
(void) ctf_type_name(g_fp, id, idnames[id].ci_name,
sizeof (idnames[id].ci_name));
idnames[id].ci_id = id;
return (0);
}
static void
ctfsrc_refname(ctf_id_t id, char *buf, size_t bufsize)
{
ctf_id_t ref;
if ((ref = ctf_type_reference(g_fp, id)) == CTF_ERR) {
ctfdump_fatal("failed to get reference type for %ld: "
"%s\n", id, ctf_errmsg(ctf_errno(g_fp)));
}
(void) ctf_type_name(g_fp, ref, buf, bufsize);
}
static void
ctfsrc_function(ctf_idname_t *idn)
{
ctf_funcinfo_t *cfi = &idn->ci_funcinfo;
char name[MAX_NAMELEN] = "unknown_t";
(void) ctf_type_name(g_fp, cfi->ctc_return, name, sizeof (name));
(void) printf("extern %s %s(", name, idn->ci_name);
if (cfi->ctc_argc != 0) {
ctfdump_fargs_grow(cfi->ctc_argc);
if (ctf_func_args(g_fp, idn->ci_symidx,
g_nfargc, g_fargc) == CTF_ERR) {
ctfdump_fatal("failed to get arguments for function "
"%s: %s\n", idn->ci_name,
ctf_errmsg(ctf_errno(g_fp)));
}
for (size_t i = 0; i < cfi->ctc_argc; i++) {
ctf_id_t aid = g_fargc[i];
name[0] = '\0';
(void) ctf_type_name(g_fp, aid, name, sizeof (name));
(void) printf("%s%s", name,
i + 1 == cfi->ctc_argc ? "" : ", ");
}
} else {
if (!(cfi->ctc_flags & CTF_FUNC_VARARG))
(void) printf("void");
}
if (cfi->ctc_flags & CTF_FUNC_VARARG)
(void) printf("%s...", cfi->ctc_argc == 0 ? "" : ", ");
(void) printf(");\n");
}
static int
probe(dtrace_hdl_t *dtp, const dtrace_probedesc_t *pdp, void *data)
{
dtrace_probeinfo_t p;
dtrace_argdesc_t arg;
char buf[BUFSIZ];
int i;
(void) printf("\r%6d", ++g_count);
(void) fflush(stdout);
if (dtrace_probe_info(dtp, pdp, &p) != 0) {
(void) printf(" failed to get probe info for "
"%s:%s:%s:%s [%d]\n", pdp->dtpd_provider, pdp->dtpd_mod,
pdp->dtpd_func, pdp->dtpd_name, pdp->dtpd_id);
g_errs++;
return (0);
}
for (i = 0; i < p.dtp_argc; i++) {
if (p.dtp_argv[i].dtt_type == CTF_ERR) {
bzero(&arg, sizeof (dtrace_argdesc_t));
arg.dtargd_id = pdp->dtpd_id;
arg.dtargd_ndx = i;
(void) ioctl(g_fd, DTRACEIOC_PROBEARG, &arg);
(void) printf(" failed to get types for args[%d] "
"of %s:%s:%s:%s [%d]: <%s> -> <%s>\n", i,
pdp->dtpd_provider, pdp->dtpd_mod, pdp->dtpd_func,
pdp->dtpd_name, pdp->dtpd_id,
arg.dtargd_native, arg.dtargd_xlate);
g_errs++;
if (g_errexit)
return (-1);
} else if (g_verbose) {
(void) printf("%d args[%d] : %s\n", pdp->dtpd_id, i,
ctf_type_name(p.dtp_argv[i].dtt_ctfp,
p.dtp_argv[i].dtt_type, buf, sizeof (buf)));
}
}
return (0);
}
char *
mdb_ctf_type_name(mdb_ctf_id_t id, char *buf, size_t len)
{
mdb_ctf_impl_t *idp = (mdb_ctf_impl_t *)&id;
char *ret;
if (!mdb_ctf_type_valid(id)) {
(void) set_errno(EINVAL);
return (NULL);
}
ret = ctf_type_name(idp->mci_fp, idp->mci_id, buf, len);
if (ret == NULL)
(void) set_errno(ctf_to_errno(ctf_errno(idp->mci_fp)));
return (ret);
}
static void
print_probe_info(const dtrace_probeinfo_t *p)
{
char buf[BUFSIZ];
char *user;
int i;
oprintf("\n\tProbe Description Attributes\n");
oprintf("\t\tIdentifier Names: %s\n",
dtrace_stability_name(p->dtp_attr.dtat_name));
oprintf("\t\tData Semantics: %s\n",
dtrace_stability_name(p->dtp_attr.dtat_data));
oprintf("\t\tDependency Class: %s\n",
dtrace_class_name(p->dtp_attr.dtat_class));
oprintf("\n\tArgument Attributes\n");
oprintf("\t\tIdentifier Names: %s\n",
dtrace_stability_name(p->dtp_arga.dtat_name));
oprintf("\t\tData Semantics: %s\n",
dtrace_stability_name(p->dtp_arga.dtat_data));
oprintf("\t\tDependency Class: %s\n",
dtrace_class_name(p->dtp_arga.dtat_class));
oprintf("\n\tArgument Types\n");
for (i = 0; i < p->dtp_argc; i++) {
if (p->dtp_argv[i].dtt_flags & DTT_FL_USER)
user = "******";
else
user = "";
if (ctf_type_name(p->dtp_argv[i].dtt_ctfp,
p->dtp_argv[i].dtt_type, buf, sizeof (buf)) == NULL)
(void) strlcpy(buf, "(unknown)", sizeof (buf));
oprintf("\t\targs[%d]: %s%s\n", i, user, buf);
}
if (p->dtp_argc == 0)
oprintf("\t\tNone\n");
oprintf("\n");
}
static void
nm_print_ctype(void *data)
{
nm_iter_info_t *niip = data;
char buf[256];
ctf_id_t id;
char *str = NULL;
uint_t index = niip->nii_id;
ctf_file_t *fp = niip->nii_fp;
if (fp != NULL) {
if (GELF_ST_TYPE(niip->nii_symp->st_info) == STT_FUNC)
str = nm_func_signature(fp, index, buf, sizeof (buf));
else if ((id = ctf_lookup_by_symbol(fp, index)) != CTF_ERR)
str = ctf_type_name(fp, id, buf, sizeof (buf));
}
if (str == NULL)
str = "<unknown type>";
mdb_printf("%-50s", str);
}
static int
ctfdump_types_cb(ctf_id_t id, boolean_t root, void *arg)
{
int kind, i, count;
ctf_id_t ref;
char name[512], ienc[128];
const char *encn;
ctf_funcinfo_t ctc;
ctf_arinfo_t ar;
ctf_encoding_t cte;
ssize_t size;
if ((kind = ctf_type_kind(g_fp, id)) == CTF_ERR)
ctfdump_fatal("encountered malformed ctf, type %s does not "
"have a kind: %s\n", name, ctf_errmsg(ctf_errno(g_fp)));
if (ctf_type_name(g_fp, id, name, sizeof (name)) == NULL) {
if (ctf_errno(g_fp) != ECTF_NOPARENT)
ctfdump_fatal("type %lu missing name: %s\n", id,
ctf_errmsg(ctf_errno(g_fp)));
(void) snprintf(name, sizeof (name), "(unknown %s)",
ctf_kind_name(g_fp, kind));
}
g_stats.cs_ntypes[kind]++;
if (root == B_TRUE)
ctfdump_printf(CTFDUMP_TYPES, " <%lu> ", id);
else
ctfdump_printf(CTFDUMP_TYPES, " [%lu] ", id);
switch (kind) {
case CTF_K_UNKNOWN:
break;
case CTF_K_INTEGER:
if (ctf_type_encoding(g_fp, id, &cte) == CTF_ERR)
ctfdump_fatal("failed to get encoding information "
"for %s: %s\n", name, ctf_errmsg(ctf_errno(g_fp)));
ctfdump_intenc_name(&cte, ienc, sizeof (ienc));
ctfdump_printf(CTFDUMP_TYPES,
"%s encoding=%s offset=%u bits=%u",
name, ienc, cte.cte_offset, cte.cte_bits);
break;
case CTF_K_FLOAT:
if (ctf_type_encoding(g_fp, id, &cte) == CTF_ERR)
ctfdump_fatal("failed to get encoding information "
"for %s: %s\n", name, ctf_errmsg(ctf_errno(g_fp)));
if (cte.cte_format < 1 || cte.cte_format > 12)
encn = "unknown";
else
encn = ctfdump_fpenc[cte.cte_format];
ctfdump_printf(CTFDUMP_TYPES, "%s encoding=%s offset=%u "
"bits=%u", name, encn, cte.cte_offset, cte.cte_bits);
break;
case CTF_K_POINTER:
if ((ref = ctf_type_reference(g_fp, id)) == CTF_ERR)
ctfdump_fatal("failed to get reference type for %s: "
"%s\n", name, ctf_errmsg(ctf_errno(g_fp)));
ctfdump_printf(CTFDUMP_TYPES, "%s refers to %lu", name,
ref);
break;
case CTF_K_ARRAY:
if (ctf_array_info(g_fp, id, &ar) == CTF_ERR)
ctfdump_fatal("failed to get array information for "
"%s: %s\n", name, ctf_errmsg(ctf_errno(g_fp)));
ctfdump_printf(CTFDUMP_TYPES, "%s contents: %lu, index: %lu",
name, ar.ctr_contents, ar.ctr_index);
break;
case CTF_K_FUNCTION:
if (ctf_func_info_by_id(g_fp, id, &ctc) == CTF_ERR)
ctfdump_fatal("failed to get function info for %s: "
"%s\n", name, ctf_errmsg(ctf_errno(g_fp)));
if (ctc.ctc_argc > 0) {
ctfdump_fargs_grow(ctc.ctc_argc);
if (ctf_func_args_by_id(g_fp, id, g_nfargc, g_fargc) ==
CTF_ERR)
ctfdump_fatal("failed to get function "
"arguments for %s: %s\n", name,
ctf_errmsg(ctf_errno(g_fp)));
}
ctfdump_printf(CTFDUMP_TYPES,
"%s returns: %lu args: (", name, ctc.ctc_return);
for (i = 0; i < ctc.ctc_argc; i++) {
ctfdump_printf(CTFDUMP_TYPES, "%lu%s", g_fargc[i],
i + 1 == ctc.ctc_argc ? "" : ", ");
}
if (ctc.ctc_flags & CTF_FUNC_VARARG)
ctfdump_printf(CTFDUMP_TYPES, "%s...",
ctc.ctc_argc == 0 ? "" : ", ");
ctfdump_printf(CTFDUMP_TYPES, ")");
break;
case CTF_K_STRUCT:
case CTF_K_UNION:
size = ctf_type_size(g_fp, id);
if (size == CTF_ERR)
ctfdump_fatal("failed to get size of %s: %s\n", name,
ctf_errmsg(ctf_errno(g_fp)));
ctfdump_printf(CTFDUMP_TYPES, "%s (%d bytes)\n", name, size);
count = 0;
if (ctf_member_iter(g_fp, id, ctfdump_member_cb, &count) != 0)
ctfdump_fatal("failed to iterate members of %s: %s\n",
name, ctf_errmsg(ctf_errno(g_fp)));
if (kind == CTF_K_STRUCT) {
g_stats.cs_nsmembs += count;
g_stats.cs_nsmax = MAX(count, g_stats.cs_nsmax);
g_stats.cs_structsz += size;
g_stats.cs_sszmax = MAX(size, g_stats.cs_sszmax);
} else {
g_stats.cs_numembs += count;
g_stats.cs_numax = MAX(count, g_stats.cs_numax);
g_stats.cs_unionsz += size;
g_stats.cs_uszmax = MAX(count, g_stats.cs_uszmax);
}
break;
case CTF_K_ENUM:
ctfdump_printf(CTFDUMP_TYPES, "%s\n", name);
count = 0;
if (ctf_enum_iter(g_fp, id, ctfdump_enum_cb, &count) != 0)
ctfdump_fatal("failed to iterate enumerators of %s: "
"%s\n", name, ctf_errmsg(ctf_errno(g_fp)));
g_stats.cs_nemembs += count;
g_stats.cs_nemax = MAX(g_stats.cs_nemax, count);
break;
case CTF_K_FORWARD:
ctfdump_printf(CTFDUMP_TYPES, "forward %s\n", name);
break;
case CTF_K_TYPEDEF:
if ((ref = ctf_type_reference(g_fp, id)) == CTF_ERR)
ctfdump_fatal("failed to get reference type for %s: "
"%s\n", name, ctf_errmsg(ctf_errno(g_fp)));
ctfdump_printf(CTFDUMP_TYPES, "typedef %s refers to %lu", name,
ref);
break;
case CTF_K_VOLATILE:
if ((ref = ctf_type_reference(g_fp, id)) == CTF_ERR)
ctfdump_fatal("failed to get reference type for %s: "
"%s\n", name, ctf_errmsg(ctf_errno(g_fp)));
ctfdump_printf(CTFDUMP_TYPES, "%s refers to %lu", name,
ref);
break;
case CTF_K_CONST:
if ((ref = ctf_type_reference(g_fp, id)) == CTF_ERR)
ctfdump_fatal("failed to get reference type for %s: "
"%s\n", name, ctf_errmsg(ctf_errno(g_fp)));
ctfdump_printf(CTFDUMP_TYPES, "%s refers to %lu", name,
ref);
break;
case CTF_K_RESTRICT:
if ((ref = ctf_type_reference(g_fp, id)) == CTF_ERR)
ctfdump_fatal("failed to get reference type for %s: "
"%s\n", name, ctf_errmsg(ctf_errno(g_fp)));
ctfdump_printf(CTFDUMP_TYPES, "%s refers to %lu", name,
ref);
break;
default:
ctfdump_fatal("encountered unknown kind for type %s: %d\n",
name, kind);
}
ctfdump_printf(CTFDUMP_TYPES, "\n");
return (0);
}
/*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);
}
/*ARGSUSED*/
static void
fbt_getargdesc(void *arg, dtrace_id_t id, void *parg, dtrace_argdesc_t *desc)
{
fbt_probe_t *fbt = parg;
struct modctl *ctl = fbt->fbtp_ctl;
struct module *mp = ctl->mod_mp;
ctf_file_t *fp = NULL, *pfp;
ctf_funcinfo_t f;
int error;
ctf_id_t argv[32], type;
int argc = sizeof (argv) / sizeof (ctf_id_t);
const char *parent;
if (!ctl->mod_loaded || (ctl->mod_loadcnt != fbt->fbtp_loadcnt))
goto err;
if (fbt->fbtp_roffset != 0 && desc->dtargd_ndx == 0) {
(void) strlcpy(desc->dtargd_native, "int",
sizeof(desc->dtargd_native));
return;
}
if ((fp = ctf_modopen(mp, &error)) == NULL) {
/*
* We have no CTF information for this module -- and therefore
* no args[] information.
*/
goto err;
}
/*
* If we have a parent container, we must manually import it.
*/
if ((parent = ctf_parent_name(fp)) != NULL) {
struct modctl *mp = &modules;
struct modctl *mod = NULL;
/*
* We must iterate over all modules to find the module that
* is our parent.
*/
do {
if (strcmp(mp->mod_modname, parent) == 0) {
mod = mp;
break;
}
} while ((mp = mp->mod_next) != &modules);
if (mod == NULL)
goto err;
if ((pfp = ctf_modopen(mod->mod_mp, &error)) == NULL) {
goto err;
}
if (ctf_import(fp, pfp) != 0) {
ctf_close(pfp);
goto err;
}
ctf_close(pfp);
}
if (ctf_func_info(fp, fbt->fbtp_symndx, &f) == CTF_ERR)
goto err;
if (fbt->fbtp_roffset != 0) {
if (desc->dtargd_ndx > 1)
goto err;
ASSERT(desc->dtargd_ndx == 1);
type = f.ctc_return;
} else {
if (desc->dtargd_ndx + 1 > f.ctc_argc)
goto err;
if (ctf_func_args(fp, fbt->fbtp_symndx, argc, argv) == CTF_ERR)
goto err;
type = argv[desc->dtargd_ndx];
}
if (ctf_type_name(fp, type, desc->dtargd_native,
DTRACE_ARGTYPELEN) != NULL) {
ctf_close(fp);
return;
}
err:
if (fp != NULL)
ctf_close(fp);
desc->dtargd_ndx = DTRACE_ARGNONE;
}
/*ARGSUSED*/
static void
instr_getargdesc(void *arg, dtrace_id_t id, void *parg, dtrace_argdesc_t *desc)
{
instr_probe_t *fbt = parg;
struct modctl *ctl = fbt->insp_ctl;
struct module *mp = (struct module *) ctl;
ctf_file_t *fp = NULL;
ctf_funcinfo_t f;
// int error;
ctf_id_t argv[32], type;
int argc = sizeof (argv) / sizeof (ctf_id_t);
// const char *parent;
if (mp->state != MODULE_STATE_LIVE ||
get_refcount(mp) != fbt->insp_loadcnt)
return;
if (fbt->insp_roffset != 0 && desc->dtargd_ndx == 0) {
(void) strcpy(desc->dtargd_native, "int");
return;
}
# if 0
if ((fp = ctf_modopen(mp, &error)) == NULL) {
/*
* We have no CTF information for this module -- and therefore
* no args[] information.
*/
goto err;
}
# endif
//TODO();
if (fp == NULL)
goto err;
# if 0
/*
* If we have a parent container, we must manually import it.
*/
if ((parent = ctf_parent_name(fp)) != NULL) {
ctf_file_t *pfp;
TODO();
struct modctl *mod;
/*
* We must iterate over all modules to find the module that
* is our parent.
*/
for (mod = &modules; mod != NULL; mod = mod->mod_next) {
if (strcmp(mod->mod_filename, parent) == 0)
break;
}
if (mod == NULL)
goto err;
if ((pfp = ctf_modopen(mod->mod_mp, &error)) == NULL)
goto err;
if (ctf_import(fp, pfp) != 0) {
ctf_close(pfp);
goto err;
}
ctf_close(pfp);
}
# endif
if (ctf_func_info(fp, fbt->insp_symndx, &f) == CTF_ERR)
goto err;
if (fbt->insp_roffset != 0) {
if (desc->dtargd_ndx > 1)
goto err;
ASSERT(desc->dtargd_ndx == 1);
type = f.ctc_return;
} else {
if (desc->dtargd_ndx + 1 > f.ctc_argc)
goto err;
if (ctf_func_args(fp, fbt->insp_symndx, argc, argv) == CTF_ERR)
goto err;
type = argv[desc->dtargd_ndx];
}
if (ctf_type_name(fp, type, desc->dtargd_native,
DTRACE_ARGTYPELEN) != NULL) {
ctf_close(fp);
return;
}
err:
if (fp != NULL)
ctf_close(fp);
desc->dtargd_ndx = DTRACE_ARGNONE;
}
