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