[apple/xnu.git] / osfmk / ddb / db_examine.c

/*
 * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */
/* 
 * Mach Operating System
 * Copyright (c) 1991,1990 Carnegie Mellon University
 * All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 * 
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 * 
 * Carnegie Mellon requests users of this software to return to
 * 
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 * 
 * any improvements or extensions that they make and grant Carnegie Mellon
 * the rights to redistribute these changes.
 */
/*
 */
/*
 *	Author: David B. Golub, Carnegie Mellon University
 *	Date:	7/90
 */
#include <string.h>			/* For strlcpy() */
#include <mach/boolean.h>
#include <machine/db_machdep.h>

#include <ddb/db_access.h>
#include <ddb/db_lex.h>
#include <ddb/db_output.h>
#include <ddb/db_command.h>
#include <ddb/db_sym.h>
#include <ddb/db_task_thread.h>
#include <ddb/db_command.h>		/* For db_option() */
#include <ddb/db_examine.h>
#include <ddb/db_expr.h>
#include <kern/thread.h>
#include <kern/task.h>
#include <mach/vm_param.h>

#define db_act_to_task(thr_act)	((thr_act)? thr_act->task: TASK_NULL)

char		db_examine_format[TOK_STRING_SIZE] = "x";
int		db_examine_count = 1;
db_addr_t	db_examine_prev_addr = 0;
thread_t	db_examine_act = THREAD_NULL;

extern int	db_max_width;


/* Prototypes for functions local to this file.  XXX -- should be static!
 */
int db_xcdump(
	db_addr_t	addr,
	int		size,
	int		count,
	task_t		task);

int db_examine_width(
	int size,
	int *items,
	int *remainder);

extern char db_last_modifier[];

/*
 * Examine (print) data.
 */
void
db_examine_cmd(db_expr_t addr, __unused boolean_t have_addr, db_expr_t count,
	       char *modif)
{
	thread_t	thr_act;

	if (modif[0] != '\0')
	    strlcpy(db_examine_format, modif, TOK_STRING_SIZE);

	if (count == (db_expr_t)-1)
	    count = 1;
	db_examine_count = count;
	if (db_option(modif, 't')) {
	    if (modif == db_last_modifier)
		thr_act = db_examine_act;
	    else if (!db_get_next_act(&thr_act, 0))
		return;
	} else
	  if (db_option(modif,'u'))
	    thr_act = current_thread();
	  else
	    thr_act = THREAD_NULL;

	db_examine_act = thr_act;
	db_examine((db_addr_t) addr, db_examine_format, count, 
					db_act_to_task(thr_act));
}

void
db_examine_forward(__unused db_expr_t addr, __unused boolean_t have_addr,
		   __unused db_expr_t count, __unused char *modif)
{
	db_examine(db_next, db_examine_format, db_examine_count,
				db_act_to_task(db_examine_act));
}

void
db_examine_backward(__unused db_expr_t addr, __unused boolean_t have_addr,
		    __unused db_expr_t count, __unused char *modif)
{
	db_examine(db_examine_prev_addr - (db_next - db_examine_prev_addr),
			 db_examine_format, db_examine_count,
				db_act_to_task(db_examine_act));
}

int
db_examine_width(
	int size,
	int *items,
	int *remainder)
{
	int sz;
	int entry;
	int width;

	width = size * 2 + 1;
	sz = (db_max_width - (sizeof (void *) * 2 + 4)) / width;
	for (entry = 1; (entry << 1) < sz; entry <<= 1)
		continue;

	sz = sizeof (void *) * 2 + 4 + entry * width;
	while (sz + entry < db_max_width) {
		width++;
		sz += entry;
	}
	*remainder = (db_max_width - sz + 1) / 2;
	*items = entry;
	return width;
}

void
db_examine(
	db_addr_t	addr,
	char *		fmt,	/* format string */
	int		count,	/* repeat count */
	task_t		task)
{
	int		c;
	db_expr_t	value;
	int		size;
	int		width;
	int		leader;
	int		items;
	int		nitems = 0;
	char *		fp;
	db_addr_t	next_addr = 0;
	int		sz;

	db_examine_prev_addr = addr;
	while (--count >= 0) {
	    fp = fmt;
	    size = sizeof(int);
	    width = db_examine_width(size, &items, &leader);
	    while ((c = *fp++) != 0) {
		switch (c) {
		    case 'b':
			size = sizeof(char);
			width = db_examine_width(size, &items, &leader);
			break;
		    case 'h':
			size = sizeof(short);
			width = db_examine_width(size, &items, &leader);
			break;
		    case 'l':
			size = sizeof(int);
			width = db_examine_width(size, &items, &leader);
			break;
		    case 'q':
			size = sizeof(long);
			width = db_examine_width(size, &items, &leader);
			break;
		    case 'a':	/* address */
		    case 'A':   /* function address */
			/* always forces a new line */
			if (db_print_position() != 0)
			    db_printf("\n");
			db_prev = addr;
			next_addr = addr + 4;
			db_task_printsym(addr, 
					(c == 'a')?DB_STGY_ANY:DB_STGY_PROC,
					task);
			db_printf(":\t");
			break;
		    case 'm':
			db_next = db_xcdump(addr, size, count+1, task);
			return;
		    case 't':
		    case 'u':
			break;
		    default:
		restart:
			/* Reset next_addr in case we are printing in
			   multiple formats.  */
			next_addr = addr;
			if (db_print_position() == 0) {
			    /* If we hit a new symbol, print it */
			    char *	name;
			    db_addr_t	off;

			    db_find_task_sym_and_offset(addr,&name,&off,task);
			    if (off == 0)
				db_printf("\r%s:\n", name);
			    db_printf("%#lln: ", (unsigned long long)addr);
			    for (sz = 0; sz < leader; sz++)
				    db_putchar(' ');
			    db_prev = addr;
			    nitems = items;
			}

			switch (c) {
			    case 'p':	/* Addrs rendered symbolically. */
				if( size == sizeof(void *) )  {
				    char       *symName;
				    db_addr_t	offset;

				    items = 1;
				    value = db_get_task_value( next_addr,
					sizeof(db_expr_t), FALSE, task );
				    db_find_task_sym_and_offset( value,
					&symName, &offset, task);
				    db_printf("\n\t*%8llX(%8llX) = %s",
						(unsigned long long)next_addr, (unsigned long long)value, symName );
				    if( offset )  {
					db_printf("+%llX", (unsigned long long)offset );
				    }
				    next_addr += size;
				}
				break;
			    case 'r':	/* signed, current radix */
				for (sz = size, next_addr = addr;
				     sz >= (signed)sizeof (db_expr_t);
				     sz -= sizeof (db_expr_t)) {
				    if (nitems-- == 0) {
					db_putchar('\n');
					goto restart;
				    }
				    value = db_get_task_value(next_addr,
							      sizeof (db_expr_t),
							      TRUE,task);
				    db_printf("%-*llr", width, (unsigned long long)value);
				    next_addr += sizeof (db_expr_t);
				}
				if (sz > 0) {
				    if (nitems-- == 0) {
					db_putchar('\n');
					goto restart;
				    }
				    value = db_get_task_value(next_addr, sz,
							      TRUE, task);
				    db_printf("%-*llR", width, (unsigned long long)value);
				    next_addr += sz;
				}
				break;
			    case 'X':	/* unsigned hex */
			    case 'x':	/* unsigned hex */
				for (sz = size, next_addr = addr;
				     sz >= (signed)sizeof (db_expr_t);
				     sz -= sizeof (db_expr_t)) {
				    if (nitems-- == 0) {
					db_putchar('\n');
					goto restart;
				    }
				    value = db_get_task_value(next_addr,
							      sizeof (db_expr_t),
							      FALSE,task);
			            if ( c == 'X')
				      db_printf("%0*llX ", 2*size, (unsigned long long)value);
				    else
				      db_printf("%-*llx", width, (unsigned long long)value);
				    next_addr += sizeof (db_expr_t);
			        }
				if (sz > 0) {
				    if (nitems-- == 0) {
					db_putchar('\n');
					goto restart;
				    }
				    value = db_get_task_value(next_addr, sz,
							      FALSE, task);
			            if ( c == 'X')
				      db_printf("%0*llX ", 2*size, (unsigned long long)value);
				    else
				      db_printf("%-*llX", width, (unsigned long long)value);
				    next_addr += sz;
				}
				break;
			    case 'z':	/* signed hex */
				for (sz = size, next_addr = addr;
				     sz >= (signed)sizeof (db_expr_t);
				     sz -= sizeof (db_expr_t)) {
				    if (nitems-- == 0) {
					db_putchar('\n');
					goto restart;
				    }
				    value = db_get_task_value(next_addr,
							      sizeof (db_expr_t),
							      TRUE, task);
				    db_printf("%-*llz", width, (unsigned long long)value);
				    next_addr += sizeof (db_expr_t);
				}
				if (sz > 0) {
				    if (nitems-- == 0) {
					db_putchar('\n');
					goto restart;
				    }
				    value = db_get_task_value(next_addr,sz,
							      TRUE,task);
				    db_printf("%-*llZ", width, (unsigned long long)value);
				    next_addr += sz;
				}
				break;
			    case 'd':	/* signed decimal */
				for (sz = size, next_addr = addr;
				     sz >= (signed)sizeof (db_expr_t);
				     sz -= sizeof (db_expr_t)) {
				    if (nitems-- == 0) {
					db_putchar('\n');
					goto restart;
				    }
				    value = db_get_task_value(next_addr,
							      sizeof (db_expr_t),
							      TRUE,task);
				    db_printf("%-*lld", width, (unsigned long long)value);
				    next_addr += sizeof (db_expr_t);
				}
				if (sz > 0) {
				    if (nitems-- == 0) {
					db_putchar('\n');
					goto restart;
				    }
				    value = db_get_task_value(next_addr, sz,
							      TRUE, task);
				    db_printf("%-*llD", width, (unsigned long long)value);
				    next_addr += sz;
				}
				break;
			    case 'U':	/* unsigned decimal */
			    case 'u':
				for (sz = size, next_addr = addr;
				     sz >= (signed)sizeof (db_expr_t);
				     sz -= sizeof (db_expr_t)) {
				    if (nitems-- == 0) {
					db_putchar('\n');
					goto restart;
				    }
				    value = db_get_task_value(next_addr,
							      sizeof (db_expr_t),
							      FALSE,task);
				    db_printf("%-*llu", width, (unsigned long long)value);
				    next_addr += sizeof (db_expr_t);
				}
				if (sz > 0) {
				    if (nitems-- == 0) {
					db_putchar('\n');
					goto restart;
				    }
				    value = db_get_task_value(next_addr, sz,
							      FALSE, task);
				    db_printf("%-*llU", width, (unsigned long long)value);
				    next_addr += sz;
				}
				break;
			    case 'o':	/* unsigned octal */
				for (sz = size, next_addr = addr;
				     sz >= (signed)sizeof (db_expr_t);
				     sz -= sizeof (db_expr_t)) {
				    if (nitems-- == 0) {
					db_putchar('\n');
					goto restart;
				    }
				    value = db_get_task_value(next_addr,
							      sizeof (db_expr_t),
							      FALSE,task);
				    db_printf("%-*llo", width, (unsigned long long)value);
				    next_addr += sizeof (db_expr_t);
				}
				if (sz > 0) {
				    if (nitems-- == 0) {
					db_putchar('\n');
					goto restart;
				    }
				    value = db_get_task_value(next_addr, sz,
							      FALSE, task);
				    db_printf("%-*llo", width, (unsigned long long)value);
				    next_addr += sz;
				}
				break;
			    case 'c':	/* character */
				for (sz = 0, next_addr = addr;
				     sz < size;
				     sz++, next_addr++) {
				    value = db_get_task_value(next_addr,1,
							      FALSE,task);
				    if ((value >= ' ' && value <= '~') ||
					value == '\n' ||
					value == '\t')
					    db_printf("%llc", (unsigned long long)value);
				    else
					    db_printf("\\%03llo", (unsigned long long)value);
				}
				break;
			    case 's':	/* null-terminated string */
				size = 0;
				for (;;) {
				    value = db_get_task_value(next_addr,1,
							      FALSE,task);
				    next_addr += 1;
				    size++;
				    if (value == 0)
					break;
				    if (value >= ' ' && value <= '~')
					db_printf("%llc", (unsigned long long)value);
				    else
					db_printf("\\%03llo", (unsigned long long)value);
				}
				break;
			    case 'i':	/* instruction */
				next_addr = db_disasm(addr, FALSE, task);
				size = next_addr - addr;
				break;
			    case 'I':	/* instruction, alternate form */
				next_addr = db_disasm(addr, TRUE, task);
				size = next_addr - addr;
				break;
			    default:
				break;
			}
			if (db_print_position() != 0)
			    db_end_line();
			break;
		}
	    }
	    addr = next_addr;
	}
	db_next = addr;
}

/*
 * Print value.
 */
char	db_print_format = 'x';

void
db_print_cmd(void)
{
	db_expr_t	value;
	int		t;
	task_t		task = TASK_NULL;

	if ((t = db_read_token()) == tSLASH) {
	    if (db_read_token() != tIDENT) {
		db_printf("Bad modifier \"/%s\"\n", db_tok_string);
		db_error(0);
		/* NOTREACHED */
	    }
	    if (db_tok_string[0])
		db_print_format = db_tok_string[0];
	    if (db_option(db_tok_string, 't')) {
		if (db_default_act)
		    task = db_default_act->task;
		if (db_print_format == 't')
		   db_print_format = db_tok_string[1];
	    }
	} else
	    db_unread_token(t);
	
	for ( ; ; ) {
	    t = db_read_token();
	    if (t == tSTRING) {
		db_printf("%s", db_tok_string);
		continue;
	    }
	    db_unread_token(t);
	    if (!db_expression(&value))
		break;
	    switch (db_print_format) {
	    case 'a':
	    case 'A':
		db_task_printsym((db_addr_t)value,
				 (db_print_format == 'a') ? DB_STGY_ANY:
				 			    DB_STGY_PROC,
				 task);
		break;
	    case 'r':
		db_printf("%11llr", (unsigned long long)value);
		break;
	    case 'X':
		db_printf("%016llX", (unsigned long long)value);
		break;
	    case 'x':
		db_printf("%016llx", (unsigned long long)value);
		break;
	    case 'z':
		db_printf("%16llz", (unsigned long long)value);
		break;
	    case 'd':
		db_printf("%11lld", (unsigned long long)value);
		break;
	    case 'u':
		db_printf("%11llu", (unsigned long long)value);
		break;
	    case 'o':
		db_printf("%16llo", (unsigned long long)value);
		break;
	    case 'c':
		value = value & 0xFF;
		if (value >= ' ' && value <= '~')
		    db_printf("%llc", (unsigned long long)value);
		else
		    db_printf("\\%03llo", (unsigned long long)value);
		break;
	    default:
		db_printf("Unknown format %c\n", db_print_format);
		db_print_format = 'x';
		db_error(0);
	    }
	}
}

void
db_print_loc(
	db_addr_t       loc,
	task_t          task)
{
	db_task_printsym(loc, DB_STGY_PROC, task);
}

void
db_print_inst(
	db_addr_t       loc,
	task_t          task)
{
	(void) db_disasm(loc, TRUE, task);
}

void
db_print_loc_and_inst(
	db_addr_t	loc,
	task_t		task)
{
	db_task_printsym(loc, DB_STGY_PROC, task);
	db_printf(":\t");
	(void) db_disasm(loc, TRUE, task);
}

/*
 * Search for a value in memory.
 * Syntax: search [/bhl] addr value [mask] [,count] [thread]
 */
void
db_search_cmd(void)
{
	int		t;
	db_addr_t	addr;
	int		size = 0;
	db_expr_t	value;
	db_expr_t	mask;
	db_addr_t	count;
	thread_t	thr_act;
	boolean_t	thread_flag = FALSE;
	register char	*p;

	t = db_read_token();
	if (t == tSLASH) {
	    t = db_read_token();
	    if (t != tIDENT) {
	      bad_modifier:
		db_printf("Bad modifier \"/%s\"\n", db_tok_string);
		db_flush_lex();
		return;
	    }

	    for (p = db_tok_string; *p; p++) {
		switch(*p) {
		case 'b':
		    size = sizeof(char);
		    break;
		case 'h':
		    size = sizeof(short);
		    break;
		case 'l':
		    size = sizeof(long);
		    break;
		case 't':
		    thread_flag = TRUE;
		    break;
		default:
		    goto bad_modifier;
		}
	    }
	} else {
	    db_unread_token(t);
	    size = sizeof(int);
	}

	if (!db_expression((db_expr_t *) &addr)) {
	    db_printf("Address missing\n");
	    db_flush_lex();
	    return;
	}

	if (!db_expression(&value)) {
	    db_printf("Value missing\n");
	    db_flush_lex();
	    return;
	}

	if (!db_expression(&mask))
	    mask = ~0;

	t = db_read_token();
	if (t == tCOMMA) {
	    if (!db_expression((db_expr_t *) &count)) {
		db_printf("Count missing\n");
		db_flush_lex();
		return;
	    }
	} else {
	    db_unread_token(t);
	    count = -1;		/* effectively forever */
	}
	if (thread_flag) {
	    if (!db_get_next_act(&thr_act, 0))
		return;
	} else
	    thr_act = THREAD_NULL;

	db_search(addr, size, value, mask, count, db_act_to_task(thr_act));
}

void
db_search(
	db_addr_t	addr,
	int		size,
	db_expr_t	value,
	db_expr_t	mask,
	unsigned int	count,
	task_t		task)
{
	while (count-- != 0) {
		db_prev = addr;
		if ((db_get_task_value(addr,size,FALSE,task) & mask) == value)
			break;
		addr += size;
	}
	db_printf("0x%llx: ", (unsigned long long)addr);
	db_next = addr;
}

#define DB_XCDUMP_NC	16

int
db_xcdump(
	db_addr_t	addr,
	int		size,
	int		count,
	task_t		task)
{
	register int 	i, n;
	db_expr_t	value;
	int		bcount;
	db_addr_t	off;
	char		*name;
	char		data[DB_XCDUMP_NC];

	db_find_task_sym_and_offset(addr, &name, &off, task);
	for (n = count*size; n > 0; n -= bcount) {
	    db_prev = addr;
	    if (off == 0) {
		db_printf("%s:\n", name);
		off = -1;
	    }
	    db_printf("%0*llX:%s", 2*sizeof(db_addr_t),(unsigned long long) addr,
					(size != 1) ? " " : "" );
	    bcount = ((n > DB_XCDUMP_NC)? DB_XCDUMP_NC: n);
	    if (trunc_page_32(addr) != trunc_page_32(addr+bcount-1)) {
		db_addr_t next_page_addr = trunc_page_32(addr+bcount-1);
		if (!DB_CHECK_ACCESS(next_page_addr, sizeof(int), task))
		    bcount = next_page_addr - addr;
	    }
	    db_read_bytes((vm_offset_t)addr, bcount, data, task);
	    for (i = 0; i < bcount && off != 0; i += size) {
		if (i % 4 == 0)
			db_printf(" ");
		value = db_get_task_value(addr, size, FALSE, task);
		db_printf("%0*llX ", size*2, (unsigned long long)value);
		addr += size;
		db_find_task_sym_and_offset(addr, &name, &off, task);
	    }
	    db_printf("%*s",
			((DB_XCDUMP_NC-i)/size)*(size*2+1)+(DB_XCDUMP_NC-i)/4,
			 "");
	    bcount = i;
	    db_printf("%s*", (size != 1)? " ": "");
	    for (i = 0; i < bcount; i++) {
		value = data[i];
		db_printf("%llc", (value >= ' ' && value <= '~')? (unsigned long long)value: (unsigned long long)'.');
	    }
	    db_printf("*\n");
	}
	return(addr);
}
Commit	Line	Data
1c79356b	1	/*
2d21ac55	2	* Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
1c79356b	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
2d21ac55 A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
8f6c56a5	14	*
2d21ac55 A	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
8f6c56a5	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/*
	29	* @OSF_COPYRIGHT@
	30	*/
1c79356b A	31	/*
	32	* Mach Operating System
	33	* Copyright (c) 1991,1990 Carnegie Mellon University
	34	* All Rights Reserved.
	35	*
	36	* Permission to use, copy, modify and distribute this software and its
	37	* documentation is hereby granted, provided that both the copyright
	38	* notice and this permission notice appear in all copies of the
	39	* software, derivative works or modified versions, and any portions
	40	* thereof, and that both notices appear in supporting documentation.
	41	*
	42	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
	43	* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
	44	* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
	45	*
	46	* Carnegie Mellon requests users of this software to return to
	47	*
	48	* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
	49	* School of Computer Science
	50	* Carnegie Mellon University
	51	* Pittsburgh PA 15213-3890
	52	*
	53	* any improvements or extensions that they make and grant Carnegie Mellon
	54	* the rights to redistribute these changes.
	55	*/
	56	/*
	57	*/
	58	/*
	59	* Author: David B. Golub, Carnegie Mellon University
	60	* Date: 7/90
	61	*/
2d21ac55	62	#include <string.h> /* For strlcpy() */
1c79356b A	63	#include <mach/boolean.h>
	64	#include <machine/db_machdep.h>
	65
	66	#include <ddb/db_access.h>
	67	#include <ddb/db_lex.h>
	68	#include <ddb/db_output.h>
	69	#include <ddb/db_command.h>
	70	#include <ddb/db_sym.h>
	71	#include <ddb/db_task_thread.h>
	72	#include <ddb/db_command.h> /* For db_option() */
	73	#include <ddb/db_examine.h>
	74	#include <ddb/db_expr.h>
	75	#include <kern/thread.h>
	76	#include <kern/task.h>
	77	#include <mach/vm_param.h>
	78
	79	#define db_act_to_task(thr_act) ((thr_act)? thr_act->task: TASK_NULL)
	80
	81	char db_examine_format[TOK_STRING_SIZE] = "x";
	82	int db_examine_count = 1;
	83	db_addr_t db_examine_prev_addr = 0;
91447636	84	thread_t db_examine_act = THREAD_NULL;
1c79356b A	85
	86	extern int db_max_width;
	87
	88
	89	/* Prototypes for functions local to this file. XXX -- should be static!
	90	*/
	91	int db_xcdump(
	92	db_addr_t addr,
	93	int size,
	94	int count,
	95	task_t task);
	96
	97	int db_examine_width(
	98	int size,
	99	int *items,
	100	int *remainder);
	101
2d21ac55 A	102	extern char db_last_modifier[];
2d21ac55 A	103
1c79356b A	104	/*
	105	* Examine (print) data.
	106	*/
	107	void
2d21ac55 A	108	db_examine_cmd(db_expr_t addr, __unused boolean_t have_addr, db_expr_t count,
2d21ac55 A	109	char *modif)
1c79356b	110	{
91447636	111	thread_t thr_act;
1c79356b A	112
1c79356b A	113	if (modif[0] != '\0')
2d21ac55	114	strlcpy(db_examine_format, modif, TOK_STRING_SIZE);
1c79356b	115
2d21ac55	116	if (count == (db_expr_t)-1)
1c79356b A	117	count = 1;
	118	db_examine_count = count;
	119	if (db_option(modif, 't')) {
	120	if (modif == db_last_modifier)
	121	thr_act = db_examine_act;
	122	else if (!db_get_next_act(&thr_act, 0))
	123	return;
	124	} else
	125	if (db_option(modif,'u'))
2d21ac55	126	thr_act = current_thread();
1c79356b	127	else
91447636	128	thr_act = THREAD_NULL;
1c79356b A	129
	130	db_examine_act = thr_act;
	131	db_examine((db_addr_t) addr, db_examine_format, count,
	132	db_act_to_task(thr_act));
	133	}
	134
	135	void
2d21ac55 A	136	db_examine_forward(__unused db_expr_t addr, __unused boolean_t have_addr,
2d21ac55 A	137	__unused db_expr_t count, __unused char *modif)
1c79356b A	138	{
	139	db_examine(db_next, db_examine_format, db_examine_count,
	140	db_act_to_task(db_examine_act));
	141	}
	142
	143	void
2d21ac55 A	144	db_examine_backward(__unused db_expr_t addr, __unused boolean_t have_addr,
2d21ac55 A	145	__unused db_expr_t count, __unused char *modif)
1c79356b A	146	{
	147	db_examine(db_examine_prev_addr - (db_next - db_examine_prev_addr),
	148	db_examine_format, db_examine_count,
	149	db_act_to_task(db_examine_act));
	150	}
	151
	152	int
	153	db_examine_width(
	154	int size,
	155	int *items,
	156	int *remainder)
	157	{
	158	int sz;
	159	int entry;
	160	int width;
	161
	162	width = size * 2 + 1;
	163	sz = (db_max_width - (sizeof (void ) 2 + 4)) / width;
	164	for (entry = 1; (entry << 1) < sz; entry <<= 1)
	165	continue;
	166
	167	sz = sizeof (void ) 2 + 4 + entry * width;
	168	while (sz + entry < db_max_width) {
	169	width++;
	170	sz += entry;
	171	}
	172	*remainder = (db_max_width - sz + 1) / 2;
	173	*items = entry;
	174	return width;
	175	}
	176
	177	void
	178	db_examine(
	179	db_addr_t addr,
	180	char * fmt, /* format string */
	181	int count, /* repeat count */
	182	task_t task)
	183	{
	184	int c;
	185	db_expr_t value;
	186	int size;
	187	int width;
	188	int leader;
	189	int items;
2d21ac55	190	int nitems = 0;
1c79356b	191	char * fp;
2d21ac55	192	db_addr_t next_addr = 0;
1c79356b A	193	int sz;
	194
	195	db_examine_prev_addr = addr;
	196	while (--count >= 0) {
	197	fp = fmt;
	198	size = sizeof(int);
	199	width = db_examine_width(size, &items, &leader);
	200	while ((c = *fp++) != 0) {
	201	switch (c) {
	202	case 'b':
	203	size = sizeof(char);
	204	width = db_examine_width(size, &items, &leader);
	205	break;
	206	case 'h':
	207	size = sizeof(short);
	208	width = db_examine_width(size, &items, &leader);
	209	break;
	210	case 'l':
	211	size = sizeof(int);
	212	width = db_examine_width(size, &items, &leader);
	213	break;
	214	case 'q':
	215	size = sizeof(long);
	216	width = db_examine_width(size, &items, &leader);
	217	break;
	218	case 'a': /* address */
	219	case 'A': /* function address */
	220	/* always forces a new line */
	221	if (db_print_position() != 0)
	222	db_printf("\n");
	223	db_prev = addr;
	224	next_addr = addr + 4;
	225	db_task_printsym(addr,
	226	(c == 'a')?DB_STGY_ANY:DB_STGY_PROC,
	227	task);
	228	db_printf(":\t");
	229	break;
	230	case 'm':
	231	db_next = db_xcdump(addr, size, count+1, task);
	232	return;
	233	case 't':
	234	case 'u':
	235	break;
	236	default:
	237	restart:
	238	/* Reset next_addr in case we are printing in
	239	multiple formats. */
	240	next_addr = addr;
	241	if (db_print_position() == 0) {
	242	/* If we hit a new symbol, print it */
	243	char * name;
	244	db_addr_t off;
	245
	246	db_find_task_sym_and_offset(addr,&name,&off,task);
	247	if (off == 0)
	248	db_printf("\r%s:\n", name);
91447636	249	db_printf("%#lln: ", (unsigned long long)addr);
1c79356b A	250	for (sz = 0; sz < leader; sz++)
	251	db_putchar(' ');
	252	db_prev = addr;
	253	nitems = items;
	254	}
	255
	256	switch (c) {
	257	case 'p': /* Addrs rendered symbolically. */
	258	if( size == sizeof(void *) ) {
	259	char *symName;
	260	db_addr_t offset;
	261
	262	items = 1;
	263	value = db_get_task_value( next_addr,
	264	sizeof(db_expr_t), FALSE, task );
	265	db_find_task_sym_and_offset( value,
	266	&symName, &offset, task);
55e303ae	267	db_printf("\n\t*%8llX(%8llX) = %s",
91447636	268	(unsigned long long)next_addr, (unsigned long long)value, symName );
1c79356b	269	if( offset ) {
91447636	270	db_printf("+%llX", (unsigned long long)offset );
1c79356b A	271	}
	272	next_addr += size;
	273	}
	274	break;
	275	case 'r': /* signed, current radix */
	276	for (sz = size, next_addr = addr;
2d21ac55	277	sz >= (signed)sizeof (db_expr_t);
1c79356b A	278	sz -= sizeof (db_expr_t)) {
	279	if (nitems-- == 0) {
	280	db_putchar('\n');
	281	goto restart;
	282	}
	283	value = db_get_task_value(next_addr,
	284	sizeof (db_expr_t),
	285	TRUE,task);
91447636	286	db_printf("%-*llr", width, (unsigned long long)value);
1c79356b A	287	next_addr += sizeof (db_expr_t);
	288	}
	289	if (sz > 0) {
	290	if (nitems-- == 0) {
	291	db_putchar('\n');
	292	goto restart;
	293	}
	294	value = db_get_task_value(next_addr, sz,
	295	TRUE, task);
91447636	296	db_printf("%-*llR", width, (unsigned long long)value);
1c79356b A	297	next_addr += sz;
	298	}
	299	break;
1c79356b	300	case 'X': /* unsigned hex */
1c79356b A	301	case 'x': /* unsigned hex */
1c79356b A	302	for (sz = size, next_addr = addr;
2d21ac55	303	sz >= (signed)sizeof (db_expr_t);
1c79356b A	304	sz -= sizeof (db_expr_t)) {
	305	if (nitems-- == 0) {
	306	db_putchar('\n');
	307	goto restart;
	308	}
	309	value = db_get_task_value(next_addr,
	310	sizeof (db_expr_t),
	311	FALSE,task);
1c79356b	312	if ( c == 'X')
91447636	313	db_printf("%0llX ", 2size, (unsigned long long)value);
1c79356b	314	else
91447636	315	db_printf("%-*llx", width, (unsigned long long)value);
1c79356b A	316	next_addr += sizeof (db_expr_t);
	317	}
	318	if (sz > 0) {
	319	if (nitems-- == 0) {
	320	db_putchar('\n');
	321	goto restart;
	322	}
	323	value = db_get_task_value(next_addr, sz,
	324	FALSE, task);
1c79356b	325	if ( c == 'X')
91447636	326	db_printf("%0llX ", 2size, (unsigned long long)value);
1c79356b	327	else
91447636	328	db_printf("%-*llX", width, (unsigned long long)value);
1c79356b A	329	next_addr += sz;
	330	}
	331	break;
	332	case 'z': /* signed hex */
	333	for (sz = size, next_addr = addr;
2d21ac55	334	sz >= (signed)sizeof (db_expr_t);
1c79356b A	335	sz -= sizeof (db_expr_t)) {
	336	if (nitems-- == 0) {
	337	db_putchar('\n');
	338	goto restart;
	339	}
	340	value = db_get_task_value(next_addr,
	341	sizeof (db_expr_t),
	342	TRUE, task);
91447636	343	db_printf("%-*llz", width, (unsigned long long)value);
1c79356b A	344	next_addr += sizeof (db_expr_t);
	345	}
	346	if (sz > 0) {
	347	if (nitems-- == 0) {
	348	db_putchar('\n');
	349	goto restart;
	350	}
	351	value = db_get_task_value(next_addr,sz,
	352	TRUE,task);
91447636	353	db_printf("%-*llZ", width, (unsigned long long)value);
1c79356b A	354	next_addr += sz;
	355	}
	356	break;
	357	case 'd': /* signed decimal */
	358	for (sz = size, next_addr = addr;
2d21ac55	359	sz >= (signed)sizeof (db_expr_t);
1c79356b A	360	sz -= sizeof (db_expr_t)) {
	361	if (nitems-- == 0) {
	362	db_putchar('\n');
	363	goto restart;
	364	}
	365	value = db_get_task_value(next_addr,
	366	sizeof (db_expr_t),
	367	TRUE,task);
91447636	368	db_printf("%-*lld", width, (unsigned long long)value);
1c79356b A	369	next_addr += sizeof (db_expr_t);
	370	}
	371	if (sz > 0) {
	372	if (nitems-- == 0) {
	373	db_putchar('\n');
	374	goto restart;
	375	}
	376	value = db_get_task_value(next_addr, sz,
	377	TRUE, task);
91447636	378	db_printf("%-*llD", width, (unsigned long long)value);
1c79356b A	379	next_addr += sz;
	380	}
	381	break;
	382	case 'U': /* unsigned decimal */
	383	case 'u':
	384	for (sz = size, next_addr = addr;
2d21ac55	385	sz >= (signed)sizeof (db_expr_t);
1c79356b A	386	sz -= sizeof (db_expr_t)) {
	387	if (nitems-- == 0) {
	388	db_putchar('\n');
	389	goto restart;
	390	}
	391	value = db_get_task_value(next_addr,
	392	sizeof (db_expr_t),
	393	FALSE,task);
91447636	394	db_printf("%-*llu", width, (unsigned long long)value);
1c79356b A	395	next_addr += sizeof (db_expr_t);
	396	}
	397	if (sz > 0) {
	398	if (nitems-- == 0) {
	399	db_putchar('\n');
	400	goto restart;
	401	}
	402	value = db_get_task_value(next_addr, sz,
	403	FALSE, task);
91447636	404	db_printf("%-*llU", width, (unsigned long long)value);
1c79356b A	405	next_addr += sz;
	406	}
	407	break;
	408	case 'o': /* unsigned octal */
	409	for (sz = size, next_addr = addr;
2d21ac55	410	sz >= (signed)sizeof (db_expr_t);
1c79356b A	411	sz -= sizeof (db_expr_t)) {
	412	if (nitems-- == 0) {
	413	db_putchar('\n');
	414	goto restart;
	415	}
	416	value = db_get_task_value(next_addr,
	417	sizeof (db_expr_t),
	418	FALSE,task);
91447636	419	db_printf("%-*llo", width, (unsigned long long)value);
1c79356b A	420	next_addr += sizeof (db_expr_t);
	421	}
	422	if (sz > 0) {
	423	if (nitems-- == 0) {
	424	db_putchar('\n');
	425	goto restart;
	426	}
	427	value = db_get_task_value(next_addr, sz,
	428	FALSE, task);
91447636	429	db_printf("%-*llo", width, (unsigned long long)value);
1c79356b A	430	next_addr += sz;
	431	}
	432	break;
	433	case 'c': /* character */
	434	for (sz = 0, next_addr = addr;
	435	sz < size;
	436	sz++, next_addr++) {
	437	value = db_get_task_value(next_addr,1,
	438	FALSE,task);
	439	if ((value >= ' ' && value <= '~') \|\|
	440	value == '\n' \|\|
	441	value == '\t')
91447636	442	db_printf("%llc", (unsigned long long)value);
1c79356b	443	else
91447636	444	db_printf("\\%03llo", (unsigned long long)value);
1c79356b A	445	}
	446	break;
	447	case 's': /* null-terminated string */
	448	size = 0;
	449	for (;;) {
	450	value = db_get_task_value(next_addr,1,
	451	FALSE,task);
	452	next_addr += 1;
	453	size++;
	454	if (value == 0)
	455	break;
	456	if (value >= ' ' && value <= '~')
91447636	457	db_printf("%llc", (unsigned long long)value);
1c79356b	458	else
91447636	459	db_printf("\\%03llo", (unsigned long long)value);
1c79356b A	460	}
	461	break;
	462	case 'i': /* instruction */
	463	next_addr = db_disasm(addr, FALSE, task);
	464	size = next_addr - addr;
	465	break;
	466	case 'I': /* instruction, alternate form */
	467	next_addr = db_disasm(addr, TRUE, task);
	468	size = next_addr - addr;
	469	break;
	470	default:
	471	break;
	472	}
	473	if (db_print_position() != 0)
	474	db_end_line();
	475	break;
	476	}
	477	}
	478	addr = next_addr;
	479	}
	480	db_next = addr;
	481	}
	482
	483	/*
	484	* Print value.
	485	*/
	486	char db_print_format = 'x';
	487
	488	void
	489	db_print_cmd(void)
	490	{
	491	db_expr_t value;
	492	int t;
	493	task_t task = TASK_NULL;
	494
	495	if ((t = db_read_token()) == tSLASH) {
	496	if (db_read_token() != tIDENT) {
	497	db_printf("Bad modifier \"/%s\"\n", db_tok_string);
	498	db_error(0);
	499	/* NOTREACHED */
	500	}
	501	if (db_tok_string[0])
	502	db_print_format = db_tok_string[0];
	503	if (db_option(db_tok_string, 't')) {
	504	if (db_default_act)
	505	task = db_default_act->task;
	506	if (db_print_format == 't')
	507	db_print_format = db_tok_string[1];
	508	}
	509	} else
	510	db_unread_token(t);
	511
	512	for ( ; ; ) {
	513	t = db_read_token();
	514	if (t == tSTRING) {
	515	db_printf("%s", db_tok_string);
	516	continue;
	517	}
	518	db_unread_token(t);
	519	if (!db_expression(&value))
	520	break;
	521	switch (db_print_format) {
	522	case 'a':
	523	case 'A':
524	db_task_printsym((db_addr_t)value,
525	(db_print_format == 'a') ? DB_STGY_ANY:
526	DB_STGY_PROC,
527	task);
528	break;
529	case 'r':
91447636	530	db_printf("%11llr", (unsigned long long)value);
55e303ae A	531	break;
55e303ae A	532	case 'X':
91447636	533	db_printf("%016llX", (unsigned long long)value);
1c79356b A	534	break;
1c79356b A	535	case 'x':
91447636	536	db_printf("%016llx", (unsigned long long)value);
1c79356b A	537	break;
1c79356b A	538	case 'z':
91447636	539	db_printf("%16llz", (unsigned long long)value);
1c79356b A	540	break;
1c79356b A	541	case 'd':
91447636	542	db_printf("%11lld", (unsigned long long)value);
1c79356b A	543	break;
1c79356b A	544	case 'u':
91447636	545	db_printf("%11llu", (unsigned long long)value);
1c79356b A	546	break;
1c79356b A	547	case 'o':
91447636	548	db_printf("%16llo", (unsigned long long)value);
1c79356b A	549	break;
	550	case 'c':
	551	value = value & 0xFF;
	552	if (value >= ' ' && value <= '~')
91447636	553	db_printf("%llc", (unsigned long long)value);
1c79356b	554	else
91447636	555	db_printf("\\%03llo", (unsigned long long)value);
1c79356b A	556	break;
	557	default:
	558	db_printf("Unknown format %c\n", db_print_format);
	559	db_print_format = 'x';
	560	db_error(0);
	561	}
	562	}
	563	}
	564
	565	void
	566	db_print_loc(
	567	db_addr_t loc,
	568	task_t task)
	569	{
	570	db_task_printsym(loc, DB_STGY_PROC, task);
	571	}
	572
	573	void
	574	db_print_inst(
	575	db_addr_t loc,
	576	task_t task)
	577	{
	578	(void) db_disasm(loc, TRUE, task);
	579	}
	580
	581	void
	582	db_print_loc_and_inst(
	583	db_addr_t loc,
	584	task_t task)
	585	{
	586	db_task_printsym(loc, DB_STGY_PROC, task);
	587	db_printf(":\t");
	588	(void) db_disasm(loc, TRUE, task);
	589	}
	590
	591	/*
	592	* Search for a value in memory.
	593	* Syntax: search [/bhl] addr value [mask] [,count] [thread]
	594	*/
	595	void
	596	db_search_cmd(void)
	597	{
	598	int t;
	599	db_addr_t addr;
	600	int size = 0;
	601	db_expr_t value;
	602	db_expr_t mask;
	603	db_addr_t count;
91447636	604	thread_t thr_act;
1c79356b A	605	boolean_t thread_flag = FALSE;
	606	register char *p;
	607
	608	t = db_read_token();
	609	if (t == tSLASH) {
	610	t = db_read_token();
	611	if (t != tIDENT) {
	612	bad_modifier:
	613	db_printf("Bad modifier \"/%s\"\n", db_tok_string);
	614	db_flush_lex();
	615	return;
	616	}
	617
	618	for (p = db_tok_string; *p; p++) {
	619	switch(*p) {
	620	case 'b':
	621	size = sizeof(char);
	622	break;
	623	case 'h':
	624	size = sizeof(short);
	625	break;
	626	case 'l':
	627	size = sizeof(long);
	628	break;
	629	case 't':
	630	thread_flag = TRUE;
	631	break;
	632	default:
	633	goto bad_modifier;
	634	}
	635	}
	636	} else {
	637	db_unread_token(t);
	638	size = sizeof(int);
	639	}
	640
	641	if (!db_expression((db_expr_t *) &addr)) {
	642	db_printf("Address missing\n");
	643	db_flush_lex();
	644	return;
	645	}
	646
	647	if (!db_expression(&value)) {
	648	db_printf("Value missing\n");
	649	db_flush_lex();
	650	return;
	651	}
	652
	653	if (!db_expression(&mask))
	654	mask = ~0;
	655
	656	t = db_read_token();
	657	if (t == tCOMMA) {
	658	if (!db_expression((db_expr_t *) &count)) {
	659	db_printf("Count missing\n");
	660	db_flush_lex();
	661	return;
	662	}
	663	} else {
	664	db_unread_token(t);
	665	count = -1; /* effectively forever */
	666	}
	667	if (thread_flag) {
	668	if (!db_get_next_act(&thr_act, 0))
669	return;
670	} else
91447636	671	thr_act = THREAD_NULL;
1c79356b A	672
	673	db_search(addr, size, value, mask, count, db_act_to_task(thr_act));
	674	}
	675
	676	void
	677	db_search(
	678	db_addr_t addr,
	679	int size,
	680	db_expr_t value,
	681	db_expr_t mask,
	682	unsigned int count,
	683	task_t task)
	684	{
	685	while (count-- != 0) {
	686	db_prev = addr;
	687	if ((db_get_task_value(addr,size,FALSE,task) & mask) == value)
	688	break;
	689	addr += size;
	690	}
91447636	691	db_printf("0x%llx: ", (unsigned long long)addr);
1c79356b A	692	db_next = addr;
	693	}
	694
	695	#define DB_XCDUMP_NC 16
	696
	697	int
	698	db_xcdump(
	699	db_addr_t addr,
	700	int size,
	701	int count,
	702	task_t task)
	703	{
	704	register int i, n;
	705	db_expr_t value;
	706	int bcount;
	707	db_addr_t off;
	708	char *name;
	709	char data[DB_XCDUMP_NC];
	710
	711	db_find_task_sym_and_offset(addr, &name, &off, task);
	712	for (n = count*size; n > 0; n -= bcount) {
	713	db_prev = addr;
	714	if (off == 0) {
	715	db_printf("%s:\n", name);
	716	off = -1;
	717	}
91447636	718	db_printf("%0llX:%s", 2sizeof(db_addr_t),(unsigned long long) addr,
1c79356b A	719	(size != 1) ? " " : "" );
1c79356b A	720	bcount = ((n > DB_XCDUMP_NC)? DB_XCDUMP_NC: n);
55e303ae A	721	if (trunc_page_32(addr) != trunc_page_32(addr+bcount-1)) {
55e303ae A	722	db_addr_t next_page_addr = trunc_page_32(addr+bcount-1);
1c79356b A	723	if (!DB_CHECK_ACCESS(next_page_addr, sizeof(int), task))
	724	bcount = next_page_addr - addr;
	725	}
	726	db_read_bytes((vm_offset_t)addr, bcount, data, task);
	727	for (i = 0; i < bcount && off != 0; i += size) {
	728	if (i % 4 == 0)
	729	db_printf(" ");
	730	value = db_get_task_value(addr, size, FALSE, task);
91447636	731	db_printf("%0llX ", size2, (unsigned long long)value);
1c79356b A	732	addr += size;
	733	db_find_task_sym_and_offset(addr, &name, &off, task);
	734	}
	735	db_printf("%*s",
	736	((DB_XCDUMP_NC-i)/size)(size2+1)+(DB_XCDUMP_NC-i)/4,
	737	"");
	738	bcount = i;
	739	db_printf("%s*", (size != 1)? " ": "");
	740	for (i = 0; i < bcount; i++) {
	741	value = data[i];
91447636	742	db_printf("%llc", (value >= ' ' && value <= '~')? (unsigned long long)value: (unsigned long long)'.');
1c79356b A	743	}
	744	db_printf("*\n");
	745	}
	746	return(addr);
	747	}