haiku.git

/*
 * Copyright 2005-2016, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2015, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */


#include <errno.h>
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <algorithm>

#include <arch/debug.h>
#include <arch/user_debugger.h>
#include <core_dump.h>
#include <cpu.h>
#include <debugger.h>
#include <kernel.h>
#include <KernelExport.h>
#include <kscheduler.h>
#include <ksignal.h>
#include <ksyscalls.h>
#include <port.h>
#include <sem.h>
#include <team.h>
#include <thread.h>
#include <thread_types.h>
#include <user_debugger.h>
#include <vm/vm.h>
#include <vm/vm_types.h>

#include <AutoDeleter.h>
#include <util/AutoLock.h>
#include <util/ThreadAutoLock.h>

#include "BreakpointManager.h"


//#define TRACE_USER_DEBUGGER
#ifdef TRACE_USER_DEBUGGER
#	define TRACE(x) dprintf x
#else
#	define TRACE(x) ;
#endif


// TODO: Since the introduction of team_debug_info::debugger_changed_condition
// there's some potential for simplifications. E.g. clear_team_debug_info() and
// destroy_team_debug_info() are now only used in nub_thread_cleanup() (plus
// arch_clear_team_debug_info() in install_team_debugger_init_debug_infos()).


static port_id sDefaultDebuggerPort = -1;
	// accessed atomically

static timer sProfilingTimers[SMP_MAX_CPUS];
	// a profiling timer for each CPU -- used when a profiled thread is running
	// on that CPU


static void schedule_profiling_timer(Thread* thread, bigtime_t interval);
static int32 profiling_event(timer* unused);
static void profiling_flush(void*);

static status_t ensure_debugger_installed();
static void get_team_debug_info(team_debug_info &teamDebugInfo);


static inline status_t
kill_interruptable_write_port(port_id port, int32 code, const void *buffer,
	size_t bufferSize)
{
	return write_port_etc(port, code, buffer, bufferSize, B_KILL_CAN_INTERRUPT,
		0);
}


static status_t
debugger_write(port_id port, int32 code, const void *buffer, size_t bufferSize,
	bool dontWait)
{
	TRACE(("debugger_write(): thread: %" B_PRId32 ", team %" B_PRId32 ", "
		"port: %" B_PRId32 ", code: %" B_PRIx32 ", message: %p, size: %lu, "
		"dontWait: %d\n", thread_get_current_thread()->id,
		thread_get_current_thread()->team->id, port, code, buffer, bufferSize,
		dontWait));

	status_t error = B_OK;

	// get the team debug info
	team_debug_info teamDebugInfo;
	get_team_debug_info(teamDebugInfo);
	sem_id writeLock = teamDebugInfo.debugger_write_lock;

	// get the write lock
	TRACE(("debugger_write(): acquiring write lock...\n"));
	error = acquire_sem_etc(writeLock, 1,
		dontWait ? (uint32)B_RELATIVE_TIMEOUT : (uint32)B_KILL_CAN_INTERRUPT, 0);
	if (error != B_OK) {
		TRACE(("debugger_write() done1: %" B_PRIx32 "\n", error));
		return error;
	}

	// re-get the team debug info
	get_team_debug_info(teamDebugInfo);

	if (teamDebugInfo.debugger_port != port
		|| (teamDebugInfo.flags & B_TEAM_DEBUG_DEBUGGER_HANDOVER)) {
		// The debugger has changed in the meantime or we are about to be
		// handed over to a new debugger. In either case we don't send the
		// message.
		TRACE(("debugger_write(): %s\n",
			(teamDebugInfo.debugger_port != port ? "debugger port changed"
				: "handover flag set")));
	} else {
		TRACE(("debugger_write(): writing to port...\n"));

		error = write_port_etc(port, code, buffer, bufferSize,
			dontWait ? (uint32)B_RELATIVE_TIMEOUT : (uint32)B_KILL_CAN_INTERRUPT, 0);
	}

	// release the write lock
	release_sem(writeLock);

	TRACE(("debugger_write() done: %" B_PRIx32 "\n", error));

	return error;
}


/*!	Updates the thread::flags field according to what user debugger flags are
	set for the thread.
	Interrupts must be disabled and the thread's debug info lock must be held.
*/
static void
update_thread_user_debug_flag(Thread* thread)
{
	if ((atomic_get(&thread->debug_info.flags) & B_THREAD_DEBUG_STOP) != 0)
		atomic_or(&thread->flags, THREAD_FLAGS_DEBUG_THREAD);
	else
		atomic_and(&thread->flags, ~THREAD_FLAGS_DEBUG_THREAD);
}


/*!	Updates the thread::flags THREAD_FLAGS_BREAKPOINTS_DEFINED bit of the
	given thread.
	Interrupts must be disabled and the thread debug info lock must be held.
*/
static void
update_thread_breakpoints_flag(Thread* thread)
{
	Team* team = thread->team;

	if (arch_has_breakpoints(&team->debug_info.arch_info))
		atomic_or(&thread->flags, THREAD_FLAGS_BREAKPOINTS_DEFINED);
	else
		atomic_and(&thread->flags, ~THREAD_FLAGS_BREAKPOINTS_DEFINED);
}


/*!	Updates the Thread::flags THREAD_FLAGS_BREAKPOINTS_DEFINED bit of all
	threads of the current team.
*/
static void
update_threads_breakpoints_flag()
{
	Team* team = thread_get_current_thread()->team;

	TeamLocker teamLocker(team);

	if (arch_has_breakpoints(&team->debug_info.arch_info)) {
		for (Thread* thread = team->thread_list.First(); thread != NULL;
				thread = team->thread_list.GetNext(thread)) {
			atomic_or(&thread->flags, THREAD_FLAGS_BREAKPOINTS_DEFINED);
		}
	} else {
		for (Thread* thread = team->thread_list.First(); thread != NULL;
				thread = team->thread_list.GetNext(thread)) {
			atomic_and(&thread->flags, ~THREAD_FLAGS_BREAKPOINTS_DEFINED);
		}
	}
}


/*!	Updates the thread::flags B_TEAM_DEBUG_DEBUGGER_INSTALLED bit of the
	given thread, which must be the current thread.
*/
static void
update_thread_debugger_installed_flag(Thread* thread)
{
	Team* team = thread->team;

	if (atomic_get(&team->debug_info.flags) & B_TEAM_DEBUG_DEBUGGER_INSTALLED)
		atomic_or(&thread->flags, THREAD_FLAGS_DEBUGGER_INSTALLED);
	else
		atomic_and(&thread->flags, ~THREAD_FLAGS_DEBUGGER_INSTALLED);
}


/*!	Updates the thread::flags THREAD_FLAGS_DEBUGGER_INSTALLED bit of all
	threads of the given team.
	The team's lock must be held.
*/
static void
update_threads_debugger_installed_flag(Team* team)
{
	if (atomic_get(&team->debug_info.flags) & B_TEAM_DEBUG_DEBUGGER_INSTALLED) {
		for (Thread* thread = team->thread_list.First(); thread != NULL;
				thread = team->thread_list.GetNext(thread)) {
			atomic_or(&thread->flags, THREAD_FLAGS_DEBUGGER_INSTALLED);
		}
	} else {
		for (Thread* thread = team->thread_list.First(); thread != NULL;
				thread = team->thread_list.GetNext(thread)) {
			atomic_and(&thread->flags, ~THREAD_FLAGS_DEBUGGER_INSTALLED);
		}
	}
}


/**
 *	For the first initialization the function must be called with \a initLock
 *	set to \c true. If it would be possible that another thread accesses the
 *	structure at the same time, `lock' must be held when calling the function.
 */
void
clear_team_debug_info(struct team_debug_info *info, bool initLock)
{
	if (info) {
		arch_clear_team_debug_info(&info->arch_info);
		atomic_set(&info->flags, B_TEAM_DEBUG_DEFAULT_FLAGS);
		info->debugger_team = -1;
		info->debugger_port = -1;
		info->nub_thread = -1;
		info->nub_port = -1;
		info->debugger_write_lock = -1;
		info->causing_thread = -1;
		info->image_event = 0;
		info->breakpoint_manager = NULL;

		if (initLock) {
			B_INITIALIZE_SPINLOCK(&info->lock);
			info->debugger_changed_condition = NULL;
		}
	}
}

/**
 *  `lock' must not be held nor may interrupts be disabled.
 *  \a info must not be a member of a team struct (or the team struct must no
 *  longer be accessible, i.e. the team should already be removed).
 *
 *	In case the team is still accessible, the procedure is:
 *	1. get `lock'
 *	2. copy the team debug info on stack
 *	3. call clear_team_debug_info() on the team debug info
 *	4. release `lock'
 *	5. call destroy_team_debug_info() on the copied team debug info
 */
static void
destroy_team_debug_info(struct team_debug_info *info)
{
	if (info) {
		arch_destroy_team_debug_info(&info->arch_info);

		// delete the breakpoint manager
		delete info->breakpoint_manager ;
		info->breakpoint_manager = NULL;

		// delete the debugger port write lock
		if (info->debugger_write_lock >= 0) {
			delete_sem(info->debugger_write_lock);
			info->debugger_write_lock = -1;
		}

		// delete the nub port
		if (info->nub_port >= 0) {
			set_port_owner(info->nub_port, B_CURRENT_TEAM);
			delete_port(info->nub_port);
			info->nub_port = -1;
		}

		// wait for the nub thread
		if (info->nub_thread >= 0) {
			if (info->nub_thread != thread_get_current_thread()->id) {
				int32 result;
				wait_for_thread(info->nub_thread, &result);
			}

			info->nub_thread = -1;
		}

		atomic_set(&info->flags, 0);
		info->debugger_team = -1;
		info->debugger_port = -1;
		info->causing_thread = -1;
		info->image_event = -1;
	}
}


void
init_thread_debug_info(struct thread_debug_info *info)
{
	if (info) {
		B_INITIALIZE_SPINLOCK(&info->lock);
		arch_clear_thread_debug_info(&info->arch_info);
		info->flags = B_THREAD_DEBUG_DEFAULT_FLAGS;
		info->debug_port = -1;
		info->ignore_signals = 0;
		info->ignore_signals_once = 0;
		info->profile.sample_area = -1;
		info->profile.interval = 0;
		info->profile.samples = NULL;
		info->profile.flush_needed = false;
		info->profile.installed_timer = NULL;
	}
}


/*!	Clears the debug info for the current thread.
	Invoked with thread debug info lock being held.
*/
void
clear_thread_debug_info(struct thread_debug_info *info, bool dying)
{
	if (info) {
		// cancel profiling timer
		if (info->profile.installed_timer != NULL) {
			cancel_timer(info->profile.installed_timer);
			info->profile.installed_timer->hook = NULL;
			info->profile.installed_timer = NULL;
		}

		arch_clear_thread_debug_info(&info->arch_info);
		atomic_set(&info->flags,
			B_THREAD_DEBUG_DEFAULT_FLAGS | (dying ? B_THREAD_DEBUG_DYING : 0));
		info->debug_port = -1;
		info->ignore_signals = 0;
		info->ignore_signals_once = 0;
		info->profile.sample_area = -1;
		info->profile.interval = 0;
		info->profile.samples = NULL;
		info->profile.flush_needed = false;
	}
}


void
destroy_thread_debug_info(struct thread_debug_info *info)
{
	if (info) {
		area_id sampleArea = info->profile.sample_area;
		if (sampleArea >= 0) {
			area_info areaInfo;
			if (get_area_info(sampleArea, &areaInfo) == B_OK) {
				unlock_memory(areaInfo.address, areaInfo.size, B_READ_DEVICE);
				delete_area(sampleArea);
			}
		}

		arch_destroy_thread_debug_info(&info->arch_info);

		if (info->debug_port >= 0) {
			delete_port(info->debug_port);
			info->debug_port = -1;
		}

		info->ignore_signals = 0;
		info->ignore_signals_once = 0;

		atomic_set(&info->flags, 0);
	}
}


static status_t
prepare_debugger_change(team_id teamID, ConditionVariable& condition,
	Team*& team)
{
	// We look up the team by ID, even in case of the current team, so we can be
	// sure, that the team is not already dying.
	if (teamID == B_CURRENT_TEAM)
		teamID = thread_get_current_thread()->team->id;

	while (true) {
		// get the team
		team = Team::GetAndLock(teamID);
		if (team == NULL)
			return B_BAD_TEAM_ID;
		BReference<Team> teamReference(team, true);
		TeamLocker teamLocker(team, true);

		// don't allow messing with the kernel team
		if (team == team_get_kernel_team())
			return B_NOT_ALLOWED;

		// check whether the condition is already set
		InterruptsSpinLocker debugInfoLocker(team->debug_info.lock);

		if (team->debug_info.debugger_changed_condition == NULL) {
			// nobody there yet -- set our condition variable and be done
			team->debug_info.debugger_changed_condition = &condition;
			return B_OK;
		}

		// we'll have to wait
		ConditionVariableEntry entry;
		team->debug_info.debugger_changed_condition->Add(&entry);

		debugInfoLocker.Unlock();
		teamLocker.Unlock();

		entry.Wait();
	}
}


static void
prepare_debugger_change(Team* team, ConditionVariable& condition)
{
	while (true) {
		// check whether the condition is already set
		InterruptsSpinLocker debugInfoLocker(team->debug_info.lock);

		if (team->debug_info.debugger_changed_condition == NULL) {
			// nobody there yet -- set our condition variable and be done
			team->debug_info.debugger_changed_condition = &condition;
			return;
		}

		// we'll have to wait
		ConditionVariableEntry entry;
		team->debug_info.debugger_changed_condition->Add(&entry);

		debugInfoLocker.Unlock();

		entry.Wait();
	}
}


static void
finish_debugger_change(Team* team)
{
	// unset our condition variable and notify all threads waiting on it
	InterruptsSpinLocker debugInfoLocker(team->debug_info.lock);

	ConditionVariable* condition = team->debug_info.debugger_changed_condition;
	team->debug_info.debugger_changed_condition = NULL;

	condition->NotifyAll();
}


void
user_debug_prepare_for_exec()
{
	Thread *thread = thread_get_current_thread();
	Team *team = thread->team;

	// If a debugger is installed for the team and the thread debug stuff
	// initialized, change the ownership of the debug port for the thread
	// to the kernel team, since exec_team() deletes all ports owned by this
	// team. We change the ownership back later.
	if (atomic_get(&team->debug_info.flags) & B_TEAM_DEBUG_DEBUGGER_INSTALLED) {
		// get the port
		port_id debugPort = -1;

		InterruptsSpinLocker threadDebugInfoLocker(thread->debug_info.lock);

		if ((thread->debug_info.flags & B_THREAD_DEBUG_INITIALIZED) != 0)
			debugPort = thread->debug_info.debug_port;

		threadDebugInfoLocker.Unlock();

		// set the new port ownership
		if (debugPort >= 0)
			set_port_owner(debugPort, team_get_kernel_team_id());
	}
}


void
user_debug_finish_after_exec()
{
	Thread *thread = thread_get_current_thread();
	Team *team = thread->team;

	// If a debugger is installed for the team and the thread debug stuff
	// initialized for this thread, change the ownership of its debug port
	// back to this team.
	if (atomic_get(&team->debug_info.flags) & B_TEAM_DEBUG_DEBUGGER_INSTALLED) {
		// get the port
		port_id debugPort = -1;

		InterruptsSpinLocker threadDebugInfoLocker(thread->debug_info.lock);

		if (thread->debug_info.flags & B_THREAD_DEBUG_INITIALIZED)
			debugPort = thread->debug_info.debug_port;

		threadDebugInfoLocker.Unlock();

		// set the new port ownership
		if (debugPort >= 0)
			set_port_owner(debugPort, team->id);
	}
}


void
init_user_debug()
{
	#ifdef ARCH_INIT_USER_DEBUG
		ARCH_INIT_USER_DEBUG();
	#endif
}


static void
get_team_debug_info(team_debug_info &teamDebugInfo)
{
	Thread *thread = thread_get_current_thread();

	cpu_status state = disable_interrupts();
	GRAB_TEAM_DEBUG_INFO_LOCK(thread->team->debug_info);

	memcpy(&teamDebugInfo, &thread->team->debug_info, sizeof(team_debug_info));

	RELEASE_TEAM_DEBUG_INFO_LOCK(thread->team->debug_info);
	restore_interrupts(state);
}


static status_t
thread_hit_debug_event_internal(debug_debugger_message event,
	const void *message, int32 size, bool requireDebugger, bool &restart)
{
	restart = false;
	Thread *thread = thread_get_current_thread();

	TRACE(("thread_hit_debug_event(): thread: %" B_PRId32 ", event: %" B_PRIu32
		", message: %p, size: %" B_PRId32 "\n", thread->id, (uint32)event,
		message, size));

	// check, if there's a debug port already
	bool setPort = !(atomic_get(&thread->debug_info.flags)
		& B_THREAD_DEBUG_INITIALIZED);

	// create a port, if there is none yet
	port_id port = -1;
	if (setPort) {
		char nameBuffer[128];
		snprintf(nameBuffer, sizeof(nameBuffer), "nub to thread %" B_PRId32,
			thread->id);

		port = create_port(1, nameBuffer);
		if (port < 0) {
			dprintf("thread_hit_debug_event(): Failed to create debug port: "
				"%s\n", strerror(port));
			return port;
		}
	}

	// check the debug info structures once more: get the debugger port, set
	// the thread's debug port, and update the thread's debug flags
	port_id deletePort = port;
	port_id debuggerPort = -1;
	port_id nubPort = -1;
	status_t error = B_OK;
	cpu_status state = disable_interrupts();
	GRAB_TEAM_DEBUG_INFO_LOCK(thread->team->debug_info);
	SpinLocker threadDebugInfoLocker(thread->debug_info.lock);

	uint32 threadFlags = thread->debug_info.flags;
	threadFlags &= ~B_THREAD_DEBUG_STOP;
	bool debuggerInstalled
		= (thread->team->debug_info.flags & B_TEAM_DEBUG_DEBUGGER_INSTALLED);
	if (thread->id == thread->team->debug_info.nub_thread) {
		// Ugh, we're the nub thread. We shouldn't be here.
		TRACE(("thread_hit_debug_event(): Misdirected nub thread: %" B_PRId32
			"\n", thread->id));

		error = B_ERROR;
	} else if (debuggerInstalled || !requireDebugger) {
		if (debuggerInstalled) {
			debuggerPort = thread->team->debug_info.debugger_port;
			nubPort = thread->team->debug_info.nub_port;
		}

		if (setPort) {
			if (threadFlags & B_THREAD_DEBUG_INITIALIZED) {
				// someone created a port for us (the port we've created will
				// be deleted below)
				port = thread->debug_info.debug_port;
			} else {
				thread->debug_info.debug_port = port;
				deletePort = -1;	// keep the port
				threadFlags |= B_THREAD_DEBUG_INITIALIZED;
			}
		} else {
			if (threadFlags & B_THREAD_DEBUG_INITIALIZED) {
				port = thread->debug_info.debug_port;
			} else {
				// someone deleted our port
				error = B_ERROR;
			}
		}
	} else
		error = B_ERROR;

	// update the flags
	if (error == B_OK)
		threadFlags |= B_THREAD_DEBUG_STOPPED;
	atomic_set(&thread->debug_info.flags, threadFlags);

	update_thread_user_debug_flag(thread);

	threadDebugInfoLocker.Unlock();
	RELEASE_TEAM_DEBUG_INFO_LOCK(thread->team->debug_info);
	restore_interrupts(state);

	// delete the superfluous port
	if (deletePort >= 0)
		delete_port(deletePort);

	if (error != B_OK) {
		TRACE(("thread_hit_debug_event() error: thread: %" B_PRId32 ", error: "
			"%" B_PRIx32 "\n", thread->id, error));
		return error;
	}

	// send a message to the debugger port
	if (debuggerInstalled) {
		// update the message's origin info first
		debug_origin *origin = (debug_origin *)message;
		origin->thread = thread->id;
		origin->team = thread->team->id;
		origin->nub_port = nubPort;

		TRACE(("thread_hit_debug_event(): thread: %" B_PRId32 ", sending "
			"message to debugger port %" B_PRId32 "\n", thread->id,
			debuggerPort));

		error = debugger_write(debuggerPort, event, message, size, false);
	}

	status_t result = B_THREAD_DEBUG_HANDLE_EVENT;
	bool singleStep = false;

	if (error == B_OK) {
		bool done = false;
		while (!done) {
			// read a command from the debug port
			int32 command;
			debugged_thread_message_data commandMessage;
			ssize_t commandMessageSize = read_port_etc(port, &command,
				&commandMessage, sizeof(commandMessage), B_KILL_CAN_INTERRUPT,
				0);

			if (commandMessageSize < 0) {
				error = commandMessageSize;
				TRACE(("thread_hit_debug_event(): thread: %" B_PRId32 ", failed "
					"to receive message from port %" B_PRId32 ": %" B_PRIx32 "\n",
					thread->id, port, error));
				break;
			}

			switch (command) {
				case B_DEBUGGED_THREAD_MESSAGE_CONTINUE:
					TRACE(("thread_hit_debug_event(): thread: %" B_PRId32 ": "
						"B_DEBUGGED_THREAD_MESSAGE_CONTINUE\n",
						thread->id));
					result = commandMessage.continue_thread.handle_event;

					singleStep = commandMessage.continue_thread.single_step;
					done = true;
					break;

				case B_DEBUGGED_THREAD_SET_CPU_STATE:
				{
					TRACE(("thread_hit_debug_event(): thread: %" B_PRId32 ": "
						"B_DEBUGGED_THREAD_SET_CPU_STATE\n",
						thread->id));
					arch_set_debug_cpu_state(
						&commandMessage.set_cpu_state.cpu_state);

					break;
				}

				case B_DEBUGGED_THREAD_GET_CPU_STATE:
				{
					port_id replyPort = commandMessage.get_cpu_state.reply_port;

					// prepare the message
					debug_nub_get_cpu_state_reply replyMessage;
					replyMessage.error = B_OK;
					replyMessage.message = event;
					arch_get_debug_cpu_state(&replyMessage.cpu_state);

					// send it
					error = kill_interruptable_write_port(replyPort, event,
						&replyMessage, sizeof(replyMessage));

					break;
				}

				case B_DEBUGGED_THREAD_DEBUGGER_CHANGED:
				{
					// Check, if the debugger really changed, i.e. is different
					// than the one we know.
					team_debug_info teamDebugInfo;
					get_team_debug_info(teamDebugInfo);

					if (teamDebugInfo.flags & B_TEAM_DEBUG_DEBUGGER_INSTALLED) {
						if (!debuggerInstalled
							|| teamDebugInfo.debugger_port != debuggerPort) {
							// debugger was installed or has changed: restart
							// this function
							restart = true;
							done = true;
						}
					} else {
						if (debuggerInstalled) {
							// debugger is gone: continue the thread normally
							done = true;
						}
					}

					break;
				}
			}
		}
	} else {
		TRACE(("thread_hit_debug_event(): thread: %" B_PRId32 ", failed to send "
			"message to debugger port %" B_PRId32 ": %" B_PRIx32 "\n",
			thread->id, debuggerPort, error));
	}

	// update the thread debug info
	bool destroyThreadInfo = false;
	thread_debug_info threadDebugInfo;

	state = disable_interrupts();
	threadDebugInfoLocker.Lock();

	// check, if the team is still being debugged
	int32 teamDebugFlags = atomic_get(&thread->team->debug_info.flags);
	if (teamDebugFlags & B_TEAM_DEBUG_DEBUGGER_INSTALLED) {
		// update the single-step flag
		if (singleStep) {
			atomic_or(&thread->debug_info.flags,
				B_THREAD_DEBUG_SINGLE_STEP);
			atomic_or(&thread->flags, THREAD_FLAGS_SINGLE_STEP);
		} else {
			atomic_and(&thread->debug_info.flags,
				~(int32)B_THREAD_DEBUG_SINGLE_STEP);
		}

		// unset the "stopped" state
		atomic_and(&thread->debug_info.flags, ~B_THREAD_DEBUG_STOPPED);

		update_thread_user_debug_flag(thread);
	} else {
		// the debugger is gone: cleanup our info completely
		threadDebugInfo = thread->debug_info;
		clear_thread_debug_info(&thread->debug_info, false);
		destroyThreadInfo = true;
	}

	threadDebugInfoLocker.Unlock();
	restore_interrupts(state);

	// enable/disable single stepping
	arch_update_thread_single_step();

	if (destroyThreadInfo)
		destroy_thread_debug_info(&threadDebugInfo);

	return (error == B_OK ? result : error);
}


static status_t
thread_hit_debug_event(debug_debugger_message event, const void *message,
	int32 size, bool requireDebugger)
{
	status_t result;
	bool restart;
	do {
		restart = false;
		result = thread_hit_debug_event_internal(event, message, size,
			requireDebugger, restart);
	} while (result >= 0 && restart);

	// Prepare to continue -- we install a debugger change condition, so no one
	// will change the debugger while we're playing with the breakpoint manager.
	// TODO: Maybe better use ref-counting and a flag in the breakpoint manager.
	Team* team = thread_get_current_thread()->team;
	ConditionVariable debugChangeCondition;
	debugChangeCondition.Init(team, "debug change condition");
	prepare_debugger_change(team, debugChangeCondition);

	if (team->debug_info.breakpoint_manager != NULL) {
		bool isSyscall;
		void* pc = arch_debug_get_interrupt_pc(&isSyscall);
		if (pc != NULL && !isSyscall)
			team->debug_info.breakpoint_manager->PrepareToContinue(pc);
	}

	finish_debugger_change(team);

	return result;
}


static status_t
thread_hit_serious_debug_event(debug_debugger_message event,
	const void *message, int32 messageSize)
{
	// ensure that a debugger is installed for this team
	status_t error = ensure_debugger_installed();
	if (error != B_OK) {
		Thread *thread = thread_get_current_thread();
		dprintf("thread_hit_serious_debug_event(): Failed to install debugger: "
			"thread: %" B_PRId32 " (%s): %s\n", thread->id, thread->name,
			strerror(error));
		return error;
	}

	// enter the debug loop
	return thread_hit_debug_event(event, message, messageSize, true);
}


void
user_debug_pre_syscall(uint32 syscall, void *args)
{
	// check whether a debugger is installed
	Thread *thread = thread_get_current_thread();
	int32 teamDebugFlags = atomic_get(&thread->team->debug_info.flags);
	if (!(teamDebugFlags & B_TEAM_DEBUG_DEBUGGER_INSTALLED))
		return;

	// check whether pre-syscall tracing is enabled for team or thread
	int32 threadDebugFlags = atomic_get(&thread->debug_info.flags);
	if ((teamDebugFlags & B_TEAM_DEBUG_PRE_SYSCALL)
			|| (threadDebugFlags & B_THREAD_DEBUG_PRE_SYSCALL)) {
		// prepare the message
		debug_pre_syscall message;
		message.syscall = syscall;

		// copy the syscall args
		if (syscall < (uint32)kSyscallCount) {
			if (kSyscallInfos[syscall].parameter_size > 0)
				memcpy(message.args, args, kSyscallInfos[syscall].parameter_size);
		}

		thread_hit_debug_event(B_DEBUGGER_MESSAGE_PRE_SYSCALL, &message,
			sizeof(message), true);
	}

	if ((teamDebugFlags & B_TEAM_DEBUG_POST_SYSCALL)
			|| (threadDebugFlags & B_THREAD_DEBUG_POST_SYSCALL)) {
		// The syscall_start_time storage is shared with the profiler's interval.
		if (thread->debug_info.profile.samples == NULL)
			thread->debug_info.profile.syscall_start_time = system_time();
	}
}


void
user_debug_post_syscall(uint32 syscall, void *args, uint64 returnValue)
{
	// check whether a debugger is installed
	Thread *thread = thread_get_current_thread();
	int32 teamDebugFlags = atomic_get(&thread->team->debug_info.flags);
	if (!(teamDebugFlags & B_TEAM_DEBUG_DEBUGGER_INSTALLED))
		return;

	// check if we need to flush the profiling buffer
	if (thread->debug_info.profile.flush_needed)
		profiling_flush(NULL);

	// check whether post-syscall tracing is enabled for team or thread
	int32 threadDebugFlags = atomic_get(&thread->debug_info.flags);
	if (!(teamDebugFlags & B_TEAM_DEBUG_POST_SYSCALL)
			&& !(threadDebugFlags & B_THREAD_DEBUG_POST_SYSCALL)) {
		return;
	}

	bigtime_t startTime = 0;
	if (thread->debug_info.profile.samples == NULL) {
		startTime = thread->debug_info.profile.syscall_start_time;
		thread->debug_info.profile.syscall_start_time = 0;
	}

	// prepare the message
	debug_post_syscall message;
	message.start_time = startTime;
	message.end_time = system_time();
	message.return_value = returnValue;
	message.syscall = syscall;

	// copy the syscall args
	if (syscall < (uint32)kSyscallCount) {
		if (kSyscallInfos[syscall].parameter_size > 0)
			memcpy(message.args, args, kSyscallInfos[syscall].parameter_size);
	}

	thread_hit_debug_event(B_DEBUGGER_MESSAGE_POST_SYSCALL, &message,
		sizeof(message), true);
}


/**	\brief To be called when an unhandled processor exception (error/fault)
 *		   occurred.
 *	\param exception The debug_why_stopped value identifying the kind of fault.
 *	\param signal The signal corresponding to the exception.
 *	\return \c true, if the caller shall continue normally, i.e. usually send
 *			a deadly signal. \c false, if the debugger insists to continue the
 *			program (e.g. because it has solved the removed the cause of the
 *			problem).
 */
bool
user_debug_exception_occurred(debug_exception_type exception, int signal)
{
	// First check whether there's a signal handler installed for the signal.
	// If so, we don't want to install a debugger for the team. We always send
	// the signal instead. An already installed debugger will be notified, if
	// it has requested notifications of signal.
	struct sigaction signalAction;
	if (sigaction(signal, NULL, &signalAction) == 0
		&& signalAction.sa_handler != SIG_DFL) {
		return true;
	}

	// prepare the message
	debug_exception_occurred message;
	message.exception = exception;
	message.signal = signal;

	status_t result = thread_hit_serious_debug_event(
		B_DEBUGGER_MESSAGE_EXCEPTION_OCCURRED, &message, sizeof(message));
	return (result != B_THREAD_DEBUG_IGNORE_EVENT);
}


bool
user_debug_handle_signal(int signal, struct sigaction *handler, siginfo_t *info,
	bool deadly)
{
	// check, if a debugger is installed and is interested in signals
	Thread *thread = thread_get_current_thread();
	int32 teamDebugFlags = atomic_get(&thread->team->debug_info.flags);
	if (~teamDebugFlags
		& (B_TEAM_DEBUG_DEBUGGER_INSTALLED | B_TEAM_DEBUG_SIGNALS)) {
		return true;
	}

	// prepare the message
	debug_signal_received message;
	message.signal = signal;
	message.handler = *handler;
	message.info = *info;
	message.deadly = deadly;

	status_t result = thread_hit_debug_event(B_DEBUGGER_MESSAGE_SIGNAL_RECEIVED,
		&message, sizeof(message), true);
	return (result != B_THREAD_DEBUG_IGNORE_EVENT);
}


void
user_debug_stop_thread()
{
	// check whether this is actually an emulated single-step notification
	Thread* thread = thread_get_current_thread();
	InterruptsSpinLocker threadDebugInfoLocker(thread->debug_info.lock);

	bool singleStepped = false;
	if ((atomic_and(&thread->debug_info.flags,
				~B_THREAD_DEBUG_NOTIFY_SINGLE_STEP)
			& B_THREAD_DEBUG_NOTIFY_SINGLE_STEP) != 0) {
		singleStepped = true;
	}

	threadDebugInfoLocker.Unlock();

	if (singleStepped) {
		user_debug_single_stepped();
	} else {
		debug_thread_debugged message;
		thread_hit_serious_debug_event(B_DEBUGGER_MESSAGE_THREAD_DEBUGGED,
			&message, sizeof(message));
	}
}


void
user_debug_team_created(team_id teamID)
{
	// check, if a debugger is installed and is interested in team creation
	// events
	Thread *thread = thread_get_current_thread();
	int32 teamDebugFlags = atomic_get(&thread->team->debug_info.flags);
	if (~teamDebugFlags
		& (B_TEAM_DEBUG_DEBUGGER_INSTALLED | B_TEAM_DEBUG_TEAM_CREATION)) {
		return;
	}

	// prepare the message
	debug_team_created message;
	message.new_team = teamID;

	thread_hit_debug_event(B_DEBUGGER_MESSAGE_TEAM_CREATED, &message,
		sizeof(message), true);
}


void
user_debug_team_deleted(team_id teamID, port_id debuggerPort, status_t status, int signal,
	team_usage_info* usageInfo)
{
	if (debuggerPort >= 0) {
		TRACE(("user_debug_team_deleted(team: %" B_PRId32 ", debugger port: "
			"%" B_PRId32 ")\n", teamID, debuggerPort));

		debug_team_deleted message;
		message.origin.thread = -1;
		message.origin.team = teamID;
		message.origin.nub_port = -1;
		message.status = status;
		message.signal = signal;
		message.usage = *usageInfo;
		write_port_etc(debuggerPort, B_DEBUGGER_MESSAGE_TEAM_DELETED, &message,
			sizeof(message), B_RELATIVE_TIMEOUT, 0);
	}
}


void
user_debug_team_exec()
{
	// check, if a debugger is installed and is interested in team creation
	// events
	Thread *thread = thread_get_current_thread();
	int32 teamDebugFlags = atomic_get(&thread->team->debug_info.flags);
	if (~teamDebugFlags
		& (B_TEAM_DEBUG_DEBUGGER_INSTALLED | B_TEAM_DEBUG_TEAM_CREATION)) {
		return;
	}

	// prepare the message
	debug_team_exec message;
	message.image_event = atomic_add(&thread->team->debug_info.image_event, 1)
		+ 1;

	thread_hit_debug_event(B_DEBUGGER_MESSAGE_TEAM_EXEC, &message,
		sizeof(message), true);
}


/*!	Called by a new userland thread to update the debugging related flags of
	\c Thread::flags before the thread first enters userland.
	\param thread The calling thread.
*/
void
user_debug_update_new_thread_flags(Thread* thread)
{
	// lock it and update it's flags
	InterruptsSpinLocker threadDebugInfoLocker(thread->debug_info.lock);

	update_thread_user_debug_flag(thread);
	update_thread_breakpoints_flag(thread);
	update_thread_debugger_installed_flag(thread);
}


void
user_debug_thread_created(thread_id threadID)
{
	// check, if a debugger is installed and is interested in thread events
	Thread *thread = thread_get_current_thread();
	int32 teamDebugFlags = atomic_get(&thread->team->debug_info.flags);
	if (~teamDebugFlags
		& (B_TEAM_DEBUG_DEBUGGER_INSTALLED | B_TEAM_DEBUG_THREADS)) {
		return;
	}

	// prepare the message
	debug_thread_created message;
	message.new_thread = threadID;

	thread_hit_debug_event(B_DEBUGGER_MESSAGE_THREAD_CREATED, &message,
		sizeof(message), true);
}


void
user_debug_thread_deleted(team_id teamID, thread_id threadID, status_t status)
{
	// Things are a bit complicated here, since this thread no longer belongs to
	// the debugged team (but to the kernel). So we can't use debugger_write().

	// get the team debug flags and debugger port
	Team* team = Team::Get(teamID);
	if (team == NULL)
		return;
	BReference<Team> teamReference(team, true);

	InterruptsSpinLocker debugInfoLocker(team->debug_info.lock);

	int32 teamDebugFlags = atomic_get(&team->debug_info.flags);
	port_id debuggerPort = team->debug_info.debugger_port;
	sem_id writeLock = team->debug_info.debugger_write_lock;

	debugInfoLocker.Unlock();

	// check, if a debugger is installed and is interested in thread events
	if (~teamDebugFlags
		& (B_TEAM_DEBUG_DEBUGGER_INSTALLED | B_TEAM_DEBUG_THREADS)) {
		return;
	}

	// acquire the debugger write lock
	status_t error = acquire_sem_etc(writeLock, 1, B_KILL_CAN_INTERRUPT, 0);
	if (error != B_OK)
		return;

	// re-get the team debug info -- we need to check whether anything changed
	debugInfoLocker.Lock();

	teamDebugFlags = atomic_get(&team->debug_info.flags);
	port_id newDebuggerPort = team->debug_info.debugger_port;

	debugInfoLocker.Unlock();

	// Send the message only if the debugger hasn't changed in the meantime or
	// the team is about to be handed over.
	if (newDebuggerPort == debuggerPort
		|| (teamDebugFlags & B_TEAM_DEBUG_DEBUGGER_HANDOVER) == 0) {
		debug_thread_deleted message;
		message.origin.thread = threadID;
		message.origin.team = teamID;
		message.origin.nub_port = -1;
		message.status = status;

		write_port_etc(debuggerPort, B_DEBUGGER_MESSAGE_THREAD_DELETED,
			&message, sizeof(message), B_KILL_CAN_INTERRUPT, 0);
	}

	// release the debugger write lock
	release_sem(writeLock);
}


/*!	Called for a thread that is about to die, cleaning up all user debug
	facilities installed for the thread.
	\param thread The current thread, the one that is going to die.
*/
void
user_debug_thread_exiting(Thread* thread)
{
	// thread is the current thread, so using team is safe
	Team* team = thread->team;

	InterruptsLocker interruptsLocker;

	GRAB_TEAM_DEBUG_INFO_LOCK(team->debug_info);

	int32 teamDebugFlags = atomic_get(&team->debug_info.flags);
	port_id debuggerPort = team->debug_info.debugger_port;

	RELEASE_TEAM_DEBUG_INFO_LOCK(team->debug_info);

	// check, if a debugger is installed
	if ((teamDebugFlags & B_TEAM_DEBUG_DEBUGGER_INSTALLED) == 0
		|| debuggerPort < 0) {
		return;
	}

	// detach the profile info and mark the thread dying
	SpinLocker threadDebugInfoLocker(thread->debug_info.lock);

	thread_debug_info& threadDebugInfo = thread->debug_info;
	if (threadDebugInfo.profile.samples == NULL)
		return;

	area_id sampleArea = threadDebugInfo.profile.sample_area;
	int32 sampleCount = threadDebugInfo.profile.sample_count;
	int32 droppedTicks = threadDebugInfo.profile.dropped_ticks;
	int32 stackDepth = threadDebugInfo.profile.stack_depth;
	bool variableStackDepth = threadDebugInfo.profile.variable_stack_depth;
	int32 imageEvent = threadDebugInfo.profile.image_event;
	threadDebugInfo.profile.sample_area = -1;
	threadDebugInfo.profile.samples = NULL;
	threadDebugInfo.profile.flush_needed = false;
	bigtime_t lastCPUTime; {
		SpinLocker threadTimeLocker(thread->time_lock);
		lastCPUTime = thread->CPUTime(false);
	}

	atomic_or(&threadDebugInfo.flags, B_THREAD_DEBUG_DYING);

	threadDebugInfoLocker.Unlock();
	interruptsLocker.Unlock();

	// notify the debugger
	debug_profiler_update message;
	message.origin.thread = thread->id;
	message.origin.team = thread->team->id;
	message.origin.nub_port = -1;	// asynchronous message
	message.sample_count = sampleCount;
	message.dropped_ticks = droppedTicks;
	message.stack_depth = stackDepth;
	message.variable_stack_depth = variableStackDepth;
	message.image_event = imageEvent;
	message.stopped = true;
	message.last_cpu_time = lastCPUTime;
	debugger_write(debuggerPort, B_DEBUGGER_MESSAGE_PROFILER_UPDATE,
		&message, sizeof(message), false);

	if (sampleArea >= 0) {
		area_info areaInfo;
		if (get_area_info(sampleArea, &areaInfo) == B_OK) {
			unlock_memory(areaInfo.address, areaInfo.size, B_READ_DEVICE);
			delete_area(sampleArea);
		}
	}
}


void
user_debug_image_created(const image_info *imageInfo)
{
	// check, if a debugger is installed and is interested in image events
	Thread *thread = thread_get_current_thread();
	int32 teamDebugFlags = atomic_get(&thread->team->debug_info.flags);
	if (~teamDebugFlags
		& (B_TEAM_DEBUG_DEBUGGER_INSTALLED | B_TEAM_DEBUG_IMAGES)) {
		return;
	}

	// prepare the message
	debug_image_created message;
	memcpy(&message.info, imageInfo, sizeof(image_info));
	message.image_event = atomic_add(&thread->team->debug_info.image_event, 1)
		+ 1;

	thread_hit_debug_event(B_DEBUGGER_MESSAGE_IMAGE_CREATED, &message,
		sizeof(message), true);
}


void
user_debug_image_deleted(const image_info *imageInfo)
{
	// check, if a debugger is installed and is interested in image events
	Thread *thread = thread_get_current_thread();
	int32 teamDebugFlags = atomic_get(&thread->team->debug_info.flags);
	if (~teamDebugFlags
		& (B_TEAM_DEBUG_DEBUGGER_INSTALLED | B_TEAM_DEBUG_IMAGES)) {
		return;
	}

	// prepare the message
	debug_image_deleted message;
	memcpy(&message.info, imageInfo, sizeof(image_info));
	message.image_event = atomic_add(&thread->team->debug_info.image_event, 1)
		+ 1;

	thread_hit_debug_event(B_DEBUGGER_MESSAGE_IMAGE_DELETED, &message,
		sizeof(message), true);
}


void
user_debug_breakpoint_hit(bool software)
{
	// prepare the message
	debug_breakpoint_hit message;
	arch_get_debug_cpu_state(&message.cpu_state);

	thread_hit_serious_debug_event(B_DEBUGGER_MESSAGE_BREAKPOINT_HIT, &message,
		sizeof(message));
}


void
user_debug_watchpoint_hit()
{
	// prepare the message
	debug_watchpoint_hit message;
	arch_get_debug_cpu_state(&message.cpu_state);

	thread_hit_serious_debug_event(B_DEBUGGER_MESSAGE_WATCHPOINT_HIT, &message,
		sizeof(message));
}


void
user_debug_single_stepped()
{
	// clear the single-step thread flag
	Thread* thread = thread_get_current_thread();
	atomic_and(&thread->flags, ~(int32)THREAD_FLAGS_SINGLE_STEP);

	// prepare the message
	debug_single_step message;
	arch_get_debug_cpu_state(&message.cpu_state);

	thread_hit_serious_debug_event(B_DEBUGGER_MESSAGE_SINGLE_STEP, &message,
		sizeof(message));
}


/*!	Schedules the profiling timer for the current thread.
	The caller must hold the thread's debug info lock.
	\param thread The current thread.
	\param interval The time after which the timer should fire.
*/
static void
schedule_profiling_timer(Thread* thread, bigtime_t interval)
{
	struct timer* timer = &sProfilingTimers[thread->cpu->cpu_num];
	// Use the "hook" field to sanity-check that this timer is not scheduled.
	ASSERT(timer->hook == NULL);
	thread->debug_info.profile.installed_timer = timer;
	thread->debug_info.profile.timer_end = system_time() + interval;
	add_timer(timer, &profiling_event, interval, B_ONE_SHOT_RELATIVE_TIMER);
}


/*!	Returns the time remaining for the current profiling timer.
	The caller must hold the thread's debug info lock.
	\param thread The current thread.
*/
static bigtime_t
profiling_timer_left(Thread* thread)
{
	return thread->debug_info.profile.timer_end - system_time();
}


/*!	Samples the current thread's instruction pointer/stack trace.
	The caller must hold the current thread's debug info lock.
	\returns Whether the profiling timer should be rescheduled.
*/
static bool
profiling_do_sample()
{
	Thread* thread = thread_get_current_thread();
	thread_debug_info& debugInfo = thread->debug_info;

	if (debugInfo.profile.samples == NULL)
		return false;

	// Check, whether the buffer is full or an image event occurred since the
	// last sample was taken.
	int32 maxSamples = debugInfo.profile.max_samples;
	int32 sampleCount = debugInfo.profile.sample_count;
	int32 stackDepth = debugInfo.profile.stack_depth;
	int32 imageEvent = thread->team->debug_info.image_event;
	if (debugInfo.profile.sample_count > 0) {
		if (debugInfo.profile.last_image_event < imageEvent
			&& debugInfo.profile.variable_stack_depth
			&& sampleCount + 2 <= maxSamples) {
			// an image event occurred, but we use variable stack depth and
			// have enough room in the buffer to indicate an image event
			addr_t* event = debugInfo.profile.samples + sampleCount;
			event[0] = B_DEBUG_PROFILE_IMAGE_EVENT;
			event[1] = imageEvent;
			sampleCount += 2;
			debugInfo.profile.sample_count = sampleCount;
			debugInfo.profile.last_image_event = imageEvent;
		}

		if (debugInfo.profile.last_image_event < imageEvent
				|| debugInfo.profile.flush_threshold - sampleCount < stackDepth) {
			debugInfo.profile.flush_needed = true;

			// If the buffer is not full yet, we add the samples,
			// otherwise we have to drop them.
			if (maxSamples - sampleCount < stackDepth) {
				debugInfo.profile.dropped_ticks++;
				return true;
			}
		}
	} else {
		// first sample -- set the image event
		debugInfo.profile.image_event = imageEvent;
		debugInfo.profile.last_image_event = imageEvent;
	}

	// get the samples
	uint32 flags = STACK_TRACE_USER;
	int32 skipIFrames = 0;
	if (debugInfo.profile.profile_kernel) {
		flags |= STACK_TRACE_KERNEL;
		skipIFrames = 1;
	}

	addr_t* returnAddresses = debugInfo.profile.samples
		+ debugInfo.profile.sample_count;
	if (debugInfo.profile.variable_stack_depth) {
		// variable sample count per hit
		*returnAddresses = arch_debug_get_stack_trace(returnAddresses + 1,
			stackDepth - 1, skipIFrames, 0, flags);

		debugInfo.profile.sample_count += *returnAddresses + 1;
	} else {
		// fixed sample count per hit
		if (stackDepth > 1 || !debugInfo.profile.profile_kernel) {
			int32 count = arch_debug_get_stack_trace(returnAddresses,
				stackDepth, skipIFrames, 0, flags);

			for (int32 i = count; i < stackDepth; i++)
				returnAddresses[i] = 0;
		} else
			*returnAddresses = (addr_t)arch_debug_get_interrupt_pc(NULL);

		debugInfo.profile.sample_count += stackDepth;
	}

	return true;
}


static void
profiling_flush(void*)
{
	// This function may be called as a post_interrupt_callback. When it is,
	// it is undefined whether the function is called with interrupts enabled
	// or disabled. (When called elsewhere, interrupts will always be enabled.)
	// We are allowed to enable interrupts, though. First make sure interrupts
	// are disabled.
	disable_interrupts();

	Thread* thread = thread_get_current_thread();
	thread_debug_info& debugInfo = thread->debug_info;

	SpinLocker threadDebugInfoLocker(debugInfo.lock);

	if (debugInfo.profile.samples != NULL && debugInfo.profile.flush_needed) {
		int32 sampleCount = debugInfo.profile.sample_count;
		int32 droppedTicks = debugInfo.profile.dropped_ticks;
		int32 stackDepth = debugInfo.profile.stack_depth;
		bool variableStackDepth = debugInfo.profile.variable_stack_depth;
		int32 imageEvent = debugInfo.profile.image_event;

		// prevent the timer from running until after we flush
		bigtime_t interval = debugInfo.profile.interval;
		if (debugInfo.profile.installed_timer != NULL) {
			interval = max_c(profiling_timer_left(thread), 0);
			cancel_timer(debugInfo.profile.installed_timer);
			debugInfo.profile.installed_timer->hook = NULL;
			debugInfo.profile.installed_timer = NULL;
		}
		debugInfo.profile.interval_left = -1;

		// notify the debugger
		debugInfo.profile.sample_count = 0;
		debugInfo.profile.dropped_ticks = 0;
		debugInfo.profile.flush_needed = false;

		threadDebugInfoLocker.Unlock();
		enable_interrupts();

		// prepare the message
		debug_profiler_update message;
		message.sample_count = sampleCount;
		message.dropped_ticks = droppedTicks;
		message.stack_depth = stackDepth;
		message.variable_stack_depth = variableStackDepth;
		message.image_event = imageEvent;
		message.stopped = false;

		thread_hit_debug_event(B_DEBUGGER_MESSAGE_PROFILER_UPDATE, &message,
			sizeof(message), false);

		disable_interrupts();
		threadDebugInfoLocker.Lock();
		if (debugInfo.profile.samples != NULL)
			schedule_profiling_timer(thread, interval);
	}

	threadDebugInfoLocker.Unlock();
	enable_interrupts();
}


/*!	Profiling timer event callback.
	Called with interrupts disabled.
*/
static int32
profiling_event(timer* /*unused*/)
{
	Thread* thread = thread_get_current_thread();
	thread_debug_info& debugInfo = thread->debug_info;

	SpinLocker threadDebugInfoLocker(debugInfo.lock);
	debugInfo.profile.installed_timer->hook = NULL;
	debugInfo.profile.installed_timer = NULL;

	if (profiling_do_sample()) {
		// Check if the sample buffer needs to be flushed. We can't do it here,
		// since we're in an interrupt handler, and we can't set the callback
		// if we interrupted a kernel function, since the callback will pause
		// this thread. (The post_syscall hook will do the flush in that case.)
		if (debugInfo.profile.flush_needed
				&& !IS_KERNEL_ADDRESS(arch_debug_get_interrupt_pc(NULL))) {
			thread->post_interrupt_callback = profiling_flush;

			// We don't reschedule the timer here because profiling_flush() will
			// lead to the thread being descheduled until we are told to continue.
			// The timer will be rescheduled after the flush concludes.
			debugInfo.profile.interval_left = -1;
		} else
			schedule_profiling_timer(thread, debugInfo.profile.interval);
	}

	return B_HANDLED_INTERRUPT;
}


/*!	Called by the scheduler when a debugged thread has been unscheduled.
	The scheduler lock is being held.
*/
void
user_debug_thread_unscheduled(Thread* thread)
{
	SpinLocker threadDebugInfoLocker(thread->debug_info.lock);

	// if running, cancel the profiling timer
	struct timer* timer = thread->debug_info.profile.installed_timer;
	if (timer != NULL) {
		// track remaining time
		bigtime_t left = profiling_timer_left(thread);
		thread->debug_info.profile.interval_left = max_c(left, 0);
		thread->debug_info.profile.installed_timer->hook = NULL;
		thread->debug_info.profile.installed_timer = NULL;

		// cancel timer
		threadDebugInfoLocker.Unlock();
			// not necessary, but doesn't harm and reduces contention
		cancel_timer(timer);
			// since invoked on the same CPU, this will not possibly wait for
			// an already called timer hook
	}
}


/*!	Called by the scheduler when a debugged thread has been scheduled.
	The scheduler lock is being held.
*/
void
user_debug_thread_scheduled(Thread* thread)
{
	SpinLocker threadDebugInfoLocker(thread->debug_info.lock);

	if (thread->debug_info.profile.samples != NULL
			&& thread->debug_info.profile.interval_left >= 0) {
		// install profiling timer
		schedule_profiling_timer(thread,
			thread->debug_info.profile.interval_left);
	}
}


/*!	\brief Called by the debug nub thread of a team to broadcast a message to
		all threads of the team that are initialized for debugging (and
		thus have a debug port).
*/
static void
broadcast_debugged_thread_message(Thread *nubThread, int32 code,
	const void *message, int32 size)
{
	// iterate through the threads
	thread_info threadInfo;
	int32 cookie = 0;
	while (get_next_thread_info(nubThread->team->id, &cookie, &threadInfo)
			== B_OK) {
		// get the thread and lock it
		Thread* thread = Thread::GetAndLock(threadInfo.thread);
		if (thread == NULL)
			continue;

		BReference<Thread> threadReference(thread, true);
		ThreadLocker threadLocker(thread, true);

		// get the thread's debug port
		InterruptsSpinLocker threadDebugInfoLocker(thread->debug_info.lock);

		port_id threadDebugPort = -1;
		if (thread && thread != nubThread && thread->team == nubThread->team
			&& (thread->debug_info.flags & B_THREAD_DEBUG_INITIALIZED) != 0
			&& (thread->debug_info.flags & B_THREAD_DEBUG_STOPPED) != 0) {
			threadDebugPort = thread->debug_info.debug_port;
		}

		threadDebugInfoLocker.Unlock();
		threadLocker.Unlock();

		// send the message to the thread
		if (threadDebugPort >= 0) {
			status_t error = kill_interruptable_write_port(threadDebugPort,
				code, message, size);
			if (error != B_OK) {
				TRACE(("broadcast_debugged_thread_message(): Failed to send "
					"message to thread %" B_PRId32 ": %" B_PRIx32 "\n",
					thread->id, error));
			}
		}
	}
}


static void
nub_thread_cleanup(Thread *nubThread)
{
	TRACE(("nub_thread_cleanup(%" B_PRId32 "): debugger port: %" B_PRId32 "\n",
		nubThread->id, nubThread->team->debug_info.debugger_port));

	ConditionVariable debugChangeCondition;
	debugChangeCondition.Init(nubThread->team, "debug change condition");
	prepare_debugger_change(nubThread->team, debugChangeCondition);

	team_debug_info teamDebugInfo;
	bool destroyDebugInfo = false;

	TeamLocker teamLocker(nubThread->team);
		// required by update_threads_debugger_installed_flag()

	cpu_status state = disable_interrupts();
	GRAB_TEAM_DEBUG_INFO_LOCK(nubThread->team->debug_info);

	team_debug_info &info = nubThread->team->debug_info;
	if (info.flags & B_TEAM_DEBUG_DEBUGGER_INSTALLED
			&& info.nub_thread == nubThread->id) {
		teamDebugInfo = info;
		clear_team_debug_info(&info, false);
		destroyDebugInfo = true;
	}

	// update the thread::flags fields
	update_threads_debugger_installed_flag(nubThread->team);

	RELEASE_TEAM_DEBUG_INFO_LOCK(nubThread->team->debug_info);
	restore_interrupts(state);

	teamLocker.Unlock();

	if (destroyDebugInfo)
		teamDebugInfo.breakpoint_manager->RemoveAllBreakpoints();

	finish_debugger_change(nubThread->team);

	if (destroyDebugInfo)
		destroy_team_debug_info(&teamDebugInfo);

	// notify all threads that the debugger is gone
	broadcast_debugged_thread_message(nubThread,
		B_DEBUGGED_THREAD_DEBUGGER_CHANGED, NULL, 0);
}


/**	\brief Debug nub thread helper function that returns the debug port of
 *		   a thread of the same team.
 */
static status_t
debug_nub_thread_get_thread_debug_port(Thread *nubThread,
	thread_id threadID, port_id &threadDebugPort)
{
	threadDebugPort = -1;

	// get the thread
	Thread* thread = Thread::GetAndLock(threadID);
	if (thread == NULL)
		return B_BAD_THREAD_ID;
	BReference<Thread> threadReference(thread, true);
	ThreadLocker threadLocker(thread, true);

	// get the debug port
	InterruptsSpinLocker threadDebugInfoLocker(thread->debug_info.lock);

	if (thread->team != nubThread->team)
		return B_BAD_VALUE;
	if ((thread->debug_info.flags & B_THREAD_DEBUG_STOPPED) == 0)
		return B_BAD_THREAD_STATE;

	threadDebugPort = thread->debug_info.debug_port;

	threadDebugInfoLocker.Unlock();

	if (threadDebugPort < 0)
		return B_ERROR;

	return B_OK;
}


static status_t
debug_nub_thread(void *)
{
	Thread *nubThread = thread_get_current_thread();

	// check, if we're still the current nub thread and get our port
	cpu_status state = disable_interrupts();
	GRAB_TEAM_DEBUG_INFO_LOCK(nubThread->team->debug_info);

	if (nubThread->team->debug_info.nub_thread != nubThread->id) {
		RELEASE_TEAM_DEBUG_INFO_LOCK(nubThread->team->debug_info);
		restore_interrupts(state);
		return 0;
	}

	port_id port = nubThread->team->debug_info.nub_port;
	sem_id writeLock = nubThread->team->debug_info.debugger_write_lock;
	BreakpointManager* breakpointManager
		= nubThread->team->debug_info.breakpoint_manager;

	RELEASE_TEAM_DEBUG_INFO_LOCK(nubThread->team->debug_info);
	restore_interrupts(state);

	TRACE(("debug_nub_thread() thread: %" B_PRId32 ", team %" B_PRId32 ", nub "
		"port: %" B_PRId32 "\n", nubThread->id, nubThread->team->id, port));

	// notify all threads that a debugger has been installed
	broadcast_debugged_thread_message(nubThread,
		B_DEBUGGED_THREAD_DEBUGGER_CHANGED, NULL, 0);

	// command processing loop
	while (true) {
		int32 command;
		debug_nub_message_data message;
		ssize_t messageSize = read_port_etc(port, &command, &message,
			sizeof(message), B_KILL_CAN_INTERRUPT, 0);

		if (messageSize < 0) {
			// The port is no longer valid or we were interrupted by a kill
			// signal: If we are still listed in the team's debug info as nub
			// thread, we need to update that.
			nub_thread_cleanup(nubThread);

			TRACE(("nub thread %" B_PRId32 ": terminating: %lx\n",
				nubThread->id, messageSize));

			return messageSize;
		}

		bool sendReply = false;
		union {
			debug_nub_read_memory_reply			read_memory;
			debug_nub_write_memory_reply		write_memory;
			debug_nub_clone_area_reply			clone_area;
			debug_nub_get_cpu_state_reply		get_cpu_state;
			debug_nub_set_breakpoint_reply		set_breakpoint;
			debug_nub_set_watchpoint_reply		set_watchpoint;
			debug_nub_get_signal_masks_reply	get_signal_masks;
			debug_nub_get_signal_handler_reply	get_signal_handler;
			debug_nub_start_profiler_reply		start_profiler;
			debug_profiler_update				profiler_update;
			debug_nub_write_core_file_reply		write_core_file;
		} reply;
		int32 replySize = 0;
		port_id replyPort = -1;

		// process the command
		switch (command) {
			case B_DEBUG_MESSAGE_READ_MEMORY:
			{
				// get the parameters
				replyPort = message.read_memory.reply_port;
				void *address = message.read_memory.address;
				int32 size = message.read_memory.size;
				status_t result = B_OK;

				// check the parameters
				if (!BreakpointManager::CanAccessAddress(address, false))
					result = B_BAD_ADDRESS;
				else if (size <= 0 || size > B_MAX_READ_WRITE_MEMORY_SIZE)
					result = B_BAD_VALUE;

				// read the memory
				size_t bytesRead = 0;
				if (result == B_OK) {
					result = breakpointManager->ReadMemory(address,
						reply.read_memory.data, size, bytesRead);
				}
				reply.read_memory.error = result;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_READ_MEMORY: "
					"reply port: %" B_PRId32 ", address: %p, size: %" B_PRId32
					", result: %" B_PRIx32 ", read: %ld\n", nubThread->id,
					replyPort, address, size, result, bytesRead));

				// send only as much data as necessary
				reply.read_memory.size = bytesRead;
				replySize = reply.read_memory.data + bytesRead - (char*)&reply;
				sendReply = true;
				break;
			}

			case B_DEBUG_MESSAGE_WRITE_MEMORY:
			{
				// get the parameters
				replyPort = message.write_memory.reply_port;
				void *address = message.write_memory.address;
				int32 size = message.write_memory.size;
				const char *data = message.write_memory.data;
				int32 realSize = (char*)&message + messageSize - data;
				status_t result = B_OK;

				// check the parameters
				if (!BreakpointManager::CanAccessAddress(address, true))
					result = B_BAD_ADDRESS;
				else if (size <= 0 || size > realSize)
					result = B_BAD_VALUE;

				// write the memory
				size_t bytesWritten = 0;
				if (result == B_OK) {
					result = breakpointManager->WriteMemory(address, data, size,
						bytesWritten);
				}
				reply.write_memory.error = result;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_WRITE_MEMORY: "
					"reply port: %" B_PRId32 ", address: %p, size: %" B_PRId32
					", result: %" B_PRIx32 ", written: %ld\n", nubThread->id,
					replyPort, address, size, result, bytesWritten));

				reply.write_memory.size = bytesWritten;
				sendReply = true;
				replySize = sizeof(debug_nub_write_memory_reply);
				break;
			}

			case B_DEBUG_MESSAGE_CLONE_AREA:
			{
				// get the parameters
				replyPort = message.clone_area.reply_port;
				const void *address = message.clone_area.address;
				area_id result = 0;

				// check the parameters
				if (!IS_USER_ADDRESS(address))
					result = B_NOT_ALLOWED;

				// find the area
				area_id sourceArea;
				addr_t addressOffset = 0;
				if (result == B_OK) {
					sourceArea = _user_area_for((void*)address);
					if (sourceArea < 0) {
						result = sourceArea;
					} else {
						area_info info;
						result = get_area_info(sourceArea, &info);
						addressOffset = (addr_t)address - (addr_t)info.address;
					}
				}

				// clone it
				if (result == B_OK) {
					void* newAddress = NULL;
					result = vm_clone_area(nubThread->team->debug_info.debugger_team,
						"debugger-cloned area", &newAddress, B_ANY_ADDRESS, B_READ_AREA,
						REGION_NO_PRIVATE_MAP, sourceArea, true);
					reply.clone_area.address = (void*)((addr_t)newAddress + addressOffset);
				}

				reply.clone_area.area = result;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_CLONE_AREA: "
					"reply port: %" B_PRId32 ", address: %p, result: %" B_PRIx32 "\n",
					nubThread->id, replyPort, address, result));

				sendReply = true;
				replySize = sizeof(debug_nub_clone_area_reply);
				break;
			}

			case B_DEBUG_MESSAGE_SET_TEAM_FLAGS:
			{
				// get the parameters
				int32 flags = message.set_team_flags.flags
					& B_TEAM_DEBUG_USER_FLAG_MASK;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_SET_TEAM_FLAGS"
					": flags: %" B_PRIx32 "\n", nubThread->id, flags));

				Team *team = thread_get_current_thread()->team;

				// set the flags
				cpu_status state = disable_interrupts();
				GRAB_TEAM_DEBUG_INFO_LOCK(team->debug_info);

				flags |= team->debug_info.flags & B_TEAM_DEBUG_KERNEL_FLAG_MASK;
				atomic_set(&team->debug_info.flags, flags);

				RELEASE_TEAM_DEBUG_INFO_LOCK(team->debug_info);
				restore_interrupts(state);

				break;
			}

			case B_DEBUG_MESSAGE_SET_THREAD_FLAGS:
			{
				// get the parameters
				thread_id threadID = message.set_thread_flags.thread;
				int32 flags = message.set_thread_flags.flags
					& B_THREAD_DEBUG_USER_FLAG_MASK;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_SET_THREAD_FLAGS"
					": thread: %" B_PRId32 ", flags: %" B_PRIx32 "\n",
					nubThread->id, threadID, flags));

				// set the flags
				Thread* thread = Thread::GetAndLock(threadID);
				if (thread == NULL)
					break;
				BReference<Thread> threadReference(thread, true);
				ThreadLocker threadLocker(thread, true);

				InterruptsSpinLocker threadDebugInfoLocker(
					thread->debug_info.lock);

				if (thread->team == thread_get_current_thread()->team) {
					flags |= thread->debug_info.flags
						& B_THREAD_DEBUG_KERNEL_FLAG_MASK;
					atomic_set(&thread->debug_info.flags, flags);
				}

				break;
			}

			case B_DEBUG_MESSAGE_CONTINUE_THREAD:
			{
				// get the parameters
				thread_id threadID;
				uint32 handleEvent;
				bool singleStep;

				threadID = message.continue_thread.thread;
				handleEvent = message.continue_thread.handle_event;
				singleStep = message.continue_thread.single_step;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_CONTINUE_THREAD"
					": thread: %" B_PRId32 ", handle event: %" B_PRIu32 ", "
					"single step: %d\n", nubThread->id, threadID, handleEvent,
					singleStep));

				// find the thread and get its debug port
				port_id threadDebugPort = -1;
				status_t result = debug_nub_thread_get_thread_debug_port(
					nubThread, threadID, threadDebugPort);

				// send a message to the debugged thread
				if (result == B_OK) {
					debugged_thread_continue commandMessage;
					commandMessage.handle_event = handleEvent;
					commandMessage.single_step = singleStep;

					result = write_port(threadDebugPort,
						B_DEBUGGED_THREAD_MESSAGE_CONTINUE,
						&commandMessage, sizeof(commandMessage));
				} else if (result == B_BAD_THREAD_STATE) {
					Thread* thread = Thread::GetAndLock(threadID);
					if (thread == NULL)
						break;

					BReference<Thread> threadReference(thread, true);
					ThreadLocker threadLocker(thread, true);
					if (thread->state == B_THREAD_SUSPENDED) {
						threadLocker.Unlock();
						resume_thread(threadID);
						break;
					}
				}

				break;
			}

			case B_DEBUG_MESSAGE_SET_CPU_STATE:
			{
				// get the parameters
				thread_id threadID = message.set_cpu_state.thread;
				const debug_cpu_state &cpuState
					= message.set_cpu_state.cpu_state;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_SET_CPU_STATE"
					": thread: %" B_PRId32 "\n", nubThread->id, threadID));

				// find the thread and get its debug port
				port_id threadDebugPort = -1;
				status_t result = debug_nub_thread_get_thread_debug_port(
					nubThread, threadID, threadDebugPort);

				// send a message to the debugged thread
				if (result == B_OK) {
					debugged_thread_set_cpu_state commandMessage;
					memcpy(&commandMessage.cpu_state, &cpuState,
						sizeof(debug_cpu_state));
					write_port(threadDebugPort,
						B_DEBUGGED_THREAD_SET_CPU_STATE,
						&commandMessage, sizeof(commandMessage));
				}

				break;
			}

			case B_DEBUG_MESSAGE_GET_CPU_STATE:
			{
				// get the parameters
				thread_id threadID = message.get_cpu_state.thread;
				replyPort = message.get_cpu_state.reply_port;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_GET_CPU_STATE"
					": thread: %" B_PRId32 "\n", nubThread->id, threadID));

				// find the thread and get its debug port
				port_id threadDebugPort = -1;
				status_t result = debug_nub_thread_get_thread_debug_port(
					nubThread, threadID, threadDebugPort);

				// send a message to the debugged thread
				if (threadDebugPort >= 0) {
					debugged_thread_get_cpu_state commandMessage;
					commandMessage.reply_port = replyPort;
					result = write_port(threadDebugPort,
						B_DEBUGGED_THREAD_GET_CPU_STATE, &commandMessage,
						sizeof(commandMessage));
				}

				// send a reply to the debugger in case of error
				if (result != B_OK) {
					reply.get_cpu_state.error = result;
					sendReply = true;
					replySize = sizeof(reply.get_cpu_state);
				}

				break;
			}

			case B_DEBUG_MESSAGE_SET_BREAKPOINT:
			{
				// get the parameters
				replyPort = message.set_breakpoint.reply_port;
				void *address = message.set_breakpoint.address;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_SET_BREAKPOINT"
					": address: %p\n", nubThread->id, address));

				// check the address
				status_t result = B_OK;
				if (address == NULL
					|| !BreakpointManager::CanAccessAddress(address, false)) {
					result = B_BAD_ADDRESS;
				}

				// set the breakpoint
				if (result == B_OK)
					result = breakpointManager->InstallBreakpoint(address);

				if (result == B_OK)
					update_threads_breakpoints_flag();

				// prepare the reply
				reply.set_breakpoint.error = result;
				replySize = sizeof(reply.set_breakpoint);
				sendReply = true;

				break;
			}

			case B_DEBUG_MESSAGE_CLEAR_BREAKPOINT:
			{
				// get the parameters
				void *address = message.clear_breakpoint.address;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_CLEAR_BREAKPOINT"
					": address: %p\n", nubThread->id, address));

				// check the address
				status_t result = B_OK;
				if (address == NULL
					|| !BreakpointManager::CanAccessAddress(address, false)) {
					result = B_BAD_ADDRESS;
				}

				// clear the breakpoint
				if (result == B_OK)
					result = breakpointManager->UninstallBreakpoint(address);

				if (result == B_OK)
					update_threads_breakpoints_flag();

				break;
			}

			case B_DEBUG_MESSAGE_SET_WATCHPOINT:
			{
				// get the parameters
				replyPort = message.set_watchpoint.reply_port;
				void *address = message.set_watchpoint.address;
				uint32 type = message.set_watchpoint.type;
				int32 length = message.set_watchpoint.length;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_SET_WATCHPOINT"
					": address: %p, type: %" B_PRIu32 ", length: %" B_PRId32 "\n",
					nubThread->id, address, type, length));

				// check the address and size
				status_t result = B_OK;
				if (address == NULL
					|| !BreakpointManager::CanAccessAddress(address, false)) {
					result = B_BAD_ADDRESS;
				}
				if (length < 0)
					result = B_BAD_VALUE;

				// set the watchpoint
				if (result == B_OK) {
					result = breakpointManager->InstallWatchpoint(address, type,
						length);
				}

				if (result == B_OK)
					update_threads_breakpoints_flag();

				// prepare the reply
				reply.set_watchpoint.error = result;
				replySize = sizeof(reply.set_watchpoint);
				sendReply = true;

				break;
			}

			case B_DEBUG_MESSAGE_CLEAR_WATCHPOINT:
			{
				// get the parameters
				void *address = message.clear_watchpoint.address;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_CLEAR_WATCHPOINT"
					": address: %p\n", nubThread->id, address));

				// check the address
				status_t result = B_OK;
				if (address == NULL
					|| !BreakpointManager::CanAccessAddress(address, false)) {
					result = B_BAD_ADDRESS;
				}

				// clear the watchpoint
				if (result == B_OK)
					result = breakpointManager->UninstallWatchpoint(address);

				if (result == B_OK)
					update_threads_breakpoints_flag();

				break;
			}

			case B_DEBUG_MESSAGE_SET_SIGNAL_MASKS:
			{
				// get the parameters
				thread_id threadID = message.set_signal_masks.thread;
				uint64 ignore = message.set_signal_masks.ignore_mask;
				uint64 ignoreOnce = message.set_signal_masks.ignore_once_mask;
				uint32 ignoreOp = message.set_signal_masks.ignore_op;
				uint32 ignoreOnceOp = message.set_signal_masks.ignore_once_op;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_SET_SIGNAL_MASKS"
					": thread: %" B_PRId32 ", ignore: %" B_PRIx64 " (op: %"
					B_PRIu32 "), ignore once: %" B_PRIx64 " (op: %" B_PRIu32
					")\n", nubThread->id, threadID, ignore, ignoreOp,
					ignoreOnce, ignoreOnceOp));

				// set the masks
				Thread* thread = Thread::GetAndLock(threadID);
				if (thread == NULL)
					break;
				BReference<Thread> threadReference(thread, true);
				ThreadLocker threadLocker(thread, true);

				InterruptsSpinLocker threadDebugInfoLocker(
					thread->debug_info.lock);

				if (thread->team == thread_get_current_thread()->team) {
					thread_debug_info &threadDebugInfo = thread->debug_info;
					// set ignore mask
					switch (ignoreOp) {
						case B_DEBUG_SIGNAL_MASK_AND:
							threadDebugInfo.ignore_signals &= ignore;
							break;
						case B_DEBUG_SIGNAL_MASK_OR:
							threadDebugInfo.ignore_signals |= ignore;
							break;
						case B_DEBUG_SIGNAL_MASK_SET:
							threadDebugInfo.ignore_signals = ignore;
							break;
					}

					// set ignore once mask
					switch (ignoreOnceOp) {
						case B_DEBUG_SIGNAL_MASK_AND:
							threadDebugInfo.ignore_signals_once &= ignoreOnce;
							break;
						case B_DEBUG_SIGNAL_MASK_OR:
							threadDebugInfo.ignore_signals_once |= ignoreOnce;
							break;
						case B_DEBUG_SIGNAL_MASK_SET:
							threadDebugInfo.ignore_signals_once = ignoreOnce;
							break;
					}
				}

				break;
			}

			case B_DEBUG_MESSAGE_GET_SIGNAL_MASKS:
			{
				// get the parameters
				replyPort = message.get_signal_masks.reply_port;
				thread_id threadID = message.get_signal_masks.thread;
				status_t result = B_OK;

				// get the masks
				uint64 ignore = 0;
				uint64 ignoreOnce = 0;

				Thread* thread = Thread::GetAndLock(threadID);
				if (thread != NULL) {
					BReference<Thread> threadReference(thread, true);
					ThreadLocker threadLocker(thread, true);

					InterruptsSpinLocker threadDebugInfoLocker(
						thread->debug_info.lock);

					ignore = thread->debug_info.ignore_signals;
					ignoreOnce = thread->debug_info.ignore_signals_once;
				} else
					result = B_BAD_THREAD_ID;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_GET_SIGNAL_MASKS"
					": reply port: %" B_PRId32 ", thread: %" B_PRId32 ", "
					"ignore: %" B_PRIx64 ", ignore once: %" B_PRIx64 ", result: "
					"%" B_PRIx32 "\n", nubThread->id, replyPort, threadID,
					ignore, ignoreOnce, result));

				// prepare the message
				reply.get_signal_masks.error = result;
				reply.get_signal_masks.ignore_mask = ignore;
				reply.get_signal_masks.ignore_once_mask = ignoreOnce;
				replySize = sizeof(reply.get_signal_masks);
				sendReply = true;
				break;
			}

			case B_DEBUG_MESSAGE_SET_SIGNAL_HANDLER:
			{
				// get the parameters
				int signal = message.set_signal_handler.signal;
				struct sigaction &handler = message.set_signal_handler.handler;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_SET_SIGNAL_HANDLER"
					": signal: %d, handler: %p\n", nubThread->id, signal,
					handler.sa_handler));

				// set the handler
				sigaction(signal, &handler, NULL);

				break;
			}

			case B_DEBUG_MESSAGE_GET_SIGNAL_HANDLER:
			{
				// get the parameters
				replyPort = message.get_signal_handler.reply_port;
				int signal = message.get_signal_handler.signal;
				status_t result = B_OK;

				// get the handler
				if (sigaction(signal, NULL, &reply.get_signal_handler.handler)
						!= 0) {
					result = errno;
				}

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_GET_SIGNAL_HANDLER"
					": reply port: %" B_PRId32 ", signal: %d, handler: %p\n",
					nubThread->id, replyPort, signal,
					reply.get_signal_handler.handler.sa_handler));

				// prepare the message
				reply.get_signal_handler.error = result;
				replySize = sizeof(reply.get_signal_handler);
				sendReply = true;
				break;
			}

			case B_DEBUG_MESSAGE_PREPARE_HANDOVER:
			{
				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_MESSAGE_PREPARE_HANDOVER"
					"\n", nubThread->id));

				Team *team = nubThread->team;

				// Acquire the debugger write lock. As soon as we have it and
				// have set the B_TEAM_DEBUG_DEBUGGER_HANDOVER flag, no thread
				// will write anything to the debugger port anymore.
				status_t result = acquire_sem_etc(writeLock, 1,
					B_KILL_CAN_INTERRUPT, 0);
				if (result == B_OK) {
					// set the respective team debug flag
					cpu_status state = disable_interrupts();
					GRAB_TEAM_DEBUG_INFO_LOCK(team->debug_info);

					atomic_or(&team->debug_info.flags,
						B_TEAM_DEBUG_DEBUGGER_HANDOVER);
					BreakpointManager* breakpointManager
						= team->debug_info.breakpoint_manager;

					RELEASE_TEAM_DEBUG_INFO_LOCK(team->debug_info);
					restore_interrupts(state);

					// remove all installed breakpoints
					breakpointManager->RemoveAllBreakpoints();

					release_sem(writeLock);
				} else {
					// We probably got a SIGKILL. If so, we will terminate when
					// reading the next message fails.
				}

				break;
			}

			case B_DEBUG_MESSAGE_HANDED_OVER:
			{
				// notify all threads that the debugger has changed
				broadcast_debugged_thread_message(nubThread,
					B_DEBUGGED_THREAD_DEBUGGER_CHANGED, NULL, 0);

				break;
			}

			case B_DEBUG_MESSAGE_START_PROFILER:
			{
				// get the parameters
				thread_id threadID = message.start_profiler.thread;
				replyPort = message.start_profiler.reply_port;
				area_id sampleArea = message.start_profiler.sample_area;
				int32 stackDepth = message.start_profiler.stack_depth;
				bool variableStackDepth
					= message.start_profiler.variable_stack_depth;
				bool profileKernel = message.start_profiler.profile_kernel;
				bigtime_t interval = max_c(message.start_profiler.interval,
					B_DEBUG_MIN_PROFILE_INTERVAL);
				status_t result = B_OK;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_START_PROFILER: "
					"thread: %" B_PRId32 ", sample area: %" B_PRId32 "\n",
					nubThread->id, threadID, sampleArea));

				if (stackDepth < 1)
					stackDepth = 1;
				else if (stackDepth > B_DEBUG_STACK_TRACE_DEPTH)
					stackDepth = B_DEBUG_STACK_TRACE_DEPTH;

				// provision for an extra entry per hit (for the number of
				// samples), if variable stack depth
				if (variableStackDepth)
					stackDepth++;

				// clone the sample area
				area_info areaInfo;
				if (result == B_OK)
					result = get_area_info(sampleArea, &areaInfo);

				area_id clonedSampleArea = -1;
				void* samples = NULL;
				if (result == B_OK) {
					clonedSampleArea = clone_area("profiling samples", &samples,
						B_ANY_KERNEL_ADDRESS,
						B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA,
						sampleArea);
					if (clonedSampleArea >= 0) {
						// we need the memory locked
						result = lock_memory(samples, areaInfo.size,
							B_READ_DEVICE);
						if (result != B_OK) {
							delete_area(clonedSampleArea);
							clonedSampleArea = -1;
						}
					} else
						result = clonedSampleArea;
				}

				// get the thread and set the profile info
				int32 imageEvent = nubThread->team->debug_info.image_event;
				if (result == B_OK) {
					Thread* thread = Thread::GetAndLock(threadID);
					BReference<Thread> threadReference(thread, true);
					ThreadLocker threadLocker(thread, true);

					if (thread != NULL && thread->team == nubThread->team) {
						thread_debug_info &threadDebugInfo = thread->debug_info;

						InterruptsSpinLocker threadDebugInfoLocker(
							threadDebugInfo.lock);

						if (threadDebugInfo.profile.samples == NULL) {
							threadDebugInfo.profile.interval = interval;
							threadDebugInfo.profile.sample_area
								= clonedSampleArea;
							threadDebugInfo.profile.samples = (addr_t*)samples;
							threadDebugInfo.profile.max_samples
								= areaInfo.size / sizeof(addr_t);
							threadDebugInfo.profile.flush_threshold
								= threadDebugInfo.profile.max_samples
									* B_DEBUG_PROFILE_BUFFER_FLUSH_THRESHOLD
									/ 100;
							threadDebugInfo.profile.sample_count = 0;
							threadDebugInfo.profile.dropped_ticks = 0;
							threadDebugInfo.profile.stack_depth = stackDepth;
							threadDebugInfo.profile.variable_stack_depth
								= variableStackDepth;
							threadDebugInfo.profile.profile_kernel = profileKernel;
							threadDebugInfo.profile.flush_needed = false;
							threadDebugInfo.profile.interval_left = interval;
							threadDebugInfo.profile.installed_timer = NULL;
							threadDebugInfo.profile.image_event = imageEvent;
							threadDebugInfo.profile.last_image_event
								= imageEvent;
						} else
							result = B_BAD_VALUE;
					} else
						result = B_BAD_THREAD_ID;
				}

				// on error unlock and delete the sample area
				if (result != B_OK) {
					if (clonedSampleArea >= 0) {
						unlock_memory(samples, areaInfo.size, B_READ_DEVICE);
						delete_area(clonedSampleArea);
					}
				}

				// send a reply to the debugger
				reply.start_profiler.error = result;
				reply.start_profiler.interval = interval;
				reply.start_profiler.image_event = imageEvent;
				sendReply = true;
				replySize = sizeof(reply.start_profiler);

				break;
			}

			case B_DEBUG_MESSAGE_STOP_PROFILER:
			{
				// get the parameters
				thread_id threadID = message.stop_profiler.thread;
				replyPort = message.stop_profiler.reply_port;
				status_t result = B_OK;

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_STOP_PROFILER: "
					"thread: %" B_PRId32 "\n", nubThread->id, threadID));

				area_id sampleArea = -1;
				addr_t* samples = NULL;
				int32 sampleCount = 0;
				int32 stackDepth = 0;
				bool variableStackDepth = false;
				int32 imageEvent = 0;
				int32 droppedTicks = 0;
				bigtime_t lastCPUTime = 0;

				// get the thread and detach the profile info
				Thread* thread = Thread::GetAndLock(threadID);
				BReference<Thread> threadReference(thread, true);
				ThreadLocker threadLocker(thread, true);

				if (thread && thread->team == nubThread->team) {
					thread_debug_info &threadDebugInfo = thread->debug_info;

					InterruptsSpinLocker threadDebugInfoLocker(
						threadDebugInfo.lock);

					if (threadDebugInfo.profile.samples != NULL) {
						sampleArea = threadDebugInfo.profile.sample_area;
						samples = threadDebugInfo.profile.samples;
						sampleCount = threadDebugInfo.profile.sample_count;
						droppedTicks = threadDebugInfo.profile.dropped_ticks;
						stackDepth = threadDebugInfo.profile.stack_depth;
						variableStackDepth
							= threadDebugInfo.profile.variable_stack_depth;
						imageEvent = threadDebugInfo.profile.image_event;
						threadDebugInfo.profile.sample_area = -1;
						threadDebugInfo.profile.samples = NULL;
						threadDebugInfo.profile.flush_needed = false;
						threadDebugInfo.profile.dropped_ticks = 0;
						{
							SpinLocker threadTimeLocker(thread->time_lock);
							lastCPUTime = thread->CPUTime(false);
						}
					} else
						result = B_BAD_VALUE;
				} else
					result = B_BAD_THREAD_ID;

				threadLocker.Unlock();

				// prepare the reply
				if (result == B_OK) {
					reply.profiler_update.origin.thread = threadID;
					reply.profiler_update.image_event = imageEvent;
					reply.profiler_update.stack_depth = stackDepth;
					reply.profiler_update.variable_stack_depth
						= variableStackDepth;
					reply.profiler_update.sample_count = sampleCount;
					reply.profiler_update.dropped_ticks = droppedTicks;
					reply.profiler_update.stopped = true;
					reply.profiler_update.last_cpu_time = lastCPUTime;
				} else
					reply.profiler_update.origin.thread = result;

				replySize = sizeof(debug_profiler_update);
				sendReply = true;

				if (sampleArea >= 0) {
					area_info areaInfo;
					if (get_area_info(sampleArea, &areaInfo) == B_OK) {
						unlock_memory(samples, areaInfo.size, B_READ_DEVICE);
						delete_area(sampleArea);
					}
				}

				break;
			}

			case B_DEBUG_MESSAGE_WRITE_CORE_FILE:
			{
				// get the parameters
				replyPort = message.write_core_file.reply_port;
				char* path = message.write_core_file.path;
				path[sizeof(message.write_core_file.path) - 1] = '\0';

				TRACE(("nub thread %" B_PRId32 ": B_DEBUG_WRITE_CORE_FILE"
					": path: %s\n", nubThread->id, path));

				// write the core file
				status_t result = core_dump_write_core_file(path, false);

				// prepare the reply
				reply.write_core_file.error = result;
				replySize = sizeof(reply.write_core_file);
				sendReply = true;

				break;
			}
		}

		// send the reply, if necessary
		if (sendReply) {
			status_t error = kill_interruptable_write_port(replyPort, command,
				&reply, replySize);

			if (error != B_OK) {
				// The debugger port is either not longer existing or we got
				// interrupted by a kill signal. In either case we terminate.
				TRACE(("nub thread %" B_PRId32 ": failed to send reply to port "
					"%" B_PRId32 ": %s\n", nubThread->id, replyPort,
					strerror(error)));

				nub_thread_cleanup(nubThread);
				return error;
			}
		}
	}
}


/**	\brief Helper function for install_team_debugger(), that sets up the team
		   and thread debug infos.

	The caller must hold the team's lock as well as the team debug info lock.

	The function also clears the arch specific team and thread debug infos
	(including among other things formerly set break/watchpoints).
 */
static void
install_team_debugger_init_debug_infos(Team *team, team_id debuggerTeam,
	port_id debuggerPort, port_id nubPort, thread_id nubThread,
	sem_id debuggerPortWriteLock, thread_id causingThread)
{
	atomic_set(&team->debug_info.flags,
		B_TEAM_DEBUG_DEFAULT_FLAGS | B_TEAM_DEBUG_DEBUGGER_INSTALLED);
	team->debug_info.nub_port = nubPort;
	team->debug_info.nub_thread = nubThread;
	team->debug_info.debugger_team = debuggerTeam;
	team->debug_info.debugger_port = debuggerPort;
	team->debug_info.debugger_write_lock = debuggerPortWriteLock;
	team->debug_info.causing_thread = causingThread;

	arch_clear_team_debug_info(&team->debug_info.arch_info);

	// set the user debug flags and signal masks of all threads to the default
	for (Thread *thread = team->thread_list.First(); thread != NULL;
			thread = team->thread_list.GetNext(thread)) {
		SpinLocker threadDebugInfoLocker(thread->debug_info.lock);

		if (thread->id == nubThread) {
			atomic_set(&thread->debug_info.flags, B_THREAD_DEBUG_NUB_THREAD);
		} else {
			int32 flags = thread->debug_info.flags
				& ~B_THREAD_DEBUG_USER_FLAG_MASK;
			atomic_set(&thread->debug_info.flags,
				flags | B_THREAD_DEBUG_DEFAULT_FLAGS);
			thread->debug_info.ignore_signals = 0;
			thread->debug_info.ignore_signals_once = 0;

			arch_clear_thread_debug_info(&thread->debug_info.arch_info);
		}
	}

	// update the thread::flags fields
	update_threads_debugger_installed_flag(team);
}


static port_id
install_team_debugger(team_id teamID, port_id debuggerPort,
	thread_id causingThread, bool useDefault, bool dontReplace)
{
	TRACE(("install_team_debugger(team: %" B_PRId32 ", port: %" B_PRId32 ", "
		"default: %d, dontReplace: %d)\n", teamID, debuggerPort, useDefault,
		dontReplace));

	if (useDefault)
		debuggerPort = atomic_get(&sDefaultDebuggerPort);

	// get the debugger team
	port_info debuggerPortInfo;
	status_t error = get_port_info(debuggerPort, &debuggerPortInfo);
	if (error != B_OK) {
		TRACE(("install_team_debugger(): Failed to get debugger port info: "
			"%" B_PRIx32 "\n", error));
		return error;
	}
	team_id debuggerTeam = debuggerPortInfo.team;

	// Check the debugger team: It must neither be the kernel team nor the
	// debugged team.
	if (teamID == B_CURRENT_TEAM)
		teamID = team_get_current_team_id();
	if (debuggerTeam == team_get_kernel_team_id() || debuggerTeam == teamID) {
		TRACE(("install_team_debugger(): Can't debug kernel or debugger team. "
			"debugger: %" B_PRId32 ", debugged: %" B_PRId32 "\n", debuggerTeam,
			teamID));
		return B_NOT_ALLOWED;
	}

	// get the team
	Team* team;
	ConditionVariable debugChangeCondition;
	debugChangeCondition.Init(NULL, "debug change condition");
	error = prepare_debugger_change(teamID, debugChangeCondition, team);
	if (error != B_OK)
		return error;

	// check, if a debugger is already installed

	bool done = false;
	port_id result = B_ERROR;
	bool handOver = false;
	port_id oldDebuggerPort = -1;
	port_id nubPort = -1;

	TeamLocker teamLocker(team);
	cpu_status state = disable_interrupts();
	GRAB_TEAM_DEBUG_INFO_LOCK(team->debug_info);

	int32 teamDebugFlags = team->debug_info.flags;

	if (teamDebugFlags & B_TEAM_DEBUG_DEBUGGER_INSTALLED) {
		// There's already a debugger installed.
		if (teamDebugFlags & B_TEAM_DEBUG_DEBUGGER_HANDOVER) {
			if (dontReplace) {
				// We're fine with already having a debugger.
				error = B_OK;
				done = true;
				result = team->debug_info.nub_port;
			} else {
				// a handover to another debugger is requested
				// Set the handing-over flag -- we'll clear both flags after
				// having sent the handed-over message to the new debugger.
				atomic_or(&team->debug_info.flags,
					B_TEAM_DEBUG_DEBUGGER_HANDING_OVER);

				oldDebuggerPort = team->debug_info.debugger_port;
				result = nubPort = team->debug_info.nub_port;
				if (causingThread < 0)
					causingThread = team->debug_info.causing_thread;

				// set the new debugger
				install_team_debugger_init_debug_infos(team, debuggerTeam,
					debuggerPort, nubPort, team->debug_info.nub_thread,
					team->debug_info.debugger_write_lock, causingThread);

				handOver = true;
				done = true;
			}
		} else {
			// there's already a debugger installed
			error = (dontReplace ? B_OK : B_BAD_VALUE);
			done = true;
			result = team->debug_info.nub_port;
		}
	} else if ((teamDebugFlags & B_TEAM_DEBUG_DEBUGGER_DISABLED) != 0
		&& useDefault) {
		// No debugger yet, disable_debugger() had been invoked, and we
		// would install the default debugger. Just fail.
		error = B_BAD_VALUE;
	}

	RELEASE_TEAM_DEBUG_INFO_LOCK(team->debug_info);
	restore_interrupts(state);
	teamLocker.Unlock();

	if (handOver && set_port_owner(nubPort, debuggerTeam) != B_OK) {
		// The old debugger must just have died. Just proceed as
		// if there was no debugger installed. We may still be too
		// early, in which case we'll fail, but this race condition
		// should be unbelievably rare and relatively harmless.
		handOver = false;
		done = false;
	}

	if (handOver) {
		// prepare the handed-over message
		debug_handed_over notification;
		notification.origin.thread = -1;
		notification.origin.team = teamID;
		notification.origin.nub_port = nubPort;
		notification.debugger = debuggerTeam;
		notification.debugger_port = debuggerPort;
		notification.causing_thread = causingThread;

		// notify the new debugger
		error = write_port_etc(debuggerPort,
			B_DEBUGGER_MESSAGE_HANDED_OVER, &notification,
			sizeof(notification), B_RELATIVE_TIMEOUT, 0);
		if (error != B_OK) {
			dprintf("install_team_debugger(): Failed to send message to new "
				"debugger: %s\n", strerror(error));
		}

		// clear the handed-over and handing-over flags
		state = disable_interrupts();
		GRAB_TEAM_DEBUG_INFO_LOCK(team->debug_info);

		atomic_and(&team->debug_info.flags,
			~(B_TEAM_DEBUG_DEBUGGER_HANDOVER
				| B_TEAM_DEBUG_DEBUGGER_HANDING_OVER));

		RELEASE_TEAM_DEBUG_INFO_LOCK(team->debug_info);
		restore_interrupts(state);

		finish_debugger_change(team);

		// notify the nub thread
		kill_interruptable_write_port(nubPort, B_DEBUG_MESSAGE_HANDED_OVER,
			NULL, 0);

		// notify the old debugger
		error = write_port_etc(oldDebuggerPort,
			B_DEBUGGER_MESSAGE_HANDED_OVER, &notification,
			sizeof(notification), B_RELATIVE_TIMEOUT, 0);
		if (error != B_OK) {
			TRACE(("install_team_debugger(): Failed to send message to old "
				"debugger: %s\n", strerror(error)));
		}

		TRACE(("install_team_debugger() done: handed over to debugger: team: "
			"%" B_PRId32 ", port: %" B_PRId32 "\n", debuggerTeam,
			debuggerPort));

		return result;
	}

	if (done || error != B_OK) {
		TRACE(("install_team_debugger() done1: %" B_PRId32 "\n",
			(error == B_OK ? result : error)));
		finish_debugger_change(team);
		return (error == B_OK ? result : error);
	}

	// create the debugger write lock semaphore
	char nameBuffer[B_OS_NAME_LENGTH];
	snprintf(nameBuffer, sizeof(nameBuffer), "team %" B_PRId32 " debugger port "
		"write", teamID);
	sem_id debuggerWriteLock = create_sem(1, nameBuffer);
	if (debuggerWriteLock < 0)
		error = debuggerWriteLock;

	// create the nub port
	snprintf(nameBuffer, sizeof(nameBuffer), "team %" B_PRId32 " debug", teamID);
	if (error == B_OK) {
		nubPort = create_port(1, nameBuffer);
		if (nubPort < 0)
			error = nubPort;
		else
			result = nubPort;
	}

	// make the debugger team the port owner; thus we know, if the debugger is
	// gone and can cleanup
	if (error == B_OK)
		error = set_port_owner(nubPort, debuggerTeam);

	// create the breakpoint manager
	BreakpointManager* breakpointManager = NULL;
	if (error == B_OK) {
		breakpointManager = new(std::nothrow) BreakpointManager;
		if (breakpointManager != NULL)
			error = breakpointManager->Init();
		else
			error = B_NO_MEMORY;
	}

	// spawn the nub thread
	thread_id nubThread = -1;
	if (error == B_OK) {
		snprintf(nameBuffer, sizeof(nameBuffer), "team %" B_PRId32 " debug task",
			teamID);
		nubThread = spawn_kernel_thread_etc(debug_nub_thread, nameBuffer,
			B_NORMAL_PRIORITY, NULL, teamID);
		if (nubThread < 0)
			error = nubThread;
	}

	// now adjust the debug info accordingly
	if (error == B_OK) {
		TeamLocker teamLocker(team);
		state = disable_interrupts();
		GRAB_TEAM_DEBUG_INFO_LOCK(team->debug_info);

		team->debug_info.breakpoint_manager = breakpointManager;
		install_team_debugger_init_debug_infos(team, debuggerTeam,
			debuggerPort, nubPort, nubThread, debuggerWriteLock,
			causingThread);

		RELEASE_TEAM_DEBUG_INFO_LOCK(team->debug_info);
		restore_interrupts(state);
	}

	finish_debugger_change(team);

	// if everything went fine, resume the nub thread, otherwise clean up
	if (error == B_OK) {
		resume_thread(nubThread);
	} else {
		// delete port and terminate thread
		if (nubPort >= 0) {
			set_port_owner(nubPort, B_CURRENT_TEAM);
			delete_port(nubPort);
		}
		if (nubThread >= 0) {
			int32 result;
			wait_for_thread(nubThread, &result);
		}

		delete breakpointManager;
	}

	TRACE(("install_team_debugger() done2: %" B_PRId32 "\n",
		(error == B_OK ? result : error)));
	return (error == B_OK ? result : error);
}


static status_t
ensure_debugger_installed()
{
	port_id port = install_team_debugger(B_CURRENT_TEAM, -1,
		thread_get_current_thread_id(), true, true);
	return port >= 0 ? B_OK : port;
}


// #pragma mark -


void
_user_debugger(const char *userMessage)
{
	// install the default debugger, if there is none yet
	status_t error = ensure_debugger_installed();
	if (error != B_OK) {
		// time to commit suicide
		char buffer[128];
		ssize_t length = user_strlcpy(buffer, userMessage, sizeof(buffer));
		if (length >= 0) {
			dprintf("_user_debugger(): Failed to install debugger. Message is: "
				"`%s'\n", buffer);
		} else {
			dprintf("_user_debugger(): Failed to install debugger. Message is: "
				"%p (%s)\n", userMessage, strerror(length));
		}
		_user_exit_team(1);
	}

	// prepare the message
	debug_debugger_call message;
	message.message = (void*)userMessage;

	thread_hit_debug_event(B_DEBUGGER_MESSAGE_DEBUGGER_CALL, &message,
		sizeof(message), true);
}


int
_user_disable_debugger(int state)
{
	Team *team = thread_get_current_thread()->team;

	TRACE(("_user_disable_debugger(%d): team: %" B_PRId32 "\n", state,
		team->id));

	cpu_status cpuState = disable_interrupts();
	GRAB_TEAM_DEBUG_INFO_LOCK(team->debug_info);

	int32 oldFlags;
	if (state) {
		oldFlags = atomic_or(&team->debug_info.flags,
			B_TEAM_DEBUG_DEBUGGER_DISABLED);
	} else {
		oldFlags = atomic_and(&team->debug_info.flags,
			~B_TEAM_DEBUG_DEBUGGER_DISABLED);
	}

	RELEASE_TEAM_DEBUG_INFO_LOCK(team->debug_info);
	restore_interrupts(cpuState);

	// TODO: Check, if the return value is really the old state.
	return !(oldFlags & B_TEAM_DEBUG_DEBUGGER_DISABLED);
}


status_t
_user_install_default_debugger(port_id debuggerPort)
{
	// Do not allow non-root processes to install a default debugger.
	if (geteuid() != 0)
		return B_PERMISSION_DENIED;

	// if supplied, check whether the port is a valid port
	if (debuggerPort >= 0) {
		port_info portInfo;
		status_t error = get_port_info(debuggerPort, &portInfo);
		if (error != B_OK)
			return error;

		// the debugger team must not be the kernel team
		if (portInfo.team == team_get_kernel_team_id())
			return B_NOT_ALLOWED;
	}

	atomic_set(&sDefaultDebuggerPort, debuggerPort);

	return B_OK;
}


port_id
_user_install_team_debugger(team_id teamID, port_id debuggerPort)
{
	if (geteuid() != 0 && team_geteuid(teamID) != geteuid())
		return B_PERMISSION_DENIED;

	return install_team_debugger(teamID, debuggerPort, -1, false, false);
}


status_t
_user_remove_team_debugger(team_id teamID)
{
	Team* team;
	ConditionVariable debugChangeCondition;
	debugChangeCondition.Init(NULL, "debug change condition");
	status_t status = prepare_debugger_change(teamID, debugChangeCondition,
		team);
	if (status != B_OK)
		return status;

	InterruptsSpinLocker debugInfoLocker(team->debug_info.lock);

	thread_id nubThread = -1;
	port_id nubPort = -1;

	if ((team->debug_info.flags & B_TEAM_DEBUG_DEBUGGER_INSTALLED) == 0) {
		// no debugger installed
		status = B_BAD_VALUE;
	}

	if (status == B_OK) {
		if (geteuid() != 0 && team->effective_uid != geteuid()
				&& team->debug_info.debugger_team != team_get_current_team_id())
			status = B_PERMISSION_DENIED;
	}

	if (status == B_OK) {
		// there's a debugger installed, and we're allowed to remove it
		nubThread = team->debug_info.nub_thread;
		nubPort = team->debug_info.nub_port;
	}

	debugInfoLocker.Unlock();

	// Delete the nub port -- this will cause the nub thread to terminate and
	// remove the debugger.
	if (nubPort >= 0)
		delete_port(nubPort);

	finish_debugger_change(team);

	// wait for the nub thread
	if (nubThread >= 0)
		wait_for_thread(nubThread, NULL);

	return status;
}


status_t
_user_debug_thread(thread_id threadID)
{
	TRACE(("[%" B_PRId32 "] _user_debug_thread(%" B_PRId32 ")\n",
		find_thread(NULL), threadID));

	// get the thread
	Thread* thread = Thread::GetAndLock(threadID);
	if (thread == NULL)
		return B_BAD_THREAD_ID;
	BReference<Thread> threadReference(thread, true);
	ThreadLocker threadLocker(thread, true);

	// we can't debug the kernel team
	if (thread->team == team_get_kernel_team())
		return B_NOT_ALLOWED;

	if (geteuid() != 0 && thread->team->effective_uid != geteuid()
			&& thread->team->debug_info.debugger_team != team_get_current_team_id())
		return B_PERMISSION_DENIED;

	InterruptsLocker interruptsLocker;
	SpinLocker threadDebugInfoLocker(thread->debug_info.lock);

	// If the thread is already dying, it's too late to debug it.
	if ((thread->debug_info.flags & B_THREAD_DEBUG_DYING) != 0)
		return B_BAD_THREAD_ID;

	// don't debug the nub thread
	if ((thread->debug_info.flags & B_THREAD_DEBUG_NUB_THREAD) != 0)
		return B_NOT_ALLOWED;

	// already marked stopped or being told to stop?
	if ((thread->debug_info.flags
			& (B_THREAD_DEBUG_STOPPED | B_THREAD_DEBUG_STOP)) != 0) {
		return B_OK;
	}

	// set the flag that tells the thread to stop as soon as possible
	atomic_or(&thread->debug_info.flags, B_THREAD_DEBUG_STOP);

	update_thread_user_debug_flag(thread);

	// send the thread a SIGNAL_DEBUG_THREAD, so it is interrupted (or
	// continued)
	threadDebugInfoLocker.Unlock();
	ReadSpinLocker teamLocker(thread->team_lock);
	SpinLocker locker(thread->team->signal_lock);

	send_signal_to_thread_locked(thread, SIGNAL_DEBUG_THREAD, NULL, 0);

	return B_OK;
}


void
_user_wait_for_debugger(void)
{
	debug_thread_debugged message = {};
	thread_hit_debug_event(B_DEBUGGER_MESSAGE_THREAD_DEBUGGED, &message,
		sizeof(message), false);
}


status_t
_user_set_debugger_breakpoint(void *address, uint32 type, int32 length,
	bool watchpoint)
{
	// check the address and size
	if (address == NULL || !BreakpointManager::CanAccessAddress(address, false))
		return B_BAD_ADDRESS;
	if (watchpoint && length < 0)
		return B_BAD_VALUE;

	// check whether a debugger is installed already
	team_debug_info teamDebugInfo;
	get_team_debug_info(teamDebugInfo);
	if (teamDebugInfo.flags & B_TEAM_DEBUG_DEBUGGER_INSTALLED)
		return B_BAD_VALUE;

	// We can't help it, here's a small but relatively harmless race condition,
	// since a debugger could be installed in the meantime. The worst case is
	// that we install a break/watchpoint the debugger doesn't know about.

	// set the break/watchpoint
	status_t result;
	if (watchpoint)
		result = arch_set_watchpoint(address, type, length);
	else
		result = arch_set_breakpoint(address);

	if (result == B_OK)
		update_threads_breakpoints_flag();

	return result;
}


status_t
_user_clear_debugger_breakpoint(void *address, bool watchpoint)
{
	// check the address
	if (address == NULL || !BreakpointManager::CanAccessAddress(address, false))
		return B_BAD_ADDRESS;

	// check whether a debugger is installed already
	team_debug_info teamDebugInfo;
	get_team_debug_info(teamDebugInfo);
	if (teamDebugInfo.flags & B_TEAM_DEBUG_DEBUGGER_INSTALLED)
		return B_BAD_VALUE;

	// We can't help it, here's a small but relatively harmless race condition,
	// since a debugger could be installed in the meantime. The worst case is
	// that we clear a break/watchpoint the debugger has just installed.

	// clear the break/watchpoint
	status_t result;
	if (watchpoint)
		result = arch_clear_watchpoint(address);
	else
		result = arch_clear_breakpoint(address);

	if (result == B_OK)
		update_threads_breakpoints_flag();

	return result;
}