haiku.git

/*
 * Copyright 2016, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include <core_dump.h>

#include <errno.h>
#include <string.h>

#include <algorithm>
#include <new>

#include <BeBuild.h>
#include <ByteOrder.h>

#include <AutoDeleter.h>

#include <commpage.h>
#include <condition_variable.h>
#include <elf.h>
#include <kimage.h>
#include <ksignal.h>
#include <team.h>
#include <thread.h>
#include <user_debugger.h>
#include <util/AutoLock.h>
#include <util/ThreadAutoLock.h>
#include <util/DoublyLinkedList.h>
#include <vm/vm.h>
#include <vm/VMArea.h>
#include <vm/VMCache.h>

#include "../cache/vnode_store.h"
#include "../vm/VMAddressSpaceLocking.h"


//#define TRACE_CORE_DUMP
#ifdef TRACE_CORE_DUMP
#	define TRACE(...) dprintf(__VA_ARGS__)
#else
#	define TRACE(...) do {} while (false)
#endif


namespace {


static const size_t kBufferSize = 1024 * 1024;
static const char* const kCoreNote = ELF_NOTE_CORE;
static const char* const kHaikuNote = ELF_NOTE_HAIKU;


struct Allocator {
	Allocator()
		:
		fAligned(NULL),
		fStrings(NULL),
		fAlignedCapacity(0),
		fStringCapacity(0),
		fAlignedSize(0),
		fStringSize(0)
	{
	}

	~Allocator()
	{
		free(fAligned);
	}

	bool HasMissingAllocations() const
	{
		return fAlignedSize > fAlignedCapacity || fStringSize > fStringCapacity;
	}

	bool Reallocate()
	{
		free(fAligned);

		fAlignedCapacity = fAlignedSize;
		fStringCapacity = fStringSize;
		fAlignedSize = 0;
		fStringSize = 0;

		fAligned = (uint8*)malloc(fAlignedCapacity + fStringCapacity);
		if (fAligned == NULL)
			return false;
		fStrings = (char*)(fAligned + fAlignedCapacity);

		return true;
	}

	void* AllocateAligned(size_t size)
	{
		size_t offset = fAlignedSize;
		fAlignedSize += (size + 7) / 8 * 8;
		if (fAlignedSize <= fAlignedCapacity)
			return fAligned + offset;
		return NULL;
	}

	char* AllocateString(size_t length)
	{
		size_t offset = fStringSize;
		fStringSize += length + 1;
		if (fStringSize <= fStringCapacity)
			return fStrings + offset;
		return NULL;
	}

	template <typename Type>
	Type* New()
	{
		void* buffer = AllocateAligned(sizeof(Type));
		if (buffer == NULL)
			return NULL;
		return new(buffer) Type;
	}

	char* DuplicateString(const char* string)
	{
		if (string == NULL)
			return NULL;
		char* newString = AllocateString(strlen(string));
		if (newString != NULL)
			strcpy(newString, string);
		return newString;
	}

private:
	uint8*	fAligned;
	char*	fStrings;
	size_t	fAlignedCapacity;
	size_t	fStringCapacity;
	size_t	fAlignedSize;
	size_t	fStringSize;
};


struct TeamInfo : team_info {
};


struct ThreadState : DoublyLinkedListLinkImpl<ThreadState> {
	ThreadState()
		:
		fThread(NULL),
		fComplete(false)
	{
	}

	~ThreadState()
	{
		SetThread(NULL);
	}

	static ThreadState* Create()
	{
		ThreadState* state = new(std::nothrow) ThreadState;
		if (state == NULL)
			return NULL;
		return state;
	}

	Thread* GetThread() const
	{
		return fThread;
	}

	void SetThread(Thread* thread)
	{
		if (fThread != NULL)
			fThread->ReleaseReference();

		fThread = thread;

		if (fThread != NULL)
			fThread->AcquireReference();
	}

	/*!	Invoke with thread lock and scheduler lock being held. */
	void GetState()
	{
		fState = fThread->state;
		fPriority = fThread->priority;
		fStackBase = fThread->user_stack_base;
		fStackEnd = fStackBase + fThread->user_stack_size;
		strlcpy(fName, fThread->name, sizeof(fName));
		if (arch_get_thread_debug_cpu_state(fThread, &fCpuState) != B_OK)
			memset(&fCpuState, 0, sizeof(fCpuState));
	}

	bool IsComplete() const
	{
		return fComplete;
	}

	void SetComplete(bool complete)
	{
		fComplete = complete;
	}

	int32 State() const
	{
		return fState;
	}

	int32 Priority() const
	{
		return fPriority;
	}

	addr_t StackBase() const
	{
		return fStackBase;
	}

	addr_t StackEnd() const
	{
		return fStackEnd;
	}

	const char* Name() const
	{
		return fName;
	}

	const debug_cpu_state* CpuState() const
	{
		return &fCpuState;
	}

private:
	Thread*			fThread;
	int32			fState;
	int32			fPriority;
	addr_t			fStackBase;
	addr_t			fStackEnd;
	char			fName[B_OS_NAME_LENGTH];
	debug_cpu_state	fCpuState;
	bool			fComplete;
};


typedef DoublyLinkedList<ThreadState> ThreadStateList;


struct ImageInfo : DoublyLinkedListLinkImpl<ImageInfo> {
	ImageInfo(struct image* image)
		:
		fId(image->info.basic_info.id),
		fType(image->info.basic_info.type),
		fDeviceId(image->info.basic_info.device),
		fNodeId(image->info.basic_info.node),
		fName(strdup(image->info.basic_info.name)),
		fInitRoutine((addr_t)image->info.basic_info.init_routine),
		fTermRoutine((addr_t)image->info.basic_info.term_routine),
		fText((addr_t)image->info.basic_info.text),
		fData((addr_t)image->info.basic_info.data),
		fTextSize(image->info.basic_info.text_size),
		fDataSize(image->info.basic_info.data_size),
		fTextDelta(image->info.text_delta),
		fSymbolTable((addr_t)image->info.symbol_table),
		fSymbolHash((addr_t)image->info.symbol_hash),
		fStringTable((addr_t)image->info.string_table),
		fSymbolTableData(NULL),
		fStringTableData(NULL),
		fSymbolCount(0),
		fStringTableSize(0)
	{
		if (fName != NULL && strcmp(fName, "commpage") == 0)
			_GetCommpageSymbols();
	}

	~ImageInfo()
	{
		free(fName);
		_FreeSymbolData();
	}

	static ImageInfo* Create(struct image* image)
	{
		ImageInfo* imageInfo = new(std::nothrow) ImageInfo(image);
		if (imageInfo == NULL || imageInfo->fName == NULL) {
			delete imageInfo;
			return NULL;
		}

		return imageInfo;
	}

	image_id Id() const
	{
		return fId;
	}

	image_type Type() const
	{
		return fType;
	}

	const char* Name() const
	{
		return fName;
	}

	dev_t DeviceId() const
	{
		return fDeviceId;
	}

	ino_t NodeId() const
	{
		return fNodeId;
	}

	addr_t InitRoutine() const
	{
		return fInitRoutine;
	}

	addr_t TermRoutine() const
	{
		return fTermRoutine;
	}

	addr_t TextBase() const
	{
		return fText;
	}

	size_t TextSize() const
	{
		return fTextSize;
	}

	ssize_t TextDelta() const
	{
		return fTextDelta;
	}

	addr_t DataBase() const
	{
		return fData;
	}

	size_t DataSize() const
	{
		return fDataSize;
	}

	addr_t SymbolTable() const
	{
		return fSymbolTable;
	}

	addr_t SymbolHash() const
	{
		return fSymbolHash;
	}

	addr_t StringTable() const
	{
		return fStringTable;
	}

	elf_sym* SymbolTableData() const
	{
		return fSymbolTableData;
	}

	char* StringTableData() const
	{
		return fStringTableData;
	}

	uint32 SymbolCount() const
	{
		return fSymbolCount;
	}

	size_t StringTableSize() const
	{
		return fStringTableSize;
	}

private:
	void _GetCommpageSymbols()
	{
		image_id commpageId = get_commpage_image();

		// get the size of the tables
		int32 symbolCount = 0;
		size_t stringTableSize = 0;
		status_t error = elf_read_kernel_image_symbols(commpageId, NULL,
			&symbolCount, NULL, &stringTableSize,
			NULL, true);
		if (error != B_OK)
			return;
		if (symbolCount == 0 || stringTableSize == 0)
			return;

		// allocate the tables
		fSymbolTableData = (elf_sym*)malloc(sizeof(elf_sym) * symbolCount);
		fStringTableData = (char*)malloc(stringTableSize);
		if (fSymbolTableData == NULL || fStringTableData == NULL) {
			_FreeSymbolData();
			return;
		}

		fSymbolCount = symbolCount;
		fStringTableSize = stringTableSize;

		// get the data
		error = elf_read_kernel_image_symbols(commpageId,
			fSymbolTableData, &symbolCount, fStringTableData, &stringTableSize,
			NULL, true);
		if (error != B_OK)
			_FreeSymbolData();
	}

	void _FreeSymbolData()
	{
		free(fSymbolTableData);
		free(fStringTableData);

		fSymbolTableData = NULL;
		fStringTableData = NULL;
		fSymbolCount = 0;
		fStringTableSize = 0;
	}

private:
	image_id	fId;
	image_type	fType;
	dev_t		fDeviceId;
	ino_t		fNodeId;
	char*		fName;
	addr_t		fInitRoutine;
	addr_t		fTermRoutine;
	addr_t		fText;
	addr_t		fData;
	size_t		fTextSize;
	size_t		fDataSize;
	ssize_t		fTextDelta;
	addr_t		fSymbolTable;
	addr_t		fSymbolHash;
	addr_t		fStringTable;
	// for commpage image
	elf_sym*	fSymbolTableData;
	char*		fStringTableData;
	uint32		fSymbolCount;
	size_t		fStringTableSize;
};


typedef DoublyLinkedList<ImageInfo> ImageInfoList;


struct AreaInfo : DoublyLinkedListLinkImpl<AreaInfo> {
	static AreaInfo* Create(Allocator& allocator, VMArea* area, size_t ramSize,
		dev_t deviceId, ino_t nodeId)
	{
		AreaInfo* areaInfo = allocator.New<AreaInfo>();
		const char* name = allocator.DuplicateString(area->name);

		if (areaInfo != NULL) {
			areaInfo->fId = area->id;
			areaInfo->fName = name;
			areaInfo->fBase = area->Base();
			areaInfo->fSize = area->Size();
			areaInfo->fLock = B_FULL_LOCK;
			areaInfo->fProtection = area->protection;
			areaInfo->fRamSize = ramSize;
			areaInfo->fDeviceId = deviceId;
			areaInfo->fNodeId = nodeId;
			areaInfo->fCacheOffset = area->cache_offset;
			areaInfo->fImageInfo = NULL;
		}

		return areaInfo;
	}

	area_id Id() const
	{
		return fId;
	}

	const char* Name() const
	{
		return fName;
	}

	addr_t Base() const
	{
		return fBase;
	}

	size_t Size() const
	{
		return fSize;
	}

	uint32 Lock() const
	{
		return fLock;
	}

	uint32 Protection() const
	{
		return fProtection;
	}

	size_t RamSize() const
	{
		return fRamSize;
	}

	off_t CacheOffset() const
	{
		return fCacheOffset;
	}

	dev_t DeviceId() const
	{
		return fDeviceId;
	}

	ino_t NodeId() const
	{
		return fNodeId;
	}

	ImageInfo* GetImageInfo() const
	{
		return fImageInfo;
	}

	void SetImageInfo(ImageInfo* imageInfo)
	{
		fImageInfo = imageInfo;
	}

private:
	area_id		fId;
	const char*	fName;
	addr_t		fBase;
	size_t		fSize;
	uint32		fLock;
	uint32		fProtection;
	size_t		fRamSize;
	dev_t		fDeviceId;
	ino_t		fNodeId;
	off_t		fCacheOffset;
	ImageInfo*	fImageInfo;
};


typedef DoublyLinkedList<AreaInfo> AreaInfoList;


struct BufferedFile {
	BufferedFile()
		:
		fFd(-1),
		fBuffer(NULL),
		fCapacity(0),
		fOffset(0),
		fBuffered(0),
		fStatus(B_NO_INIT)
	{
	}

	~BufferedFile()
	{
		if (fFd >= 0)
			close(fFd);

		free(fBuffer);
	}

	status_t Init(const char* path)
	{
		fCapacity = kBufferSize;
		fBuffer = (uint8*)malloc(fCapacity);
		if (fBuffer == NULL)
			return B_NO_MEMORY;

		fFd = open(path, O_WRONLY | O_CREAT | O_EXCL, S_IRUSR);
		if (fFd < 0)
			return errno;

		fStatus = B_OK;
		return B_OK;
	}

	status_t Status() const
	{
		return fStatus;
	}

	off_t EndOffset() const
	{
		return fOffset + (off_t)fBuffered;
	}

	status_t Flush()
	{
		if (fStatus != B_OK)
			return fStatus;

		if (fBuffered == 0)
			return B_OK;

		ssize_t written = pwrite(fFd, fBuffer, fBuffered, fOffset);
		if (written < 0)
			return fStatus = errno;
		if ((size_t)written != fBuffered)
			return fStatus = B_IO_ERROR;

		fOffset += (off_t)fBuffered;
		fBuffered = 0;
		return B_OK;
	}

	status_t Seek(off_t offset)
	{
		if (fStatus != B_OK)
			return fStatus;

		if (fBuffered == 0) {
			fOffset = offset;
		} else if (offset != fOffset + (off_t)fBuffered) {
			status_t error = Flush();
			if (error != B_OK)
				return fStatus = error;
			fOffset = offset;
		}

		return B_OK;
	}

	status_t Write(const void* data, size_t size)
	{
		if (fStatus != B_OK)
			return fStatus;

		if (size == 0)
			return B_OK;

		while (size > 0) {
			size_t toWrite = std::min(size, fCapacity - fBuffered);
			if (toWrite == 0) {
				status_t error = Flush();
				if (error != B_OK)
					return fStatus = error;
				continue;
			}

			memcpy(fBuffer + fBuffered, data, toWrite);
			fBuffered += toWrite;
			size -= toWrite;
		}

		return B_OK;
	}

	template<typename Data>
	status_t Write(const Data& data)
	{
		return Write(&data, sizeof(data));
	}

	status_t WriteAt(off_t offset, const void* data, size_t size)
	{
		if (Seek(offset) != B_OK)
			return fStatus;

		return Write(data, size);
	}

	status_t WriteUserArea(addr_t base, size_t size)
	{
		uint8* data = (uint8*)base;
		size = size / B_PAGE_SIZE * B_PAGE_SIZE;

		// copy the area page-wise into the buffer, flushing when necessary
		while (size > 0) {
			if (fBuffered + B_PAGE_SIZE > fCapacity) {
				status_t error = Flush();
				if (error != B_OK)
					return error;
			}

			if (user_memcpy(fBuffer + fBuffered, data, B_PAGE_SIZE) != B_OK)
				memset(fBuffer + fBuffered, 0, B_PAGE_SIZE);

			fBuffered += B_PAGE_SIZE;
			data += B_PAGE_SIZE;
			size -= B_PAGE_SIZE;
		}

		return B_OK;
	}

private:
	int			fFd;
	uint8*		fBuffer;
	size_t		fCapacity;
	off_t		fOffset;
	size_t		fBuffered;
	status_t	fStatus;
};


struct DummyWriter {
	DummyWriter()
		:
		fWritten(0)
	{
	}

	status_t Status() const
	{
		return B_OK;
	}

	size_t BytesWritten() const
	{
		return fWritten;
	}

	status_t Write(const void* data, size_t size)
	{
		fWritten += size;
		return B_OK;
	}

	template<typename Data>
	status_t Write(const Data& data)
	{
		return Write(&data, sizeof(data));
	}

private:
	size_t	fWritten;
};


struct CoreDumper {
	CoreDumper()
		:
		fCurrentThread(thread_get_current_thread()),
		fTeam(fCurrentThread->team),
		fFile(),
		fThreadCount(0),
		fThreadStates(),
		fPreAllocatedThreadStates(),
		fAreaInfoAllocator(),
		fAreaInfos(),
		fImageInfos(),
		fThreadBlockCondition()
	{
		fThreadBlockCondition.Init(this, "core dump");
	}

	~CoreDumper()
	{
		while (ThreadState* state = fThreadStates.RemoveHead())
			delete state;
		while (ThreadState* state = fPreAllocatedThreadStates.RemoveHead())
			delete state;
		while (ImageInfo* info = fImageInfos.RemoveHead())
			delete info;
	}

	status_t Dump(const char* path, bool killTeam)
	{
		// gcc thinks fTeam may be null in atomic_or
        // and warn which causes error on some configs
		if (fTeam == NULL)
			return B_ERROR;

		// the path must be absolute
		if (path[0] != '/')
			return B_BAD_VALUE;

		AutoLocker<Team> teamLocker(fTeam);

		// indicate that we're dumping core
		if ((atomic_or(&fTeam->flags, TEAM_FLAG_DUMP_CORE)
				& TEAM_FLAG_DUMP_CORE) != 0) {
			return B_BUSY;
		}

		fTeam->SetCoreDumpCondition(&fThreadBlockCondition);

		int32 threadCount = _SetThreadsCoreDumpFlag(true);

		teamLocker.Unlock();

		// write the core file
		status_t error = _Dump(path, threadCount);

		// send kill signal, if requested
		if (killTeam)
			kill_team(fTeam->id);

		// clean up the team state and wake up waiting threads
		teamLocker.Lock();

		fTeam->SetCoreDumpCondition(NULL);

		atomic_and(&fTeam->flags, ~(int32)TEAM_FLAG_DUMP_CORE);

		_SetThreadsCoreDumpFlag(false);

		fThreadBlockCondition.NotifyAll();

		return error;
	}

private:
	status_t _Dump(const char* path, int32 threadCount)
	{
		status_t error = _GetTeamInfo();
		if (error != B_OK)
			return error;

		// pre-allocate a list of thread states
		if (!_AllocateThreadStates(threadCount))
			return B_NO_MEMORY;

		// collect the threads states
		_GetThreadStates();

		// collect the other team information
		if (!_GetAreaInfos() || !_GetImageInfos())
			return B_NO_MEMORY;

		// open the file
		error = fFile.Init(path);
		if (error != B_OK)
			return error;

		_PrepareCoreFileInfo();

		// write ELF header
		error = _WriteElfHeader();
		if (error != B_OK)
			return error;

		// write note segment
		error = _WriteNotes();
		if (error != B_OK)
			return error;

		size_t notesEndOffset = (size_t)fFile.EndOffset();
		fNoteSegmentSize = notesEndOffset - fNoteSegmentOffset;
		fFirstAreaSegmentOffset = (notesEndOffset + B_PAGE_SIZE - 1)
			/ B_PAGE_SIZE * B_PAGE_SIZE;

		error = _WriteProgramHeaders();
		if (error != B_OK)
			return error;

		// write area segments
		error = _WriteAreaSegments();
		if (error != B_OK)
			return error;

		return _WriteElfHeader();
	}

	int32 _SetThreadsCoreDumpFlag(bool setFlag)
	{
		int32 count = 0;

		for (Thread* thread = fTeam->thread_list.First(); thread != NULL;
				thread = fTeam->thread_list.GetNext(thread)) {
			count++;
			if (setFlag) {
				atomic_or(&thread->flags, THREAD_FLAGS_TRAP_FOR_CORE_DUMP);
			} else {
				atomic_and(&thread->flags,
					~(int32)THREAD_FLAGS_TRAP_FOR_CORE_DUMP);
			}
		}

		return count;
	}

	status_t _GetTeamInfo()
	{
		return get_team_info(fTeam->id, &fTeamInfo);
	}

	bool _AllocateThreadStates(int32 count)
	{
		if (!_PreAllocateThreadStates(count))
			return false;

		TeamLocker teamLocker(fTeam);

		for (;;) {
			fThreadCount = 0;
			int32 missing = 0;

			for (Thread* thread = fTeam->thread_list.First(); thread != NULL;
					thread = fTeam->thread_list.GetNext(thread)) {
				fThreadCount++;
				ThreadState* state = fPreAllocatedThreadStates.RemoveHead();
				if (state != NULL) {
					state->SetThread(thread);
					fThreadStates.Insert(state);
				} else
					missing++;
			}

			if (missing == 0)
				break;

			teamLocker.Unlock();

			fPreAllocatedThreadStates.TakeFrom(&fThreadStates);
			if (!_PreAllocateThreadStates(missing))
				return false;

			teamLocker.Lock();
		}

		return true;
	}

	bool _PreAllocateThreadStates(int32 count)
	{
		for (int32 i = 0; i < count; i++) {
			ThreadState* state = ThreadState::Create();
			if (state == NULL)
				return false;
			fPreAllocatedThreadStates.Insert(state);
		}

		return true;
	}

	void _GetThreadStates()
	{
		for (;;) {
			bool missing = false;
			for (ThreadStateList::Iterator it = fThreadStates.GetIterator();
					ThreadState* state = it.Next();) {
				if (state->IsComplete())
					continue;

				Thread* thread = state->GetThread();
				AutoLocker<Thread> threadLocker(thread);
				if (thread->team != fTeam) {
					// no longer in our team -- i.e. dying and transferred to
					// the kernel team
					threadLocker.Unlock();
					it.Remove();
					delete state;
					fThreadCount--;
					continue;
				}

				InterruptsSpinLocker schedulerLocker(&thread->scheduler_lock);
				if (thread != fCurrentThread
						&& thread->state == B_THREAD_RUNNING) {
					missing = true;
					continue;
				}

				state->GetState();
				state->SetComplete(true);
			}

			if (!missing)
				break;

			// We still haven't got a state for all threads. Wait a moment and
			// try again.
			snooze(10000);
		}
	}

	bool _GetAreaInfos()
	{
		for (;;) {
			AddressSpaceReadLocker addressSpaceLocker(fTeam->address_space,
				true);

			for (VMAddressSpace::AreaIterator it
						= addressSpaceLocker.AddressSpace()->GetAreaIterator();
					VMArea* area = it.Next();) {

				VMCache* cache = vm_area_get_locked_cache(area);
				size_t ramSize = (size_t)cache->page_count * B_PAGE_SIZE;
					// simplified, but what the kernel uses as well ATM

				// iterate to the root cache and, if it is a mapped file, get
				// the file's node_ref
				while (VMCache* source = cache->source) {
					source->Lock();
					source->AcquireRefLocked();
					cache->ReleaseRefAndUnlock();
					cache = source;
				}

				dev_t deviceId = -1;
				ino_t nodeId = -1;
				if (cache->type == CACHE_TYPE_VNODE) {
					VMVnodeCache* vnodeCache = (VMVnodeCache*)cache;
					deviceId = vnodeCache->DeviceId();
					nodeId = vnodeCache->InodeId();
				}

				cache->ReleaseRefAndUnlock();

				AreaInfo* areaInfo = AreaInfo::Create(fAreaInfoAllocator, area,
					ramSize, deviceId, nodeId);

				if (areaInfo != NULL)
					fAreaInfos.Insert(areaInfo);
			}

			addressSpaceLocker.Unlock();

			if (!fAreaInfoAllocator.HasMissingAllocations())
				return true;

			if (!fAreaInfoAllocator.Reallocate())
				return false;
		}
	}

	bool _GetImageInfos()
	{
		return image_iterate_through_team_images(fTeam->id,
			&_GetImageInfoCallback, this) == NULL;
	}

	static bool _GetImageInfoCallback(struct image* image, void* cookie)
	{
		return ((CoreDumper*)cookie)->_GetImageInfo(image);
	}

	bool _GetImageInfo(struct image* image)
	{
		ImageInfo* info = ImageInfo::Create(image);
		if (info == NULL)
			return true;

		fImageInfos.Insert(info);
		return false;
	}

	void _PrepareCoreFileInfo()
	{
		// assign image infos to area infos where possible
		fAreaCount = 0;
		fMappedFilesCount = 0;
		for (AreaInfoList::Iterator it = fAreaInfos.GetIterator();
				AreaInfo* areaInfo = it.Next();) {
			fAreaCount++;
			dev_t deviceId = areaInfo->DeviceId();
			if (deviceId < 0)
				continue;
			ImageInfo* imageInfo = _FindImageInfo(deviceId, areaInfo->NodeId());
			if (imageInfo != NULL) {
				areaInfo->SetImageInfo(imageInfo);
				fMappedFilesCount++;
			}
		}

		fImageCount = fImageInfos.Count();
		fSegmentCount = 1 + fAreaCount;
		fProgramHeadersOffset = sizeof(elf_ehdr);
		fNoteSegmentOffset = fProgramHeadersOffset
			+ sizeof(elf_phdr) * fSegmentCount;
	}

	ImageInfo* _FindImageInfo(dev_t deviceId, ino_t nodeId) const
	{
		for (ImageInfoList::ConstIterator it = fImageInfos.GetIterator();
				ImageInfo* info = it.Next();) {
			if (info->DeviceId() == deviceId && info->NodeId() == nodeId)
				return info;
		}

		return NULL;
	}

	status_t _WriteElfHeader()
	{
		elf_ehdr header;
		memset(&header, 0, sizeof(header));

		// e_ident
		header.e_ident[EI_MAG0] = ELFMAG[0];
		header.e_ident[EI_MAG1] = ELFMAG[1];
		header.e_ident[EI_MAG2] = ELFMAG[2];
		header.e_ident[EI_MAG3] = ELFMAG[3];
#ifdef B_HAIKU_64_BIT
		header.e_ident[EI_CLASS] = ELFCLASS64;
#else
		header.e_ident[EI_CLASS] = ELFCLASS32;
#endif
#if B_HOST_IS_LENDIAN
		header.e_ident[EI_DATA] = ELFDATA2LSB;
#else
		header.e_ident[EI_DATA] = ELFDATA2MSB;
#endif
		header.e_ident[EI_VERSION] = EV_CURRENT;

		// e_type
		header.e_type = ET_CORE;

		// e_machine
#if defined(__HAIKU_ARCH_X86)
		header.e_machine = EM_386;
#elif defined(__HAIKU_ARCH_X86_64)
		header.e_machine = EM_X86_64;
#elif defined(__HAIKU_ARCH_PPC)
		header.e_machine = EM_PPC64;
#elif defined(__HAIKU_ARCH_M68K)
		header.e_machine = EM_68K;
#elif defined(__HAIKU_ARCH_MIPSEL)
		header.e_machine = EM_MIPS;
#elif defined(__HAIKU_ARCH_ARM)
		header.e_machine = EM_ARM;
#elif defined(__HAIKU_ARCH_ARM64)
		header.e_machine = EM_AARCH64;
#elif defined(__HAIKU_ARCH_SPARC)
		header.e_machine = EM_SPARCV9;
#elif defined(__HAIKU_ARCH_RISCV64)
		header.e_machine = EM_RISCV;
#else
#	error Unsupported architecture!
#endif

		header.e_version = EV_CURRENT;
		header.e_entry = 0;
		header.e_phoff = sizeof(header);
		header.e_shoff = 0;
		header.e_flags = 0;
		header.e_ehsize = sizeof(header);
		header.e_phentsize = sizeof(elf_phdr);
		header.e_phnum = fSegmentCount;
		header.e_shentsize = sizeof(elf_shdr);
		header.e_shnum = 0;
		header.e_shstrndx = SHN_UNDEF;

		return fFile.WriteAt(0, &header, sizeof(header));
	}

	status_t _WriteProgramHeaders()
	{
		fFile.Seek(fProgramHeadersOffset);

		// write the header for the notes segment
		elf_phdr header;
		memset(&header, 0, sizeof(header));
		header.p_type = PT_NOTE;
		header.p_flags = 0;
		header.p_offset = fNoteSegmentOffset;
		header.p_vaddr = 0;
		header.p_paddr = 0;
		header.p_filesz = fNoteSegmentSize;
		header.p_memsz = 0;
		header.p_align = 0;
		fFile.Write(header);

		// write the headers for the area segments
		size_t segmentOffset = fFirstAreaSegmentOffset;
		for (AreaInfoList::Iterator it = fAreaInfos.GetIterator();
				AreaInfo* areaInfo = it.Next();) {
			memset(&header, 0, sizeof(header));
			header.p_type = PT_LOAD;
			header.p_flags = 0;
			uint32 protection = areaInfo->Protection();
			if ((protection & B_READ_AREA) != 0)
				header.p_flags |= PF_READ;
			if ((protection & B_WRITE_AREA) != 0)
				header.p_flags |= PF_WRITE;
			if ((protection & B_EXECUTE_AREA) != 0)
				header.p_flags |= PF_EXECUTE;
			header.p_offset = segmentOffset;
			header.p_vaddr = areaInfo->Base();
			header.p_paddr = 0;
			header.p_filesz = areaInfo->Size();
			header.p_memsz = areaInfo->Size();
			header.p_align = 0;
			fFile.Write(header);

			segmentOffset += areaInfo->Size();
		}

		return fFile.Status();
	}

	status_t _WriteAreaSegments()
	{
		fFile.Seek(fFirstAreaSegmentOffset);

		for (AreaInfoList::Iterator it = fAreaInfos.GetIterator();
				AreaInfo* areaInfo = it.Next();) {
			status_t error = fFile.WriteUserArea(areaInfo->Base(),
				areaInfo->Size());
			if (error != B_OK)
				return error;
		}

		return fFile.Status();
	}

	status_t _WriteNotes()
	{
		status_t error = fFile.Seek((off_t)fNoteSegmentOffset);
		if (error != B_OK)
			return error;

		error = _WriteFilesNote();
		if (error != B_OK)
			return error;

		error = _WriteTeamNote();
		if (error != B_OK)
			return error;

		error = _WriteAreasNote();
		if (error != B_OK)
			return error;

		error = _WriteImagesNote();
		if (error != B_OK)
			return error;

		error = _WriteImageSymbolsNotes();
		if (error != B_OK)
			return error;

		error = _WriteThreadsNote();
		if (error != B_OK)
			return error;

		return B_OK;
	}

	template<typename Writer>
	void _WriteTeamNote(Writer& writer)
	{
		elf_note_team note;
		memset(&note, 0, sizeof(note));
		note.nt_id = fTeamInfo.team;
		note.nt_uid = fTeamInfo.uid;
		note.nt_gid = fTeamInfo.gid;
		writer.Write((uint32)sizeof(note));
		writer.Write(note);

		// write args
		const char* args = fTeamInfo.args;
		writer.Write(args, strlen(args) + 1);
	}

	status_t _WriteTeamNote()
	{
		// determine needed size for the note's data
		DummyWriter dummyWriter;
		_WriteTeamNote(dummyWriter);
		size_t dataSize = dummyWriter.BytesWritten();

		// write the note header
		_WriteNoteHeader(kHaikuNote, NT_TEAM, dataSize);

		// write the note data
		_WriteTeamNote(fFile);

		// padding
		_WriteNotePadding(dataSize);

		return fFile.Status();
	}

	template<typename Writer>
	void _WriteFilesNote(Writer& writer)
	{
		// file count and table size
		writer.Write(fMappedFilesCount);
		writer.Write((size_t)B_PAGE_SIZE);

		// write table
		for (AreaInfoList::Iterator it = fAreaInfos.GetIterator();
				AreaInfo* areaInfo = it.Next();) {
			if (areaInfo->GetImageInfo() == NULL)
				continue;

			// start address, end address, and file offset in pages
			writer.Write(areaInfo->Base());
			writer.Write(areaInfo->Base() + areaInfo->Size());
			writer.Write(size_t(areaInfo->CacheOffset() / B_PAGE_SIZE));
		}

		// write strings
		for (AreaInfoList::Iterator it = fAreaInfos.GetIterator();
				AreaInfo* areaInfo = it.Next();) {
			ImageInfo* imageInfo = areaInfo->GetImageInfo();
			if (imageInfo == NULL)
				continue;

			const char* name = imageInfo->Name();
			writer.Write(name, strlen(name) + 1);
		}
	}

	status_t _WriteFilesNote()
	{
		// determine needed size for the note's data
		DummyWriter dummyWriter;
		_WriteFilesNote(dummyWriter);
		size_t dataSize = dummyWriter.BytesWritten();

		// write the note header
		_WriteNoteHeader(kCoreNote, NT_FILE, dataSize);

		// write the note data
		_WriteFilesNote(fFile);

		// padding
		_WriteNotePadding(dataSize);

		return fFile.Status();
	}

	template<typename Writer>
	void _WriteAreasNote(Writer& writer)
	{
		// area count
		writer.Write((uint32)fAreaCount);
		writer.Write((uint32)sizeof(elf_note_area_entry));

		// write table
		for (AreaInfoList::Iterator it = fAreaInfos.GetIterator();
				AreaInfo* areaInfo = it.Next();) {
			elf_note_area_entry entry;
			memset(&entry, 0, sizeof(entry));
			entry.na_id = areaInfo->Id();
			entry.na_lock = areaInfo->Lock();
			entry.na_protection = areaInfo->Protection();
			entry.na_base = areaInfo->Base();
			entry.na_size = areaInfo->Size();
			entry.na_ram_size = areaInfo->RamSize();
			writer.Write(entry);
		}

		// write strings
		for (AreaInfoList::Iterator it = fAreaInfos.GetIterator();
				AreaInfo* areaInfo = it.Next();) {
			const char* name = areaInfo->Name();
			writer.Write(name, strlen(name) + 1);
		}
	}

	status_t _WriteAreasNote()
	{
		// determine needed size for the note's data
		DummyWriter dummyWriter;
		_WriteAreasNote(dummyWriter);
		size_t dataSize = dummyWriter.BytesWritten();

		// write the note header
		_WriteNoteHeader(kHaikuNote, NT_AREAS, dataSize);

		// write the note data
		_WriteAreasNote(fFile);

		// padding
		_WriteNotePadding(dataSize);

		return fFile.Status();
	}

	template<typename Writer>
	void _WriteImagesNote(Writer& writer)
	{
		// image count
		writer.Write((uint32)fImageCount);
		writer.Write((uint32)sizeof(elf_note_image_entry));

		// write table
		for (ImageInfoList::Iterator it = fImageInfos.GetIterator();
				ImageInfo* imageInfo = it.Next();) {
			elf_note_image_entry entry;
			memset(&entry, 0, sizeof(entry));
			entry.ni_id = imageInfo->Id();
			entry.ni_type = imageInfo->Type();
			entry.ni_init_routine = imageInfo->InitRoutine();
			entry.ni_term_routine = imageInfo->TermRoutine();
			entry.ni_device = imageInfo->DeviceId();
			entry.ni_node = imageInfo->NodeId();
			entry.ni_text_base = imageInfo->TextBase();
			entry.ni_text_size = imageInfo->TextSize();
			entry.ni_data_base = imageInfo->DataBase();
			entry.ni_data_size = imageInfo->DataSize();
			entry.ni_text_delta = imageInfo->TextDelta();
			entry.ni_symbol_table = imageInfo->SymbolTable();
			entry.ni_symbol_hash = imageInfo->SymbolHash();
			entry.ni_string_table = imageInfo->StringTable();
			writer.Write(entry);
		}

		// write strings
		for (ImageInfoList::Iterator it = fImageInfos.GetIterator();
				ImageInfo* imageInfo = it.Next();) {
			const char* name = imageInfo->Name();
			writer.Write(name, strlen(name) + 1);
		}
	}

	status_t _WriteImagesNote()
	{
		// determine needed size for the note's data
		DummyWriter dummyWriter;
		_WriteImagesNote(dummyWriter);
		size_t dataSize = dummyWriter.BytesWritten();

		// write the note header
		_WriteNoteHeader(kHaikuNote, NT_IMAGES, dataSize);

		// write the note data
		_WriteImagesNote(fFile);

		// padding
		_WriteNotePadding(dataSize);

		return fFile.Status();
	}

	status_t _WriteImageSymbolsNotes()
	{
		// write table
		for (ImageInfoList::Iterator it = fImageInfos.GetIterator();
				ImageInfo* imageInfo = it.Next();) {
			if (imageInfo->SymbolTableData() == NULL
					|| imageInfo->StringTableData() == NULL) {
				continue;
			}

			status_t error = _WriteImageSymbolsNote(imageInfo);
			if (error != B_OK)
				return error;
		}

		return B_OK;
	}

	template<typename Writer>
	void _WriteImageSymbolsNote(const ImageInfo* imageInfo, Writer& writer)
	{
		uint32 symbolCount = imageInfo->SymbolCount();
		uint32 symbolEntrySize = (uint32)sizeof(elf_sym);

		writer.Write((int32)imageInfo->Id());
		writer.Write(symbolCount);
		writer.Write(symbolEntrySize);
		writer.Write(imageInfo->SymbolTableData(),
			symbolCount * symbolEntrySize);
		writer.Write(imageInfo->StringTableData(),
			imageInfo->StringTableSize());
	}

	status_t _WriteImageSymbolsNote(const ImageInfo* imageInfo)
	{
		// determine needed size for the note's data
		DummyWriter dummyWriter;
		_WriteImageSymbolsNote(imageInfo, dummyWriter);
		size_t dataSize = dummyWriter.BytesWritten();

		// write the note header
		_WriteNoteHeader(kHaikuNote, NT_SYMBOLS, dataSize);

		// write the note data
		_WriteImageSymbolsNote(imageInfo, fFile);

		// padding
		_WriteNotePadding(dataSize);

		return fFile.Status();
	}

	template<typename Writer>
	void _WriteThreadsNote(Writer& writer)
	{
		// thread count and size of CPU state
		writer.Write((uint32)fThreadCount);
		writer.Write((uint32)sizeof(elf_note_thread_entry));
		writer.Write((uint32)sizeof(debug_cpu_state));

		// write table
		for (ThreadStateList::Iterator it = fThreadStates.GetIterator();
				ThreadState* state = it.Next();) {
			elf_note_thread_entry entry;
			memset(&entry, 0, sizeof(entry));
			entry.nth_id = state->GetThread()->id;
			entry.nth_state = state->State();
			entry.nth_priority = state->Priority();
			entry.nth_stack_base = state->StackBase();
			entry.nth_stack_end = state->StackEnd();
			writer.Write(&entry, sizeof(entry));
			writer.Write(state->CpuState(), sizeof(debug_cpu_state));
		}

		// write strings
		for (ThreadStateList::Iterator it = fThreadStates.GetIterator();
				ThreadState* state = it.Next();) {
			const char* name = state->Name();
			writer.Write(name, strlen(name) + 1);
		}
	}

	status_t _WriteThreadsNote()
	{
		// determine needed size for the note's data
		DummyWriter dummyWriter;
		_WriteThreadsNote(dummyWriter);
		size_t dataSize = dummyWriter.BytesWritten();

		// write the note header
		_WriteNoteHeader(kHaikuNote, NT_THREADS, dataSize);

		// write the note data
		_WriteThreadsNote(fFile);

		// padding
		_WriteNotePadding(dataSize);

		return fFile.Status();
	}

	status_t _WriteNoteHeader(const char* name, uint32 type, uint32 dataSize)
	{
		// prepare and write the header
		Elf32_Nhdr noteHeader;
		memset(&noteHeader, 0, sizeof(noteHeader));
		size_t nameSize = strlen(name) + 1;
		noteHeader.n_namesz = nameSize;
		noteHeader.n_descsz = dataSize;
		noteHeader.n_type = type;
		fFile.Write(noteHeader);

		// write the name
		fFile.Write(name, nameSize);
		// pad the name to 4 byte alignment
		_WriteNotePadding(nameSize);
		return fFile.Status();
	}

	status_t _WriteNotePadding(size_t sizeToPad)
	{
		if (sizeToPad % 4 != 0) {
			uint8 pad[3] = {};
			fFile.Write(&pad, 4 - sizeToPad % 4);
		}
		return fFile.Status();
	}

private:
	Thread*				fCurrentThread;
	Team*				fTeam;
	BufferedFile		fFile;
	TeamInfo			fTeamInfo;
	size_t				fThreadCount;
	ThreadStateList		fThreadStates;
	ThreadStateList		fPreAllocatedThreadStates;
	Allocator			fAreaInfoAllocator;
	AreaInfoList		fAreaInfos;
	ImageInfoList		fImageInfos;
	ConditionVariable	fThreadBlockCondition;
	size_t				fSegmentCount;
	size_t				fProgramHeadersOffset;
	size_t				fNoteSegmentOffset;
	size_t				fNoteSegmentSize;
	size_t				fFirstAreaSegmentOffset;
	size_t				fAreaCount;
	size_t				fImageCount;
	size_t				fMappedFilesCount;
};


} // unnamed namespace


status_t
core_dump_write_core_file(const char* path, bool killTeam)
{
	TRACE("core_dump_write_core_file(\"%s\", %d): team: %" B_PRId32 "\n", path,
		killTeam, team_get_current_team_id());

	CoreDumper* coreDumper = new(std::nothrow) CoreDumper();
	if (coreDumper == NULL)
		return B_NO_MEMORY;
	ObjectDeleter<CoreDumper> coreDumperDeleter(coreDumper);
	return coreDumper->Dump(path, killTeam);
}


void
core_dump_trap_thread()
{
	Thread* thread = thread_get_current_thread();
	ConditionVariableEntry conditionVariableEntry;
	TeamLocker teamLocker(thread->team);

	while ((atomic_get(&thread->flags) & THREAD_FLAGS_TRAP_FOR_CORE_DUMP)
			!= 0) {
		thread->team->CoreDumpCondition()->Add(&conditionVariableEntry);
		teamLocker.Unlock();
		conditionVariableEntry.Wait();
		teamLocker.Lock();
	}
}