Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

467 lines
12 KiB

  1. /*++
  2. Copyright (c) 1996 Microsoft Corporation
  3. Module Name:
  4. dataexpr.c
  5. Abstract:
  6. a file containing the constant data structures used by the Performance
  7. Monitor data for the Extended Process Performance data objects
  8. Created:
  9. Bob Watson 22-Oct-1996
  10. Revision History:
  11. None.
  12. --*/
  13. //
  14. // Include Files
  15. //
  16. #include <windows.h>
  17. #include <winperf.h>
  18. #include <ntprfctr.h>
  19. #include <perfutil.h>
  20. #include "dataexpr.h"
  21. // dummy variable for field sizing.
  22. static EXPROCESS_COUNTER_DATA ecd;
  23. //
  24. // Constant structure initializations
  25. // defined in dataexpr.h
  26. //
  27. EXPROCESS_DATA_DEFINITION ExProcessDataDefinition = {
  28. { 0,
  29. sizeof (EXPROCESS_DATA_DEFINITION),
  30. sizeof (PERF_OBJECT_TYPE),
  31. EXPROCESS_OBJECT_TITLE_INDEX,
  32. 0,
  33. 787,
  34. 0,
  35. PERF_DETAIL_WIZARD,
  36. (sizeof(EXPROCESS_DATA_DEFINITION) - sizeof (PERF_OBJECT_TYPE))/
  37. sizeof(PERF_COUNTER_DEFINITION),
  38. 0,
  39. 0,
  40. UNICODE_CODE_PAGE,
  41. {0L,0L},
  42. {0L,0L}
  43. },
  44. { sizeof(PERF_COUNTER_DEFINITION),
  45. 784,
  46. 0,
  47. 785,
  48. 0,
  49. 0,
  50. PERF_DETAIL_WIZARD,
  51. PERF_COUNTER_LARGE_RAWCOUNT,
  52. sizeof (ecd.ProcessId),
  53. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ProcessId
  54. },
  55. { sizeof(PERF_COUNTER_DEFINITION),
  56. 776,
  57. 0,
  58. 777,
  59. 0,
  60. -4,
  61. PERF_DETAIL_WIZARD,
  62. PERF_COUNTER_LARGE_RAWCOUNT,
  63. sizeof (ecd.ImageReservedBytes),
  64. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ImageReservedBytes
  65. },
  66. { sizeof(PERF_COUNTER_DEFINITION),
  67. 778,
  68. 0,
  69. 779,
  70. 0,
  71. -4,
  72. PERF_DETAIL_WIZARD,
  73. PERF_COUNTER_LARGE_RAWCOUNT,
  74. sizeof (ecd.ImageFreeBytes),
  75. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ImageFreeBytes
  76. },
  77. { sizeof(PERF_COUNTER_DEFINITION),
  78. 780,
  79. 0,
  80. 781,
  81. 0,
  82. -4,
  83. PERF_DETAIL_WIZARD,
  84. PERF_COUNTER_LARGE_RAWCOUNT,
  85. sizeof (ecd.ReservedBytes),
  86. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ReservedBytes
  87. },
  88. { sizeof(PERF_COUNTER_DEFINITION),
  89. 782,
  90. 0,
  91. 783,
  92. 0,
  93. -4,
  94. PERF_DETAIL_WIZARD,
  95. PERF_COUNTER_LARGE_RAWCOUNT,
  96. sizeof (ecd.FreeBytes),
  97. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->FreeBytes
  98. },
  99. { sizeof(PERF_COUNTER_DEFINITION),
  100. 710,
  101. 0,
  102. 711,
  103. 0,
  104. -5,
  105. PERF_DETAIL_WIZARD,
  106. PERF_COUNTER_LARGE_RAWCOUNT,
  107. sizeof (ecd.CommitNoAccess),
  108. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->CommitNoAccess
  109. },
  110. { sizeof(PERF_COUNTER_DEFINITION),
  111. 712,
  112. 0,
  113. 713,
  114. 0,
  115. -5,
  116. PERF_DETAIL_WIZARD,
  117. PERF_COUNTER_LARGE_RAWCOUNT,
  118. sizeof (ecd.CommitReadOnly),
  119. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->CommitReadOnly
  120. },
  121. { sizeof(PERF_COUNTER_DEFINITION),
  122. 714,
  123. 0,
  124. 715,
  125. 0,
  126. -5,
  127. PERF_DETAIL_WIZARD,
  128. PERF_COUNTER_LARGE_RAWCOUNT,
  129. sizeof (ecd.CommitReadWrite),
  130. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->CommitReadWrite
  131. },
  132. { sizeof(PERF_COUNTER_DEFINITION),
  133. 716,
  134. 0,
  135. 717,
  136. 0,
  137. -5,
  138. PERF_DETAIL_WIZARD,
  139. PERF_COUNTER_LARGE_RAWCOUNT,
  140. sizeof (ecd.CommitWriteCopy),
  141. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->CommitWriteCopy
  142. },
  143. { sizeof(PERF_COUNTER_DEFINITION),
  144. 718,
  145. 0,
  146. 719,
  147. 0,
  148. -5,
  149. PERF_DETAIL_WIZARD,
  150. PERF_COUNTER_LARGE_RAWCOUNT,
  151. sizeof (ecd.CommitExecute),
  152. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->CommitExecute
  153. },
  154. { sizeof(PERF_COUNTER_DEFINITION),
  155. 720,
  156. 0,
  157. 721,
  158. 0,
  159. -5,
  160. PERF_DETAIL_WIZARD,
  161. PERF_COUNTER_LARGE_RAWCOUNT,
  162. sizeof (ecd.CommitExecuteRead),
  163. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->CommitExecuteRead
  164. },
  165. { sizeof(PERF_COUNTER_DEFINITION),
  166. 722,
  167. 0,
  168. 723,
  169. 0,
  170. -5,
  171. PERF_DETAIL_WIZARD,
  172. PERF_COUNTER_LARGE_RAWCOUNT,
  173. sizeof (ecd.CommitExecuteWrite),
  174. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->CommitExecuteWrite
  175. },
  176. { sizeof(PERF_COUNTER_DEFINITION),
  177. 724,
  178. 0,
  179. 725,
  180. 0,
  181. -5,
  182. PERF_DETAIL_WIZARD,
  183. PERF_COUNTER_LARGE_RAWCOUNT,
  184. sizeof (ecd.CommitExecuteWriteCopy),
  185. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->CommitExecuteWriteCopy
  186. },
  187. { sizeof(PERF_COUNTER_DEFINITION),
  188. 726,
  189. 0,
  190. 727,
  191. 0,
  192. -5,
  193. PERF_DETAIL_WIZARD,
  194. PERF_COUNTER_LARGE_RAWCOUNT,
  195. sizeof (ecd.ReservedNoAccess),
  196. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ReservedNoAccess
  197. },
  198. { sizeof(PERF_COUNTER_DEFINITION),
  199. 728,
  200. 0,
  201. 729,
  202. 0,
  203. -5,
  204. PERF_DETAIL_WIZARD,
  205. PERF_COUNTER_LARGE_RAWCOUNT,
  206. sizeof (ecd.ReservedReadOnly),
  207. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ReservedReadOnly
  208. },
  209. { sizeof(PERF_COUNTER_DEFINITION),
  210. 730,
  211. 0,
  212. 731,
  213. 0,
  214. -5,
  215. PERF_DETAIL_WIZARD,
  216. PERF_COUNTER_LARGE_RAWCOUNT,
  217. sizeof (ecd.ReservedReadWrite),
  218. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ReservedReadWrite
  219. },
  220. { sizeof(PERF_COUNTER_DEFINITION),
  221. 732,
  222. 0,
  223. 733,
  224. 0,
  225. -5,
  226. PERF_DETAIL_WIZARD,
  227. PERF_COUNTER_LARGE_RAWCOUNT,
  228. sizeof (ecd.ReservedWriteCopy),
  229. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ReservedWriteCopy
  230. },
  231. { sizeof(PERF_COUNTER_DEFINITION),
  232. 734,
  233. 0,
  234. 735,
  235. 0,
  236. -5,
  237. PERF_DETAIL_WIZARD,
  238. PERF_COUNTER_LARGE_RAWCOUNT,
  239. sizeof (ecd.ReservedExecute),
  240. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ReservedExecute
  241. },
  242. { sizeof(PERF_COUNTER_DEFINITION),
  243. 736,
  244. 0,
  245. 737,
  246. 0,
  247. -5,
  248. PERF_DETAIL_WIZARD,
  249. PERF_COUNTER_LARGE_RAWCOUNT,
  250. sizeof (ecd.ReservedExecuteRead),
  251. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ReservedExecuteRead
  252. },
  253. { sizeof(PERF_COUNTER_DEFINITION),
  254. 738,
  255. 0,
  256. 739,
  257. 0,
  258. -5,
  259. PERF_DETAIL_WIZARD,
  260. PERF_COUNTER_LARGE_RAWCOUNT,
  261. sizeof (ecd.ReservedExecuteWrite),
  262. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ReservedExecuteWrite
  263. },
  264. { sizeof(PERF_COUNTER_DEFINITION),
  265. 742,
  266. 0,
  267. 743,
  268. 0,
  269. -5,
  270. PERF_DETAIL_WIZARD,
  271. PERF_COUNTER_LARGE_RAWCOUNT,
  272. sizeof (ecd.ReservedExecuteWriteCopy),
  273. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ReservedExecuteWriteCopy
  274. },
  275. { sizeof(PERF_COUNTER_DEFINITION),
  276. 744,
  277. 0,
  278. 745,
  279. 0,
  280. -5,
  281. PERF_DETAIL_WIZARD,
  282. PERF_COUNTER_LARGE_RAWCOUNT,
  283. sizeof (ecd.UnassignedNoAccess),
  284. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->UnassignedNoAccess
  285. },
  286. { sizeof(PERF_COUNTER_DEFINITION),
  287. 746,
  288. 0,
  289. 747,
  290. 0,
  291. -5,
  292. PERF_DETAIL_WIZARD,
  293. PERF_COUNTER_LARGE_RAWCOUNT,
  294. sizeof (ecd.UnassignedReadOnly),
  295. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->UnassignedReadOnly
  296. },
  297. { sizeof(PERF_COUNTER_DEFINITION),
  298. 748,
  299. 0,
  300. 749,
  301. 0,
  302. -5,
  303. PERF_DETAIL_WIZARD,
  304. PERF_COUNTER_LARGE_RAWCOUNT,
  305. sizeof (ecd.UnassignedReadWrite),
  306. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->UnassignedReadWrite
  307. },
  308. { sizeof(PERF_COUNTER_DEFINITION),
  309. 750,
  310. 0,
  311. 751,
  312. 0,
  313. -5,
  314. PERF_DETAIL_WIZARD,
  315. PERF_COUNTER_LARGE_RAWCOUNT,
  316. sizeof (ecd.UnassignedWriteCopy),
  317. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->UnassignedWriteCopy
  318. },
  319. { sizeof(PERF_COUNTER_DEFINITION),
  320. 752,
  321. 0,
  322. 753,
  323. 0,
  324. -5,
  325. PERF_DETAIL_WIZARD,
  326. PERF_COUNTER_LARGE_RAWCOUNT,
  327. sizeof (ecd.UnassignedExecute),
  328. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->UnassignedExecute
  329. },
  330. { sizeof(PERF_COUNTER_DEFINITION),
  331. 754,
  332. 0,
  333. 755,
  334. 0,
  335. -5,
  336. PERF_DETAIL_WIZARD,
  337. PERF_COUNTER_LARGE_RAWCOUNT,
  338. sizeof (ecd.UnassignedExecuteRead),
  339. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->UnassignedExecuteRead
  340. },
  341. { sizeof(PERF_COUNTER_DEFINITION),
  342. 756,
  343. 0,
  344. 757,
  345. 0,
  346. -5,
  347. PERF_DETAIL_WIZARD,
  348. PERF_COUNTER_LARGE_RAWCOUNT,
  349. sizeof (ecd.UnassignedExecuteWrite),
  350. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->UnassignedExecuteWrite
  351. },
  352. { sizeof(PERF_COUNTER_DEFINITION),
  353. 758,
  354. 0,
  355. 759,
  356. 0,
  357. -5,
  358. PERF_DETAIL_WIZARD,
  359. PERF_COUNTER_LARGE_RAWCOUNT,
  360. sizeof (ecd.UnassignedExecuteWriteCopy),
  361. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->UnassignedExecuteWriteCopy
  362. },
  363. { sizeof(PERF_COUNTER_DEFINITION),
  364. 760,
  365. 0,
  366. 761,
  367. 0,
  368. -5,
  369. PERF_DETAIL_WIZARD,
  370. PERF_COUNTER_LARGE_RAWCOUNT,
  371. sizeof (ecd.ImageTotalNoAccess),
  372. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ImageTotalNoAccess
  373. },
  374. { sizeof(PERF_COUNTER_DEFINITION),
  375. 762,
  376. 0,
  377. 763,
  378. 0,
  379. -5,
  380. PERF_DETAIL_WIZARD,
  381. PERF_COUNTER_LARGE_RAWCOUNT,
  382. sizeof (ecd.ImageTotalReadOnly),
  383. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ImageTotalReadOnly
  384. },
  385. { sizeof(PERF_COUNTER_DEFINITION),
  386. 764,
  387. 0,
  388. 765,
  389. 0,
  390. -5,
  391. PERF_DETAIL_WIZARD,
  392. PERF_COUNTER_LARGE_RAWCOUNT,
  393. sizeof (ecd.ImageTotalReadWrite),
  394. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ImageTotalReadWrite
  395. },
  396. { sizeof(PERF_COUNTER_DEFINITION),
  397. 766,
  398. 0,
  399. 767,
  400. 0,
  401. -5,
  402. PERF_DETAIL_WIZARD,
  403. PERF_COUNTER_LARGE_RAWCOUNT,
  404. sizeof (ecd.ImageTotalWriteCopy),
  405. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ImageTotalWriteCopy
  406. },
  407. { sizeof(PERF_COUNTER_DEFINITION),
  408. 768,
  409. 0,
  410. 769,
  411. 0,
  412. -5,
  413. PERF_DETAIL_WIZARD,
  414. PERF_COUNTER_LARGE_RAWCOUNT,
  415. sizeof (ecd.ImageTotalExecute),
  416. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ImageTotalExecute
  417. },
  418. { sizeof(PERF_COUNTER_DEFINITION),
  419. 770,
  420. 0,
  421. 771,
  422. 0,
  423. -5,
  424. PERF_DETAIL_WIZARD,
  425. PERF_COUNTER_LARGE_RAWCOUNT,
  426. sizeof (ecd.ImageTotalExecuteRead),
  427. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ImageTotalExecuteRead
  428. },
  429. { sizeof(PERF_COUNTER_DEFINITION),
  430. 772,
  431. 0,
  432. 773,
  433. 0,
  434. -5,
  435. PERF_DETAIL_WIZARD,
  436. PERF_COUNTER_LARGE_RAWCOUNT,
  437. sizeof (ecd.ImageTotalExecuteWrite),
  438. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ImageTotalExecuteWrite
  439. },
  440. { sizeof(PERF_COUNTER_DEFINITION),
  441. 774,
  442. 0,
  443. 775,
  444. 0,
  445. -5,
  446. PERF_DETAIL_WIZARD,
  447. PERF_COUNTER_LARGE_RAWCOUNT,
  448. sizeof (ecd.ImageTotalExecuteWriteCopy),
  449. (DWORD)(ULONG_PTR)&((PEXPROCESS_COUNTER_DATA)0)->ImageTotalExecuteWriteCopy
  450. }
  451. };
  452.