/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Copyright (c) 2013, 2015 by Delphix. All rights reserved.
* Copyright (c) 2013, Joyent, Inc. All rights reserved.
*/
#include <mdb/mdb_ctf_impl.h>
#include <mdb/mdb_modapi.h>
#include <mdb/mdb_string.h>
#include <mdb/mdb_debug.h>
#include <libctf.h>
#include <string.h>
typedef struct tnarg {
} tnarg_t;
typedef struct type_iter {
void *ti_arg;
} type_iter_t;
typedef struct member_iter {
void *mi_arg;
typedef struct type_visit {
void *tv_arg;
int tv_min_depth;
} type_visit_t;
typedef struct mbr_info {
const char *mbr_member;
} mbr_info_t;
typedef struct synth_intrinsic {
const char *syn_name;
typedef struct synth_typedef {
const char *syt_src;
const char *syt_targ;
/*
* As part of our support for synthetic types via ::typedef, we define a core
* set of types.
*/
{ NULL, { 0, 0, 0}, 0 }
};
{ NULL, { 0, 0, 0 }, 0 }
};
{ "char", "int8_t" },
{ "short", "int16_t" },
{ "int", "int32_t" },
{ "long long", "int64_t" },
{ "int", "intptr_t" },
{ "unsigned char", "uint8_t" },
{ "unsigned short", "uint16_t" },
{ "unsigned", "uint32_t" },
{ "unsigned long long", "uint64_t" },
{ "unsigned char", "uchar_t" },
{ "unsigned short", "ushort_t" },
{ "unsigned", "uint_t" },
{ "unsigned long", "ulong_t" },
{ "unsigned long long", "u_longlong_t" },
{ "int", "ptrdiff_t" },
{ "unsigned", "uintptr_t" },
};
{ "char", "int8_t" },
{ "short", "int16_t" },
{ "int", "int32_t" },
{ "long", "int64_t" },
{ "long", "intptr_t" },
{ "unsigned char", "uint8_t" },
{ "unsigned short", "uint16_t" },
{ "unsigned", "uint32_t" },
{ "unsigned long", "uint64_t" },
{ "unsigned char", "uchar_t" },
{ "unsigned short", "ushort_t" },
{ "unsigned", "uint_t" },
{ "unsigned long", "ulong_t" },
{ "unsigned long long", "u_longlong_t" },
{ "long", "ptrdiff_t" },
{ "unsigned long", "uintptr_t" },
};
static void
{
}
/*
* Callback function for mdb_tgt_object_iter used from name_to_type, below,
* to search the CTF namespace of each object file for a particular name.
*/
/*ARGSUSED*/
static int
{
/*
* We may have found a forward declaration. If we did, we'll
* note the ID and file pointer, but we'll keep searching in
* an attempt to find the real thing. If we found something
* real (i.e. not a forward), we stop the iteration.
*/
}
return (0);
}
/*
* Convert a string type name with an optional leading object specifier into
* the corresponding CTF file container and type ID. If an error occurs, we
* print an appropriate message and return NULL.
*/
static ctf_file_t *
{
char *p, *s;
/*
* We need to shuffle things around a little to support
* type names of the form "struct module`name".
*/
p = name + (p - s);
}
if (*name != '\0')
name = p;
}
/*
* Attempt to look up the name in the primary object file. If this
* fails and the name was unscoped, search all remaining object files.
* Finally, search the synthetic types.
*/
object == MDB_TGT_OBJ_EXEC) {
}
}
return (NULL); /* errno is set for us */
return (NULL);
}
return (fp);
}
/*
* Check to see if there is ctf data in the given object. This is useful
* so that we don't enter some loop where every call to lookup fails.
*/
int
{
}
int
{
return (-1); /* errno is set for us */
}
return (0);
}
int
mdb_ctf_id_t *p)
{
}
return (-1); /* errno is set for us */
}
}
return (0);
}
int
{
const char *obj, *c;
if (p == NULL)
return (-1); /* errno is set for us */
}
} else {
return (-1); /* errno is set for us */
}
c = name;
}
return (-1); /* errno is set for us */
}
}
int
{
return (set_errno(EMDB_NOCTF));
return (0);
}
/*ARGSUSED*/
int
{
int err;
/*
* In case the input symbol came from a merged or private symbol table,
* re-lookup the address as a symbol, and then perform a fully scoped
* lookup of that symbol name to get the mdb_syminfo_t for its CTF.
*/
return (-1); /* errno is set for us */
else
if (err != 0)
return (-1); /* errno is set for us */
return (0);
}
int
{
int i;
}
return (0);
}
void
{
}
int
{
}
int
{
}
int
{
if (outp)
}
NULL &&
return (0);
}
}
return (0);
}
char *
{
char *ret;
if (!mdb_ctf_type_valid(id)) {
return (NULL);
}
return (ret);
}
{
/* resolve the type in case there's a forward declaration */
return (ret);
return (ret);
}
int
{
int ret;
return (ret);
}
int
{
if (outp)
}
return (0);
}
int
{
return (0);
}
/*
* callback proxy for mdb_ctf_type_visit
*/
static int
{
int ret;
return (0);
return (ret);
/*
* If the type resolves to a type in a different file, we must have
* followed a forward declaration. We need to recurse into the
* new type.
*/
}
return (ret);
}
int
{
int ret;
tv.tv_base_offset = 0;
tv.tv_base_depth = 0;
tv.tv_min_depth = 0;
return (ret);
}
int
{
return (0);
}
const char *
{
const char *ret;
/* resolve the type in case there's a forward declaration */
return (NULL);
return (ret);
}
/*
* callback proxy for mdb_ctf_member_iter
*/
static int
{
}
int
{
int ret;
/* resolve the type in case there's a forward declaration */
return (ret);
return (ret);
}
int
{
int ret;
/* resolve the type in case there's a forward declaration */
return (ret);
}
/*
* callback proxy for mdb_ctf_type_iter
*/
static int
{
}
int
{
int ret;
if (object == MDB_CTF_SYNTHETIC_ITER)
else
return (-1);
return (ret);
}
/* utility functions */
{
}
{
}
static int
{
return (1);
}
return (0);
}
int
{
int rc;
/* couldn't get member list */
if (rc == -1)
return (-1); /* errno is set for us */
/* not a member */
if (rc == 0)
return (set_errno(EMDB_CTFNOMEMB));
return (0);
}
/*
* Returns offset in _bits_ in *retp.
*/
int
{
}
/*
* Returns offset in _bytes_, or -1 on failure.
*/
int
{
return (-1);
}
return (-1);
}
if (off % 8 != 0) {
mdb_warn("member %s of type %s is an unsupported bitfield\n",
return (-1);
}
off /= 8;
return (off);
}
{
return (-1);
}
return (-1);
}
return (size);
}
/*ARGSUSED*/
static int
{
return (0);
}
int
{
int count = 0;
return (-1); /* errno is set for us */
return (count);
}
typedef struct mbr_contains {
char **mbc_bufp;
static int
{
size_t n;
return (0);
else
return (0);
return (1);
}
{
size_t n;
if (!mdb_ctf_type_valid(id))
/*
* Quick sanity check to make sure the given offset is within
* this scope of this type.
*/
*buf = '\0';
for (;;) {
/*
* Check for an exact match.
*/
if (off == 0)
break;
/*
* Find the member that contains this offset.
*/
switch (mdb_ctf_type_kind(id)) {
case CTF_K_ARRAY: {
if (n > len)
n = len;
buf += n;
len -= n;
break;
}
case CTF_K_STRUCT: {
int ret;
/*
* Find the member that contains this offset
* and continue.
*/
if (dot) {
if (len != 0) {
*buf++ = '.';
*buf = '\0';
len--;
}
}
if (ret == -1)
return (-1); /* errno is set for us */
/*
* If we did not find a member containing this offset
* (due to holes in the structure), return EINVAL.
*/
if (ret == 0)
break;
}
case CTF_K_UNION:
/*
* Treat unions like atomic entities since we can't
* do more than guess which member of the union
* might be the intended one.
*/
goto done;
case CTF_K_INTEGER:
case CTF_K_FLOAT:
case CTF_K_POINTER:
case CTF_K_ENUM:
goto done;
default:
}
dot = 1;
}
done:
}
static void
{
if (flags & MDB_CTF_VREAD_QUIET)
return;
}
/*
* Check if two types are structurally the same rather than logically
* the same. That is to say that two types are equal if they have the
* same logical structure rather than having the same ids in CTF-land.
*/
static int
{
/*
* Look up the corresponding member in the other composite type.
*/
return (1);
/*
* We don't allow members to be shuffled around.
*/
return (1);
}
static int
{
/*
* Resolve both types down to their fundamental types, and make
* sure their sizes and kinds match.
*/
if (mdb_ctf_type_resolve(a, &a) != 0 ||
mdb_ctf_type_resolve(b, &b) != 0 ||
return (0);
}
switch (akind) {
case CTF_K_INTEGER:
case CTF_K_FLOAT:
case CTF_K_POINTER:
/*
* For pointers we could be a little stricter and require
* both pointers to reference types which look vaguely
* similar (for example, we could insist that the two types
* have the same name). However, all we really care about
* here is that the structure of the two types are the same,
* and, in that regard, one pointer is as good as another.
*/
return (1);
case CTF_K_UNION:
case CTF_K_STRUCT:
/*
* The test for the number of members is only strictly
* necessary for unions since we'll find other problems with
* structs. However, the extra check will do no harm.
*/
return (mdb_ctf_num_members(a) == mdb_ctf_num_members(b) &&
mdb_ctf_member_iter(a, type_equals_cb, &b) == 0);
case CTF_K_ARRAY:
return (mdb_ctf_array_info(a, &aar) == 0 &&
mdb_ctf_array_info(b, &bar) == 0 &&
}
return (0);
}
typedef struct member {
char *m_modbuf;
char *m_tgtbuf;
const char *m_tgtname;
} member_t;
const char *, uint_t);
static int
{
"could not find %s\n", tgtname);
return (set_errno(EMDB_CTFNOMEMB));
}
}
typedef struct enum_value {
int *ev_modbuf;
const char *ev_name;
} enum_value_t;
static int
{
return (1);
}
return (0);
}
static int
{
int ret;
int i;
}
if (mdb_ctf_type_name(modid,
}
tgtname = "";
/*
* Resolve the types to their canonical form.
*/
"couldn't determine type kind of mdb module type %s\n",
return (-1); /* errno is set for us */
}
"couldn't determine type kind of %s\n", typename);
return (-1); /* errno is set for us */
}
"mdb module type %s\n", mdbtypename);
return (-1); /* errno is set for us */
}
return (-1); /* errno is set for us */
}
/* allow them to convert a pointer to a uintptr_t */
return (set_errno(EMDB_INCOMPAT));
}
switch (tgtkind) {
case CTF_K_INTEGER:
case CTF_K_FLOAT:
/*
* Must determine if the target and module types have the same
* encoding before we can copy them.
*/
"couldn't determine encoding of type %s (%s)\n",
return (-1); /* errno is set for us */
}
"mdb module type %s\n", mdbtypename);
return (-1); /* errno is set for us */
}
if (modkind == CTF_K_INTEGER) {
"signedness mismatch between type "
"%s (%s) and mdb module type %s\n",
return (set_errno(EMDB_INCOMPAT));
}
"encoding mismatch (%#x != %#x) between type "
"%s (%s) and mdb module type %s\n",
return (set_errno(EMDB_INCOMPAT));
}
/* FALLTHROUGH */
case CTF_K_POINTER:
/*
* If the sizes don't match we need to be tricky to make
* sure that the caller gets the correct data.
*/
"large for mdb module type %s\n",
return (set_errno(EMDB_INCOMPAT));
/* BEGIN CSTYLED */
/*
* Fill modbuf with 1's for sign extension if target
* buf is a signed integer and its value is negative.
*
* S = sign bit (in most-significant byte)
*
* BIG ENDIAN DATA
* +--------+--------+--------+--------+
* |S | | | |
* +--------+--------+--------+--------+
* 0 1 ... sz-1 sz
*
* LITTLE ENDIAN DATA
* +--------+--------+--------+--------+
* | | | |S |
* +--------+--------+--------+--------+
* 0 1 ... sz-1 sz
*/
/* END CSTYLED */
#ifdef _BIG_ENDIAN
#else
#endif
else
#ifdef _BIG_ENDIAN
#else
#endif
} else {
}
return (0);
case CTF_K_ENUM:
return (set_errno(EMDB_INCOMPAT));
}
/*
* Default to the same value as in the target.
*/
/* LINTED */
i = *(int *)tgtbuf;
/* LINTED */
"unexpected value %u of enum type %s (%s)\n",
return (set_errno(EMDB_INCOMPAT));
}
if (ret == 0) {
/* value not found */
"unexpected value %s (%u) of enum type %s (%s)\n",
return (set_errno(EMDB_INCOMPAT));
} else if (ret == 1) {
/* value found */
return (0);
} else if (ret == -1) {
}
return (ret);
case CTF_K_STRUCT:
case CTF_K_UNION:
/*
* Unions are a little tricky. The only time it's truly
* safe to read in a union is if no part of the union or
* any of its component types have changed. The correct
* use of this feature is to read the containing structure,
* figure out which component of the union is valid, compute
* the location of that in the target and then read in
* that part of the structure.
*/
return (set_errno(EMDB_INCOMPAT));
}
return (0);
case CTF_K_ARRAY:
"couldn't get array info for %s (%s)\n",
return (-1); /* errno is set for us */
}
"couldn't get array info for mdb module type %s\n",
return (-1); /* errno is set for us */
}
"unexpected array size (%u) for type %s (%s)\n",
return (set_errno(EMDB_INCOMPAT));
}
"mdb module type %s\n", mdbtypename);
return (-1); /* errno is set for us */
}
"couldn't determine size of %s (%s)\n",
return (-1); /* errno is set for us */
}
for (i = 0; i < tar.mta_nelems; i++) {
if (ret != 0)
return (ret);
}
return (0);
}
return (set_errno(EMDB_INCOMPAT));
}
/*
* Like mdb_vread(), mdb_ctf_vread() is used to read from the target's
* virtual address space. However, mdb_ctf_vread() can be used to safely
* read a complex type (e.g. a struct) from the target, even if MDB was compiled
* against a different definition of that type (e.g. when debugging a crash
* dump from an older release).
*
* Callers can achieve this by defining their own type which corresponds to the
* type in the target, but contains only the members that the caller requires.
* Using the CTF type information embedded in the target, mdb_ctf_vread will
* find the required members in the target and fill in the caller's structure.
* The members are located by name, and their types are verified to be
* compatible.
*
* By convention, the caller will declare a type with the name "mdb_<type>",
* where <type> is the name of the type in the target (e.g. mdb_zio_t). This
* type will contain the members that the caller is interested in. For example:
*
* typedef struct mdb_zio {
* enum zio_type io_type;
* uintptr_t io_waiter;
* struct {
* struct {
* uintptr_t list_next;
* } list_head;
* } io_parent_list;
* int io_error;
* } mdb_zio_t;
*
* mdb_zio_t zio;
* error = mdb_ctf_vread(&zio, "zio_t", "mdb_zio_t", zio_target_addr, 0);
*
* If a given MDB module has different dcmds or walkers that need to read
* different members from the same struct, then different "mdb_" types
* should be declared for each caller. By convention, these types should
* be named "mdb_<dcmd or walker>_<type>", e.g. mdb_findstack_kthread_t
* for ::findstack. If the MDB module is compiled from several source files,
* one must be especially careful to not define different types with the
* same name in different source files, because the compiler can not detect
* this error.
*
* Enums will also be translated by name, so the mdb module will receive
* the enum value it expects even if the target has renumbered the enum.
* Warning: it will therefore only work with enums are only used to store
* legitimate enum values (not several values or-ed together).
*
* By default, if mdb_ctf_vread() can not find any members or enum values,
* it will print a descriptive message (with mdb_warn()) and fail.
* Passing MDB_CTF_VREAD_QUIET in 'flags' will suppress the warning message.
* Additional flags can be used to ignore specific types of translation
* failure, but should be used with caution, because they will silently leave
* the caller's buffer uninitialized.
*/
int
{
void *tgtbuf;
return (set_errno(EMDB_NOCTF));
}
"type %s in mdb module %s\n",
}
"couldn't find type %s in target's ctf data\n",
return (set_errno(EMDB_NOCTF));
}
/*
* Read the data out of the target's address space.
*/
return (-1); /* errno is set for us */
}
return (-1); /* errno is set for us */
}
}
/*
* Note: mdb_ctf_readsym() doesn't take separate parameters for the name
* of the target's type vs the mdb module's type. Use with complicated
* types (e.g. structs) may result in unnecessary failure if a member of
* the struct has been changed in the target, but is not actually needed
* by the mdb module. Use mdb_lookup_by_name() + mdb_ctf_vread() to
* avoid this problem.
*/
int
{
return (-1); /* errno is set for us */
}
}
{
ctdata.cts_offset = 0;
}
int
mdb_ctf_synthetics_init(void)
{
int err;
return (0);
}
void
mdb_ctf_synthetics_fini(void)
{
return;
}
int
{
int err;
mdb_printf("synthetic types disabled: ctf create failed\n");
return (1);
}
switch (kind) {
case SYNTHETIC_ILP32:
break;
case SYNTHETIC_LP64:
break;
default:
kind);
return (1);
}
err = 0;
} else {
}
goto discard;
}
}
goto discard;
}
goto discard;
}
CTF_ERR) {
goto discard;
}
}
goto discard;
}
return (0);
(void) ctf_discard(cp);
return (err);
}
int
mdb_ctf_synthetics_reset(void)
{
return (mdb_ctf_synthetics_init());
}
int
{
mdb_printf("synthetic types disabled: ctf create failed\n");
return (1);
}
"with that name already exists\n", name);
}
}
}
}
return (0);
}
int
{
mdb_printf("synthetic types disabled: ctf create failed\n");
return (1);
}
"with that name already exists\n", name);
}
CTF_ERR) {
}
}
return (0);
}
int
{
mdb_printf("synthetic types disabled: ctf create failed\n");
return (1);
}
"with that name already exists\n", name);
}
CTF_ERR) {
}
}
return (0);
}
int
{
mdb_printf("synthetic types disabled: ctf create failed\n");
return (DCMD_ERR);
}
"that wasn't created from a synthetic\n");
}
}
}
}
}
return (0);
}
int
{
mdb_printf("synthetic types disabled: ctf create failed\n");
return (1);
}
}
}
}
}
}
return (0);
}
int
{
mdb_printf("synthetic types disabled: ctf create failed\n");
return (1);
}
}
}
}
}
return (0);
}
int
{
int ret;
mdb_warn("bad ctf_file_t, expected synth container\n");
return (1);
}
if (ret != 0) {
}
}
return (0);
}
static int
{
}
return (0);
}
int
{
int ret;
mdb_warn("synthetic types disabled: ctf create failed\n");
return (1);
}
ctf_errmsg(ret));
return (1);
}
mdb_warn("failed to add types");
goto cleanup;
}
}
if (ret != 0)
(void) ctf_discard(syn);
return (ret);
}
int
{
int err;
mdb_warn("synthetic types are disabled, not writing "
"anything\n");
return (DCMD_ERR);
}
if (err != 0) {
else
} else {
}
return (err);
}