private long MakePath(PDH_COUNTER_PATH_ELEMENTS pathElts, out string outPath, bool bWildcardInstances) { outPath = ""; IntPtr pcchBufferSize = new IntPtr(0); if (bWildcardInstances) { pathElts.InstanceIndex = 0; pathElts.InstanceName = "*"; pathElts.ParentInstance = null; } long num = PdhMakeCounterPath(ref pathElts, IntPtr.Zero, ref pcchBufferSize, 0); if (num == 0x800007d2L) { IntPtr szFullPathBuffer = Marshal.AllocHGlobal((int)(pcchBufferSize.ToInt32() * 2)); try { num = PdhMakeCounterPath(ref pathElts, szFullPathBuffer, ref pcchBufferSize, 0); if (num == 0) { outPath = Marshal.PtrToStringUni(szFullPathBuffer); } } finally { Marshal.FreeHGlobal(szFullPathBuffer); } } return(num); }
private long ParsePath(string fullPath, ref PDH_COUNTER_PATH_ELEMENTS pCounterPathElements) { IntPtr pdwBufferSize = new IntPtr(0); long num = PdhParseCounterPath(fullPath, IntPtr.Zero, ref pdwBufferSize, 0); switch (num) { case 0x800007d2L: case 0: { IntPtr ptr2 = Marshal.AllocHGlobal(pdwBufferSize.ToInt32()); try { num = PdhParseCounterPath(fullPath, ptr2, ref pdwBufferSize, 0); if (num == 0) { pCounterPathElements = (PDH_COUNTER_PATH_ELEMENTS)Marshal.PtrToStructure(ptr2, typeof(PDH_COUNTER_PATH_ELEMENTS)); } } finally { Marshal.FreeHGlobal(ptr2); } break; } } return(num); }
private bool IsPathValid(ref PDH_COUNTER_PATH_ELEMENTS pathElts, out string outPath) { bool flag = false; outPath = ""; IntPtr pcchBufferSize = new IntPtr(0); if (PdhMakeCounterPath(ref pathElts, IntPtr.Zero, ref pcchBufferSize, 0) != 0x800007d2L) { return(false); } IntPtr szFullPathBuffer = Marshal.AllocHGlobal((int)(pcchBufferSize.ToInt32() * 2)); try { if (PdhMakeCounterPath(ref pathElts, szFullPathBuffer, ref pcchBufferSize, 0) != 0) { return(flag); } outPath = Marshal.PtrToStringUni(szFullPathBuffer); if (!this.m_isPreVista) { return(PdhValidatePathEx(this.m_hDataSource, outPath) == 0); } flag = PdhValidatePath(outPath) == 0; } finally { Marshal.FreeHGlobal(szFullPathBuffer); } return(flag); }
public long GetValidPaths(string machineName, string objectName, ref StringCollection counters, ref StringCollection instances, ref StringCollection validPaths) { PDH_COUNTER_PATH_ELEMENTS pathElts = new PDH_COUNTER_PATH_ELEMENTS { MachineName = machineName, ObjectName = objectName }; foreach (string str in counters) { pathElts.CounterName = str; if (instances.Count == 0) { string str2; if (this.IsPathValid(ref pathElts, out str2)) { validPaths.Add(str2); } } else { foreach (string str3 in instances) { string str4; pathElts.InstanceName = str3; pathElts.InstanceIndex = 0; if (this.IsPathValid(ref pathElts, out str4)) { validPaths.Add(str4); } } } } return(0); }
public long AddRelogCountersPreservingPaths(PerformanceCounterSampleSet sampleSet) { long num = 0; foreach (PerformanceCounterSample sample in sampleSet.CounterSamples) { PDH_COUNTER_PATH_ELEMENTS pCounterPathElements = new PDH_COUNTER_PATH_ELEMENTS(); num = this.ParsePath(sample.Path, ref pCounterPathElements); if (num == 0) { IntPtr ptr; num = PdhAddRelogCounter(this.m_hQuery, sample.Path, (long)sample.CounterType, sample.DefaultScale, sample.TimeBase, out ptr); if (num == 0) { CounterHandleNInstance instance = new CounterHandleNInstance { hCounter = ptr }; if (pCounterPathElements.InstanceName != null) { instance.InstanceName = pCounterPathElements.InstanceName.ToLower(CultureInfo.InvariantCulture); } if (!this.m_ReloggerPathToHandleAndInstanceMap.ContainsKey(sample.Path.ToLower(CultureInfo.InvariantCulture))) { this.m_ReloggerPathToHandleAndInstanceMap.Add(sample.Path.ToLower(CultureInfo.InvariantCulture), instance); } } } } if (this.m_ReloggerPathToHandleAndInstanceMap.Keys.Count <= 0) { return(num); } return(0); }
private long MakeAllInstancePath(string origPath, out string unifiedPath) { unifiedPath = origPath; PDH_COUNTER_PATH_ELEMENTS pCounterPathElements = new PDH_COUNTER_PATH_ELEMENTS(); long num = this.ParsePath(origPath, ref pCounterPathElements); if (num != 0) { return(num); } return(this.MakePath(pCounterPathElements, out unifiedPath, true)); }
public long AddCounters(ref StringCollection validPaths, bool bFlushOldCounters) { if (bFlushOldCounters) { this.m_ConsumerPathToHandleAndInstanceMap.Clear(); } bool flag = false; long num = 0; foreach (string str in validPaths) { IntPtr ptr; num = PdhAddCounter(this.m_hQuery, str, IntPtr.Zero, out ptr); if (num == 0) { CounterHandleNInstance instance = new CounterHandleNInstance { hCounter = ptr, InstanceName = null }; PDH_COUNTER_PATH_ELEMENTS pCounterPathElements = new PDH_COUNTER_PATH_ELEMENTS(); num = this.ParsePath(str, ref pCounterPathElements); if ((num == 0) && (pCounterPathElements.InstanceName != null)) { instance.InstanceName = pCounterPathElements.InstanceName.ToLower(CultureInfo.InvariantCulture); } if (!this.m_ConsumerPathToHandleAndInstanceMap.ContainsKey(str.ToLower(CultureInfo.InvariantCulture))) { this.m_ConsumerPathToHandleAndInstanceMap.Add(str.ToLower(CultureInfo.InvariantCulture), instance); } flag = true; } } if (!flag) { return(num); } return(0); }
public long AddCounters(ref StringCollection validPaths, bool bFlushOldCounters) { if (bFlushOldCounters) { this.m_ConsumerPathToHandleAndInstanceMap.Clear(); } bool flag = false; long num = 0; foreach (string str in validPaths) { IntPtr ptr; num = PdhAddCounter(this.m_hQuery, str, IntPtr.Zero, out ptr); if (num == 0) { CounterHandleNInstance instance = new CounterHandleNInstance { hCounter = ptr, InstanceName = null }; PDH_COUNTER_PATH_ELEMENTS pCounterPathElements = new PDH_COUNTER_PATH_ELEMENTS(); num = this.ParsePath(str, ref pCounterPathElements); if ((num == 0) && (pCounterPathElements.InstanceName != null)) { instance.InstanceName = pCounterPathElements.InstanceName.ToLower(CultureInfo.InvariantCulture); } if (!this.m_ConsumerPathToHandleAndInstanceMap.ContainsKey(str.ToLower(CultureInfo.InvariantCulture))) { this.m_ConsumerPathToHandleAndInstanceMap.Add(str.ToLower(CultureInfo.InvariantCulture), instance); } flag = true; } } if (!flag) { return num; } return 0; }
public long AddRelogCountersPreservingPaths(PerformanceCounterSampleSet sampleSet) { long num = 0; foreach (PerformanceCounterSample sample in sampleSet.CounterSamples) { PDH_COUNTER_PATH_ELEMENTS pCounterPathElements = new PDH_COUNTER_PATH_ELEMENTS(); num = this.ParsePath(sample.Path, ref pCounterPathElements); if (num == 0) { IntPtr ptr; num = PdhAddRelogCounter(this.m_hQuery, sample.Path, (long) sample.CounterType, sample.DefaultScale, sample.TimeBase, out ptr); if (num == 0) { CounterHandleNInstance instance = new CounterHandleNInstance { hCounter = ptr }; if (pCounterPathElements.InstanceName != null) { instance.InstanceName = pCounterPathElements.InstanceName.ToLower(CultureInfo.InvariantCulture); } if (!this.m_ReloggerPathToHandleAndInstanceMap.ContainsKey(sample.Path.ToLower(CultureInfo.InvariantCulture))) { this.m_ReloggerPathToHandleAndInstanceMap.Add(sample.Path.ToLower(CultureInfo.InvariantCulture), instance); } } } } if (this.m_ReloggerPathToHandleAndInstanceMap.Keys.Count <= 0) { return num; } return 0; }
// // TranslateLocalCounterPath() helper translates counter paths from English into the current locale language. // NOTE: we can only translate counter set and counter names. // Translated instance names come from providers // This function will leave them unchanged: // however, it works for common cases like "*" and "_total" // and many instance names are just numbers, anyway. // // Also - this only supports local paths, b/c connecting to remote registry // requires a different firewall exception. // This function checks and Asserts if the path is not valid. // public uint TranslateLocalCounterPath(string englishPath, out string localizedPath) { uint res = 0; localizedPath = ""; PDH_COUNTER_PATH_ELEMENTS pathElts = new PDH_COUNTER_PATH_ELEMENTS(); res = ParsePath(englishPath, ref pathElts); if (res != 0) { return res; } // Check if the path is local and assert if not: string machineNameMassaged = pathElts.MachineName.ToLower(CultureInfo.InvariantCulture); machineNameMassaged = machineNameMassaged.TrimStart('\\'); Debug.Assert(machineNameMassaged == System.Environment.MachineName.ToLower(CultureInfo.InvariantCulture)); string lowerEngCtrName = pathElts.CounterName.ToLower(CultureInfo.InvariantCulture); string lowerEngObjectName = pathElts.ObjectName.ToLower(CultureInfo.InvariantCulture); // Get the registry index RegistryKey rootKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Perflib\\009"); string[] regCounters = (string[])rootKey.GetValue("Counter"); // NOTE: 1-based enumeration because the name strings follow index strings in the array Int32 counterIndex = -1; Int32 objIndex = -1; for (uint enumIndex = 1; enumIndex < regCounters.Length; enumIndex++) { string regString = regCounters[enumIndex]; if (regString.ToLower(CultureInfo.InvariantCulture) == lowerEngCtrName) { try { counterIndex = Convert.ToInt32(regCounters[enumIndex - 1], CultureInfo.InvariantCulture); } catch (Exception) { return (uint)PdhResults.PDH_INVALID_PATH; } } else if (regString.ToLower(CultureInfo.InvariantCulture) == lowerEngObjectName) { try { objIndex = Convert.ToInt32(regCounters[enumIndex - 1], CultureInfo.InvariantCulture); } catch (Exception) { return (uint)PdhResults.PDH_INVALID_PATH; } } if (counterIndex != -1 && objIndex != -1) { break; } } if (counterIndex == -1 || objIndex == -1) { return (uint)PdhResults.PDH_INVALID_PATH; } // Now, call retrieve the localized names of the object and the counter by index: string objNameLocalized; res = LookupPerfNameByIndex(pathElts.MachineName, (uint)objIndex, out objNameLocalized); if (res != 0) { return res; } pathElts.ObjectName = objNameLocalized; string ctrNameLocalized; res = LookupPerfNameByIndex(pathElts.MachineName, (uint)counterIndex, out ctrNameLocalized); if (res != 0) { return res; } pathElts.CounterName = ctrNameLocalized; // Assemble the path back by using the translated object and counter names: res = MakePath(pathElts, out localizedPath, false); return res; }
private uint MakeAllInstancePath(string origPath, out string unifiedPath) { unifiedPath = origPath; PDH_COUNTER_PATH_ELEMENTS elts = new PDH_COUNTER_PATH_ELEMENTS(); uint res = ParsePath(origPath, ref elts); if (res != 0) { return res; } return MakePath(elts, out unifiedPath, true); }
private uint ParsePath(string fullPath, ref PDH_COUNTER_PATH_ELEMENTS pCounterPathElements) { IntPtr bufSize = new IntPtr(0); uint res = PdhParseCounterPath(fullPath, IntPtr.Zero, ref bufSize, 0); if (res != PdhResults.PDH_MORE_DATA && res != 0) { //Console.WriteLine("error in PdhParseCounterPath: " + res); return res; } IntPtr structPtr = Marshal.AllocHGlobal(bufSize.ToInt32()); try { res = PdhParseCounterPath(fullPath, structPtr, ref bufSize, 0); if (res == 0) { // // Marshal.PtrToStructure will allocate managed memory for the object, // so the unmanaged ptr can be freed safely // pCounterPathElements = (PDH_COUNTER_PATH_ELEMENTS)Marshal.PtrToStructure(structPtr, typeof(PDH_COUNTER_PATH_ELEMENTS)); } } finally { Marshal.FreeHGlobal(structPtr); } return res; }
private bool IsPathValid(ref PDH_COUNTER_PATH_ELEMENTS pathElts, out string outPath) { bool ret = false; outPath = ""; IntPtr pPathBufferSize = new IntPtr(0); uint res = PdhMakeCounterPath(ref pathElts, IntPtr.Zero, ref pPathBufferSize, 0); if (res != PdhResults.PDH_MORE_DATA) { return false; } Int32 cChars = pPathBufferSize.ToInt32(); IntPtr strPath = Marshal.AllocHGlobal(cChars * sizeof(char)); try { res = PdhMakeCounterPath(ref pathElts, strPath, ref pPathBufferSize, 0); if (res == 0) { outPath = Marshal.PtrToStringUni(strPath); if (!_isPreVista) { ret = (PdhValidatePathEx(_hDataSource, outPath) == 0); } else { ret = (PdhValidatePath(outPath) == 0); } } } finally { Marshal.FreeHGlobal(strPath); } return ret; }
private uint MakePath(PDH_COUNTER_PATH_ELEMENTS pathElts, out string outPath, bool bWildcardInstances) { outPath = ""; IntPtr pPathBufferSize = new IntPtr(0); if (bWildcardInstances) { pathElts.InstanceIndex = 0; pathElts.InstanceName = "*"; pathElts.ParentInstance = null; } uint res = PdhMakeCounterPath(ref pathElts, IntPtr.Zero, ref pPathBufferSize, 0); if (res != PdhResults.PDH_MORE_DATA) { return res; } Int32 cChars = pPathBufferSize.ToInt32(); IntPtr strPath = Marshal.AllocHGlobal(cChars * sizeof(char)); try { res = PdhMakeCounterPath(ref pathElts, strPath, ref pPathBufferSize, 0); if (res == 0) { outPath = Marshal.PtrToStringUni(strPath); } } finally { Marshal.FreeHGlobal(strPath); } return res; }
private static extern long PdhMakeCounterPath(ref PDH_COUNTER_PATH_ELEMENTS pCounterPathElements, IntPtr szFullPathBuffer, ref IntPtr pcchBufferSize, long dwFlags);
public long AddRelogCounters(PerformanceCounterSampleSet sampleSet) { long num = 0; Dictionary <string, List <PerformanceCounterSample> > dictionary = new Dictionary <string, List <PerformanceCounterSample> >(); foreach (PerformanceCounterSample sample in sampleSet.CounterSamples) { PDH_COUNTER_PATH_ELEMENTS pCounterPathElements = new PDH_COUNTER_PATH_ELEMENTS(); num = this.ParsePath(sample.Path, ref pCounterPathElements); if (num == 0) { List <PerformanceCounterSample> list; string str = pCounterPathElements.MachineName.ToLower(CultureInfo.InvariantCulture); string str2 = pCounterPathElements.ObjectName.ToLower(CultureInfo.InvariantCulture); string str3 = pCounterPathElements.CounterName.ToLower(CultureInfo.InvariantCulture); string key = @"\\" + str + @"\" + str2 + @"\" + str3; if (dictionary.TryGetValue(key, out list)) { dictionary[key].Add(sample); } else { List <PerformanceCounterSample> list2 = new List <PerformanceCounterSample> { sample }; dictionary.Add(key, list2); } } } foreach (string str5 in dictionary.Keys) { IntPtr ptr; string path = dictionary[str5][0].Path; if (dictionary[str5].Count > 1) { num = this.MakeAllInstancePath(dictionary[str5][0].Path, out path); if (num != 0) { continue; } } num = PdhAddRelogCounter(this.m_hQuery, path, (long)dictionary[str5][0].CounterType, dictionary[str5][0].DefaultScale, dictionary[str5][0].TimeBase, out ptr); if (num == 0) { foreach (PerformanceCounterSample sample2 in dictionary[str5]) { PDH_COUNTER_PATH_ELEMENTS pdh_counter_path_elements2 = new PDH_COUNTER_PATH_ELEMENTS(); num = this.ParsePath(sample2.Path, ref pdh_counter_path_elements2); if (num == 0) { CounterHandleNInstance instance = new CounterHandleNInstance { hCounter = ptr }; if (pdh_counter_path_elements2.InstanceName != null) { instance.InstanceName = pdh_counter_path_elements2.InstanceName.ToLower(CultureInfo.InvariantCulture); } if (!this.m_ReloggerPathToHandleAndInstanceMap.ContainsKey(sample2.Path.ToLower(CultureInfo.InvariantCulture))) { this.m_ReloggerPathToHandleAndInstanceMap.Add(sample2.Path.ToLower(CultureInfo.InvariantCulture), instance); } } } } } if (this.m_ReloggerPathToHandleAndInstanceMap.Keys.Count <= 0) { return(num); } return(0); }
private long ParsePath(string fullPath, ref PDH_COUNTER_PATH_ELEMENTS pCounterPathElements) { IntPtr pdwBufferSize = new IntPtr(0); long num = PdhParseCounterPath(fullPath, IntPtr.Zero, ref pdwBufferSize, 0); switch (num) { case 0x800007d2L: case 0: { IntPtr ptr2 = Marshal.AllocHGlobal(pdwBufferSize.ToInt32()); try { num = PdhParseCounterPath(fullPath, ptr2, ref pdwBufferSize, 0); if (num == 0) { pCounterPathElements = (PDH_COUNTER_PATH_ELEMENTS) Marshal.PtrToStructure(ptr2, typeof(PDH_COUNTER_PATH_ELEMENTS)); } } finally { Marshal.FreeHGlobal(ptr2); } break; } } return num; }
private long MakeAllInstancePath(string origPath, out string unifiedPath) { unifiedPath = origPath; PDH_COUNTER_PATH_ELEMENTS pCounterPathElements = new PDH_COUNTER_PATH_ELEMENTS(); long num = this.ParsePath(origPath, ref pCounterPathElements); if (num != 0) { return num; } return this.MakePath(pCounterPathElements, out unifiedPath, true); }
public long GetValidPaths(string machineName, string objectName, ref StringCollection counters, ref StringCollection instances, ref StringCollection validPaths) { PDH_COUNTER_PATH_ELEMENTS pathElts = new PDH_COUNTER_PATH_ELEMENTS { MachineName = machineName, ObjectName = objectName }; foreach (string str in counters) { pathElts.CounterName = str; if (instances.Count == 0) { string str2; if (this.IsPathValid(ref pathElts, out str2)) { validPaths.Add(str2); } } else { foreach (string str3 in instances) { string str4; pathElts.InstanceName = str3; pathElts.InstanceIndex = 0; if (this.IsPathValid(ref pathElts, out str4)) { validPaths.Add(str4); } } } } return 0; }
public long TranslateLocalCounterPath(string englishPath, out string localizedPath) { string str5; string str6; long num = 0; localizedPath = ""; PDH_COUNTER_PATH_ELEMENTS pCounterPathElements = new PDH_COUNTER_PATH_ELEMENTS(); num = this.ParsePath(englishPath, ref pCounterPathElements); if (num != 0) { return(num); } string str = pCounterPathElements.MachineName.ToLower(CultureInfo.InvariantCulture).TrimStart(new char[] { '\\' }); string str2 = pCounterPathElements.CounterName.ToLower(CultureInfo.InvariantCulture); string str3 = pCounterPathElements.ObjectName.ToLower(CultureInfo.InvariantCulture); string[] strArray = (string[])Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\009").GetValue("Counter"); int num2 = -1; int num3 = -1; for (long i = 1; i < strArray.Length; i++) { string str4 = strArray[i]; if (str4.ToLower(CultureInfo.InvariantCulture) == str2) { try { num2 = Convert.ToInt32(strArray[(int)((IntPtr)(i - 1))], CultureInfo.InvariantCulture); goto Label_0114; } catch (Exception) { return(0xc0000bc4); } } if (str4.ToLower(CultureInfo.InvariantCulture) == str3) { try { num3 = Convert.ToInt32(strArray[(int)((IntPtr)(i - 1))], CultureInfo.InvariantCulture); } catch (Exception) { return(0xc0000bc4); } } Label_0114: if ((num2 != -1) && (num3 != -1)) { break; } } if ((num2 == -1) || (num3 == -1)) { return(0xc0000bc4); } num = this.LookupPerfNameByIndex(pCounterPathElements.MachineName, (long)num3, out str5); if (num != 0) { return(num); } pCounterPathElements.ObjectName = str5; num = this.LookupPerfNameByIndex(pCounterPathElements.MachineName, (long)num2, out str6); if (num != 0) { return(num); } pCounterPathElements.CounterName = str6; return(this.MakePath(pCounterPathElements, out localizedPath, false)); }
private static extern long PdhMakeCounterPath(ref PDH_COUNTER_PATH_ELEMENTS pCounterPathElements, IntPtr szFullPathBuffer, ref IntPtr pcchBufferSize, long dwFlags);
private bool IsPathValid(ref PDH_COUNTER_PATH_ELEMENTS pathElts, out string outPath) { bool flag = false; outPath = ""; IntPtr pcchBufferSize = new IntPtr(0); if (PdhMakeCounterPath(ref pathElts, IntPtr.Zero, ref pcchBufferSize, 0) != 0x800007d2L) { return false; } IntPtr szFullPathBuffer = Marshal.AllocHGlobal((int) (pcchBufferSize.ToInt32() * 2)); try { if (PdhMakeCounterPath(ref pathElts, szFullPathBuffer, ref pcchBufferSize, 0) != 0) { return flag; } outPath = Marshal.PtrToStringUni(szFullPathBuffer); if (!this.m_isPreVista) { return (PdhValidatePathEx(this.m_hDataSource, outPath) == 0); } flag = PdhValidatePath(outPath) == 0; } finally { Marshal.FreeHGlobal(szFullPathBuffer); } return flag; }
public uint GetValidPaths(string machineName, string objectName, ref StringCollection counters, ref StringCollection instances, ref StringCollection validPaths) { uint res = 0; PDH_COUNTER_PATH_ELEMENTS pathElts = new PDH_COUNTER_PATH_ELEMENTS(); pathElts.MachineName = machineName; pathElts.ObjectName = objectName; foreach (string counterName in counters) { pathElts.CounterName = counterName; if (instances.Count == 0) { string pathCandidate; if (IsPathValid(ref pathElts, out pathCandidate)) { validPaths.Add(pathCandidate); } } else { foreach (string instanceName in instances) { pathElts.InstanceName = instanceName; pathElts.InstanceIndex = 0; string pathCandidate; if (IsPathValid(ref pathElts, out pathCandidate)) { validPaths.Add(pathCandidate); } } } } return res; }
private long MakePath(PDH_COUNTER_PATH_ELEMENTS pathElts, out string outPath, bool bWildcardInstances) { outPath = ""; IntPtr pcchBufferSize = new IntPtr(0); if (bWildcardInstances) { pathElts.InstanceIndex = 0; pathElts.InstanceName = "*"; pathElts.ParentInstance = null; } long num = PdhMakeCounterPath(ref pathElts, IntPtr.Zero, ref pcchBufferSize, 0); if (num == 0x800007d2L) { IntPtr szFullPathBuffer = Marshal.AllocHGlobal((int) (pcchBufferSize.ToInt32() * 2)); try { num = PdhMakeCounterPath(ref pathElts, szFullPathBuffer, ref pcchBufferSize, 0); if (num == 0) { outPath = Marshal.PtrToStringUni(szFullPathBuffer); } } finally { Marshal.FreeHGlobal(szFullPathBuffer); } } return num; }
public uint AddCounters(ref StringCollection validPaths, bool bFlushOldCounters) { Debug.Assert(_hQuery != null && !_hQuery.IsInvalid); if (bFlushOldCounters) { _consumerPathToHandleAndInstanceMap.Clear(); } bool bAtLeastOneAdded = false; uint res = 0; foreach (string counterPath in validPaths) { IntPtr counterHandle; res = PdhAddCounter(_hQuery, counterPath, IntPtr.Zero, out counterHandle); if (res == 0) { CounterHandleNInstance chi = new CounterHandleNInstance(); chi.hCounter = counterHandle; chi.InstanceName = null; PDH_COUNTER_PATH_ELEMENTS pathElts = new PDH_COUNTER_PATH_ELEMENTS(); res = ParsePath(counterPath, ref pathElts); if (res == 0 && pathElts.InstanceName != null) { chi.InstanceName = pathElts.InstanceName.ToLower(CultureInfo.InvariantCulture); } if (!_consumerPathToHandleAndInstanceMap.ContainsKey(counterPath.ToLower(CultureInfo.InvariantCulture))) { _consumerPathToHandleAndInstanceMap.Add(counterPath.ToLower(CultureInfo.InvariantCulture), chi); } bAtLeastOneAdded = true; } } return bAtLeastOneAdded ? 0 : res; }
public long AddRelogCounters(PerformanceCounterSampleSet sampleSet) { long num = 0; Dictionary<string, List<PerformanceCounterSample>> dictionary = new Dictionary<string, List<PerformanceCounterSample>>(); foreach (PerformanceCounterSample sample in sampleSet.CounterSamples) { PDH_COUNTER_PATH_ELEMENTS pCounterPathElements = new PDH_COUNTER_PATH_ELEMENTS(); num = this.ParsePath(sample.Path, ref pCounterPathElements); if (num == 0) { List<PerformanceCounterSample> list; string str = pCounterPathElements.MachineName.ToLower(CultureInfo.InvariantCulture); string str2 = pCounterPathElements.ObjectName.ToLower(CultureInfo.InvariantCulture); string str3 = pCounterPathElements.CounterName.ToLower(CultureInfo.InvariantCulture); string key = @"\\" + str + @"\" + str2 + @"\" + str3; if (dictionary.TryGetValue(key, out list)) { dictionary[key].Add(sample); } else { List<PerformanceCounterSample> list2 = new List<PerformanceCounterSample> { sample }; dictionary.Add(key, list2); } } } foreach (string str5 in dictionary.Keys) { IntPtr ptr; string path = dictionary[str5][0].Path; if (dictionary[str5].Count > 1) { num = this.MakeAllInstancePath(dictionary[str5][0].Path, out path); if (num != 0) { continue; } } num = PdhAddRelogCounter(this.m_hQuery, path, (long) dictionary[str5][0].CounterType, dictionary[str5][0].DefaultScale, dictionary[str5][0].TimeBase, out ptr); if (num == 0) { foreach (PerformanceCounterSample sample2 in dictionary[str5]) { PDH_COUNTER_PATH_ELEMENTS pdh_counter_path_elements2 = new PDH_COUNTER_PATH_ELEMENTS(); num = this.ParsePath(sample2.Path, ref pdh_counter_path_elements2); if (num == 0) { CounterHandleNInstance instance = new CounterHandleNInstance { hCounter = ptr }; if (pdh_counter_path_elements2.InstanceName != null) { instance.InstanceName = pdh_counter_path_elements2.InstanceName.ToLower(CultureInfo.InvariantCulture); } if (!this.m_ReloggerPathToHandleAndInstanceMap.ContainsKey(sample2.Path.ToLower(CultureInfo.InvariantCulture))) { this.m_ReloggerPathToHandleAndInstanceMap.Add(sample2.Path.ToLower(CultureInfo.InvariantCulture), instance); } } } } } if (this.m_ReloggerPathToHandleAndInstanceMap.Keys.Count <= 0) { return num; } return 0; }
// // AddRelogCounters combines instances and adds counters to m_hQuery. // The counter handles and full paths // public uint AddRelogCounters(PerformanceCounterSampleSet sampleSet) { Debug.Assert(_hQuery != null && !_hQuery.IsInvalid); uint res = 0; Dictionary<string, List<PerformanceCounterSample>> prefixInstanceMap = new Dictionary<string, List<PerformanceCounterSample>>(); // // Go through all the samples one, constructing prefixInstanceMap and adding new counters as needed // foreach (PerformanceCounterSample sample in sampleSet.CounterSamples) { PDH_COUNTER_PATH_ELEMENTS pathElts = new PDH_COUNTER_PATH_ELEMENTS(); res = ParsePath(sample.Path, ref pathElts); if (res != 0) { // Skipping for now, but should be a non-terminating error continue; } string lowerCaseMachine = pathElts.MachineName.ToLower(CultureInfo.InvariantCulture); string lowerCaseObject = pathElts.ObjectName.ToLower(CultureInfo.InvariantCulture); string lowerCaseCounter = pathElts.CounterName.ToLower(CultureInfo.InvariantCulture); string lcPathMinusInstance = @"\\" + lowerCaseMachine + @"\" + lowerCaseObject + @"\" + lowerCaseCounter; List<PerformanceCounterSample> sampleList; if (prefixInstanceMap.TryGetValue(lcPathMinusInstance, out sampleList)) { prefixInstanceMap[lcPathMinusInstance].Add(sample); } else { List<PerformanceCounterSample> newList = new List<PerformanceCounterSample>(); newList.Add(sample); prefixInstanceMap.Add(lcPathMinusInstance, newList); } //Console.WriteLine ("Added path " + sample.Path + " to the 1ist map with prefix " + lcPathMinusInstance); } // // Add counters to the query, consolidating multi-instance with a wildcard path, // and construct m_ReloggerPathToHandleAndInstanceMap where each full path would be pointing to its counter handle // and an instance name (might be empty for no-instance counter types). // You can have multiple full paths inside m_ReloggerPathToHandleAndInstanceMap pointing to the same handle. // foreach (string prefix in prefixInstanceMap.Keys) { IntPtr counterHandle; string unifiedPath = prefixInstanceMap[prefix][0].Path; if (prefixInstanceMap[prefix].Count > 1) { res = MakeAllInstancePath(prefixInstanceMap[prefix][0].Path, out unifiedPath); if (res != 0) { // Skipping for now, but should be a non-terminating error continue; } } res = PdhAddRelogCounter(_hQuery, unifiedPath, (UInt32)prefixInstanceMap[prefix][0].CounterType, prefixInstanceMap[prefix][0].DefaultScale, prefixInstanceMap[prefix][0].TimeBase, out counterHandle); if (res != 0) { // Skipping for now, but should be a non-terminating error // Console.WriteLine ("PdhAddCounter returned " + res + " for counter path " + unifiedPath); continue; } //Console.WriteLine ("added pdh query path:" + unifiedPath ); //now, add all actual paths to m_ReloggerPathToHandleAndInstanceMap foreach (PerformanceCounterSample sample in prefixInstanceMap[prefix]) { PDH_COUNTER_PATH_ELEMENTS pathElts = new PDH_COUNTER_PATH_ELEMENTS(); res = ParsePath(sample.Path, ref pathElts); if (res != 0) { // Skipping for now, but should be a non-terminating error continue; } CounterHandleNInstance chi = new CounterHandleNInstance(); chi.hCounter = counterHandle; if (pathElts.InstanceName != null) { chi.InstanceName = pathElts.InstanceName.ToLower(CultureInfo.InvariantCulture); } if (!_reloggerPathToHandleAndInstanceMap.ContainsKey(sample.Path.ToLower(CultureInfo.InvariantCulture))) { _reloggerPathToHandleAndInstanceMap.Add(sample.Path.ToLower(CultureInfo.InvariantCulture), chi); //Console.WriteLine ("added map path:" + sample.Path ); } } } //TODO: verify that all counters are in the map return (_reloggerPathToHandleAndInstanceMap.Keys.Count > 0) ? 0 : res; }
public long TranslateLocalCounterPath(string englishPath, out string localizedPath) { string str5; string str6; long num = 0; localizedPath = ""; PDH_COUNTER_PATH_ELEMENTS pCounterPathElements = new PDH_COUNTER_PATH_ELEMENTS(); num = this.ParsePath(englishPath, ref pCounterPathElements); if (num != 0) { return num; } string str = pCounterPathElements.MachineName.ToLower(CultureInfo.InvariantCulture).TrimStart(new char[] { '\\' }); string str2 = pCounterPathElements.CounterName.ToLower(CultureInfo.InvariantCulture); string str3 = pCounterPathElements.ObjectName.ToLower(CultureInfo.InvariantCulture); string[] strArray = (string[]) Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\009").GetValue("Counter"); int num2 = -1; int num3 = -1; for (long i = 1; i < strArray.Length; i++) { string str4 = strArray[i]; if (str4.ToLower(CultureInfo.InvariantCulture) == str2) { try { num2 = Convert.ToInt32(strArray[(int) ((IntPtr) (i - 1))], CultureInfo.InvariantCulture); goto Label_0114; } catch (Exception) { return 0xc0000bc4; } } if (str4.ToLower(CultureInfo.InvariantCulture) == str3) { try { num3 = Convert.ToInt32(strArray[(int) ((IntPtr) (i - 1))], CultureInfo.InvariantCulture); } catch (Exception) { return 0xc0000bc4; } } Label_0114: if ((num2 != -1) && (num3 != -1)) { break; } } if ((num2 == -1) || (num3 == -1)) { return 0xc0000bc4; } num = this.LookupPerfNameByIndex(pCounterPathElements.MachineName, (long) num3, out str5); if (num != 0) { return num; } pCounterPathElements.ObjectName = str5; num = this.LookupPerfNameByIndex(pCounterPathElements.MachineName, (long) num2, out str6); if (num != 0) { return num; } pCounterPathElements.CounterName = str6; return this.MakePath(pCounterPathElements, out localizedPath, false); }
// // AddRelogCountersPreservingPaths preserves all paths and adds as relog counters to m_hQuery. // The counter handles and full paths are added to m_ReloggerPathToHandleAndInstanceMap // public uint AddRelogCountersPreservingPaths(PerformanceCounterSampleSet sampleSet) { Debug.Assert(_hQuery != null && !_hQuery.IsInvalid); uint res = 0; // // Go through all the samples one, constructing prefixInstanceMap and adding new counters as needed // foreach (PerformanceCounterSample sample in sampleSet.CounterSamples) { PDH_COUNTER_PATH_ELEMENTS pathElts = new PDH_COUNTER_PATH_ELEMENTS(); res = ParsePath(sample.Path, ref pathElts); if (res != 0) { // Skipping for now, but should be a non-terminating error continue; } IntPtr counterHandle; res = PdhAddRelogCounter(_hQuery, sample.Path, (uint)sample.CounterType, sample.DefaultScale, sample.TimeBase, out counterHandle); if (res != 0) { // Skipping for now, but should be a non-terminating error continue; } CounterHandleNInstance chi = new CounterHandleNInstance(); chi.hCounter = counterHandle; if (pathElts.InstanceName != null) { chi.InstanceName = pathElts.InstanceName.ToLower(CultureInfo.InvariantCulture); } if (!_reloggerPathToHandleAndInstanceMap.ContainsKey(sample.Path.ToLower(CultureInfo.InvariantCulture))) { _reloggerPathToHandleAndInstanceMap.Add(sample.Path.ToLower(CultureInfo.InvariantCulture), chi); } } return (_reloggerPathToHandleAndInstanceMap.Keys.Count > 0) ? 0 : res; }