kernel: Add core dump facility

* Add function core_dump_write_core_file(). It writes a core file for
  the current thread's team. The file format is similar to that of
  other OSs (i.e. ELF with PT_LOAD segments and a PT_NOTE segment), but
  most of the notes are Haiku specific (infos for team, areas, images,
  threads). More data will probably need to be added.
* Add team flag TEAM_FLAG_DUMP_CORE, thread flag
  THREAD_FLAGS_TRAP_FOR_CORE_DUMP, and Team property coreDumpCondition,
  a condition variable available while a core dump is progress. A
  thread that finds its flag THREAD_FLAGS_TRAP_FOR_CORE_DUMP set before
  exiting the kernel to userland calls core_dump_trap_thread(), which
  blocks on the condition variable until the core dump has finished. We
  need the team's threads to stop so we can get their CPU state (and
  have a generally unchanging team state while writing the core file).
* Add user debugger message B_DEBUG_WRITE_CORE_FILE. It causes
  core_dump_write_core_file() to be called for the team.
* Dumping core as an immediate effect of a terminal signal has not been
  implemented yet, but that should be fairly straight forward.

headers/private/kernel/core_dump.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2016, Ingo Weinhold, [email protected].
+ * Distributed under the terms of the MIT License.
+ *
+ * Core dump support.
+ */
+#ifndef _KERNEL_CORE_DUMP_H
+#define _KERNEL_CORE_DUMP_H
+
+
+#include <SupportDefs.h>
+
+
+status_t	core_dump_write_core_file(const char* path, bool killTeam);
+void		core_dump_trap_thread();
+
+
+#endif	// _KERNEL_CORE_DUMP_H

headers/private/kernel/thread_types.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2004-2011, Haiku, Inc.
+ * Copyright 2004-2016, Haiku, Inc.
  * Distributed under the terms of the MIT License.
  *
  * Thread definition and structures
@@ -44,6 +44,9 @@ enum team_state {
 };
 
 #define	TEAM_FLAG_EXEC_DONE	0x01
+	// team has executed exec*()
+#define	TEAM_FLAG_DUMP_CORE	0x02
+	// a core dump is in progress
 
 typedef enum job_control_state {
 	JOB_CONTROL_STATE_NONE,
@@ -392,6 +395,11 @@ public:
 									Thread* lockedThread = NULL) const;
 			bigtime_t			UserCPUTime() const;
 
+			ConditionVariable*	CoreDumpCondition() const
+									{ return fCoreDumpCondition; }
+			void				SetCoreDumpCondition(
+									ConditionVariable* condition)
+									{ fCoreDumpCondition = condition; }
 private:
 								Team(team_id id, bool kernel);
 
@@ -412,6 +420,9 @@ private:
 									// protected by scheduler lock
 			TeamUserTimeUserTimerList fUserTimeUserTimers;
 			int32				fUserDefinedTimerCount;	// accessed atomically
+
+			ConditionVariable*	fCoreDumpCondition;
+									// protected by fLock
 };
 
 
@@ -821,6 +832,9 @@ using BKernel::ProcessGroupList;
 	// the thread is currently in a syscall; set/reset only for certain
 	// functions (e.g. ioctl()) to allow inner functions to discriminate
 	// whether e.g. parameters were passed from userland or kernel
+#define	THREAD_FLAGS_TRAP_FOR_CORE_DUMP		0x1000
+	// core dump in progress; the thread shall not exit the kernel to userland,
+	// but shall invoke core_dump_trap_thread() instead.
 
 
 #endif	/* _KERNEL_THREAD_TYPES_H */