coredumper-solaris.cpp@ 106580

Last change on this file since 106580 was 106061, checked in by vboxsync, 2 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 82.8 KB

Line
1	/* $Id: coredumper-solaris.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* IPRT - Custom Core Dumper, Solaris.
4	*/
5
6	/*
7	* Copyright (C) 2010-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#define LOG_GROUP RTLOGGROUP_DEFAULT
42	#include <iprt/coredumper.h>
43
44	#include <iprt/asm.h>
45	#include <iprt/dir.h>
46	#include <iprt/err.h>
47	#include <iprt/log.h>
48	#include <iprt/param.h>
49	#include <iprt/path.h>
50	#include <iprt/process.h>
51	#include <iprt/string.h>
52	#include <iprt/thread.h>
53	#include "coredumper-solaris.h"
54
55	#ifdef RT_OS_SOLARIS
56	# include <syslog.h>
57	# include <signal.h>
58	# include <stdlib.h>
59	# include <unistd.h>
60	# include <errno.h>
61	# include <zone.h>
62	# include <sys/proc.h>
63	# include <sys/sysmacros.h>
64	# include <sys/systeminfo.h>
65	# include <sys/mman.h>
66	# include <sys/types.h>
67	# include <sys/stat.h>
68	# include <fcntl.h>
69	# include <ucontext.h>
70	#endif /* RT_OS_SOLARIS */
71
72	#include <iprt/formats/elf.h>
73	#include <iprt/formats/elf64.h>
74
75
76	/*********************************************************************************************************************************
77	* Globals *
78	*********************************************************************************************************************************/
79	static RTNATIVETHREAD volatile g_CoreDumpThread = NIL_RTNATIVETHREAD;
80	static bool volatile g_fCoreDumpSignalSetup = false;
81	static uint32_t volatile g_fCoreDumpFlags = 0;
82	static char g_szCoreDumpDir[PATH_MAX] = { 0 };
83	static char g_szCoreDumpFile[PATH_MAX] = { 0 };
84
85
86	/*********************************************************************************************************************************
87	* Defined Constants And Macros *
88	*********************************************************************************************************************************/
89	#define CORELOG_NAME "CoreDumper: "
90	#define CORELOG(a) Log(a)
91	#define CORELOGRELSYS(a) \
92	do { \
93	rtCoreDumperSysLogWrapper a; \
94	} while (0)
95
96
97	/**
98	* ELFNOTEHDR: ELF NOTE header.
99	*/
100	typedef struct ELFNOTEHDR
101	{
102	Elf64_Nhdr Hdr; /* Header of NOTE section */
103	char achName[8]; /* Name of NOTE section */
104	} ELFNOTEHDR;
105	typedef ELFNOTEHDR *PELFNOTEHDR;
106
107	/**
108	* Wrapper function to write IPRT format style string to the syslog.
109	*
110	* @param pszFormat Format string
111	*/
112	static void rtCoreDumperSysLogWrapper(const char *pszFormat, ...)
113	{
114	va_list va;
115	va_start(va, pszFormat);
116	char szBuf[1024];
117	RTStrPrintfV(szBuf, sizeof(szBuf), pszFormat, va);
118	va_end(va);
119	syslog(LOG_ERR, "%s", szBuf);
120	}
121
122
123	/**
124	* Determines endianness of the system. Just for completeness.
125	*
126	* @return Will return false if system is little endian, true otherwise.
127	*/
128	static bool IsBigEndian()
129	{
130	const int i = 1;
131	char p = (char )&i;
132	if (p[0] == 1)
133	return false;
134	return true;
135	}
136
137
138	/**
139	* Reads from a file making sure an interruption doesn't cause a failure.
140	*
141	* @param fd Handle to the file to read.
142	* @param pv Where to store the read data.
143	* @param cbToRead Size of data to read.
144	*
145	* @return IPRT status code.
146	*/
147	static int ReadFileNoIntr(int fd, void *pv, size_t cbToRead)
148	{
149	for (;;)
150	{
151	ssize_t cbRead = read(fd, pv, cbToRead);
152	if (cbRead < 0)
153	{
154	if (errno == EINTR)
155	continue;
156	return RTErrConvertFromErrno(errno);
157	}
158	if ((size_t)cbRead == cbToRead)
159	return VINF_SUCCESS;
160	if ((size_t)cbRead > cbToRead)
161	return VERR_INTERNAL_ERROR_3;
162	if (cbRead == 0)
163	return VERR_EOF;
164	pv = (uint8_t *)pv + cbRead;
165	cbToRead -= cbRead;
166	}
167	}
168
169
170	/**
171	* Writes to a file making sure an interruption doesn't cause a failure.
172	*
173	* @param fd Handle to the file to write to.
174	* @param pv Pointer to what to write.
175	* @param cbToWrite Size of data to write.
176	*
177	* @return IPRT status code.
178	*/
179	static int WriteFileNoIntr(int fd, const void *pv, size_t cbToWrite)
180	{
181	for (;;)
182	{
183	ssize_t cbWritten = write(fd, pv, cbToWrite);
184	if (cbWritten < 0)
185	{
186	if (errno == EINTR)
187	continue;
188	return RTErrConvertFromErrno(errno);
189	}
190	if ((size_t)cbWritten == cbToWrite)
191	return VINF_SUCCESS;
192	if ((size_t)cbWritten > cbToWrite)
193	return VERR_INTERNAL_ERROR_2;
194	pv = (uint8_t const *)pv + cbWritten;
195	cbToWrite -= cbWritten;
196	}
197	}
198
199
200	/**
201	* Read from a given offset in the process' address space.
202	*
203	* @param pSolProc Pointer to the solaris process.
204	* @param off The offset to read from.
205	* @param pvBuf Where to read the data into.
206	* @param cbToRead Number of bytes to read.
207	*
208	* @return VINF_SUCCESS, if all the given bytes was read in, otherwise VERR_READ_ERROR.
209	*/
210	static ssize_t ProcReadAddrSpace(PRTSOLCOREPROCESS pSolProc, RTFOFF off, void *pvBuf, size_t cbToRead)
211	{
212	for (;;)
213	{
214	ssize_t cbRead = pread(pSolProc->fdAs, pvBuf, cbToRead, off);
215	if (cbRead < 0)
216	{
217	if (errno == EINTR)
218	continue;
219	return RTErrConvertFromErrno(errno);
220	}
221	if ((size_t)cbRead == cbToRead)
222	return VINF_SUCCESS;
223	if ((size_t)cbRead > cbToRead)
224	return VERR_INTERNAL_ERROR_4;
225	if (cbRead == 0)
226	return VERR_EOF;
227
228	pvBuf = (uint8_t *)pvBuf + cbRead;
229	cbToRead -= cbRead;
230	off += cbRead;
231	}
232	}
233
234
235	/**
236	* Determines if the current process' architecture is suitable for dumping core.
237	*
238	* @param pSolProc Pointer to the solaris process.
239	*
240	* @return true if the architecture matches the current one.
241	*/
242	static inline bool IsProcessArchNative(PRTSOLCOREPROCESS pSolProc)
243	{
244	psinfo_t pProcInfo = (psinfo_t )pSolProc->pvProcInfo;
245	return pProcInfo->pr_dmodel == PR_MODEL_NATIVE;
246	}
247
248
249	/**
250	* Helper function to get the size_t compatible file size from a file
251	* descriptor.
252	*
253	* @return The file size (in bytes).
254	* @param fd The file descriptor.
255	*/
256	static size_t GetFileSizeByFd(int fd)
257	{
258	struct stat st;
259	if (fstat(fd, &st) == 0)
260	{
261	if (st.st_size <= 0)
262	return 0;
263	size_t cbFile = (size_t)st.st_size;
264	return (off_t)cbFile == st.st_size ? cbFile : ~(size_t)0;
265	}
266
267	CORELOGRELSYS((CORELOG_NAME "GetFileSizeByFd: fstat failed rc=%Rrc\n", RTErrConvertFromErrno(errno)));
268	return 0;
269	}
270
271
272	/**
273	* Helper function to get the size_t compatible size of a file given its path.
274	*
275	* @return The file size (in bytes).
276	* @param pszPath Pointer to the full path of the file.
277	*/
278	static size_t GetFileSizeByName(const char *pszPath)
279	{
280	int fd = open(pszPath, O_RDONLY);
281	if (fd < 0)
282	{
283	CORELOGRELSYS((CORELOG_NAME "GetFileSizeByName: failed to open %s rc=%Rrc\n", pszPath, RTErrConvertFromErrno(errno)));
284	return 0;
285	}
286
287	size_t cb = GetFileSizeByFd(fd);
288	close(fd);
289	return cb;
290	}
291
292
293	/**
294	* Pre-compute and pre-allocate sufficient memory for dumping core.
295	* This is meant to be called once, as a single-large anonymously
296	* mapped memory area which will be used during the core dumping routines.
297	*
298	* @param pSolCore Pointer to the core object.
299	*
300	* @return IPRT status code.
301	*/
302	static int AllocMemoryArea(PRTSOLCORE pSolCore)
303	{
304	AssertReturn(pSolCore->pvCore == NULL, VERR_ALREADY_EXISTS);
305
306	static struct
307	{
308	const char pszFilePath; / Proc based path */
309	size_t cbHeader; /* Size of header */
310	size_t cbEntry; /* Size of each entry in file */
311	size_t cbAccounting; /* Size of each accounting entry per entry */
312	} const s_aPreAllocTable[] =
313	{
314	{ "/proc/%d/psinfo", 0, 0, 0 },
315	{ "/proc/%d/map", 0, sizeof(prmap_t), sizeof(RTSOLCOREMAPINFO) },
316	{ "/proc/%d/auxv", 0, 0, 0 },
317	{ "/proc/%d/lpsinfo", sizeof(prheader_t), sizeof(lwpsinfo_t), sizeof(RTSOLCORETHREADINFO) },
318	{ "/proc/%d/lstatus", 0, 0, 0 },
319	{ "/proc/%d/ldt", 0, 0, 0 },
320	{ "/proc/%d/cred", sizeof(prcred_t), sizeof(gid_t), 0 },
321	{ "/proc/%d/priv", sizeof(prpriv_t), sizeof(priv_chunk_t), 0 },
322	};
323
324	size_t cb = 0;
325	for (unsigned i = 0; i < RT_ELEMENTS(s_aPreAllocTable); i++)
326	{
327	char szPath[PATH_MAX];
328	RTStrPrintf(szPath, sizeof(szPath), s_aPreAllocTable[i].pszFilePath, (int)pSolCore->SolProc.Process);
329	size_t cbFile = GetFileSizeByName(szPath);
330	cb += cbFile;
331	if ( cbFile > 0
332	&& s_aPreAllocTable[i].cbEntry > 0)
333	{
334	cb += ((cbFile - s_aPreAllocTable[i].cbHeader) / s_aPreAllocTable[i].cbEntry)
335	* (s_aPreAllocTable[i].cbAccounting > 0 ? s_aPreAllocTable[i].cbAccounting : 1);
336	cb += s_aPreAllocTable[i].cbHeader;
337	}
338	}
339
340	/*
341	* Make room for our own mapping accountant entry which will also be included in the core.
342	*/
343	cb += sizeof(RTSOLCOREMAPINFO);
344
345	/*
346	* Allocate the required space, plus some extra room.
347	*/
348	cb += _128K;
349	void pv = mmap(NULL, cb, PROT_READ \| PROT_WRITE, MAP_PRIVATE \| MAP_ANON, -1 / fd /, 0 / offset */);
350	if (pv != MAP_FAILED)
351	{
352	CORELOG((CORELOG_NAME "AllocMemoryArea: memory area of %u bytes allocated.\n", cb));
353	pSolCore->pvCore = pv;
354	pSolCore->pvFree = pv;
355	pSolCore->cbCore = cb;
356	return VINF_SUCCESS;
357	}
358	CORELOGRELSYS((CORELOG_NAME "AllocMemoryArea: failed cb=%u\n", cb));
359	return VERR_NO_MEMORY;
360	}
361
362
363	/**
364	* Free memory area used by the core object.
365	*
366	* @param pSolCore Pointer to the core object.
367	*/
368	static void FreeMemoryArea(PRTSOLCORE pSolCore)
369	{
370	AssertReturnVoid(pSolCore);
371	AssertReturnVoid(pSolCore->pvCore);
372	AssertReturnVoid(pSolCore->cbCore > 0);
373
374	munmap(pSolCore->pvCore, pSolCore->cbCore);
375	CORELOG((CORELOG_NAME "FreeMemoryArea: memory area of %u bytes freed.\n", pSolCore->cbCore));
376
377	pSolCore->pvCore = NULL;
378	pSolCore->pvFree= NULL;
379	pSolCore->cbCore = 0;
380	}
381
382
383	/**
384	* Get a chunk from the area of allocated memory.
385	*
386	* @param pSolCore Pointer to the core object.
387	* @param cb Size of requested chunk.
388	*
389	* @return Pointer to allocated memory, or NULL on failure.
390	*/
391	static void *GetMemoryChunk(PRTSOLCORE pSolCore, size_t cb)
392	{
393	AssertReturn(pSolCore, NULL);
394	AssertReturn(pSolCore->pvCore, NULL);
395	AssertReturn(pSolCore->pvFree, NULL);
396
397	size_t cbAllocated = (char )pSolCore->pvFree - (char )pSolCore->pvCore;
398	if (cbAllocated < pSolCore->cbCore)
399	{
400	char pb = (char )pSolCore->pvFree;
401	pSolCore->pvFree = pb + cb;
402	return pb;
403	}
404
405	return NULL;
406	}
407
408
409	/**
410	* Reads the proc file's content into a newly allocated buffer.
411	*
412	* @param pSolCore Pointer to the core object.
413	* @param pszProcFileName Only the name of the file to read from
414	* (/proc/\<pid\> will be prepended)
415	* @param ppv Where to store the allocated buffer.
416	* @param pcb Where to store size of the buffer.
417	*
418	* @return IPRT status code. If the proc file is 0 bytes, VINF_SUCCESS is
419	* returned with pointed to values of @c ppv, @c pcb set to NULL and 0
420	* respectively.
421	*/
422	static int ProcReadFileInto(PRTSOLCORE pSolCore, const char pszProcFileName, void ppv, size_t pcb)
423	{
424	AssertReturn(pSolCore, VERR_INVALID_POINTER);
425
426	char szPath[PATH_MAX];
427	RTStrPrintf(szPath, sizeof(szPath), "/proc/%d/%s", (int)pSolCore->SolProc.Process, pszProcFileName);
428	int rc = VINF_SUCCESS;
429	int fd = open(szPath, O_RDONLY);
430	if (fd >= 0)
431	{
432	*pcb = GetFileSizeByFd(fd);
433	if (*pcb > 0)
434	{
435	ppv = GetMemoryChunk(pSolCore, pcb);
436	if (*ppv)
437	rc = ReadFileNoIntr(fd, ppv, pcb);
438	else
439	rc = VERR_NO_MEMORY;
440	}
441	else
442	{
443	*pcb = 0;
444	*ppv = NULL;
445	rc = VINF_SUCCESS;
446	}
447	close(fd);
448	}
449	else
450	{
451	rc = RTErrConvertFromErrno(fd);
452	CORELOGRELSYS((CORELOG_NAME "ProcReadFileInto: failed to open %s. rc=%Rrc\n", szPath, rc));
453	}
454	return rc;
455	}
456
457
458	/**
459	* Read process information (format psinfo_t) from /proc.
460	*
461	* @param pSolCore Pointer to the core object.
462	*
463	* @return IPRT status code.
464	*/
465	static int ProcReadInfo(PRTSOLCORE pSolCore)
466	{
467	AssertReturn(pSolCore, VERR_INVALID_POINTER);
468
469	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
470	return ProcReadFileInto(pSolCore, "psinfo", &pSolProc->pvProcInfo, &pSolProc->cbProcInfo);
471	}
472
473
474	/**
475	* Read process status (format pstatus_t) from /proc.
476	*
477	* @param pSolCore Pointer to the core object.
478	*
479	* @return IPRT status code.
480	*/
481	static int ProcReadStatus(PRTSOLCORE pSolCore)
482	{
483	AssertReturn(pSolCore, VERR_INVALID_POINTER);
484
485	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
486
487	char szPath[PATH_MAX];
488	int rc = VINF_SUCCESS;
489
490	RTStrPrintf(szPath, sizeof(szPath), "/proc/%d/status", (int)pSolProc->Process);
491	int fd = open(szPath, O_RDONLY);
492	if (fd >= 0)
493	{
494	size_t cbProcStatus = sizeof(pstatus_t);
495	AssertCompile(sizeof(pstatus_t) == sizeof(pSolProc->ProcStatus));
496	rc = ReadFileNoIntr(fd, &pSolProc->ProcStatus, cbProcStatus);
497	close(fd);
498	}
499	else
500	{
501	rc = RTErrConvertFromErrno(fd);
502	CORELOGRELSYS((CORELOG_NAME "ProcReadStatus: failed to open %s. rc=%Rrc\n", szPath, rc));
503	}
504	return rc;
505	}
506
507
508	/**
509	* Read process credential information (format prcred_t + array of guid_t)
510	*
511	* @return IPRT status code.
512	* @param pSolCore Pointer to the core object.
513	*
514	* @remarks Should not be called before successful call to @see AllocMemoryArea()
515	*/
516	static int ProcReadCred(PRTSOLCORE pSolCore)
517	{
518	AssertReturn(pSolCore, VERR_INVALID_POINTER);
519
520	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
521	return ProcReadFileInto(pSolCore, "cred", &pSolProc->pvCred, &pSolProc->cbCred);
522	}
523
524
525	/**
526	* Read process privilege information (format prpriv_t + array of priv_chunk_t)
527	*
528	* @return IPRT status code.
529	* @param pSolCore Pointer to the core object.
530	*
531	* @remarks Should not be called before successful call to @see AllocMemoryArea()
532	*/
533	static int ProcReadPriv(PRTSOLCORE pSolCore)
534	{
535	AssertReturn(pSolCore, VERR_INVALID_POINTER);
536
537	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
538	int rc = ProcReadFileInto(pSolCore, "priv", (void **)&pSolProc->pPriv, &pSolProc->cbPriv);
539	if (RT_FAILURE(rc))
540	return rc;
541	pSolProc->pcPrivImpl = getprivimplinfo();
542	if (!pSolProc->pcPrivImpl)
543	{
544	CORELOGRELSYS((CORELOG_NAME "ProcReadPriv: getprivimplinfo returned NULL.\n"));
545	return VERR_INVALID_STATE;
546	}
547	return rc;
548	}
549
550
551	/**
552	* Read process LDT information (format array of struct ssd) from /proc.
553	*
554	* @return IPRT status code.
555	* @param pSolCore Pointer to the core object.
556	*
557	* @remarks Should not be called before successful call to @see AllocMemoryArea()
558	*/
559	static int ProcReadLdt(PRTSOLCORE pSolCore)
560	{
561	AssertReturn(pSolCore, VERR_INVALID_POINTER);
562
563	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
564	return ProcReadFileInto(pSolCore, "ldt", &pSolProc->pvLdt, &pSolProc->cbLdt);
565	}
566
567
568	/**
569	* Read process auxiliary vectors (format auxv_t) for the process.
570	*
571	* @return IPRT status code.
572	* @param pSolCore Pointer to the core object.
573	*
574	* @remarks Should not be called before successful call to @see AllocMemoryArea()
575	*/
576	static int ProcReadAuxVecs(PRTSOLCORE pSolCore)
577	{
578	AssertReturn(pSolCore, VERR_INVALID_POINTER);
579
580	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
581	char szPath[PATH_MAX];
582	int rc = VINF_SUCCESS;
583	RTStrPrintf(szPath, sizeof(szPath), "/proc/%d/auxv", (int)pSolProc->Process);
584	int fd = open(szPath, O_RDONLY);
585	if (fd < 0)
586	{
587	rc = RTErrConvertFromErrno(fd);
588	CORELOGRELSYS((CORELOG_NAME "ProcReadAuxVecs: failed to open %s rc=%Rrc\n", szPath, rc));
589	return rc;
590	}
591
592	size_t cbAuxFile = GetFileSizeByFd(fd);
593	if (cbAuxFile >= sizeof(auxv_t))
594	{
595	pSolProc->pAuxVecs = (auxv_t*)GetMemoryChunk(pSolCore, cbAuxFile + sizeof(auxv_t));
596	if (pSolProc->pAuxVecs)
597	{
598	rc = ReadFileNoIntr(fd, pSolProc->pAuxVecs, cbAuxFile);
599	if (RT_SUCCESS(rc))
600	{
601	/* Terminate list of vectors */
602	pSolProc->cAuxVecs = cbAuxFile / sizeof(auxv_t);
603	CORELOG((CORELOG_NAME "ProcReadAuxVecs: cbAuxFile=%u auxv_t size %d cAuxVecs=%u\n", cbAuxFile, sizeof(auxv_t),
604	pSolProc->cAuxVecs));
605	if (pSolProc->cAuxVecs > 0)
606	{
607	pSolProc->pAuxVecs[pSolProc->cAuxVecs].a_type = AT_NULL;
608	pSolProc->pAuxVecs[pSolProc->cAuxVecs].a_un.a_val = 0L;
609	close(fd);
610	return VINF_SUCCESS;
611	}
612
613	CORELOGRELSYS((CORELOG_NAME "ProcReadAuxVecs: Invalid vector count %u\n", pSolProc->cAuxVecs));
614	rc = VERR_READ_ERROR;
615	}
616	else
617	CORELOGRELSYS((CORELOG_NAME "ProcReadAuxVecs: ReadFileNoIntr failed. rc=%Rrc cbAuxFile=%u\n", rc, cbAuxFile));
618
619	pSolProc->pAuxVecs = NULL;
620	pSolProc->cAuxVecs = 0;
621	}
622	else
623	{
624	CORELOGRELSYS((CORELOG_NAME "ProcReadAuxVecs: no memory for %u bytes\n", cbAuxFile + sizeof(auxv_t)));
625	rc = VERR_NO_MEMORY;
626	}
627	}
628	else
629	{
630	CORELOGRELSYS((CORELOG_NAME "ProcReadAuxVecs: aux file too small %u, expecting %u or more\n", cbAuxFile, sizeof(auxv_t)));
631	rc = VERR_READ_ERROR;
632	}
633
634	close(fd);
635	return rc;
636	}
637
638
639	/*
640	* Find an element in the process' auxiliary vector.
641	*/
642	static long GetAuxVal(PRTSOLCOREPROCESS pSolProc, int Type)
643	{
644	AssertReturn(pSolProc, -1);
645	if (pSolProc->pAuxVecs)
646	{
647	auxv_t *pAuxVec = pSolProc->pAuxVecs;
648	for (; pAuxVec->a_type != AT_NULL; pAuxVec++)
649	{
650	if (pAuxVec->a_type == Type)
651	return pAuxVec->a_un.a_val;
652	}
653	}
654	return -1;
655	}
656
657
658	/**
659	* Read the process mappings (format prmap_t array).
660	*
661	* @return IPRT status code.
662	* @param pSolCore Pointer to the core object.
663	*
664	* @remarks Should not be called before successful call to @see AllocMemoryArea()
665	*/
666	static int ProcReadMappings(PRTSOLCORE pSolCore)
667	{
668	AssertReturn(pSolCore, VERR_INVALID_POINTER);
669
670	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
671	char szPath[PATH_MAX];
672	int rc = VINF_SUCCESS;
673	RTStrPrintf(szPath, sizeof(szPath), "/proc/%d/map", (int)pSolProc->Process);
674	int fdMap = open(szPath, O_RDONLY);
675	if (fdMap < 0)
676	{
677	rc = RTErrConvertFromErrno(errno);
678	CORELOGRELSYS((CORELOG_NAME "ProcReadMappings: failed to open %s. rc=%Rrc\n", szPath, rc));
679	return rc;
680	}
681
682	RTStrPrintf(szPath, sizeof(szPath), "/proc/%d/as", (int)pSolProc->Process);
683	pSolProc->fdAs = open(szPath, O_RDONLY);
684	if (pSolProc->fdAs >= 0)
685	{
686	/*
687	* Allocate and read all the prmap_t objects from proc.
688	*/
689	size_t cbMapFile = GetFileSizeByFd(fdMap);
690	if (cbMapFile >= sizeof(prmap_t))
691	{
692	prmap_t pMap = (prmap_t)GetMemoryChunk(pSolCore, cbMapFile);
693	if (pMap)
694	{
695	rc = ReadFileNoIntr(fdMap, pMap, cbMapFile);
696	if (RT_SUCCESS(rc))
697	{
698	pSolProc->cMappings = cbMapFile / sizeof(prmap_t);
699	if (pSolProc->cMappings > 0)
700	{
701	/*
702	* Allocate for each prmap_t object, a corresponding RTSOLCOREMAPINFO object.
703	*/
704	pSolProc->pMapInfoHead = (PRTSOLCOREMAPINFO)GetMemoryChunk(pSolCore,
705	pSolProc->cMappings * sizeof(RTSOLCOREMAPINFO));
706	if (pSolProc->pMapInfoHead)
707	{
708	/*
709	* Associate the prmap_t with the mapping info object.
710	*/
711	/Assert(pSolProc->pMapInfoHead == NULL); - does not make sense /
712	PRTSOLCOREMAPINFO pCur = pSolProc->pMapInfoHead;
713	PRTSOLCOREMAPINFO pPrev = NULL;
714	for (uint64_t i = 0; i < pSolProc->cMappings; i++, pMap++, pCur++)
715	{
716	memcpy(&pCur->pMap, pMap, sizeof(pCur->pMap));
717	if (pPrev)
718	pPrev->pNext = pCur;
719
720	pCur->fError = 0;
721
722	/*
723	* Make sure we can read the mapping, otherwise mark them to be skipped.
724	*/
725	char achBuf[PAGE_SIZE];
726	uint64_t k = 0;
727	while (k < pCur->pMap.pr_size)
728	{
729	size_t cb = RT_MIN(sizeof(achBuf), pCur->pMap.pr_size - k);
730	int rc2 = ProcReadAddrSpace(pSolProc, pCur->pMap.pr_vaddr + k, &achBuf, cb);
731	if (RT_FAILURE(rc2))
732	{
733	CORELOGRELSYS((CORELOG_NAME "ProcReadMappings: skipping mapping. vaddr=%#x rc=%Rrc\n",
734	pCur->pMap.pr_vaddr, rc2));
735
736	/*
737	* Instead of storing the actual mapping data which we failed to read, the core
738	* will contain an errno in place. So we adjust the prmap_t's size field too
739	* so the program header offsets match.
740	*/
741	pCur->pMap.pr_size = RT_ALIGN_Z(sizeof(int), 8);
742	pCur->fError = errno;
743	if (pCur->fError == 0) /* huh!? somehow errno got reset? fake one! EFAULT is nice. */
744	pCur->fError = EFAULT;
745	break;
746	}
747	k += cb;
748	}
749
750	pPrev = pCur;
751	}
752	if (pPrev)
753	pPrev->pNext = NULL;
754
755	close(fdMap);
756	close(pSolProc->fdAs);
757	pSolProc->fdAs = -1;
758	CORELOG((CORELOG_NAME "ProcReadMappings: successfully read in %u mappings\n", pSolProc->cMappings));
759	return VINF_SUCCESS;
760	}
761
762	CORELOGRELSYS((CORELOG_NAME "ProcReadMappings: GetMemoryChunk failed %u\n",
763	pSolProc->cMappings * sizeof(RTSOLCOREMAPINFO)));
764	rc = VERR_NO_MEMORY;
765	}
766	else
767	{
768	CORELOGRELSYS((CORELOG_NAME "ProcReadMappings: Invalid mapping count %u\n", pSolProc->cMappings));
769	rc = VERR_READ_ERROR;
770	}
771	}
772	else
773	{
774	CORELOGRELSYS((CORELOG_NAME "ProcReadMappings: FileReadNoIntr failed. rc=%Rrc cbMapFile=%u\n", rc,
775	cbMapFile));
776	}
777	}
778	else
779	{
780	CORELOGRELSYS((CORELOG_NAME "ProcReadMappings: GetMemoryChunk failed. cbMapFile=%u\n", cbMapFile));
781	rc = VERR_NO_MEMORY;
782	}
783	}
784
785	close(pSolProc->fdAs);
786	pSolProc->fdAs = -1;
787	}
788	else
789	CORELOGRELSYS((CORELOG_NAME "ProcReadMappings: failed to open %s. rc=%Rrc\n", szPath, rc));
790
791	close(fdMap);
792	return rc;
793	}
794
795
796	/**
797	* Reads the thread information for all threads in the process.
798	*
799	* @return IPRT status code.
800	* @param pSolCore Pointer to the core object.
801	*
802	* @remarks Should not be called before successful call to @see AllocMemoryArea()
803	*/
804	static int ProcReadThreads(PRTSOLCORE pSolCore)
805	{
806	AssertReturn(pSolCore, VERR_INVALID_POINTER);
807
808	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
809	AssertReturn(pSolProc->pCurThreadCtx, VERR_NO_DATA);
810
811	/*
812	* Read the information for threads.
813	* Format: prheader_t + array of lwpsinfo_t's.
814	*/
815	size_t cbInfoHdrAndData;
816	void *pvInfoHdr = NULL;
817	int rc = ProcReadFileInto(pSolCore, "lpsinfo", &pvInfoHdr, &cbInfoHdrAndData);
818	if (RT_SUCCESS(rc))
819	{
820	/*
821	* Read the status of threads.
822	* Format: prheader_t + array of lwpstatus_t's.
823	*/
824	void *pvStatusHdr = NULL;
825	size_t cbStatusHdrAndData;
826	rc = ProcReadFileInto(pSolCore, "lstatus", &pvStatusHdr, &cbStatusHdrAndData);
827	if (RT_SUCCESS(rc))
828	{
829	prheader_t pInfoHdr = (prheader_t )pvInfoHdr;
830	prheader_t pStatusHdr = (prheader_t )pvStatusHdr;
831	lwpstatus_t pStatus = (lwpstatus_t )((uintptr_t)pStatusHdr + sizeof(prheader_t));
832	lwpsinfo_t pInfo = (lwpsinfo_t )((uintptr_t)pInfoHdr + sizeof(prheader_t));
833	uint64_t cStatus = pStatusHdr->pr_nent;
834	uint64_t cInfo = pInfoHdr->pr_nent;
835
836	CORELOG((CORELOG_NAME "ProcReadThreads: read info(%u) status(%u), threads:cInfo=%u cStatus=%u\n", cbInfoHdrAndData,
837	cbStatusHdrAndData, cInfo, cStatus));
838
839	/*
840	* Minor sanity size check (remember sizeof lwpstatus_t & lwpsinfo_t is <= size in file per entry).
841	*/
842	if ( (cbStatusHdrAndData - sizeof(prheader_t)) % pStatusHdr->pr_entsize == 0
843	&& (cbInfoHdrAndData - sizeof(prheader_t)) % pInfoHdr->pr_entsize == 0)
844	{
845	/*
846	* Make sure we have a matching lstatus entry for an lpsinfo entry unless
847	* it is a zombie thread, in which case we will not have a matching lstatus entry.
848	*/
849	for (; cInfo != 0; cInfo--)
850	{
851	if (pInfo->pr_sname != 'Z') /* zombie */
852	{
853	if ( cStatus == 0
854	\|\| pStatus->pr_lwpid != pInfo->pr_lwpid)
855	{
856	CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: cStatus = %u pStatuslwpid=%d infolwpid=%d\n", cStatus,
857	pStatus->pr_lwpid, pInfo->pr_lwpid));
858	rc = VERR_INVALID_STATE;
859	break;
860	}
861	pStatus = (lwpstatus_t *)((uintptr_t)pStatus + pStatusHdr->pr_entsize);
862	cStatus--;
863	}
864	pInfo = (lwpsinfo_t *)((uintptr_t)pInfo + pInfoHdr->pr_entsize);
865	}
866
867	if (RT_SUCCESS(rc))
868	{
869	/*
870	* There can still be more lwpsinfo_t's than lwpstatus_t's, build the
871	* lists accordingly.
872	*/
873	pStatus = (lwpstatus_t *)((uintptr_t)pStatusHdr + sizeof(prheader_t));
874	pInfo = (lwpsinfo_t *)((uintptr_t)pInfoHdr + sizeof(prheader_t));
875	cInfo = pInfoHdr->pr_nent;
876	cStatus = pInfoHdr->pr_nent;
877
878	size_t cbThreadInfo = RT_MAX(cStatus, cInfo) * sizeof(RTSOLCORETHREADINFO);
879	pSolProc->pThreadInfoHead = (PRTSOLCORETHREADINFO)GetMemoryChunk(pSolCore, cbThreadInfo);
880	if (pSolProc->pThreadInfoHead)
881	{
882	PRTSOLCORETHREADINFO pCur = pSolProc->pThreadInfoHead;
883	PRTSOLCORETHREADINFO pPrev = NULL;
884	for (uint64_t i = 0; i < cInfo; i++, pCur++)
885	{
886	pCur->Info = *pInfo;
887	if ( pInfo->pr_sname != 'Z'
888	&& pInfo->pr_lwpid == pStatus->pr_lwpid)
889	{
890	/*
891	* Adjust the context of the dumping thread to reflect the context
892	* when the core dump got initiated before whatever signal caused it.
893	*/
894	if ( pStatus /* noid droid */
895	&& pStatus->pr_lwpid == (id_t)pSolProc->hCurThread)
896	{
897	AssertCompile(sizeof(pStatus->pr_reg) == sizeof(pSolProc->pCurThreadCtx->uc_mcontext.gregs));
898	AssertCompile(sizeof(pStatus->pr_fpreg) == sizeof(pSolProc->pCurThreadCtx->uc_mcontext.fpregs));
899	memcpy(&pStatus->pr_reg, &pSolProc->pCurThreadCtx->uc_mcontext.gregs, sizeof(pStatus->pr_reg));
900	memcpy(&pStatus->pr_fpreg, &pSolProc->pCurThreadCtx->uc_mcontext.fpregs, sizeof(pStatus->pr_fpreg));
901
902	AssertCompile(sizeof(pStatus->pr_lwphold) == sizeof(pSolProc->pCurThreadCtx->uc_sigmask));
903	memcpy(&pStatus->pr_lwphold, &pSolProc->pCurThreadCtx->uc_sigmask, sizeof(pStatus->pr_lwphold));
904	pStatus->pr_ustack = (uintptr_t)&pSolProc->pCurThreadCtx->uc_stack;
905
906	CORELOG((CORELOG_NAME "ProcReadThreads: patched dumper thread with pre-dump time context.\n"));
907	}
908
909	pCur->pStatus = pStatus;
910	pStatus = (lwpstatus_t *)((uintptr_t)pStatus + pStatusHdr->pr_entsize);
911	}
912	else
913	{
914	CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: missing status for lwp %d\n", pInfo->pr_lwpid));
915	pCur->pStatus = NULL;
916	}
917
918	if (pPrev)
919	pPrev->pNext = pCur;
920	pPrev = pCur;
921	pInfo = (lwpsinfo_t *)((uintptr_t)pInfo + pInfoHdr->pr_entsize);
922	}
923	if (pPrev)
924	pPrev->pNext = NULL;
925
926	CORELOG((CORELOG_NAME "ProcReadThreads: successfully read %u threads.\n", cInfo));
927	pSolProc->cThreads = cInfo;
928	return VINF_SUCCESS;
929	}
930	else
931	{
932	CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: GetMemoryChunk failed for %u bytes\n", cbThreadInfo));
933	rc = VERR_NO_MEMORY;
934	}
935	}
936	else
937	CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: Invalid state information for threads. rc=%Rrc\n", rc));
938	}
939	else
940	{
941	CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: huh!? cbStatusHdrAndData=%u prheader_t=%u entsize=%u\n",
942	cbStatusHdrAndData, sizeof(prheader_t), pStatusHdr->pr_entsize));
943	CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: huh!? cbInfoHdrAndData=%u entsize=%u\n", cbInfoHdrAndData,
944	pStatusHdr->pr_entsize));
945	rc = VERR_INVALID_STATE;
946	}
947	}
948	else
949	CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: ReadFileNoIntr failed for \"lpsinfo\" rc=%Rrc\n", rc));
950	}
951	else
952	CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: ReadFileNoIntr failed for \"lstatus\" rc=%Rrc\n", rc));
953	return rc;
954	}
955
956
957	/**
958	* Reads miscellaneous information that is collected as part of a core file.
959	* This may include platform name, zone name and other OS-specific information.
960	*
961	* @param pSolCore Pointer to the core object.
962	*
963	* @return IPRT status code.
964	*/
965	static int ProcReadMiscInfo(PRTSOLCORE pSolCore)
966	{
967	AssertReturn(pSolCore, VERR_INVALID_POINTER);
968
969	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
970
971	#ifdef RT_OS_SOLARIS
972	/*
973	* Read the platform name, uname string and zone name.
974	*/
975	int rc = sysinfo(SI_PLATFORM, pSolProc->szPlatform, sizeof(pSolProc->szPlatform));
976	if (rc == -1)
977	{
978	CORELOGRELSYS((CORELOG_NAME "ProcReadMiscInfo: sysinfo failed. rc=%d errno=%d\n", rc, errno));
979	return VERR_GENERAL_FAILURE;
980	}
981	pSolProc->szPlatform[sizeof(pSolProc->szPlatform) - 1] = '\0';
982
983	rc = uname(&pSolProc->UtsName);
984	if (rc == -1)
985	{
986	CORELOGRELSYS((CORELOG_NAME "ProcReadMiscInfo: uname failed. rc=%d errno=%d\n", rc, errno));
987	return VERR_GENERAL_FAILURE;
988	}
989
990	/*
991	* See comment in GetOldProcessInfo() for why we need to verify the offset here.
992	* It's not perfect, but it should be fine unless they really mess up the structure
993	* layout in the future. See @bugref{8479}.
994	*/
995	size_t const offZoneId = RT_UOFFSETOF(psinfo_t, pr_zoneid);
996	if (pSolProc->cbProcInfo < offZoneId)
997	{
998	CORELOGRELSYS((CORELOG_NAME "ProcReadMiscInfo: psinfo size mismatch. cbProcInfo=%u expected >= %u\n",
999	pSolProc->cbProcInfo, offZoneId));
1000	return VERR_GENERAL_FAILURE;
1001	}
1002
1003	psinfo_t pProcInfo = (psinfo_t )pSolProc->pvProcInfo;
1004	rc = getzonenamebyid(pProcInfo->pr_zoneid, pSolProc->szZoneName, sizeof(pSolProc->szZoneName));
1005	if (rc < 0)
1006	{
1007	CORELOGRELSYS((CORELOG_NAME "ProcReadMiscInfo: getzonenamebyid failed. rc=%d errno=%d zoneid=%d\n", rc, errno,
1008	pProcInfo->pr_zoneid));
1009	return VERR_GENERAL_FAILURE;
1010	}
1011	pSolProc->szZoneName[sizeof(pSolProc->szZoneName) - 1] = '\0';
1012	rc = VINF_SUCCESS;
1013
1014	#else
1015	# error Port Me!
1016	#endif
1017	return rc;
1018	}
1019
1020
1021	/**
1022	* On Solaris use the old-style procfs interfaces but the core file still should have this
1023	* info. for backward and GDB compatibility, hence the need for this ugly function.
1024	*
1025	* @returns IPRT status code.
1026	*
1027	* @param pSolCore Pointer to the core object.
1028	* @param pInfo Pointer to the old prpsinfo_t structure to update.
1029	*/
1030	static int GetOldProcessInfo(PRTSOLCORE pSolCore, prpsinfo_t *pInfo)
1031	{
1032	AssertReturn(pSolCore, VERR_INVALID_PARAMETER);
1033	AssertReturn(pInfo, VERR_INVALID_PARAMETER);
1034
1035	/*
1036	* The psinfo_t and the size of /proc/<pid>/psinfo varies both within the same Solaris system
1037	* and across Solaris major versions. However, manual dumping of the structure and offsets shows
1038	* that they changed the size of lwpsinfo_t and the size of the lwpsinfo_t::pr_filler.
1039	*
1040	* The proc psinfo file will be what gets dumped ultimately in the core file but we still need
1041	* to read the fields to translate to the older process info structure here.
1042	*
1043	* See @bugref{8479}.
1044	*/
1045	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
1046
1047	size_t offLwp = RT_UOFFSETOF(psinfo_t, pr_lwp);
1048	/* last member we care about in lwpsinfo_t is pr_bindpset which is also present on ancient Solaris version we use for
1049	building the additions. Should be safe enough as we don't need/access members upto or beyond that point anyway. */
1050	size_t offLastOnProc = RT_UOFFSETOF(lwpsinfo_t, pr_bindpset);
1051	if (pSolProc->cbProcInfo >= offLwp + offLastOnProc)
1052	{
1053	psinfo_t pSrc = (psinfo_t )pSolProc->pvProcInfo;
1054	memset(pInfo, 0, sizeof(prpsinfo_t));
1055	pInfo->pr_state = pSrc->pr_lwp.pr_state;
1056	pInfo->pr_zomb = (pInfo->pr_state == SZOMB);
1057	RTStrCopy(pInfo->pr_clname, sizeof(pInfo->pr_clname), pSrc->pr_lwp.pr_clname);
1058	RTStrCopy(pInfo->pr_fname, sizeof(pInfo->pr_fname), pSrc->pr_fname);
1059	memcpy(&pInfo->pr_psargs, &pSrc->pr_psargs, sizeof(pInfo->pr_psargs));
1060	pInfo->pr_nice = pSrc->pr_lwp.pr_nice;
1061	pInfo->pr_flag = pSrc->pr_lwp.pr_flag;
1062	pInfo->pr_uid = pSrc->pr_uid;
1063	pInfo->pr_gid = pSrc->pr_gid;
1064	pInfo->pr_pid = pSrc->pr_pid;
1065	pInfo->pr_ppid = pSrc->pr_ppid;
1066	pInfo->pr_pgrp = pSrc->pr_pgid;
1067	pInfo->pr_sid = pSrc->pr_sid;
1068	pInfo->pr_addr = (caddr_t)pSrc->pr_addr;
1069	pInfo->pr_size = pSrc->pr_size;
1070	pInfo->pr_rssize = pSrc->pr_rssize;
1071	pInfo->pr_wchan = (caddr_t)pSrc->pr_lwp.pr_wchan;
1072	pInfo->pr_start = pSrc->pr_start;
1073	pInfo->pr_time = pSrc->pr_time;
1074	pInfo->pr_pri = pSrc->pr_lwp.pr_pri;
1075	pInfo->pr_oldpri = pSrc->pr_lwp.pr_oldpri;
1076	pInfo->pr_cpu = pSrc->pr_lwp.pr_cpu;
1077	pInfo->pr_ottydev = cmpdev(pSrc->pr_ttydev);
1078	pInfo->pr_lttydev = pSrc->pr_ttydev;
1079	pInfo->pr_syscall = pSrc->pr_lwp.pr_syscall;
1080	pInfo->pr_ctime = pSrc->pr_ctime;
1081	pInfo->pr_bysize = pSrc->pr_size * PAGESIZE;
1082	pInfo->pr_byrssize = pSrc->pr_rssize * PAGESIZE;
1083	pInfo->pr_argc = pSrc->pr_argc;
1084	pInfo->pr_argv = (char **)pSrc->pr_argv;
1085	pInfo->pr_envp = (char **)pSrc->pr_envp;
1086	pInfo->pr_wstat = pSrc->pr_wstat;
1087	pInfo->pr_pctcpu = pSrc->pr_pctcpu;
1088	pInfo->pr_pctmem = pSrc->pr_pctmem;
1089	pInfo->pr_euid = pSrc->pr_euid;
1090	pInfo->pr_egid = pSrc->pr_egid;
1091	pInfo->pr_aslwpid = 0;
1092	pInfo->pr_dmodel = pSrc->pr_dmodel;
1093
1094	return VINF_SUCCESS;
1095	}
1096
1097	CORELOGRELSYS((CORELOG_NAME "GetOldProcessInfo: Size/offset mismatch. offLwp=%u offLastOnProc=%u cbProcInfo=%u\n",
1098	offLwp, offLastOnProc, pSolProc->cbProcInfo));
1099	return VERR_MISMATCH;
1100	}
1101
1102
1103	/**
1104	* On Solaris use the old-style procfs interfaces but the core file still should have this
1105	* info. for backward and GDB compatibility, hence the need for this ugly function.
1106	*
1107	* @param pSolCore Pointer to the core object.
1108	* @param pInfo Pointer to the thread info.
1109	* @param pStatus Pointer to the thread status.
1110	* @param pDst Pointer to the old-style status structure to update.
1111	*
1112	*/
1113	static void GetOldProcessStatus(PRTSOLCORE pSolCore, lwpsinfo_t pInfo, lwpstatus_t pStatus, prstatus_t *pDst)
1114	{
1115	AssertReturnVoid(pSolCore);
1116	AssertReturnVoid(pInfo);
1117	AssertReturnVoid(pStatus);
1118	AssertReturnVoid(pDst);
1119
1120	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
1121	memset(pDst, 0, sizeof(prstatus_t));
1122	if (pStatus->pr_flags & PR_STOPPED)
1123	pDst->pr_flags = 0x0001;
1124	if (pStatus->pr_flags & PR_ISTOP)
1125	pDst->pr_flags = 0x0002;
1126	if (pStatus->pr_flags & PR_DSTOP)
1127	pDst->pr_flags = 0x0004;
1128	if (pStatus->pr_flags & PR_ASLEEP)
1129	pDst->pr_flags = 0x0008;
1130	if (pStatus->pr_flags & PR_FORK)
1131	pDst->pr_flags = 0x0010;
1132	if (pStatus->pr_flags & PR_RLC)
1133	pDst->pr_flags = 0x0020;
1134	/* PR_PTRACE is never set */
1135	if (pStatus->pr_flags & PR_PCINVAL)
1136	pDst->pr_flags = 0x0080;
1137	if (pStatus->pr_flags & PR_ISSYS)
1138	pDst->pr_flags = 0x0100;
1139	if (pStatus->pr_flags & PR_STEP)
1140	pDst->pr_flags = 0x0200;
1141	if (pStatus->pr_flags & PR_KLC)
1142	pDst->pr_flags = 0x0400;
1143	if (pStatus->pr_flags & PR_ASYNC)
1144	pDst->pr_flags = 0x0800;
1145	if (pStatus->pr_flags & PR_PTRACE)
1146	pDst->pr_flags = 0x1000;
1147	if (pStatus->pr_flags & PR_MSACCT)
1148	pDst->pr_flags = 0x2000;
1149	if (pStatus->pr_flags & PR_BPTADJ)
1150	pDst->pr_flags = 0x4000;
1151	if (pStatus->pr_flags & PR_ASLWP)
1152	pDst->pr_flags = 0x8000;
1153
1154	pDst->pr_who = pStatus->pr_lwpid;
1155	pDst->pr_why = pStatus->pr_why;
1156	pDst->pr_what = pStatus->pr_what;
1157	pDst->pr_info = pStatus->pr_info;
1158	pDst->pr_cursig = pStatus->pr_cursig;
1159	pDst->pr_sighold = pStatus->pr_lwphold;
1160	pDst->pr_altstack = pStatus->pr_altstack;
1161	pDst->pr_action = pStatus->pr_action;
1162	pDst->pr_syscall = pStatus->pr_syscall;
1163	pDst->pr_nsysarg = pStatus->pr_nsysarg;
1164	pDst->pr_lwppend = pStatus->pr_lwppend;
1165	pDst->pr_oldcontext = (ucontext_t *)pStatus->pr_oldcontext;
1166	memcpy(pDst->pr_reg, pStatus->pr_reg, sizeof(pDst->pr_reg));
1167	memcpy(pDst->pr_sysarg, pStatus->pr_sysarg, sizeof(pDst->pr_sysarg));
1168	RTStrCopy(pDst->pr_clname, sizeof(pDst->pr_clname), pStatus->pr_clname);
1169
1170	pDst->pr_nlwp = pSolProc->ProcStatus.pr_nlwp;
1171	pDst->pr_sigpend = pSolProc->ProcStatus.pr_sigpend;
1172	pDst->pr_pid = pSolProc->ProcStatus.pr_pid;
1173	pDst->pr_ppid = pSolProc->ProcStatus.pr_ppid;
1174	pDst->pr_pgrp = pSolProc->ProcStatus.pr_pgid;
1175	pDst->pr_sid = pSolProc->ProcStatus.pr_sid;
1176	pDst->pr_utime = pSolProc->ProcStatus.pr_utime;
1177	pDst->pr_stime = pSolProc->ProcStatus.pr_stime;
1178	pDst->pr_cutime = pSolProc->ProcStatus.pr_cutime;
1179	pDst->pr_cstime = pSolProc->ProcStatus.pr_cstime;
1180	pDst->pr_brkbase = (caddr_t)pSolProc->ProcStatus.pr_brkbase;
1181	pDst->pr_brksize = pSolProc->ProcStatus.pr_brksize;
1182	pDst->pr_stkbase = (caddr_t)pSolProc->ProcStatus.pr_stkbase;
1183	pDst->pr_stksize = pSolProc->ProcStatus.pr_stksize;
1184
1185	pDst->pr_processor = (short)pInfo->pr_onpro;
1186	pDst->pr_bind = (short)pInfo->pr_bindpro;
1187	pDst->pr_instr = pStatus->pr_instr;
1188	}
1189
1190
1191	/**
1192	* Callback for rtCoreDumperForEachThread to suspend a thread.
1193	*
1194	* @param pSolCore Pointer to the core object.
1195	* @param pvThreadInfo Opaque pointer to thread information.
1196	*
1197	* @return IPRT status code.
1198	*/
1199	static int suspendThread(PRTSOLCORE pSolCore, void *pvThreadInfo)
1200	{
1201	AssertPtrReturn(pvThreadInfo, VERR_INVALID_POINTER);
1202	NOREF(pSolCore);
1203
1204	lwpsinfo_t pThreadInfo = (lwpsinfo_t )pvThreadInfo;
1205	CORELOG((CORELOG_NAME ":suspendThread %d\n", (lwpid_t)pThreadInfo->pr_lwpid));
1206	if ((lwpid_t)pThreadInfo->pr_lwpid != pSolCore->SolProc.hCurThread)
1207	_lwp_suspend(pThreadInfo->pr_lwpid);
1208	return VINF_SUCCESS;
1209	}
1210
1211
1212	/**
1213	* Callback for rtCoreDumperForEachThread to resume a thread.
1214	*
1215	* @param pSolCore Pointer to the core object.
1216	* @param pvThreadInfo Opaque pointer to thread information.
1217	*
1218	* @return IPRT status code.
1219	*/
1220	static int resumeThread(PRTSOLCORE pSolCore, void *pvThreadInfo)
1221	{
1222	AssertPtrReturn(pvThreadInfo, VERR_INVALID_POINTER);
1223	NOREF(pSolCore);
1224
1225	lwpsinfo_t pThreadInfo = (lwpsinfo_t )pvThreadInfo;
1226	CORELOG((CORELOG_NAME ":resumeThread %d\n", (lwpid_t)pThreadInfo->pr_lwpid));
1227	if ((lwpid_t)pThreadInfo->pr_lwpid != (lwpid_t)pSolCore->SolProc.hCurThread)
1228	_lwp_continue(pThreadInfo->pr_lwpid);
1229	return VINF_SUCCESS;
1230	}
1231
1232
1233	/**
1234	* Calls a thread worker function for all threads in the process as described by /proc
1235	*
1236	* @param pSolCore Pointer to the core object.
1237	* @param pcThreads Number of threads read.
1238	* @param pfnWorker Callback function for each thread.
1239	*
1240	* @return IPRT status code.
1241	*/
1242	static int rtCoreDumperForEachThread(PRTSOLCORE pSolCore, uint64_t *pcThreads, PFNRTSOLCORETHREADWORKER pfnWorker)
1243	{
1244	AssertPtrReturn(pSolCore, VERR_INVALID_POINTER);
1245
1246	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
1247
1248	/*
1249	* Read the information for threads.
1250	* Format: prheader_t + array of lwpsinfo_t's.
1251	*/
1252	char szLpsInfoPath[PATH_MAX];
1253	RTStrPrintf(szLpsInfoPath, sizeof(szLpsInfoPath), "/proc/%d/lpsinfo", (int)pSolProc->Process);
1254
1255	int rc = VINF_SUCCESS;
1256	int fd = open(szLpsInfoPath, O_RDONLY);
1257	if (fd >= 0)
1258	{
1259	size_t cbInfoHdrAndData = GetFileSizeByFd(fd);
1260	void *pvInfoHdr = mmap(NULL, cbInfoHdrAndData, PROT_READ \| PROT_WRITE, MAP_PRIVATE \| MAP_ANON,
1261	-1 /* fd /, 0 / offset */);
1262	if (pvInfoHdr != MAP_FAILED)
1263	{
1264	rc = ReadFileNoIntr(fd, pvInfoHdr, cbInfoHdrAndData);
1265	if (RT_SUCCESS(rc))
1266	{
1267	prheader_t pHeader = (prheader_t )pvInfoHdr;
1268	lwpsinfo_t pThreadInfo = (lwpsinfo_t )((uintptr_t)pvInfoHdr + sizeof(prheader_t));
1269	for (long i = 0; i < pHeader->pr_nent; i++)
1270	{
1271	pfnWorker(pSolCore, pThreadInfo);
1272	pThreadInfo = (lwpsinfo_t *)((uintptr_t)pThreadInfo + pHeader->pr_entsize);
1273	}
1274	if (pcThreads)
1275	*pcThreads = pHeader->pr_nent;
1276	}
1277
1278	munmap(pvInfoHdr, cbInfoHdrAndData);
1279	}
1280	else
1281	rc = VERR_NO_MEMORY;
1282	close(fd);
1283	}
1284	else
1285	rc = RTErrConvertFromErrno(rc);
1286
1287	return rc;
1288	}
1289
1290
1291	/**
1292	* Resume all threads of this process.
1293	*
1294	* @param pSolCore Pointer to the core object.
1295	*
1296	* @return IPRT status code..
1297	*/
1298	static int rtCoreDumperResumeThreads(PRTSOLCORE pSolCore)
1299	{
1300	AssertReturn(pSolCore, VERR_INVALID_POINTER);
1301
1302	uint64_t cThreads;
1303	return rtCoreDumperForEachThread(pSolCore, &cThreads, resumeThread);
1304	}
1305
1306
1307	/**
1308	* Stop all running threads of this process except the current one.
1309	*
1310	* @param pSolCore Pointer to the core object.
1311	*
1312	* @return IPRT status code.
1313	*/
1314	static int rtCoreDumperSuspendThreads(PRTSOLCORE pSolCore)
1315	{
1316	AssertPtrReturn(pSolCore, VERR_INVALID_POINTER);
1317
1318	/*
1319	* This function tries to ensures while we suspend threads, no newly spawned threads
1320	* or a combination of spawning and terminating threads can cause any threads to be left running.
1321	* The assumption here is that threads can only increase not decrease across iterations.
1322	*/
1323	uint16_t cTries = 0;
1324	uint64_t aThreads[4];
1325	RT_ZERO(aThreads);
1326	int rc = VERR_GENERAL_FAILURE;
1327	void *pv = NULL;
1328	size_t cb = 0;
1329	for (cTries = 0; cTries < RT_ELEMENTS(aThreads); cTries++)
1330	{
1331	rc = rtCoreDumperForEachThread(pSolCore, &aThreads[cTries], suspendThread);
1332	if (RT_FAILURE(rc))
1333	break;
1334	}
1335	if ( RT_SUCCESS(rc)
1336	&& aThreads[cTries - 1] != aThreads[cTries - 2])
1337	{
1338	CORELOGRELSYS((CORELOG_NAME "rtCoreDumperSuspendThreads: possible thread bomb!?\n"));
1339	rc = VERR_TIMEOUT;
1340	}
1341	return rc;
1342	}
1343
1344
1345	/**
1346	* Returns size of an ELF NOTE header given the size of data the NOTE section will contain.
1347	*
1348	* @param cb Size of the data.
1349	*
1350	* @return Size of data actually used for NOTE header and section.
1351	*/
1352	static inline size_t ElfNoteHeaderSize(size_t cb)
1353	{
1354	return sizeof(ELFNOTEHDR) + RT_ALIGN_Z(cb, 4);
1355	}
1356
1357
1358	/**
1359	* Write an ELF NOTE header into the core file.
1360	*
1361	* @param pSolCore Pointer to the core object.
1362	* @param Type Type of this NOTE section.
1363	* @param pcv Opaque pointer to the data, if NULL only computes size.
1364	* @param cb Size of the data.
1365	*
1366	* @return IPRT status code.
1367	*/
1368	static int ElfWriteNoteHeader(PRTSOLCORE pSolCore, uint_t Type, const void *pcv, size_t cb)
1369	{
1370	AssertReturn(pSolCore, VERR_INVALID_POINTER);
1371	AssertReturn(pcv, VERR_INVALID_POINTER);
1372	AssertReturn(cb > 0, VERR_NO_DATA);
1373	AssertReturn(pSolCore->pfnWriter, VERR_WRITE_ERROR);
1374	AssertReturn(pSolCore->fdCoreFile >= 0, VERR_INVALID_HANDLE);
1375
1376	int rc = VERR_GENERAL_FAILURE;
1377	#ifdef RT_OS_SOLARIS
1378	ELFNOTEHDR ElfNoteHdr;
1379	RT_ZERO(ElfNoteHdr);
1380	ElfNoteHdr.achName[0] = 'C';
1381	ElfNoteHdr.achName[1] = 'O';
1382	ElfNoteHdr.achName[2] = 'R';
1383	ElfNoteHdr.achName[3] = 'E';
1384
1385	/*
1386	* This is a known violation of the 64-bit ELF spec., see xTracker @bugref{5211}
1387	* for the historic reasons as to the padding and 'namesz' anomalies.
1388	*/
1389	static const char s_achPad[3] = { 0, 0, 0 };
1390	size_t cbAlign = RT_ALIGN_Z(cb, 4);
1391	ElfNoteHdr.Hdr.n_namesz = 5;
1392	ElfNoteHdr.Hdr.n_type = Type;
1393	ElfNoteHdr.Hdr.n_descsz = cbAlign;
1394
1395	/*
1396	* Write note header and description.
1397	*/
1398	rc = pSolCore->pfnWriter(pSolCore->fdCoreFile, &ElfNoteHdr, sizeof(ElfNoteHdr));
1399	if (RT_SUCCESS(rc))
1400	{
1401	rc = pSolCore->pfnWriter(pSolCore->fdCoreFile, pcv, cb);
1402	if (RT_SUCCESS(rc))
1403	{
1404	if (cbAlign > cb)
1405	rc = pSolCore->pfnWriter(pSolCore->fdCoreFile, s_achPad, cbAlign - cb);
1406	}
1407	}
1408
1409	if (RT_FAILURE(rc))
1410	CORELOGRELSYS((CORELOG_NAME "ElfWriteNote: pfnWriter failed. Type=%d rc=%Rrc\n", Type, rc));
1411	#else
1412	#error Port Me!
1413	#endif
1414	return rc;
1415	}
1416
1417
1418	/**
1419	* Computes the size of NOTE section for the given core type.
1420	* Solaris has two types of program header information (new and old).
1421	*
1422	* @param pSolCore Pointer to the core object.
1423	* @param enmType Type of core file information required.
1424	*
1425	* @return Size of NOTE section.
1426	*/
1427	static size_t ElfNoteSectionSize(PRTSOLCORE pSolCore, RTSOLCORETYPE enmType)
1428	{
1429	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
1430	size_t cb = 0;
1431	switch (enmType)
1432	{
1433	case enmOldEra:
1434	{
1435	cb += ElfNoteHeaderSize(sizeof(prpsinfo_t));
1436	cb += ElfNoteHeaderSize(pSolProc->cAuxVecs * sizeof(auxv_t));
1437	cb += ElfNoteHeaderSize(strlen(pSolProc->szPlatform));
1438
1439	PRTSOLCORETHREADINFO pThreadInfo = pSolProc->pThreadInfoHead;
1440	while (pThreadInfo)
1441	{
1442	if (pThreadInfo->pStatus)
1443	{
1444	cb += ElfNoteHeaderSize(sizeof(prstatus_t));
1445	cb += ElfNoteHeaderSize(sizeof(prfpregset_t));
1446	}
1447	pThreadInfo = pThreadInfo->pNext;
1448	}
1449
1450	break;
1451	}
1452
1453	case enmNewEra:
1454	{
1455	cb += ElfNoteHeaderSize(sizeof(psinfo_t));
1456	cb += ElfNoteHeaderSize(sizeof(pstatus_t));
1457	cb += ElfNoteHeaderSize(pSolProc->cAuxVecs * sizeof(auxv_t));
1458	cb += ElfNoteHeaderSize(strlen(pSolProc->szPlatform) + 1);
1459	cb += ElfNoteHeaderSize(sizeof(struct utsname));
1460	cb += ElfNoteHeaderSize(sizeof(core_content_t));
1461	cb += ElfNoteHeaderSize(pSolProc->cbCred);
1462
1463	if (pSolProc->pPriv)
1464	cb += ElfNoteHeaderSize(PRIV_PRPRIV_SIZE(pSolProc->pPriv)); /* Ought to be same as cbPriv!? */
1465
1466	if (pSolProc->pcPrivImpl)
1467	cb += ElfNoteHeaderSize(PRIV_IMPL_INFO_SIZE(pSolProc->pcPrivImpl));
1468
1469	cb += ElfNoteHeaderSize(strlen(pSolProc->szZoneName) + 1);
1470	if (pSolProc->cbLdt > 0)
1471	cb += ElfNoteHeaderSize(pSolProc->cbLdt);
1472
1473	PRTSOLCORETHREADINFO pThreadInfo = pSolProc->pThreadInfoHead;
1474	while (pThreadInfo)
1475	{
1476	cb += ElfNoteHeaderSize(sizeof(lwpsinfo_t));
1477	if (pThreadInfo->pStatus)
1478	cb += ElfNoteHeaderSize(sizeof(lwpstatus_t));
1479
1480	pThreadInfo = pThreadInfo->pNext;
1481	}
1482
1483	break;
1484	}
1485
1486	default:
1487	{
1488	CORELOGRELSYS((CORELOG_NAME "ElfNoteSectionSize: Unknown segment era %d\n", enmType));
1489	break;
1490	}
1491	}
1492
1493	return cb;
1494	}
1495
1496
1497	/**
1498	* Write the note section for the given era into the core file.
1499	* Solaris has two types of program header information (new and old).
1500	*
1501	* @param pSolCore Pointer to the core object.
1502	* @param enmType Type of core file information required.
1503	*
1504	* @return IPRT status code.
1505	*/
1506	static int ElfWriteNoteSection(PRTSOLCORE pSolCore, RTSOLCORETYPE enmType)
1507	{
1508	AssertReturn(pSolCore, VERR_INVALID_POINTER);
1509
1510	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
1511	int rc = VERR_GENERAL_FAILURE;
1512
1513	#ifdef RT_OS_SOLARIS
1514	typedef int (PFNELFWRITENOTEHDR)(PRTSOLCORE pSolCore, uint_t, const void pcv, size_t cb);
1515	typedef struct
1516	{
1517	const char *pszType;
1518	uint_t Type;
1519	const void *pcv;
1520	size_t cb;
1521	} ELFWRITENOTE;
1522
1523	switch (enmType)
1524	{
1525	case enmOldEra:
1526	{
1527	ELFWRITENOTE aElfNotes[] =
1528	{
1529	{ "NT_PRPSINFO", NT_PRPSINFO, &pSolProc->ProcInfoOld, sizeof(prpsinfo_t) },
1530	{ "NT_AUXV", NT_AUXV, pSolProc->pAuxVecs, pSolProc->cAuxVecs * sizeof(auxv_t) },
1531	{ "NT_PLATFORM", NT_PLATFORM, pSolProc->szPlatform, strlen(pSolProc->szPlatform) + 1 }
1532	};
1533
1534	for (unsigned i = 0; i < RT_ELEMENTS(aElfNotes); i++)
1535	{
1536	rc = ElfWriteNoteHeader(pSolCore, aElfNotes[i].Type, aElfNotes[i].pcv, aElfNotes[i].cb);
1537	if (RT_FAILURE(rc))
1538	{
1539	CORELOGRELSYS((CORELOG_NAME "ElfWriteNoteSection: ElfWriteNoteHeader failed for %s. rc=%Rrc\n",
1540	aElfNotes[i].pszType, rc));
1541	break;
1542	}
1543	}
1544
1545	/*
1546	* Write old-style thread info., they contain nothing about zombies,
1547	* so we just skip if there is no status information for them.
1548	*/
1549	PRTSOLCORETHREADINFO pThreadInfo = pSolProc->pThreadInfoHead;
1550	for (; pThreadInfo; pThreadInfo = pThreadInfo->pNext)
1551	{
1552	if (!pThreadInfo->pStatus)
1553	continue;
1554
1555	prstatus_t OldProcessStatus;
1556	GetOldProcessStatus(pSolCore, &pThreadInfo->Info, pThreadInfo->pStatus, &OldProcessStatus);
1557	rc = ElfWriteNoteHeader(pSolCore, NT_PRSTATUS, &OldProcessStatus, sizeof(prstatus_t));
1558	if (RT_SUCCESS(rc))
1559	{
1560	rc = ElfWriteNoteHeader(pSolCore, NT_PRFPREG, &pThreadInfo->pStatus->pr_fpreg, sizeof(prfpregset_t));
1561	if (RT_FAILURE(rc))
1562	{
1563	CORELOGRELSYS((CORELOG_NAME "ElfWriteSegment: ElfWriteNote failed for NT_PRFPREF. rc=%Rrc\n", rc));
1564	break;
1565	}
1566	}
1567	else
1568	{
1569	CORELOGRELSYS((CORELOG_NAME "ElfWriteSegment: ElfWriteNote failed for NT_PRSTATUS. rc=%Rrc\n", rc));
1570	break;
1571	}
1572	}
1573	break;
1574	}
1575
1576	case enmNewEra:
1577	{
1578	ELFWRITENOTE aElfNotes[] =
1579	{
1580	{ "NT_PSINFO", NT_PSINFO, pSolProc->pvProcInfo, pSolProc->cbProcInfo },
1581	{ "NT_PSTATUS", NT_PSTATUS, &pSolProc->ProcStatus, sizeof(pstatus_t) },
1582	{ "NT_AUXV", NT_AUXV, pSolProc->pAuxVecs, pSolProc->cAuxVecs * sizeof(auxv_t) },
1583	{ "NT_PLATFORM", NT_PLATFORM, pSolProc->szPlatform, strlen(pSolProc->szPlatform) + 1 },
1584	{ "NT_UTSNAME", NT_UTSNAME, &pSolProc->UtsName, sizeof(struct utsname) },
1585	{ "NT_CONTENT", NT_CONTENT, &pSolProc->CoreContent, sizeof(core_content_t) },
1586	{ "NT_PRCRED", NT_PRCRED, pSolProc->pvCred, pSolProc->cbCred },
1587	{ "NT_PRPRIV", NT_PRPRIV, pSolProc->pPriv, PRIV_PRPRIV_SIZE(pSolProc->pPriv) },
1588	{ "NT_PRPRIVINFO", NT_PRPRIVINFO, pSolProc->pcPrivImpl, PRIV_IMPL_INFO_SIZE(pSolProc->pcPrivImpl) },
1589	{ "NT_ZONENAME", NT_ZONENAME, pSolProc->szZoneName, strlen(pSolProc->szZoneName) + 1 }
1590	};
1591
1592	for (unsigned i = 0; i < RT_ELEMENTS(aElfNotes); i++)
1593	{
1594	rc = ElfWriteNoteHeader(pSolCore, aElfNotes[i].Type, aElfNotes[i].pcv, aElfNotes[i].cb);
1595	if (RT_FAILURE(rc))
1596	{
1597	CORELOGRELSYS((CORELOG_NAME "ElfWriteNoteSection: ElfWriteNoteHeader failed for %s. rc=%Rrc\n",
1598	aElfNotes[i].pszType, rc));
1599	break;
1600	}
1601	}
1602
1603	/*
1604	* Write new-style thread info., missing lwpstatus_t indicates it's a zombie thread
1605	* we only dump the lwpsinfo_t in that case.
1606	*/
1607	PRTSOLCORETHREADINFO pThreadInfo = pSolProc->pThreadInfoHead;
1608	for (; pThreadInfo; pThreadInfo = pThreadInfo->pNext)
1609	{
1610	rc = ElfWriteNoteHeader(pSolCore, NT_LWPSINFO, &pThreadInfo->Info, sizeof(lwpsinfo_t));
1611	if (RT_FAILURE(rc))
1612	{
1613	CORELOGRELSYS((CORELOG_NAME "ElfWriteNoteSection: ElfWriteNoteHeader for NT_LWPSINFO failed. rc=%Rrc\n", rc));
1614	break;
1615	}
1616
1617	if (pThreadInfo->pStatus)
1618	{
1619	rc = ElfWriteNoteHeader(pSolCore, NT_LWPSTATUS, pThreadInfo->pStatus, sizeof(lwpstatus_t));
1620	if (RT_FAILURE(rc))
1621	{
1622	CORELOGRELSYS((CORELOG_NAME "ElfWriteNoteSection: ElfWriteNoteHeader for NT_LWPSTATUS failed. rc=%Rrc\n",
1623	rc));
1624	break;
1625	}
1626	}
1627	}
1628	break;
1629	}
1630
1631	default:
1632	{
1633	CORELOGRELSYS((CORELOG_NAME "ElfWriteNoteSection: Invalid type %d\n", enmType));
1634	rc = VERR_GENERAL_FAILURE;
1635	break;
1636	}
1637	}
1638	#else
1639	# error Port Me!
1640	#endif
1641	return rc;
1642	}
1643
1644
1645	/**
1646	* Write mappings into the core file.
1647	*
1648	* @param pSolCore Pointer to the core object.
1649	*
1650	* @return IPRT status code.
1651	*/
1652	static int ElfWriteMappings(PRTSOLCORE pSolCore)
1653	{
1654	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
1655
1656	int rc = VERR_GENERAL_FAILURE;
1657	PRTSOLCOREMAPINFO pMapInfo = pSolProc->pMapInfoHead;
1658	while (pMapInfo)
1659	{
1660	if (!pMapInfo->fError)
1661	{
1662	uint64_t k = 0;
1663	char achBuf[PAGE_SIZE];
1664	while (k < pMapInfo->pMap.pr_size)
1665	{
1666	size_t cb = RT_MIN(sizeof(achBuf), pMapInfo->pMap.pr_size - k);
1667	int rc2 = ProcReadAddrSpace(pSolProc, pMapInfo->pMap.pr_vaddr + k, &achBuf, cb);
1668	if (RT_FAILURE(rc2))
1669	{
1670	CORELOGRELSYS((CORELOG_NAME "ElfWriteMappings: Failed to read mapping, can't recover. Bye. rc=%Rrc\n", rc));
1671	return VERR_INVALID_STATE;
1672	}
1673
1674	rc = pSolCore->pfnWriter(pSolCore->fdCoreFile, achBuf, sizeof(achBuf));
1675	if (RT_FAILURE(rc))
1676	{
1677	CORELOGRELSYS((CORELOG_NAME "ElfWriteMappings: pfnWriter failed. rc=%Rrc\n", rc));
1678	return rc;
1679	}
1680	k += cb;
1681	}
1682	}
1683	else
1684	{
1685	char achBuf[RT_ALIGN_Z(sizeof(int), 8)];
1686	RT_ZERO(achBuf);
1687	memcpy(achBuf, &pMapInfo->fError, sizeof(pMapInfo->fError));
1688	if (sizeof(achBuf) != pMapInfo->pMap.pr_size)
1689	CORELOGRELSYS((CORELOG_NAME "ElfWriteMappings: Huh!? something is wrong!\n"));
1690	rc = pSolCore->pfnWriter(pSolCore->fdCoreFile, &achBuf, sizeof(achBuf));
1691	if (RT_FAILURE(rc))
1692	{
1693	CORELOGRELSYS((CORELOG_NAME "ElfWriteMappings: pfnWriter(2) failed. rc=%Rrc\n", rc));
1694	return rc;
1695	}
1696	}
1697
1698	pMapInfo = pMapInfo->pNext;
1699	}
1700
1701	return VINF_SUCCESS;
1702	}
1703
1704
1705	/**
1706	* Write program headers for all mappings into the core file.
1707	*
1708	* @param pSolCore Pointer to the core object.
1709	*
1710	* @return IPRT status code.
1711	*/
1712	static int ElfWriteMappingHeaders(PRTSOLCORE pSolCore)
1713	{
1714	AssertReturn(pSolCore, VERR_INVALID_POINTER);
1715
1716	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
1717	Elf_Phdr ProgHdr;
1718	RT_ZERO(ProgHdr);
1719	ProgHdr.p_type = PT_LOAD;
1720
1721	int rc = VERR_GENERAL_FAILURE;
1722	PRTSOLCOREMAPINFO pMapInfo = pSolProc->pMapInfoHead;
1723	while (pMapInfo)
1724	{
1725	ProgHdr.p_vaddr = pMapInfo->pMap.pr_vaddr; /* Virtual address of this mapping in the process address space */
1726	ProgHdr.p_offset = pSolCore->offWrite; /* Where this mapping is located in the core file */
1727	ProgHdr.p_memsz = pMapInfo->pMap.pr_size; /* Size of the memory image of the mapping */
1728	ProgHdr.p_filesz = pMapInfo->pMap.pr_size; /* Size of the file image of the mapping */
1729
1730	ProgHdr.p_flags = 0; /* Reset fields in a loop when needed! */
1731	if (pMapInfo->pMap.pr_mflags & MA_READ)
1732	ProgHdr.p_flags \|= PF_R;
1733	if (pMapInfo->pMap.pr_mflags & MA_WRITE)
1734	ProgHdr.p_flags \|= PF_W;
1735	if (pMapInfo->pMap.pr_mflags & MA_EXEC)
1736	ProgHdr.p_flags \|= PF_X;
1737
1738	if (pMapInfo->fError)
1739	ProgHdr.p_flags \|= PF_SUNW_FAILURE;
1740
1741	rc = pSolCore->pfnWriter(pSolCore->fdCoreFile, &ProgHdr, sizeof(ProgHdr));
1742	if (RT_FAILURE(rc))
1743	{
1744	CORELOGRELSYS((CORELOG_NAME "ElfWriteMappingHeaders: pfnWriter failed. rc=%Rrc\n", rc));
1745	return rc;
1746	}
1747
1748	pSolCore->offWrite += ProgHdr.p_filesz;
1749	pMapInfo = pMapInfo->pNext;
1750	}
1751	return rc;
1752	}
1753
1754	/**
1755	* Inner worker for rtCoreDumperWriteCore, which purpose is to
1756	* squash cleanup gotos.
1757	*/
1758	static int rtCoreDumperWriteCoreDoIt(PRTSOLCORE pSolCore, PFNRTCOREWRITER pfnWriter,
1759	PRTSOLCOREPROCESS pSolProc)
1760	{
1761	pSolCore->offWrite = 0;
1762	uint32_t cProgHdrs = pSolProc->cMappings + 2; /* two PT_NOTE program headers (old, new style) */
1763
1764	/*
1765	* Write the ELF header.
1766	*/
1767	Elf_Ehdr ElfHdr;
1768	RT_ZERO(ElfHdr);
1769	ElfHdr.e_ident[EI_MAG0] = ELFMAG0;
1770	ElfHdr.e_ident[EI_MAG1] = ELFMAG1;
1771	ElfHdr.e_ident[EI_MAG2] = ELFMAG2;
1772	ElfHdr.e_ident[EI_MAG3] = ELFMAG3;
1773	ElfHdr.e_ident[EI_DATA] = IsBigEndian() ? ELFDATA2MSB : ELFDATA2LSB;
1774	ElfHdr.e_type = ET_CORE;
1775	ElfHdr.e_version = EV_CURRENT;
1776	#ifdef RT_ARCH_AMD64
1777	ElfHdr.e_machine = EM_AMD64;
1778	ElfHdr.e_ident[EI_CLASS] = ELFCLASS64;
1779	#else
1780	ElfHdr.e_machine = EM_386;
1781	ElfHdr.e_ident[EI_CLASS] = ELFCLASS32;
1782	#endif
1783	if (cProgHdrs >= PN_XNUM)
1784	ElfHdr.e_phnum = PN_XNUM;
1785	else
1786	ElfHdr.e_phnum = cProgHdrs;
1787	ElfHdr.e_ehsize = sizeof(ElfHdr);
1788	ElfHdr.e_phoff = sizeof(ElfHdr);
1789	ElfHdr.e_phentsize = sizeof(Elf_Phdr);
1790	ElfHdr.e_shentsize = sizeof(Elf_Shdr);
1791	int rc = pSolCore->pfnWriter(pSolCore->fdCoreFile, &ElfHdr, sizeof(ElfHdr));
1792	if (RT_FAILURE(rc))
1793	{
1794	CORELOGRELSYS((CORELOG_NAME "WriteCore: pfnWriter failed writing ELF header. rc=%Rrc\n", rc));
1795	return rc;
1796	}
1797
1798	/*
1799	* Setup program header.
1800	*/
1801	Elf_Phdr ProgHdr;
1802	RT_ZERO(ProgHdr);
1803	ProgHdr.p_type = PT_NOTE;
1804	ProgHdr.p_flags = PF_R;
1805
1806	/*
1807	* Write old-style NOTE program header.
1808	*/
1809	pSolCore->offWrite += sizeof(ElfHdr) + cProgHdrs * sizeof(ProgHdr);
1810	ProgHdr.p_offset = pSolCore->offWrite;
1811	ProgHdr.p_filesz = ElfNoteSectionSize(pSolCore, enmOldEra);
1812	rc = pSolCore->pfnWriter(pSolCore->fdCoreFile, &ProgHdr, sizeof(ProgHdr));
1813	if (RT_FAILURE(rc))
1814	{
1815	CORELOGRELSYS((CORELOG_NAME "WriteCore: pfnWriter failed writing old-style ELF program Header. rc=%Rrc\n", rc));
1816	return rc;
1817	}
1818
1819	/*
1820	* Write new-style NOTE program header.
1821	*/
1822	pSolCore->offWrite += ProgHdr.p_filesz;
1823	ProgHdr.p_offset = pSolCore->offWrite;
1824	ProgHdr.p_filesz = ElfNoteSectionSize(pSolCore, enmNewEra);
1825	rc = pSolCore->pfnWriter(pSolCore->fdCoreFile, &ProgHdr, sizeof(ProgHdr));
1826	if (RT_FAILURE(rc))
1827	{
1828	CORELOGRELSYS((CORELOG_NAME "WriteCore: pfnWriter failed writing new-style ELF program header. rc=%Rrc\n", rc));
1829	return rc;
1830	}
1831
1832	/*
1833	* Write program headers per mapping.
1834	*/
1835	pSolCore->offWrite += ProgHdr.p_filesz;
1836	rc = ElfWriteMappingHeaders(pSolCore);
1837	if (RT_FAILURE(rc))
1838	{
1839	CORELOGRELSYS((CORELOG_NAME "Write: ElfWriteMappings failed. rc=%Rrc\n", rc));
1840	return rc;
1841	}
1842
1843	/*
1844	* Write old-style note section.
1845	*/
1846	rc = ElfWriteNoteSection(pSolCore, enmOldEra);
1847	if (RT_FAILURE(rc))
1848	{
1849	CORELOGRELSYS((CORELOG_NAME "WriteCore: ElfWriteNoteSection old-style failed. rc=%Rrc\n", rc));
1850	return rc;
1851	}
1852
1853	/*
1854	* Write new-style section.
1855	*/
1856	rc = ElfWriteNoteSection(pSolCore, enmNewEra);
1857	if (RT_FAILURE(rc))
1858	{
1859	CORELOGRELSYS((CORELOG_NAME "WriteCore: ElfWriteNoteSection new-style failed. rc=%Rrc\n", rc));
1860	return rc;
1861	}
1862
1863	/*
1864	* Write all mappings.
1865	*/
1866	rc = ElfWriteMappings(pSolCore);
1867	if (RT_FAILURE(rc))
1868	{
1869	CORELOGRELSYS((CORELOG_NAME "WriteCore: ElfWriteMappings failed. rc=%Rrc\n", rc));
1870	return rc;
1871	}
1872
1873	return rc;
1874	}
1875
1876
1877	/**
1878	* Write a prepared core file using a user-passed in writer function, requires all threads
1879	* to be in suspended state (i.e. called after CreateCore).
1880	*
1881	* @return IPRT status code.
1882	* @param pSolCore Pointer to the core object.
1883	* @param pfnWriter Pointer to the writer function to override default writer (NULL uses default).
1884	*
1885	* @remarks Resumes all suspended threads, unless it's an invalid core. This
1886	* function must be called only -after- rtCoreDumperCreateCore().
1887	*/
1888	static int rtCoreDumperWriteCore(PRTSOLCORE pSolCore, PFNRTCOREWRITER pfnWriter)
1889	{
1890	AssertReturn(pSolCore, VERR_INVALID_POINTER);
1891
1892	if (!pSolCore->fIsValid)
1893	return VERR_INVALID_STATE;
1894
1895	if (pfnWriter)
1896	pSolCore->pfnWriter = pfnWriter;
1897
1898	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
1899	char szPath[PATH_MAX];
1900	int rc;
1901
1902	/*
1903	* Open the process address space file.
1904	*/
1905	RTStrPrintf(szPath, sizeof(szPath), "/proc/%d/as", (int)pSolProc->Process);
1906	int fd = open(szPath, O_RDONLY);
1907	if (fd >= 0)
1908	{
1909	pSolProc->fdAs = fd;
1910
1911	/*
1912	* Create the core file.
1913	*/
1914	fd = open(pSolCore->szCorePath, O_CREAT \| O_TRUNC \| O_RDWR, S_IRUSR);
1915	if (fd >= 0)
1916	{
1917	pSolCore->fdCoreFile = fd;
1918
1919	/*
1920	* Do the actual writing.
1921	*/
1922	rc = rtCoreDumperWriteCoreDoIt(pSolCore, pfnWriter, pSolProc);
1923
1924	close(pSolCore->fdCoreFile);
1925	pSolCore->fdCoreFile = -1;
1926	}
1927	else
1928	{
1929	rc = RTErrConvertFromErrno(fd);
1930	CORELOGRELSYS((CORELOG_NAME "WriteCore: failed to open %s. rc=%Rrc\n", pSolCore->szCorePath, rc));
1931	}
1932	close(pSolProc->fdAs);
1933	pSolProc->fdAs = -1;
1934	}
1935	else
1936	{
1937	rc = RTErrConvertFromErrno(fd);
1938	CORELOGRELSYS((CORELOG_NAME "WriteCore: Failed to open address space, %s. rc=%Rrc\n", szPath, rc));
1939	}
1940
1941	rtCoreDumperResumeThreads(pSolCore);
1942	return rc;
1943	}
1944
1945
1946	/**
1947	* Takes a process snapshot into a passed-in core object. It has the side-effect of halting
1948	* all threads which can lead to things like spurious wakeups of threads (if and when threads
1949	* are ultimately resumed en-masse) already suspended while calling this function.
1950	*
1951	* @return IPRT status code.
1952	* @param pSolCore Pointer to a core object.
1953	* @param pContext Pointer to the caller context thread.
1954	* @param pszCoreFilePath Path to the core file. If NULL is passed, the global
1955	* path specified in RTCoreDumperSetup() would be used.
1956	*
1957	* @remarks Halts all threads.
1958	*/
1959	static int rtCoreDumperCreateCore(PRTSOLCORE pSolCore, ucontext_t pContext, const char pszCoreFilePath)
1960	{
1961	AssertReturn(pSolCore, VERR_INVALID_POINTER);
1962	AssertReturn(pContext, VERR_INVALID_POINTER);
1963
1964	/*
1965	* Initialize core structures.
1966	*/
1967	memset(pSolCore, 0, sizeof(RTSOLCORE));
1968	pSolCore->pfnReader = &ReadFileNoIntr;
1969	pSolCore->pfnWriter = &WriteFileNoIntr;
1970	pSolCore->fIsValid = false;
1971	pSolCore->fdCoreFile = -1;
1972
1973	PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
1974	pSolProc->Process = RTProcSelf();
1975	pSolProc->hCurThread = _lwp_self(); /* thr_self() */
1976	pSolProc->fdAs = -1;
1977	pSolProc->pCurThreadCtx = pContext;
1978	pSolProc->CoreContent = CC_CONTENT_DEFAULT;
1979
1980	RTProcGetExecutablePath(pSolProc->szExecPath, sizeof(pSolProc->szExecPath)); /* this gets full path not just name */
1981	pSolProc->pszExecName = RTPathFilename(pSolProc->szExecPath);
1982
1983	/*
1984	* If a path has been specified, use it. Otherwise use the global path.
1985	*/
1986	if (!pszCoreFilePath)
1987	{
1988	/*
1989	* If no output directory is specified, use current directory.
1990	*/
1991	if (g_szCoreDumpDir[0] == '\0')
1992	g_szCoreDumpDir[0] = '.';
1993
1994	if (g_szCoreDumpFile[0] == '\0')
1995	{
1996	/* We cannot call RTPathAbs() as they call getcwd() which calls malloc. /
1997	RTStrPrintf(pSolCore->szCorePath, sizeof(pSolCore->szCorePath), "%s/core.vb.%s.%d",
1998	g_szCoreDumpDir, pSolProc->pszExecName, (int)pSolProc->Process);
1999	}
2000	else
2001	RTStrPrintf(pSolCore->szCorePath, sizeof(pSolCore->szCorePath), "%s/core.vb.%s", g_szCoreDumpDir, g_szCoreDumpFile);
2002	}
2003	else
2004	RTStrCopy(pSolCore->szCorePath, sizeof(pSolCore->szCorePath), pszCoreFilePath);
2005
2006	CORELOG((CORELOG_NAME "CreateCore: Taking Core %s from Thread %d\n", pSolCore->szCorePath, (int)pSolProc->hCurThread));
2007
2008	/*
2009	* Quiesce the process.
2010	*/
2011	int rc = rtCoreDumperSuspendThreads(pSolCore);
2012	if (RT_SUCCESS(rc))
2013	{
2014	rc = AllocMemoryArea(pSolCore);
2015	if (RT_SUCCESS(rc))
2016	{
2017	rc = ProcReadInfo(pSolCore);
2018	if (RT_SUCCESS(rc))
2019	{
2020	rc = GetOldProcessInfo(pSolCore, &pSolProc->ProcInfoOld);
2021	if (RT_SUCCESS(rc))
2022	{
2023	if (IsProcessArchNative(pSolProc))
2024	{
2025	/*
2026	* Read process status, information such as number of active LWPs will be
2027	* invalid since we just quiesced the process.
2028	*/
2029	rc = ProcReadStatus(pSolCore);
2030	if (RT_SUCCESS(rc))
2031	{
2032	struct COREACCUMULATOR
2033	{
2034	const char *pszName;
2035	PFNRTSOLCOREACCUMULATOR pfnAcc;
2036	bool fOptional;
2037	} aAccumulators[] =
2038	{
2039	{ "ProcReadLdt", &ProcReadLdt, false },
2040	{ "ProcReadCred", &ProcReadCred, false },
2041	{ "ProcReadPriv", &ProcReadPriv, false },
2042	{ "ProcReadAuxVecs", &ProcReadAuxVecs, false },
2043	{ "ProcReadMappings", &ProcReadMappings, false },
2044	{ "ProcReadThreads", &ProcReadThreads, false },
2045	{ "ProcReadMiscInfo", &ProcReadMiscInfo, false }
2046	};
2047
2048	for (unsigned i = 0; i < RT_ELEMENTS(aAccumulators); i++)
2049	{
2050	rc = aAccumulators[i].pfnAcc(pSolCore);
2051	if (RT_FAILURE(rc))
2052	{
2053	CORELOGRELSYS((CORELOG_NAME "CreateCore: %s failed. rc=%Rrc\n", aAccumulators[i].pszName, rc));
2054	if (!aAccumulators[i].fOptional)
2055	break;
2056	}
2057	}
2058
2059	if (RT_SUCCESS(rc))
2060	{
2061	pSolCore->fIsValid = true;
2062	return VINF_SUCCESS;
2063	}
2064
2065	FreeMemoryArea(pSolCore);
2066	}
2067	else
2068	CORELOGRELSYS((CORELOG_NAME "CreateCore: ProcReadStatus failed. rc=%Rrc\n", rc));
2069	}
2070	else
2071	{
2072	CORELOGRELSYS((CORELOG_NAME "CreateCore: IsProcessArchNative failed.\n"));
2073	rc = VERR_BAD_EXE_FORMAT;
2074	}
2075	}
2076	else
2077	CORELOGRELSYS((CORELOG_NAME "CreateCore: GetOldProcessInfo failed. rc=%Rrc\n", rc));
2078	}
2079	else
2080	CORELOGRELSYS((CORELOG_NAME "CreateCore: ProcReadInfo failed. rc=%Rrc\n", rc));
2081	}
2082	else
2083	CORELOGRELSYS((CORELOG_NAME "CreateCore: AllocMemoryArea failed. rc=%Rrc\n", rc));
2084
2085	/*
2086	* Resume threads on failure.
2087	*/
2088	rtCoreDumperResumeThreads(pSolCore);
2089	}
2090	else
2091	CORELOG((CORELOG_NAME "CreateCore: SuspendAllThreads failed. Thread bomb!?! rc=%Rrc\n", rc));
2092
2093	return rc;
2094	}
2095
2096
2097	/**
2098	* Destroy an existing core object.
2099	*
2100	* @param pSolCore Pointer to the core object.
2101	*
2102	* @return IPRT status code.
2103	*/
2104	static int rtCoreDumperDestroyCore(PRTSOLCORE pSolCore)
2105	{
2106	AssertReturn(pSolCore, VERR_INVALID_POINTER);
2107	if (!pSolCore->fIsValid)
2108	return VERR_INVALID_STATE;
2109
2110	FreeMemoryArea(pSolCore);
2111	pSolCore->fIsValid = false;
2112	return VINF_SUCCESS;
2113	}
2114
2115
2116	/**
2117	* Takes a core dump.
2118	*
2119	* @param pContext The context of the caller.
2120	* @param pszOutputFile Path of the core file. If NULL is passed, the
2121	* global path passed in RTCoreDumperSetup will
2122	* be used.
2123	* @returns IPRT status code.
2124	*/
2125	static int rtCoreDumperTakeDump(ucontext_t pContext, const char pszOutputFile)
2126	{
2127	if (!pContext)
2128	{
2129	CORELOGRELSYS((CORELOG_NAME "TakeDump: Missing context.\n"));
2130	return VERR_INVALID_POINTER;
2131	}
2132
2133	/*
2134	* Take a snapshot, then dump core to disk, all threads except this one are halted
2135	* from before taking the snapshot until writing the core is completely finished.
2136	* Any errors would resume all threads if they were halted.
2137	*/
2138	RTSOLCORE SolCore;
2139	RT_ZERO(SolCore);
2140	int rc = rtCoreDumperCreateCore(&SolCore, pContext, pszOutputFile);
2141	if (RT_SUCCESS(rc))
2142	{
2143	rc = rtCoreDumperWriteCore(&SolCore, &WriteFileNoIntr);
2144	if (RT_SUCCESS(rc))
2145	CORELOGRELSYS((CORELOG_NAME "Core dumped in %s\n", SolCore.szCorePath));
2146	else
2147	CORELOGRELSYS((CORELOG_NAME "TakeDump: WriteCore failed. szCorePath=%s rc=%Rrc\n", SolCore.szCorePath, rc));
2148
2149	rtCoreDumperDestroyCore(&SolCore);
2150	}
2151	else
2152	CORELOGRELSYS((CORELOG_NAME "TakeDump: CreateCore failed. rc=%Rrc\n", rc));
2153
2154	return rc;
2155	}
2156
2157
2158	/**
2159	* The signal handler that will be invoked to take core dumps.
2160	*
2161	* @param Sig The signal that invoked us.
2162	* @param pSigInfo The signal information.
2163	* @param pvArg Opaque pointer to the caller context structure,
2164	* this cannot be NULL.
2165	*/
2166	static void rtCoreDumperSignalHandler(int Sig, siginfo_t pSigInfo, void pvArg)
2167	{
2168	CORELOG((CORELOG_NAME "SignalHandler Sig=%d pvArg=%p\n", Sig, pvArg));
2169
2170	RTNATIVETHREAD hCurNativeThread = RTThreadNativeSelf();
2171	int rc = VERR_GENERAL_FAILURE;
2172	bool fCallSystemDump = false;
2173	bool fRc;
2174	ASMAtomicCmpXchgHandle(&g_CoreDumpThread, hCurNativeThread, NIL_RTNATIVETHREAD, fRc);
2175	if (fRc)
2176	{
2177	rc = rtCoreDumperTakeDump((ucontext_t )pvArg, NULL / Use Global Core filepath */);
2178	ASMAtomicWriteHandle(&g_CoreDumpThread, NIL_RTNATIVETHREAD);
2179
2180	if (RT_FAILURE(rc))
2181	CORELOGRELSYS((CORELOG_NAME "TakeDump failed! rc=%Rrc\n", rc));
2182	}
2183	else if (Sig == SIGSEGV \|\| Sig == SIGBUS \|\| Sig == SIGTRAP)
2184	{
2185	/*
2186	* Core dumping is already in progress and we've somehow ended up being
2187	* signalled again.
2188	*/
2189	rc = VERR_INTERNAL_ERROR;
2190
2191	/*
2192	* If our dumper has crashed. No point in waiting, trigger the system one.
2193	* Wait only when the dumping thread is not the one generating this signal.
2194	*/
2195	RTNATIVETHREAD hNativeDumperThread;
2196	ASMAtomicReadHandle(&g_CoreDumpThread, &hNativeDumperThread);
2197	if (hNativeDumperThread == RTThreadNativeSelf())
2198	{
2199	CORELOGRELSYS((CORELOG_NAME "SignalHandler: Core dumper (thread %u) crashed Sig=%d. Triggering system dump\n",
2200	RTThreadSelf(), Sig));
2201	fCallSystemDump = true;
2202	}
2203	else
2204	{
2205	/*
2206	* Some other thread in the process is triggering a crash, wait a while
2207	* to let our core dumper finish, on timeout trigger system dump.
2208	*/
2209	CORELOGRELSYS((CORELOG_NAME "SignalHandler: Core dump already in progress! Waiting a while for completion Sig=%d.\n",
2210	Sig));
2211	int64_t iTimeout = 16000; /* timeout (ms) */
2212	for (;;)
2213	{
2214	ASMAtomicReadHandle(&g_CoreDumpThread, &hNativeDumperThread);
2215	if (hNativeDumperThread == NIL_RTNATIVETHREAD)
2216	break;
2217	RTThreadSleep(200);
2218	iTimeout -= 200;
2219	if (iTimeout <= 0)
2220	break;
2221	}
2222	if (iTimeout <= 0)
2223	{
2224	fCallSystemDump = true;
2225	CORELOGRELSYS((CORELOG_NAME "SignalHandler: Core dumper seems to be stuck. Signalling new signal %d\n", Sig));
2226	}
2227	}
2228	}
2229
2230	if (Sig == SIGSEGV \|\| Sig == SIGBUS \|\| Sig == SIGTRAP)
2231	{
2232	/*
2233	* Reset signal handlers, we're not a live core we will be blown away
2234	* one way or another.
2235	*/
2236	signal(SIGSEGV, SIG_DFL);
2237	signal(SIGBUS, SIG_DFL);
2238	signal(SIGTRAP, SIG_DFL);
2239
2240	/*
2241	* Hard terminate the process if this is not a live dump without invoking
2242	* the system core dumping behaviour.
2243	*/
2244	if (RT_SUCCESS(rc))
2245	raise(SIGKILL);
2246
2247	/*
2248	* Something went wrong, fall back to the system core dumper.
2249	*/
2250	if (fCallSystemDump)
2251	abort();
2252	}
2253	}
2254
2255
2256	RTDECL(int) RTCoreDumperTakeDump(const char *pszOutputFile, bool fLiveCore)
2257	{
2258	ucontext_t Context;
2259	int rc = getcontext(&Context);
2260	if (!rc)
2261	{
2262	/*
2263	* Block SIGSEGV and co. while we write the core.
2264	*/
2265	sigset_t SigSet, OldSigSet;
2266	sigemptyset(&SigSet);
2267	sigaddset(&SigSet, SIGSEGV);
2268	sigaddset(&SigSet, SIGBUS);
2269	sigaddset(&SigSet, SIGTRAP);
2270	sigaddset(&SigSet, SIGUSR2);
2271	pthread_sigmask(SIG_BLOCK, &SigSet, &OldSigSet);
2272	rc = rtCoreDumperTakeDump(&Context, pszOutputFile);
2273	if (RT_FAILURE(rc))
2274	CORELOGRELSYS(("RTCoreDumperTakeDump: rtCoreDumperTakeDump failed rc=%Rrc\n", rc));
2275
2276	if (!fLiveCore)
2277	{
2278	signal(SIGSEGV, SIG_DFL);
2279	signal(SIGBUS, SIG_DFL);
2280	signal(SIGTRAP, SIG_DFL);
2281	if (RT_SUCCESS(rc))
2282	raise(SIGKILL);
2283	else
2284	abort();
2285	}
2286	pthread_sigmask(SIG_SETMASK, &OldSigSet, NULL);
2287	}
2288	else
2289	{
2290	CORELOGRELSYS(("RTCoreDumperTakeDump: getcontext failed rc=%d.\n", rc));
2291	rc = VERR_INVALID_CONTEXT;
2292	}
2293
2294	return rc;
2295	}
2296
2297
2298	RTDECL(int) RTCoreDumperSetup(const char *pszOutputDir, uint32_t fFlags)
2299	{
2300	/*
2301	* Validate flags.
2302	*/
2303	AssertReturn(fFlags, VERR_INVALID_PARAMETER);
2304	AssertReturn(!(fFlags & ~( RTCOREDUMPER_FLAGS_REPLACE_SYSTEM_DUMP
2305	\| RTCOREDUMPER_FLAGS_LIVE_CORE)),
2306	VERR_INVALID_PARAMETER);
2307
2308
2309	/*
2310	* Setup/change the core dump directory if specified.
2311	*/
2312	RT_ZERO(g_szCoreDumpDir);
2313	if (pszOutputDir)
2314	{
2315	if (!RTDirExists(pszOutputDir))
2316	return VERR_NOT_A_DIRECTORY;
2317	RTStrCopy(g_szCoreDumpDir, sizeof(g_szCoreDumpDir), pszOutputDir);
2318	}
2319
2320	/*
2321	* Install core dump signal handler only if the flags changed or if it's the first time.
2322	*/
2323	if ( ASMAtomicReadBool(&g_fCoreDumpSignalSetup) == false
2324	\|\| ASMAtomicReadU32(&g_fCoreDumpFlags) != fFlags)
2325	{
2326	struct sigaction sigAct;
2327	RT_ZERO(sigAct);
2328	sigAct.sa_sigaction = &rtCoreDumperSignalHandler;
2329
2330	if ( (fFlags & RTCOREDUMPER_FLAGS_REPLACE_SYSTEM_DUMP)
2331	&& !(g_fCoreDumpFlags & RTCOREDUMPER_FLAGS_REPLACE_SYSTEM_DUMP))
2332	{
2333	sigemptyset(&sigAct.sa_mask);
2334	sigAct.sa_flags = SA_RESTART \| SA_SIGINFO \| SA_NODEFER;
2335	sigaction(SIGSEGV, &sigAct, NULL);
2336	sigaction(SIGBUS, &sigAct, NULL);
2337	sigaction(SIGTRAP, &sigAct, NULL);
2338	}
2339
2340	if ( fFlags & RTCOREDUMPER_FLAGS_LIVE_CORE
2341	&& !(g_fCoreDumpFlags & RTCOREDUMPER_FLAGS_LIVE_CORE))
2342	{
2343	sigfillset(&sigAct.sa_mask); /* Block all signals while in it's signal handler */
2344	sigAct.sa_flags = SA_RESTART \| SA_SIGINFO;
2345	sigaction(SIGUSR2, &sigAct, NULL);
2346	}
2347
2348	ASMAtomicWriteU32(&g_fCoreDumpFlags, fFlags);
2349	ASMAtomicWriteBool(&g_fCoreDumpSignalSetup, true);
2350	}
2351
2352	return VINF_SUCCESS;
2353	}
2354
2355
2356	RTDECL(int) RTCoreDumperDisable(void)
2357	{
2358	/*
2359	* Remove core dump signal handler & reset variables.
2360	*/
2361	if (ASMAtomicReadBool(&g_fCoreDumpSignalSetup) == true)
2362	{
2363	signal(SIGSEGV, SIG_DFL);
2364	signal(SIGBUS, SIG_DFL);
2365	signal(SIGTRAP, SIG_DFL);
2366	signal(SIGUSR2, SIG_DFL);
2367	ASMAtomicWriteBool(&g_fCoreDumpSignalSetup, false);
2368	}
2369
2370	RT_ZERO(g_szCoreDumpDir);
2371	RT_ZERO(g_szCoreDumpFile);
2372	ASMAtomicWriteU32(&g_fCoreDumpFlags, 0);
2373	return VINF_SUCCESS;
2374	}
2375

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/r3/solaris/coredumper-solaris.cpp@ 106580

Download in other formats: