mdb_ks.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (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 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Mdb kernel support module. This module is loaded automatically when the
* kvm target is initialized. Any global functions declared here are exported
* for the resolution of symbols in subsequently loaded modules.
*
* WARNING: Do not assume that static variables in mdb_ks will be initialized
* to zero.
*/
#include <mdb/mdb_target.h>
#include <mdb/mdb_param.h>
#include <mdb/mdb_modapi.h>
#include <sys/autoconf.h>
#include <sys/ddi_impldefs.h>
#include <sys/refstr_impl.h>
#include <errno.h>
typedef struct mdb_path {
} mdb_path_t;
/*
*/
unsigned long _mdb_ks_pagesize;
unsigned int _mdb_ks_pageshift;
unsigned long _mdb_ks_pageoffset;
unsigned long long _mdb_ks_pagemask;
unsigned long _mdb_ks_mmu_pagesize;
unsigned int _mdb_ks_mmu_pageshift;
unsigned long _mdb_ks_mmu_pageoffset;
unsigned long _mdb_ks_mmu_pagemask;
unsigned long _mdb_ks_msg_bsize;
unsigned long _mdb_ks_defaultstksz;
int _mdb_ks_ncpu;
/*
* In-core copy of DNLC information:
*/
#define MDB_DNLC_HSIZE 1024
#define MDB_DNLC_MAX_RETRY 4
/*
* This will be the location of the vnodeops pointer for "autofs_vnodeops"
* The pointer still needs to be read with mdb_vread() to get the location
* of the vnodeops structure for autofs.
*/
static struct vnodeops *autofs_vnops_ptr;
/*
* STREAMS queue registrations:
*/
typedef struct mdb_qinfo {
} mdb_qinfo_t;
/*
* Device naming callback structure:
*/
typedef struct nm_query {
} nm_query_t;
/*
* Address-to-modctl callback structure:
*/
typedef struct a2m_query {
} a2m_query_t;
/*
* Segment-to-mdb_map callback structure:
*/
typedef struct {
void *asm_cbdata; /* Callback data [in] */
} asmap_arg_t;
static void
dnlc_free(void)
{
int i;
return;
}
/*
* Free up current dnlc entries
*/
for (i = 0; i < MDB_DNLC_HSIZE; i++) {
}
}
}
char bad_dnlc[] = "inconsistent dnlc chain: %d, ncache va: %p"
" - continuing with the rest\n";
static int
dnlc_load(void)
{
int i; /* hash index */
int retry_cnt = 0;
int skip_bad_chains = 0;
int nc_hashsz; /* kernel hash array size */
/*
* If we've already cached the DNLC and we're looking at a dump,
* our cache is good forever, so don't bother re-loading.
*/
if (dnlc_hash && mdb_prop_postmortem) {
return (0);
}
/*
* For a core dump, retries wont help.
* Just print and skip any bad chains.
*/
if (mdb_prop_postmortem) {
skip_bad_chains = 1;
}
if (retry_cnt++ >= MDB_DNLC_MAX_RETRY) {
/*
* Give up retrying the rapidly changing dnlc.
* Just print and skip any bad chains
*/
skip_bad_chains = 1;
}
dnlc_free(); /* Free up the mdb hashed dnlc - if any */
/*
* Although nc_hashsz and the location of nc_hash doesn't currently
* change, it may do in the future with a more dynamic dnlc.
* So always read these values afresh.
*/
mdb_warn("failed to read nc_hashsz");
return (-1);
}
mdb_warn("failed to read nc_hash");
return (-1);
}
/*
* Allocate the mdb dnlc hash array
*/
/* for each kernel hash chain */
int hash; /* mdb hash value */
int khash; /* kernel dnlc hash value */
int nc_size; /* size of a name cache entry */
/*
* We read each element of the nc_hash array individually
* just before we process the entries in its chain. This is
* because the chain can change so rapidly on a running system.
*/
mdb_warn("failed to read nc_hash chain header %d", i);
dnlc_free();
return (-1);
}
/* for each entry in the chain */
/*
* The size of the ncache entries varies
* because the name is appended to the structure.
* So we read in the structure then re-read
* for the structure plus name.
*/
if (skip_bad_chains) {
break;
}
goto retry;
}
if (skip_bad_chains) {
break;
}
goto retry;
}
/*
* Check for chain consistency
*/
if (skip_bad_chains) {
break;
}
goto retry;
}
/*
* Terminate the new name with a null.
* Note, we allowed space for this null when
* allocating space for the entry.
*/
/*
* Validate new entry by re-hashing using the
* kernel dnlc hash function and comparing the hash
*/
if (skip_bad_chains) {
break;
}
goto retry;
}
/*
* Finally put the validated entry into the mdb
* hash chains. Reuse the kernel next hash field
* for the mdb hash chain pointer.
*/
}
}
return (0);
}
/*ARGSUSED*/
int
{
int i;
return (DCMD_USAGE);
if (dnlc_load() == -1)
return (DCMD_ERR);
for (i = 0; i < MDB_DNLC_HSIZE; i++) {
mdb_printf("%0?p %0?p %s\n",
}
}
return (DCMD_OK);
}
static int
{
char *s = buf;
int i;
if (len < sizeof ("/..."))
return (-1);
if (!path->mdp_complete) {
(void) strcpy(s, "??");
s += 2;
return (-1);
}
(void) strcpy(s, "/");
return (0);
}
/*
* Number of bytes left is the distance from where we
* are to the end, minus 2 for '/' and '\0'
*/
if (left <= 0)
break;
*s++ = '/';
s += strlen(s);
break;
}
if (i >= 0)
return (0);
}
static int
{
/*
* "autofs_vnops_ptr" is the address of the pointer to the vnodeops
* structure for autofs. We want to read it each time we access
* it since autofs could (in theory) be unloaded and reloaded.
*/
return (-1);
return (-1);
return (-1);
return (-1);
for (;;) {
char elemstr[MAXNAMELEN];
char *c, *p;
if (elem == MDB_PATH_NELEM) {
return (-1);
}
return (-1);
}
}
break;
}
else
}
return (0);
}
int
{
/*
* Check to see if we have a cached value for this vnode
*/
return (0);
if (dnlc_load() == -1)
return (-1);
mdb_warn("failed to read 'rootdir'");
return (-1);
}
/*
* 0 elems && complete tells sprintpath to just print "/"
*/
goto out;
}
goto out;
}
continue;
mdb_warn("path exceeded maximum expected "
"elements\n");
return (-1);
}
goto again;
}
}
out:
}
{
int pid_hashsz, hash;
return (NULL);
return (NULL);
return (NULL);
return (NULL);
while (paddr != 0) {
return (NULL);
return (NULL);
return (procp);
}
}
return (NULL);
}
{
long page_hashsz, ndx;
return (NULL);
return (pp);
}
return (NULL);
}
char
{
static const char vttab[] = {
' ', /* VNON */
' ', /* VREG */
'/', /* VDIR */
' ', /* VBLK */
' ', /* VCHR */
'@', /* VLNK */
'|', /* VFIFO */
'>', /* VDOOR */
' ', /* VPROC */
'=', /* VSOCK */
' ', /* VBAD */
};
return ('?');
return ('*');
}
static int
{
return (0);
return (0);
}
goto found;
goto found;
return (0);
return (-1);
}
{
}
static mdb_qinfo_t *
{
return (qip);
}
return (NULL);
}
void
{
return;
}
}
void
{
else
return;
}
}
}
char *
{
struct module_info mi;
goto err;
}
goto err;
}
goto err;
}
return (buf);
err:
return (buf);
}
void
{
buf[0] = '\0';
}
mdb_qrnext(const queue_t *q)
{
return (NULL);
}
mdb_qwnext(const queue_t *q)
{
return (NULL);
}
mdb_qrnext_default(const queue_t *q)
{
}
mdb_qwnext_default(const queue_t *q)
{
}
/*
* The following three routines borrowed from modsubr.c
*/
static int
{
char c;
int hash = 0;
hash ^= c;
return (hash & MOD_BIND_HASHMASK);
}
static uintptr_t
{
int hashndx;
while (mb) {
return (NULL);
}
mdb_warn("failed to read node name string at %p",
return (NULL);
}
break;
}
return (mb);
}
int
{
struct bind mbind_local;
mdb_warn("failed to read symbol 'mb_hashtab'");
return (-1);
}
-1) {
return (-1);
}
return (0);
}
return (-1);
}
const char *
{
return (NULL);
return (NULL);
return (NULL);
return ((const char *)name);
}
/*
* Return the name of the driver attached to the dip in drivername.
*/
int
{
const char *namestr;
return (-1);
}
mdb_warn("failed to read binding name at %p",
return (-1);
}
/*
* Many->one relation: various names to one major number
*/
mdb_warn("failed to translate bind name to major number\n");
return (-1);
}
/*
* One->one relation: one major number corresponds to one driver
*/
return (-1);
}
return (0);
}
/*
* Find the name of the driver attached to this dip (if any), given:
* - the address of a dip (in core)
* - the NAME of the global pointer to the driver's i_ddi_soft_state struct
* - pointer to a pointer to receive the address
*/
int
{
return (-1);
}
}
/*
* Returns a pointer to the top of the soft state struct for the instance
* specified (in state_addr), given the address of the global soft state
* pointer and size of the struct. Also fills in the buffer pointed to by
* state_buf_p (if non-NULL) with the contents of the state struct.
*/
int
{
struct i_ddi_soft_state ss;
void *statep;
return (-1);
return (-1);
return (-1);
if (state_addr != NULL)
return (-1);
}
if (state_buf_p != NULL) {
/* Read the state struct into the buffer in local space. */
return (-1);
}
return (0);
}
/*
* Returns a pointer to the top of the soft state struct for the instance
* specified (in state_addr), given the name of the global soft state pointer
* and size of the struct. Also fills in the buffer pointed to by
* state_buf_p (if non-NULL) with the contents of the state struct.
*/
int
{
return (-1);
}
static const mdb_dcmd_t dcmds[] = {
{ NULL }
};
/*ARGSUSED*/
static void
update_vars(void *arg)
{
else
}
const mdb_modinfo_t *
_mdb_init(void)
{
/*
* When used with mdb, mdb_ks is a separate dmod. With kmdb, however,
* mdb_ks is compiled into the debugger module. kmdb cannot
* automatically modunload itself when it exits. If it restarts after
* debugger fault, static variables may not be initialized to zero.
* They must be manually reinitialized here.
*/
return (&modinfo);
}
void
_mdb_fini(void)
{
dnlc_free();
}
}
/*
* Interface between MDB kproc target and mdb_ks. The kproc target relies
* on looking up and invoking these functions in mdb_ks so that dependencies
* on the current kernel implementation are isolated in mdb_ks.
*/
/*
* Given the address of a proc_t, return the p.p_as pointer; return NULL
* if we were unable to read a proc structure from the given address.
*/
{
proc_t p;
return (NULL);
}
/*
* Given the address of a proc_t, return the p.p_model value; return
* PR_MODEL_UNKNOWN if we were unable to read a proc structure or if
* the model value does not match one of the two known values.
*/
{
proc_t p;
switch (p.p_model) {
case DATAMODEL_ILP32:
return (PR_MODEL_ILP32);
case DATAMODEL_LP64:
return (PR_MODEL_LP64);
}
}
return (PR_MODEL_UNKNOWN);
}
/*
* Callback function for walking process's segment list. For each segment,
* we fill in an mdb_map_t describing its properties, and then invoke
* the callback function provided by the kproc target.
*/
static int
{
struct segvn_data svd;
MDB_TGT_MAPSZ) != 0) {
}
} else
} else {
"[ seg %p ]", addr);
}
return (WALK_NEXT);
}
/*
* Given a process address space, walk its segment list using the seg walker,
* convert the segment data to an mdb_map_t, and pass this information
* back to the kproc target via the given callback function.
*/
int
{
arg.asm_cbdata = p;
}
/*
* Copy the auxv array from the given process's u-area into the provided
* buffer. If the buffer is NULL, only return the size of the auxv array
* so the caller knows how much space will be required.
*/
int
{
proc_t p;
return (-1);
sizeof (auxv_t) * __KERN_NAUXV_IMPL);
}
return (__KERN_NAUXV_IMPL);
}
/*
* Given a process address, return the PID.
*/
{
proc_t p;
return (-1);
}
/*
* Interface between the MDB kvm target and mdb_ks. The kvm target relies
* on looking up and invoking these functions in mdb_ks so that dependencies
* on the current kernel implementation are isolated in mdb_ks.
*/
/*
* Determine whether or not the thread that panicked the given kernel was a
* kernel thread (panic_thread->t_procp == &p0).
*/
void
{
int expcont = 0;
int actcont;
mdb_printf("dump content: all kernel and user pages\n");
return;
} else if (actcont == DF_CURPROC) {
mdb_printf("dump content: kernel pages and pages from "
"PID %d", content);
return;
}
mdb_printf("dump content: kernel pages only\n");
if (!(expcont & DF_CURPROC))
return;
goto kthreadpanic_err;
goto kthreadpanic_err;
goto kthreadpanic_err;
mdb_printf(" (curproc requested, but a kernel thread "
"panicked)\n");
} else {
mdb_printf(" (curproc requested, but the process that "
"panicked could not be dumped)\n");
}
return;
mdb_printf(" (curproc requested, but the process that panicked could "
"not be found)\n");
}
/*
* Determine the process that was saved in a `curproc' dump. This process will
* be recorded as the first element in dump_pids[].
*/
int
mdb_dump_find_curproc(void)
{
pid > 0)
return (pid);
else
return (-1);
}
/*
* Following three funcs extracted from sunddi.c
*/
/*
* Return core address of root node of devinfo tree
*/
static uintptr_t
mdb_ddi_root_node(void)
{
/* return (top_devinfo); */
mdb_warn("failed to read top_devinfo");
return (NULL);
}
return (top_devinfo_addr);
}
/*
* Return the name of the devinfo node pointed at by 'dip_addr' in the buffer
* pointed at by 'name.'
*
* - dip_addr is a pointer to a dev_info struct in core.
*/
static char *
{
char *local_namep = name;
if (dip_addr == mdb_ddi_root_node()) {
if (name_size < 1) {
mdb_warn("failed to get node name: buf too small\n");
return (NULL);
}
*name = '\0';
return (name);
}
if (name_size < 2) {
mdb_warn("failed to get node name: buf too small\n");
return (NULL);
}
local_namep = name;
*local_namep++ = '/';
*local_namep = '\0';
mdb_warn("failed to read devinfo struct");
}
if (length == -1) {
mdb_warn("failed to read node name");
return (NULL);
}
local_namep += length;
if (local_name_size < 2) {
mdb_warn("not enough room for node address string");
return (name);
}
*local_namep++ = '@';
*local_namep = '\0';
if (length == -1) {
mdb_warn("failed to read name");
return (NULL);
}
}
return (name);
}
/*
* Generate the full path under the /devices dir to the device entry.
*
* dip is a pointer to a devinfo struct in core (not in local memory).
*/
char *
{
char *bp;
if (dip_addr == mdb_ddi_root_node()) {
*path = '\0';
return (path);
}
mdb_warn("failed to read devinfo struct");
}
return (path);
}
/*
* Read in the string value of a refstr, which is appended to the end of
* the structure.
*/
{
}