/kernel/ttd/ttd_server.c

/* 
 * Mach Operating System
 * Copyright (c) 1993,1992 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.
 */
/*
 * TTD Communications parsing code for the kernel ttd server.
 *
 * HISTORY:
 * $Log:	ttd_server.c,v $
 * Revision 2.2  93/05/10  23:24:51  rvb
 * 	Checkin for MK80 branch.
 * 	[93/05/10  15:08:55  grm]
 * 
 * Revision 2.1.2.3  93/04/20  11:06:02  grm
 * 	Changed types for use with a more universal protocol.  Added code
 * 	to support the use of multiple endian machines.  Alignment code
 * 	added.
 * 	[93/04/20            grm]
 * 
 * Revision 2.1.2.2  93/03/29  16:30:24  grm
 * 	Version for protocol 2.2
 * 	[93/03/29            grm]
 * 
 * Revision 2.1.2.1  93/03/03  14:41:22  grm
 * 	Second version of code.  It works.
 * 	[93/03/03            grm]
 * 
 * Revision 2.1.1.8  93/01/28  15:14:51  grm
 * 	Added ttd_loop_type.  Last checkin before locore rewrite.
 * 
 * Revision 2.1.1.7  93/01/22  15:52:52  grm
 * 	Added request length checks.
 * 
 * Revision 2.1.1.6  93/01/21  13:03:49  grm
 * 	Changed to Ansi C prototypes.  Added kttd_debug statements.
 * 
 * Revision 2.1.1.5  92/10/30  12:44:18  grm
 * 	Fixed single stepping and set_state_action bug.
 * 	[92/10/30            grm]
 * 
 * Revision 2.1.1.4  92/10/23  21:21:39  grm
 * 	Added first pass at single stepping code.  Fixed bug in
 * 	stop/restart logic.
 * 	[92/10/23            grm]
 * 
 * Revision 2.1.1.3  92/10/08  14:29:28  grm
 * 	Fixed clear_breakpoint function.  Added some debugging code.
 * 	[92/10/08            grm]
 * 
 * Revision 2.1.1.2  92/10/01  15:36:54  grm
 * 	KTTD restructuring checkpoint.
 * 	[92/10/01            grm]
 * 
 * Revision 2.1.1.1  92/09/25  15:10:26  grm
 * 	Initial checkin.
 * 	[92/09/25            grm]
 * 
 */
/***********************************************************
Copyright 1992 by Digital Equipment Corporation, Maynard, Massachusetts,

                        All Rights Reserved

Permission to use, copy, modify, and distribute this software and its 
documentation for any purpose and without fee is hereby granted, provided 
that the above copyright notice appear in all copies and that both that 
copyright notice and this permission notice appear in supporting 
documentation, and that the name of Digital not be used in advertising 
or publicity pertaining to distribution of the software without specific, 
written prior permission.  Digital makes no representations about the 
suitability of this software for any purpose.  It is provided "as is"
without express or implied warranty.

DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.

******************************************************************/

#include <mach/boolean.h>
#include <mach/vm_param.h>

#include <ttd/ttd_comm.h>
#include <ttd/ttd_types.h>
#include <ttd/ttd_msg.h>
#include <ttd/kernel_ttd.h>
#include <ttd/ttd_stub.h>
#include <ttd/ttd_server.h>
#include <ttd/ttd_debug.h>

struct ttd_reply	prev_reply;         /* saved reply for idempotency */
natural_t		prev_reply_length;
ttd_operation		prev_operation;

static boolean_t	ttd_server_initialized;

#define END_ADDRESS(x) ((ttd_address)((natural_t)&(x) + sizeof(x)))

#define TTD_KMSG(kmsg)	((kmsg == NULL) ? ttd_request_msg : kmsg)

#define target_is_kernel(target) (target == TTD_KERNEL_MID)

#define target_stopped() kttd_target.is_stopped

#define valid_count(count) (count <= TTD_MAX_BLOCK_SIZE)

/*
 * Aligned TTD Request.
 */
struct ttd_request aligned_request;

/*
 * Kernel target state:
 */
boolean_t		kttd_single_stepping = FALSE;
ttd_seq			kttd_current_seq;

kttd_breakpoint		kttd_breaktable[KTTD_MAXBPT];
ttd_target_info		kttd_target;

ttd_machine_type	ttd_target_machine_type;

/*
 * Used by the ttd_stub code. 
 */
void kttd_stop_target(void)
{
	kttd_target.is_stopped = TRUE;
}

/*
 * Used by the machine dependent code for single stepping.
 */
boolean_t break_set(ttd_address addr,
		    ttd_saved_inst *inst)
{
	kttd_breakno b;
	
	for (b = 0; b < KTTD_MAXBPT; b++) {
		if ((!kttd_breaktable[b].free) &&
		    (kttd_breaktable[b].address == addr)) {
			*inst = kttd_breaktable[b].saved_inst;
			return TRUE; 
		}
	}
	return FALSE;
}

/*
 * Misc. routines for this module:
 */
static boolean_t find_break(ttd_address addr,
		     ttd_thread thread,
		     kttd_breakno *bn)
{
	kttd_breakno b;
	
	for (b = 0; b < KTTD_MAXBPT; b++) {
		if ((!kttd_breaktable[b].free) &&
		    (kttd_breaktable[b].address == addr) &&
		    (kttd_breaktable[b].thread == thread)) {
			*bn = b;
			return TRUE; 
		}
	}
	return FALSE;
}

static boolean_t find_free_breakentry(kttd_breakno *breakno)
{
	kttd_breakno	b;

	for(b = 0; b < KTTD_MAXBPT; b++) {
		if (kttd_breaktable[b].free) {
			*breakno = b;
			return TRUE;
		}
	}
	return FALSE;
}

static boolean_t valid_thread(ttd_thread thread)
{
	/* XXX Fix... */

	return TRUE;
}

static void init_break_table(void)
{
	kttd_breakno bn;
	
	for (bn = 0; bn < KTTD_MAXBPT; bn++)
		kttd_breaktable[bn].free = TRUE;
}

static void init_kernel_target(void)
{
	kttd_target.is_targeted = FALSE;
	kttd_target.is_stopped = FALSE;
	kttd_target.trapped_thread = 0;

	kttd_current_seq = 0x7fffffff;

	init_break_table();

	kttd_single_stepping = FALSE;
}

/*
 * Check to see if this message is a duplicate.  Updates
 * the current sequence number as a side effect.
 */
static boolean_t duplicate(ttd_seq s)
{
	boolean_t dup;
	
	dup = (kttd_current_seq == s);
	if (kttd_debug && (s < kttd_current_seq))
		printf("TTD:duplicate, SRC code bites us here.\n");
	kttd_current_seq = s;
				
	return dup;
}

/*
 * Note: since the kernel is the only kttd target, the target is
 * implicit.
 */
static void get_kernel_target_info(ttd_target_info *ti)
{
	ti->is_stopped = kttd_target.is_stopped;
	ti->is_targeted = kttd_target.is_targeted;
	ti->trapped_thread = 1;		/* XXX Fix */
	ti->debug_reason.length = 0;
#if	NOT_NOW
	strcpy("Hi!", ti->debug_reason.chars);
#endif	/* NOT_NOW */
}

/*******************/
/* Action Routines */
/*******************/

/*
 * Read and write to kernel VM.
 */
static ttd_code_t read_write_action(vm_prot_t	access,
				    ttd_address	mem_ptr,
				    ttd_address	buffer,
				    ttd_count	length)
{
	vm_size_t	size;

	/*
	 *	handle this in pages
	 */
	while (length > 0) {
		/*
		 *	get the number of bytes that we can
		 *	access in this page
		 */
		size = trunc_page(mem_ptr + PAGE_SIZE) - mem_ptr;
		if (length < size)
			size = length;
		
		if (!kttd_mem_access(mem_ptr, access)) {
			if (kttd_debug)
				printf("can't read memory\n");
			return MemoryReferenceFailed;
		}
		
		/*
		 *	we can move anything on this page
		 */
		if (access & VM_PROT_WRITE) {
			bcopy(buffer, mem_ptr, size);
			kttd_flush_cache(mem_ptr, size);
		}else if (access & VM_PROT_READ) {
			bcopy(mem_ptr, buffer, size);
		}else{
			return InvalidArgument;
		}

		mem_ptr += size;
		buffer += size;
		length -= size;
	}

	return Okay;
}

/*
 * XXX Fix it.
 */
static boolean_t get_next_thread_action(ttd_thread *thread)
{
#if	0
	boolean_t found_prev;
	hardware_processor_number p;
	
	found_prev = (*thread == 0);
	for (p = 0; p < hardware_max_processors; p++) {
		if (ISIN (heaP->up, p)) {
			if (found_prev) {
				*thread = current_thread(p);
				return TRUE;
			}
			found_prev = (*thread == Current_thread(p));
		}
	}
	*thread = 0;
	return found_prev;
#endif
}

static void get_state_action(ttd_thread		thread,
			     ttd_thread_info	*thread_info,
			     ttd_trap_info	*trap_info,
			     ttd_machine_state	*machine_state)
{
	/*
	 * Don't do the thread_info, or trap_info now. XXX Fix it?
	 */
	kttd_machine_getregs(machine_state);
}

static void set_state_action(ttd_thread		thread,
			     ttd_thread_info	*thread_info,
			     ttd_trap_info	*trap_info,
			     ttd_machine_state	*machine_state)
{
	/*
	 * Don't do the thread_info, or trap_info now either. XXX Fix it?
	 */

	kttd_machine_setregs(machine_state);
}

static void insert_break(kttd_breakno	bn,
			 ttd_address	addr,
			 ttd_thread	thread,
			 ttd_flavor	flavor,
			 ttd_saved_inst	saved_inst)
{
	kttd_breaktable[bn].free	= FALSE;
	kttd_breaktable[bn].address	= addr;
	kttd_breaktable[bn].thread	= thread;
	kttd_breaktable[bn].flavor	= flavor;
	kttd_breaktable[bn].saved_inst	= saved_inst;
}

static ttd_code_t set_break_action(ttd_address	addr,
				   ttd_thread	thread,
				   ttd_flavor	flavor,
				   ttd_saved_inst	*saved_inst)
{
	kttd_breakno	bn;
	boolean_t	found = FALSE;

	/*
	 * Check to see if a breakpoint is already set there for a
	 * different thread.
	 */
	for(bn = 0; bn < KTTD_MAXBPT; bn++) {
		if (!kttd_breaktable[bn].free &&
		    (kttd_breaktable[bn].address == addr)) {
			*saved_inst = kttd_breaktable[bn].saved_inst;
			found = TRUE;
			break;
		}
	}

	/*
	 * Get a free table entry.
	 */
	if (!find_free_breakentry(&bn))
		return TooManyBreakpoints;
	
	/*
	 * Insert into table if already have saved_inst.
	 */
	if (found) {
		insert_break(bn, addr, thread, flavor, *saved_inst);
		return Okay;
	}

	/*
	 * Fault in memory if not available.
	 */
	if (!kttd_mem_access(addr, VM_PROT_WRITE))
		return MemoryReferenceFailed;

	/*
	 * Insert the breakpoint into physical memory and flush the
	 * cache.
	 */
	if (!kttd_insert_breakpoint(addr, saved_inst))
		return MemoryReferenceFailed;

	kttd_flush_cache(addr, sizeof(ttd_saved_inst));
	
	/*
	 * Insert breakpoint into table.
	 */

	insert_break(bn, addr, thread, flavor, *saved_inst);

	if (kttd_debug) {
		printf("Inserting breakpoint into table at bn = %d\n",bn);
	}

	return Okay;
}

static ttd_code_t clear_break_action(ttd_address addr, ttd_thread thread)
{
	kttd_breakno	b;
	kttd_breakno	bn = 0;
	ttd_count	count = 0;
	ttd_saved_inst	saved_inst;
	boolean_t	found = FALSE;
	
	/*
	 * Cycle through breaktable.  If more than one breakpoint
	 * at addr, we know not to replace memory with saved_inst.
	 */
	for(b = 0; b < KTTD_MAXBPT; b++) {
		if (!kttd_breaktable[b].free &&
		    (kttd_breaktable[b].address == addr)) {
			if (kttd_breaktable[b].thread == thread) {
				found = TRUE;
				bn = b;
			}
			if (++count > 1) {
				break;
			}
		}
	}

	/*
	 * Didn't find breakpoint in table, return
	 */
	if (!found) {
		if (kttd_debug) {
			printf("Couldn't find breakpoint in table.\n");
		}
		return InvalidArgument;
	}

	/*
	 * Only one breakpoint at that address, fault in memory
	 * and clear the breakpoint.
	 */
	if (count == 1) {
		if (!kttd_mem_access(addr, VM_PROT_WRITE))
			return MemoryReferenceFailed;
		
		saved_inst = kttd_breaktable[bn].saved_inst;

		if (!kttd_remove_breakpoint(addr, saved_inst))
			return MemoryReferenceFailed;
	}

	/*
	 * Free entry in breaktable.
	 */
	kttd_breaktable[bn].free = TRUE;

	return Okay;
}

static ttd_code_t get_next_break_action(boolean_t	all_breaks,
					ttd_address	*addr,
					ttd_thread	*thread,
					ttd_flavor	*flavor,
					ttd_saved_inst	*saved_inst)
{
	kttd_breakno bn;
	kttd_breakno start;

	/*
	 * If addr is zero, then start from beginning of list.
	 * Otherwise, start from the breakno after addr's breakno.
	 */
	if (*addr == 0) {
		start = 0;
	}else{
		/*
		 * Find the first matching breakpoint entry.
		 */
		for(bn = 0; bn < KTTD_MAXBPT; bn++) {
			if (!kttd_breaktable[bn].free &&
			    (kttd_breaktable[bn].address == *addr) &&
			    (kttd_breaktable[bn].thread == *thread))
				break;
		}

		/*
		 * If ran off the end, it's an invalid argument.
		 * Even all_breaks will have a valid addr and thread.
		 */
		if (!all_breaks && (bn > KTTD_MAXBPT))
			return InvalidArgument;

		if (bn < KTTD_MAXBPT - 1) {
			start = bn + 1;
		}else{
			/*
			 * Ran off the end.  No more breakpoints
			 * in the table.  Return zeros in vars.
			 */
			*addr = 0;
			*flavor = 0;
			bzero(saved_inst, sizeof(ttd_saved_inst));
			return Okay;
		}
	}

	for(bn = start; bn < KTTD_MAXBPT; bn ++) {
		if (!kttd_breaktable[bn].free &&
		    (all_breaks ||
		     (kttd_breaktable[bn].thread == *thread))) {
			*addr		= kttd_breaktable[bn].address;
			*thread		= kttd_breaktable[bn].thread;
			*flavor		= kttd_breaktable[bn].flavor;
			*saved_inst	= kttd_breaktable[bn].saved_inst;
			return Okay;
		}
	}
	*addr = 0;
	*flavor = 0;
	bzero(saved_inst, sizeof(ttd_saved_inst));

	return Okay;
}

/*
 * The Operations:
 */

/*
 * probe_server:
 *
 *  Probe server returns the version number of the KTTD implementation
 * and the machine type that it is executing on.
 *
 */
static void probe_server(ttd_request_t	request,
			 ttd_reply_t	reply,
			 ttd_address	*reply_end)
{
	if (kttd_debug) {
		printf("TTD:Probe Server, version = %d, machine_type = %d\n",
		       TTD_VERSION, ttd_target_machine_type);
	}

	reply->u.probe_server.version = netswap_4_bytes(TTD_VERSION);
	reply->u.probe_server.machine_type = netswap_4_bytes(ttd_target_machine_type);
	*reply_end = END_ADDRESS (reply->u.probe_server);
}

/*
 * get_target_info:
 *
 *  Get target info returns the target_info struct for the given target.
 * Since this is the kttd implementation, the only valid target is the
 * kernel target (ie. it only returns the target info for the kernel.
 *
 */
static void get_target_info(ttd_request_t	request,
			    ttd_reply_t	 	reply,
			    ttd_address		*reply_end)
{
	ttd_target	target;
	ttd_target_info	target_info;

	target = request->u.get_target_info.target;
	if (!target_is_kernel(target)) {
		reply->result.code = InvalidTarget;

		if (kttd_debug) {
			printf("TTD:get_target_info, invalid target %d\n", target);
		}

		return;
	}

	get_kernel_target_info(&target_info);

	reply->u.get_target_info.target_info = target_info;
	*reply_end = END_ADDRESS (reply->u.get_target_info);
	
	if (kttd_debug) {
		printf("TTD:get_target_info, target %d is %s, %s, th = 0x%x\n",
		       target,
		       target_info.is_stopped ? "stopped" : "running",
		       target_info.is_targeted ? "targeted" : "untargeted",
		       target_info.trapped_thread);
	}
}

/*
 * connect_to_target:
 *
 *  Connect to target connects to the target.  The only valid target
 * in the kttd implemetation is the kernel, all other targets are
 * invalid.  If the kernel is already targeted, it can only succeed
 * if the key value that is passed in the request message is valid.
 *
 * Note:  In this early implementation of kttd there is no security
 *        built into the ttd protocol (ie. a value of MASTER_KEY
 *        allows anyone to override the current connection).
 *
 */
static void connect_to_target(ttd_request_t	request,
			      ttd_reply_t	reply,
			      ttd_address	*reply_end)
{
	ttd_target	target;
	ttd_key		key;
	ttd_target_info	target_info;

	target = request->u.connect_to_target.target;
	key = request->u.connect_to_target.key;

	if (!target_is_kernel(target)) {
		reply->result.code = InvalidTarget;
		if (kttd_debug)
			printf("TTD:connect_to_target, invalid target %d\n", target);
		return;
	} else if (kttd_target.is_targeted && (key != MASTER_KEY)) {
		reply->result.code = TargetNotAvailable;
		if (kttd_debug)
			printf("TTD:connect_to_target, target %d unavailable\n", target);
		return;
	}

	kttd_target.is_targeted = TRUE;
	kttd_current_seq = 0;

	get_kernel_target_info(&target_info);

	reply->u.connect_to_target.target = TTD_KERNEL_MID;
	reply->u.connect_to_target.target_info = target_info;
	reply->result.argno = 2;
	*reply_end = END_ADDRESS (reply->u.connect_to_target);

	if (kttd_debug)
		printf("TTD:connect_to_target, connected kttd to target %d\n",target);
}

/*
 * disconnect_from_target:
 *
 *  Disconnect from target disconnects from the specified target.
 * The kernel target is the only valid target in the kttd implemen-
 * tation.
 *
 * Note:  This routine does not implicitly restart the target.
 *
 */
static void disconnect_from_target(ttd_request_t request,
				   ttd_reply_t 	 reply,
				   ttd_address	 *reply_end)
{
	/*
	 * The target checking is done in the kttd_service_request
	 * routine.  We know the target is the kernel if we get this
	 * far.
	 */
	kttd_target.is_targeted = FALSE;

	if (kttd_debug)
		printf("TTD:disconnect_from_target, disconnected from kttd target\n");
}	

/*
 * read_from_target:
 *
 *  Read from target reads count number of bytes from the target's
 * address space (the kernel in this implementation) and places them
 * in the reply message's buffer.
 *
 */
static void read_from_target(ttd_request_t	request,
			     ttd_reply_t	reply,
			     ttd_address	*reply_end)
{
	ttd_address	start;
	ttd_count		count;
	ttd_address	buffer;

	/*
	 * Target must be stopped in order to do this operation.
	 */
	if (!target_stopped()) {
		reply->result.code = TargetNotStopped;
		if (kttd_debug)
			printf("TTD:read_from_target, target not stopped.\n");
		return;
	}

	start = (ttd_address) request->u.read_from_target.start;
	count = request->u.read_from_target.count;
	buffer = (ttd_address) &reply->u.read_from_target.data[0];

	if (!valid_count(count)) {
		reply->result.code = InvalidArgument;
		if (kttd_debug)
			printf("TTD:read_from_target, invalid count 0x%x!!\n",
			       count);
		return;
	}

#if	VERBOSE
	if (kttd_debug)
		printf("TTD:read_from_target, start= 0x%x count=0x%x,",
		       start, count);
#endif	/* VERBOSE */

	reply->result.code = read_write_action(VM_PROT_READ, start, buffer, count);

	if (reply->result.code == Okay) {
		reply->u.read_from_target.count = count;
		*reply_end = (ttd_address)
			&reply->u.read_from_target.data[count];
		reply->result.argno = 2;

#if	VERBOSE
		if (kttd_debug)
			printf("OK! readbytes=0x%x\n",count);
#endif	/* VERBOSE */
	}
}

/*
 * write_info_target:
 *
 *  Write into target writes count bytes into the target's address
 * space (the kernel's address space) at the address addr from the
 * request message's buffer.
 *
 */
static void write_into_target(ttd_request_t	request,
			      ttd_reply_t	reply,
			      ttd_address	*reply_end)
{
	ttd_address	start;
	ttd_count	count;
	ttd_address	buffer;

	/*
	 * Target must be stopped in order to do this operation.
	 */
	if (!target_stopped()) {
		reply->result.code = TargetNotStopped;
		if (kttd_debug)
			printf("TTD:write_into_target, target not stopped\n");
		return;
	}

	start = (ttd_address) request->u.write_into_target.start;
	count = request->u.write_into_target.count;
	buffer = (ttd_address) &request->u.write_into_target.data[0];

	if (!valid_count(count)) {
		reply->result.code = InvalidArgument;
		if (kttd_debug)
			printf("TTD:write_into_target, invalid count 0x%x\n",
			       count);
		return;
	}

	reply->result.code = read_write_action(VM_PROT_WRITE, start, buffer, count);

	if (kttd_debug)
		printf("TTD:write_into_target, start=0x%x count=0x%x, result = %s\n",
		       start, count, (reply->result.code == Okay) ? "OK" : "ERR");
}

/*
 * get_next_thread:
 *
 *  Get next thread returns the next thread in the taks's (target's)
 * thread list starting at the thread in the request message.  If the
 * request thread's value is NULL, the first thread in the task's
 * thread list is returned, otherwise we return the next thread.
 *
 */
static void get_next_thread(ttd_request_t	request,
			    ttd_reply_t		reply,
			    ttd_address		*reply_end)
{
	ttd_thread	thread;

	/*
	 * Target must be stopped in order to do this operation.
	 */
	if (!target_stopped()) {
		reply->result.code = TargetNotStopped;
		if (kttd_debug)
			printf("TTD:get_next_thread, target not stopped\n");
		return;
	}

	thread = request->u.get_next_thread.thread;

	if (!get_next_thread_action(&thread)) {
		reply->result.code = InvalidArgument;
		return;
	}

	reply->u.get_next_thread.next = thread;
	reply->result.argno = 1;
	*reply_end = END_ADDRESS (reply->u.get_next_thread);

	if (kttd_debug)
		printf("TTD:get_next_thread, orig= 0x%x, thread=0x%x\n",
		       request->u.get_next_thread.thread, thread);
}

/*
 * get_thread_info:
 *
 *  Get thread info returns information about the thread specified
 * in the request message.  There are three parts to the thread info:
 * 
 *	thread_info:	the thread's state (ie. what's returned by
 *			thread_getstatus).
 *
 *	trap_info:	information on which trap caused the thread
 *			to trap (if it is stopped).
 *
 *	machine_state:	the thread's register state.
 *
 * Note:  In this implementation, we only support the machine state.
 *
 */
static void get_thread_info(ttd_request_t	request,
			    ttd_reply_t		reply,
			    ttd_address		*reply_end)
{
	ttd_thread	thread;
	ttd_thread_info	thread_info;
	ttd_trap_info	trap_info;
	ttd_machine_state machine_state;

	/*
	 * Target must be stopped in order to do this operation.
	 */
	if (!target_stopped()) {
		reply->result.code = TargetNotStopped;
		if (kttd_debug)
			printf("TTD:get_thread_info, target not stopped.\n");
		return;
	}

	thread = request->u.get_thread_info.thread;

	if (!valid_thread(thread)) {
		reply->result.code = InvalidArgument;
		if (kttd_debug)
			printf("TTD:get_thread_info, invalid thread.\n");
		return;
	}

	get_state_action(thread, &thread_info, &trap_info, &machine_state);

	if (kttd_debug)
		printf("TTD:get_thread_info, thread= 0x%x, ...\n", thread);
		
	reply->u.get_thread_info.thread_info = thread_info;
	reply->u.get_thread_info.trap_info = trap_info;
	reply->u.get_thread_info.machine_state = machine_state;
	reply->result.argno = 3;
	*reply_end = END_ADDRESS (reply->u.get_thread_info);
}

/*
 * set_thread_info:
 *
 *  Set thread info sets the specified thread's three states to
 * parameters in the request message.  These thread states are the
 * ones outlined above in the get_thread_info call.
 *
 * Note:  Only the thread's machine_state is set in this implemen-
 *        tation.
 *
 */
static void set_thread_info(ttd_request_t	request,
			    ttd_reply_t		reply,
			    ttd_address		*reply_end)
{
	ttd_thread	thread;
	ttd_thread_info	*thread_info;
	ttd_trap_info	*trap_info;
	ttd_machine_state *machine_state;

	/*
	 * Target must be stopped in order to do this operation.
	 */
	if (!target_stopped()) {
		reply->result.code = TargetNotStopped;
		if (kttd_debug)
			printf("TTD:set_thread_info, target not stopped.\n");
		return;
	}

#if	FUTURE
	thread = request->u.set_thread_info.thread;
	thread_info = &(request->u.set_thread_info.thread_info);
	trap_info = &(request->u.set_thread_info.trap_info);
#endif	/* FUTURE */
	machine_state = &(request->u.set_thread_info.machine_state);

#if	FUTURE
	if (!valid_thread(thread)) {
		reply->result.code = InvalidArgument;
		if (kttd_debug)
			printf("TTD:set_thread_info, invalid thread.\n");
		return;
	}
#endif	/* FUTURE */

	set_state_action(thread, thread_info, trap_info, machine_state);

	if (kttd_debug)
		printf("TTD:set_thread_info, thread= 0x%x, ...\n");
}

/*
 * stop_target:
 *
 *  Stop target stops the target specified in the request message.
 * In order to issue this command, the client must have successfull
 * issued an attach_to_target request previous to this request.
 *
 * Note:  this command was not directly supported by the original
 *        NubTTD implementation.  It is supported by kttd since
 *        the kttd client can communicate with the kttd server
 *        asynchronously.
 *
 * Note:  This implementation stops all threads in a task.  Future
 *        versions will work on a per-thread basis.
 *
 */
static void stop_target(ttd_request_t	request,
			ttd_reply_t	reply,
			ttd_address	*reply_end)
{
	/*
	 * Return error message if already stopped.
	 */
	if (target_stopped()) {
		reply->result.code = TargetStopped;
		if (kttd_debug)
			printf("TTD:stop_target, target ALREADY stopped.\n");
		return;
	}

	/*
	 * All we need to do to stop the kernel is call
	 * kttd_break.  This will cause this "thread" to
	 * enter the kttd_handle_sync() routine which will:
	 *
	 * 1.  Halt all the processors.
	 * 
	 * 2.  Stop the kernel (kttd_target.is_stopped = TRUE).
	 *
	 */

	if (kttd_debug)
		printf("TTD:stop_target, stopping kernel.\n");

	kttd_halt_processors();

	kttd_target.is_stopped = TRUE;

#if	PRE_MIPS_CODE
	kttd_stop_status = FULL_STOP;
#else
	kttd_run_status = FULL_STOP;
#endif	/* PRE_MIPS_CODE */
}

/*
 * probe_target:
 *
 *  Probe target returns the target info of the current target.  This
 * is used extensively by the asynhronous client.  In general the client
 * will poll the kttd target until it is stopped, and only then issue
 * requests.
 *
 */
static void probe_target(ttd_request_t	request,
			 ttd_reply_t	reply,
			 ttd_address	*reply_end)
{
	ttd_target_info	target_info;

	get_kernel_target_info(&target_info);
	reply->u.probe_target.target_info = target_info;
	reply->result.argno = 1;
	*reply_end = END_ADDRESS (reply->u.probe_target);

	if (kttd_debug)
		printf("TTD:probe_target, Kernel target is %s, %s, th = 0x%x\n",
		       target_info.is_stopped ? "stopped" : "running",
		       target_info.is_targeted ? "targeted" : "untargeted",
		       target_info.trapped_thread);
}

/*
 * restart_target:
 *
 *  Restart target resume's the kttd target's (the kernel's) execution.
 *
 * Note:  The current implementation restarts all a tasks threads at once.
 *        Future versions will work on a per thread basis.
 *
 */
static ttd_response_t restart_target(ttd_request_t	request,
				     ttd_reply_t	reply,
				     ttd_address	*reply_end)
{
	ttd_thread	thread;

	/*
	 * If target already running return error code.
	 */
	if (!target_stopped()) {
		reply->result.code = TargetNotStopped;
		if (kttd_debug)
			printf("TTD:restart_target, target not stopped.\n");
		return SEND_REPLY;
	}

	if (kttd_debug)
		printf("TTD:restart_target, restarting target....\n");

	/*
	 * We don't need to save a message for duplicate replies since
	 * restart doesn't send a reply.  We have a check when we check
	 * for duplicates that determines if it's a duplicate restart packet.
	 * If it is, then we just ignore it.
	 *
	 * The same holds for duplicate single_step packets.
	 */

	/* This will make it restart. */
#if	PRE_MIPS_CODE
	kttd_stop_status = ONE_STOP;
#else
	kttd_run_status = ONE_STOP;
#endif	/* PRE_MIPS_CODE */

	kttd_target.is_stopped = FALSE;

#if	SECOND_ATTEMPT
	/* Restart operations do not expect a reply. */
	return NO_REPLY;
#else
	/*
	 * Second way didn't send reply now, but third way will.
	 * We'll cache the reply and send it whenever we receive
	 * a duplicate!  Duhhhhhh....
	 */
	return SEND_REPLY;
#endif	/* SECOND_ATTEMPT */
}

/*
 * set_breakpoint_in_target
 *
 *  Set breakpoint in target sets a breakpoint for a specified thread in
 * in the current task's (the kernel task) at a specified address with
 * a specified flavor.  If the thread is NULL, it applies to all threads
 * in the target's task (all kernel threads).
 *
 */
static void set_breakpoint_in_target(ttd_request_t	request,
				     ttd_reply_t	reply,
				     ttd_address	*reply_end)
{
	ttd_address	addr;
	ttd_thread	thread;
	ttd_flavor	flavor;
	kttd_breakno	bn;
	ttd_saved_inst	saved_inst;

	/*
	 * Target must be stopped in order to do this operation.
	 */
	if (!target_stopped()) {
		reply->result.code = TargetNotStopped;
		if (kttd_debug)
			printf("TTD:set_breakpoint, target not stopped.\n");
		return;
	}

	addr = (ttd_address) request->u.set_breakpoint_in_target.address;
	thread = (ttd_thread) request->u.set_breakpoint_in_target.thread;
	flavor = request->u.set_breakpoint_in_target.flavor;

	if (thread && !valid_thread(thread)) {
		reply->result.code = InvalidArgument;
		if (kttd_debug) {
			printf("TTD:set_breakpoint, Invalid thread.\n");
		}
		return;
	}
		
	if (kttd_debug) {
		printf("TTD:set_breakpoint, addr= 0x%x, thread= 0x%x, flavor= %d, ",
		       addr, thread, flavor);
	}

	if (find_break(addr, thread, &bn)) {
		kttd_breaktable[bn].flavor = flavor;
		saved_inst = kttd_breaktable[bn].saved_inst;
	}else{
		reply->result.code = set_break_action(addr, thread,
						      flavor, &saved_inst);
	}

	if (!reply->result.code == Okay) {
		if (kttd_debug)
			printf("ERR\n");
		return;
	}

	if (kttd_debug)
		printf("OK\n");

	reply->u.set_breakpoint_in_target.saved_inst = saved_inst;
	reply->result.argno = 1;
	*reply_end = END_ADDRESS(reply->u.set_breakpoint_in_target);
}

/*
 * clear_breakpoint_in_target:
 *
 *  Clear breakpoint in target removes the breakpoint from target's
 * breakpoint table.  Like the set breakpoint request above, it takes
 * an address and a thread.  If the thread is NULL, it only clears
 * the breakpoints that apply to all threads.
 *
 */
static void clear_breakpoint_in_target(ttd_request_t	request,
				       ttd_reply_t	reply,
				       ttd_address	*reply_end)
{
	ttd_address	addr;
	ttd_thread	thread;

	/*
	 * Target must be stopped in order to do this operation.
	 */
	if (!target_stopped()) {
		reply->result.code = TargetNotStopped;
		if (kttd_debug)
		       printf("TTD:clear_break, target not stopped.\n");
		return;
	}

	addr = (ttd_address)request->u.clear_breakpoint_in_target.address;
	thread = (ttd_thread)request->u.clear_breakpoint_in_target.thread;

	if (kttd_debug)
		printf("TTD:clear_breakpoint, addr= 0x%x, thread= 0x%x\n",
		       addr, thread);

	/*
	 * Doesn't have to be a legal thread.  Might want to clear a
	 * breakpoint for a thread that has been destroyed.  The
	 * clear break action procedure will ignore threads that don't
	 * have breakpoints in the table.
	 */
	reply->result.code = clear_break_action(addr, thread);
}

/*
 * get_next_breakpoint_in_target:
 *
 *  Get next breakpoint in target returns the next breakpoint in the
 * target's (the kernel's) breakpoint list.  This request returns the
 * next breakpoint with respect to the breakpoint passed in the request.
 * If the request breakpoint is NULL, it starts at the beginning of the
 * breakpoint list.  If all_breaks is TRUE it returns the next breakpoint
 * without regard to the breakpoint's associated thread.  If all_breaks
 * is FALSE it only returns the next breakpoint that is associated with
 * the thread specified in the request message.
 *
 * Note:  This request can be issued on a running target.
 *
 */
static void get_next_breakpoint_in_target(ttd_request_t	request,
					  ttd_reply_t	reply,
					  ttd_address	*reply_end)
{
	ttd_address	addr;
	ttd_thread	thread;
	ttd_flavor	flavor;
	ttd_saved_inst	saved_inst;
	boolean_t	all_breaks;
		
	addr = (ttd_address)request->u.get_next_breakpoint_in_target.address;
	thread = (ttd_thread)request->u.get_next_breakpoint_in_target.thread;
	all_breaks = request->u.get_next_breakpoint_in_target.all_breaks;

	if (kttd_debug)
		printf("TTD:get_break, address= 0x%x, thread= 0x%x, allbreaks= 0x%x\n",
		       addr, thread, all_breaks);

	reply->result.code = get_next_break_action(all_breaks, &addr, &thread,
						   &flavor, &saved_inst);

	if (reply->result.code != Okay)
		return;

	reply->u.get_next_breakpoint_in_target.address = (ttd_address) addr;
	reply->u.get_next_breakpoint_in_target.flavor = flavor;
	reply->u.get_next_breakpoint_in_target.saved_inst = saved_inst;
	*reply_end = END_ADDRESS (reply->u.get_next_breakpoint_in_target);
}

/*
 * kttd_single_step:
 *
 *  KTTD Single Step sets the machine independent single stepping
 * values to single stepping state.  It then calls the machine 
 * dependent code to turn the machine into single stepping mode.
 *
 */
boolean_t kttd_single_step(void)
{
	if (kttd_single_stepping) {
		printf("kttd_single_step:  Already Single stepping!!!\n");
		return FALSE;
	}

	kttd_single_stepping = TRUE;

	/*
	 * In the current implementation, we can only set and
	 * clear single step in the kernel task.
	 */
	return(kttd_set_machine_single_step(NULL));
}

/*
 * kttd_clear_single_step:
 *
 *  KTTD Clear Single Step clear the machine independent single stepping
 * mechanism, and takes the machine out of single stepping mode.
 *
 */
boolean_t kttd_clear_single_step(void)
{
	if (!kttd_single_stepping) {
		printf("kttd_clear_single_step: Already out of single stepping!!\n");
	}

	kttd_single_stepping = FALSE;

	/*
	 * In the current implementation, we can only set and
	 * clear single step in the kernel task.
	 */
	return (kttd_clear_machine_single_step(NULL));
}

boolean_t kttd_in_single_step(void)
{
	return (kttd_single_stepping);
}

/*
 * single_step_thread:
 *
 *  Single step thread starts a thread specified in the request message
 * executing in single step mode.
 *
 * Note:  In this implementation you can only single step the current
 *        thread.
 *
 */
static ttd_response_t single_step_thread(ttd_request_t	request,
					 ttd_reply_t	reply,
					 ttd_address	*reply_end)
{
	ttd_thread	thread;

	/*
	 * Target must be stopped in order to do this operation.
	 */
	if (!target_stopped()) {
		reply->result.code = TargetNotStopped;
		if (kttd_debug)
			printf("TTD:single_step, target not stopped.\n");
		return SEND_REPLY;
	}

#if	DO_LATER
	thread = request->u.single_step_thread.thread;

	if (!valid_thread(thread)) {
		reply->result.code = InvalidArgument;
		return SEND_REPLY;
	}
#endif	/* DO_LATER */

	/*
	 * Note:  in this implementation a thread is assumed to
	 *        be stopped if it's target (task) is not running,
	 *        make sure the check that the thread is stopped
	 *        when the implementation is changed to allow 
	 *        thread stoppages.
	 */

	/*
	 * What should happen here:
	 *
	 * 1. swap in the specified thread.
	 *
	 */

	if (!kttd_single_step()) {
		reply->result.code = SingleSteppingError;
		if (kttd_debug)
			printf("TTD:single_step, single stepping ERROR!\n");
		return SEND_REPLY;
	}

	if (kttd_debug)
		printf("TTD:single_step, single step.\n");


	/* This will restart the kernel */
#if	PRE_MIPS_CODE
	kttd_stop_status = ONE_STOP;
#else
	kttd_run_status = ONE_STOP;
#endif	/* PRE_MIPS_CODE */

	kttd_target.is_stopped = FALSE;

#if	SECOND_ATTEMPT
	return NO_REPLY;
#else
	/* See comments in restart_target. */
	return SEND_REPLY;
#endif	/* SECOND_ATTEMPT */
}

/*
 * ttd_decode_request:
 *
 *  Returns TRUE if a reply should be sent, FALSE if no reply
 * should be sent.
 *
 */
static ttd_response_t ttd_decode_request(ttd_request_t	request,
					 ttd_reply_t	reply,
					 natural_t *	reply_length)
{
	ttd_address	reply_end;
	boolean_t	targeted_op;
	ttd_response_t	sr;

	/*
	 * Convert from network to host byte ordering.
	 */
	request->server = netswap_4_bytes(request->server);
	request->seq = netswap_4_bytes(request->seq);
	request->target = netswap_4_bytes(request->target);
	request->operation = netswap_4_bytes(request->operation);

	targeted_op = request->operation > CONNECT_TO_TARGET;

	/*
	 * Setup the reply's return values that are common
	 * to all operations:
	 */
	reply->server = netswap_4_bytes(KERNEL_TTD);
	reply->target = netswap_4_bytes(TTD_KERNEL_MID);
	reply->result.code = Okay;
	reply->result.argno = 0;
	reply->operation = netswap_4_bytes(request->operation);

	reply_end = END_ADDRESS(reply->operation);

	/*
	 * Set this now for those requests that return before the end.	
	 */
	*reply_length = (natural_t)reply_end - (natural_t)reply;
	
	/*
	 * For untargeted operations, set the sequence number of the
	 * reply to the seq # of the last valid targeted operation.
	 * This is used by the client end to determine restart and single
	 * stepping reception.
	 */
	reply->seq = netswap_4_bytes(kttd_current_seq);

	if (request->server != KERNEL_TTD) {
		reply->result.code = ServerNotAvailable;

		if (kttd_debug)
			printf("KTTD Server not available.\n");
		
		return SEND_REPLY;
	}

	/*
	 * Make sure that there aren't any idempotent operations
	 * that aren't targeted operations, since the duplicate
	 * sequence checking takes place in this if-clause!
	 */
	if (targeted_op) {
		if (!target_is_kernel(request->target)) {
			reply->result.code = InvalidTarget;

			if (kttd_debug)
				printf("Invalid KTTD target.\n");

			return SEND_REPLY;
		}

		if (!kttd_target.is_targeted) {
			reply->result.code = TargetNotAvailable;
			
			if (kttd_debug)
				printf("Kernel not targeted.\n");

			return SEND_REPLY;
		}

		if (duplicate(request->seq)) {
#if	SECOND_ATTEMPT
			/*
			 * The problem is, what happens when we get a duplicate
			 * restart or single step message?  There wasn't a
			 * reply for it, so we can't resend it.  So we just 
			 * act like we're ignoring it (like we did the first
			 * message), and "know" that we've already restarted
			 * or single stepped the kernel.
			 */
			if ((prev_operation == RESTART_TARGET) ||
			    (prev_operation == SINGLE_STEP_THREAD))
				return NO_REPLY;
#endif	/* SECOND_ATTEMPT */

			bcopy(&prev_reply, reply, prev_reply_length);

			if (kttd_debug)
#if	KTTD_VERBOSE
				printf("Duplicate, resending last reply.\n");
#else
			        printf("<D>");
#endif	/* KTTD_VERBOSE */
			
			return SEND_REPLY;
		}
	}
	
	switch(request->operation) {
	    case PROBE_SERVER:
		probe_server(request, reply, &reply_end);
		sr = SEND_REPLY;
		break;

	    case GET_TARGET_INFO:
		get_target_info(request, reply, &reply_end);
		sr = SEND_REPLY;
		break;

	    case CONNECT_TO_TARGET:
		connect_to_target(request, reply, &reply_end);
		sr = SEND_REPLY;
		break;

	    case DISCONNECT_FROM_TARGET:
		disconnect_from_target(request, reply, &reply_end);
		sr = SEND_REPLY;
		break;

	    case READ_FROM_TARGET:
		read_from_target(request, reply, &reply_end);
		sr = SEND_REPLY;
		break;

	    case WRITE_INTO_TARGET:
		write_into_target(request, reply, &reply_end);
		sr = SEND_REPLY;
		break;

	    case GET_NEXT_THREAD:
		get_next_thread(request, reply, &reply_end);
		sr = SEND_REPLY;
		break;

	    case GET_THREAD_INFO:
		get_thread_info(request, reply, &reply_end);
		sr = SEND_REPLY;
		break;

	    case SET_THREAD_INFO:
		set_thread_info(request, reply, &reply_end);
		sr = SEND_REPLY;
		break;

	    case STOP_TARGET:
		stop_target(request, reply, &reply_end);
		sr = SEND_REPLY;
		break;

	    case PROBE_TARGET:
		probe_target(request, reply, &reply_end);
		sr = SEND_REPLY;
		break;

	    case RESTART_TARGET:
		sr = restart_target(request, reply, &reply_end);
		break;

	    case SET_BREAKPOINT_IN_TARGET:
		set_breakpoint_in_target(request, reply, &reply_end);
		sr = SEND_REPLY;
		break;

	    case CLEAR_BREAKPOINT_IN_TARGET:
		clear_breakpoint_in_target(request, reply, &reply_end);
		sr = SEND_REPLY;
		break;

	    case GET_NEXT_BREAKPOINT_IN_TARGET:
		get_next_breakpoint_in_target(request, reply, &reply_end);
		sr = SEND_REPLY;
		break;

	    case SINGLE_STEP_THREAD:
		sr = single_step_thread(request, reply, &reply_end);
		break;

	    default:
		sr = SEND_REPLY;
		reply->result.code = InvalidOperation;
		
		/*
		 * Don't return here, we might've already set up our
		 * seq # as the duplicate seq #, and we therefore need
		 * to make sure that the prev_reply_length field is set
		 * properly.
		 */
	}

	/*
	 * See above comment dealing with the reply->seq.
	 */
	if (targeted_op)
		reply->seq = netswap_4_bytes(request->seq);

	*reply_length = (natural_t)reply_end - (natural_t)reply;

	prev_operation = request->operation;

	return (sr);
}

/*
 * ttd_service_request:
 *
 */
void ttd_service_request(void)
{
	natural_t	kttd_reply_length;
	ttd_request_t	request;
	ttd_reply_t	reply;

	/*
	 * If the length is bad, just drop the packet.
	 */
	if (kttd_current_length > sizeof(struct ttd_request)) {
		if (kttd_debug)
			printf("INVALID TTD Request Size!! 0x%x > 0x%x\n",
			       kttd_current_length, sizeof(struct ttd_request));
		return;
	}

	request = (ttd_request_t)kttd_current_request;
	reply = skip_net_headers(ttd_reply_msg);

	if ((int)request % BYTE_ALIGNMENT) {
		request = &aligned_request;
		bcopy(kttd_current_request, request,
		      ((kttd_current_length) > sizeof(struct ttd_request) ?
		       sizeof(struct ttd_request) : kttd_current_length));
	}

	if (ttd_decode_request(request, reply, &kttd_reply_length) == SEND_REPLY) {

		/*
		 * We've only built the ttd_reply_msg portion of the
		 * reply.  Now build the ether/ip/udp parts and cache
		 * the reply for duplicate retransmissions.
		 *
		 * Save this reply so that duplicate requests
		 * receive the right reply (idempotent requests).
		 *
		 * Remember that kttd_reply_msg is the
		 * skip_net_headers(ttd_reply_msg)!
		 *
		 * Just save the struct ttd_reply_msg, we'll build the
		 * reply header and ip/udp contents later.
		 *
		 */
		bcopy(skip_net_headers(ttd_reply_msg),
		      &prev_reply,
		      kttd_reply_length);
		prev_reply_length = kttd_reply_length;

		/*
		 * Build the Full reply msg, then send it.
		 */

		complete_and_send_ttd_reply(kttd_reply_length);
	}
}

void ttd_server_initialize(void)
{
	if (ttd_server_initialized)
		return;

	init_kernel_target();

	ttd_target_machine_type = get_ttd_machine_type();

	ttd_request_msg = &ttd_request_msg_array[0];
	ttd_reply_msg = &ttd_reply_msg_array[0];

	/*
	 * Get it to line up on the last 2 byte boundary before a
	 * BYTE_ALIGNMENT boundary.
	 */
	ttd_reply_msg = (char *)((int)ttd_reply_msg +
				 (int)ttd_reply_msg % BYTE_ALIGNMENT +
				 (BYTE_ALIGNMENT - 2));;
	
	ttd_server_initialized = TRUE;
}