vendor/winapi/src/um/pdh.rs

   1 // Licensed under the Apache License, Version 2.0
   2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
   4 // All files in the project carrying such notice may not be copied, modified, or distributed
   5 // except according to those terms.
   6 //! Common Performance Data Helper definitions
   7 use ctypes::c_double;
   8 use shared::basetsd::DWORD_PTR;
   9 use shared::guiddef::GUID;
  10 use shared::minwindef::{BOOL, DWORD, FILETIME, LPDWORD, UCHAR};
  11 use shared::windef::HWND;
  12 use um::winnt::{BOOLEAN, HANDLE, LONG, LONGLONG, LPCSTR, LPCWSTR, LPSTR, LPWSTR};
  13 pub const PDH_FMT_RAW: DWORD = 0x00000010;
  14 pub const PDH_FMT_ANSI: DWORD = 0x00000020;
  15 pub const PDH_FMT_UNICODE: DWORD = 0x00000040;
  16 pub const PDH_FMT_LONG: DWORD = 0x00000100;
  17 pub const PDH_FMT_DOUBLE: DWORD = 0x00000200;
  18 pub const PDH_FMT_LARGE: DWORD = 0x00000400;
  19 pub const PDH_FMT_NOSCALE: DWORD = 0x00001000;
  20 pub const PDH_FMT_1000: DWORD = 0x00002000;
  21 pub const PDH_FMT_NODATA: DWORD = 0x00004000;
  22 pub const PDH_FMT_NOCAP100: DWORD = 0x00008000;
  23 pub const PERF_DETAIL_COSTLY: DWORD = 0x00010000;
  24 pub const PERF_DETAIL_STANDARD: DWORD = 0x0000FFFF;
  25 pub type PDH_STATUS = LONG;
  26 pub type PDH_HQUERY = HANDLE;
  27 pub type HQUERY = PDH_HQUERY;
  28 pub type PDH_HCOUNTER = HANDLE;
  29 pub type HCOUNTER = PDH_HCOUNTER;
  30 pub type PPDH_BROWSE_DLG_CONFIG_A = *mut PDH_BROWSE_DLG_CONFIG_A;
  31 pub type PPDH_BROWSE_DLG_CONFIG_W = *mut PDH_BROWSE_DLG_CONFIG_W;
  32 pub type PDH_HLOG = HANDLE;
  33 pub type PPDH_RAW_LOG_RECORD = *mut PDH_RAW_LOG_RECORD;
  34 pub type PPDH_TIME_INFO = *mut PDH_TIME_INFO;
  35 pub type PPDH_RAW_COUNTER = *mut PDH_RAW_COUNTER;
  36 pub type PPDH_COUNTER_INFO_A = *mut PDH_COUNTER_INFO_A;
  37 pub type PPDH_COUNTER_INFO_W = *mut PDH_COUNTER_INFO_W;
  38 pub type PPDH_STATISTICS = *mut PDH_STATISTICS;
  39 pub type PPDH_FMT_COUNTERVALUE_ITEM_A = *mut PDH_FMT_COUNTERVALUE_ITEM_A;
  40 pub type PPDH_FMT_COUNTERVALUE_ITEM_W = *mut PDH_FMT_COUNTERVALUE_ITEM_W;
  41 pub type PPDH_DATA_ITEM_PATH_ELEMENTS_A = *mut PDH_DATA_ITEM_PATH_ELEMENTS_A;
  42 pub type PPDH_DATA_ITEM_PATH_ELEMENTS_W = *mut PDH_DATA_ITEM_PATH_ELEMENTS_W;
  43 pub type PPDH_FMT_COUNTERVALUE = *mut PDH_FMT_COUNTERVALUE;
  44 FN!{stdcall CounterPathCallBack(
  45     DWORD_PTR,
  46 ) -> PDH_STATUS}
  47 pub type PPDH_COUNTER_PATH_ELEMENTS_A = *mut PDH_COUNTER_PATH_ELEMENTS_A;
  48 pub type PPDH_COUNTER_PATH_ELEMENTS_W = *mut PDH_COUNTER_PATH_ELEMENTS_W;
  49 pub type PPDH_BROWSE_DLG_CONFIG_HA = *mut PDH_BROWSE_DLG_CONFIG_HA;
  50 pub type PPDH_BROWSE_DLG_CONFIG_HW = *mut PDH_BROWSE_DLG_CONFIG_HW;
  51 UNION!{union PDH_FMT_COUNTERVALUE_u {
  52     [u64; 1],
  53     longValue longValue_mut: LONG,
  54     doubleValue doubleValue_mut: c_double,
  55     largeValue largeValue_mut: LONGLONG,
  56     AnsiStringValue AnsiStringValue_mut: LPCSTR,
  57     WideStringValue WideStringValue_mut: LPCWSTR,
  58 }}
  59 STRUCT!{struct PDH_FMT_COUNTERVALUE {
  60     CStatus: DWORD,
  61     u: PDH_FMT_COUNTERVALUE_u,
  62 }}
  63 STRUCT!{struct PDH_RAW_LOG_RECORD {
  64     dwStructureSize: DWORD,
  65     dwRecordType: DWORD,
  66     dwItems: DWORD,
  67     RawBytes: UCHAR,
  68 }}
  69 STRUCT!{struct PDH_TIME_INFO {
  70     StartTime: LONGLONG,
  71     EndTime: LONGLONG,
  72     SampleCount: DWORD,
  73 }}
  74 STRUCT!{struct PDH_RAW_COUNTER {
  75     CStatus: DWORD,
  76     TimeStamp: FILETIME,
  77     FirstValue: LONGLONG,
  78     SecondValue: LONGLONG,
  79     MultiCount: DWORD,
  80 }}
  81 STRUCT!{struct PDH_STATISTICS {
  82     dwFormat: DWORD,
  83     count: DWORD,
  84     min: PDH_FMT_COUNTERVALUE,
  85     max: PDH_FMT_COUNTERVALUE,
  86     mean: PDH_FMT_COUNTERVALUE,
  87 }}
  88 STRUCT!{struct PDH_FMT_COUNTERVALUE_ITEM_A {
  89     szName: LPSTR,
  90     FmtValue: PDH_FMT_COUNTERVALUE,
  91 }}
  92 STRUCT!{struct PDH_FMT_COUNTERVALUE_ITEM_W {
  93     szName: LPWSTR,
  94     FmtValue: PDH_FMT_COUNTERVALUE,
  95 }}
  96 STRUCT!{struct PDH_BROWSE_DLG_CONFIG_A {
  97     flags: DWORD,
  98     hWndOwner: HWND,
  99     szDataSource: LPSTR,
 100     szReturnPathBuffer: LPSTR,
 101     cchReturnPathLength: DWORD,
 102     pCallBack: CounterPathCallBack,
 103     dwCallBackArg: DWORD_PTR,
 104     CallBackStatus: PDH_STATUS,
 105     dwDefaultDetailLevel: DWORD,
 106     szDialogBoxCaption: LPSTR,
 107 }}
 108 BITFIELD!{PDH_BROWSE_DLG_CONFIG_A flags: DWORD [
 109     IncludeInstanceIndex set_IncludeInstanceIndex[0..1],
 110     SingleCounterPerAdd set_SingleCounterPerAdd[1..2],
 111     SingleCounterPerDialog set_SingleCounterPerDialog[2..3],
 112     LocalCountersOnly set_LocalCountersOnly[3..4],
 113     WildCardInstances set_WildCardInstances[4..5],
 114     HideDetailBox set_HideDetailBox[5..6],
 115     InitializePath set_InitializePath[6..7],
 116     DisableMachineSelection set_DisableMachineSelection[7..8],
 117     IncludeCostlyObjects set_IncludeCostlyObjects[8..9],
 118     ShowObjectBrowser set_ShowObjectBrowser[9..10],
 119 ]}
 120 STRUCT!{struct PDH_BROWSE_DLG_CONFIG_W {
 121     flags: DWORD,
 122     hWndOwner: HWND,
 123     szDataSource: LPWSTR,
 124     szReturnPathBuffer: LPWSTR,
 125     cchReturnPathLength: DWORD,
 126     pCallBack: CounterPathCallBack,
 127     dwCallBackArg: DWORD_PTR,
 128     CallBackStatus: PDH_STATUS,
 129     dwDefaultDetailLevel: DWORD,
 130     szDialogBoxCaption: LPWSTR,
 131 }}
 132 BITFIELD!{PDH_BROWSE_DLG_CONFIG_W flags: DWORD [
 133     IncludeInstanceIndex set_IncludeInstanceIndex[0..1],
 134     SingleCounterPerAdd set_SingleCounterPerAdd[1..2],
 135     SingleCounterPerDialog set_SingleCounterPerDialog[2..3],
 136     LocalCountersOnly set_LocalCountersOnly[3..4],
 137     WildCardInstances set_WildCardInstances[4..5],
 138     HideDetailBox set_HideDetailBox[5..6],
 139     InitializePath set_InitializePath[6..7],
 140     DisableMachineSelection set_DisableMachineSelection[7..8],
 141     IncludeCostlyObjects set_IncludeCostlyObjects[8..9],
 142     ShowObjectBrowser set_ShowObjectBrowser[9..10],
 143 ]}
 144 STRUCT!{struct PDH_COUNTER_PATH_ELEMENTS_A {
 145     szMachineName: LPSTR,
 146     szObjectName: LPSTR,
 147     szInstanceName: LPSTR,
 148     szParentInstance: LPSTR,
 149     dwInstanceIndex: DWORD,
 150     szCounterName: LPSTR,
 151 }}
 152 STRUCT!{struct PDH_COUNTER_PATH_ELEMENTS_W {
 153     szMachineName: LPWSTR,
 154     szObjectName: LPWSTR,
 155     szInstanceName: LPWSTR,
 156     szParentInstance: LPWSTR,
 157     dwInstanceIndex: DWORD,
 158     szCounterName: LPWSTR,
 159 }}
 160 STRUCT!{struct PDH_DATA_ITEM_PATH_ELEMENTS_A {
 161     szMachineName: LPSTR,
 162     ObjectGUID: GUID,
 163     dwItemId: DWORD,
 164     szInstanceName: LPSTR,
 165 }}
 166 STRUCT!{struct PDH_DATA_ITEM_PATH_ELEMENTS_W {
 167     szMachineName: LPWSTR,
 168     ObjectGUID: GUID,
 169     dwItemId: DWORD,
 170     szInstanceName: LPWSTR,
 171 }}
 172 STRUCT!{struct PDH_COUNTER_INFO_A_u_s {
 173     szMachineName: LPSTR,
 174     szObjectName: LPSTR,
 175     szInstanceName: LPSTR,
 176     szParentInstance: LPSTR,
 177     dwInstanceIndex: DWORD,
 178     szCounterName: LPSTR,
 179 }}
 180 UNION!{union PDH_COUNTER_INFO_A_u {
 181     [u32; 7] [u64; 6],
 182     DataItemPath DataItemPath_mut: PDH_DATA_ITEM_PATH_ELEMENTS_A,
 183     CounterPath CounterPath_mut: PDH_COUNTER_PATH_ELEMENTS_A,
 184     s s_mut: PDH_COUNTER_INFO_A_u_s,
 185 }}
 186 STRUCT!{struct PDH_COUNTER_INFO_A {
 187     dwLength: DWORD,
 188     dwType: DWORD,
 189     CVersion: DWORD,
 190     CStatus: DWORD,
 191     lScale: LONG,
 192     lDefaultScale: LONG,
 193     dwUserData: DWORD_PTR,
 194     dwQueryUserData: DWORD_PTR,
 195     szFullPath: LPSTR,
 196     u: PDH_COUNTER_INFO_A_u,
 197     szExplainText: LPSTR,
 198     DataBuffer: [DWORD; 1],
 199 }}
 200 STRUCT!{struct PDH_COUNTER_INFO_W_u_s {
 201     szMachineName: LPWSTR,
 202     szObjectName: LPWSTR,
 203     szInstanceName: LPWSTR,
 204     szParentInstance: LPWSTR,
 205     dwInstanceIndex: DWORD,
 206     szCounterName: LPWSTR,
 207 }}
 208 UNION!{union PDH_COUNTER_INFO_W_u {
 209     [u32; 7] [u64; 6],
 210     DataItemPath DataItemPath_mut: PDH_DATA_ITEM_PATH_ELEMENTS_W,
 211     CounterPath CounterPath_mut: PDH_COUNTER_PATH_ELEMENTS_W,
 212     s s_mut: PDH_COUNTER_INFO_W_u_s,
 213 }}
 214 STRUCT!{struct PDH_COUNTER_INFO_W {
 215     dwLength: DWORD,
 216     dwType: DWORD,
 217     CVersion: DWORD,
 218     CStatus: DWORD,
 219     lScale: LONG,
 220     lDefaultScale: LONG,
 221     dwUserData: DWORD_PTR,
 222     dwQueryUserData: DWORD_PTR,
 223     szFullPath: LPWSTR,
 224     u: PDH_COUNTER_INFO_W_u,
 225     szExplainText: LPWSTR,
 226     DataBuffer: [DWORD; 1],
 227 }}
 228 STRUCT!{struct PDH_BROWSE_DLG_CONFIG_HA {
 229     flags: DWORD,
 230     hWndOwner: HWND,
 231     hDataSource: PDH_HLOG,
 232     szReturnPathBuffer: LPSTR,
 233     cchReturnPathLength: DWORD,
 234     pCallBack: CounterPathCallBack,
 235     dwCallBackArg: DWORD_PTR,
 236     CallBackStatus: PDH_STATUS,
 237     dwDefaultDetailLevel: DWORD,
 238     szDialogBoxCaption: LPSTR,
 239 }}
 240 BITFIELD!{PDH_BROWSE_DLG_CONFIG_HA flags: DWORD [
 241     IncludeInstanceIndex set_IncludeInstanceIndex[0..1],
 242     SingleCounterPerAdd set_SingleCounterPerAdd[1..2],
 243     SingleCounterPerDialog set_SingleCounterPerDialog[2..3],
 244     LocalCountersOnly set_LocalCountersOnly[3..4],
 245     WildCardInstances set_WildCardInstances[4..5],
 246     HideDetailBox set_HideDetailBox[5..6],
 247     InitializePath set_InitializePath[6..7],
 248     DisableMachineSelection set_DisableMachineSelection[7..8],
 249     IncludeCostlyObjects set_IncludeCostlyObjects[8..9],
 250     ShowObjectBrowser set_ShowObjectBrowser[9..10],
 251 ]}
 252 STRUCT!{struct PDH_BROWSE_DLG_CONFIG_HW {
 253     flags: DWORD,
 254     hWndOwner: HWND,
 255     hDataSource: PDH_HLOG,
 256     szReturnPathBuffer: LPWSTR,
 257     cchReturnPathLength: DWORD,
 258     pCallBack: CounterPathCallBack,
 259     dwCallBackArg: DWORD_PTR,
 260     CallBackStatus: PDH_STATUS,
 261     dwDefaultDetailLevel: DWORD,
 262     szDialogBoxCaption: LPWSTR,
 263 }}
 264 BITFIELD!{PDH_BROWSE_DLG_CONFIG_HW flags: DWORD [
 265     IncludeInstanceIndex set_IncludeInstanceIndex[0..1],
 266     SingleCounterPerAdd set_SingleCounterPerAdd[1..2],
 267     SingleCounterPerDialog set_SingleCounterPerDialog[2..3],
 268     LocalCountersOnly set_LocalCountersOnly[3..4],
 269     WildCardInstances set_WildCardInstances[4..5],
 270     HideDetailBox set_HideDetailBox[5..6],
 271     InitializePath set_InitializePath[6..7],
 272     DisableMachineSelection set_DisableMachineSelection[7..8],
 273     IncludeCostlyObjects set_IncludeCostlyObjects[8..9],
 274     ShowObjectBrowser set_ShowObjectBrowser[9..10],
 275 ]}
 276 extern "system" {
 277     pub fn PdhGetDllVersion(
 278         lpdwVersion: LPDWORD,
 279     ) -> PDH_STATUS;
 280     pub fn PdhOpenQueryW(
 281         szDataSource: LPCWSTR,
 282         dwUserData: DWORD_PTR,
 283         phQuery: *mut PDH_HQUERY,
 284     ) -> PDH_STATUS;
 285     pub fn PdhOpenQueryA(
 286         szDataSource: LPCSTR,
 287         dwUserData: DWORD_PTR,
 288         phQuery: *mut PDH_HQUERY,
 289     ) -> PDH_STATUS;
 290     pub fn PdhAddCounterW(
 291         hQuery: PDH_HQUERY,
 292         szFullCounterPath: LPCWSTR,
 293         dwUserData: DWORD_PTR,
 294         phCounter: *mut PDH_HCOUNTER,
 295     ) -> PDH_STATUS;
 296     pub fn PdhAddCounterA(
 297         hQuery: PDH_HQUERY,
 298         szFullCounterPath: LPCSTR,
 299         dwUserData: DWORD_PTR,
 300         phCounter: *mut PDH_HCOUNTER,
 301     ) -> PDH_STATUS;
 302     pub fn PdhAddEnglishCounterW(
 303         hQuery: PDH_HQUERY,
 304         szFullCounterPath: LPCWSTR,
 305         dwUserData: DWORD_PTR,
 306         phCounter: *mut PDH_HCOUNTER,
 307     ) -> PDH_STATUS;
 308     pub fn PdhAddEnglishCounterA(
 309         hQuery: PDH_HQUERY,
 310         szFullCounterPath: LPCSTR,
 311         dwUserData: DWORD_PTR,
 312         phCounter: *mut PDH_HCOUNTER,
 313     ) -> PDH_STATUS;
 314     pub fn PdhCollectQueryDataWithTime(
 315         hQuery: PDH_HQUERY,
 316         pllTimeStamp: *mut LONGLONG,
 317     ) -> PDH_STATUS;
 318     pub fn PdhValidatePathExW(
 319         hDataSource: PDH_HLOG,
 320         szFullPathBuffer: LPCWSTR,
 321     ) -> PDH_STATUS;
 322     pub fn PdhValidatePathExA(
 323         hDataSource: PDH_HLOG,
 324         szFullPathBuffer: LPCSTR,
 325     ) -> PDH_STATUS;
 326     pub fn PdhRemoveCounter(
 327         hCounter: PDH_HCOUNTER,
 328     ) -> PDH_STATUS;
 329     pub fn PdhCollectQueryData(
 330         hQuery: PDH_HQUERY,
 331     ) -> PDH_STATUS;
 332     pub fn PdhCloseQuery(
 333         hQuery: PDH_HQUERY,
 334     ) -> PDH_STATUS;
 335     pub fn PdhGetFormattedCounterValue(
 336         hCounter: PDH_HCOUNTER,
 337         dwFormat: DWORD,
 338         lpdwType: LPDWORD,
 339         pValue: PPDH_FMT_COUNTERVALUE,
 340     ) -> PDH_STATUS;
 341     pub fn PdhGetFormattedCounterArrayA(
 342         hCounter: PDH_HCOUNTER,
 343         dwFormat: DWORD,
 344         lpdwBufferSize: LPDWORD,
 345         lpdwBufferCount: LPDWORD,
 346         ItemBuffer: PPDH_FMT_COUNTERVALUE_ITEM_A,
 347     ) -> PDH_STATUS;
 348     pub fn PdhGetFormattedCounterArrayW(
 349         hCounter: PDH_HCOUNTER,
 350         dwFormat: DWORD,
 351         lpdwBufferSize: LPDWORD,
 352         lpdwBufferCount: LPDWORD,
 353         ItemBuffer: PPDH_FMT_COUNTERVALUE_ITEM_W,
 354     ) -> PDH_STATUS;
 355     pub fn PdhGetRawCounterValue(
 356         hCounter: PDH_HCOUNTER,
 357         lpdwType: LPDWORD,
 358         pValue: PPDH_RAW_COUNTER,
 359     ) -> PDH_STATUS;
 360     pub fn PdhGetRawCounterArrayA(
 361         hCounter: PDH_HCOUNTER,
 362         dwFormat: DWORD,
 363         lpdwBufferSize: LPDWORD,
 364         lpdwBufferCount: LPDWORD,
 365         ItemBuffer: PPDH_FMT_COUNTERVALUE_ITEM_A,
 366     ) -> PDH_STATUS;
 367     pub fn PdhGetRawCounterArrayW(
 368         hCounter: PDH_HCOUNTER,
 369         dwFormat: DWORD,
 370         lpdwBufferSize: LPDWORD,
 371         lpdwBufferCount: LPDWORD,
 372         ItemBuffer: PPDH_FMT_COUNTERVALUE_ITEM_W,
 373     ) -> PDH_STATUS;
 374     pub fn PdhCalculateCounterFromRawValue(
 375         hCounter: PDH_HCOUNTER,
 376         dwFormat: DWORD,
 377         rawValue1: PPDH_RAW_COUNTER,
 378         rawValue2: PPDH_RAW_COUNTER,
 379         fmtValue: PPDH_FMT_COUNTERVALUE,
 380     ) -> PDH_STATUS;
 381     pub fn PdhComputeCounterStatistics(
 382         hCounter: PDH_HCOUNTER,
 383         dwFormat: DWORD,
 384         dwFirstEntry: DWORD,
 385         dwNumEntries: DWORD,
 386         lpRawValueArray: PPDH_RAW_COUNTER,
 387         data: PPDH_STATISTICS,
 388     ) -> PDH_STATUS;
 389     pub fn PdhGetCounterInfoW(
 390         hCounter: PDH_HCOUNTER,
 391         bRetrieveExplainText: BOOLEAN,
 392         pdwBufferSize: LPDWORD,
 393         lpBuffer: PPDH_COUNTER_INFO_W,
 394     ) -> PDH_STATUS;
 395     pub fn PdhGetCounterInfoA(
 396         hCounter: PDH_HCOUNTER,
 397         bRetrieveExplainText: BOOLEAN,
 398         pdwBufferSize: LPDWORD,
 399         lpBuffer: PPDH_COUNTER_INFO_A,
 400     ) -> PDH_STATUS;
 401     pub fn PdhSetCounterScaleFactor(
 402         hCounter: PDH_HCOUNTER,
 403         lFactor: LONG,
 404     ) -> PDH_STATUS;
 405     pub fn PdhConnectMachineW(
 406         szMachineName: LPCWSTR,
 407     ) -> PDH_STATUS;
 408     pub fn PdhConnectMachineA(
 409         szMachineName: LPCSTR,
 410     ) -> PDH_STATUS;
 411     pub fn PdhEnumMachinesW(
 412         szDataSource: LPCWSTR,
 413         mszMachineNameList: LPWSTR,
 414         pcchBufferLength: LPDWORD,
 415     ) -> PDH_STATUS;
 416     pub fn PdhEnumMachinesA(
 417         szDataSource: LPCSTR,
 418         mszMachineNameList: LPSTR,
 419         pcchBufferLength: LPDWORD,
 420     ) -> PDH_STATUS;
 421     pub fn PdhEnumObjectsW(
 422         szDataSource: LPCWSTR,
 423         szMachineName: LPCWSTR,
 424         mszObjectList: LPWSTR,
 425         pcchBufferLength: LPDWORD,
 426         dwDetailLevel: DWORD,
 427         bRefresh: BOOL,
 428     ) -> PDH_STATUS;
 429     pub fn PdhEnumObjectsA(
 430         szDataSource: LPCSTR,
 431         szMachineName: LPCSTR,
 432         mszObjectList: LPSTR,
 433         pcchBufferLength: LPDWORD,
 434         dwDetailLevel: DWORD,
 435         bRefresh: BOOL,
 436     ) -> PDH_STATUS;
 437     pub fn PdhEnumObjectItemsW(
 438         szDataSource: LPCWSTR,
 439         szMachineName: LPCWSTR,
 440         szObjectName: LPCWSTR,
 441         mszCounterList: LPWSTR,
 442         pcchCounterListLength: LPDWORD,
 443         mszInstanceList: LPWSTR,
 444         pcchInstanceListLength: LPDWORD,
 445         dwDetailLevel: DWORD,
 446         dwFlags: DWORD,
 447     ) -> PDH_STATUS;
 448     pub fn PdhEnumObjectItemsA(
 449         szDataSource: LPCSTR,
 450         szMachineName: LPCSTR,
 451         szObjectName: LPCSTR,
 452         mszCounterList: LPSTR,
 453         pcchCounterListLength: LPDWORD,
 454         mszInstanceList: LPSTR,
 455         pcchInstanceListLength: LPDWORD,
 456         dwDetailLevel: DWORD,
 457         dwFlags: DWORD,
 458     ) -> PDH_STATUS;
 459     pub fn PdhMakeCounterPathW(
 460         pCounterPathElements: PPDH_COUNTER_PATH_ELEMENTS_W,
 461         szFullPathBuffer: LPWSTR,
 462         pcchBufferSize: LPDWORD,
 463         dwFlags: DWORD,
 464     ) -> PDH_STATUS;
 465     pub fn PdhMakeCounterPathA(
 466         pCounterPathElements: PPDH_COUNTER_PATH_ELEMENTS_A,
 467         szFullPathBuffer: LPSTR,
 468         pcchBufferSize: LPDWORD,
 469         dwFlags: DWORD,
 470     ) -> PDH_STATUS;
 471     pub fn PdhParseCounterPathW(
 472         szFullPathBuffer: LPCWSTR,
 473         pCounterPathElements: *mut PDH_COUNTER_PATH_ELEMENTS_W,
 474         pcchBufferSize: LPDWORD,
 475         dwFlags: DWORD,
 476     ) -> PDH_STATUS;
 477     pub fn PdhParseCounterPathA(
 478         szFullPathBuffer: LPCSTR,
 479         pCounterPathElements: *mut PDH_COUNTER_PATH_ELEMENTS_A,
 480         pcchBufferSize: LPDWORD,
 481         dwFlags: DWORD,
 482     ) -> PDH_STATUS;
 483     pub fn PdhParseInstanceNameW(
 484         szInstanceString: LPCWSTR,
 485         szInstanceName: LPWSTR,
 486         pcchInstanceNameLength: LPDWORD,
 487         szParentName: LPWSTR,
 488         pcchParentNameLength: LPDWORD,
 489         lpIndex: LPDWORD,
 490     ) -> PDH_STATUS;
 491     pub fn PdhParseInstanceNameA(
 492         szInstanceString: LPCSTR,
 493         szInstanceName: LPSTR,
 494         pcchInstanceNameLength: LPDWORD,
 495         szParentName: LPSTR,
 496         pcchParentNameLength: LPDWORD,
 497         lpIndex: LPDWORD,
 498     ) -> PDH_STATUS;
 499     pub fn PdhValidatePathW(
 500         szFullCounterPath: LPCWSTR,
 501     ) -> PDH_STATUS;
 502     pub fn PdhValidatePathA(
 503         szFullCounterPath: LPCSTR,
 504     ) -> PDH_STATUS;
 505     pub fn PdhGetDefaultPerfObjectW(
 506         szDataSource: LPCWSTR,
 507         szMachineName: LPCWSTR,
 508         szDefaultObjectName: LPWSTR,
 509         pcchBufferSize: LPDWORD,
 510     ) -> PDH_STATUS;
 511     pub fn PdhGetDefaultPerfObjectA(
 512         szDataSource: LPCSTR,
 513         szMachineName: LPCSTR,
 514         szDefaultObjectName: LPSTR,
 515         pcchBufferSize: LPDWORD,
 516     ) -> PDH_STATUS;
 517     pub fn PdhGetDefaultPerfCounterW(
 518         szDataSource: LPCWSTR,
 519         szMachineName: LPCWSTR,
 520         szObjectName: LPCWSTR,
 521         szDefaultCounterName: LPWSTR,
 522         pcchBufferSize: LPDWORD,
 523     ) -> PDH_STATUS;
 524     pub fn PdhGetDefaultPerfCounterA(
 525         szDataSource: LPCSTR,
 526         szMachineName: LPCSTR,
 527         szObjectName: LPCSTR,
 528         szDefaultCounterName: LPSTR,
 529         pcchBufferSize: LPDWORD,
 530     ) -> PDH_STATUS;
 531     pub fn PdhBrowseCountersW(
 532         pBrowseDlgData: PPDH_BROWSE_DLG_CONFIG_W,
 533     ) -> PDH_STATUS;
 534     pub fn PdhBrowseCountersA(
 535         pBrowseDlgData: PPDH_BROWSE_DLG_CONFIG_A,
 536     ) -> PDH_STATUS;
 537     pub fn PdhExpandCounterPathW(
 538         szWildCardPath: LPCWSTR,
 539         mszExpandedPathList: LPWSTR,
 540         pcchPathListLength: LPDWORD,
 541     ) -> PDH_STATUS;
 542     pub fn PdhExpandCounterPathA(
 543         szWildCardPath: LPCSTR,
 544         mszExpandedPathList: LPSTR,
 545         pcchPathListLength: LPDWORD,
 546     ) -> PDH_STATUS;
 547     pub fn PdhLookupPerfNameByIndexW(
 548         szMachineName: LPCWSTR,
 549         dwNameIndex: DWORD,
 550         szNameBuffer: LPWSTR,
 551         pcchNameBufferSize: LPDWORD,
 552     ) -> PDH_STATUS;
 553     pub fn PdhLookupPerfNameByIndexA(
 554         szMachineName: LPCSTR,
 555         dwNameIndex: DWORD,
 556         szNameBuffer: LPSTR,
 557         pcchNameBufferSize: LPDWORD,
 558     ) -> PDH_STATUS;
 559     pub fn PdhLookupPerfIndexByNameW(
 560         szMachineName: LPCWSTR,
 561         szNameBuffer: LPCWSTR,
 562         pdwIndex: LPDWORD,
 563     ) -> PDH_STATUS;
 564     pub fn PdhLookupPerfIndexByNameA(
 565         szMachineName: LPCSTR,
 566         szNameBuffer: LPCSTR,
 567         pdwIndex: LPDWORD,
 568     ) -> PDH_STATUS;
 569     pub fn PdhExpandWildCardPathW(
 570         szDataSource: LPCWSTR,
 571         szWildCardPath: LPCWSTR,
 572         mszExpandedPathList: LPWSTR,
 573         pcchPathListLength: LPDWORD,
 574         dwFlags: DWORD,
 575     ) -> PDH_STATUS;
 576     pub fn PdhExpandWildCardPathA(
 577         szDataSource: LPCSTR,
 578         szWildCardPath: LPCSTR,
 579         mszExpandedPathList: LPSTR,
 580         pcchPathListLength: LPDWORD,
 581         dwFlags: DWORD,
 582     ) -> PDH_STATUS;
 583     pub fn PdhOpenLogW(
 584         szLogFileName: LPCWSTR,
 585         dwAccessFlags: DWORD,
 586         lpdwLogType: LPDWORD,
 587         hQuery: PDH_HQUERY,
 588         dwMaxSize: DWORD,
 589         szUserCaption: LPCWSTR,
 590         phLog: *mut PDH_HLOG,
 591     ) -> PDH_STATUS;
 592     pub fn PdhOpenLogA(
 593         szLogFileName: LPCSTR,
 594         dwAccessFlags: DWORD,
 595         lpdwLogType: LPDWORD,
 596         hQuery: PDH_HQUERY,
 597         dwMaxSize: DWORD,
 598         szUserCaption: LPCSTR,
 599         phLog: *mut PDH_HLOG,
 600     ) -> PDH_STATUS;
 601     pub fn PdhUpdateLogW(
 602         hLog: PDH_HLOG,
 603         szUserString: LPCWSTR,
 604     ) -> PDH_STATUS;
 605     pub fn PdhUpdateLogA(
 606         hLog: PDH_HLOG,
 607         szUserString: LPCSTR,
 608     ) -> PDH_STATUS;
 609     pub fn PdhUpdateLogFileCatalog(
 610         hLog: PDH_HLOG,
 611     ) -> PDH_STATUS;
 612     pub fn PdhGetLogFileSize(
 613         hLog: PDH_HLOG,
 614         llSize: *mut LONGLONG,
 615     ) -> PDH_STATUS;
 616     pub fn PdhCloseLog(
 617         hLog: PDH_HLOG,
 618         dwFlags: DWORD,
 619     ) -> PDH_STATUS;
 620     pub fn PdhSelectDataSourceW(
 621         hWndOwner: HWND,
 622         dwFlags: DWORD,
 623         szDataSource: LPWSTR,
 624         pcchBufferLength: LPDWORD,
 625     ) -> PDH_STATUS;
 626     pub fn PdhSelectDataSourceA(
 627         hWndOwner: HWND,
 628         dwFlags: DWORD,
 629         szDataSource: LPSTR,
 630         pcchBufferLength: LPDWORD,
 631     ) -> PDH_STATUS;
 632     pub fn PdhIsRealTimeQuery(
 633         hQuery: PDH_HQUERY,
 634     ) -> PDH_STATUS;
 635     pub fn PdhSetQueryTimeRange(
 636         hQuery: PDH_HQUERY,
 637         pInfo: PPDH_TIME_INFO,
 638     ) -> PDH_STATUS;
 639     pub fn PdhGetDataSourceTimeRangeW(
 640         szDataSource: LPCWSTR,
 641         pdwNumEntries: LPDWORD,
 642         pInfo: PPDH_TIME_INFO,
 643         pdwBufferSize: LPDWORD,
 644     ) -> PDH_STATUS;
 645     pub fn PdhGetDataSourceTimeRangeA(
 646         szDataSource: LPCSTR,
 647         pdwNumEntries: LPDWORD,
 648         pInfo: PPDH_TIME_INFO,
 649         pdwBufferSize: LPDWORD,
 650     ) -> PDH_STATUS;
 651     pub fn PdhCollectQueryDataEx(
 652         hQuery: PDH_HQUERY,
 653         dwIntervalTime: DWORD,
 654         hNewDataEvent: HANDLE,
 655     ) -> PDH_STATUS;
 656     pub fn PdhFormatFromRawValue(
 657         dwCounterType: DWORD,
 658         dwFormat: DWORD,
 659         pTimeBase: *mut LONGLONG,
 660         rawValue1: PPDH_RAW_COUNTER,
 661         rawValue2: PPDH_RAW_COUNTER,
 662         fmtValue: PPDH_FMT_COUNTERVALUE,
 663     ) -> PDH_STATUS;
 664     pub fn PdhGetCounterTimeBase(
 665         hCounter: PDH_HCOUNTER,
 666         pTimeBase: *mut LONGLONG,
 667     ) -> PDH_STATUS;
 668     pub fn PdhReadRawLogRecord(
 669         hLog: PDH_HLOG,
 670         ftRecord: FILETIME,
 671         pRawLogRecord: PPDH_RAW_LOG_RECORD,
 672         pdwBufferLength: LPDWORD,
 673     ) -> PDH_STATUS;
 674     pub fn PdhSetDefaultRealTimeDataSource(
 675         dwDataSourceId: DWORD,
 676     ) -> PDH_STATUS;
 677     pub fn PdhBindInputDataSourceW(
 678         phDataSource: *mut PDH_HLOG,
 679         szLogFileNameList: LPCWSTR,
 680     ) -> PDH_STATUS;
 681     pub fn PdhBindInputDataSourceA(
 682         phDataSource: *mut PDH_HLOG,
 683         szLogFileNameList: LPCSTR,
 684     ) -> PDH_STATUS;
 685     pub fn PdhOpenQueryH(
 686         hDataSource: PDH_HLOG,
 687         dwUserData: DWORD_PTR,
 688         phQuery: *mut PDH_HQUERY,
 689     ) -> PDH_STATUS;
 690     pub fn PdhEnumMachinesHW(
 691         hDataSource: PDH_HLOG,
 692         mszMachineNameList: LPWSTR,
 693         pcchBufferLength: LPDWORD,
 694     ) -> PDH_STATUS;
 695     pub fn PdhEnumMachinesHA(
 696         hDataSource: PDH_HLOG,
 697         mszMachineNameList: LPSTR,
 698         pcchBufferLength: LPDWORD,
 699     ) -> PDH_STATUS;
 700     pub fn PdhEnumObjectsHW(
 701         hDataSource: PDH_HLOG,
 702         szMachineName: LPCWSTR,
 703         mszObjectList: LPWSTR,
 704         pcchBufferLength: LPDWORD,
 705         dwDetailLevel: DWORD,
 706         bRefresh: BOOL,
 707     ) -> PDH_STATUS;
 708     pub fn PdhEnumObjectsHA(
 709         hDataSource: PDH_HLOG,
 710         szMachineName: LPCSTR,
 711         mszObjectList: LPSTR,
 712         pcchBufferLength: LPDWORD,
 713         dwDetailLevel: DWORD,
 714         bRefresh: BOOL,
 715     ) -> PDH_STATUS;
 716     pub fn PdhEnumObjectItemsHW(
 717         hDataSource: PDH_HLOG,
 718         szMachineName: LPCWSTR,
 719         szObjectName: LPCWSTR,
 720         mszCounterList: LPWSTR,
 721         pcchCounterListLength: LPDWORD,
 722         mszInstanceList: LPWSTR,
 723         pcchInstanceListLength: LPDWORD,
 724         dwDetailLevel: DWORD,
 725         dwFlags: DWORD,
 726     ) -> PDH_STATUS;
 727     pub fn PdhEnumObjectItemsHA(
 728         hDataSource: PDH_HLOG,
 729         szMachineName: LPCSTR,
 730         szObjectName: LPCSTR,
 731         mszCounterList: LPSTR,
 732         pcchCounterListLength: LPDWORD,
 733         mszInstanceList: LPSTR,
 734         pcchInstanceListLength: LPDWORD,
 735         dwDetailLevel: DWORD,
 736         dwFlags: DWORD,
 737     ) -> PDH_STATUS;
 738     pub fn PdhExpandWildCardPathHW(
 739         hDataSource: PDH_HLOG,
 740         szWildCardPath: LPCWSTR,
 741         mszExpandedPathList: LPWSTR,
 742         pcchPathListLength: LPDWORD,
 743         dwFlags: DWORD,
 744     ) -> PDH_STATUS;
 745     pub fn PdhExpandWildCardPathHA(
 746         hDataSource: PDH_HLOG,
 747         szWildCardPath: LPCSTR,
 748         mszExpandedPathList: LPSTR,
 749         pcchPathListLength: LPDWORD,
 750         dwFlags: DWORD,
 751     ) -> PDH_STATUS;
 752     pub fn PdhGetDataSourceTimeRangeH(
 753         hDataSource: PDH_HLOG,
 754         pdwNumEntries: LPDWORD,
 755         pInfo: PPDH_TIME_INFO,
 756         pdwBufferSize: LPDWORD,
 757     ) -> PDH_STATUS;
 758     pub fn PdhGetDefaultPerfObjectHW(
 759         hDataSource: PDH_HLOG,
 760         szMachineName: LPCWSTR,
 761         szDefaultObjectName: LPWSTR,
 762         pcchBufferSize: LPDWORD,
 763     ) -> PDH_STATUS;
 764     pub fn PdhGetDefaultPerfObjectHA(
 765         hDataSource: PDH_HLOG,
 766         szMachineName: LPCSTR,
 767         szDefaultObjectName: LPSTR,
 768         pcchBufferSize: LPDWORD,
 769     ) -> PDH_STATUS;
 770     pub fn PdhGetDefaultPerfCounterHW(
 771         hDataSource: PDH_HLOG,
 772         szMachineName: LPCWSTR,
 773         szObjectName: LPCWSTR,
 774         szDefaultCounterName: LPWSTR,
 775         pcchBufferSize: LPDWORD,
 776     ) -> PDH_STATUS;
 777     pub fn PdhGetDefaultPerfCounterHA(
 778         hDataSource: PDH_HLOG,
 779         szMachineName: LPCSTR,
 780         szObjectName: LPCSTR,
 781         szDefaultCounterName: LPSTR,
 782         pcchBufferSize: LPDWORD,
 783     ) -> PDH_STATUS;
 784     pub fn PdhBrowseCountersHW(
 785         pBrowseDlgData: PPDH_BROWSE_DLG_CONFIG_HW,
 786     ) -> PDH_STATUS;
 787     pub fn PdhBrowseCountersHA(
 788         pBrowseDlgData: PPDH_BROWSE_DLG_CONFIG_HA,
 789     ) -> PDH_STATUS;
 790     pub fn PdhEnumLogSetNamesW(
 791         szDataSource: LPCWSTR,
 792         mszLogSetNameList: LPWSTR,
 793         pcchBufferLength: LPDWORD,
 794     ) -> PDH_STATUS;
 795     pub fn PdhEnumLogSetNamesA(
 796         szDataSource: LPCSTR,
 797         mszLogSetNameList: LPSTR,
 798         pcchBufferLength: LPDWORD,
 799     ) -> PDH_STATUS;
 800 }
 801 // pub fn PdhVerifySQLDBW() -> PDH_STATUS;
 802 // pub fn PdhVerifySQLDBA() -> PDH_STATUS;
 803 // pub fn PdhCreateSQLTablesW() -> PDH_STATUS;
 804 // pub fn PdhCreateSQLTablesA() -> PDH_STATUS;
 805 //pub fn PdhGetLogSetGUID() -> PDH_STATUS;
 806 // pub fn PdhSetLogSetRunID() -> PDH_STATUS;