ReactOS 0.4.15-dev-7711-g5627da4
tracingum.cpp
Go to the documentation of this file.
1/*++
2
3Copyright (c) Microsoft Corporation
4
5Module Name:
6
7 Tracing.cpp
8
9Abstract:
10
11 This module implements tracing for the driver frameworks
12
13Author:
14
15
16
17
18Revision History:
19
20
21
22
23--*/
24
25#include "FxSupportPch.hpp"
26#include "fxldrum.h"
27
28extern "C" {
29#if defined(EVENT_TRACING)
30#include "TracingUM.tmh"
31#endif
32}
33
34#include <strsafe.h>
35#include <initguid.h>
36#include "fxIFR.h" // shared struct between IFR and debug ext.
37#include "fxIFRKm.h" // kernel mode only IFR definitions
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
257 VOID
258 )
259
260/*++
261
262Routine Description:
263
264 This routine initializes the frameworks tracing.
265
266 It must be called early on in the frameworks DriverEntry
267 initialization.
268
269Arguments:
270
271 None
272
273Returns:
274
275 NTSTATUS code
276
277--*/
278{
279 //
280 // Initialize the tracing package.
281 //
283
284 return STATUS_SUCCESS;
285}
286
287VOID
289 VOID
290 )
291/*++
292
293Routine Description:
294 This routine uninitializes the frameworks tracing. It must be called just
295 before DriverUnload
296
297Arguments:
298 None
299
300Returns:
301 None
302
303--*/
304{
306}
307
311 __in TRACE_INFORMATION_CLASS /* TraceInformationClass */,
312 __out_bcount(TraceInformationLength) PVOID /* TraceInformation */,
313 __in ULONG /* TraceInformationLength */,
314 __out_opt PULONG /* RequiredLength */,
315 __in_opt PVOID /* Buffer */
316 )
317{
318 return STATUS_UNSUCCESSFUL;
319}
320
324 __in TRACEHANDLE LoggerHandle,
325 __in ULONG MessageFlags,
326 __in LPGUID MessageGuid,
328 ...
329 )
330{
332
333 va_list va;
335 //
336 // UMDF is supported only on XP and newer OS so no need to support w2k
337 // tracing (which requires using a different tracing api, see kmdf impl)
338 //
339#pragma prefast(suppress:__WARNING_BUFFER_OVERFLOW, "Recommneded by EndClean");
340 status = TraceMessageVa(LoggerHandle,
341 MessageFlags,
342 MessageGuid,
344 va);
345
346 va_end(va);
347
348 return status;
349}
350
351
352//-----------------------------------------------------------------------------
353// Subcomponents for the In-Flight Recorder follow.
354//-----------------------------------------------------------------------------
355
356ULONG
358 __in PFX_DRIVER_GLOBALS FxDriverGlobals,
360 )
361/*++
362
363Routine Description:
364 Checks to see if the service has overriden the default number of pages that
365 are in the IFR.
366
367Arguments:
368 RegistryPath - path to the service
369
370Return Value:
371 The size of the IFR to create in bytes (not pages!)
372
373 --*/
374{
375 FxAutoRegKey service, parameters;
377 ULONG numPages;
378
379 //
380 // This is the value used in case of any error while retrieving 'LogPages'
381 // from the registry.
382 //
383 numPages = FxIFRMinLogPages;
384
385 //
386 // External representation of the IFR is the "log", so use tha term when
387 // overriding the size via the registry.
388 //
389 DECLARE_CONST_UNICODE_STRING(parametersPath, L"Parameters\\Wdf");
390 DECLARE_CONST_UNICODE_STRING(valueName, L"LogPages");
391
392 //
393 // UMDF may not provide this registry path
394 //
395 if (NULL == RegistryPath) {
396 goto defaultValues;
397 }
398
399 status = FxRegKey::_OpenKey(NULL,
401 &service.m_Key,
402 KEY_READ);
403 if (!NT_SUCCESS(status)) {
404 goto defaultValues;
405 }
406
407 status = FxRegKey::_OpenKey(service.m_Key,
408 (PCUNICODE_STRING)&parametersPath,
409 &parameters.m_Key,
410 KEY_READ);
411 if (!NT_SUCCESS(status)) {
412 goto defaultValues;
413 }
414
415 status = FxRegKey::_QueryULong(parameters.m_Key, &valueName, &numPages);
416 if (!NT_SUCCESS(status)) {
417 goto defaultValues;
418 }
419
420 if (numPages == 0) {
421 numPages = FxIFRMinLogPages;
422 }
423
424defaultValues:
425 //
426 // This behavior is different from KMDF. KMDF would allocate Average page count (5)
427 // if Verifier is on otherwise 1 page if the request is large.
428 // Since for UMDF the memory is coming from WudfRd, which does not know about verifier
429 // we will give it max pages here.
430 //
431 if (numPages > FxIFRMaxLogPages) {
432 numPages = FxIFRMaxLogPages;
433 }
434
435 return numPages * PAGE_SIZE;
436}
437
438VOID
440 __in PFX_DRIVER_GLOBALS FxDriverGlobals,
443 )
444/*++
445
446Routine Description:
447
448 This routine initialize the In-Flight Recorder (IFR).
449
450 The default log size is set by WDF_IFR_LOG_SIZE and currently
451 is 4096 (one x86 page).
452 This routine should be called very early in driver initialization
453 to allow the capture of all significant events.
454
455Arguments:
456
457Returns:
458
459--*/
460{
462 ULONG pageCount;
463 ULONG sizeCb;
464 HRESULT hr;
465 IWudfDeviceStack2 *pDeviceStack2;
466 PDRIVER_OBJECT_UM umDriverObject;
468 size_t bufferLengthCch;
469 ULONG allocatedBufferLengthCb;
470 LONG i;
471
472 //
473 // Return early if IFR is disabled.
474 //
476 ASSERT(FxDriverGlobals->WdfLogHeader == NULL);
477 return;
478 }
479
481
482 if (FxDriverGlobals == NULL || FxDriverGlobals->WdfLogHeader != NULL) {
483 return;
484 }
485
486 //
487 // It is safe to use StringCchLength here as WudfHost makes sure that this
488 // RegistryPath is null terminated
489 //
491 RegistryPath->MaximumLength/sizeof(WCHAR),
492 &bufferLengthCch);
493
494 if (FAILED(hr)) {
495 return;
496 }
497
498 //
499 // Lets find the last '\' that will mark the begining of the service name
500 //
501 for (i = (ULONG)bufferLengthCch - 1;
502 i >= 0 && RegistryPath->Buffer[i] != '\\';
503 i--);
504
505 //
506 // We did not find the service name
507 //
508 if (i < 0) {
509 return;
510 }
511
512 serviceName = &RegistryPath->Buffer[i+1];
513
514 sizeCb = FxIFRGetSize(FxDriverGlobals, RegistryPath);
515 pageCount = sizeCb / PAGE_SIZE;
516
517 //
518 // Get the IWudfDeviceStack interface
519 //
520 umDriverObject = (PDRIVER_OBJECT_UM)DriverObject;
521
522 pDeviceStack2 = (IWudfDeviceStack2 *)umDriverObject->WudfDevStack;
523
524 if(pDeviceStack2 == NULL) {
525 return;
526 }
527
528 allocatedBufferLengthCb = 0;
529 hr = pDeviceStack2->AllocateIfrMemory(serviceName,
530 pageCount,
531 FALSE,
532 TRUE,
533 (PVOID *)&pHeader,
534 &allocatedBufferLengthCb);
535
536 if (pHeader == NULL || allocatedBufferLengthCb <= sizeof(WDF_IFR_HEADER)) {
537 return;
538 }
539
540 //
541 // Initialize the header.
542 // Base will be where the IFR records are placed.
543 // WPP_ThisDir_CTLGUID_FrameworksTraceGuid
544 //
545 RtlCopyMemory(&pHeader->Guid, (PVOID) &WdfTraceGuid, sizeof(GUID));
546
547 pHeader->Base = (PUCHAR) &pHeader[1];
548 pHeader->Size = allocatedBufferLengthCb - sizeof(WDF_IFR_HEADER);
549
550 pHeader->Offset.u.s.Current = 0;
551 pHeader->Offset.u.s.Previous = 0;
552 pHeader->SequenceNumberPointer = &(DriverObject->IfrSequenceNumber);
553
554 StringCchCopyA(pHeader->DriverName, WDF_IFR_HEADER_NAME_LEN, FxDriverGlobals->Public.DriverName);
555
556 FxDriverGlobals->WdfLogHeader = pHeader;
557
559 "FxIFR logging started" );
560
561 if (sizeCb > FxIFRMinLogSize) {
563 FxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGDRIVER,
564 "FxIFR has been started with a size override: size 0x%x bytes, "
565 "# Pages %d. An extended IFR size may not be written to a minidump!",
566 sizeCb, sizeCb/PAGE_SIZE);
567 }
568
569 if (sizeCb != allocatedBufferLengthCb) {
570 ASSERTMSG("FxIFR requested buffer size could not be allocated",FALSE);
572 FxDriverGlobals, TRACE_LEVEL_WARNING, TRACINGDRIVER,
573 "FxIFR requested an allocation of size 0x%x bytes, "
574 "Allocated memory was of size 0x%x bytes",
575 sizeCb, allocatedBufferLengthCb);
576 }
577}
578
579VOID
581 __in PFX_DRIVER_GLOBALS FxDriverGlobals
582 )
583/*++
584
585Routine Description:
586
587 This routine stops the In-Flight Recorder (IFR).
588
589 For UMDF FxIFRStop is no longer required as WudfRd manages the buffer's lifetime
590 The buffer is kept alive till WudfRd unloads to aid in debugging in cases of
591 WudfHost crash or in dumps with WudfHost paged out or not captured
592
593Arguments:
594
595Returns:
596
597--*/
598{
599 UNREFERENCED_PARAMETER(FxDriverGlobals);
600
601 //
602 // Uncomment the code below if you add any logic to this function.
603 //
604 // if (FxLibraryGlobals.IfrDisabled) {
605 // ASSERT(FxDriverGlobals->WdfLogHeader == NULL);
606 // return;
607 // }
608 //
609}
610
614 __in PFX_DRIVER_GLOBALS FxDriverGlobals,
615 __in UCHAR MessageLevel,
616 __in ULONG MessageFlags,
617 __in LPGUID MessageGuid,
619 ...
620 )
621/*++
622
623Routine Description:
624
625 This routine is the main In-Flight Recorder (IFR) routine.
626
627 It captures a WPP message to the IFR log.
628 The IFR is always running, e.g. not WPP logger is necessary
629 to start logging.
630
631Arguments:
632
633 MessageLevel - The WPP message level for this event
634 MessageFlags - The WPP message flags for this event (see trace GUID)
635 MessageGuid - The tracewpp generated guid for module emitting this event.
636 MessageNumber - The tracewpp generated message number within
637 the emitting module.
638 ... - Variable arguments associates with the emitted message.
639
640Returns:
641
642 NTSTATUS
643
644--*/
645{
646 size_t size;
648
649 UNREFERENCED_PARAMETER( MessageLevel );
650
651 //
652 // Return early if IFR is disabled.
653 //
655 ASSERT(FxDriverGlobals->WdfLogHeader == NULL);
656 return STATUS_SUCCESS;
657 }
658
659 if ( FxDriverGlobals->WdfLogHeader == NULL) {
660 return STATUS_UNSUCCESSFUL;
661 }
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687 UNREFERENCED_PARAMETER( MessageFlags );
688
689
690 //
691 // Determine the number bytes to follow header
692 //
693 size = 0; // For Count of Bytes
694
695 //
696 // Determine how much log space is needed for this
697 // trace record's data.
698 //
699 {
700 va_list ap;
701 size_t argLen;
702
704#pragma prefast(suppress: __WARNING_BUFFER_OVERFLOW, "Recommneded by EndClean");
705 while ((va_arg(ap, PVOID)) != NULL) {
706
707 argLen = va_arg(ap, size_t);
708
709 if (argLen > 0) {
710
711 if (argLen > FxIFRMaxMessageSize) {
712 goto drop_message;
713 }
714 size += (USHORT) argLen;
715 }
716 }
717
718 va_end(ap);
719
720 //
721 // NOTE: The final size must be 32-bit (ULONG) aligned.
722 // This is necessary for IA64 to prevent Alignment Faults.
723 //
724 size += (size % sizeof(ULONG)) ? sizeof(ULONG) - (size % sizeof(ULONG)) : 0;
725
727 goto drop_message;
728 }
729 }
730
731 size += sizeof(WDF_IFR_RECORD);
732
733 //
734 // Allocate log space of the calculated size
735 //
736 {
738 WDF_IFR_OFFSET offsetRet;
739 WDF_IFR_OFFSET offsetCur;
740 WDF_IFR_OFFSET offsetNew;
741 USHORT usSize = (USHORT) size; // for a prefast artifact.
742
743 header = (PWDF_IFR_HEADER) FxDriverGlobals->WdfLogHeader;
744 ASSERT(header->Size < FxIFRMaxLogSize); // size doesn't include header.
745 ASSERT(header->Size >= header->Offset.u.s.Current);
746 ASSERT(header->Size >= header->Offset.u.s.Previous);
747
748 offsetRet.u.AsLONG = header->Offset.u.AsLONG;
749 offsetNew.u.AsLONG = offsetRet.u.s.Current;
750
751 do {
752 offsetCur.u.AsLONG = offsetRet.u.AsLONG;
753
754 if (&header->Base[header->Size] < &header->Base[offsetCur.u.s.Current+size]) {
755
756 offsetNew.u.s.Current = 0;
757 offsetNew.u.s.Previous = offsetRet.u.s.Previous;
758
759 offsetRet.u.AsLONG =
760 InterlockedCompareExchange( &header->Offset.u.AsLONG,
761 offsetNew.u.AsLONG,
762 offsetCur.u.AsLONG );
763
764 if (offsetCur.u.AsLONG != offsetRet.u.AsLONG) {
765 continue;
766 } else {
767 offsetNew.u.s.Current = offsetCur.u.s.Current + usSize;
768 offsetNew.u.s.Previous = offsetRet.u.s.Current;
769 }
770 } else {
771
772 offsetNew.u.s.Current = offsetCur.u.s.Current + usSize;
773 offsetNew.u.s.Previous = offsetCur.u.s.Current;
774 }
775
776 offsetRet.u.AsLONG =
777 InterlockedCompareExchange( &header->Offset.u.AsLONG,
778 offsetNew.u.AsLONG,
779 offsetCur.u.AsLONG );
780
781 } while (offsetCur.u.AsLONG != offsetRet.u.AsLONG);
782
783 record = (PWDF_IFR_RECORD) &header->Base[offsetRet.u.s.Current];
784
785 // RtlZeroMemory( record, sizeof(WDF_IFR_RECORD) );
786
787 //
788 // Build record (fill all fields!)
789 //
790 record->Signature = FxIFRRecordSignature;
791 record->Length = (USHORT) size;
792 record->PrevOffset = (USHORT) offsetRet.u.s.Previous;
793 record->MessageNumber = MessageNumber;
794 record->Sequence = InterlockedIncrement(header->SequenceNumberPointer);
795 record->MessageGuid = *MessageGuid;
796 }
797
798 //
799 // Move variable part of data into log.
800 //
801 {
802 va_list ap;
803 size_t argLen;
805 PUCHAR argsData;
806
807 argsData = (UCHAR*) &record[1];
808
810#pragma prefast(suppress: __WARNING_BUFFER_OVERFLOW, "Recommneded by EndClean");
811 while ((source = va_arg(ap, PVOID)) != NULL) {
812
813 argLen = va_arg(ap, size_t);
814
815 if (argLen > 0) {
816
817 RtlCopyMemory( argsData, source, argLen );
818 argsData += argLen;
819 }
820 }
821
822 va_end(ap);
823 }
824
825 return STATUS_SUCCESS;
826
827 {
828 //
829 // Increment sequence number to indicate dropped message
830 //
831drop_message:
833 header = (PWDF_IFR_HEADER) FxDriverGlobals->WdfLogHeader;
834 InterlockedIncrement(header->SequenceNumberPointer);
835 return STATUS_UNSUCCESSFUL;
836 }
837}
838
char * va_list
Definition: acmsvcex.h:78
#define va_end(ap)
Definition: acmsvcex.h:90
#define va_start(ap, A)
Definition: acmsvcex.h:91
#define va_arg(ap, T)
Definition: acmsvcex.h:89
#define InterlockedIncrement
Definition: armddk.h:53
LONG NTSTATUS
Definition: precomp.h:26
#define __out_opt
Definition: dbghelp.h:65
#define __in
Definition: dbghelp.h:35
#define __out_bcount(x)
Definition: dbghelp.h:68
#define __in_opt
Definition: dbghelp.h:38
#define TRACINGDRIVER
Definition: dbgtrace.h:68
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define WPP_INIT_TRACING(a, b)
Definition: kdebugprint.h:56
#define WPP_CLEANUP(a)
Definition: kdebugprint.h:57
#define PAGE_SIZE
Definition: env_spec_w32.h:49
EXTERN_C ULONG WMIAPI TraceMessageVa(IN TRACEHANDLE LoggerHandle, IN ULONG MessageFlags, IN LPCGUID MessageGuid, IN USHORT MessageNumber, IN va_list MessageArgList)
ULONG64 TRACEHANDLE
Definition: evntrace.h:40
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
struct _WDF_IFR_HEADER * PWDF_IFR_HEADER
struct _WDF_IFR_RECORD WDF_IFR_RECORD
#define WDF_IFR_RECORD_SIGNATURE
Definition: fxifr.h:109
struct _WDF_IFR_HEADER WDF_IFR_HEADER
struct _WDF_IFR_RECORD * PWDF_IFR_RECORD
#define WDF_IFR_HEADER_NAME_LEN
Definition: fxifr.h:42
@ FxIFRMaxLogSize
Definition: fxifrkm.h:24
@ FxIFRMaxLogPages
Definition: fxifrkm.h:20
@ FxIFRMinLogPages
Definition: fxifrkm.h:19
@ FxIFRMinLogSize
Definition: fxifrkm.h:23
@ FxIFRMaxMessageSize
Definition: fxifrkm.h:27
@ FxIFRRecordSignature
Definition: fxifrkm.h:29
GLsizeiptr size
Definition: glext.h:5919
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
FxContextHeader * pHeader
Definition: handleapi.cpp:604
#define InterlockedCompareExchange
Definition: interlocked.h:104
#define FAILED(hr)
Definition: intsafe.h:51
#define ASSERT(a)
Definition: mode.c:44
#define _Must_inspect_result_
Definition: ms_sal.h:558
struct _DRIVER_OBJECT_UM * PDRIVER_OBJECT_UM
Definition: mxum.h:165
#define ASSERTMSG(msg, exp)
Definition: nt_native.h:431
#define KEY_READ
Definition: nt_native.h:1023
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
#define L(x)
Definition: ntvdm.h:50
long LONG
Definition: pedump.c:60
unsigned short USHORT
Definition: pedump.c:61
FxLibraryGlobalsType FxLibraryGlobals
Definition: globals.cpp:95
#define STATUS_SUCCESS
Definition: shellext.h:65
HRESULT hr
Definition: shlfolder.c:183
#define TRACE_LEVEL_WARNING
Definition: storswtr.h:28
#define TRACE_LEVEL_VERBOSE
Definition: storswtr.h:30
#define TRACE_LEVEL_INFORMATION
Definition: storswtr.h:29
STRSAFEAPI StringCchCopyA(STRSAFE_LPSTR pszDest, size_t cchDest, STRSAFE_LPCSTR pszSrc)
Definition: strsafe.h:145
#define StringCchLength
Definition: strsafe.h:829
IWudfDeviceStack2 * WudfDevStack
Definition: fxldrum.h:190
struct _WDF_IFR_OFFSET::@4759::@4760 s
union _WDF_IFR_OFFSET::@4759 u
LONG AsLONG
Definition: fxifr.h:83
Definition: ps.c:97
char serviceName[]
Definition: tftpd.cpp:34
_Must_inspect_result_ NTSTATUS FxIFR(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in UCHAR MessageLevel, __in ULONG MessageFlags, __in LPGUID MessageGuid, __in USHORT MessageNumber,...)
Definition: tracingum.cpp:613
_Must_inspect_result_ NTSTATUS FxWmiQueryTraceInformation(__in TRACE_INFORMATION_CLASS, __out_bcount(TraceInformationLength) PVOID, __in ULONG, __out_opt PULONG, __in_opt PVOID)
Definition: tracingum.cpp:310
ULONG FxIFRGetSize(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PCUNICODE_STRING RegistryPath)
Definition: tracingum.cpp:357
VOID FxIFRStart(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PCUNICODE_STRING RegistryPath, __in MdDriverObject DriverObject)
Definition: tracingum.cpp:439
VOID TraceUninitialize(VOID)
Definition: tracingum.cpp:288
VOID FxIFRStop(__in PFX_DRIVER_GLOBALS FxDriverGlobals)
Definition: tracingum.cpp:580
_Must_inspect_result_ NTSTATUS FxTraceInitialize(VOID)
Definition: tracingum.cpp:256
_Must_inspect_result_ NTSTATUS FxWmiTraceMessage(__in TRACEHANDLE LoggerHandle, __in ULONG MessageFlags, __in LPGUID MessageGuid, __in USHORT MessageNumber,...)
Definition: tracingum.cpp:323
uint32_t * PULONG
Definition: typedefs.h:59
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
uint16_t * PWCHAR
Definition: typedefs.h:56
unsigned char * PUCHAR
Definition: typedefs.h:53
uint32_t ULONG
Definition: typedefs.h:59
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define WDFCASSERT(c)
Definition: wdfassert.h:93
#define DECLARE_CONST_UNICODE_STRING(_variablename, _string)
Definition: wdfcore.h:161
_Must_inspect_result_ _In_ PDRIVER_OBJECT _In_ PCUNICODE_STRING RegistryPath
Definition: wdfdriver.h:215
_Must_inspect_result_ _In_ PDRIVER_OBJECT DriverObject
Definition: wdfdriver.h:213
void int int ULONGLONG int va_list * ap
Definition: winesup.h:36
_In_ ULONG TraceInformationLength
Definition: wmifuncs.h:29
enum _TRACE_INFORMATION_CLASS TRACE_INFORMATION_CLASS
_Must_inspect_result_ typedef _In_ ULONG _In_ ULONG MessageNumber
Definition: iotypes.h:4304
unsigned char UCHAR
Definition: xmlstorage.h:181
__wchar_t WCHAR
Definition: xmlstorage.h:180