public bool CounterExists(string counterName)
{
if (counterName == null)
{
throw new ArgumentNullException("counterName");
}
if (this.categoryName == null)
{
throw new InvalidOperationException(SR.GetString("CategoryNameNotSet"));
}
return(PerformanceCounterLib.CounterExists(this.machineName, this.categoryName, counterName));
}
public bool InstanceExists(string instanceName)
{
if (instanceName == null)
{
throw new ArgumentNullException("instanceName");
}
if (this.categoryName == null)
{
throw new InvalidOperationException(SR.GetString("CategoryNameNotSet"));
}
return(PerformanceCounterLib.GetCategorySample(this.machineName, this.categoryName).InstanceNameTable.ContainsKey(instanceName));
}
/// <summary>
/// Reads all the counter and instance data of this performance category. Note that reading the entire category
/// at once can be as efficient as reading a single counter because of the way the system provides the data.
/// </summary>
public InstanceDataCollectionCollection ReadCategory()
{
if (_categoryName == null)
{
throw new InvalidOperationException(SR.CategoryNameNotSet);
}
using (CategorySample categorySample = PerformanceCounterLib.GetCategorySample(_machineName, _categoryName))
{
return(categorySample.ReadCategory());
}
}
/// <summary>
/// Returns true if the counter is registered for this category
/// </summary>
public bool CounterExists(string counterName)
{
if (counterName == null)
{
throw new ArgumentNullException(nameof(counterName));
}
if (_categoryName == null)
{
throw new InvalidOperationException(SR.CategoryNameNotSet);
}
return(PerformanceCounterLib.CounterExists(_machineName, _categoryName, counterName));
}
/// <summary>
/// Returns true if the instance already exists for this category.
/// </summary>
public bool InstanceExists(string instanceName)
{
ArgumentNullException.ThrowIfNull(instanceName);
if (_categoryName == null)
{
throw new InvalidOperationException(SR.CategoryNameNotSet);
}
using (CategorySample categorySample = PerformanceCounterLib.GetCategorySample(_machineName, _categoryName))
{
return(categorySample._instanceNameTable.ContainsKey(instanceName));
}
}
public static PerformanceCounterCategory[] GetCategories(string machineName)
{
if (!SyntaxCheck.CheckMachineName(machineName))
{
throw new ArgumentException(SR.GetString("InvalidParameter", new object[] { "machineName", machineName }));
}
new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Browse, machineName, "*").Demand();
string[] categories = PerformanceCounterLib.GetCategories(machineName);
PerformanceCounterCategory[] categoryArray = new PerformanceCounterCategory[categories.Length];
for (int i = 0; i < categoryArray.Length; i++)
{
categoryArray[i] = new PerformanceCounterCategory(categories[i], machineName);
}
return(categoryArray);
}
/// <include file='doc\PerformanceCounterCategory.uex' path='docs/doc[@for="PerformanceCounterCategory.ReadCategory"]/*' />
/// <devdoc>
/// Reads all the counter and instance data of this performance category. Note that reading the entire category
/// at once can be as efficient as reading a single counter because of the way the system provides the data.
/// </devdoc>
public InstanceDataCollectionCollection ReadCategory()
{
if (this.categoryName == null)
{
throw new InvalidOperationException(SR.GetString(SR.CategoryNameNotSet));
}
CategorySample categorySample = PerformanceCounterLib.GetCategorySample(this.machineName, this.categoryName);
try {
return(categorySample.ReadCategory());
}
finally {
categorySample.Dispose();
}
}
/// <summary>
/// Returns an array of performance counter categories for a particular machine.
/// </summary>
public static PerformanceCounterCategory[] GetCategories(string machineName)
{
if (!SyntaxCheck.CheckMachineName(machineName))
{
throw new ArgumentException(SR.Format(SR.InvalidParameter, nameof(machineName), machineName), nameof(machineName));
}
string[] categoryNames = PerformanceCounterLib.GetCategories(machineName);
PerformanceCounterCategory[] categories = new PerformanceCounterCategory[categoryNames.Length];
for (int index = 0; index < categories.Length; index++)
{
categories[index] = new PerformanceCounterCategory(categoryNames[index], machineName);
}
return(categories);
}
/// <summary>
/// Returns true if the instance already exists for this category.
/// </summary>
public bool InstanceExists(string instanceName)
{
if (instanceName == null)
{
throw new ArgumentNullException(nameof(instanceName));
}
if (_categoryName == null)
{
throw new InvalidOperationException(SR.Format(SR.CategoryNameNotSet));
}
CategorySample categorySample = PerformanceCounterLib.GetCategorySample(_machineName, _categoryName);
return(categorySample._instanceNameTable.ContainsKey(instanceName));
}
public static PerformanceCounterCategory Create(string categoryName, string categoryHelp, PerformanceCounterCategoryType categoryType, CounterCreationDataCollection counterData)
{
if (categoryType < PerformanceCounterCategoryType.Unknown || categoryType > PerformanceCounterCategoryType.MultiInstance)
{
throw new ArgumentOutOfRangeException("categoryType");
}
if (counterData == null)
{
throw new ArgumentNullException("counterData");
}
CheckValidCategory(categoryName);
if (categoryHelp != null)
{
// null categoryHelp is a valid option - it gets set to "Help Not Available" later on.
CheckValidHelp(categoryHelp);
}
string machineName = ".";
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Administer, machineName, categoryName);
permission.Demand();
SharedUtils.CheckNtEnvironment();
Mutex mutex = null;
RuntimeHelpers.PrepareConstrainedRegions();
try {
SharedUtils.EnterMutex(perfMutexName, ref mutex);
if (PerformanceCounterLib.IsCustomCategory(machineName, categoryName) || PerformanceCounterLib.CategoryExists(machineName, categoryName))
{
throw new InvalidOperationException(SR.GetString(SR.PerformanceCategoryExists, categoryName));
}
CheckValidCounterLayout(counterData);
PerformanceCounterLib.RegisterCategory(categoryName, categoryType, categoryHelp, counterData);
return(new PerformanceCounterCategory(categoryName, machineName));
}
finally {
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
}
public static bool Exists(string categoryName, string machineName)
{
if (categoryName == null)
{
throw new ArgumentNullException("categoryName");
}
if (categoryName.Length == 0)
{
throw new ArgumentException(SR.GetString("InvalidParameter", new object[] { "categoryName", categoryName }));
}
if (!SyntaxCheck.CheckMachineName(machineName))
{
throw new ArgumentException(SR.GetString("InvalidParameter", new object[] { "machineName", machineName }));
}
new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Browse, machineName, categoryName).Demand();
return(PerformanceCounterLib.IsCustomCategory(machineName, categoryName) || PerformanceCounterLib.CategoryExists(machineName, categoryName));
}
internal static string[] GetCounterInstances(string categoryName, string machineName)
{
new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Browse, machineName, categoryName).Demand();
CategorySample categorySample = PerformanceCounterLib.GetCategorySample(machineName, categoryName);
if (categorySample.InstanceNameTable.Count == 0)
{
return(new string[0]);
}
string[] array = new string[categorySample.InstanceNameTable.Count];
categorySample.InstanceNameTable.Keys.CopyTo(array, 0);
if ((array.Length == 1) && (array[0].CompareTo("systemdiagnosticsperfcounterlibsingleinstance") == 0))
{
return(new string[0]);
}
return(array);
}
/// <summary>
/// Returns true if the counter is registered for this category on a particular machine.
/// </summary>
public static bool CounterExists(string counterName, string categoryName, string machineName)
{
ArgumentNullException.ThrowIfNull(counterName);
ArgumentNullException.ThrowIfNull(categoryName);
if (categoryName.Length == 0)
{
throw new ArgumentException(SR.Format(SR.InvalidParameter, nameof(categoryName), categoryName), nameof(categoryName));
}
if (!SyntaxCheck.CheckMachineName(machineName))
{
throw new ArgumentException(SR.Format(SR.InvalidParameter, nameof(machineName), machineName), nameof(machineName));
}
return(PerformanceCounterLib.CounterExists(machineName, categoryName, counterName));
}
public static PerformanceCounterCategory Create(string categoryName, string categoryHelp, PerformanceCounterCategoryType categoryType, CounterCreationDataCollection counterData)
{
PerformanceCounterCategory category;
if ((categoryType < PerformanceCounterCategoryType.Unknown) || (categoryType > PerformanceCounterCategoryType.MultiInstance))
{
throw new ArgumentOutOfRangeException("categoryType");
}
if (counterData == null)
{
throw new ArgumentNullException("counterData");
}
CheckValidCategory(categoryName);
if (categoryHelp != null)
{
CheckValidHelp(categoryHelp);
}
string machineName = ".";
new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Administer, machineName, categoryName).Demand();
SharedUtils.CheckNtEnvironment();
Mutex mutex = null;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
SharedUtils.EnterMutex("netfxperf.1.0", ref mutex);
if (PerformanceCounterLib.IsCustomCategory(machineName, categoryName) || PerformanceCounterLib.CategoryExists(machineName, categoryName))
{
throw new InvalidOperationException(SR.GetString("PerformanceCategoryExists", new object[] { categoryName }));
}
CheckValidCounterLayout(counterData);
PerformanceCounterLib.RegisterCategory(categoryName, categoryType, categoryHelp, counterData);
category = new PerformanceCounterCategory(categoryName, machineName);
}
finally
{
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
return(category);
}
public static ProcessInfo[] GetProcessInfos(string machineName, bool isRemoteMachine)
{
ProcessInfo[] processInfos;
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
try
{
processInfos = GetProcessInfos(PerformanceCounterLib.GetPerformanceCounterLib(machineName, new CultureInfo(9)));
}
catch (Exception exception)
{
if (isRemoteMachine)
{
throw new InvalidOperationException(SR.GetString("CouldntConnectToRemoteMachine"), exception);
}
throw exception;
}
return(processInfos);
}
/// <summary>
/// Returns the instance names for a given category
/// </summary>
/// <internalonly/>
internal static string[] GetCounterInstances(string categoryName, string machineName)
{
CategorySample categorySample = PerformanceCounterLib.GetCategorySample(machineName, categoryName);
if (categorySample._instanceNameTable.Count == 0)
{
return(Array.Empty <string>());
}
string[] instanceNames = new string[categorySample._instanceNameTable.Count];
categorySample._instanceNameTable.Keys.CopyTo(instanceNames, 0);
if (instanceNames.Length == 1 && instanceNames[0] == PerformanceCounterLib.SingleInstanceName)
{
return(Array.Empty <string>());
}
return(instanceNames);
}
public static PerformanceCounterCategory Create(string categoryName, string categoryHelp, PerformanceCounterCategoryType categoryType, CounterCreationDataCollection counterData)
{
if (categoryType < PerformanceCounterCategoryType.Unknown || categoryType > PerformanceCounterCategoryType.MultiInstance)
{
throw new ArgumentOutOfRangeException(nameof(categoryType));
}
if (counterData == null)
{
throw new ArgumentNullException(nameof(counterData));
}
CheckValidCategory(categoryName);
if (categoryHelp != null)
{
// null categoryHelp is a valid option - it gets set to "Help Not Available" later on.
CheckValidHelp(categoryHelp);
}
string machineName = ".";
Mutex mutex = null;
try
{
NetFrameworkUtils.EnterMutex(PerfMutexName, ref mutex);
if (PerformanceCounterLib.IsCustomCategory(machineName, categoryName) || PerformanceCounterLib.CategoryExists(machineName, categoryName))
{
throw new InvalidOperationException(SR.Format(SR.PerformanceCategoryExists, categoryName));
}
CheckValidCounterLayout(counterData);
PerformanceCounterLib.RegisterCategory(categoryName, categoryType, categoryHelp, counterData);
return(new PerformanceCounterCategory(categoryName, machineName));
}
finally
{
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
}
/// <include file='doc\PerformanceCounterCategory.uex' path='docs/doc[@for="PerformanceCounterCategory.GetCounterInstances"]/*' />
/// <devdoc>
/// Returns the instance names for a given category
/// </devdoc>
/// <internalonly/>
internal static string[] GetCounterInstances(string categoryName, string machineName)
{
if (categoryName == null)
{
throw new ArgumentNullException("categoryName");
}
if (categoryName.Length == 0)
{
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "categoryName", categoryName));
}
if (!SyntaxCheck.CheckMachineName(machineName))
{
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "machineName", machineName));
}
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Browse, machineName, categoryName);
permission.Demand();
CategorySample categorySample = PerformanceCounterLib.GetCategorySample(machineName, categoryName);
try {
if (categorySample.InstanceNameTable.Count == 0)
{
throw new InvalidOperationException(SR.GetString(SR.NoInstanceInformation, categoryName));
}
string[] instanceNames = new string[categorySample.InstanceNameTable.Count];
categorySample.InstanceNameTable.Keys.CopyTo(instanceNames, 0);
if (instanceNames.Length == 1 && instanceNames[0].CompareTo(PerformanceCounterLib.SingleInstanceName) == 0)
{
return(new string[0]);
}
return(instanceNames);
}
finally {
categorySample.Dispose();
}
}
/// <devdoc>
/// Returns an array of performance counter categories for a particular machine.
/// </devdoc>
public static PerformanceCounterCategory[] GetCategories(string machineName)
{
if (!SyntaxCheck.CheckMachineName(machineName))
{
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "machineName", machineName));
}
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, machineName, "*");
permission.Demand();
string[] categoryNames = PerformanceCounterLib.GetCategories(machineName);
PerformanceCounterCategory[] categories = new PerformanceCounterCategory[categoryNames.Length];
for (int index = 0; index < categories.Length; index++)
{
categories[index] = new PerformanceCounterCategory(categoryNames[index], machineName);
}
return(categories);
}
public static ProcessInfo[] GetProcessInfos(string machineName, bool isRemoteMachine)
{
try
{
// We don't want to call library.Close() here because that would cause us to unload all of the perflibs.
// On the next call to GetProcessInfos, we'd have to load them all up again, which is SLOW!
PerformanceCounterLib library = PerformanceCounterLib.GetPerformanceCounterLib(machineName, new CultureInfo("en"));
return(GetProcessInfos(library));
}
catch (Exception e)
{
if (isRemoteMachine)
{
throw new InvalidOperationException(SR.CouldntConnectToRemoteMachine, e);
}
else
{
throw;
}
}
}
public PerformanceCounter[] GetCounters(string instanceName)
{
if (instanceName == null)
{
throw new ArgumentNullException("instanceName");
}
if (this.categoryName == null)
{
throw new InvalidOperationException(SR.GetString("CategoryNameNotSet"));
}
if ((instanceName.Length != 0) && !this.InstanceExists(instanceName))
{
throw new InvalidOperationException(SR.GetString("MissingInstance", new object[] { instanceName, this.categoryName }));
}
string[] counters = PerformanceCounterLib.GetCounters(this.machineName, this.categoryName);
PerformanceCounter[] counterArray = new PerformanceCounter[counters.Length];
for (int i = 0; i < counterArray.Length; i++)
{
counterArray[i] = new PerformanceCounter(this.categoryName, counters[i], instanceName, this.machineName, true);
}
return(counterArray);
}
private static ProcessInfo[] GetProcessInfos(PerformanceCounterLib library)
{
ProcessInfo[] infoArray = new ProcessInfo[0];
byte[] data = null;
for (int i = 5; (infoArray.Length == 0) && (i != 0); i--)
{
try
{
data = library.GetPerformanceData("230 232");
infoArray = GetProcessInfos(library, 230, 0xe8, data);
}
catch (Exception exception)
{
throw new InvalidOperationException(SR.GetString("CouldntGetProcessInfos"), exception);
}
}
if (infoArray.Length == 0)
{
throw new InvalidOperationException(SR.GetString("ProcessDisabled"));
}
return(infoArray);
}
/// <include file='doc\PerformanceCounterCategory.uex' path='docs/doc[@for="PerformanceCounterCategory.InstanceExists"]/*' />
/// <devdoc>
/// Returns true if the instance already exists for this category.
/// </devdoc>
public bool InstanceExists(string instanceName)
{
if (instanceName == null)
{
throw new ArgumentNullException("instanceName");
}
if (this.categoryName == null)
{
throw new InvalidOperationException(SR.GetString(SR.CategoryNameNotSet));
}
CategorySample categorySample = PerformanceCounterLib.GetCategorySample(machineName, categoryName);
try {
IEnumerator valueEnum = categorySample.CounterTable.Values.GetEnumerator();
return(categorySample.InstanceNameTable.ContainsKey(instanceName));
}
finally {
categorySample.Dispose();
}
}
/// <devdoc>
/// Returns the instance names for a given category
/// </devdoc>
/// <internalonly/>
internal static string[] GetCounterInstances(string categoryName, string machineName)
{
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Read, machineName, categoryName);
permission.Demand();
CategorySample categorySample = PerformanceCounterLib.GetCategorySample(machineName, categoryName);
if (categorySample.InstanceNameTable.Count == 0)
{
return(new string[0]);
}
string[] instanceNames = new string[categorySample.InstanceNameTable.Count];
categorySample.InstanceNameTable.Keys.CopyTo(instanceNames, 0);
if (instanceNames.Length == 1 && instanceNames[0].CompareTo(PerformanceCounterLib.SingleInstanceName) == 0)
{
return(new string[0]);
}
return(instanceNames);
}
internal static bool CounterExists(string machine, string category, string counter)
{
PerformanceCounterLib performanceCounterLib = GetPerformanceCounterLib(machine, new CultureInfo(9));
bool categoryExists = false;
bool flag2 = performanceCounterLib.CounterExists(category, counter, ref categoryExists);
if (!categoryExists && (CultureInfo.CurrentCulture.Parent.LCID != 9))
{
for (CultureInfo info = CultureInfo.CurrentCulture; info != CultureInfo.InvariantCulture; info = info.Parent)
{
flag2 = GetPerformanceCounterLib(machine, info).CounterExists(category, counter, ref categoryExists);
if (flag2)
{
break;
}
}
}
if (!categoryExists)
{
throw new InvalidOperationException(SR.GetString("MissingCategory"));
}
return(flag2);
}
/// <summary>
/// Returns an array of counters in this category for the given instance.
/// </summary>
public PerformanceCounter[] GetCounters(string instanceName)
{
ArgumentNullException.ThrowIfNull(instanceName);
if (_categoryName == null)
{
throw new InvalidOperationException(SR.CategoryNameNotSet);
}
if (instanceName.Length != 0 && !InstanceExists(instanceName))
{
throw new InvalidOperationException(SR.Format(SR.MissingInstance, instanceName, _categoryName));
}
string[] counterNames = PerformanceCounterLib.GetCounters(_machineName, _categoryName);
PerformanceCounter[] counters = new PerformanceCounter[counterNames.Length];
for (int index = 0; index < counters.Length; index++)
{
counters[index] = new PerformanceCounter(_categoryName, counterNames[index], instanceName, _machineName, true);
}
return(counters);
}
internal static string[] GetCounters(string machine, string category)
{
PerformanceCounterLib performanceCounterLib = GetPerformanceCounterLib(machine, new CultureInfo(9));
bool categoryExists = false;
string[] counters = performanceCounterLib.GetCounters(category, ref categoryExists);
if (!categoryExists && (CultureInfo.CurrentCulture.Parent.LCID != 9))
{
for (CultureInfo info = CultureInfo.CurrentCulture; info != CultureInfo.InvariantCulture; info = info.Parent)
{
counters = GetPerformanceCounterLib(machine, info).GetCounters(category, ref categoryExists);
if (categoryExists)
{
return(counters);
}
}
}
if (!categoryExists)
{
throw new InvalidOperationException(SR.GetString("MissingCategory"));
}
return(counters);
}
internal static PerformanceCounterLib GetPerformanceCounterLib(string machineName, CultureInfo culture)
{
string lcidString = culture.Name.ToLowerInvariant();
if (machineName.CompareTo(".") == 0)
{
machineName = ComputerName.ToLowerInvariant();
}
else
{
machineName = machineName.ToLowerInvariant();
}
if (PerformanceCounterLib.s_libraryTable == null)
{
lock (InternalSyncObject)
{
if (PerformanceCounterLib.s_libraryTable == null)
{
PerformanceCounterLib.s_libraryTable = new Dictionary <string, PerformanceCounterLib>();
}
}
}
string libraryKey = machineName + ":" + lcidString;
if (PerformanceCounterLib.s_libraryTable.ContainsKey(libraryKey))
{
return((PerformanceCounterLib)PerformanceCounterLib.s_libraryTable[libraryKey]);
}
else
{
PerformanceCounterLib library = new PerformanceCounterLib(machineName, lcidString);
PerformanceCounterLib.s_libraryTable[libraryKey] = library;
return(library);
}
}
/// <summary>
/// Returns true if the category is registered in the machine.
/// </summary>
public static bool Exists(string categoryName, string machineName)
{
if (categoryName == null)
{
throw new ArgumentNullException(nameof(categoryName));
}
if (categoryName.Length == 0)
{
throw new ArgumentException(SR.Format(SR.InvalidParameter, nameof(categoryName), categoryName), nameof(categoryName));
}
if (!SyntaxCheck.CheckMachineName(machineName))
{
throw new ArgumentException(SR.Format(SR.InvalidParameter, nameof(machineName), machineName), nameof(machineName));
}
if (PerformanceCounterLib.IsCustomCategory(machineName, categoryName))
{
return(true);
}
return(PerformanceCounterLib.CategoryExists(machineName, categoryName));
}
public static void Delete(string categoryName)
{
CheckValidCategory(categoryName);
string machineName = ".";
PerformanceCounterPermission permission = new PerformanceCounterPermission(PerformanceCounterPermissionAccess.Administer, machineName, categoryName);
permission.Demand();
SharedUtils.CheckNtEnvironment();
categoryName = categoryName.ToLower(CultureInfo.InvariantCulture);
Mutex mutex = null;
RuntimeHelpers.PrepareConstrainedRegions();
try {
SharedUtils.EnterMutex(perfMutexName, ref mutex);
if (!PerformanceCounterLib.IsCustomCategory(machineName, categoryName))
{
throw new InvalidOperationException(SR.GetString(SR.CantDeleteCategory));
}
SharedPerformanceCounter.RemoveAllInstances(categoryName);
PerformanceCounterLib.UnregisterCategory(categoryName);
PerformanceCounterLib.CloseAllLibraries();
}
finally {
if (mutex != null)
{
mutex.ReleaseMutex();
mutex.Close();
}
}
}
private static ProcessInfo[] GetProcessInfos(PerformanceCounterLib library, int processIndex, int threadIndex, byte[] data)
{
Hashtable hashtable = new Hashtable();
ArrayList list = new ArrayList();
GCHandle handle = new GCHandle();
try
{
handle = GCHandle.Alloc(data, GCHandleType.Pinned);
IntPtr ptr = handle.AddrOfPinnedObject();
Microsoft.Win32.NativeMethods.PERF_DATA_BLOCK structure = new Microsoft.Win32.NativeMethods.PERF_DATA_BLOCK();
Marshal.PtrToStructure(ptr, structure);
IntPtr ptr2 = (IntPtr) (((long) ptr) + structure.HeaderLength);
Microsoft.Win32.NativeMethods.PERF_INSTANCE_DEFINITION perf_instance_definition = new Microsoft.Win32.NativeMethods.PERF_INSTANCE_DEFINITION();
Microsoft.Win32.NativeMethods.PERF_COUNTER_BLOCK perf_counter_block = new Microsoft.Win32.NativeMethods.PERF_COUNTER_BLOCK();
for (int j = 0; j < structure.NumObjectTypes; j++)
{
Microsoft.Win32.NativeMethods.PERF_OBJECT_TYPE perf_object_type = new Microsoft.Win32.NativeMethods.PERF_OBJECT_TYPE();
Marshal.PtrToStructure(ptr2, perf_object_type);
IntPtr ptr3 = (IntPtr) (((long) ptr2) + perf_object_type.DefinitionLength);
IntPtr ptr4 = (IntPtr) (((long) ptr2) + perf_object_type.HeaderLength);
ArrayList list2 = new ArrayList();
for (int k = 0; k < perf_object_type.NumCounters; k++)
{
Microsoft.Win32.NativeMethods.PERF_COUNTER_DEFINITION perf_counter_definition = new Microsoft.Win32.NativeMethods.PERF_COUNTER_DEFINITION();
Marshal.PtrToStructure(ptr4, perf_counter_definition);
string counterName = library.GetCounterName(perf_counter_definition.CounterNameTitleIndex);
if (perf_object_type.ObjectNameTitleIndex == processIndex)
{
perf_counter_definition.CounterNameTitlePtr = (int) GetValueId(counterName);
}
else if (perf_object_type.ObjectNameTitleIndex == threadIndex)
{
perf_counter_definition.CounterNameTitlePtr = (int) GetValueId(counterName);
}
list2.Add(perf_counter_definition);
ptr4 = (IntPtr) (((long) ptr4) + perf_counter_definition.ByteLength);
}
Microsoft.Win32.NativeMethods.PERF_COUNTER_DEFINITION[] perf_counter_definitionArray = new Microsoft.Win32.NativeMethods.PERF_COUNTER_DEFINITION[list2.Count];
list2.CopyTo(perf_counter_definitionArray, 0);
for (int m = 0; m < perf_object_type.NumInstances; m++)
{
Marshal.PtrToStructure(ptr3, perf_instance_definition);
IntPtr ptr5 = (IntPtr) (((long) ptr3) + perf_instance_definition.NameOffset);
string strA = Marshal.PtrToStringUni(ptr5);
if (!strA.Equals("_Total"))
{
IntPtr ptr6 = (IntPtr) (((long) ptr3) + perf_instance_definition.ByteLength);
Marshal.PtrToStructure(ptr6, perf_counter_block);
if (perf_object_type.ObjectNameTitleIndex == processIndex)
{
ProcessInfo info = GetProcessInfo(perf_object_type, (IntPtr) (((long) ptr3) + perf_instance_definition.ByteLength), perf_counter_definitionArray);
if (((info.processId != 0) || (string.Compare(strA, "Idle", StringComparison.OrdinalIgnoreCase) == 0)) && (hashtable[info.processId] == null))
{
string str3 = strA;
if (str3.Length == 15)
{
if (strA.EndsWith(".", StringComparison.Ordinal))
{
str3 = strA.Substring(0, 14);
}
else if (strA.EndsWith(".e", StringComparison.Ordinal))
{
str3 = strA.Substring(0, 13);
}
else if (strA.EndsWith(".ex", StringComparison.Ordinal))
{
str3 = strA.Substring(0, 12);
}
}
info.processName = str3;
hashtable.Add(info.processId, info);
}
}
else if (perf_object_type.ObjectNameTitleIndex == threadIndex)
{
ThreadInfo info2 = GetThreadInfo(perf_object_type, (IntPtr) (((long) ptr3) + perf_instance_definition.ByteLength), perf_counter_definitionArray);
if (info2.threadId != 0)
{
list.Add(info2);
}
}
ptr3 = (IntPtr) ((((long) ptr3) + perf_instance_definition.ByteLength) + perf_counter_block.ByteLength);
}
}
ptr2 = (IntPtr) (((long) ptr2) + perf_object_type.TotalByteLength);
}
}
finally
{
if (handle.IsAllocated)
{
handle.Free();
}
}
for (int i = 0; i < list.Count; i++)
{
ThreadInfo info3 = (ThreadInfo) list[i];
ProcessInfo info4 = (ProcessInfo) hashtable[info3.processId];
if (info4 != null)
{
info4.threadInfoList.Add(info3);
}
}
ProcessInfo[] array = new ProcessInfo[hashtable.Values.Count];
hashtable.Values.CopyTo(array, 0);
return array;
}
internal static PerformanceCounterLib GetPerformanceCounterLib(string machineName, CultureInfo culture) {
SharedUtils.CheckEnvironment();
string lcidString = culture.LCID.ToString("X3", CultureInfo.InvariantCulture);
if (machineName.CompareTo(".") == 0)
machineName = ComputerName.ToLower(CultureInfo.InvariantCulture);
else
machineName = machineName.ToLower(CultureInfo.InvariantCulture);
if (PerformanceCounterLib.libraryTable == null) {
lock (InternalSyncObject) {
if (PerformanceCounterLib.libraryTable == null)
PerformanceCounterLib.libraryTable = new Hashtable();
}
}
string libraryKey = machineName + ":" + lcidString;
if (PerformanceCounterLib.libraryTable.Contains(libraryKey))
return (PerformanceCounterLib)PerformanceCounterLib.libraryTable[libraryKey];
else {
PerformanceCounterLib library = new PerformanceCounterLib(machineName, lcidString);
PerformanceCounterLib.libraryTable[libraryKey] = library;
return library;
}
}
internal unsafe CategorySample(byte[] data, CategoryEntry entry, PerformanceCounterLib library) {
this.entry = entry;
this.library = library;
int categoryIndex = entry.NameIndex;
NativeMethods.PERF_DATA_BLOCK dataBlock = new NativeMethods.PERF_DATA_BLOCK();
fixed (byte* dataPtr = data) {
IntPtr dataRef = new IntPtr((void*) dataPtr);
Marshal.PtrToStructure(dataRef, dataBlock);
this.SystemFrequency = dataBlock.PerfFreq;
this.TimeStamp = dataBlock.PerfTime;
this.TimeStamp100nSec = dataBlock.PerfTime100nSec;
dataRef = (IntPtr)((long)dataRef + dataBlock.HeaderLength);
int numPerfObjects = dataBlock.NumObjectTypes;
if (numPerfObjects == 0) {
this.CounterTable = new Hashtable();
this.InstanceNameTable = new Hashtable(StringComparer.OrdinalIgnoreCase);
return;
}
//Need to find the right category, GetPerformanceData might return
//several of them.
NativeMethods.PERF_OBJECT_TYPE perfObject = null;
bool foundCategory = false;
for (int index = 0; index < numPerfObjects; index++) {
perfObject = new NativeMethods.PERF_OBJECT_TYPE();
Marshal.PtrToStructure(dataRef, perfObject);
if (perfObject.ObjectNameTitleIndex == categoryIndex) {
foundCategory = true;
break;
}
dataRef = (IntPtr)((long)dataRef + perfObject.TotalByteLength);
}
if (!foundCategory)
throw new InvalidOperationException(SR.GetString(SR.CantReadCategoryIndex, categoryIndex.ToString(CultureInfo.CurrentCulture)));
this.CounterFrequency = perfObject.PerfFreq;
this.CounterTimeStamp = perfObject.PerfTime;
int counterNumber = perfObject.NumCounters;
int instanceNumber = perfObject.NumInstances;
if (instanceNumber == -1)
IsMultiInstance = false;
else
IsMultiInstance = true;
// Move pointer forward to end of PERF_OBJECT_TYPE
dataRef = (IntPtr)((long)dataRef + perfObject.HeaderLength);
CounterDefinitionSample[] samples = new CounterDefinitionSample[counterNumber];
this.CounterTable = new Hashtable(counterNumber);
for (int index = 0; index < samples.Length; ++ index) {
NativeMethods.PERF_COUNTER_DEFINITION perfCounter = new NativeMethods.PERF_COUNTER_DEFINITION();
Marshal.PtrToStructure(dataRef, perfCounter);
samples[index] = new CounterDefinitionSample(perfCounter, this, instanceNumber);
dataRef = (IntPtr)((long)dataRef + perfCounter.ByteLength);
int currentSampleType = samples[index].CounterType;
if (!PerformanceCounterLib.IsBaseCounter(currentSampleType)) {
// We'll put only non-base counters in the table.
if (currentSampleType != NativeMethods.PERF_COUNTER_NODATA)
this.CounterTable[samples[index].NameIndex] = samples[index];
}
else {
// it's a base counter, try to hook it up to the main counter.
Debug.Assert(index > 0, "Index > 0 because base counters should never be at index 0");
if (index > 0)
samples[index-1].BaseCounterDefinitionSample = samples[index];
}
}
// now set up the InstanceNameTable.
if (!IsMultiInstance) {
this.InstanceNameTable = new Hashtable(1, StringComparer.OrdinalIgnoreCase);
this.InstanceNameTable[PerformanceCounterLib.SingleInstanceName] = 0;
for (int index = 0; index < samples.Length; ++ index) {
samples[index].SetInstanceValue(0, dataRef);
}
}
else {
string[] parentInstanceNames = null;
this.InstanceNameTable = new Hashtable(instanceNumber, StringComparer.OrdinalIgnoreCase);
for (int i = 0; i < instanceNumber; i++) {
NativeMethods.PERF_INSTANCE_DEFINITION perfInstance = new NativeMethods.PERF_INSTANCE_DEFINITION();
Marshal.PtrToStructure(dataRef, perfInstance);
if (perfInstance.ParentObjectTitleIndex > 0 && parentInstanceNames == null)
parentInstanceNames = GetInstanceNamesFromIndex(perfInstance.ParentObjectTitleIndex);
string instanceName;
if (parentInstanceNames != null && perfInstance.ParentObjectInstance >= 0 && perfInstance.ParentObjectInstance < parentInstanceNames.Length - 1)
instanceName = parentInstanceNames[perfInstance.ParentObjectInstance] + "/" + Marshal.PtrToStringUni((IntPtr)((long)dataRef + perfInstance.NameOffset));
else
instanceName = Marshal.PtrToStringUni((IntPtr)((long)dataRef + perfInstance.NameOffset));
//In some cases instance names are not unique (Process), same as perfmon
//generate a unique name.
string newInstanceName = instanceName;
int newInstanceNumber = 1;
while (true) {
if (!this.InstanceNameTable.ContainsKey(newInstanceName)) {
this.InstanceNameTable[newInstanceName] = i;
break;
}
else {
newInstanceName = instanceName + "#" + newInstanceNumber.ToString(CultureInfo.InvariantCulture);
++ newInstanceNumber;
}
}
dataRef = (IntPtr)((long)dataRef + perfInstance.ByteLength);
for (int index = 0; index < samples.Length; ++ index)
samples[index].SetInstanceValue(i, dataRef);
dataRef = (IntPtr)((long)dataRef + Marshal.ReadInt32(dataRef));
}
}
}
}
static ProcessInfo[] GetProcessInfos(PerformanceCounterLib library, int processIndex, int threadIndex, byte[] data) {
Debug.WriteLineIf(Process.processTracing.TraceVerbose, "GetProcessInfos()");
Hashtable processInfos = new Hashtable();
ArrayList threadInfos = new ArrayList();
GCHandle dataHandle = new GCHandle();
try {
dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
IntPtr dataBlockPtr = dataHandle.AddrOfPinnedObject();
NativeMethods.PERF_DATA_BLOCK dataBlock = new NativeMethods.PERF_DATA_BLOCK();
Marshal.PtrToStructure(dataBlockPtr, dataBlock);
IntPtr typePtr = (IntPtr)((long)dataBlockPtr + dataBlock.HeaderLength);
NativeMethods.PERF_INSTANCE_DEFINITION instance = new NativeMethods.PERF_INSTANCE_DEFINITION();
NativeMethods.PERF_COUNTER_BLOCK counterBlock = new NativeMethods.PERF_COUNTER_BLOCK();
for (int i = 0; i < dataBlock.NumObjectTypes; i++) {
NativeMethods.PERF_OBJECT_TYPE type = new NativeMethods.PERF_OBJECT_TYPE();
Marshal.PtrToStructure(typePtr, type);
IntPtr instancePtr = (IntPtr)((long)typePtr + type.DefinitionLength);
IntPtr counterPtr = (IntPtr)((long)typePtr + type.HeaderLength);
ArrayList counterList = new ArrayList();
for (int j = 0; j < type.NumCounters; j++) {
NativeMethods.PERF_COUNTER_DEFINITION counter = new NativeMethods.PERF_COUNTER_DEFINITION();
Marshal.PtrToStructure(counterPtr, counter);
string counterName = library.GetCounterName(counter.CounterNameTitleIndex);
if (type.ObjectNameTitleIndex == processIndex)
counter.CounterNameTitlePtr = (int)GetValueId(counterName);
else if (type.ObjectNameTitleIndex == threadIndex)
counter.CounterNameTitlePtr = (int)GetValueId(counterName);
counterList.Add(counter);
counterPtr = (IntPtr)((long)counterPtr + counter.ByteLength);
}
NativeMethods.PERF_COUNTER_DEFINITION[] counters = new NativeMethods.PERF_COUNTER_DEFINITION[counterList.Count];
counterList.CopyTo(counters, 0);
for (int j = 0; j < type.NumInstances; j++) {
Marshal.PtrToStructure(instancePtr, instance);
IntPtr namePtr = (IntPtr)((long)instancePtr + instance.NameOffset);
string instanceName = Marshal.PtrToStringUni(namePtr);
if (instanceName.Equals("_Total")) continue;
IntPtr counterBlockPtr = (IntPtr)((long)instancePtr + instance.ByteLength);
Marshal.PtrToStructure(counterBlockPtr, counterBlock);
if (type.ObjectNameTitleIndex == processIndex) {
ProcessInfo processInfo = GetProcessInfo(type, (IntPtr)((long)instancePtr + instance.ByteLength), counters);
if (processInfo.processId == 0 && string.Compare(instanceName, "Idle", StringComparison.OrdinalIgnoreCase) != 0) {
// Sometimes we'll get a process structure that is not completely filled in.
// We can catch some of these by looking for non-"idle" processes that have id 0
// and ignoring those.
Debug.WriteLineIf(Process.processTracing.TraceVerbose, "GetProcessInfos() - found a non-idle process with id 0; ignoring.");
}
else {
if (processInfos[processInfo.processId] != null) {
// We've found two entries in the perfcounters that claim to be the
// same process. We throw an exception. Is this really going to be
// helpfull to the user? Should we just ignore?
Debug.WriteLineIf(Process.processTracing.TraceVerbose, "GetProcessInfos() - found a duplicate process id");
}
else {
// the performance counters keep a 15 character prefix of the exe name, and then delete the ".exe",
// if it's in the first 15. The problem is that sometimes that will leave us with part of ".exe"
// at the end. If instanceName ends in ".", ".e", or ".ex" we remove it.
string processName = instanceName;
if (processName.Length == 15) {
if (instanceName.EndsWith(".", StringComparison.Ordinal )) processName = instanceName.Substring(0, 14);
else if (instanceName.EndsWith(".e", StringComparison.Ordinal )) processName = instanceName.Substring(0, 13);
else if (instanceName.EndsWith(".ex", StringComparison.Ordinal)) processName = instanceName.Substring(0, 12);
}
processInfo.processName = processName;
processInfos.Add(processInfo.processId, processInfo);
}
}
}
else if (type.ObjectNameTitleIndex == threadIndex) {
ThreadInfo threadInfo = GetThreadInfo(type, (IntPtr)((long)instancePtr + instance.ByteLength), counters);
if (threadInfo.threadId != 0) threadInfos.Add(threadInfo);
}
instancePtr = (IntPtr)((long)instancePtr + instance.ByteLength + counterBlock.ByteLength);
}
typePtr = (IntPtr)((long)typePtr + type.TotalByteLength);
}
}
finally {
if (dataHandle.IsAllocated) dataHandle.Free();
}
for (int i = 0; i < threadInfos.Count; i++) {
ThreadInfo threadInfo = (ThreadInfo)threadInfos[i];
ProcessInfo processInfo = (ProcessInfo)processInfos[threadInfo.processId];
if (processInfo != null) {
processInfo.threadInfoList.Add(threadInfo);
}
}
ProcessInfo[] temp = new ProcessInfo[processInfos.Values.Count];
processInfos.Values.CopyTo(temp, 0);
return temp;
}
static ProcessInfo[] GetProcessInfos(PerformanceCounterLib library) {
ProcessInfo[] processInfos = new ProcessInfo[0] ;
byte[] dataPtr = null;
int retryCount = 5;
while (processInfos.Length == 0 && retryCount != 0) {
try {
dataPtr = library.GetPerformanceData(PerfCounterQueryString);
processInfos = GetProcessInfos(library, ProcessPerfCounterId, ThreadPerfCounterId, dataPtr);
}
catch (Exception e) {
throw new InvalidOperationException(SR.GetString(SR.CouldntGetProcessInfos), e);
}
--retryCount;
}
if (processInfos.Length == 0)
throw new InvalidOperationException(SR.GetString(SR.ProcessDisabled));
return processInfos;
}
private static ProcessInfo[] GetProcessInfos(PerformanceCounterLib library)
{
ProcessInfo[] infoArray = new ProcessInfo[0];
byte[] data = null;
for (int i = 5; (infoArray.Length == 0) && (i != 0); i--)
{
try
{
data = library.GetPerformanceData("230 232");
infoArray = GetProcessInfos(library, 230, 0xe8, data);
}
catch (Exception exception)
{
throw new InvalidOperationException(SR.GetString("CouldntGetProcessInfos"), exception);
}
}
if (infoArray.Length == 0)
{
throw new InvalidOperationException(SR.GetString("ProcessDisabled"));
}
return infoArray;
}
internal static PerformanceCounterLib GetPerformanceCounterLib(string machineName, CultureInfo culture)
{
SharedUtils.CheckEnvironment();
string lcid = culture.LCID.ToString("X3", CultureInfo.InvariantCulture);
if (machineName.CompareTo(".") == 0)
{
machineName = ComputerName.ToLower(CultureInfo.InvariantCulture);
}
else
{
machineName = machineName.ToLower(CultureInfo.InvariantCulture);
}
if (libraryTable == null)
{
lock (InternalSyncObject)
{
if (libraryTable == null)
{
libraryTable = new Hashtable();
}
}
}
string key = machineName + ":" + lcid;
if (libraryTable.Contains(key))
{
return (PerformanceCounterLib) libraryTable[key];
}
PerformanceCounterLib lib = new PerformanceCounterLib(machineName, lcid);
libraryTable[key] = lib;
return lib;
}
internal unsafe CategorySample(byte[] data, System.Diagnostics.CategoryEntry entry, PerformanceCounterLib library)
{
this.entry = entry;
this.library = library;
int nameIndex = entry.NameIndex;
Microsoft.Win32.NativeMethods.PERF_DATA_BLOCK structure = new Microsoft.Win32.NativeMethods.PERF_DATA_BLOCK();
fixed (byte* numRef = data)
{
IntPtr ptr = new IntPtr((void*) numRef);
Marshal.PtrToStructure(ptr, structure);
this.SystemFrequency = structure.PerfFreq;
this.TimeStamp = structure.PerfTime;
this.TimeStamp100nSec = structure.PerfTime100nSec;
ptr = (IntPtr) (((long) ptr) + structure.HeaderLength);
int numObjectTypes = structure.NumObjectTypes;
if (numObjectTypes == 0)
{
this.CounterTable = new Hashtable();
this.InstanceNameTable = new Hashtable(StringComparer.OrdinalIgnoreCase);
return;
}
Microsoft.Win32.NativeMethods.PERF_OBJECT_TYPE perf_object_type = null;
bool flag = false;
for (int i = 0; i < numObjectTypes; i++)
{
perf_object_type = new Microsoft.Win32.NativeMethods.PERF_OBJECT_TYPE();
Marshal.PtrToStructure(ptr, perf_object_type);
if (perf_object_type.ObjectNameTitleIndex == nameIndex)
{
flag = true;
break;
}
ptr = (IntPtr) (((long) ptr) + perf_object_type.TotalByteLength);
}
if (!flag)
{
throw new InvalidOperationException(SR.GetString("CantReadCategoryIndex", new object[] { nameIndex.ToString(CultureInfo.CurrentCulture) }));
}
this.CounterFrequency = perf_object_type.PerfFreq;
this.CounterTimeStamp = perf_object_type.PerfTime;
int numCounters = perf_object_type.NumCounters;
int numInstances = perf_object_type.NumInstances;
if (numInstances == -1)
{
this.IsMultiInstance = false;
}
else
{
this.IsMultiInstance = true;
}
ptr = (IntPtr) (((long) ptr) + perf_object_type.HeaderLength);
CounterDefinitionSample[] sampleArray = new CounterDefinitionSample[numCounters];
this.CounterTable = new Hashtable(numCounters);
for (int j = 0; j < sampleArray.Length; j++)
{
Microsoft.Win32.NativeMethods.PERF_COUNTER_DEFINITION perf_counter_definition = new Microsoft.Win32.NativeMethods.PERF_COUNTER_DEFINITION();
Marshal.PtrToStructure(ptr, perf_counter_definition);
sampleArray[j] = new CounterDefinitionSample(perf_counter_definition, this, numInstances);
ptr = (IntPtr) (((long) ptr) + perf_counter_definition.ByteLength);
int counterType = sampleArray[j].CounterType;
if (!PerformanceCounterLib.IsBaseCounter(counterType))
{
if (counterType != 0x40000200)
{
this.CounterTable[sampleArray[j].NameIndex] = sampleArray[j];
}
}
else if (j > 0)
{
sampleArray[j - 1].BaseCounterDefinitionSample = sampleArray[j];
}
}
if (!this.IsMultiInstance)
{
this.InstanceNameTable = new Hashtable(1, StringComparer.OrdinalIgnoreCase);
this.InstanceNameTable["systemdiagnosticsperfcounterlibsingleinstance"] = 0;
for (int k = 0; k < sampleArray.Length; k++)
{
sampleArray[k].SetInstanceValue(0, ptr);
}
}
else
{
string[] instanceNamesFromIndex = null;
this.InstanceNameTable = new Hashtable(numInstances, StringComparer.OrdinalIgnoreCase);
for (int m = 0; m < numInstances; m++)
{
string str;
Microsoft.Win32.NativeMethods.PERF_INSTANCE_DEFINITION perf_instance_definition = new Microsoft.Win32.NativeMethods.PERF_INSTANCE_DEFINITION();
Marshal.PtrToStructure(ptr, perf_instance_definition);
if ((perf_instance_definition.ParentObjectTitleIndex > 0) && (instanceNamesFromIndex == null))
{
instanceNamesFromIndex = this.GetInstanceNamesFromIndex(perf_instance_definition.ParentObjectTitleIndex);
}
if (((instanceNamesFromIndex != null) && (perf_instance_definition.ParentObjectInstance >= 0)) && (perf_instance_definition.ParentObjectInstance < (instanceNamesFromIndex.Length - 1)))
{
str = instanceNamesFromIndex[perf_instance_definition.ParentObjectInstance] + "/" + Marshal.PtrToStringUni((IntPtr) (((long) ptr) + perf_instance_definition.NameOffset));
}
else
{
str = Marshal.PtrToStringUni((IntPtr) (((long) ptr) + perf_instance_definition.NameOffset));
}
string key = str;
int num10 = 1;
while (true)
{
if (!this.InstanceNameTable.ContainsKey(key))
{
this.InstanceNameTable[key] = m;
break;
}
key = str + "#" + num10.ToString(CultureInfo.InvariantCulture);
num10++;
}
ptr = (IntPtr) (((long) ptr) + perf_instance_definition.ByteLength);
for (int n = 0; n < sampleArray.Length; n++)
{
sampleArray[n].SetInstanceValue(m, ptr);
}
ptr = (IntPtr) (((long) ptr) + Marshal.ReadInt32(ptr));
}
}
}
}
internal static PerformanceCounterLib GetPerformanceCounterLib(string machineName, CultureInfo culture)
{
string lcidString = culture.Name.ToLowerInvariant();
if (machineName.CompareTo(".") == 0)
machineName = ComputerName.ToLowerInvariant();
else
machineName = machineName.ToLowerInvariant();
if (PerformanceCounterLib.s_libraryTable == null)
{
lock (InternalSyncObject)
{
if (PerformanceCounterLib.s_libraryTable == null)
PerformanceCounterLib.s_libraryTable = new Dictionary<string, PerformanceCounterLib>();
}
}
string libraryKey = machineName + ":" + lcidString;
if (PerformanceCounterLib.s_libraryTable.ContainsKey(libraryKey))
return (PerformanceCounterLib)PerformanceCounterLib.s_libraryTable[libraryKey];
else
{
PerformanceCounterLib library = new PerformanceCounterLib(machineName, lcidString);
PerformanceCounterLib.s_libraryTable[libraryKey] = library;
return library;
}
}