| 1 |
# |
| 2 |
# Default configuration options for tracewpp for users who are using TCHARs |
| 3 |
# and have UNICODE defined. This is the same as defaultwpp.ini except that: |
| 4 |
# |
| 5 |
# - %s is for WCHAR* instead of CHAR*. |
| 6 |
# - %S is for CHAR* instead of WCHAR*. |
| 7 |
# - %Z is for UNICODE_STRING* instead of ANSI_STRING*. |
| 8 |
# |
| 9 |
# Refer to the defaultwpp.ini file for additional information about the syntax |
| 10 |
# of WPP INI files. |
| 11 |
|
| 12 |
################################ |
| 13 |
# Default WPP configuration |
| 14 |
################################ |
| 15 |
|
| 16 |
# our basic arithmetic types |
| 17 |
|
| 18 |
DEFINE_SIMPLE_TYPE( XINT64, signed __int64, ItemLongLongX, "I64x", i, 8, win:HexInt64); |
| 19 |
DEFINE_SIMPLE_TYPE( XXINT64,signed __int64, ItemLongLongXX,"I64X", i, 8, win:HexInt64); |
| 20 |
DEFINE_SIMPLE_TYPE( OINT64, signed __int64, ItemLongLongO, "I64o", i, 8, win:HexInt64); |
| 21 |
|
| 22 |
DEFINE_SIMPLE_TYPE( SBYTE, signed char, ItemChar, "c", c, 1, win:Int8); |
| 23 |
DEFINE_SIMPLE_TYPE( SSHORT, signed short, ItemShort, "hd", h, 2, win:Int16); |
| 24 |
DEFINE_SIMPLE_TYPE( SINT, signed int, ItemLong, "d", d, 4, win:Int32); |
| 25 |
DEFINE_SIMPLE_TYPE( SLONG, signed long, ItemLong, "ld", l, 4, win:Int32); |
| 26 |
DEFINE_SIMPLE_TYPE( SINT64, signed __int64, ItemLongLong, "I64d", i, 8, win:Int64); |
| 27 |
|
| 28 |
DEFINE_SIMPLE_TYPE( UBYTE, unsigned char, ItemChar, "c", C, 1, win:UInt8); |
| 29 |
DEFINE_SIMPLE_TYPE( USHORT, unsigned short, ItemShort, "hu", H, 2, win:UInt16); |
| 30 |
DEFINE_SIMPLE_TYPE( UINT, unsigned int, ItemLong, "u", D, 4, win:UInt32); |
| 31 |
DEFINE_SIMPLE_TYPE( ULONG, unsigned long, ItemLong, "lu", L, 4, win:UInt32); |
| 32 |
DEFINE_SIMPLE_TYPE( UINT64, unsigned __int64,ItemULongLong, "I64u", I, 8, win:UInt64); |
| 33 |
|
| 34 |
DEFINE_SIMPLE_TYPE( DOUBLE, double, ItemDouble, "s", g, 8, win:Double); |
| 35 |
|
| 36 |
DEFINE_FLAVOR( UCHAR, UBYTE, ItemUChar, "c", win:UInt8; outType=xs:string); |
| 37 |
DEFINE_FLAVOR( SCHAR, SBYTE, ItemChar, "c", win:Int8; outType=xs:string); |
| 38 |
|
| 39 |
# arch dependent types |
| 40 |
|
| 41 |
DEFINE_SIMPLE_TYPE( SLONGPTR, LONG_PTR, ItemPtr, "Id", p, 7, win:Pointer; adapter=WPP_ADAPTER_PVOID; outType=xs:long); |
| 42 |
DEFINE_SIMPLE_TYPE( ULONGPTR, ULONG_PTR, ItemPtr, "Iu", P, 7, win:Pointer; adapter=WPP_ADAPTER_PVOID; outType=xs:unsignedLong); |
| 43 |
DEFINE_SIMPLE_TYPE( PTR, const void*, ItemPtr, "p", q, 6, win:Pointer); |
| 44 |
DEFINE_SIMPLE_TYPE( HANDLE, const void*, ItemPtr, "p", q, 6, win:Pointer); |
| 45 |
|
| 46 |
DEFINE_SIMPLE_TYPE_PTR(GUID, LPCGUID, ItemGuid, "s", _guid_, 4, win:GUID); |
| 47 |
|
| 48 |
# Predefined constants. |
| 49 |
# Typically used in the function's prefix or suffix. |
| 50 |
DEFINE_SIMPLE_TYPE( COMPNAME,,, "__COMPNAME__",,); |
| 51 |
DEFINE_SIMPLE_TYPE( FILE,,, "__FILE__",,); |
| 52 |
DEFINE_SIMPLE_TYPE( LINE,,, "__LINE__",,); |
| 53 |
DEFINE_SIMPLE_TYPE( SPACE,,, " ",,); |
| 54 |
|
| 55 |
# The following can be used in the prefix or suffix. |
| 56 |
DEFINE_SIMPLE_TYPE( FUNC,,, "%!FUNC!",,); |
| 57 |
DEFINE_SIMPLE_TYPE( LEVEL,,, "%!LEVEL!",,); |
| 58 |
DEFINE_SIMPLE_TYPE( KEYWORDS,,, "%!FLAGS!",,); |
| 59 |
DEFINE_SIMPLE_TYPE( STDPREFIX,,, "%0",,); # Only works at start of prefix. Ignored for manifest-based WPP. |
| 60 |
DEFINE_SIMPLE_TYPE( MOD,,, "%1!s!",,); |
| 61 |
DEFINE_SIMPLE_TYPE( TYP,,, "%2!s!",,); |
| 62 |
DEFINE_SIMPLE_TYPE( TID,,, "%3!x!",,); |
| 63 |
DEFINE_SIMPLE_TYPE( NOW,,, "%4!s!",,); |
| 64 |
DEFINE_SIMPLE_TYPE( SEQ,,, "%7!u!",,); |
| 65 |
DEFINE_SIMPLE_TYPE( PID,,, "%8!x!",,); |
| 66 |
DEFINE_SIMPLE_TYPE( CPU,,, "%9!u!",,); |
| 67 |
|
| 68 |
# Complex types |
| 69 |
|
| 70 |
# Strings and SID require custom processing |
| 71 |
DEFINE_CPLX_TYPE(ASTR, WPP_LOGASTR, LPCSTR, ItemString, "s", s, 1, win:AnsiString); |
| 72 |
DEFINE_CPLX_TYPE(ARSTR, WPP_LOGASTR, LPCSTR, ItemRString, "s", s, 1, win:AnsiString); |
| 73 |
DEFINE_CPLX_TYPE(ARWSTR,WPP_LOGWSTR, LPCWSTR, ItemRWString,"s", S, 2, win:UnicodeString); |
| 74 |
DEFINE_CPLX_TYPE(WSTR, WPP_LOGWSTR, LPCWSTR, ItemWString, "s", S, 2, win:UnicodeString); |
| 75 |
DEFINE_CPLX_TYPE(CSTR, WPP_LOGPCSTR, const CSTRING*, ItemPString, "s", z, 1, win:CountedAnsiString; adapter=WPP_ADAPTER_PCSTR); |
| 76 |
DEFINE_CPLX_TYPE(USTR, WPP_LOGPUSTR, PCUNICODE_STRING, ItemPWString,"s", Z, 2, win:CountedUnicodeString; adapter=WPP_ADAPTER_PUSTR); |
| 77 |
DEFINE_CPLX_TYPE(ANSTR, WPP_LOGPCSTR, const ANSI_STRING*, ItemPString, "s", aZ, 1, win:CountedAnsiString; adapter=WPP_ADAPTER_PCSTR); |
| 78 |
DEFINE_CPLX_TYPE(sid, WPP_LOGPSID, PSID, ItemSid, "s", _sid_, 0, win:SID; adapter=WPP_ADAPTER_PSID); |
| 79 |
|
| 80 |
# Raw binary data. Usage: DoTraceMessage(FLAG, "%!BIN!", WppBinary(pointer, size)); |
| 81 |
DEFINE_CPLX_TYPE(BIN, WPP_LOGCSTR, WPP_BINARY, ItemHexDump, "s", _zb_, 1, win:CountedBinary; adapter=WPP_ADAPTER_BIN); |
| 82 |
|
| 83 |
# C++ string types |
| 84 |
DEFINE_CPLX_TYPE(str, WPP_LOGCPPSTR, const std::string&, ItemPString, "s", _str_, 0, win:CountedAnsiString; adapter=WPP_ADAPTER_CPPSTR); |
| 85 |
DEFINE_CPLX_TYPE(wstr, WPP_LOGCPPSTR, const std::wstring&, ItemPWString, "s", _wstr_, 0, win:CountedUnicodeString; adapter=WPP_ADAPTER_CPPSTR); |
| 86 |
DEFINE_CPLX_TYPE(sv, WPP_LOGCPPVEC, const std::string_view&, ItemPString, "s", _sv_, 0, win:CountedAnsiString; adapter=WPP_ADAPTER_CPPVEC); |
| 87 |
DEFINE_CPLX_TYPE(wsv, WPP_LOGCPPVEC, const std::wstring_view&,ItemPWString, "s", _wsv_, 0, win:CountedUnicodeString; adapter=WPP_ADAPTER_CPPVEC); |
| 88 |
|
| 89 |
# Define printf-compatible types |
| 90 |
|
| 91 |
DEFINE_FLAVOR(e, DOUBLE,,); |
| 92 |
DEFINE_FLAVOR(E, DOUBLE,,); |
| 93 |
DEFINE_FLAVOR(f, DOUBLE,,); |
| 94 |
DEFINE_FLAVOR(g, DOUBLE,,); |
| 95 |
DEFINE_FLAVOR(G, DOUBLE,,); |
| 96 |
|
| 97 |
DEFINE_FLAVOR(c, SCHAR,,); |
| 98 |
DEFINE_FLAVOR(hc, SCHAR,,); |
| 99 |
DEFINE_FLAVOR(lc, SSHORT,,); |
| 100 |
DEFINE_FLAVOR(wc, SSHORT,,); |
| 101 |
DEFINE_FLAVOR(C, SSHORT,,); |
| 102 |
|
| 103 |
DEFINE_FLAVOR(s, WSTR,,); # %s is WIDE with TCHARUNIwpp.ini. |
| 104 |
DEFINE_FLAVOR(hs, ASTR,,); |
| 105 |
DEFINE_FLAVOR(S, ASTR,,); # %S is ANSI with TCHARUNIwpp.ini. |
| 106 |
DEFINE_FLAVOR(ws, WSTR,,); |
| 107 |
DEFINE_FLAVOR(ls, WSTR,,); |
| 108 |
|
| 109 |
DEFINE_FLAVOR(hi, SSHORT,,); |
| 110 |
DEFINE_FLAVOR(hd, SSHORT,,); |
| 111 |
DEFINE_FLAVOR(hu, USHORT,,"u"); |
| 112 |
DEFINE_FLAVOR(hx, USHORT,,"x", win:UInt16; outType=win:HexInt16); |
| 113 |
DEFINE_FLAVOR(hX, USHORT,,"X", win:UInt16; outType=win:HexInt16); |
| 114 |
DEFINE_FLAVOR(ho, USHORT,,"o", win:UInt16; outType=win:HexInt16); |
| 115 |
|
| 116 |
DEFINE_FLAVOR(Id, ULONGPTR,,"Id"); |
| 117 |
DEFINE_FLAVOR(Iu, ULONGPTR,,"Iu"); |
| 118 |
DEFINE_FLAVOR(Ix, ULONGPTR,,"Ix", win:Pointer; adapter=WPP_ADAPTER_PVOID); |
| 119 |
DEFINE_FLAVOR(IX, ULONGPTR,,"IX", win:Pointer; adapter=WPP_ADAPTER_PVOID); |
| 120 |
DEFINE_FLAVOR(Io, ULONGPTR,,"Io", win:Pointer; adapter=WPP_ADAPTER_PVOID); |
| 121 |
|
| 122 |
DEFINE_FLAVOR(i, SINT,,); |
| 123 |
DEFINE_FLAVOR(d, SINT,,); |
| 124 |
DEFINE_FLAVOR(u, UINT,,"u"); |
| 125 |
DEFINE_FLAVOR(x, UINT,,"x", win:HexInt32); |
| 126 |
DEFINE_FLAVOR(X, UINT,,"X", win:HexInt32); |
| 127 |
DEFINE_FLAVOR(o, UINT,,"o", win:HexInt32); |
| 128 |
|
| 129 |
DEFINE_FLAVOR(cccc, SINT, ItemChar4, "s", win:AnsiString; length=4; adapter=WPP_ADAPTER_CCCC); |
| 130 |
|
| 131 |
DEFINE_FLAVOR(li, SLONG,,); |
| 132 |
DEFINE_FLAVOR(ld, SLONG,,); |
| 133 |
DEFINE_FLAVOR(lu, ULONG,,"u"); |
| 134 |
DEFINE_FLAVOR(lx, ULONG,,"x", win:HexInt32); |
| 135 |
DEFINE_FLAVOR(lX, ULONG,,"X", win:HexInt32); |
| 136 |
DEFINE_FLAVOR(lo, ULONG,,"o", win:HexInt32); |
| 137 |
|
| 138 |
DEFINE_FLAVOR(I64d, SINT64,,); |
| 139 |
DEFINE_FLAVOR(I64u, UINT64,,); |
| 140 |
DEFINE_FLAVOR(I64x, XINT64,,"I64x"); |
| 141 |
DEFINE_FLAVOR(I64X, XXINT64,,"I64X"); |
| 142 |
DEFINE_FLAVOR(I64o, OINT64,,"I64o"); |
| 143 |
|
| 144 |
DEFINE_FLAVOR(lld, SINT64,,); |
| 145 |
DEFINE_FLAVOR(llu, UINT64,,); |
| 146 |
DEFINE_FLAVOR(llx, XINT64,,"I64x"); |
| 147 |
DEFINE_FLAVOR(llX, XXINT64,,"I64X"); |
| 148 |
DEFINE_FLAVOR(llo, OINT64,,"I64o"); |
| 149 |
|
| 150 |
DEFINE_FLAVOR(p, PTR,,); |
| 151 |
|
| 152 |
DEFINE_FLAVOR(Z, USTR,,); # %Z is PCUNICODE_STRING with TCHARUNIwpp.ini. |
| 153 |
DEFINE_FLAVOR(wZ, USTR,,); |
| 154 |
DEFINE_FLAVOR(z, CSTR,,); |
| 155 |
DEFINE_FLAVOR(hZ, CSTR,,); |
| 156 |
|
| 157 |
# default formats for those who don't care to provide their own strings |
| 158 |
|
| 159 |
DEFINE_FLAVOR(XBYTE, SBYTE,, "02x", win:UInt8; outType=win:HexInt8); |
| 160 |
DEFINE_FLAVOR(OBYTE, SBYTE,, "o", win:UInt8; outType=win:HexInt8); |
| 161 |
|
| 162 |
DEFINE_FLAVOR(XSHORT, SSHORT,, "04hX", win:UInt16; outType=win:HexInt16); |
| 163 |
DEFINE_FLAVOR(OSHORT, SSHORT,, "ho", win:UInt16; outType=win:HexInt16); |
| 164 |
|
| 165 |
DEFINE_FLAVOR(XINT, SINT,, "08x", win:HexInt32); |
| 166 |
DEFINE_FLAVOR(OINT, SINT,, "o", win:HexInt32); |
| 167 |
|
| 168 |
DEFINE_FLAVOR(XLONG, SLONG,, "08lX", win:HexInt32); |
| 169 |
DEFINE_FLAVOR(OLONG, SLONG,, "lo", win:HexInt32); |
| 170 |
|
| 171 |
DEFINE_FLAVOR(XLONGPTR, SLONGPTR,,"Ix", win:Pointer; adapter=WPP_ADAPTER_PVOID); |
| 172 |
DEFINE_FLAVOR(OLONGPTR, SLONGPTR,,"Io", win:Pointer; adapter=WPP_ADAPTER_PVOID); |
| 173 |
|
| 174 |
# special formats |
| 175 |
|
| 176 |
DEFINE_FLAVOR(IPADDR, UINT, ItemIPAddr, "s", win:UInt32; outType=win:IPv4); |
| 177 |
DEFINE_FLAVOR(PORT, USHORT, ItemPort, "s", win:UInt16; outType=win:Port); |
| 178 |
DEFINE_FLAVOR(STATUS, SINT, ItemNTSTATUS, "s", win:HexInt32; outType=win:NTSTATUS); |
| 179 |
DEFINE_FLAVOR(WINERROR, UINT, ItemWINERROR, "s", win:UInt32; outType=win:Win32Error); |
| 180 |
DEFINE_FLAVOR(HRESULT, SINT, ItemHRESULT, "s", win:Int32; outType=win:HResult); |
| 181 |
|
| 182 |
# Note: The %!NDIS_STATUS! and %!NDIS_OID! types work for for TMF-based WPP but |
| 183 |
# do not work well with manifest-based WPP. Manifest-based ETW decoders will |
| 184 |
# treat %!NDIS_STATUS! and %!NDIS_OID! items as HexInt32 items. |
| 185 |
DEFINE_FLAVOR(NDIS_STATUS, SINT, ItemNDIS_STATUS, "s", win:HexInt32); |
| 186 |
DEFINE_FLAVOR(NDIS_OID, UINT, ItemNDIS_OID, "s", win:HexInt32); |
| 187 |
|
| 188 |
DEFINE_FLAVOR(ipaddr,IPADDR,,); |
| 189 |
DEFINE_FLAVOR(port,PORT,,); |
| 190 |
DEFINE_FLAVOR(status,STATUS,,); |
| 191 |
DEFINE_FLAVOR(hresult,HRESULT,,); |
| 192 |
DEFINE_FLAVOR(winerr,WINERROR,,); |
| 193 |
DEFINE_FLAVOR(guid,GUID,,); |
| 194 |
|
| 195 |
# time related stuff |
| 196 |
|
| 197 |
DEFINE_FLAVOR(TIMESTAMP, SINT64, ItemTimestamp, "s", win:FILETIME; adapter=WPP_ADAPTER_PFILETIME); |
| 198 |
DEFINE_FLAVOR(TIME, SINT64, ItemTimestamp, "s", win:FILETIME; adapter=WPP_ADAPTER_PFILETIME); |
| 199 |
DEFINE_FLAVOR(DATE, SINT64, ItemTimestamp, "s", win:FILETIME; adapter=WPP_ADAPTER_PFILETIME); |
| 200 |
DEFINE_FLAVOR(WAITTIME, SINT64, ItemTimestamp, "s", win:FILETIME; adapter=WPP_ADAPTER_PFILETIME); |
| 201 |
|
| 202 |
DEFINE_FLAVOR(due, SINT64, ItemWaitTime, "s", win:FILETIME; adapter=WPP_ADAPTER_PFILETIME); |
| 203 |
DEFINE_FLAVOR(delta, SINT64, ItemTimeDelta, "s"); |
| 204 |
DEFINE_FLAVOR(datetime, SINT64, ItemTimestamp, "s", win:FILETIME; adapter=WPP_ADAPTER_PFILETIME); |
| 205 |
|
| 206 |
# enumeration types |
| 207 |
|
| 208 |
DEFINE_FLAVOR(ItemListByte, SBYTE, ItemListByte, "s", win:UInt8); |
| 209 |
DEFINE_FLAVOR(ItemListShort, SSHORT, ItemListShort, "s", win:UInt16); |
| 210 |
DEFINE_FLAVOR(ItemListLong, SLONG, ItemListLong, "s", win:UInt32); |
| 211 |
|
| 212 |
DEFINE_FLAVOR(ItemSetByte, UBYTE, ItemSetByte, "s", win:UInt8; outType=win:HexInt8); |
| 213 |
DEFINE_FLAVOR(ItemSetShort, USHORT, ItemSetShort, "s", win:UInt16; outType=win:HexInt16); |
| 214 |
DEFINE_FLAVOR(ItemSetLong, ULONG, ItemSetLong, "s", win:HexInt32); |
| 215 |
|
| 216 |
# Note: The "ItemEnum" and "ItemFlagsEnum" types work for for TMF-based WPP but |
| 217 |
# do not work well with manifest-based WPP. Manifest-based ETW decoders will |
| 218 |
# treat types based on "ItemEnum" as UInt32 and will treat types based on |
| 219 |
# "ItemFlagsEnum" as HexInt32. For better results, use ItemListLong, |
| 220 |
# ItemSetLong, or a "begin_wpp enum" block for your enumeration. |
| 221 |
DEFINE_FLAVOR(ItemEnum, ULONG, ItemEnum, "s"); |
| 222 |
DEFINE_FLAVOR(ItemFlagsEnum, ULONG, ItemFlagsEnum, "s", win:HexInt32); |
| 223 |
|
| 224 |
DEFINE_FLAVOR(CLSID, GUID, ItemCLSID, "s"); |
| 225 |
DEFINE_FLAVOR(LIBID, GUID, ItemLIBID, "s"); |
| 226 |
DEFINE_FLAVOR(IID, GUID, ItemIID, "s"); |
| 227 |
|
| 228 |
CUSTOM_TYPE(b1, ItemSetByte(1,2,3,4,5,6,7,8) ); |
| 229 |
CUSTOM_TYPE(b2, ItemSetShort(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16) ); |
| 230 |
CUSTOM_TYPE(b4, ItemSetLong(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32) ); |
| 231 |
|
| 232 |
CUSTOM_TYPE(bool, ItemListLong(false,true) ); |
| 233 |
CUSTOM_TYPE(bool16, ItemListShort(false,true) ); |
| 234 |
CUSTOM_TYPE(bool8, ItemListByte(false,true) ); |
| 235 |
CUSTOM_TYPE(BOOLEAN, ItemListByte(FALSE,TRUE) ); |
| 236 |
|
| 237 |
CUSTOM_TYPE(irql, ItemListByte(Low,APC,DPC) ); |
| 238 |
|
| 239 |
CUSTOM_TYPE(pnpmn, ItemListByte(IRP_MN_START_DEVICE,IRP_MN_QUERY_REMOVE_DEVICE,IRP_MN_REMOVE_DEVICE,IRP_MN_CANCEL_REMOVE_DEVICE,IRP_MN_STOP_DEVICE,IRP_MN_QUERY_STOP_DEVICE,IRP_MN_CANCEL_STOP_DEVICE,IRP_MN_QUERY_DEVICE_RELATIONS,IRP_MN_QUERY_INTERFACE,IRP_MN_QUERY_CAPABILITIES,IRP_MN_QUERY_RESOURCES,IRP_MN_QUERY_RESOURCE_REQUIREMENTS,IRP_MN_QUERY_DEVICE_TEXT,IRP_MN_FILTER_RESOURCE_REQUIREMENTS,IRP_MN_PNP_14,IRP_MN_READ_CONFIG,IRP_MN_WRITE_CONFIG,IRP_MN_EJECT,IRP_MN_SET_LOCK,IRP_MN_QUERY_ID,IRP_MN_QUERY_PNP_DEVICE_STATE,IRP_MN_QUERY_BUS_INFORMATION,IRP_MN_DEVICE_USAGE_NOTIFICATION,IRP_MN_SURPRISE_REMOVAL) ); |
| 240 |
CUSTOM_TYPE(sysctrl, ItemListByte(IRP_MN_QUERY_ALL_DATA,IRP_MN_QUERY_SINGLE_INSTANCE, IRP_MN_CHANGE_SINGLE_INSTANCE, IRP_MN_CHANGE_SINGLE_ITEM, IRP_MN_ENABLE_EVENTS, IRP_MN_DISABLE_EVENTS, IRP_MN_ENABLE_COLLECTION, IRP_MN_DISABLE_COLLECTION, IRP_MN_REGINFO, IRP_MN_EXECUTE_METHOD, IRP_MN_Reserved_0a, IRP_MN_REGINFO_EX) ); |
| 241 |
CUSTOM_TYPE(pnpmj, ItemListByte(IRP_MJ_CREATE,IRP_MJ_CREATE_NAMED_PIPE,IRP_MJ_CLOSE,IRP_MJ_READ,IRP_MJ_WRITE,IRP_MJ_QUERY_INFORMATION,IRP_MJ_SET_INFORMATION,IRP_MJ_QUERY_EA,IRP_MJ_SET_EA,IRP_MJ_FLUSH_BUFFERS,IRP_MJ_QUERY_VOLUME_INFORMATION,IRP_MJ_SET_VOLUME_INFORMATION,IRP_MJ_DIRECTORY_CONTROL,IRP_MJ_FILE_SYSTEM_CONTROL,IRP_MJ_DEVICE_CONTROL,IRP_MJ_INTERNAL_DEVICE_CONTROL,IRP_MJ_SHUTDOWN,IRP_MJ_LOCK_CONTROL,IRP_MJ_CLEANUP,IRP_MJ_CREATE_MAILSLOT,IRP_MJ_QUERY_SECURITY,IRP_MJ_SET_SECURITY,IRP_MJ_POWER,IRP_MJ_SYSTEM_CONTROL,IRP_MJ_DEVICE_CHANGE,IRP_MJ_QUERY_QUOTA,IRP_MJ_SET_QUOTA,IRP_MJ_PNP) ); |
| 242 |
|
| 243 |
# Built-in levels (for use with manifests) |
| 244 |
|
| 245 |
DEFINE_BUILTIN_LEVEL(win:LogAlways, 0, WINEVENT_LEVEL_LOG_ALWAYS); |
| 246 |
DEFINE_BUILTIN_LEVEL(win:Critical, 1, WINEVENT_LEVEL_CRITICAL, TRACE_LEVEL_CRITICAL); |
| 247 |
DEFINE_BUILTIN_LEVEL(win:Error, 2, WINEVENT_LEVEL_ERROR, TRACE_LEVEL_ERROR); |
| 248 |
DEFINE_BUILTIN_LEVEL(win:Warning, 3, WINEVENT_LEVEL_WARNING, TRACE_LEVEL_WARNING); |
| 249 |
DEFINE_BUILTIN_LEVEL(win:Informational, 4, WINEVENT_LEVEL_INFO, TRACE_LEVEL_INFORMATION); |
| 250 |
DEFINE_BUILTIN_LEVEL(win:Verbose, 5, WINEVENT_LEVEL_VERBOSE, TRACE_LEVEL_VERBOSE); |
| 251 |
DEFINE_BUILTIN_LEVEL(win:ReservedLevel6, 6, WINEVENT_LEVEL_RESERVED_6); |
| 252 |
DEFINE_BUILTIN_LEVEL(win:ReservedLevel7, 7, WINEVENT_LEVEL_RESERVED_7); |
| 253 |
DEFINE_BUILTIN_LEVEL(win:ReservedLevel8, 8, WINEVENT_LEVEL_RESERVED_8); |
| 254 |
DEFINE_BUILTIN_LEVEL(win:ReservedLevel9, 9, WINEVENT_LEVEL_RESERVED_9); |
| 255 |
DEFINE_BUILTIN_LEVEL(win:ReservedLevel10, 10, WINEVENT_LEVEL_RESERVED_10); |
| 256 |
DEFINE_BUILTIN_LEVEL(win:ReservedLevel11, 11, WINEVENT_LEVEL_RESERVED_11); |
| 257 |
DEFINE_BUILTIN_LEVEL(win:ReservedLevel12, 12, WINEVENT_LEVEL_RESERVED_12); |
| 258 |
DEFINE_BUILTIN_LEVEL(win:ReservedLevel13, 13, WINEVENT_LEVEL_RESERVED_13); |
| 259 |
DEFINE_BUILTIN_LEVEL(win:ReservedLevel14, 14, WINEVENT_LEVEL_RESERVED_14); |
| 260 |
DEFINE_BUILTIN_LEVEL(win:ReservedLevel15, 15, WINEVENT_LEVEL_RESERVED_15); |
| 261 |
|
| 262 |
# Built-in keywords (for use with manifests) |
| 263 |
|
| 264 |
DEFINE_BUILTIN_KEYWORD(win:AnyKeyword, 0x0, WINEVT_KEYWORD_ANY); |
| 265 |
DEFINE_BUILTIN_KEYWORD(win:ResponseTime, 0x0001000000000000, WINEVENT_KEYWORD_RESPONSE_TIME); |
| 266 |
DEFINE_BUILTIN_KEYWORD(win:WDIContext, 0x0002000000000000, WINEVENT_KEYWORD_WDI_CONTEXT); |
| 267 |
DEFINE_BUILTIN_KEYWORD(win:WDIDiag, 0x0004000000000000, WINEVENT_KEYWORD_WDI_DIAG); |
| 268 |
DEFINE_BUILTIN_KEYWORD(win:SQM, 0x0008000000000000, WINEVENT_KEYWORD_SQM); |
| 269 |
DEFINE_BUILTIN_KEYWORD(win:AuditFailure, 0x0010000000000000, WINEVENT_KEYWORD_AUDIT_FAILURE); |
| 270 |
DEFINE_BUILTIN_KEYWORD(win:AuditSuccess, 0x0020000000000000, WINEVENT_KEYWORD_AUDIT_SUCCESS); |
| 271 |
DEFINE_BUILTIN_KEYWORD(win:CorrelationHint, 0x0040000000000000, WINEVENT_KEYWORD_CORRELATION_HINT); |
| 272 |
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword56, 0x0100000000000000, WINEVENT_KEYWORD_RESERVED_56); |
| 273 |
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword57, 0x0200000000000000, WINEVENT_KEYWORD_RESERVED_57); |
| 274 |
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword58, 0x0400000000000000, WINEVENT_KEYWORD_RESERVED_58); |
| 275 |
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword59, 0x0800000000000000, WINEVENT_KEYWORD_RESERVED_59); |
| 276 |
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword60, 0x1000000000000000, WINEVENT_KEYWORDE_RESERVED_60); |
| 277 |
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword61, 0x2000000000000000, WINEVENT_KEYWORD_RESERVED_61); |
| 278 |
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword62, 0x4000000000000000, WINEVENT_KEYWORD_RESERVED_62); |
| 279 |
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword63, 0x8000000000000000, WINEVENT_KEYWORD_RESERVED_63); |
| 280 |
|
| 281 |
# default tracing macros |
| 282 |
FUNC DoTraceMessage(LEVEL,MSG,...); # Uses WPP-provided ENABLED/LOGGER macros |
| 283 |
FUNC DoDebugTrace(TRACELEVEL,MSG,...); # Requires used-defined ENABLED/LOGGER macros |
| 284 |
|
| 285 |
# default prefix (use traceprt default) |
| 286 |
USEPREFIX(*,"%!STDPREFIX!"); # traceprt will add standard prefix |
| 287 |
|
| 288 |
# the source file that calls WPP_INIT_TRACING is given special treatment |
| 289 |
WPP_FLAGS(-lookfor:WPP_INIT_TRACING); |