/*
* 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 (c) 2013 by Delphix. All rights reserved.
* Copyright 2015 Nexenta Systems, Inc. All rights reserved.
*/
#include <mdb/mdb_modapi.h>
#include <mdb/mdb_module.h>
#include <mdb/mdb_string.h>
#include <mdb/mdb_debug.h>
#include <mdb/mdb_callb.h>
#include <mdb/mdb_dump.h>
#include <mdb/mdb_frame.h>
/*
* Private callback structure for implementing mdb_walk_dcmd, below.
*/
typedef struct {
/*
* Global properties which modules are allowed to look at. These are
* re-initialized by the target activation callbacks.
*/
{
return (rbytes);
}
{
}
{
return (rbytes);
}
{
}
{
return (rbytes);
}
{
}
{
return (rbytes);
}
{
}
{
}
{
}
{
return (rbytes);
}
{
}
{
return (-1);
return (-1);
}
{
return (-1);
return (-1);
}
int
{
}
int
{
}
int
{
}
int
{
}
mdb_strtoull(const char *s)
{
if (s[0] == '0') {
switch (s[1]) {
case 'I':
case 'i':
radix = 2;
s += 2;
break;
case 'O':
case 'o':
radix = 8;
s += 2;
break;
case 'T':
case 't':
radix = 10;
s += 2;
break;
case 'X':
case 'x':
radix = 16;
s += 2;
break;
}
}
}
{
return (nbytes);
}
void
{
}
void
{
}
void
mdb_flush(void)
{
}
/*
* Convert an object of len bytes pointed to by srcraw between
* network-order and host-order and store in dstraw. The length len must
* be the actual length of the objects pointed to by srcraw and dstraw (or
* zero) or the results are undefined. srcraw and dstraw may be the same,
* in which case the object is converted in-place. Note that this routine
* will convert from host-order to network-order or network-order to
* host-order, since the conversion is the same in either case.
*/
/* ARGSUSED */
void
{
#ifdef _LITTLE_ENDIAN
size_t i;
for (i = 0; i < len / 2; i++) {
}
#else
#endif
}
/*
* Bit formatting functions: Note the interesting use of UM_GC here to
* allocate a buffer for the caller which will be automatically freed
* when the dcmd completes or is forcibly aborted.
*/
(buf)[(j)++] = ' '; \
(buf)[(j)++] = (c); \
}
const char *
{
int i, j = 0;
char *buf;
for (i = bit - 1; i >= 0; i--)
return (buf);
}
const char *
{
int i, j = 0;
char *buf;
for (; i >= 0; i--)
return (buf);
}
{
return (margin);
}
return (0);
}
{
} else
return (margin);
}
return (0);
}
int
mdb_eval(const char *s)
{
int err;
if (s == NULL)
/*
* Push m_in down onto the input stack, then set m_in to point to the
* i/o buffer for our command string, and reset the frame marker.
* The mdb_run() function returns when the new m_in iob reaches EOF.
*/
/*
* Now pop the old standard input stream and restore mdb.m_in and
* the parser's saved current line number.
*/
/*
* If mdb_run() returned an error, propagate this backward
* up the stack of debugger environment frames.
*/
if (MDB_ERR_IS_FATAL(err))
return (set_errno(EMDB_CANCEL));
if (err != 0)
return (0);
}
void
{
}
mdb_get_dot(void)
{
}
static int
{
int status;
/*
* If the control block has no layers, we just invoke the walker's
* step function and return status indicating whether to continue
* or stop. If the control block has layers, we need to invoke
* ourself recursively for the next layer, until eventually we
* percolate down to an unlayered walk.
*/
}
return (WALK_NEXT);
return (status);
}
static int
{
/*
* Enter the control block in the active list so that mdb can clean
* up after it in case we abort out of the current command.
*/
else
/*
* The per-walk constructor performs private buffer initialization
* and locates whatever symbols are necessary.
*/
goto done;
}
/*
* Mark wcb to indicate that walk_init has been called (which means
* we can call walk_fini if the walk is aborted at this point).
*/
continue;
done:
else
return (rval);
}
typedef struct pwalk_step {
void *ps_private;
} pwalk_step_t;
static int
{
int ret;
return (ret);
}
int
{
pwalk_step_t p;
p.ps_private = private;
int ret;
return (ret);
}
return (-1); /* errno is set for us */
}
int
{
}
/*ARGSUSED*/
static int
{
int status;
return (WALK_ERR);
return (WALK_NEXT);
}
int
{
int status;
return (-1); /* errno is set for us */
return (-1); /* errno is set for us */
return (status);
}
int
{
}
/*ARGSUSED*/
static int
{
/*
* Prior to calling the top-level walker's step function, reset its
* mdb_walk_state_t walk_addr and walk_layer members to refer to the
* target virtual address and data buffer of the underlying object.
*/
}
int
{
return (-1); /* errno is set for us */
return (set_errno(EMDB_BADWCB));
return (set_errno(EMDB_WALKLOOP));
return (set_errno(EMDB_WALKINIT));
}
} else
return (0);
}
int
{
int status;
return (-1); /* errno is set for us */
return (set_errno(EMDB_DCFAIL));
if (status == DCMD_USAGE)
return (set_errno(EMDB_DCUSAGE));
return (0);
}
int
{
} else
}
int
{
} else
}
void
{
if (p == NULL) {
warn("dcmd failure: mdb_get_pipe invoked with NULL pointer\n");
}
} else {
p->pipe_len = 0;
}
}
void
{
if (p == NULL) {
warn("dcmd failure: mdb_set_pipe invoked with NULL pointer\n");
}
}
}
{
}
/*
* Private callback structure for implementing mdb_object_iter, below.
*/
typedef struct {
void *oi_arg;
int oi_rval;
/*ARGSUSED*/
static int
{
return (0);
return (0);
}
int
{
return (-1);
}
/*
* Private callback structure for implementing mdb_symbol_iter, below.
*/
typedef struct {
void *si_arg;
int si_rval;
/*ARGSUSED*/
static int
{
return (0);
return (0);
}
int
{
mdb_symbol_cb, &arg) != 0)
return (-1);
}
/*
* Private structure and function for implementing mdb_dumpptr on top
* of mdb_dump_internal
*/
typedef struct dptrdat {
void *arg;
} dptrdat_t;
static ssize_t
{
}
/*
* Private structure and function for handling callbacks which return
* EMDB_PARTIAL
*/
typedef struct d64dat {
void *arg;
} d64dat_t;
static ssize_t
{
int result;
int count;
count = 0;
do {
if (result == 1)
count++;
if (count)
}
return (result);
}
int
void *arg)
{
}
int
void *arg)
{
}
int
mdb_get_state(void)
{
}
void *
{
mdb_module_t *m;
return (NULL);
}
else
}
void
{
}