VirtualBox

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

Last change on this file since 76553 was 76553, checked in by vboxsync, 5 years ago

scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 28.1 KB
Line 
1/* $Id: log-vbox.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2/** @file
3 * VirtualBox Runtime - Logging configuration.
4 */
5
6/*
7 * Copyright (C) 2006-2019 Oracle Corporation
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 (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27/** @page pg_rtlog Runtime - Logging
28 *
29 * VBox uses the IPRT logging system which supports group level flags and multiple
30 * destinations. The GC logging is making it even more interesting since GC logging will
31 * have to be buffered and written when back in host context.
32 *
33 * [more later]
34 *
35 *
36 * @section sec_logging_destination The Destination Specifier.
37 *
38 * The {logger-env-base}_DEST environment variable can be used to specify where
39 * the log output goes. The following specifiers are recognized:
40 *
41 * - file=\<filename\>
42 * This sets the logger output filename to \<filename\>. Not formatting
43 * or anything is supported. Each logger specifies a default name if
44 * file logging should be enabled by default.
45 *
46 * - nofile
47 * This disables the file output.
48 *
49 * - stdout
50 * Enables logger output to stdout.
51 *
52 * - nostdout
53 * Disables logger output to stdout.
54 *
55 * - stderr
56 * Enables logger output to stderr.
57 *
58 * - nostderr
59 * Disables logger output to stderr.
60 *
61 * - debugger
62 * Enables logger output to native debugger. (Win32/64 only)
63 *
64 * - nodebugger
65 * Disables logger output to native debugger. (Win32/64 only)
66 *
67 * - user
68 * Enables logger output to special backdoor if in guest r0.
69 *
70 * - nodebugger
71 * Disables logger output to special user stream.
72 *
73 *
74 *
75 * @section sec_logging_group The Group Specifier.
76 *
77 * The {logger-env-base} environment variable can be used to specify which
78 * logger groups to enable and which to disable. By default all groups are
79 * disabled. For your convenience this specifier is case in-sensitive (ASCII).
80 *
81 * The specifier is evaluated from left to right.
82 *
83 * [more later]
84 *
85 * The groups settings can be reprogrammed during execution using the
86 * RTLogGroupSettings() command and a group specifier.
87 *
88 *
89 *
90 * @section sec_logging_default The Default Logger
91 *
92 * The default logger uses VBOX_LOG_DEST as destination specifier. File output is
93 * enabled by default and goes to a file "./VBox-\<pid\>.log".
94 *
95 * The default logger have all groups turned off by default to force the developer
96 * to be careful with what log information to collect - logging everything is
97 * generally NOT a good idea.
98 *
99 * The log groups of the default logger can be found in the LOGGROUP in enum. The
100 * VBOX_LOG environment variable and the .log debugger command can be used to
101 * configure the groups.
102 *
103 * Each group have flags in addition to the enable/disable flag. These flags can
104 * be appended to the group name using dot separators. The flags correspond to
105 * RTLOGGRPFLAGS and have a short and a long version:
106 *
107 * - e - Enabled: Whether the group is enabled at all.
108 * - l - Level2: Level-2 logging.
109 * - f - Flow: Execution flow logging (entry messages)
110 * - s - Sander: Special Sander logging messages.
111 * - b - Bird: Special Bird logging messages.
112 *
113 * @todo Update this section...
114 *
115 * Example:
116 *
117 * VBOX_LOG=+all+pgm.e.s.b.z.l-qemu
118 *
119 * Space and ';' separators are allowed:
120 *
121 * VBOX_LOG=+all +pgm.e.s.b.z.l ; - qemu
122 *
123 */
124
125
126/*********************************************************************************************************************************
127* Header Files *
128*********************************************************************************************************************************/
129#ifdef IN_RING3
130# if defined(RT_OS_WINDOWS)
131# include <iprt/win/windows.h>
132# elif defined(RT_OS_LINUX)
133# include <unistd.h>
134# elif defined(RT_OS_FREEBSD) || defined(RT_OS_NETBSD)
135# include <sys/param.h>
136# include <sys/sysctl.h>
137# if defined(RT_OS_FREEBSD)
138# include <sys/user.h>
139# endif
140# include <stdlib.h>
141# include <unistd.h>
142# elif defined(RT_OS_HAIKU)
143# include <OS.h>
144# elif defined(RT_OS_SOLARIS)
145# define _STRUCTURED_PROC 1
146# undef _FILE_OFFSET_BITS /* procfs doesn't like this */
147# include <sys/procfs.h>
148# include <unistd.h>
149# elif defined(RT_OS_OS2)
150# include <stdlib.h>
151# endif
152#endif
153
154#include <VBox/log.h>
155#include <iprt/asm.h>
156#include <iprt/errcore.h>
157#include <iprt/time.h>
158#ifdef IN_RING3
159# include <iprt/param.h>
160# include <iprt/assert.h>
161# include <iprt/path.h>
162# include <iprt/process.h>
163# include <iprt/string.h>
164# include <iprt/mem.h>
165# include <stdio.h>
166#endif
167#if defined(IN_RING0) && defined(RT_OS_DARWIN)
168# include <iprt/asm-amd64-x86.h>
169# include <iprt/thread.h>
170#endif
171
172
173/*********************************************************************************************************************************
174* Global Variables *
175*********************************************************************************************************************************/
176/** The default logger. */
177static PRTLOGGER g_pLogger = NULL;
178/** The default logger groups.
179 * This must match LOGGROUP! */
180static const char *g_apszGroups[] =
181VBOX_LOGGROUP_NAMES;
182
183
184/**
185 * Creates the default logger instance for a VBox process.
186 *
187 * @returns Pointer to the logger instance.
188 */
189RTDECL(PRTLOGGER) RTLogDefaultInit(void)
190{
191 /*
192 * Initialize the default logger instance.
193 * Take care to do this once and not recursively.
194 */
195 static volatile uint32_t fInitializing = 0;
196 PRTLOGGER pLogger;
197 int rc;
198
199 if (g_pLogger || !ASMAtomicCmpXchgU32(&fInitializing, 1, 0))
200 return g_pLogger;
201
202#ifdef IN_RING3
203 /*
204 * Assert the group definitions.
205 */
206#define ASSERT_LOG_GROUP(grp) ASSERT_LOG_GROUP2(LOG_GROUP_##grp, #grp)
207#define ASSERT_LOG_GROUP2(def, str) \
208 do { if (strcmp(g_apszGroups[def], str)) {printf("%s='%s' expects '%s'\n", #def, g_apszGroups[def], str); RTAssertDoPanic(); } } while (0)
209 ASSERT_LOG_GROUP(DEFAULT);
210 ASSERT_LOG_GROUP(AUDIO_MIXER);
211 ASSERT_LOG_GROUP(AUDIO_MIXER_BUFFER);
212 ASSERT_LOG_GROUP(AUTOLOGON);
213 ASSERT_LOG_GROUP(CFGM);
214 ASSERT_LOG_GROUP(CPUM);
215 ASSERT_LOG_GROUP(CSAM);
216 ASSERT_LOG_GROUP(DBGC);
217 ASSERT_LOG_GROUP(DBGF);
218 ASSERT_LOG_GROUP(DBGF_INFO);
219 ASSERT_LOG_GROUP(DBGG);
220 ASSERT_LOG_GROUP(DEV);
221 ASSERT_LOG_GROUP(DEV_AC97);
222 ASSERT_LOG_GROUP(DEV_ACPI);
223 ASSERT_LOG_GROUP(DEV_APIC);
224 ASSERT_LOG_GROUP(DEV_BUSLOGIC);
225 ASSERT_LOG_GROUP(DEV_DMA);
226 ASSERT_LOG_GROUP(DEV_E1000);
227 ASSERT_LOG_GROUP(DEV_EFI);
228 ASSERT_LOG_GROUP(DEV_EHCI);
229 ASSERT_LOG_GROUP(DEV_FDC);
230 ASSERT_LOG_GROUP(DEV_GIM);
231 ASSERT_LOG_GROUP(DEV_HDA);
232 ASSERT_LOG_GROUP(DEV_HDA_CODEC);
233 ASSERT_LOG_GROUP(DEV_HPET);
234 ASSERT_LOG_GROUP(DEV_IDE);
235 ASSERT_LOG_GROUP(DEV_INIP);
236 ASSERT_LOG_GROUP(DEV_KBD);
237 ASSERT_LOG_GROUP(DEV_LPC);
238 ASSERT_LOG_GROUP(DEV_LSILOGICSCSI);
239 ASSERT_LOG_GROUP(DEV_NVME);
240 ASSERT_LOG_GROUP(DEV_OHCI);
241 ASSERT_LOG_GROUP(DEV_PARALLEL);
242 ASSERT_LOG_GROUP(DEV_PC);
243 ASSERT_LOG_GROUP(DEV_PC_ARCH);
244 ASSERT_LOG_GROUP(DEV_PC_BIOS);
245 ASSERT_LOG_GROUP(DEV_PCI);
246 ASSERT_LOG_GROUP(DEV_PCI_RAW);
247 ASSERT_LOG_GROUP(DEV_PCNET);
248 ASSERT_LOG_GROUP(DEV_PIC);
249 ASSERT_LOG_GROUP(DEV_PIT);
250 ASSERT_LOG_GROUP(DEV_RTC);
251 ASSERT_LOG_GROUP(DEV_SB16);
252 ASSERT_LOG_GROUP(DEV_SERIAL);
253 ASSERT_LOG_GROUP(DEV_SMC);
254 ASSERT_LOG_GROUP(DEV_VGA);
255 ASSERT_LOG_GROUP(DEV_VIRTIO);
256 ASSERT_LOG_GROUP(DEV_VIRTIO_NET);
257 ASSERT_LOG_GROUP(DEV_VMM);
258 ASSERT_LOG_GROUP(DEV_VMM_BACKDOOR);
259 ASSERT_LOG_GROUP(DEV_VMM_STDERR);
260 ASSERT_LOG_GROUP(DEV_VMSVGA);
261 ASSERT_LOG_GROUP(DEV_XHCI);
262 ASSERT_LOG_GROUP(DIS);
263 ASSERT_LOG_GROUP(DRV);
264 ASSERT_LOG_GROUP(DRV_ACPI);
265 ASSERT_LOG_GROUP(DRV_AUDIO);
266 ASSERT_LOG_GROUP(DRV_BLOCK);
267 ASSERT_LOG_GROUP(DRV_CHAR);
268 ASSERT_LOG_GROUP(DRV_DISK_INTEGRITY);
269 ASSERT_LOG_GROUP(DRV_DISPLAY);
270 ASSERT_LOG_GROUP(DRV_FLOPPY);
271 ASSERT_LOG_GROUP(DRV_HOST_AUDIO);
272 ASSERT_LOG_GROUP(DRV_HOST_BASE);
273 ASSERT_LOG_GROUP(DRV_HOST_DVD);
274 ASSERT_LOG_GROUP(DRV_HOST_FLOPPY);
275 ASSERT_LOG_GROUP(DRV_HOST_PARALLEL);
276 ASSERT_LOG_GROUP(DRV_HOST_SERIAL);
277 ASSERT_LOG_GROUP(DRV_INTNET);
278 ASSERT_LOG_GROUP(DRV_ISO);
279 ASSERT_LOG_GROUP(DRV_KBD_QUEUE);
280 ASSERT_LOG_GROUP(DRV_LWIP);
281 ASSERT_LOG_GROUP(DRV_MINIPORT);
282 ASSERT_LOG_GROUP(DRV_MOUSE_QUEUE);
283 ASSERT_LOG_GROUP(DRV_NAMEDPIPE);
284 ASSERT_LOG_GROUP(DRV_NAT);
285 ASSERT_LOG_GROUP(DRV_RAW_IMAGE);
286 ASSERT_LOG_GROUP(DRV_SCSI);
287 ASSERT_LOG_GROUP(DRV_SCSIHOST);
288 ASSERT_LOG_GROUP(DRV_TCP);
289 ASSERT_LOG_GROUP(DRV_TRANSPORT_ASYNC);
290 ASSERT_LOG_GROUP(DRV_TUN);
291 ASSERT_LOG_GROUP(DRV_UDPTUNNEL);
292 ASSERT_LOG_GROUP(DRV_USBPROXY);
293 ASSERT_LOG_GROUP(DRV_VBOXHDD);
294 ASSERT_LOG_GROUP(DRV_VD);
295 ASSERT_LOG_GROUP(DRV_VRDE_AUDIO);
296 ASSERT_LOG_GROUP(DRV_VSWITCH);
297 ASSERT_LOG_GROUP(DRV_VUSB);
298 ASSERT_LOG_GROUP(EM);
299 ASSERT_LOG_GROUP(FTM);
300 ASSERT_LOG_GROUP(GIM);
301 ASSERT_LOG_GROUP(GMM);
302 ASSERT_LOG_GROUP(GUEST_CONTROL);
303 ASSERT_LOG_GROUP(GUEST_DND);
304 ASSERT_LOG_GROUP(GUI);
305 ASSERT_LOG_GROUP(GVMM);
306 ASSERT_LOG_GROUP(HGCM);
307 ASSERT_LOG_GROUP(HGSMI);
308 ASSERT_LOG_GROUP(HM);
309 ASSERT_LOG_GROUP(IEM);
310 ASSERT_LOG_GROUP(IOM);
311 ASSERT_LOG_GROUP(IPC);
312 ASSERT_LOG_GROUP(LWIP);
313 ASSERT_LOG_GROUP(LWIP_API_LIB);
314 ASSERT_LOG_GROUP(LWIP_API_MSG);
315 ASSERT_LOG_GROUP(LWIP_ETHARP);
316 ASSERT_LOG_GROUP(LWIP_ICMP);
317 ASSERT_LOG_GROUP(LWIP_IGMP);
318 ASSERT_LOG_GROUP(LWIP_INET);
319 ASSERT_LOG_GROUP(LWIP_IP4);
320 ASSERT_LOG_GROUP(LWIP_IP4_REASS);
321 ASSERT_LOG_GROUP(LWIP_IP6);
322 ASSERT_LOG_GROUP(LWIP_MEM);
323 ASSERT_LOG_GROUP(LWIP_MEMP);
324 ASSERT_LOG_GROUP(LWIP_NETIF);
325 ASSERT_LOG_GROUP(LWIP_PBUF);
326 ASSERT_LOG_GROUP(LWIP_RAW);
327 ASSERT_LOG_GROUP(LWIP_SOCKETS);
328 ASSERT_LOG_GROUP(LWIP_SYS);
329 ASSERT_LOG_GROUP(LWIP_TCP);
330 ASSERT_LOG_GROUP(LWIP_TCPIP);
331 ASSERT_LOG_GROUP(LWIP_TCP_CWND);
332 ASSERT_LOG_GROUP(LWIP_TCP_FR);
333 ASSERT_LOG_GROUP(LWIP_TCP_INPUT);
334 ASSERT_LOG_GROUP(LWIP_TCP_OUTPUT);
335 ASSERT_LOG_GROUP(LWIP_TCP_QLEN);
336 ASSERT_LOG_GROUP(LWIP_TCP_RST);
337 ASSERT_LOG_GROUP(LWIP_TCP_RTO);
338 ASSERT_LOG_GROUP(LWIP_TCP_WND);
339 ASSERT_LOG_GROUP(LWIP_TIMERS);
340 ASSERT_LOG_GROUP(LWIP_UDP);
341 ASSERT_LOG_GROUP(MAIN);
342 ASSERT_LOG_GROUP(MAIN_ADDITIONSFACILITY);
343 ASSERT_LOG_GROUP(MAIN_ADDITIONSSTATECHANGEDEVENT);
344 ASSERT_LOG_GROUP(MAIN_APPLIANCE);
345 ASSERT_LOG_GROUP(MAIN_AUDIOADAPTER);
346 ASSERT_LOG_GROUP(MAIN_BANDWIDTHCONTROL);
347 ASSERT_LOG_GROUP(MAIN_BANDWIDTHGROUP);
348 ASSERT_LOG_GROUP(MAIN_BANDWIDTHGROUPCHANGEDEVENT);
349 ASSERT_LOG_GROUP(MAIN_BIOSSETTINGS);
350 ASSERT_LOG_GROUP(MAIN_CANSHOWWINDOWEVENT);
351 ASSERT_LOG_GROUP(MAIN_CLIPBOARDMODECHANGEDEVENT);
352 ASSERT_LOG_GROUP(MAIN_CONSOLE);
353 ASSERT_LOG_GROUP(MAIN_CPUCHANGEDEVENT);
354 ASSERT_LOG_GROUP(MAIN_CPUEXECUTIONCAPCHANGEDEVENT);
355 ASSERT_LOG_GROUP(MAIN_CURSORPOSITIONCHANGEDEVENT);
356 ASSERT_LOG_GROUP(MAIN_DHCPSERVER);
357 ASSERT_LOG_GROUP(MAIN_DIRECTORY);
358 ASSERT_LOG_GROUP(MAIN_DISPLAY);
359 ASSERT_LOG_GROUP(MAIN_DISPLAYSOURCEBITMAP);
360 ASSERT_LOG_GROUP(MAIN_DNDBASE);
361 ASSERT_LOG_GROUP(MAIN_DNDMODECHANGEDEVENT);
362 ASSERT_LOG_GROUP(MAIN_DNDSOURCE);
363 ASSERT_LOG_GROUP(MAIN_DNDTARGET);
364 ASSERT_LOG_GROUP(MAIN_EMULATEDUSB);
365 ASSERT_LOG_GROUP(MAIN_EVENT);
366 ASSERT_LOG_GROUP(MAIN_EVENTLISTENER);
367 ASSERT_LOG_GROUP(MAIN_EVENTSOURCE);
368 ASSERT_LOG_GROUP(MAIN_EVENTSOURCECHANGEDEVENT);
369 ASSERT_LOG_GROUP(MAIN_EXTPACK);
370 ASSERT_LOG_GROUP(MAIN_EXTPACKBASE);
371 ASSERT_LOG_GROUP(MAIN_EXTPACKFILE);
372 ASSERT_LOG_GROUP(MAIN_EXTPACKMANAGER);
373 ASSERT_LOG_GROUP(MAIN_EXTPACKPLUGIN);
374 ASSERT_LOG_GROUP(MAIN_EXTRADATACANCHANGEEVENT);
375 ASSERT_LOG_GROUP(MAIN_EXTRADATACHANGEDEVENT);
376 ASSERT_LOG_GROUP(MAIN_FILE);
377 ASSERT_LOG_GROUP(MAIN_FRAMEBUFFER);
378 ASSERT_LOG_GROUP(MAIN_FRAMEBUFFEROVERLAY);
379 ASSERT_LOG_GROUP(MAIN_FSOBJINFO);
380 ASSERT_LOG_GROUP(MAIN_GUEST);
381 ASSERT_LOG_GROUP(MAIN_GUESTDIRECTORY);
382 ASSERT_LOG_GROUP(MAIN_GUESTDNDSOURCE);
383 ASSERT_LOG_GROUP(MAIN_GUESTDNDTARGET);
384 ASSERT_LOG_GROUP(MAIN_GUESTERRORINFO);
385 ASSERT_LOG_GROUP(MAIN_GUESTFILE);
386 ASSERT_LOG_GROUP(MAIN_GUESTFILEEVENT);
387 ASSERT_LOG_GROUP(MAIN_GUESTFILEIOEVENT);
388 ASSERT_LOG_GROUP(MAIN_GUESTFILEOFFSETCHANGEDEVENT);
389 ASSERT_LOG_GROUP(MAIN_GUESTFILEREADEVENT);
390 ASSERT_LOG_GROUP(MAIN_GUESTFILEREGISTEREDEVENT);
391 ASSERT_LOG_GROUP(MAIN_GUESTFILESTATECHANGEDEVENT);
392 ASSERT_LOG_GROUP(MAIN_GUESTFILEWRITEEVENT);
393 ASSERT_LOG_GROUP(MAIN_GUESTFSOBJINFO);
394 ASSERT_LOG_GROUP(MAIN_GUESTKEYBOARDEVENT);
395 ASSERT_LOG_GROUP(MAIN_GUESTMONITORCHANGEDEVENT);
396 ASSERT_LOG_GROUP(MAIN_GUESTMOUSEEVENT);
397 ASSERT_LOG_GROUP(MAIN_GUESTMULTITOUCHEVENT);
398 ASSERT_LOG_GROUP(MAIN_GUESTOSTYPE);
399 ASSERT_LOG_GROUP(MAIN_GUESTPROCESS);
400 ASSERT_LOG_GROUP(MAIN_GUESTPROCESSEVENT);
401 ASSERT_LOG_GROUP(MAIN_GUESTPROCESSINPUTNOTIFYEVENT);
402 ASSERT_LOG_GROUP(MAIN_GUESTPROCESSIOEVENT);
403 ASSERT_LOG_GROUP(MAIN_GUESTPROCESSOUTPUTEVENT);
404 ASSERT_LOG_GROUP(MAIN_GUESTPROCESSREGISTEREDEVENT);
405 ASSERT_LOG_GROUP(MAIN_GUESTPROCESSSTATECHANGEDEVENT);
406 ASSERT_LOG_GROUP(MAIN_GUESTPROPERTYCHANGEDEVENT);
407 ASSERT_LOG_GROUP(MAIN_GUESTSESSION);
408 ASSERT_LOG_GROUP(MAIN_GUESTSESSIONEVENT);
409 ASSERT_LOG_GROUP(MAIN_GUESTSESSIONREGISTEREDEVENT);
410 ASSERT_LOG_GROUP(MAIN_GUESTSESSIONSTATECHANGEDEVENT);
411 ASSERT_LOG_GROUP(MAIN_GUESTUSERSTATECHANGEDEVENT);
412 ASSERT_LOG_GROUP(MAIN_HOST);
413 ASSERT_LOG_GROUP(MAIN_HOSTNAMERESOLUTIONCONFIGURATIONCHANGEEVENT);
414 ASSERT_LOG_GROUP(MAIN_HOSTNETWORKINTERFACE);
415 ASSERT_LOG_GROUP(MAIN_HOSTPCIDEVICEPLUGEVENT);
416 ASSERT_LOG_GROUP(MAIN_HOSTUSBDEVICE);
417 ASSERT_LOG_GROUP(MAIN_HOSTUSBDEVICEFILTER);
418 ASSERT_LOG_GROUP(MAIN_HOSTVIDEOINPUTDEVICE);
419 ASSERT_LOG_GROUP(MAIN_INTERNALMACHINECONTROL);
420 ASSERT_LOG_GROUP(MAIN_INTERNALSESSIONCONTROL);
421 ASSERT_LOG_GROUP(MAIN_KEYBOARD);
422 ASSERT_LOG_GROUP(MAIN_KEYBOARDLEDSCHANGEDEVENT);
423 ASSERT_LOG_GROUP(MAIN_MACHINE);
424 ASSERT_LOG_GROUP(MAIN_MACHINEDATACHANGEDEVENT);
425 ASSERT_LOG_GROUP(MAIN_MACHINEDEBUGGER);
426 ASSERT_LOG_GROUP(MAIN_MACHINEEVENT);
427 ASSERT_LOG_GROUP(MAIN_MACHINEREGISTEREDEVENT);
428 ASSERT_LOG_GROUP(MAIN_MACHINESTATECHANGEDEVENT);
429 ASSERT_LOG_GROUP(MAIN_MEDIUM);
430 ASSERT_LOG_GROUP(MAIN_MEDIUMATTACHMENT);
431 ASSERT_LOG_GROUP(MAIN_MEDIUMCHANGEDEVENT);
432 ASSERT_LOG_GROUP(MAIN_MEDIUMCONFIGCHANGEDEVENT);
433 ASSERT_LOG_GROUP(MAIN_MEDIUMFORMAT);
434 ASSERT_LOG_GROUP(MAIN_MEDIUMREGISTEREDEVENT);
435 ASSERT_LOG_GROUP(MAIN_MOUSE);
436 ASSERT_LOG_GROUP(MAIN_MOUSECAPABILITYCHANGEDEVENT);
437 ASSERT_LOG_GROUP(MAIN_MOUSEPOINTERSHAPE);
438 ASSERT_LOG_GROUP(MAIN_MOUSEPOINTERSHAPECHANGEDEVENT);
439 ASSERT_LOG_GROUP(MAIN_NATENGINE);
440 ASSERT_LOG_GROUP(MAIN_NATNETWORK);
441 ASSERT_LOG_GROUP(MAIN_NATNETWORKALTEREVENT);
442 ASSERT_LOG_GROUP(MAIN_NATNETWORKCHANGEDEVENT);
443 ASSERT_LOG_GROUP(MAIN_NATNETWORKCREATIONDELETIONEVENT);
444 ASSERT_LOG_GROUP(MAIN_NATNETWORKPORTFORWARDEVENT);
445 ASSERT_LOG_GROUP(MAIN_NATNETWORKSETTINGEVENT);
446 ASSERT_LOG_GROUP(MAIN_NATNETWORKSTARTSTOPEVENT);
447 ASSERT_LOG_GROUP(MAIN_NATREDIRECTEVENT);
448 ASSERT_LOG_GROUP(MAIN_NETWORKADAPTER);
449 ASSERT_LOG_GROUP(MAIN_NETWORKADAPTERCHANGEDEVENT);
450 ASSERT_LOG_GROUP(MAIN_PARALLELPORT);
451 ASSERT_LOG_GROUP(MAIN_PARALLELPORTCHANGEDEVENT);
452 ASSERT_LOG_GROUP(MAIN_PCIADDRESS);
453 ASSERT_LOG_GROUP(MAIN_PCIDEVICEATTACHMENT);
454 ASSERT_LOG_GROUP(MAIN_PERFORMANCECOLLECTOR);
455 ASSERT_LOG_GROUP(MAIN_PERFORMANCEMETRIC);
456 ASSERT_LOG_GROUP(MAIN_PROCESS);
457 ASSERT_LOG_GROUP(MAIN_PROGRESS);
458 ASSERT_LOG_GROUP(MAIN_REUSABLEEVENT);
459 ASSERT_LOG_GROUP(MAIN_RUNTIMEERROREVENT);
460 ASSERT_LOG_GROUP(MAIN_SERIALPORT);
461 ASSERT_LOG_GROUP(MAIN_SERIALPORTCHANGEDEVENT);
462 ASSERT_LOG_GROUP(MAIN_SESSION);
463 ASSERT_LOG_GROUP(MAIN_SESSIONSTATECHANGEDEVENT);
464 ASSERT_LOG_GROUP(MAIN_SHAREDFOLDER);
465 ASSERT_LOG_GROUP(MAIN_SHAREDFOLDERCHANGEDEVENT);
466 ASSERT_LOG_GROUP(MAIN_SHOWWINDOWEVENT);
467 ASSERT_LOG_GROUP(MAIN_SNAPSHOT);
468 ASSERT_LOG_GROUP(MAIN_SNAPSHOTCHANGEDEVENT);
469 ASSERT_LOG_GROUP(MAIN_SNAPSHOTDELETEDEVENT);
470 ASSERT_LOG_GROUP(MAIN_SNAPSHOTEVENT);
471 ASSERT_LOG_GROUP(MAIN_SNAPSHOTRESTOREDEVENT);
472 ASSERT_LOG_GROUP(MAIN_SNAPSHOTTAKENEVENT);
473 ASSERT_LOG_GROUP(MAIN_STATECHANGEDEVENT);
474 ASSERT_LOG_GROUP(MAIN_STORAGECONTROLLER);
475 ASSERT_LOG_GROUP(MAIN_STORAGECONTROLLERCHANGEDEVENT);
476 ASSERT_LOG_GROUP(MAIN_STORAGEDEVICECHANGEDEVENT);
477 ASSERT_LOG_GROUP(MAIN_SYSTEMPROPERTIES);
478 ASSERT_LOG_GROUP(MAIN_TOKEN);
479 ASSERT_LOG_GROUP(MAIN_USBCONTROLLER);
480 ASSERT_LOG_GROUP(MAIN_USBCONTROLLERCHANGEDEVENT);
481 ASSERT_LOG_GROUP(MAIN_USBDEVICE);
482 ASSERT_LOG_GROUP(MAIN_USBDEVICEFILTERS);
483 ASSERT_LOG_GROUP(MAIN_USBDEVICESTATECHANGEDEVENT);
484 ASSERT_LOG_GROUP(MAIN_VBOXSVCAVAILABILITYCHANGEDEVENT);
485 ASSERT_LOG_GROUP(MAIN_VIRTUALBOX);
486 ASSERT_LOG_GROUP(MAIN_VIRTUALBOXCLIENT);
487 ASSERT_LOG_GROUP(MAIN_VIRTUALBOXSDS);
488 ASSERT_LOG_GROUP(MAIN_VIRTUALSYSTEMDESCRIPTION);
489 ASSERT_LOG_GROUP(MAIN_VRDESERVER);
490 ASSERT_LOG_GROUP(MAIN_VRDESERVERCHANGEDEVENT);
491 ASSERT_LOG_GROUP(MAIN_VRDESERVERINFO);
492 ASSERT_LOG_GROUP(MAIN_VRDESERVERINFOCHANGEDEVENT);
493 ASSERT_LOG_GROUP(MISC);
494 ASSERT_LOG_GROUP(MM);
495 ASSERT_LOG_GROUP(MM_HEAP);
496 ASSERT_LOG_GROUP(MM_HYPER);
497 ASSERT_LOG_GROUP(MM_HYPER_HEAP);
498 ASSERT_LOG_GROUP(MM_PHYS);
499 ASSERT_LOG_GROUP(MM_POOL);
500 ASSERT_LOG_GROUP(NAT_SERVICE);
501 ASSERT_LOG_GROUP(NET_ADP_DRV);
502 ASSERT_LOG_GROUP(NET_FLT_DRV);
503 ASSERT_LOG_GROUP(NET_SERVICE);
504 ASSERT_LOG_GROUP(NET_SHAPER);
505 ASSERT_LOG_GROUP(PATM);
506 ASSERT_LOG_GROUP(PDM);
507 ASSERT_LOG_GROUP(PDM_ASYNC_COMPLETION);
508 ASSERT_LOG_GROUP(PDM_BLK_CACHE);
509 ASSERT_LOG_GROUP(PDM_DEVICE);
510 ASSERT_LOG_GROUP(PDM_DRIVER);
511 ASSERT_LOG_GROUP(PDM_LDR);
512 ASSERT_LOG_GROUP(PDM_QUEUE);
513 ASSERT_LOG_GROUP(PGM);
514 ASSERT_LOG_GROUP(PGM_DYNMAP);
515 ASSERT_LOG_GROUP(PGM_PHYS);
516 ASSERT_LOG_GROUP(PGM_PHYS_ACCESS);
517 ASSERT_LOG_GROUP(PGM_POOL);
518 ASSERT_LOG_GROUP(PGM_SHARED);
519 ASSERT_LOG_GROUP(REM);
520 ASSERT_LOG_GROUP(REM_DISAS);
521 ASSERT_LOG_GROUP(REM_HANDLER);
522 ASSERT_LOG_GROUP(REM_IOPORT);
523 ASSERT_LOG_GROUP(REM_MMIO);
524 ASSERT_LOG_GROUP(REM_PRINTF);
525 ASSERT_LOG_GROUP(REM_RUN);
526 ASSERT_LOG_GROUP(SELM);
527 ASSERT_LOG_GROUP(SHARED_CLIPBOARD);
528 ASSERT_LOG_GROUP(SHARED_CROPENGL);
529 ASSERT_LOG_GROUP(SHARED_FOLDERS);
530 ASSERT_LOG_GROUP(SHARED_OPENGL);
531 ASSERT_LOG_GROUP(SRV_INTNET);
532 ASSERT_LOG_GROUP(SSM);
533 ASSERT_LOG_GROUP(STAM);
534 ASSERT_LOG_GROUP(SUP);
535 ASSERT_LOG_GROUP(TM);
536 ASSERT_LOG_GROUP(TRPM);
537 ASSERT_LOG_GROUP(USB_CARDREADER);
538 ASSERT_LOG_GROUP(USB_DRV);
539 ASSERT_LOG_GROUP(USB_FILTER);
540 ASSERT_LOG_GROUP(USB_KBD);
541 ASSERT_LOG_GROUP(USB_MOUSE);
542 ASSERT_LOG_GROUP(USB_MSD);
543 ASSERT_LOG_GROUP(USB_REMOTE);
544 ASSERT_LOG_GROUP(USB_WEBCAM);
545 ASSERT_LOG_GROUP(VGDRV);
546 ASSERT_LOG_GROUP(VBGL);
547 ASSERT_LOG_GROUP(VD);
548 ASSERT_LOG_GROUP(VD_DMG);
549 ASSERT_LOG_GROUP(VD_ISCSI);
550 ASSERT_LOG_GROUP(VD_PARALLELS);
551 ASSERT_LOG_GROUP(VD_QCOW);
552 ASSERT_LOG_GROUP(VD_QED);
553 ASSERT_LOG_GROUP(VD_RAW);
554 ASSERT_LOG_GROUP(VD_VDI);
555 ASSERT_LOG_GROUP(VD_VHD);
556 ASSERT_LOG_GROUP(VD_VHDX);
557 ASSERT_LOG_GROUP(VD_VMDK);
558 ASSERT_LOG_GROUP(VM);
559 ASSERT_LOG_GROUP(VMM);
560 ASSERT_LOG_GROUP(VRDE);
561 ASSERT_LOG_GROUP(VRDP);
562 ASSERT_LOG_GROUP(VSCSI);
563 ASSERT_LOG_GROUP(WEBSERVICE);
564#undef ASSERT_LOG_GROUP
565#undef ASSERT_LOG_GROUP2
566#endif /* IN_RING3 */
567
568 /*
569 * Create the default logging instance.
570 */
571#ifdef IN_RING3
572# ifndef IN_GUEST
573 char szExecName[RTPATH_MAX];
574 if (!RTProcGetExecutablePath(szExecName, sizeof(szExecName)))
575 strcpy(szExecName, "VBox");
576 RTTIMESPEC TimeSpec;
577 RTTIME Time;
578 RTTimeExplode(&Time, RTTimeNow(&TimeSpec));
579 rc = RTLogCreate(&pLogger, 0, NULL, "VBOX_LOG", RT_ELEMENTS(g_apszGroups), &g_apszGroups[0], RTLOGDEST_FILE,
580 "./%04d-%02d-%02d-%02d-%02d-%02d.%03d-%s-%d.log",
581 Time.i32Year, Time.u8Month, Time.u8MonthDay, Time.u8Hour, Time.u8Minute, Time.u8Second, Time.u32Nanosecond / 10000000,
582 RTPathFilename(szExecName), RTProcSelf());
583 if (RT_SUCCESS(rc))
584 {
585 /*
586 * Write a log header.
587 */
588 char szBuf[RTPATH_MAX];
589 RTTimeSpecToString(&TimeSpec, szBuf, sizeof(szBuf));
590 RTLogLoggerEx(pLogger, 0, ~0U, "Log created: %s\n", szBuf);
591 RTLogLoggerEx(pLogger, 0, ~0U, "Executable: %s\n", szExecName);
592
593 /* executable and arguments - tricky and all platform specific. */
594# if defined(RT_OS_WINDOWS)
595 RTLogLoggerEx(pLogger, 0, ~0U, "Commandline: %ls\n", GetCommandLineW());
596
597# elif defined(RT_OS_SOLARIS)
598 psinfo_t psi;
599 char szArgFileBuf[80];
600 RTStrPrintf(szArgFileBuf, sizeof(szArgFileBuf), "/proc/%ld/psinfo", (long)getpid());
601 FILE* pFile = fopen(szArgFileBuf, "rb");
602 if (pFile)
603 {
604 if (fread(&psi, sizeof(psi), 1, pFile) == 1)
605 {
606# if 0 /* 100% safe:*/
607 RTLogLoggerEx(pLogger, 0, ~0U, "Args: %s\n", psi.pr_psargs);
608# else /* probably safe: */
609 const char * const *argv = (const char * const *)psi.pr_argv;
610 for (int iArg = 0; iArg < psi.pr_argc; iArg++)
611 RTLogLoggerEx(pLogger, 0, ~0U, "Arg[%d]: %s\n", iArg, argv[iArg]);
612# endif
613
614 }
615 fclose(pFile);
616 }
617
618# elif defined(RT_OS_LINUX)
619 FILE *pFile = fopen("/proc/self/cmdline", "r");
620 if (pFile)
621 {
622 /* braindead */
623 unsigned iArg = 0;
624 int ch;
625 bool fNew = true;
626 while (!feof(pFile) && (ch = fgetc(pFile)) != EOF)
627 {
628 if (fNew)
629 {
630 RTLogLoggerEx(pLogger, 0, ~0U, "Arg[%u]: ", iArg++);
631 fNew = false;
632 }
633 if (ch)
634 RTLogLoggerEx(pLogger, 0, ~0U, "%c", ch);
635 else
636 {
637 RTLogLoggerEx(pLogger, 0, ~0U, "\n");
638 fNew = true;
639 }
640 }
641 if (!fNew)
642 RTLogLoggerEx(pLogger, 0, ~0U, "\n");
643 fclose(pFile);
644 }
645
646# elif defined(RT_OS_HAIKU)
647 team_info info;
648 if (get_team_info(0, &info) == B_OK)
649 {
650 /* there is an info.argc, but no way to know arg boundaries */
651 RTLogLoggerEx(pLogger, 0, ~0U, "Commandline: %.64s\n", info.args);
652 }
653
654# elif defined(RT_OS_FREEBSD) || defined(RT_OS_NETBSD)
655 /* Retrieve the required length first */
656 int aiName[4];
657# if defined(RT_OS_FREEBSD)
658 aiName[0] = CTL_KERN;
659 aiName[1] = KERN_PROC;
660 aiName[2] = KERN_PROC_ARGS; /* Introduced in FreeBSD 4.0 */
661 aiName[3] = getpid();
662# elif defined(RT_OS_NETBSD)
663 aiName[0] = CTL_KERN;
664 aiName[1] = KERN_PROC_ARGS;
665 aiName[2] = getpid();
666 aiName[3] = KERN_PROC_ARGV;
667# endif
668 size_t cchArgs = 0;
669 int rcBSD = sysctl(aiName, RT_ELEMENTS(aiName), NULL, &cchArgs, NULL, 0);
670 if (cchArgs > 0)
671 {
672 char *pszArgFileBuf = (char *)RTMemAllocZ(cchArgs + 1 /* Safety */);
673 if (pszArgFileBuf)
674 {
675 /* Retrieve the argument list */
676 rcBSD = sysctl(aiName, RT_ELEMENTS(aiName), pszArgFileBuf, &cchArgs, NULL, 0);
677 if (!rcBSD)
678 {
679 unsigned iArg = 0;
680 size_t off = 0;
681 while (off < cchArgs)
682 {
683 size_t cchArg = strlen(&pszArgFileBuf[off]);
684 RTLogLoggerEx(pLogger, 0, ~0U, "Arg[%u]: %s\n", iArg, &pszArgFileBuf[off]);
685
686 /* advance */
687 off += cchArg + 1;
688 iArg++;
689 }
690 }
691 RTMemFree(pszArgFileBuf);
692 }
693 }
694
695# elif defined(RT_OS_OS2) || defined(RT_OS_DARWIN)
696 /* commandline? */
697# else
698# error needs porting.
699# endif
700 }
701
702# else /* IN_GUEST */
703 /* The user destination is backdoor logging. */
704 rc = RTLogCreate(&pLogger, 0, NULL, "VBOX_LOG", RT_ELEMENTS(g_apszGroups), &g_apszGroups[0], RTLOGDEST_USER, "VBox.log");
705# endif /* IN_GUEST */
706
707#else /* IN_RING0 */
708
709 /* Some platforms has trouble allocating memory with interrupts and/or
710 preemption disabled. Check and fail before we panic. */
711# if defined(RT_OS_DARWIN)
712 if ( !ASMIntAreEnabled()
713 || !RTThreadPreemptIsEnabled(NIL_RTTHREAD))
714 return NULL;
715# endif
716
717# ifndef IN_GUEST
718 rc = RTLogCreate(&pLogger, 0, NULL, "VBOX_LOG", RT_ELEMENTS(g_apszGroups), &g_apszGroups[0], RTLOGDEST_FILE, "VBox-ring0.log");
719# else /* IN_GUEST */
720 rc = RTLogCreate(&pLogger, 0, NULL, "VBOX_LOG", RT_ELEMENTS(g_apszGroups), &g_apszGroups[0], RTLOGDEST_USER, "VBox-ring0.log");
721# endif /* IN_GUEST */
722 if (RT_SUCCESS(rc))
723 {
724 /*
725 * This is where you set your ring-0 logging preferences.
726 *
727 * On platforms which don't differ between debugger and kernel
728 * log printing, STDOUT is gonna be a stub and the DEBUGGER
729 * destination is the one doing all the work. On platforms
730 * that do differ (like Darwin), STDOUT is the kernel log.
731 */
732# if defined(DEBUG_bird)
733 /*RTLogGroupSettings(pLogger, "all=~0 -default.l6.l5.l4.l3");*/
734 RTLogFlags(pLogger, "enabled unbuffered pid tid");
735# ifndef IN_GUEST
736 pLogger->fDestFlags |= RTLOGDEST_DEBUGGER | RTLOGDEST_STDOUT;
737# else
738 RTLogGroupSettings(pLogger, "all=~0 -default.l6.l5.l4.l3");
739# endif
740# endif
741# if defined(DEBUG_sandervl) && !defined(IN_GUEST)
742 RTLogGroupSettings(pLogger, "+all");
743 RTLogFlags(pLogger, "enabled unbuffered");
744 pLogger->fDestFlags |= RTLOGDEST_DEBUGGER;
745# endif
746# if defined(DEBUG_ramshankar) /* Guest ring-0 as well */
747 RTLogGroupSettings(pLogger, "+all.e.l.f");
748 RTLogFlags(pLogger, "enabled unbuffered");
749 pLogger->fDestFlags |= RTLOGDEST_DEBUGGER;
750# endif
751# if defined(DEBUG_aleksey) /* Guest ring-0 as well */
752 RTLogGroupSettings(pLogger, "net_flt_drv.e.l.f.l3.l4.l5.l6 +net_adp_drv.e.l.f.l3.l4.l5.l6");
753 RTLogFlags(pLogger, "enabled unbuffered");
754 pLogger->fDestFlags |= RTLOGDEST_DEBUGGER | RTLOGDEST_STDOUT;
755# endif
756# if defined(DEBUG_andy) /* Guest ring-0 as well */
757 RTLogGroupSettings(pLogger, "+all.e.l.f");
758 RTLogFlags(pLogger, "enabled unbuffered pid tid");
759 pLogger->fDestFlags |= RTLOGDEST_DEBUGGER | RTLOGDEST_STDOUT;
760# endif
761# if defined(DEBUG_misha) /* Guest ring-0 as well */
762 RTLogFlags(pLogger, "enabled unbuffered");
763 pLogger->fDestFlags |= RTLOGDEST_DEBUGGER;
764# endif
765# if defined(DEBUG_michael) && defined(IN_GUEST)
766 RTLogGroupSettings(pLogger, "+vga.e.l.f");
767 RTLogFlags(pLogger, "enabled unbuffered");
768 pLogger->fDestFlags |= RTLOGDEST_DEBUGGER | RTLOGDEST_STDOUT;
769# endif
770# if 0 /* vboxdrv logging - ATTENTION: this is what we're referring to guys! Change to '# if 1'. */
771 RTLogGroupSettings(pLogger, "all=~0 -default.l6.l5.l4.l3");
772 RTLogFlags(pLogger, "enabled unbuffered tid");
773 pLogger->fDestFlags |= RTLOGDEST_DEBUGGER | RTLOGDEST_STDOUT;
774# endif
775 }
776#endif /* IN_RING0 */
777 return g_pLogger = RT_SUCCESS(rc) ? pLogger : NULL;
778}
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use