log.cpp@ 4953

Last change on this file since 4953 was 4699, checked in by vboxsync, 17 years ago
Better error message if mmap(PROT_EXEC \| PROT_WRITE) failed. A better solution would be a function RTMemInit() which performs this test.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 73.1 KB

Line
1	/* $Id: log.cpp 4699 2007-09-11 11:27:25Z vboxsync $ */
2	/** @file
3	* Runtime VBox - Logger.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 innotek GmbH
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#include <iprt/log.h>
23	#ifndef IN_GC
24	# include <iprt/alloc.h>
25	# include <iprt/thread.h>
26	# include <iprt/semaphore.h>
27	#endif
28	#ifdef IN_RING3
29	# include <iprt/process.h>
30	# include <iprt/file.h>
31	# include <iprt/path.h>
32	#endif
33	#include <iprt/time.h>
34	#include <iprt/asm.h>
35	#include <iprt/assert.h>
36	#include <iprt/err.h>
37	#include <iprt/param.h>
38
39	#include <iprt/stdarg.h>
40	#include <iprt/string.h>
41	#ifdef IN_RING3
42	# include <iprt/ctype.h>
43	# include <iprt/alloca.h>
44	# include <stdio.h>
45	#else
46	# define isspace(ch) ( (ch) == ' ' \|\| (ch) == '\t' )
47	#endif
48
49
50
51	/*******************************************************************************
52	* Defined Constants And Macros *
53	*******************************************************************************/
54	/** Ascii to lower macro. */
55	#define CHLOWER(ch) (((unsigned char)(ch) < (unsigned char)'A') \|\| ((unsigned char)(ch) > (unsigned char)'Z') ? (ch) : (ch) + ('a' - 'A'))
56
57
58	/*******************************************************************************
59	* Structures and Typedefs *
60	*******************************************************************************/
61	/**
62	* Arguments passed to the output function.
63	*/
64	typedef struct RTLOGOUTPUTPREFIXEDARGS
65	{
66	/** The logger instance. */
67	PRTLOGGER pLogger;
68	/** The flags. (used for prefixing.) */
69	unsigned fFlags;
70	/** The group. (used for prefixing.) */
71	unsigned iGroup;
72	} RTLOGOUTPUTPREFIXEDARGS, *PRTLOGOUTPUTPREFIXEDARGS;
73
74
75	/*******************************************************************************
76	* Internal Functions *
77	*******************************************************************************/
78	#ifndef IN_GC
79	static unsigned rtlogGroupFlags(const char *psz);
80	#endif
81	static void rtlogLogger(PRTLOGGER pLogger, unsigned fFlags, unsigned iGroup, const char *pszFormat, va_list args);
82	static void rtlogFlush(PRTLOGGER pLogger);
83	static DECLCALLBACK(size_t) rtLogOutput(void pv, const char pachChars, size_t cbChars);
84	static DECLCALLBACK(size_t) rtLogOutputPrefixed(void pv, const char pachChars, size_t cbChars);
85
86
87	/*******************************************************************************
88	* Global Variables *
89	*******************************************************************************/
90	#ifdef IN_GC
91	/** Default logger instance. */
92	extern "C" DECLIMPORT(RTLOGGERGC) g_Logger;
93	/** Default relese logger instance. */
94	extern "C" DECLIMPORT(RTLOGGERGC) g_RelLogger;
95	#else /* !IN_GC */
96	/** Default logger instance. */
97	static PRTLOGGER g_pLogger;
98	/** Default release logger instance. */
99	static PRTLOGGER g_pRelLogger;
100	#endif /* !IN_GC */
101	#ifdef IN_RING0
102	/** Number of per-thread loggers. */
103	static int32_t volatile g_cPerThreadLoggers;
104	/** Per-thread loggers.
105	* This is just a quick TLS hack suitable for debug logging only.
106	* If we run out of entries, just unload and reload the driver. */
107	static struct RTLOGGERPERTHREAD
108	{
109	/** The thread. */
110	RTNATIVETHREAD volatile NativeThread;
111	/** The (process / session) key. */
112	uintptr_t volatile uKey;
113	/** The logger instance.*/
114	PRTLOGGER volatile pLogger;
115	} g_aPerThreadLoggers[8] =
116	{ { NIL_RTNATIVETHREAD, 0, 0},
117	{ NIL_RTNATIVETHREAD, 0, 0},
118	{ NIL_RTNATIVETHREAD, 0, 0},
119	{ NIL_RTNATIVETHREAD, 0, 0},
120	{ NIL_RTNATIVETHREAD, 0, 0},
121	{ NIL_RTNATIVETHREAD, 0, 0},
122	{ NIL_RTNATIVETHREAD, 0, 0},
123	{ NIL_RTNATIVETHREAD, 0, 0}
124	};
125	#endif /* IN_RING0 */
126
127
128	/**
129	* Locks the logger instance.
130	*
131	* @returns See RTSemFastMutexRequest().
132	* @param pLogger The logger instance.
133	*/
134	DECLINLINE(int) rtlogLock(PRTLOGGER pLogger)
135	{
136	#ifdef IN_RING3
137	if (pLogger->MutexSem != NIL_RTSEMFASTMUTEX)
138	{
139	int rc = RTSemFastMutexRequest(pLogger->MutexSem);
140	AssertRCReturn(rc, rc);
141	}
142	#endif
143	return VINF_SUCCESS;
144	}
145
146
147	/**
148	* Unlocks the logger instance.
149	* @param pLogger The logger instance.
150	*/
151	DECLINLINE(void) rtlogUnlock(PRTLOGGER pLogger)
152	{
153	#ifdef IN_RING3
154	if (pLogger->MutexSem != NIL_RTSEMFASTMUTEX)
155	RTSemFastMutexRelease(pLogger->MutexSem);
156	#endif
157	return;
158	}
159
160
161	#ifndef IN_GC
162	/**
163	* Create a logger instance, comprehensive version.
164	*
165	* @returns iprt status code.
166	*
167	* @param ppLogger Where to store the logger instance.
168	* @param fFlags Logger instance flags, a combination of the RTLOGFLAGS_* values.
169	* @param pszGroupSettings The initial group settings.
170	* @param pszEnvVarBase Base name for the environment variables for this instance.
171	* @param cGroups Number of groups in the array.
172	* @param papszGroups Pointer to array of groups. This must stick around for the life of the
173	* logger instance.
174	* @param fDestFlags The destination flags. RTLOGDEST_FILE is ORed if pszFilenameFmt specified.
175	* @param pszErrorMsg A buffer which is filled with an error message if something fails. May be NULL.
176	* @param cchErrorMsg The size of the error message buffer.
177	* @param pszFilenameFmt Log filename format string. Standard RTStrFormat().
178	* @param ... Format arguments.
179	*/
180	RTDECL(int) RTLogCreateExV(PRTLOGGER ppLogger, RTUINT fFlags, const char pszGroupSettings,
181	const char pszEnvVarBase, unsigned cGroups, const char const * papszGroups,
182	RTUINT fDestFlags, char pszErrorMsg, size_t cchErrorMsg, const char pszFilenameFmt, va_list args)
183	{
184	/*
185	* Validate input.
186	*/
187	if ( (cGroups && !papszGroups)
188	\|\| !VALID_PTR(ppLogger)
189	)
190	{
191	AssertMsgFailed(("Invalid parameters!\n"));
192	return VERR_INVALID_PARAMETER;
193	}
194	*ppLogger = NULL;
195
196	if (pszErrorMsg)
197	RTStrPrintf(pszErrorMsg, cchErrorMsg, "unknown error");
198
199	/*
200	* Allocate a logger instance.
201	*/
202	int rc;
203	size_t cb = RT_OFFSETOF(RTLOGGER, afGroups[cGroups + 1]) + RTPATH_MAX;
204	PRTLOGGER pLogger = (PRTLOGGER)RTMemAllocZ(cb);
205	if (pLogger)
206	{
207	pLogger->u32Magic = RTLOGGER_MAGIC;
208	pLogger->papszGroups = papszGroups;
209	pLogger->cMaxGroups = cGroups;
210	pLogger->cGroups = cGroups;
211	pLogger->pszFilename = (char *)&pLogger->afGroups[cGroups + 1];
212	pLogger->File = NIL_RTFILE;
213	pLogger->fFlags = fFlags;
214	pLogger->fDestFlags = fDestFlags;
215	pLogger->fPendingPrefix = true;
216	if (pszGroupSettings)
217	RTLogGroupSettings(pLogger, pszGroupSettings);
218
219	/*
220	* Emit wrapper code.
221	*/
222	uint8_t pu8Code = (uint8_t )RTMemExecAlloc(64);
223	if (pu8Code)
224	{
225	pLogger->pfnLogger = (PFNRTLOGGER)&pu8Code;
226	#ifdef RT_ARCH_AMD64
227	/* this wrapper will not be used on AMD64, we will be requiring C99 compilers there. */
228	*pu8Code++ = 0xcc;
229	#else
230	pu8Code++ = 0x68; / push imm32 */
231	(void *)pu8Code = pLogger;
232	pu8Code += sizeof(void *);
233	pu8Code++ = 0xe8; / call rel32 */
234	(uint32_t )pu8Code = (uintptr_t)RTLogLogger - ((uintptr_t)pu8Code + sizeof(uint32_t));
235	pu8Code += sizeof(uint32_t);
236	pu8Code++ = 0x8d; / lea esp, [esp + 4] */
237	*pu8Code++ = 0x64;
238	*pu8Code++ = 0x24;
239	*pu8Code++ = 0x04;
240	pu8Code++ = 0xc3; / ret near */
241	#endif
242	AssertMsg((uintptr_t)pu8Code - (uintptr_t)pLogger->pfnLogger <= 64,
243	("Wrapper assembly is too big! %d bytes\n", (uintptr_t)pu8Code - (uintptr_t)pLogger->pfnLogger));
244
245
246	#ifdef IN_RING3 /* files and env.vars. are only accessible when in R3 at the present time. */
247	/*
248	* Format the filename.
249	*/
250	if (pszFilenameFmt)
251	{
252	RTStrPrintfV(pLogger->pszFilename, RTPATH_MAX, pszFilenameFmt, args);
253	pLogger->fDestFlags \|= RTLOGDEST_FILE;
254	}
255
256	/*
257	* Parse the environment variables.
258	*/
259	if (pszEnvVarBase)
260	{
261	/* make temp copy of environment variable base. */
262	size_t cchEnvVarBase = strlen(pszEnvVarBase);
263	char pszEnvVar = (char )alloca(cchEnvVarBase + 16);
264	memcpy(pszEnvVar, pszEnvVarBase, cchEnvVarBase);
265
266	/*
267	* Destination.
268	*/
269	strcpy(pszEnvVar + cchEnvVarBase, "_DEST");
270	const char *pszVar = getenv(pszEnvVar);
271	if (pszVar)
272	{
273	while (*pszVar)
274	{
275	/* skip blanks. */
276	while (isspace(pszVar) \|\| pszVar == '\n' \|\| *pszVar == '\r')
277	pszVar++;
278	if (!*pszVar)
279	break;
280
281	/* parse instruction. */
282	static struct
283	{
284	const char *pszInstr;
285	unsigned fFlag;
286	} const aDest[] =
287	{
288	{ "file", RTLOGDEST_FILE }, /* Must be 1st! */
289	{ "dir", RTLOGDEST_FILE }, /* Must be 2nd! */
290	{ "stdout", RTLOGDEST_STDOUT },
291	{ "stderr", RTLOGDEST_STDERR },
292	{ "debugger", RTLOGDEST_DEBUGGER },
293	{ "com", RTLOGDEST_COM },
294	{ "user", RTLOGDEST_USER },
295	};
296
297	/* check no prefix. */
298	bool fNo = false;
299	if (pszVar[0] == 'n' && pszVar[1] == 'o')
300	{
301	fNo = true;
302	pszVar += 2;
303	}
304
305	/* instruction. */
306	unsigned i;
307	for (i = 0; i < ELEMENTS(aDest); i++)
308	{
309	size_t cchInstr = strlen(aDest[i].pszInstr);
310	if (!strncmp(pszVar, aDest[i].pszInstr, cchInstr))
311	{
312	if (!fNo)
313	pLogger->fDestFlags \|= aDest[i].fFlag;
314	else
315	pLogger->fDestFlags &= ~aDest[i].fFlag;
316	pszVar += cchInstr;
317
318	/* check for value. */
319	while (isspace(pszVar) \|\| pszVar == '\n' \|\| *pszVar == '\r')
320	pszVar++;
321	if (pszVar == '=' \|\| pszVar == ':')
322	{
323	pszVar++;
324	const char *pszEnd = strchr(pszVar, ';');
325	if (!pszEnd)
326	pszEnd = strchr(pszVar, '\0');
327
328	/* log file name */
329	size_t cch = pszEnd - pszVar;
330	if (i == 0 /* file */ && !fNo)
331	{
332	memcpy(pLogger->pszFilename, pszVar, cch);
333	pLogger->pszFilename[cch] = '\0';
334	}
335	/* log directory */
336	else if (i == 1 /* dir */ && !fNo)
337	{
338	char szTmp[RTPATH_MAX];
339	const char *pszFile = RTPathFilename(pLogger->pszFilename);
340	if (pszFile)
341	strcpy(szTmp, pszFile);
342	else
343	pszFile = ""; /* you've screwed up, sir. */
344
345	memcpy(pLogger->pszFilename, pszVar, cch);
346	pLogger->pszFilename[cch] = '\0';
347	RTPathStripTrailingSlash(pLogger->pszFilename);
348
349	cch = strlen(pLogger->pszFilename);
350	pLogger->pszFilename[cch++] = '/';
351	strcpy(&pLogger->pszFilename[cch], szTmp);
352	}
353	else
354	AssertMsgFailed(("Invalid %s_DEST! %s%s doesn't take a value!\n", pszEnvVarBase, fNo ? "no" : "", aDest[i].pszInstr));
355	pszVar = pszEnd + (*pszEnd != '\0');
356	}
357	break;
358	}
359	}
360	/* unknown instruction? */
361	if (i >= ELEMENTS(aDest))
362	{
363	AssertMsgFailed(("Invalid %s_DEST! unknown instruction %.20s\n", pszEnvVarBase, pszVar));
364	pszVar++;
365	}
366
367	/* skip blanks and delimiters. */
368	while (isspace(pszVar) \|\| pszVar == '\n' \|\| pszVar == '\r' \|\| pszVar == ';')
369	pszVar++;
370	} /* while more environment variable value left */
371	}
372
373	/*
374	* The flags.
375	*/
376	strcpy(pszEnvVar + cchEnvVarBase, "_FLAGS");
377	pszVar = getenv(pszEnvVar);
378	if (pszVar)
379	RTLogFlags(pLogger, pszVar);
380
381	/*
382	* The group settings.
383	*/
384	pszEnvVar[cchEnvVarBase] = '\0';
385	pszVar = getenv(pszEnvVar);
386	if (pszVar)
387	RTLogGroupSettings(pLogger, pszVar);
388	}
389	#endif /* IN_RING3 */
390
391	/*
392	* Open the destination(s).
393	*/
394	rc = VINF_SUCCESS;
395	#ifdef IN_RING3
396	if (pLogger->fDestFlags & RTLOGDEST_FILE)
397	{
398	rc = RTFileOpen(&pLogger->File, pLogger->pszFilename,
399	RTFILE_O_WRITE \| RTFILE_O_CREATE_REPLACE \| RTFILE_O_DENY_WRITE);
400	if (RT_FAILURE(rc) && pszErrorMsg)
401	RTStrPrintf(pszErrorMsg, cchErrorMsg, "could not open file '%s'", pLogger->pszFilename);
402	}
403	#endif /* IN_RING3 */
404
405	/*
406	* Create mutex.
407	*/
408	if (RT_SUCCESS(rc))
409	{
410	rc = RTSemFastMutexCreate(&pLogger->MutexSem);
411	if (RT_SUCCESS(rc))
412	{
413	*ppLogger = pLogger;
414	return VINF_SUCCESS;
415	}
416	else if (pszErrorMsg)
417	RTStrPrintf(pszErrorMsg, cchErrorMsg, "failed to create sempahore");
418	}
419	#ifdef IN_RING3
420	RTFileClose(pLogger->File);
421	#endif
422	RTMemExecFree((void *)&pLogger->pfnLogger);
423	}
424	else
425	{
426	#ifdef RT_OS_LINUX
427	/*
428	* RTMemAlloc() succeeded but RTMemExecAlloc() failed -- most probably an SELinux problem.
429	*/
430	if (pszErrorMsg)
431	RTStrPrintf(pszErrorMsg, cchErrorMsg, "mmap(PROT_WRITE \| PROT_EXEC) failed -- SELinux?");
432	#endif /* RT_OS_LINUX */
433	rc = VERR_NO_MEMORY;
434	}
435	RTMemFree(pLogger);
436	}
437	else
438	rc = VERR_NO_MEMORY;
439
440	return rc;
441	}
442
443	/**
444	* Create a logger instance.
445	*
446	* @returns iprt status code.
447	*
448	* @param ppLogger Where to store the logger instance.
449	* @param fFlags Logger instance flags, a combination of the RTLOGFLAGS_* values.
450	* @param pszGroupSettings The initial group settings.
451	* @param pszEnvVarBase Base name for the environment variables for this instance.
452	* @param cGroups Number of groups in the array.
453	* @param papszGroups Pointer to array of groups. This must stick around for the life of the
454	* logger instance.
455	* @param fDestFlags The destination flags. RTLOGDEST_FILE is ORed if pszFilenameFmt specified.
456	* @param pszFilenameFmt Log filename format string. Standard RTStrFormat().
457	* @param ... Format arguments.
458	*/
459	RTDECL(int) RTLogCreate(PRTLOGGER ppLogger, RTUINT fFlags, const char pszGroupSettings,
460	const char pszEnvVarBase, unsigned cGroups, const char const * papszGroups,
461	RTUINT fDestFlags, const char *pszFilenameFmt, ...)
462	{
463	va_list args;
464	int rc;
465
466	va_start(args, pszFilenameFmt);
467	rc = RTLogCreateExV(ppLogger, fFlags, pszGroupSettings, pszEnvVarBase, cGroups, papszGroups, fDestFlags, NULL, 0, pszFilenameFmt, args);
468	va_end(args);
469	return rc;
470	}
471
472	/**
473	* Create a logger instance.
474	*
475	* @returns iprt status code.
476	*
477	* @param ppLogger Where to store the logger instance.
478	* @param fFlags Logger instance flags, a combination of the RTLOGFLAGS_* values.
479	* @param pszGroupSettings The initial group settings.
480	* @param pszEnvVarBase Base name for the environment variables for this instance.
481	* @param cGroups Number of groups in the array.
482	* @param papszGroups Pointer to array of groups. This must stick around for the life of the
483	* logger instance.
484	* @param fDestFlags The destination flags. RTLOGDEST_FILE is ORed if pszFilenameFmt specified.
485	* @param pszErrorMsg A buffer which is filled with an error message if something fails. May be NULL.
486	* @param cchErrorMsg The size of the error message buffer.
487	* @param pszFilenameFmt Log filename format string. Standard RTStrFormat().
488	* @param ... Format arguments.
489	*/
490	RTDECL(int) RTLogCreateEx(PRTLOGGER ppLogger, RTUINT fFlags, const char pszGroupSettings,
491	const char pszEnvVarBase, unsigned cGroups, const char const * papszGroups,
492	RTUINT fDestFlags, char pszErrorMsg, size_t cchErrorMsg, const char pszFilenameFmt, ...)
493	{
494	va_list args;
495	int rc;
496
497	va_start(args, pszFilenameFmt);
498	rc = RTLogCreateExV(ppLogger, fFlags, pszGroupSettings, pszEnvVarBase, cGroups, papszGroups, fDestFlags, pszErrorMsg, cchErrorMsg, pszFilenameFmt, args);
499	va_end(args);
500	return rc;
501	}
502
503	/**
504	* Destroys a logger instance.
505	*
506	* The instance is flushed and all output destinations closed (where applicable).
507	*
508	* @returns iprt status code.
509	* @param pLogger The logger instance which close destroyed.
510	*/
511	RTDECL(int) RTLogDestroy(PRTLOGGER pLogger)
512	{
513	/*
514	* Validate input.
515	*/
516	AssertReturn(VALID_PTR(pLogger), VERR_INVALID_POINTER);
517	AssertReturn(pLogger->u32Magic == RTLOGGER_MAGIC, VERR_INVALID_MAGIC);
518
519	/*
520	* Acquire logger instance sem and disable all logging. (paranoia)
521	*/
522	int rc = rtlogLock(pLogger);
523	if (RT_FAILURE(rc))
524	return rc;
525
526	pLogger->fFlags \|= RTLOGFLAGS_DISABLED;
527	RTUINT iGroup = pLogger->cGroups;
528	while (iGroup-- > 0)
529	pLogger->afGroups[iGroup] = 0;
530
531	/*
532	* Flush it.
533	*/
534	RTLogFlush(pLogger);
535
536	/*
537	* Close output stuffs.
538	*/
539	#ifdef IN_RING3
540	if (pLogger->File != NIL_RTFILE)
541	{
542	int rc2 = RTFileClose(pLogger->File);
543	AssertRC(rc2);
544	if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
545	rc = rc2;
546	pLogger->File = NIL_RTFILE;
547	}
548	#endif
549
550	/*
551	* Free the mutex and the instance memory.
552	*/
553	RTSEMFASTMUTEX MutexSem = pLogger->MutexSem;
554	pLogger->MutexSem = NIL_RTSEMFASTMUTEX;
555	if (MutexSem != NIL_RTSEMFASTMUTEX)
556	{
557	int rc2 = RTSemFastMutexDestroy(MutexSem);
558	AssertRC(rc2);
559	if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
560	rc = rc2;
561	}
562
563	RTMemFree(pLogger);
564
565	return rc;
566	}
567
568
569	/**
570	* Create a logger instance clone for GC usage.
571	*
572	* @returns iprt status code.
573	*
574	* @param pLogger The logger instance to be cloned.
575	* @param pLoggerGC Where to create the GC logger instance.
576	* @param cbLoggerGC Amount of memory allocated to for the GC logger instance clone.
577	* @param pfnLoggerGCPtr Pointer to logger wrapper function for this instance (GC Ptr).
578	* @param pfnFlushGCPtr Pointer to flush function (GC Ptr).
579	* @param fFlags Logger instance flags, a combination of the RTLOGFLAGS_* values.
580	*/
581	RTDECL(int) RTLogCloneGC(PRTLOGGER pLogger, PRTLOGGERGC pLoggerGC, size_t cbLoggerGC,
582	RTGCPTR pfnLoggerGCPtr, RTGCPTR pfnFlushGCPtr, RTUINT fFlags)
583	{
584	/*
585	* Validate input.
586	*/
587	if ( !pLoggerGC
588	\|\| !pfnFlushGCPtr
589	\|\| !pfnLoggerGCPtr)
590	{
591	AssertMsgFailed(("Invalid parameters!\n"));
592	return VERR_INVALID_PARAMETER;
593	}
594	if (cbLoggerGC < sizeof(*pLoggerGC))
595	{
596	AssertMsgFailed(("%d min=%d\n", cbLoggerGC, sizeof(*pLoggerGC)));
597	return VERR_INVALID_PARAMETER;
598	}
599
600	/*
601	* Initialize GC instance.
602	*/
603	pLoggerGC->offScratch = 0;
604	pLoggerGC->fPendingPrefix = false;
605	pLoggerGC->pfnLogger = pfnLoggerGCPtr;
606	pLoggerGC->pfnFlush = pfnFlushGCPtr;
607	pLoggerGC->u32Magic = RTLOGGERGC_MAGIC;
608	pLoggerGC->fFlags = fFlags \| RTLOGFLAGS_DISABLED;
609	pLoggerGC->cGroups = 1;
610	pLoggerGC->afGroups[0] = 0;
611
612	/*
613	* Resolve defaults.
614	*/
615	if (!pLogger)
616	{
617	pLogger = RTLogDefaultInstance();
618	if (!pLogger)
619	return VINF_SUCCESS;
620	}
621
622	/*
623	* Check if there's enough space for the groups.
624	*/
625	if (cbLoggerGC < (size_t)RT_OFFSETOF(RTLOGGERGC, afGroups[pLogger->cGroups]))
626	{
627	AssertMsgFailed(("%d req=%d cGroups=%d\n", cbLoggerGC, RT_OFFSETOF(RTLOGGERGC, afGroups[pLogger->cGroups]), pLogger->cGroups));
628	return VERR_INVALID_PARAMETER;
629	}
630	memcpy(&pLoggerGC->afGroups[0], &pLogger->afGroups[0], pLogger->cGroups * sizeof(pLoggerGC->afGroups[0]));
631	pLoggerGC->cGroups = pLogger->cGroups;
632
633	/*
634	* Copy bits from the HC instance.
635	*/
636	pLoggerGC->fPendingPrefix = pLogger->fPendingPrefix;
637	pLoggerGC->fFlags \|= pLogger->fFlags;
638
639	/*
640	* Check if we can remove the disabled flag.
641	*/
642	if ( pLogger->fDestFlags
643	&& !((pLogger->fFlags \| fFlags) & RTLOGFLAGS_DISABLED))
644	pLoggerGC->fFlags &= ~RTLOGFLAGS_DISABLED;
645
646	return VINF_SUCCESS;
647	}
648
649
650	/**
651	* Flushes a GC logger instance to a HC logger.
652	*
653	*
654	* @returns iprt status code.
655	* @param pLogger The HC logger instance to flush pLoggerGC to.
656	* If NULL the default logger is used.
657	* @param pLoggerGC The GC logger instance to flush.
658	*/
659	RTDECL(void) RTLogFlushGC(PRTLOGGER pLogger, PRTLOGGERGC pLoggerGC)
660	{
661	/*
662	* Resolve defaults.
663	*/
664	if (!pLogger)
665	{
666	pLogger = RTLogDefaultInstance();
667	if (!pLogger)
668	{
669	pLoggerGC->offScratch = 0;
670	return;
671	}
672	}
673
674	/*
675	* Any thing to flush?
676	*/
677	if ( pLogger->offScratch
678	\|\| pLoggerGC->offScratch)
679	{
680	/*
681	* Acquire logger instance sem.
682	*/
683	int rc = rtlogLock(pLogger);
684	if (RT_FAILURE(rc))
685	return;
686
687	/*
688	* Write whatever the GC instance contains to the HC one, and then
689	* flush the HC instance.
690	*/
691	if (pLoggerGC->offScratch)
692	{
693	rtLogOutput(pLogger, pLoggerGC->achScratch, pLoggerGC->offScratch);
694	rtLogOutput(pLogger, NULL, 0);
695	pLoggerGC->offScratch = 0;
696	}
697
698	/*
699	* Release the semaphore.
700	*/
701	rtlogUnlock(pLogger);
702	}
703	}
704
705
706	#ifdef IN_RING3
707	/**
708	* Create a logger instance for singled threaded ring-0 usage.
709	*
710	* @returns iprt status code.
711	*
712	* @param pLogger Where to create the logger instance.
713	* @param cbLogger The amount of memory available for the logger instance.
714	* @param pfnLogger Pointer to logger wrapper function for the clone.
715	* @param pfnFlush Pointer to flush function for the clone.
716	* @param fFlags Logger instance flags for the clone, a combination of the RTLOGFLAGS_* values.
717	* @param fDestFlags The destination flags.
718	*/
719	RTDECL(int) RTLogCreateForR0(PRTLOGGER pLogger, size_t cbLogger, PFNRTLOGGER pfnLogger, PFNRTLOGFLUSH pfnFlush, RTUINT fFlags, RTUINT fDestFlags)
720	{
721	/*
722	* Validate input.
723	*/
724	AssertPtrReturn(pLogger, VERR_INVALID_PARAMETER);
725	AssertReturn(cbLogger >= sizeof(*pLogger), VERR_INVALID_PARAMETER);
726	AssertReturn(pfnLogger, VERR_INVALID_PARAMETER);
727	AssertReturn(pfnFlush, VERR_INVALID_PARAMETER);
728
729	/*
730	* Initialize the ring-0 instance.
731	*/
732	pLogger->offScratch = 0;
733	pLogger->fPendingPrefix = false;
734	pLogger->pfnLogger = pfnLogger;
735	pLogger->pfnFlush = pfnFlush;
736	pLogger->MutexSem = NIL_RTSEMFASTMUTEX; /* Not serialized. */
737	pLogger->u32Magic = RTLOGGER_MAGIC;
738	pLogger->fFlags = fFlags;
739	pLogger->fDestFlags = fDestFlags & ~RTLOGDEST_FILE;
740	pLogger->File = NIL_RTFILE;
741	pLogger->pszFilename = NULL;
742	pLogger->papszGroups = NULL;
743	pLogger->cMaxGroups = (cbLogger - RT_OFFSETOF(RTLOGGER, afGroups[0])) / sizeof(pLogger->afGroups[0]);
744	pLogger->cGroups = 1;
745	pLogger->afGroups[0] = 0;
746	return VINF_SUCCESS;
747	}
748	#endif /* IN_RING3 */
749
750
751	/**
752	* Copies the group settings and flags from logger instance to another.
753	*
754	* @returns IPRT status code.
755	* @param pDstLogger The destination logger instance.
756	* @param pSrcLogger The source logger instance. If NULL the default one is used.
757	* @param fFlagsOr OR mask for the flags.
758	* @param fFlagsAnd AND mask for the flags.
759	*/
760	RTDECL(int) RTLogCopyGroupsAndFlags(PRTLOGGER pDstLogger, PCRTLOGGER pSrcLogger, unsigned fFlagsOr, unsigned fFlagsAnd)
761	{
762	/*
763	* Validate input.
764	*/
765	AssertPtrReturn(pDstLogger, VERR_INVALID_PARAMETER);
766	AssertPtrNullReturn(pSrcLogger, VERR_INVALID_PARAMETER);
767
768	/*
769	* Resolve defaults.
770	*/
771	if (!pSrcLogger)
772	{
773	pSrcLogger = RTLogDefaultInstance();
774	if (!pSrcLogger)
775	{
776	pDstLogger->fFlags \|= RTLOGFLAGS_DISABLED;
777	pDstLogger->cGroups = 1;
778	pDstLogger->afGroups[0] = 0;
779	return VINF_SUCCESS;
780	}
781	}
782
783	/*
784	* Copy flags and group settings.
785	*/
786	pDstLogger->fFlags = (pSrcLogger->fFlags & fFlagsAnd) \| fFlagsOr;
787
788	int rc = VINF_SUCCESS;
789	unsigned cGroups = pSrcLogger->cGroups;
790	if (cGroups < pDstLogger->cMaxGroups)
791	{
792	AssertMsgFailed(("cMaxGroups=%zd cGroups=%zd (min size %d)\n", pDstLogger->cMaxGroups,
793	pSrcLogger->cGroups, RT_OFFSETOF(RTLOGGER, afGroups[pSrcLogger->cGroups])));
794	rc = VERR_INVALID_PARAMETER;
795	cGroups = pDstLogger->cMaxGroups;
796	}
797	memcpy(&pDstLogger->afGroups[0], &pSrcLogger->afGroups[0], cGroups * sizeof(pDstLogger->afGroups[0]));
798	pDstLogger->cGroups = cGroups;
799
800	return rc;
801	}
802
803
804	/**
805	* Flushes the buffer in one logger instance onto another logger.
806	*
807	* @returns iprt status code.
808	*
809	* @param pSrcLogger The logger instance to flush.
810	* @param pDstLogger The logger instance to flush onto.
811	* If NULL the default logger will be used.
812	*/
813	RTDECL(void) RTLogFlushToLogger(PRTLOGGER pSrcLogger, PRTLOGGER pDstLogger)
814	{
815	/*
816	* Resolve defaults.
817	*/
818	if (!pDstLogger)
819	{
820	pDstLogger = RTLogDefaultInstance();
821	if (!pDstLogger)
822	{
823	/* flushing to "/dev/null". */
824	if (pSrcLogger->offScratch)
825	{
826	int rc = rtlogLock(pSrcLogger);
827	if (RT_SUCCESS(rc))
828	{
829	pSrcLogger->offScratch = 0;
830	rtlogLock(pSrcLogger);
831	}
832	}
833	return;
834	}
835	}
836
837	/*
838	* Any thing to flush?
839	*/
840	if ( pSrcLogger->offScratch
841	\|\| pDstLogger->offScratch)
842	{
843	/*
844	* Acquire logger semaphores.
845	*/
846	int rc = rtlogLock(pDstLogger);
847	if (RT_FAILURE(rc))
848	return;
849	rc = rtlogLock(pSrcLogger);
850	if (RT_SUCCESS(rc))
851	{
852	/*
853	* Write whatever the GC instance contains to the HC one, and then
854	* flush the HC instance.
855	*/
856	if (pSrcLogger->offScratch)
857	{
858	rtLogOutput(pDstLogger, pSrcLogger->achScratch, pSrcLogger->offScratch);
859	rtLogOutput(pDstLogger, NULL, 0);
860	pSrcLogger->offScratch = 0;
861	}
862
863	/*
864	* Release the semaphores.
865	*/
866	rtlogUnlock(pSrcLogger);
867	}
868	rtlogUnlock(pDstLogger);
869	}
870	}
871
872
873	/**
874	* Matches a group name with a pattern mask in an case insensitive manner (ASCII).
875	*
876	* @returns true if matching and *ppachMask set to the end of the pattern.
877	* @returns false if no match.
878	* @param pszGrp The group name.
879	* @param ppachMask Pointer to the pointer to the mask. Only wildcard supported is '*'.
880	* @param cchMask The length of the mask, including modifiers. The modifiers is why
881	* we update *ppachMask on match.
882	*/
883	static bool rtlogIsGroupMatching(const char pszGrp, const char *ppachMask, unsigned cchMask)
884	{
885	if (!pszGrp \|\| !*pszGrp)
886	return false;
887	const char pachMask = ppachMask;
888	for (;;)
889	{
890	if (CHLOWER(pszGrp) != CHLOWER(pachMask))
891	{
892	/*
893	* Check for wildcard and do a minimal match if found.
894	*/
895	if (pachMask != '')
896	return false;
897
898	/* eat ''s. /
899	do pachMask++;
900	while (--cchMask && pachMask == '');
901
902	/* is there more to match? */
903	if ( !cchMask
904	\|\| *pachMask == '.'
905	\|\| *pachMask == '=')
906	break; /* we're good */
907
908	/* do extremely minimal matching (fixme) */
909	pszGrp = strchr(pszGrp, *pachMask);
910	if (!pszGrp)
911	return false;
912	continue;
913	}
914
915	/* done? */
916	if (!*++pszGrp)
917	{
918	/* trailing wildcard is ok. */
919	do
920	{
921	pachMask++;
922	cchMask--;
923	} while (cchMask && pachMask == '');
924	if ( !cchMask
925	\|\| *pachMask == '.'
926	\|\| *pachMask == '=')
927	break; /* we're good */
928	return false;
929	}
930
931	if (!--cchMask)
932	return false;
933	pachMask++;
934	}
935
936	/* match */
937	*ppachMask = pachMask;
938	return true;
939	}
940
941
942	/**
943	* Updates the group settings for the logger instance using the specified
944	* specification string.
945	*
946	* @returns iprt status code.
947	* Failures can safely be ignored.
948	* @param pLogger Logger instance.
949	* @param pszVar Value to parse.
950	*/
951	RTDECL(int) RTLogGroupSettings(PRTLOGGER pLogger, const char *pszVar)
952	{
953	/*
954	* Resolve defaults.
955	*/
956	if (!pLogger)
957	{
958	pLogger = RTLogDefaultInstance();
959	if (!pLogger)
960	return VINF_SUCCESS;
961	}
962
963	/*
964	* Iterate the string.
965	*/
966	while (*pszVar)
967	{
968	/*
969	* Skip prefixes (blanks, ;, + and -).
970	*/
971	bool fEnabled = true;
972	char ch;
973	while ((ch = *pszVar) == '+' \|\| ch == '-' \|\| ch == ' ' \|\| ch == '\t' \|\| ch == '\n' \|\| ch == ';')
974	{
975	if (ch == '+' \|\| ch == '-' \|\| ';')
976	fEnabled = ch != '-';
977	pszVar++;
978	}
979	if (!*pszVar)
980	break;
981
982	/*
983	* Find end.
984	*/
985	const char *pszStart = pszVar;
986	while ((ch = *pszVar) != '\0' && ch != '+' && ch != '-' && ch != ' ' && ch != '\t')
987	pszVar++;
988
989	/*
990	* Find the group (ascii case insensitive search).
991	* Special group 'all'.
992	*/
993	unsigned i;
994	size_t cch = pszVar - pszStart;
995	if ( cch >= 3
996	&& (pszStart[0] == 'a' \|\| pszStart[0] == 'A')
997	&& (pszStart[1] == 'l' \|\| pszStart[1] == 'L')
998	&& (pszStart[2] == 'l' \|\| pszStart[2] == 'L')
999	&& (cch == 3 \|\| pszStart[3] == '.' \|\| pszStart[3] == '='))
1000	{
1001	/*
1002	* All.
1003	*/
1004	unsigned fFlags = cch == 3
1005	? RTLOGGRPFLAGS_ENABLED \| RTLOGGRPFLAGS_LEVEL_1
1006	: rtlogGroupFlags(&pszStart[3]);
1007	for (i = 0; i < pLogger->cGroups; i++)
1008	{
1009	if (fEnabled)
1010	pLogger->afGroups[i] \|= fFlags;
1011	else
1012	pLogger->afGroups[i] &= ~fFlags;
1013	}
1014	}
1015	else
1016	{
1017	/*
1018	* Specific group(s).
1019	*/
1020	bool fFound;
1021	for (i = 0, fFound = false; i < pLogger->cGroups && !fFound; i++)
1022	{
1023	const char psz2 = (const char)pszStart;
1024	if (rtlogIsGroupMatching(pLogger->papszGroups[i], &psz2, cch))
1025	{
1026	unsigned fFlags = RTLOGGRPFLAGS_ENABLED \| RTLOGGRPFLAGS_LEVEL_1;
1027	if (psz2 == '.' \|\| psz2 == '=')
1028	fFlags = rtlogGroupFlags(psz2);
1029	if (fEnabled)
1030	pLogger->afGroups[i] \|= fFlags;
1031	else
1032	pLogger->afGroups[i] &= ~fFlags;
1033	}
1034	} /* for each group */
1035	}
1036
1037	} /* parse specification */
1038
1039	return VINF_SUCCESS;
1040	}
1041
1042
1043	/**
1044	* Interprets the group flags suffix.
1045	*
1046	* @returns Flags specified. (0 is possible!)
1047	* @param psz Start of Suffix. (Either dot or equal sign.)
1048	*/
1049	static unsigned rtlogGroupFlags(const char *psz)
1050	{
1051	unsigned fFlags = 0;
1052
1053	/*
1054	* Litteral flags.
1055	*/
1056	while (*psz == '.')
1057	{
1058	static struct
1059	{
1060	const char pszFlag; / lowercase!! */
1061	unsigned fFlag;
1062	} aFlags[] =
1063	{
1064	{ "eo", RTLOGGRPFLAGS_ENABLED },
1065	{ "enabledonly",RTLOGGRPFLAGS_ENABLED },
1066	{ "e", RTLOGGRPFLAGS_ENABLED \| RTLOGGRPFLAGS_LEVEL_1 },
1067	{ "enabled", RTLOGGRPFLAGS_ENABLED \| RTLOGGRPFLAGS_LEVEL_1 },
1068	{ "l1", RTLOGGRPFLAGS_LEVEL_1 },
1069	{ "level1", RTLOGGRPFLAGS_LEVEL_1 },
1070	{ "l", RTLOGGRPFLAGS_LEVEL_2 },
1071	{ "l2", RTLOGGRPFLAGS_LEVEL_2 },
1072	{ "level2", RTLOGGRPFLAGS_LEVEL_2 },
1073	{ "l3", RTLOGGRPFLAGS_LEVEL_3 },
1074	{ "level3", RTLOGGRPFLAGS_LEVEL_3 },
1075	{ "l4", RTLOGGRPFLAGS_LEVEL_4 },
1076	{ "level4", RTLOGGRPFLAGS_LEVEL_4 },
1077	{ "l5", RTLOGGRPFLAGS_LEVEL_5 },
1078	{ "level5", RTLOGGRPFLAGS_LEVEL_5 },
1079	{ "l6", RTLOGGRPFLAGS_LEVEL_6 },
1080	{ "level6", RTLOGGRPFLAGS_LEVEL_6 },
1081	{ "f", RTLOGGRPFLAGS_FLOW },
1082	{ "flow", RTLOGGRPFLAGS_FLOW },
1083
1084	{ "lelik", RTLOGGRPFLAGS_LELIK },
1085	{ "michael", RTLOGGRPFLAGS_MICHAEL },
1086	{ "dmik", RTLOGGRPFLAGS_DMIK },
1087	{ "sunlover", RTLOGGRPFLAGS_SUNLOVER },
1088	{ "achim", RTLOGGRPFLAGS_ACHIM },
1089	{ "achimha", RTLOGGRPFLAGS_ACHIM },
1090	{ "s", RTLOGGRPFLAGS_SANDER },
1091	{ "sander", RTLOGGRPFLAGS_SANDER },
1092	{ "sandervl", RTLOGGRPFLAGS_SANDER },
1093	{ "klaus", RTLOGGRPFLAGS_KLAUS },
1094	{ "frank", RTLOGGRPFLAGS_FRANK },
1095	{ "b", RTLOGGRPFLAGS_BIRD },
1096	{ "bird", RTLOGGRPFLAGS_BIRD },
1097	{ "n", RTLOGGRPFLAGS_NONAME },
1098	{ "noname", RTLOGGRPFLAGS_NONAME }
1099	};
1100	psz++;
1101	unsigned i;
1102	bool fFound = false;
1103	for (i = 0; i < ELEMENTS(aFlags) && !fFound; i++)
1104	{
1105	const char *psz1 = aFlags[i].pszFlag;
1106	const char *psz2 = psz;
1107	while (psz1 == CHLOWER(psz2))
1108	{
1109	psz1++;
1110	psz2++;
1111	if (!*psz1)
1112	{
1113	if ( (psz2 >= 'a' && psz2 <= 'z')
1114	\|\| (psz2 >= 'A' && psz2 <= 'Z')
1115	\|\| (psz2 >= '0' && psz2 <= '9') )
1116	break;
1117	fFlags \|= aFlags[i].fFlag;
1118	fFound = true;
1119	psz = psz2;
1120	break;
1121	}
1122	} /* strincmp */
1123	} /* for each flags */
1124	}
1125
1126	/*
1127	* Flag value.
1128	*/
1129	if (*psz == '=')
1130	{
1131	psz++;
1132	if (*psz == '~')
1133	fFlags = ~RTStrToInt32(psz + 1);
1134	else
1135	fFlags = RTStrToInt32(psz);
1136	}
1137
1138	return fFlags;
1139	}
1140
1141	#endif /* !IN_GC */
1142
1143
1144	/**
1145	* Updates the flags for the logger instance using the specified
1146	* specification string.
1147	*
1148	* @returns iprt status code.
1149	* Failures can safely be ignored.
1150	* @param pLogger Logger instance (NULL for default logger).
1151	* @param pszVar Value to parse.
1152	*/
1153	RTDECL(int) RTLogFlags(PRTLOGGER pLogger, const char *pszVar)
1154	{
1155	int rc = VINF_SUCCESS;
1156
1157	/*
1158	* Resolve defaults.
1159	*/
1160	if (!pLogger)
1161	{
1162	pLogger = RTLogDefaultInstance();
1163	if (!pLogger)
1164	return VINF_SUCCESS;
1165	}
1166
1167	/*
1168	* Iterate the string.
1169	*/
1170	while (*pszVar)
1171	{
1172	/* skip blanks. */
1173	while (isspace(pszVar) \|\| pszVar == '\n' \|\| *pszVar == '\r')
1174	pszVar++;
1175	if (!*pszVar)
1176	return rc;
1177
1178	/* parse instruction. */
1179	static struct
1180	{
1181	const char *pszInstr;
1182	size_t cchInstr;
1183	unsigned fFlag;
1184	bool fInverted;
1185	} const aDest[] =
1186	{
1187	{ "disabled", sizeof("disabled" ) - 1, RTLOGFLAGS_DISABLED, false },
1188	{ "enabled", sizeof("enabled" ) - 1, RTLOGFLAGS_DISABLED, true },
1189	{ "buffered", sizeof("buffered" ) - 1, RTLOGFLAGS_BUFFERED, false },
1190	{ "unbuffered", sizeof("unbuffered" ) - 1, RTLOGFLAGS_BUFFERED, true },
1191	{ "usecrlf", sizeof("usecrlf" ) - 1, RTLOGFLAGS_USECRLF, true },
1192	{ "uself", sizeof("uself" ) - 1, RTLOGFLAGS_USECRLF, false },
1193	{ "rel", sizeof("rel" ) - 1, RTLOGFLAGS_REL_TS, false },
1194	{ "abs", sizeof("abs" ) - 1, RTLOGFLAGS_REL_TS, true },
1195	{ "dec", sizeof("dec" ) - 1, RTLOGFLAGS_DECIMAL_TS, false },
1196	{ "hex", sizeof("hex" ) - 1, RTLOGFLAGS_DECIMAL_TS, true },
1197	{ "flagno", sizeof("flagno" ) - 1, RTLOGFLAGS_PREFIX_FLAG_NO, false },
1198	{ "flag", sizeof("flag" ) - 1, RTLOGFLAGS_PREFIX_FLAG, false },
1199	{ "groupno", sizeof("groupno" ) - 1, RTLOGFLAGS_PREFIX_GROUP_NO, false },
1200	{ "group", sizeof("group" ) - 1, RTLOGFLAGS_PREFIX_GROUP, false },
1201	{ "tid", sizeof("tid" ) - 1, RTLOGFLAGS_PREFIX_TID, false },
1202	{ "thread", sizeof("thread" ) - 1, RTLOGFLAGS_PREFIX_THREAD, false },
1203	{ "timeprog", sizeof("timeprog" ) - 1, RTLOGFLAGS_PREFIX_TIME_PROG, false },
1204	{ "time", sizeof("time" ) - 1, RTLOGFLAGS_PREFIX_TIME, false },
1205	{ "msprog", sizeof("msprog" ) - 1, RTLOGFLAGS_PREFIX_MS_PROG, false },
1206	{ "tsc", sizeof("tsc" ) - 1, RTLOGFLAGS_PREFIX_TSC, false }, /* before ts! */
1207	{ "ts", sizeof("ts" ) - 1, RTLOGFLAGS_PREFIX_TS, false },
1208	};
1209
1210	/* check no prefix. */
1211	bool fNo = false;
1212	char ch;
1213	while ((ch = *pszVar) != '\0')
1214	{
1215	if (ch == 'n' && pszVar[1] == 'o')
1216	{
1217	pszVar += 2;
1218	fNo = !fNo;
1219	}
1220	else if (ch == '+')
1221	{
1222	pszVar++;
1223	fNo = true;
1224	}
1225	else if (ch == '-' \|\| ch == '!' \|\| ch == '~')
1226	{
1227	pszVar++;
1228	fNo = !fNo;
1229	}
1230	else
1231	break;
1232	}
1233
1234	/* instruction. */
1235	unsigned i;
1236	for (i = 0; i < ELEMENTS(aDest); i++)
1237	{
1238	if (!strncmp(pszVar, aDest[i].pszInstr, aDest[i].cchInstr))
1239	{
1240	if (fNo == aDest[i].fInverted)
1241	pLogger->fFlags \|= aDest[i].fFlag;
1242	else
1243	pLogger->fFlags &= ~aDest[i].fFlag;
1244	pszVar += aDest[i].cchInstr;
1245	break;
1246	}
1247	}
1248
1249	/* unknown instruction? */
1250	if (i >= ELEMENTS(aDest))
1251	{
1252	AssertMsgFailed(("Invalid flags! unknown instruction %.20s\n", pszVar));
1253	pszVar++;
1254	}
1255
1256	/* skip blanks and delimiters. */
1257	while (isspace(pszVar) \|\| pszVar == '\n' \|\| pszVar == '\r' \|\| pszVar == ';')
1258	pszVar++;
1259	} /* while more environment variable value left */
1260
1261	return rc;
1262	}
1263
1264
1265	/**
1266	* Flushes the specified logger.
1267	*
1268	* @param pLogger The logger instance to flush.
1269	* If NULL the default instance is used. The default instance
1270	* will not be initialized by this call.
1271	*/
1272	RTDECL(void) RTLogFlush(PRTLOGGER pLogger)
1273	{
1274	/*
1275	* Resolve defaults.
1276	*/
1277	if (!pLogger)
1278	{
1279	#ifdef IN_GC
1280	pLogger = &g_Logger;
1281	#else
1282	pLogger = g_pLogger;
1283	#endif
1284	if (!pLogger)
1285	return;
1286	}
1287
1288	/*
1289	* Any thing to flush?
1290	*/
1291	if (pLogger->offScratch)
1292	{
1293	#ifndef IN_GC
1294	/*
1295	* Acquire logger instance sem.
1296	*/
1297	int rc = rtlogLock(pLogger);
1298	if (RT_FAILURE(rc))
1299	return;
1300	#endif
1301	/*
1302	* Call worker.
1303	*/
1304	rtlogFlush(pLogger);
1305
1306	#ifndef IN_GC
1307	/*
1308	* Release the semaphore.
1309	*/
1310	rtlogUnlock(pLogger);
1311	#endif
1312	}
1313	}
1314
1315
1316	/**
1317	* Gets the default logger instance.
1318	*
1319	* @returns Pointer to default logger instance.
1320	* @returns NULL if no default logger instance available.
1321	*/
1322	RTDECL(PRTLOGGER) RTLogDefaultInstance(void)
1323	{
1324	#ifdef IN_GC
1325	return &g_Logger;
1326
1327	#else /* !IN_GC */
1328	# ifdef IN_RING0
1329	/*
1330	* Check per thread loggers first.
1331	*/
1332	if (g_cPerThreadLoggers)
1333	{
1334	const RTNATIVETHREAD Self = RTThreadNativeSelf();
1335	int32_t i = ELEMENTS(g_aPerThreadLoggers);
1336	while (i-- > 0)
1337	if (g_aPerThreadLoggers[i].NativeThread == Self)
1338	return g_aPerThreadLoggers[i].pLogger;
1339	}
1340	# endif /* IN_RING0 */
1341
1342	/*
1343	* If no per thread logger, use the default one.
1344	*/
1345	if (!g_pLogger)
1346	g_pLogger = RTLogDefaultInit();
1347	return g_pLogger;
1348	#endif /* !IN_GC */
1349	}
1350
1351
1352	#ifdef IN_RING0
1353	/**
1354	* Changes the default logger instance for the current thread.
1355	*
1356	* @returns IPRT status code.
1357	* @param pLogger The logger instance. Pass NULL for deregistration.
1358	* @param uKey Associated key for cleanup purposes. If pLogger is NULL,
1359	* all instances with this key will be deregistered. So in
1360	* order to only deregister the instance associated with the
1361	* current thread use 0.
1362	*/
1363	RTDECL(int) RTLogSetDefaultInstanceThread(PRTLOGGER pLogger, uintptr_t uKey)
1364	{
1365	int rc;
1366	RTNATIVETHREAD Self = RTThreadNativeSelf();
1367	if (pLogger)
1368	{
1369	AssertReturn(pLogger->u32Magic == RTLOGGER_MAGIC, VERR_INVALID_MAGIC);
1370
1371	/*
1372	* Iterate the table to see if there is already an entry for this thread.
1373	*/
1374	int32_t i = ELEMENTS(g_aPerThreadLoggers);
1375	while (i-- > 0)
1376	if (g_aPerThreadLoggers[i].NativeThread == Self)
1377	{
1378	ASMAtomicXchgPtr((void * volatile )&g_aPerThreadLoggers[i].uKey, (void )uKey);
1379	g_aPerThreadLoggers[i].pLogger = pLogger;
1380	return VINF_SUCCESS;
1381	}
1382
1383	/*
1384	* Allocate a new table entry.
1385	*/
1386	i = ASMAtomicIncS32(&g_cPerThreadLoggers);
1387	if (i > (int32_t)ELEMENTS(g_aPerThreadLoggers))
1388	{
1389	ASMAtomicDecS32(&g_cPerThreadLoggers);
1390	return VERR_BUFFER_OVERFLOW; /* horrible error code! */
1391	}
1392
1393	for (unsigned j = 0; j < 10; j++)
1394	{
1395	i = ELEMENTS(g_aPerThreadLoggers);
1396	while (i-- > 0)
1397	{
1398	AssertCompile(sizeof(RTNATIVETHREAD) == sizeof(void*));
1399	if ( g_aPerThreadLoggers[i].NativeThread == NIL_RTNATIVETHREAD
1400	&& ASMAtomicCmpXchgPtr((void * volatile )&g_aPerThreadLoggers[i].NativeThread, (void )Self, (void *)NIL_RTNATIVETHREAD))
1401	{
1402	ASMAtomicXchgPtr((void * volatile )&g_aPerThreadLoggers[i].uKey, (void )uKey);
1403	ASMAtomicXchgPtr((void * volatile *)&g_aPerThreadLoggers[i].pLogger, pLogger);
1404	return VINF_SUCCESS;
1405	}
1406	}
1407	}
1408
1409	ASMAtomicDecS32(&g_cPerThreadLoggers);
1410	rc = VERR_INTERNAL_ERROR;
1411	}
1412	else
1413	{
1414	/*
1415	* Search the array for the current thread.
1416	*/
1417	int32_t i = ELEMENTS(g_aPerThreadLoggers);
1418	while (i-- > 0)
1419	if ( g_aPerThreadLoggers[i].NativeThread == Self
1420	\|\| g_aPerThreadLoggers[i].uKey == uKey)
1421	{
1422	ASMAtomicXchgPtr((void * volatile *)&g_aPerThreadLoggers[i].uKey, NULL);
1423	ASMAtomicXchgPtr((void * volatile *)&g_aPerThreadLoggers[i].pLogger, NULL);
1424	ASMAtomicXchgPtr((void * volatile )&g_aPerThreadLoggers[i].NativeThread, (void )NIL_RTNATIVETHREAD);
1425	ASMAtomicDecS32(&g_cPerThreadLoggers);
1426	}
1427
1428	rc = VINF_SUCCESS;
1429	}
1430	return rc;
1431	}
1432	#endif
1433
1434
1435	/**
1436	* Gets the default release logger instance.
1437	*
1438	* @returns Pointer to default release logger instance.
1439	* @returns NULL if no default release logger instance available.
1440	*/
1441	RTDECL(PRTLOGGER) RTLogRelDefaultInstance(void)
1442	{
1443	#ifdef IN_GC
1444	return &g_RelLogger;
1445	#else /* !IN_GC */
1446	return g_pRelLogger;
1447	#endif /* !IN_GC */
1448	}
1449
1450
1451	#ifndef IN_GC
1452	/**
1453	* Sets the default logger instance.
1454	*
1455	* @returns iprt status code.
1456	* @param pLogger The new default release logger instance.
1457	*/
1458	RTDECL(PRTLOGGER) RTLogRelSetDefaultInstance(PRTLOGGER pLogger)
1459	{
1460	return (PRTLOGGER)ASMAtomicXchgPtr((void * volatile *)&g_pRelLogger, pLogger);
1461	}
1462	#endif /* !IN_GC */
1463
1464
1465	/**
1466	* Write to a logger instance.
1467	*
1468	* @param pLogger Pointer to logger instance.
1469	* @param pvCallerRet Ignored.
1470	* @param pszFormat Format string.
1471	* @param ... Format arguments.
1472	*/
1473	RTDECL(void) RTLogLogger(PRTLOGGER pLogger, void pvCallerRet, const char pszFormat, ...)
1474	{
1475	va_list args;
1476	va_start(args, pszFormat);
1477	#if defined(RT_OS_DARWIN) && defined(RT_ARCH_X86) && defined(IN_RING3)
1478	/* manually align the stack before doing the call.
1479	* We boldly assume that there is a stack frame here! */
1480	__asm__ __volatile__("andl $-32, %%esp\t\n" ::: "%esp");
1481	RTLogLoggerExV(pLogger, 0, ~0U, pszFormat, args);
1482	#else
1483	RTLogLoggerExV(pLogger, 0, ~0U, pszFormat, args);
1484	#endif
1485	va_end(args);
1486	}
1487
1488
1489	/**
1490	* Write to a logger instance.
1491	*
1492	* @param pLogger Pointer to logger instance.
1493	* @param pszFormat Format string.
1494	* @param args Format arguments.
1495	*/
1496	RTDECL(void) RTLogLoggerV(PRTLOGGER pLogger, const char *pszFormat, va_list args)
1497	{
1498	RTLogLoggerExV(pLogger, 0, ~0U, pszFormat, args);
1499	}
1500
1501
1502	/**
1503	* Write to a logger instance.
1504	*
1505	* This function will check whether the instance, group and flags makes up a
1506	* logging kind which is currently enabled before writing anything to the log.
1507	*
1508	* @param pLogger Pointer to logger instance. If NULL the default logger instance will be attempted.
1509	* @param fFlags The logging flags.
1510	* @param iGroup The group.
1511	* The value ~0U is reserved for compatability with RTLogLogger[V] and is
1512	* only for internal usage!
1513	* @param pszFormat Format string.
1514	* @param ... Format arguments.
1515	* @remark This is a worker function of LogIt.
1516	*/
1517	RTDECL(void) RTLogLoggerEx(PRTLOGGER pLogger, unsigned fFlags, unsigned iGroup, const char *pszFormat, ...)
1518	{
1519	va_list args;
1520	va_start(args, pszFormat);
1521	RTLogLoggerExV(pLogger, fFlags, iGroup, pszFormat, args);
1522	va_end(args);
1523	}
1524
1525
1526	/**
1527	* Write to a logger instance.
1528	*
1529	* This function will check whether the instance, group and flags makes up a
1530	* logging kind which is currently enabled before writing anything to the log.
1531	*
1532	* @param pLogger Pointer to logger instance. If NULL the default logger instance will be attempted.
1533	* @param fFlags The logging flags.
1534	* @param iGroup The group.
1535	* The value ~0U is reserved for compatability with RTLogLogger[V] and is
1536	* only for internal usage!
1537	* @param pszFormat Format string.
1538	* @param args Format arguments.
1539	*/
1540	RTDECL(void) RTLogLoggerExV(PRTLOGGER pLogger, unsigned fFlags, unsigned iGroup, const char *pszFormat, va_list args)
1541	{
1542	/*
1543	* A NULL logger means default instance.
1544	*/
1545	if (!pLogger)
1546	{
1547	pLogger = RTLogDefaultInstance();
1548	if (!pLogger)
1549	return;
1550	}
1551	rtlogLogger(pLogger, fFlags, iGroup, pszFormat, args);
1552	}
1553
1554
1555	/**
1556	* Write to a logger instance, defaulting to the release one.
1557	*
1558	* This function will check whether the instance, group and flags makes up a
1559	* logging kind which is currently enabled before writing anything to the log.
1560	*
1561	* @param pLogger Pointer to logger instance.
1562	* @param fFlags The logging flags.
1563	* @param iGroup The group.
1564	* The value ~0U is reserved for compatability with RTLogLogger[V] and is
1565	* only for internal usage!
1566	* @param pszFormat Format string.
1567	* @param ... Format arguments.
1568	* @remark This is a worker function for LogRelIt.
1569	*/
1570	RTDECL(void) RTLogRelLogger(PRTLOGGER pLogger, unsigned fFlags, unsigned iGroup, const char *pszFormat, ...)
1571	{
1572	va_list args;
1573	va_start(args, pszFormat);
1574	RTLogRelLoggerV(pLogger, fFlags, iGroup, pszFormat, args);
1575	va_end(args);
1576	}
1577
1578
1579	/**
1580	* Write to a logger instance, defaulting to the release one.
1581	*
1582	* This function will check whether the instance, group and flags makes up a
1583	* logging kind which is currently enabled before writing anything to the log.
1584	*
1585	* @param pLogger Pointer to logger instance. If NULL the default release instance is attempted.
1586	* @param fFlags The logging flags.
1587	* @param iGroup The group.
1588	* The value ~0U is reserved for compatability with RTLogLogger[V] and is
1589	* only for internal usage!
1590	* @param pszFormat Format string.
1591	* @param args Format arguments.
1592	*/
1593	RTDECL(void) RTLogRelLoggerV(PRTLOGGER pLogger, unsigned fFlags, unsigned iGroup, const char *pszFormat, va_list args)
1594	{
1595	/*
1596	* A NULL logger means default instance.
1597	*/
1598	if (!pLogger)
1599	{
1600	pLogger = RTLogRelDefaultInstance();
1601	if (!pLogger)
1602	return;
1603	}
1604	rtlogLogger(pLogger, fFlags, iGroup, pszFormat, args);
1605	}
1606
1607
1608	/**
1609	* Worker for the RTLog[Rel]Logger*() functions.
1610	*
1611	* @param pLogger Pointer to logger instance.
1612	* @param fFlags The logging flags.
1613	* @param iGroup The group.
1614	* The value ~0U is reserved for compatability with RTLogLogger[V] and is
1615	* only for internal usage!
1616	* @param pszFormat Format string.
1617	* @param args Format arguments.
1618	*/
1619	static void rtlogLogger(PRTLOGGER pLogger, unsigned fFlags, unsigned iGroup, const char *pszFormat, va_list args)
1620	{
1621	/*
1622	* Validate and correct iGroup.
1623	*/
1624	if (iGroup != ~0U && iGroup >= pLogger->cGroups)
1625	iGroup = 0;
1626
1627	/*
1628	* If no output, then just skip it.
1629	*/
1630	if ( (pLogger->fFlags & RTLOGFLAGS_DISABLED)
1631	#ifndef IN_GC
1632	\|\| !pLogger->fDestFlags
1633	#endif
1634	\|\| !pszFormat \|\| !*pszFormat)
1635	return;
1636	if ( iGroup != ~0U
1637	&& (pLogger->afGroups[iGroup] & (fFlags \| RTLOGGRPFLAGS_ENABLED)) != (fFlags \| RTLOGGRPFLAGS_ENABLED))
1638	return;
1639
1640	/*
1641	* Acquire logger instance sem.
1642	*/
1643	int rc = rtlogLock(pLogger);
1644	if (RT_FAILURE(rc))
1645	return;
1646
1647	/*
1648	* Format the message and perhaps flush it.
1649	*/
1650	if (pLogger->fFlags & (RTLOGFLAGS_PREFIX_MASK \| RTLOGFLAGS_USECRLF))
1651	{
1652	RTLOGOUTPUTPREFIXEDARGS OutputArgs;
1653	OutputArgs.pLogger = pLogger;
1654	OutputArgs.iGroup = iGroup;
1655	OutputArgs.fFlags = fFlags;
1656	RTLogFormatV(rtLogOutputPrefixed, &OutputArgs, pszFormat, args);
1657	}
1658	else
1659	RTLogFormatV(rtLogOutput, pLogger, pszFormat, args);
1660	if ( !(pLogger->fFlags & RTLOGFLAGS_BUFFERED)
1661	&& pLogger->offScratch)
1662	rtlogFlush(pLogger);
1663
1664	/*
1665	* Release the semaphore.
1666	*/
1667	rtlogUnlock(pLogger);
1668	}
1669
1670
1671	/**
1672	* printf like function for writing to the default log.
1673	*
1674	* @param pszFormat Printf like format string.
1675	* @param ... Optional arguments as specified in pszFormat.
1676	*
1677	* @remark The API doesn't support formatting of floating point numbers at the moment.
1678	*/
1679	RTDECL(void) RTLogPrintf(const char *pszFormat, ...)
1680	{
1681	va_list args;
1682	va_start(args, pszFormat);
1683	RTLogPrintfV(pszFormat, args);
1684	va_end(args);
1685	}
1686
1687
1688	/**
1689	* vprintf like function for writing to the default log.
1690	*
1691	* @param pszFormat Printf like format string.
1692	* @param args Optional arguments as specified in pszFormat.
1693	*
1694	* @remark The API doesn't support formatting of floating point numbers at the moment.
1695	*/
1696	RTDECL(void) RTLogPrintfV(const char *pszFormat, va_list args)
1697	{
1698	RTLogLoggerV(NULL, pszFormat, args);
1699	}
1700
1701
1702	/**
1703	* printf like function for writing to the default release log.
1704	*
1705	* @param pszFormat Printf like format string.
1706	* @param ... Optional arguments as specified in pszFormat.
1707	*
1708	* @remark The API doesn't support formatting of floating point numbers at the moment.
1709	*/
1710	RTDECL(void) RTLogRelPrintf(const char *pszFormat, ...)
1711	{
1712	va_list args;
1713	va_start(args, pszFormat);
1714	RTLogRelPrintfV(pszFormat, args);
1715	va_end(args);
1716	}
1717
1718
1719	/**
1720	* vprintf like function for writing to the default release log.
1721	*
1722	* @param pszFormat Printf like format string.
1723	* @param args Optional arguments as specified in pszFormat.
1724	*
1725	* @remark The API doesn't support formatting of floating point numbers at the moment.
1726	*/
1727	RTDECL(void) RTLogRelPrintfV(const char *pszFormat, va_list args)
1728	{
1729	RTLogRelLoggerV(NULL, 0, ~0U, pszFormat, args);
1730	}
1731
1732
1733	/**
1734	* Writes the buffer to the given log device without checking for buffered
1735	* data or anything.
1736	* Used by the RTLogFlush() function.
1737	*
1738	* @param pLogger The logger instance to write to. NULL is not allowed!
1739	*/
1740	static void rtlogFlush(PRTLOGGER pLogger)
1741	{
1742	#ifndef IN_GC
1743	if (pLogger->fDestFlags & RTLOGDEST_USER)
1744	RTLogWriteUser(pLogger->achScratch, pLogger->offScratch);
1745
1746	if (pLogger->fDestFlags & RTLOGDEST_DEBUGGER)
1747	RTLogWriteDebugger(pLogger->achScratch, pLogger->offScratch);
1748
1749	# ifdef IN_RING3
1750	if (pLogger->fDestFlags & RTLOGDEST_FILE)
1751	RTFileWrite(pLogger->File, pLogger->achScratch, pLogger->offScratch, NULL);
1752	# endif
1753
1754	if (pLogger->fDestFlags & RTLOGDEST_STDOUT)
1755	RTLogWriteStdOut(pLogger->achScratch, pLogger->offScratch);
1756
1757	if (pLogger->fDestFlags & RTLOGDEST_STDERR)
1758	RTLogWriteStdErr(pLogger->achScratch, pLogger->offScratch);
1759
1760	# if (defined(IN_RING0) \|\| defined(IN_GC)) && !defined(LOG_NO_COM)
1761	if (pLogger->fDestFlags & RTLOGDEST_COM)
1762	RTLogWriteCom(pLogger->achScratch, pLogger->offScratch);
1763	# endif
1764	#endif /* !IN_GC */
1765
1766	if (pLogger->pfnFlush)
1767	pLogger->pfnFlush(pLogger);
1768
1769	/* empty the buffer. */
1770	pLogger->offScratch = 0;
1771	}
1772
1773
1774	/**
1775	* Callback for RTLogFormatV which writes to the com port.
1776	* See PFNLOGOUTPUT() for details.
1777	*/
1778	static DECLCALLBACK(size_t) rtLogOutput(void pv, const char pachChars, size_t cbChars)
1779	{
1780	PRTLOGGER pLogger = (PRTLOGGER)pv;
1781	if (cbChars)
1782	{
1783	size_t cbRet = 0;
1784	for (;;)
1785	{
1786	#if defined(DEBUG) && defined(IN_RING3)
1787	/* sanity */
1788	if (pLogger->offScratch >= sizeof(pLogger->achScratch))
1789	{
1790	fprintf(stderr, "pLogger->offScratch >= sizeof(pLogger->achScratch) (%#x >= %#x)\n",
1791	pLogger->offScratch, (unsigned)sizeof(pLogger->achScratch));
1792	AssertBreakpoint(); AssertBreakpoint();
1793	}
1794	#endif
1795
1796	/* how much */
1797	size_t cb = sizeof(pLogger->achScratch) - pLogger->offScratch - 1;
1798	if (cb > cbChars)
1799	cb = cbChars;
1800
1801	/* copy */
1802	memcpy(&pLogger->achScratch[pLogger->offScratch], pachChars, cb);
1803
1804	/* advance */
1805	pLogger->offScratch += cb;
1806	cbRet += cb;
1807	cbChars -= cb;
1808
1809	/* done? */
1810	if (cbChars <= 0)
1811	return cbRet;
1812
1813	pachChars += cb;
1814
1815	/* flush */
1816	rtlogFlush(pLogger);
1817	}
1818
1819	/* won't ever get here! */
1820	}
1821	else
1822	{
1823	/*
1824	* Termination call.
1825	* There's always space for a terminator, and it's not counted.
1826	*/
1827	pLogger->achScratch[pLogger->offScratch] = '\0';
1828	return 0;
1829	}
1830	}
1831
1832
1833
1834	/**
1835	* Callback for RTLogFormatV which writes to the logger instance.
1836	* This version supports prefixes.
1837	*
1838	* See PFNLOGOUTPUT() for details.
1839	*/
1840	static DECLCALLBACK(size_t) rtLogOutputPrefixed(void pv, const char pachChars, size_t cbChars)
1841	{
1842	PRTLOGOUTPUTPREFIXEDARGS pArgs = (PRTLOGOUTPUTPREFIXEDARGS)pv;
1843	PRTLOGGER pLogger = pArgs->pLogger;
1844	if (cbChars)
1845	{
1846	size_t cbRet = 0;
1847	for (;;)
1848	{
1849	size_t cb = sizeof(pLogger->achScratch) - pLogger->offScratch - 1;
1850
1851	/*
1852	* Pending prefix?
1853	*/
1854	if (pLogger->fPendingPrefix)
1855	{
1856	pLogger->fPendingPrefix = false;
1857
1858	#if defined(DEBUG) && defined(IN_RING3)
1859	/* sanity */
1860	if (pLogger->offScratch >= sizeof(pLogger->achScratch))
1861	{
1862	fprintf(stderr, "pLogger->offScratch >= sizeof(pLogger->achScratch) (%#x >= %#x)\n",
1863	pLogger->offScratch, (unsigned)sizeof(pLogger->achScratch));
1864	AssertBreakpoint(); AssertBreakpoint();
1865	}
1866	#endif
1867
1868	/*
1869	* Flush the buffer if there isn't enough room for the maximum prefix config.
1870	* Max is 124, add a couple of extra bytes.
1871	*/
1872	if (cb < 128 + 18 + 22)
1873	{
1874	rtlogFlush(pLogger);
1875	cb = sizeof(pLogger->achScratch) - pLogger->offScratch - 1;
1876	}
1877
1878	/*
1879	* Write the prefixes.
1880	* psz is pointing to the current position.
1881	*/
1882	char *psz = &pLogger->achScratch[pLogger->offScratch];
1883	if (pLogger->fFlags & RTLOGFLAGS_PREFIX_TS)
1884	{
1885	#if defined(IN_RING3) \|\| defined(IN_GC)
1886	uint64_t u64 = RTTimeNanoTS();
1887	#else
1888	uint64_t u64 = ~0;
1889	#endif
1890	int iBase = 16;
1891	unsigned int fFlags = RTSTR_F_ZEROPAD;
1892	if (pLogger->fFlags & RTLOGFLAGS_DECIMAL_TS)
1893	{
1894	iBase = 10;
1895	fFlags = 0;
1896	}
1897	if (pLogger->fFlags & RTLOGFLAGS_REL_TS)
1898	{
1899	static uint64_t s_u64LastTs;
1900	uint64_t u64DiffTs = u64 - s_u64LastTs;
1901	s_u64LastTs = u64;
1902	/* We could have been preempted just before reading of s_u64LastTs by
1903	* another thread which wrote s_u64LastTs. In that case the difference
1904	* is negative which we simply ignore. */
1905	u64 = (int64_t)u64DiffTs < 0 ? 0 : u64DiffTs;
1906	}
1907	/* 1E15 nanoseconds = 11 days */
1908	psz += RTStrFormatNumber(psz, u64, iBase, 16, 0, fFlags);
1909	*psz++ = ' ';
1910	}
1911	if (pLogger->fFlags & RTLOGFLAGS_PREFIX_TSC)
1912	{
1913	uint64_t u64 = ASMReadTSC();
1914	int iBase = 16;
1915	unsigned int fFlags = RTSTR_F_ZEROPAD;
1916	if (pLogger->fFlags & RTLOGFLAGS_DECIMAL_TS)
1917	{
1918	iBase = 10;
1919	fFlags = 0;
1920	}
1921	if (pLogger->fFlags & RTLOGFLAGS_REL_TS)
1922	{
1923	static uint64_t s_u64LastTsc;
1924	uint64_t u64DiffTsc = u64 - s_u64LastTsc;
1925	s_u64LastTsc = u64;
1926	/* We could have been preempted just before reading of s_u64LastTsc by
1927	* another thread which wrote s_u64LastTsc. In that case the difference
1928	* is negative which we simply ignore. */
1929	u64 = u64DiffTsc < 0 ? 0 : u64DiffTsc;
1930	}
1931	/* 1E15 ticks at 4GHz = 69 hours */
1932	psz += RTStrFormatNumber(psz, u64, iBase, 16, 0, fFlags);
1933	*psz++ = ' ';
1934	}
1935	if (pLogger->fFlags & RTLOGFLAGS_PREFIX_MS_PROG)
1936	{
1937	#if defined(IN_RING3) \|\| defined(IN_GC)
1938	uint64_t u64 = RTTimeProgramMilliTS();
1939	#else
1940	uint64_t u64 = 0;
1941	#endif
1942	/* 1E8 milliseconds = 27 hours */
1943	psz += RTStrFormatNumber(psz, u64, 10, 9, 0, RTSTR_F_ZEROPAD);
1944	*psz++ = ' ';
1945	}
1946	if (pLogger->fFlags & RTLOGFLAGS_PREFIX_TIME)
1947	{
1948	#ifdef IN_RING3
1949	RTTIMESPEC TimeSpec;
1950	RTTIME Time;
1951	RTTimeExplode(&Time, RTTimeNow(&TimeSpec));
1952	psz += RTStrFormatNumber(psz, Time.u8Hour, 10, 2, 0, RTSTR_F_ZEROPAD);
1953	*psz++ = ':';
1954	psz += RTStrFormatNumber(psz, Time.u8Minute, 10, 2, 0, RTSTR_F_ZEROPAD);
1955	*psz++ = ':';
1956	psz += RTStrFormatNumber(psz, Time.u8Second, 10, 2, 0, RTSTR_F_ZEROPAD);
1957	*psz++ = '.';
1958	psz += RTStrFormatNumber(psz, Time.u32Nanosecond / 1000000, 10, 3, 0, RTSTR_F_ZEROPAD);
1959	*psz++ = ' ';
1960	#else
1961	memset(psz, ' ', 13);
1962	psz += 13;
1963	#endif
1964	}
1965	if (pLogger->fFlags & RTLOGFLAGS_PREFIX_TIME_PROG)
1966	{
1967	#ifdef IN_RING3
1968	uint64_t u64 = RTTimeProgramMilliTS();
1969	psz += RTStrFormatNumber(psz, (uint32_t)(u64 / (60 * 60 * 1000)), 10, 2, 0, RTSTR_F_ZEROPAD);
1970	*psz++ = ':';
1971	uint32_t u32 = (uint32_t)(u64 % (60 * 60 * 1000));
1972	psz += RTStrFormatNumber(psz, u32 / (60 * 1000), 10, 2, 0, RTSTR_F_ZEROPAD);
1973	*psz++ = ':';
1974	u32 %= 60 * 1000;
1975	psz += RTStrFormatNumber(psz, u32 / 1000, 10, 2, 0, RTSTR_F_ZEROPAD);
1976	*psz++ = '.';
1977	psz += RTStrFormatNumber(psz, u32 % 1000, 10, 3, 0, RTSTR_F_ZEROPAD);
1978	*psz++ = ' ';
1979	#else
1980	memset(psz, ' ', 13);
1981	psz += 13;
1982	#endif
1983	}
1984	# if 0
1985	if (pLogger->fFlags & RTLOGFLAGS_PREFIX_DATETIME)
1986	{
1987	char szDate[32];
1988	RTTIMESPEC Time;
1989	RTTimeSpecToString(RTTimeNow(&Time), szDate, sizeof(szDate));
1990	size_t cch = strlen(szDate);
1991	memcpy(psz, szDate, cch);
1992	psz += cch;
1993	*psz++ = ' ';
1994	}
1995	# endif
1996	if (pLogger->fFlags & RTLOGFLAGS_PREFIX_TID)
1997	{
1998	#ifdef IN_RING3
1999	RTNATIVETHREAD Thread = RTThreadNativeSelf();
2000	#else
2001	RTNATIVETHREAD Thread = NIL_RTNATIVETHREAD;
2002	#endif
2003	psz += RTStrFormatNumber(psz, Thread, 16, sizeof(RTNATIVETHREAD) * 2, 0, RTSTR_F_ZEROPAD);
2004	*psz++ = ' ';
2005	}
2006	if (pLogger->fFlags & RTLOGFLAGS_PREFIX_THREAD)
2007	{
2008	#ifdef IN_RING3
2009	const char *pszName = RTThreadSelfName();
2010	#elif defined IN_GC
2011	const char *pszName = "EMT-GC";
2012	#else
2013	const char *pszName = "EMT-R0";
2014	#endif
2015	size_t cch = 0;
2016	if (pszName)
2017	{
2018	cch = strlen(pszName);
2019	cch = RT_MIN(cch, 16);
2020	memcpy(psz, pszName, cch);
2021	psz += cch;
2022	}
2023	do
2024	*psz++ = ' ';
2025	while (cch++ < 8);
2026	}
2027	if (pLogger->fFlags & RTLOGFLAGS_PREFIX_FLAG_NO)
2028	{
2029	psz += RTStrFormatNumber(psz, pArgs->fFlags, 16, 8, 0, RTSTR_F_ZEROPAD);
2030	*psz++ = ' ';
2031	}
2032	if (pLogger->fFlags & RTLOGFLAGS_PREFIX_FLAG)
2033	{
2034	#ifdef IN_RING3
2035	const char *pszGroup = pArgs->iGroup != ~0U ? pLogger->papszGroups[pArgs->iGroup] : NULL;
2036	#else
2037	const char *pszGroup = NULL;
2038	#endif
2039	size_t cch = 0;
2040	if (pszGroup)
2041	{
2042	cch = strlen(pszGroup);
2043	cch = RT_MIN(cch, 16);
2044	memcpy(psz, pszGroup, cch);
2045	psz += cch;
2046	}
2047	do
2048	*psz++ = ' ';
2049	while (cch++ < 8);
2050	}
2051	if (pLogger->fFlags & RTLOGFLAGS_PREFIX_GROUP_NO)
2052	{
2053	if (pArgs->iGroup != ~0U)
2054	{
2055	psz += RTStrFormatNumber(psz, pArgs->iGroup, 16, 3, 0, RTSTR_F_ZEROPAD);
2056	*psz++ = ' ';
2057	}
2058	else
2059	{
2060	memcpy(psz, "-1 ", sizeof("-1 ") - 1);
2061	psz += sizeof("-1 ") - 1;
2062	}
2063	}
2064	if (pLogger->fFlags & RTLOGFLAGS_PREFIX_GROUP)
2065	{
2066	const unsigned fGrp = pLogger->afGroups[pArgs->iGroup != ~0U ? pArgs->iGroup : 0];
2067	const char *pszGroup;
2068	size_t cch;
2069	switch (pArgs->fFlags & fGrp)
2070	{
2071	case 0: pszGroup = "--------"; cch = sizeof("--------") - 1; break;
2072	case RTLOGGRPFLAGS_ENABLED: pszGroup = "enabled" ; cch = sizeof("enabled" ) - 1; break;
2073	case RTLOGGRPFLAGS_LEVEL_1: pszGroup = "level 1" ; cch = sizeof("level 1" ) - 1; break;
2074	case RTLOGGRPFLAGS_LEVEL_2: pszGroup = "level 2" ; cch = sizeof("level 2" ) - 1; break;
2075	case RTLOGGRPFLAGS_LEVEL_3: pszGroup = "level 3" ; cch = sizeof("level 3" ) - 1; break;
2076	case RTLOGGRPFLAGS_LEVEL_4: pszGroup = "level 4" ; cch = sizeof("level 4" ) - 1; break;
2077	case RTLOGGRPFLAGS_LEVEL_5: pszGroup = "level 5" ; cch = sizeof("level 5" ) - 1; break;
2078	case RTLOGGRPFLAGS_LEVEL_6: pszGroup = "level 6" ; cch = sizeof("level 6" ) - 1; break;
2079	case RTLOGGRPFLAGS_FLOW: pszGroup = "flow" ; cch = sizeof("flow" ) - 1; break;
2080
2081	/* personal groups */
2082	case RTLOGGRPFLAGS_LELIK: pszGroup = "lelik" ; cch = sizeof("lelik" ) - 1; break;
2083	case RTLOGGRPFLAGS_MICHAEL: pszGroup = "Michael" ; cch = sizeof("Michael" ) - 1; break;
2084	case RTLOGGRPFLAGS_DMIK: pszGroup = "dmik" ; cch = sizeof("dmik" ) - 1; break;
2085	case RTLOGGRPFLAGS_SUNLOVER: pszGroup = "sunlover"; cch = sizeof("sunlover") - 1; break;
2086	case RTLOGGRPFLAGS_ACHIM: pszGroup = "Achim" ; cch = sizeof("Achim" ) - 1; break;
2087	case RTLOGGRPFLAGS_SANDER: pszGroup = "Sander" ; cch = sizeof("Sander" ) - 1; break;
2088	case RTLOGGRPFLAGS_KLAUS: pszGroup = "Klaus" ; cch = sizeof("Klaus" ) - 1; break;
2089	case RTLOGGRPFLAGS_FRANK: pszGroup = "Frank" ; cch = sizeof("Frank" ) - 1; break;
2090	case RTLOGGRPFLAGS_BIRD: pszGroup = "bird" ; cch = sizeof("bird" ) - 1; break;
2091	case RTLOGGRPFLAGS_NONAME: pszGroup = "noname" ; cch = sizeof("noname" ) - 1; break;
2092	default: pszGroup = "????????"; cch = sizeof("????????") - 1; break;
2093	}
2094	if (pszGroup)
2095	{
2096	cch = RT_MIN(cch, 16);
2097	memcpy(psz, pszGroup, cch);
2098	psz += cch;
2099	}
2100	do
2101	*psz++ = ' ';
2102	while (cch++ < 8);
2103	}
2104
2105	/*
2106	* Done, figure what we've used and advance the buffer and free size.
2107	*/
2108	cb = psz - &pLogger->achScratch[pLogger->offScratch];
2109	Assert(cb <= 124);
2110	pLogger->offScratch += cb;
2111	cb = sizeof(pLogger->achScratch) - pLogger->offScratch - 1;
2112	}
2113	else if (cb <= 0)
2114	{
2115	rtlogFlush(pLogger);
2116	cb = sizeof(pLogger->achScratch) - pLogger->offScratch - 1;
2117	}
2118
2119	#if defined(DEBUG) && defined(IN_RING3)
2120	/* sanity */
2121	if (pLogger->offScratch >= sizeof(pLogger->achScratch))
2122	{
2123	fprintf(stderr, "pLogger->offScratch >= sizeof(pLogger->achScratch) (%#x >= %#x)\n",
2124	pLogger->offScratch, (unsigned)sizeof(pLogger->achScratch));
2125	AssertBreakpoint(); AssertBreakpoint();
2126	}
2127	#endif
2128
2129	/* how much */
2130	if (cb > cbChars)
2131	cb = cbChars;
2132
2133	/* have newline? */
2134	const char pszNewLine = (const char )memchr(pachChars, '\n', cb);
2135	if (pszNewLine)
2136	{
2137	if (pLogger->fFlags & RTLOGFLAGS_USECRLF)
2138	cb = pszNewLine - pachChars;
2139	else
2140	{
2141	cb = pszNewLine - pachChars + 1;
2142	pLogger->fPendingPrefix = true;
2143	}
2144	}
2145
2146	/* copy */
2147	memcpy(&pLogger->achScratch[pLogger->offScratch], pachChars, cb);
2148
2149	/* advance */
2150	pLogger->offScratch += cb;
2151	cbRet += cb;
2152	cbChars -= cb;
2153
2154	if ( pszNewLine
2155	&& (pLogger->fFlags & RTLOGFLAGS_USECRLF)
2156	&& pLogger->offScratch + 2 < sizeof(pLogger->achScratch))
2157	{
2158	memcpy(&pLogger->achScratch[pLogger->offScratch], "\r\n", 2);
2159	pLogger->offScratch += 2;
2160	cbRet++;
2161	cbChars--;
2162	cb++;
2163	pLogger->fPendingPrefix = true;
2164	}
2165
2166	/* done? */
2167	if (cbChars <= 0)
2168	return cbRet;
2169	pachChars += cb;
2170	}
2171
2172	/* won't ever get here! */
2173	}
2174	else
2175	{
2176	/*
2177	* Termination call.
2178	* There's always space for a terminator, and it's not counted.
2179	*/
2180	pLogger->achScratch[pLogger->offScratch] = '\0';
2181	return 0;
2182	}
2183	}
2184

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

source: vbox/trunk/src/VBox/Runtime/log.cpp@ 4953

Download in other formats: