public static ProcessInfo[] Enum()
{
List<ProcessInfo> Result = new List<ProcessInfo>();
Process[] ProcList = Process.GetProcesses();
for (int i = 0; i < ProcList.Length; i++)
{
Process Proc = ProcList[i];
try
{
ProcessInfo Info = new ProcessInfo();
Info.FileName = Proc.MainModule.FileName;
Info.Id = Proc.Id;
Info.Is64Bit = RemoteHooking.IsX64Process(Proc.Id);
Info.Identity = RemoteHooking.GetProcessIdentity(Proc.Id).Owner.ToString();
Result.Add(Info);
}
catch
{
}
}
return Result.ToArray();
}
public static ProcessInfo[] EnumProcesses()
{
List<ProcessInfo> result = new List<ProcessInfo>();
Process[] procList = Process.GetProcesses();
for (int i = 0; i < procList.Length; i++)
{
Process proc = procList[i];
try
{
ProcessInfo info = new ProcessInfo();
info.FileName = proc.MainModule.FileName;
info.Id = proc.Id;
info.Is64Bit = RemoteHooking.IsX64Process(proc.Id);
info.User = RemoteHooking.GetProcessIdentity(proc.Id).Name;
result.Add(info);
}
catch
{
}
}
return result.ToArray();
}
public static ProcessInfo[] EnumProcesses()
{
var result = new List<ProcessInfo>();
var procList = Process.GetProcesses();
foreach (var proc in procList)
{
try
{
var info = new ProcessInfo
{
FileName = proc.MainModule.FileName,
ID = proc.Id,
Is64Bit = RemoteHooking.IsX64Process(proc.Id),
User = RemoteHooking.GetProcessIdentity(proc.Id)
.Name
};
result.Add(info);
}
catch
{
}
}
return result.ToArray();
}
static FileLocker()
{
Process currentProcess = Process.GetCurrentProcess();
Int32 processId = currentProcess.Id;
String processName = currentProcess.ProcessName;
Int64 startTimeTicks = currentProcess.StartTime.Ticks;
CurrentProcessInfo = new ProcessInfo(processId, processName, startTimeTicks);
}
// -----------------------------
// ---- PAL layer ends here ----
// -----------------------------
private static ProcessInfo CreateProcessInfo(int pid)
{
// Negative PIDs aren't valid
if (pid < 0)
{
throw new ArgumentOutOfRangeException("pid");
}
ProcessInfo procInfo = new ProcessInfo()
{
ProcessId = pid
};
// Try to get the task info. This can fail if the user permissions don't permit
// this user context to query the specified process
Interop.libproc.proc_taskallinfo? info = Interop.libproc.GetProcessInfoById(pid);
if (info.HasValue)
{
// Set the values we have; all the other values don't have meaning or don't exist on OSX
Interop.libproc.proc_taskallinfo temp = info.Value;
unsafe { procInfo.ProcessName = Marshal.PtrToStringAnsi(new IntPtr(temp.pbsd.pbi_comm)); }
procInfo.BasePriority = temp.pbsd.pbi_nice;
procInfo.HandleCount = Interop.libproc.GetFileDescriptorCountForPid(pid);
procInfo.VirtualBytes = (long)temp.ptinfo.pti_virtual_size;
procInfo.WorkingSet = (long)temp.ptinfo.pti_resident_size;
}
// Get the sessionId for the given pid, getsid returns -1 on error
int sessionId = Interop.libc.getsid(pid);
if (sessionId != -1)
procInfo.SessionId = sessionId;
// Create a threadinfo for each thread in the process
List<KeyValuePair<ulong, Interop.libproc.proc_threadinfo?>> lstThreads = Interop.libproc.GetAllThreadsInProcess(pid);
foreach (KeyValuePair<ulong, Interop.libproc.proc_threadinfo?> t in lstThreads)
{
var ti = new ThreadInfo()
{
_processId = pid,
_threadId = (int)t.Key, // The OS X thread ID is 64-bits, but we're forced to truncate due to the public API signature
_basePriority = 0,
_startAddress = IntPtr.Zero
};
// Fill in additional info if we were able to retrieve such data about the thread
if (t.Value.HasValue)
{
ti._currentPriority = t.Value.Value.pth_curpri;
ti._threadState = ConvertOsxThreadRunStateToThreadState((Interop.libproc.ThreadRunState)t.Value.Value.pth_run_state);
ti._threadWaitReason = ConvertOsxThreadFlagsToWaitReason((Interop.libproc.ThreadFlags)t.Value.Value.pth_flags);
}
procInfo._threadInfoList.Add(ti);
}
return procInfo;
}
//private static List<Int32> ActivePIDList = new List<Int32>();
public static ProcessInfo AddHookedProcess(Process process)
{
lock (ProcessList)
{
ProcessInfo pInfo = new ProcessInfo(process);
ProcessList.Add(pInfo);
HookedProcesses.Add(process.Id);
return pInfo;
}
}
public Player()
{
currentState = new LoginState(this);
ProcessInfo = new ProcessInfo();
ProcessInfo.Status = ProcessInfo.StatusCode.NotInitialized;
Messager = new Messager();
messageQueue = Messager.Queue;
messagerThread = new Thread(
new ThreadStart(Messager.Receive));
messagerThread.Start();
}
// CreateProcess wrapper
public static bool CreateProcess(String ExeName, String
CmdLine, ProcessInfo pi)
{
if (pi == null)
pi = new ProcessInfo();
byte[] si = new byte[128];
return CreateProcess(ExeName, CmdLine, IntPtr.Zero,
IntPtr.Zero, 0, 0, IntPtr.Zero, IntPtr.Zero, si, pi) != 0;
}
private void GetProcesses()
{
listBox1.Items.Clear();
var processes = Process.GetProcesses();
foreach (var process in processes)
{
var processInfo = new ProcessInfo(process.Id, process.ProcessName);
listBox1.Items.Add(processInfo);
}
}
static extern bool CreateProcessWithLogonW(
string principal,
string authority,
string password,
LogonFlags logonFlags,
string appName,
string cmdLine,
CreationFlags creationFlags,
IntPtr environmentBlock,
string currentDirectory,
ref StartupInfo startupInfo,
out ProcessInfo processInfo);
// -----------------------------
// ---- PAL layer ends here ----
// -----------------------------
private unsafe static ProcessInfo CreateProcessInfo(int pid)
{
// Negative PIDs aren't valid
if (pid < 0)
{
throw new ArgumentOutOfRangeException("pid");
}
ProcessInfo procInfo = new ProcessInfo();
// Try to get the task info. This can fail if the user permissions don't permit
// this user context to query the specified process
Interop.libproc.proc_taskallinfo? info = Interop.libproc.GetProcessInfoById(pid);
if (info.HasValue)
{
// We need to convert the byte pointer to an IntPtr
// that we can pass to the Marshal.PtrToStringAnsi call
// but the nullable struct type makes it difficult to inline,
// so make a temp variable to remove the nullable and get the pointer
Interop.libproc.proc_taskallinfo temp = info.Value;
IntPtr ptrString = new IntPtr(temp.pbsd.pbi_comm);
// Set the values we have; all the other values don't have meaning or don't exist on OSX
procInfo.BasePriority = temp.ptinfo.pti_priority;
procInfo.HandleCount = Interop.libproc.GetFileDescriptorCountForPid(pid);
procInfo.ProcessId = pid;
procInfo.ProcessName = System.Runtime.InteropServices.Marshal.PtrToStringAnsi(ptrString);
procInfo.VirtualBytes = (long)temp.ptinfo.pti_virtual_size;
procInfo.WorkingSet = (long)temp.ptinfo.pti_resident_size;
}
// Create a threadinfo for each thread in the process
List<KeyValuePair<ulong, Interop.libproc.proc_threadinfo?>> lstThreads = Interop.libproc.GetAllThreadsInProcess(pid);
foreach (KeyValuePair<ulong, Interop.libproc.proc_threadinfo?> t in lstThreads)
{
if (t.Value.HasValue)
{
procInfo._threadInfoList.Add(new ThreadInfo()
{
_basePriority = 0,
_currentPriority = t.Value.Value.pth_curpri,
_processId = pid,
_startAddress = IntPtr.Zero, // We don't have this info
_threadId = Convert.ToInt32(t.Key),
_threadState = ConvertOsxThreadRunStateToThreadState((Interop.libproc.ThreadRunState)t.Value.Value.pth_run_state),
_threadWaitReason = ConvertOsxThreadFlagsToWaitReason((Interop.libproc.ThreadFlags)t.Value.Value.pth_flags)
});
}
}
return procInfo;
}
public override void Init(string xmlInformation)
{
XmlDocument xmlDoc = new XmlDocument();
List<ProcessInfo> list = new List<ProcessInfo>();
xmlDoc.LoadXml(xmlInformation);
foreach (XmlNode node in xmlDoc.ChildNodes[0].ChildNodes)
{
ProcessInfo pInfo = new ProcessInfo();
pInfo.PID = int.Parse(node.Attributes["ID"].Value);
pInfo.Name = node.Attributes["Name"].Value;
pInfo.MemoryUsed = long.Parse(node.Attributes["Memory"].Value);
list.Add(pInfo);
}
Processes = list.ToArray();
}
public static ProcessInfo GetHookedProcess(Process process)
{
lock (ProcessList)
{
ProcessInfo pInfo = new ProcessInfo(process);
int index = ProcessList.IndexOf(pInfo);
if (index > -1)
{
return ProcessList[index];
}
else
{
return null;
}
}
}
public override IEnumerator<object> WaitUntilProcessReady(ProcessInfo process)
{
bool isReady = false;
do {
yield return Program.EvalPython<bool>(process, @"
try:
m = __import__('uix')
g = getattr(__import__('__builtin__'), 'sm', None)
return (m is not None) and (g is not None)
except:
return False").Bind(() => isReady);
yield return new Sleep(1);
} while (!isReady);
Console.WriteLine("EVE started.");
}
protected override string GetInformationXML()
{
StringBuilder strBld = new StringBuilder();
strBld.Append("<ProcessStateInfo>");
if (activeProcesses != null)
{
if (activeProcesses.Length > 0)
{
foreach (Process p in activeProcesses)
{
ProcessInfo pInfo = new ProcessInfo();
pInfo.Name = p.ProcessName;
pInfo.MemoryUsed = p.PagedMemorySize64;
pInfo.PID = p.Id;
strBld.Append(pInfo.ToXML());
}
}
}
strBld.Append("</ProcessStateInfo>");
return strBld.ToString();
}
private static uint CreateHoneytokenProcess(string appPath, string domain, string user,
string password, LogonFlags lf, CreationFlags cf)
{
StartupInfo si = new StartupInfo();
si.cb = Marshal.SizeOf(typeof(StartupInfo));
ProcessInfo pi = new ProcessInfo();
pi.dwProcessId = 0;
if (CreateProcessWithLogonW(user, domain, password,
lf,
appPath, null,
cf, IntPtr.Zero, null,
ref si, out pi))
{
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
}
else
{
throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());
}
return(pi.dwProcessId);
}
public ViewResultBase Details()
{
if (!string.IsNullOrEmpty(Request["isTooltip"]))
{
Guid id;
if (Guid.TryParse(Request["id"], out id))
{
var data = new ProcessInfo(base.EntityType.GetData(id));
return new PartialViewResult { ViewName = "Partials/Details", ViewData = new ViewDataDictionary(data) };
}
else
{
throw new ValidationException("非法的Guid标识" + Request["id"]);
}
}
else if (!string.IsNullOrEmpty(Request["isInner"]))
{
return new PartialViewResult { ViewName = "Partials/Details" };
}
else
{
return this.View();
}
}
public static ProcessInfo[] GetProcessInfos() {
IntPtr handle = (IntPtr)(-1);
GCHandle bufferHandle = new GCHandle();
ArrayList threadInfos = new ArrayList();
Hashtable processInfos = new Hashtable();
try {
handle = NativeMethods.CreateToolhelp32Snapshot(NativeMethods.TH32CS_SNAPPROCESS | NativeMethods.TH32CS_SNAPTHREAD, 0);
if (handle == (IntPtr)(-1)) throw new Win32Exception();
int entrySize = (int)Marshal.SizeOf(typeof(NativeMethods.WinProcessEntry));
int bufferSize = entrySize + NativeMethods.WinProcessEntry.sizeofFileName;
int[] buffer = new int[bufferSize / 4];
bufferHandle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
IntPtr bufferPtr = bufferHandle.AddrOfPinnedObject();
Marshal.WriteInt32(bufferPtr, bufferSize);
HandleRef handleRef = new HandleRef(null, handle);
if (NativeMethods.Process32First(handleRef, bufferPtr)) {
do {
NativeMethods.WinProcessEntry process = new NativeMethods.WinProcessEntry();
Marshal.PtrToStructure(bufferPtr, process);
ProcessInfo processInfo = new ProcessInfo();
String name = Marshal.PtrToStringAnsi((IntPtr)((long)bufferPtr + entrySize));
processInfo.processName = Path.ChangeExtension(Path.GetFileName(name), null);
processInfo.handleCount = process.cntUsage;
processInfo.processId = process.th32ProcessID;
processInfo.basePriority = process.pcPriClassBase;
processInfo.mainModuleId = process.th32ModuleID;
processInfos.Add(processInfo.processId, processInfo);
Marshal.WriteInt32(bufferPtr, bufferSize);
}
while (NativeMethods.Process32Next(handleRef, bufferPtr));
}
NativeMethods.WinThreadEntry thread = new NativeMethods.WinThreadEntry();
thread.dwSize = Marshal.SizeOf(thread);
if (NativeMethods.Thread32First(handleRef, thread)) {
do {
ThreadInfo threadInfo = new ThreadInfo();
threadInfo.threadId = thread.th32ThreadID;
threadInfo.processId = thread.th32OwnerProcessID;
threadInfo.basePriority = thread.tpBasePri;
threadInfo.currentPriority = thread.tpBasePri + thread.tpDeltaPri;
threadInfos.Add(threadInfo);
}
while (NativeMethods.Thread32Next(handleRef, thread));
}
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);
//else
// throw new InvalidOperationException(SR.GetString(SR.ProcessNotFound, threadInfo.threadId.ToString(), threadInfo.processId.ToString()));
}
}
finally {
if (bufferHandle.IsAllocated) bufferHandle.Free();
Debug.WriteLineIf(Process.processTracing.TraceVerbose, "Process - CloseHandle(toolhelp32 snapshot handle)");
if (handle != (IntPtr)(-1)) SafeNativeMethods.CloseHandle(handle);
}
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;
}
static ProcessInfo GetProcessInfo(Interop.Advapi32.PERF_OBJECT_TYPE type, IntPtr instancePtr, Interop.Advapi32.PERF_COUNTER_DEFINITION[] counters)
{
ProcessInfo processInfo = new ProcessInfo();
for (int i = 0; i < counters.Length; i++)
{
Interop.Advapi32.PERF_COUNTER_DEFINITION counter = counters[i];
long value = ReadCounterValue(counter.CounterType, (IntPtr)((long)instancePtr + counter.CounterOffset));
switch ((ValueId)counter.CounterNameTitlePtr)
{
case ValueId.ProcessId:
processInfo.ProcessId = (int)value;
break;
case ValueId.PoolPagedBytes:
processInfo.PoolPagedBytes = value;
break;
case ValueId.PoolNonpagedBytes:
processInfo.PoolNonPagedBytes = value;
break;
case ValueId.VirtualBytes:
processInfo.VirtualBytes = value;
break;
case ValueId.VirtualBytesPeak:
processInfo.VirtualBytesPeak = value;
break;
case ValueId.WorkingSetPeak:
processInfo.WorkingSetPeak = value;
break;
case ValueId.WorkingSet:
processInfo.WorkingSet = value;
break;
case ValueId.PageFileBytesPeak:
processInfo.PageFileBytesPeak = value;
break;
case ValueId.PageFileBytes:
processInfo.PageFileBytes = value;
break;
case ValueId.PrivateBytes:
processInfo.PrivateBytes = value;
break;
case ValueId.BasePriority:
processInfo.BasePriority = (int)value;
break;
case ValueId.HandleCount:
processInfo.HandleCount = (int)value;
break;
}
}
return(processInfo);
}
static ProcessInfo[] GetProcessInfos(IntPtr dataPtr) {
// 60 is a reasonable number for processes on a normal machine.
Hashtable processInfos = new Hashtable(60);
long totalOffset = 0;
while(true) {
IntPtr currentPtr = (IntPtr)((long)dataPtr + totalOffset);
SystemProcessInformation pi = new SystemProcessInformation();
Marshal.PtrToStructure(currentPtr, pi);
// get information for a process
ProcessInfo processInfo = new ProcessInfo();
// Process ID shouldn't overflow. OS API GetCurrentProcessID returns DWORD.
processInfo.processId = pi.UniqueProcessId.ToInt32();
processInfo.handleCount = (int)pi.HandleCount;
processInfo.sessionId = (int)pi.SessionId;
processInfo.poolPagedBytes = (long)pi.QuotaPagedPoolUsage;;
processInfo.poolNonpagedBytes = (long)pi.QuotaNonPagedPoolUsage;
processInfo.virtualBytes = (long)pi.VirtualSize;
processInfo.virtualBytesPeak = (long)pi.PeakVirtualSize;
processInfo.workingSetPeak = (long)pi.PeakWorkingSetSize;
processInfo.workingSet = (long)pi.WorkingSetSize;
processInfo.pageFileBytesPeak = (long)pi.PeakPagefileUsage;
processInfo.pageFileBytes = (long)pi.PagefileUsage;
processInfo.privateBytes = (long)pi.PrivatePageCount;
processInfo.basePriority = pi.BasePriority;
if( pi.NamePtr == IntPtr.Zero) {
if( processInfo.processId == NtProcessManager.SystemProcessID) {
processInfo.processName = "System";
}
else if( processInfo.processId == NtProcessManager.IdleProcessID) {
processInfo.processName = "Idle";
}
else {
// for normal process without name, using the process ID.
processInfo.processName = processInfo.processId.ToString(CultureInfo.InvariantCulture);
}
}
else {
string processName = GetProcessShortName(Marshal.PtrToStringUni(pi.NamePtr, pi.NameLength/sizeof(char)));
//
// On old operating system (NT4 and windows 2000), the process name might be truncated to 15
// characters. For example, aspnet_admin.exe will show up in performance counter as aspnet_admin.ex.
// Process class try to return a nicer name. We used to get the main module name for a process and
// use that as the process name. However normal user doesn't have access to module information,
// so normal user will see an exception when we try to get a truncated process name.
//
if (ProcessManager.IsOSOlderThanXP && (processName.Length == 15)) {
if (processName.EndsWith(".", StringComparison.OrdinalIgnoreCase)) {
processName = processName.Substring(0, 14);
}
else if (processName.EndsWith(".e", StringComparison.OrdinalIgnoreCase)) {
processName = processName.Substring(0, 13);
}
else if (processName.EndsWith(".ex", StringComparison.OrdinalIgnoreCase)) {
processName = processName.Substring(0, 12);
}
}
processInfo.processName = processName;
}
// get the threads for current process
processInfos[processInfo.processId] = processInfo;
currentPtr = (IntPtr)((long)currentPtr + Marshal.SizeOf(pi));
int i = 0;
while( i < pi.NumberOfThreads) {
SystemThreadInformation ti = new SystemThreadInformation();
Marshal.PtrToStructure(currentPtr, ti);
ThreadInfo threadInfo = new ThreadInfo();
threadInfo.processId = (int)ti.UniqueProcess;
threadInfo.threadId = (int)ti.UniqueThread;
threadInfo.basePriority = ti.BasePriority;
threadInfo.currentPriority = ti.Priority;
threadInfo.startAddress = ti.StartAddress;
threadInfo.threadState = (ThreadState)ti.ThreadState;
threadInfo.threadWaitReason = NtProcessManager.GetThreadWaitReason((int)ti.WaitReason);
processInfo.threadInfoList.Add(threadInfo);
currentPtr = (IntPtr)((long)currentPtr + Marshal.SizeOf(ti));
i++;
}
if (pi.NextEntryOffset == 0) {
break;
}
totalOffset += pi.NextEntryOffset;
}
ProcessInfo[] temp = new ProcessInfo[processInfos.Values.Count];
processInfos.Values.CopyTo(temp, 0);
return temp;
}
/// <devdoc>
/// Helper method for checking preconditions when accessing properties.
/// </devdoc>
/// <internalonly/>
private void EnsureState(State state)
{
if ((state & State.Associated) != (State)0)
{
if (!Associated)
{
throw new InvalidOperationException(SR.NoAssociatedProcess);
}
}
if ((state & State.HaveId) != (State)0)
{
if (!_haveProcessId)
{
if (_haveProcessHandle)
{
SetProcessId(ProcessManager.GetProcessIdFromHandle(_processHandle));
}
else
{
EnsureState(State.Associated);
throw new InvalidOperationException(SR.ProcessIdRequired);
}
}
if ((state & State.HaveNonExitedId) == State.HaveNonExitedId)
{
ThrowIfExited(refresh: false);
}
}
if ((state & State.IsLocal) != (State)0 && _isRemoteMachine)
{
throw new NotSupportedException(SR.NotSupportedRemote);
}
if ((state & State.HaveProcessInfo) != (State)0)
{
if (_processInfo == null)
{
if ((state & State.HaveNonExitedId) != State.HaveNonExitedId)
{
EnsureState(State.HaveNonExitedId);
}
_processInfo = ProcessManager.GetProcessInfo(_processId, _machineName);
if (_processInfo == null)
{
throw new InvalidOperationException(SR.NoProcessInfo);
}
}
}
if ((state & State.Exited) != (State)0)
{
if (!HasExited)
{
throw new InvalidOperationException(SR.WaitTillExit);
}
if (!_haveProcessHandle)
{
throw new InvalidOperationException(SR.NoProcessHandle);
}
}
}
/// <summary>
/// Creates a ProcessInfo from the data parsed from a /proc/pid/stat file and the associated tasks directory.
/// </summary>
internal static ProcessInfo CreateProcessInfo(ref Interop.procfs.ParsedStat procFsStat, ref Interop.procfs.ParsedStatus procFsStatus, ReusableTextReader reusableReader, string?processName = null)
{
int pid = procFsStat.pid;
var pi = new ProcessInfo()
{
ProcessId = pid,
ProcessName = processName ?? Process.GetUntruncatedProcessName(ref procFsStat) ?? string.Empty,
BasePriority = (int)procFsStat.nice,
SessionId = procFsStat.session,
PoolPagedBytes = (long)procFsStatus.VmSwap,
VirtualBytes = (long)procFsStatus.VmSize,
VirtualBytesPeak = (long)procFsStatus.VmPeak,
WorkingSetPeak = (long)procFsStatus.VmHWM,
WorkingSet = (long)procFsStatus.VmRSS,
PageFileBytes = (long)procFsStatus.VmSwap,
PrivateBytes = (long)procFsStatus.VmData,
// We don't currently fill in the other values.
// A few of these could probably be filled in from getrusage,
// but only for the current process or its children, not for
// arbitrary other processes.
};
// Then read through /proc/pid/task/ to find each thread in the process...
string tasksDir = Interop.procfs.GetTaskDirectoryPathForProcess(pid);
try
{
foreach (string taskDir in Directory.EnumerateDirectories(tasksDir))
{
// ...and read its associated /proc/pid/task/tid/stat file to create a ThreadInfo
string dirName = Path.GetFileName(taskDir);
int tid;
Interop.procfs.ParsedStat stat;
if (int.TryParse(dirName, NumberStyles.Integer, CultureInfo.InvariantCulture, out tid) &&
Interop.procfs.TryReadStatFile(pid, tid, out stat, reusableReader))
{
unsafe
{
pi._threadInfoList.Add(new ThreadInfo()
{
_processId = pid,
_threadId = (ulong)tid,
_basePriority = pi.BasePriority,
_currentPriority = (int)stat.nice,
_startAddress = IntPtr.Zero,
_threadState = ProcFsStateToThreadState(stat.state),
_threadWaitReason = ThreadWaitReason.Unknown
});
}
}
}
}
catch (IOException)
{
// Between the time that we get an ID and the time that we try to read the associated
// directories and files in procfs, the process could be gone.
}
// Finally return what we've built up
return(pi);
}
public static ProcessInfo[] GetProcessInfos()
{
IntPtr ptr = (IntPtr)(-1);
GCHandle handle = new GCHandle();
ArrayList list = new ArrayList();
Hashtable hashtable = new Hashtable();
try
{
Microsoft.Win32.NativeMethods.WinThreadEntry entry2;
ptr = Microsoft.Win32.NativeMethods.CreateToolhelp32Snapshot(6, 0);
if (ptr == ((IntPtr)(-1)))
{
throw new Win32Exception();
}
int num = Marshal.SizeOf(typeof(Microsoft.Win32.NativeMethods.WinProcessEntry));
int val = num + 260;
int[] numArray = new int[val / 4];
handle = GCHandle.Alloc(numArray, GCHandleType.Pinned);
IntPtr ptr2 = handle.AddrOfPinnedObject();
Marshal.WriteInt32(ptr2, val);
HandleRef ref2 = new HandleRef(null, ptr);
if (Microsoft.Win32.NativeMethods.Process32First(ref2, ptr2))
{
do
{
Microsoft.Win32.NativeMethods.WinProcessEntry structure = new Microsoft.Win32.NativeMethods.WinProcessEntry();
Marshal.PtrToStructure(ptr2, structure);
ProcessInfo info = new ProcessInfo();
string path = Marshal.PtrToStringAnsi((IntPtr)(((long)ptr2) + num));
info.processName = Path.ChangeExtension(Path.GetFileName(path), null);
info.handleCount = structure.cntUsage;
info.processId = structure.th32ProcessID;
info.basePriority = structure.pcPriClassBase;
info.mainModuleId = structure.th32ModuleID;
hashtable.Add(info.processId, info);
Marshal.WriteInt32(ptr2, val);
}while (Microsoft.Win32.NativeMethods.Process32Next(ref2, ptr2));
}
entry2 = new Microsoft.Win32.NativeMethods.WinThreadEntry {
dwSize = Marshal.SizeOf(entry2)
};
if (Microsoft.Win32.NativeMethods.Thread32First(ref2, entry2))
{
do
{
ThreadInfo info2 = new ThreadInfo {
threadId = entry2.th32ThreadID,
processId = entry2.th32OwnerProcessID,
basePriority = entry2.tpBasePri,
currentPriority = entry2.tpBasePri + entry2.tpDeltaPri
};
list.Add(info2);
}while (Microsoft.Win32.NativeMethods.Thread32Next(ref2, entry2));
}
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);
}
}
}
finally
{
if (handle.IsAllocated)
{
handle.Free();
}
if (ptr != ((IntPtr)(-1)))
{
Microsoft.Win32.SafeNativeMethods.CloseHandle(new HandleRef(null, ptr));
}
}
ProcessInfo[] array = new ProcessInfo[hashtable.Values.Count];
hashtable.Values.CopyTo(array, 0);
return(array);
}
/// <summary>
/// Currently Mono returns incomplete process names in Process.GetProcesses() so we need to parse 'ps' output.
/// </summary>
/// <returns></returns>
public override ProcessInfo[] GetProcesses()
{
var Result = new List<ProcessInfo>();
var StartInfo = new ProcessStartInfo ();
StartInfo.FileName = "ps";
StartInfo.Arguments = "-eaw -o pid,comm";
StartInfo.CreateNoWindow = true;
StartInfo.UseShellExecute = false;
StartInfo.RedirectStandardOutput = true;
var Proc = new Process ();
Proc.StartInfo = StartInfo;
try
{
Proc.Start();
Proc.WaitForExit();
for (string Line = Proc.StandardOutput.ReadLine(); Line != null; Line = Proc.StandardOutput.ReadLine())
{
Line = Line.Trim();
int PIDEnd = Line.IndexOf(' ');
var PIDString = Line.Substring(0, PIDEnd);
if (PIDString != "PID")
{
var Filename = Line.Substring(PIDEnd + 1);
var Pid = Int32.Parse(PIDString);
try
{
var ExistingProc = Process.GetProcessById(Pid);
if (ExistingProc != null && Pid != Process.GetCurrentProcess().Id && ExistingProc.HasExited == false)
{
var ProcInfo = new ProcessInfo(ExistingProc);
ProcInfo.Name = Path.GetFileName(Filename);
ProcInfo.Filename = Filename;
Result.Add(ProcInfo);
}
} catch {}
}
}
}
catch {}
return Result.ToArray();
}
public virtual IEnumerator<object> WaitUntilProcessReady(ProcessInfo process)
{
yield break;
}
public bool Equals(ProcessInfo p)
{
// If parameter is null return false:
if ((object)p == null)
{
return false;
}
// Return true if the fields match:
return p.Process.Id==this.Process.Id;
}
internal static ProcessInfo?CreateProcessInfo(int pid, string?processNameFilter = null)
{
// Negative PIDs aren't valid
if (pid < 0)
{
throw new ArgumentOutOfRangeException(nameof(pid));
}
ProcessInfo procInfo;
// Try to get the task info. This can fail if the user permissions don't permit
// this user context to query the specified process
Interop.libproc.proc_taskallinfo?info = Interop.libproc.GetProcessInfoById(pid);
if (info.HasValue)
{
// Set the values we have; all the other values don't have meaning or don't exist on OSX
Interop.libproc.proc_taskallinfo temp = info.Value;
string processName;
unsafe { processName = Marshal.PtrToStringUTF8(new IntPtr(temp.pbsd.pbi_comm)) !; }
if (!string.IsNullOrEmpty(processNameFilter) && !string.Equals(processName, processNameFilter, StringComparison.OrdinalIgnoreCase))
{
return(null);
}
procInfo = new ProcessInfo()
{
ProcessId = pid,
ProcessName = processName,
BasePriority = temp.pbsd.pbi_nice,
VirtualBytes = (long)temp.ptinfo.pti_virtual_size,
WorkingSet = (long)temp.ptinfo.pti_resident_size,
};
}
else if (string.IsNullOrEmpty(processNameFilter))
{
procInfo = new ProcessInfo()
{
ProcessId = pid,
};
}
else
{
// We couldn't get process information but we only want to return a process that
// matches the specified name, so consider this process not a match.
return(null);
}
// Get the sessionId for the given pid, getsid returns -1 on error
int sessionId = Interop.Sys.GetSid(pid);
if (sessionId != -1)
{
procInfo.SessionId = sessionId;
}
// Create a threadinfo for each thread in the process
List <KeyValuePair <ulong, Interop.libproc.proc_threadinfo?> > lstThreads = Interop.libproc.GetAllThreadsInProcess(pid);
foreach (KeyValuePair <ulong, Interop.libproc.proc_threadinfo?> t in lstThreads)
{
var ti = new ThreadInfo()
{
_processId = pid,
_threadId = t.Key,
_basePriority = procInfo.BasePriority,
_startAddress = IntPtr.Zero
};
// Fill in additional info if we were able to retrieve such data about the thread
if (t.Value.HasValue)
{
ti._currentPriority = t.Value.Value.pth_curpri;
ti._threadState = ConvertOsxThreadRunStateToThreadState((Interop.libproc.ThreadRunState)t.Value.Value.pth_run_state);
ti._threadWaitReason = ConvertOsxThreadFlagsToWaitReason((Interop.libproc.ThreadFlags)t.Value.Value.pth_flags);
}
procInfo._threadInfoList.Add(ti);
}
return(procInfo);
}
/// <summary>
/// Creates a ProcessInfo from the data parsed from a /proc/pid/stat file and the associated tasks directory.
/// </summary>
internal static ProcessInfo CreateProcessInfo(Interop.procfs.ParsedStat procFsStat, ReusableTextReader reusableReader)
{
int pid = procFsStat.pid;
// Get long process name if possible, otherwise use a fall back method.
string procName = Path.GetFileName(Process.GetExePath(pid));
if (string.IsNullOrEmpty(procName))
{
procName = procFsStat.comm;
}
var pi = new ProcessInfo()
{
ProcessId = pid,
ProcessName = procName,
BasePriority = (int)procFsStat.nice,
VirtualBytes = (long)procFsStat.vsize,
WorkingSet = procFsStat.rss * Environment.SystemPageSize,
SessionId = procFsStat.session,
// We don't currently fill in the other values.
// A few of these could probably be filled in from getrusage,
// but only for the current process or its children, not for
// arbitrary other processes.
};
// Then read through /proc/pid/task/ to find each thread in the process...
string tasksDir = Interop.procfs.GetTaskDirectoryPathForProcess(pid);
try
{
foreach (string taskDir in Directory.EnumerateDirectories(tasksDir))
{
// ...and read its associated /proc/pid/task/tid/stat file to create a ThreadInfo
string dirName = Path.GetFileName(taskDir);
int tid;
Interop.procfs.ParsedStat stat;
if (int.TryParse(dirName, NumberStyles.Integer, CultureInfo.InvariantCulture, out tid) &&
Interop.procfs.TryReadStatFile(pid, tid, out stat, reusableReader))
{
unsafe
{
pi._threadInfoList.Add(new ThreadInfo()
{
_processId = pid,
_threadId = (ulong)tid,
_basePriority = pi.BasePriority,
_currentPriority = (int)stat.nice,
_startAddress = IntPtr.Zero,
_threadState = ProcFsStateToThreadState(stat.state),
_threadWaitReason = ThreadWaitReason.Unknown
});
}
}
}
}
catch (IOException)
{
// Between the time that we get an ID and the time that we try to read the associated
// directories and files in procfs, the process could be gone.
}
// Finally return what we've built up
return(pi);
}
static ProcessInfo[] GetProcessInfos(PerformanceCounterLib library, int processIndex, int threadIndex, byte[] data)
{
#if FEATURE_TRACESWITCH
Debug.WriteLineIf(Process._processTracing.TraceVerbose, "GetProcessInfos()");
#endif
Dictionary <int, ProcessInfo> processInfos = new Dictionary <int, ProcessInfo>();
List <ThreadInfo> threadInfos = new List <ThreadInfo>();
GCHandle dataHandle = new GCHandle();
try
{
dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
IntPtr dataBlockPtr = dataHandle.AddrOfPinnedObject();
Interop.Advapi32.PERF_DATA_BLOCK dataBlock = new Interop.Advapi32.PERF_DATA_BLOCK();
Marshal.PtrToStructure(dataBlockPtr, dataBlock);
IntPtr typePtr = (IntPtr)((long)dataBlockPtr + dataBlock.HeaderLength);
Interop.Advapi32.PERF_INSTANCE_DEFINITION instance = new Interop.Advapi32.PERF_INSTANCE_DEFINITION();
Interop.Advapi32.PERF_COUNTER_BLOCK counterBlock = new Interop.Advapi32.PERF_COUNTER_BLOCK();
for (int i = 0; i < dataBlock.NumObjectTypes; i++)
{
Interop.Advapi32.PERF_OBJECT_TYPE type = new Interop.Advapi32.PERF_OBJECT_TYPE();
Marshal.PtrToStructure(typePtr, type);
IntPtr instancePtr = (IntPtr)((long)typePtr + type.DefinitionLength);
IntPtr counterPtr = (IntPtr)((long)typePtr + type.HeaderLength);
List <Interop.Advapi32.PERF_COUNTER_DEFINITION> counterList = new List <Interop.Advapi32.PERF_COUNTER_DEFINITION>();
for (int j = 0; j < type.NumCounters; j++)
{
Interop.Advapi32.PERF_COUNTER_DEFINITION counter = new Interop.Advapi32.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);
}
Interop.Advapi32.PERF_COUNTER_DEFINITION[] counters = counterList.ToArray();
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.
#if FEATURE_TRACESWITCH
Debug.WriteLineIf(Process._processTracing.TraceVerbose, "GetProcessInfos() - found a non-idle process with id 0; ignoring.");
#endif
}
else
{
if (processInfos.ContainsKey(processInfo.ProcessId))
{
// 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
// helpful to the user? Should we just ignore?
#if FEATURE_TRACESWITCH
Debug.WriteLineIf(Process._processTracing.TraceVerbose, "GetProcessInfos() - found a duplicate process id");
#endif
}
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;
if (processInfos.TryGetValue(threadInfo._processId, out processInfo))
{
processInfo._threadInfoList.Add(threadInfo);
}
}
ProcessInfo[] temp = new ProcessInfo[processInfos.Values.Count];
processInfos.Values.CopyTo(temp, 0);
return(temp);
}
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;
}
private static ProcessInfo[] GetProcessInfos(IntPtr dataPtr)
{
IntPtr ptr;
Hashtable hashtable = new Hashtable(60);
long num = 0L;
Label_000B:
ptr = (IntPtr)(((long)dataPtr) + num);
SystemProcessInformation structure = new SystemProcessInformation();
Marshal.PtrToStructure(ptr, structure);
ProcessInfo info = new ProcessInfo {
processId = structure.UniqueProcessId.ToInt32(),
handleCount = (int)structure.HandleCount,
sessionId = (int)structure.SessionId,
poolPagedBytes = (long)((ulong)structure.QuotaPagedPoolUsage),
poolNonpagedBytes = (long)((ulong)structure.QuotaNonPagedPoolUsage),
virtualBytes = (long)((ulong)structure.VirtualSize),
virtualBytesPeak = (long)((ulong)structure.PeakVirtualSize),
workingSetPeak = (long)((ulong)structure.PeakWorkingSetSize),
workingSet = (long)((ulong)structure.WorkingSetSize),
pageFileBytesPeak = (long)((ulong)structure.PeakPagefileUsage),
pageFileBytes = (long)((ulong)structure.PagefileUsage),
privateBytes = (long)((ulong)structure.PrivatePageCount),
basePriority = structure.BasePriority
};
if (structure.NamePtr == IntPtr.Zero)
{
if (info.processId == NtProcessManager.SystemProcessID)
{
info.processName = "System";
}
else if (info.processId == 0)
{
info.processName = "Idle";
}
else
{
info.processName = info.processId.ToString(CultureInfo.InvariantCulture);
}
}
else
{
string processShortName = GetProcessShortName(Marshal.PtrToStringUni(structure.NamePtr, structure.NameLength / 2));
if (ProcessManager.IsOSOlderThanXP && (processShortName.Length == 15))
{
if (processShortName.EndsWith(".", StringComparison.OrdinalIgnoreCase))
{
processShortName = processShortName.Substring(0, 14);
}
else if (processShortName.EndsWith(".e", StringComparison.OrdinalIgnoreCase))
{
processShortName = processShortName.Substring(0, 13);
}
else if (processShortName.EndsWith(".ex", StringComparison.OrdinalIgnoreCase))
{
processShortName = processShortName.Substring(0, 12);
}
}
info.processName = processShortName;
}
hashtable[info.processId] = info;
ptr = (IntPtr)(((long)ptr) + Marshal.SizeOf(structure));
for (int i = 0; i < structure.NumberOfThreads; i++)
{
SystemThreadInformation information2 = new SystemThreadInformation();
Marshal.PtrToStructure(ptr, information2);
ThreadInfo info2 = new ThreadInfo {
processId = (int)information2.UniqueProcess,
threadId = (int)information2.UniqueThread,
basePriority = information2.BasePriority,
currentPriority = information2.Priority,
startAddress = information2.StartAddress,
threadState = (ThreadState)information2.ThreadState,
threadWaitReason = NtProcessManager.GetThreadWaitReason((int)information2.WaitReason)
};
info.threadInfoList.Add(info2);
ptr = (IntPtr)(((long)ptr) + Marshal.SizeOf(information2));
}
if (structure.NextEntryOffset != 0)
{
num += structure.NextEntryOffset;
goto Label_000B;
}
ProcessInfo[] array = new ProcessInfo[hashtable.Values.Count];
hashtable.Values.CopyTo(array, 0);
return(array);
}
static ProcessInfo GetProcessInfo(NativeMethods.PERF_OBJECT_TYPE type, IntPtr instancePtr, NativeMethods.PERF_COUNTER_DEFINITION[] counters) {
ProcessInfo processInfo = new ProcessInfo();
for (int i = 0; i < counters.Length; i++) {
NativeMethods.PERF_COUNTER_DEFINITION counter = counters[i];
long value = ReadCounterValue(counter.CounterType, (IntPtr)((long)instancePtr + counter.CounterOffset));
switch ((ValueId)counter.CounterNameTitlePtr) {
case ValueId.ProcessId:
processInfo.processId = (int)value;
break;
case ValueId.HandleCount:
processInfo.handleCount = (int)value;
break;
case ValueId.PoolPagedBytes:
processInfo.poolPagedBytes = value;
break;
case ValueId.PoolNonpagedBytes:
processInfo.poolNonpagedBytes = value;
break;
case ValueId.VirtualBytes:
processInfo.virtualBytes = value;
break;
case ValueId.VirtualBytesPeak:
processInfo.virtualBytesPeak = value;
break;
case ValueId.WorkingSetPeak:
processInfo.workingSetPeak = value;
break;
case ValueId.WorkingSet:
processInfo.workingSet = value;
break;
case ValueId.PageFileBytesPeak:
processInfo.pageFileBytesPeak = value;
break;
case ValueId.PageFileBytes:
processInfo.pageFileBytes = value;
break;
case ValueId.PrivateBytes:
processInfo.privateBytes = value;
break;
case ValueId.BasePriority:
processInfo.basePriority = (int)value;
break;
}
}
return processInfo;
}
static ProcessInfo[] GetProcessInfos(IntPtr dataPtr)
{
// 60 is a reasonable number for processes on a normal machine.
Dictionary<int, ProcessInfo> processInfos = new Dictionary<int, ProcessInfo>(60);
long totalOffset = 0;
while (true)
{
IntPtr currentPtr = (IntPtr)((long)dataPtr + totalOffset);
SystemProcessInformation pi = new SystemProcessInformation();
Marshal.PtrToStructure(currentPtr, pi);
// get information for a process
ProcessInfo processInfo = new ProcessInfo();
// Process ID shouldn't overflow. OS API GetCurrentProcessID returns DWORD.
processInfo.ProcessId = pi.UniqueProcessId.ToInt32();
processInfo.SessionId = (int)pi.SessionId;
processInfo.PoolPagedBytes = (long)pi.QuotaPagedPoolUsage; ;
processInfo.PoolNonPagedBytes = (long)pi.QuotaNonPagedPoolUsage;
processInfo.VirtualBytes = (long)pi.VirtualSize;
processInfo.VirtualBytesPeak = (long)pi.PeakVirtualSize;
processInfo.WorkingSetPeak = (long)pi.PeakWorkingSetSize;
processInfo.WorkingSet = (long)pi.WorkingSetSize;
processInfo.PageFileBytesPeak = (long)pi.PeakPagefileUsage;
processInfo.PageFileBytes = (long)pi.PagefileUsage;
processInfo.PrivateBytes = (long)pi.PrivatePageCount;
processInfo.BasePriority = pi.BasePriority;
if (pi.NamePtr == IntPtr.Zero)
{
if (processInfo.ProcessId == NtProcessManager.SystemProcessID)
{
processInfo.ProcessName = "System";
}
else if (processInfo.ProcessId == NtProcessManager.IdleProcessID)
{
processInfo.ProcessName = "Idle";
}
else
{
// for normal process without name, using the process ID.
processInfo.ProcessName = processInfo.ProcessId.ToString(CultureInfo.InvariantCulture);
}
}
else
{
string processName = GetProcessShortName(Marshal.PtrToStringUni(pi.NamePtr, pi.NameLength / sizeof(char)));
processInfo.ProcessName = processName;
}
// get the threads for current process
processInfos[processInfo.ProcessId] = processInfo;
currentPtr = (IntPtr)((long)currentPtr + Marshal.SizeOf(pi));
int i = 0;
while (i < pi.NumberOfThreads)
{
SystemThreadInformation ti = new SystemThreadInformation();
Marshal.PtrToStructure(currentPtr, ti);
ThreadInfo threadInfo = new ThreadInfo();
threadInfo._processId = (int)ti.UniqueProcess;
threadInfo._threadId = (ulong)ti.UniqueThread;
threadInfo._basePriority = ti.BasePriority;
threadInfo._currentPriority = ti.Priority;
threadInfo._startAddress = ti.StartAddress;
threadInfo._threadState = (ThreadState)ti.ThreadState;
threadInfo._threadWaitReason = NtProcessManager.GetThreadWaitReason((int)ti.WaitReason);
processInfo._threadInfoList.Add(threadInfo);
currentPtr = (IntPtr)((long)currentPtr + Marshal.SizeOf(ti));
i++;
}
if (pi.NextEntryOffset == 0)
{
break;
}
totalOffset += pi.NextEntryOffset;
}
ProcessInfo[] temp = new ProcessInfo[processInfos.Values.Count];
processInfos.Values.CopyTo(temp, 0);
return temp;
}
private static ProcessInfo CreateProcessInfo(int pid)
{
// Read /proc/pid/stat to get information about the process, and churn that into a ProcessInfo
ProcessInfo pi;
try
{
Interop.procfs.ParsedStat procFsStat = Interop.procfs.ReadStatFile(pid);
pi = new ProcessInfo
{
_processId = pid,
_processName = procFsStat.comm,
_basePriority = (int)procFsStat.nice,
_virtualBytes = (long)procFsStat.vsize,
_workingSet = procFsStat.rss,
_sessionId = procFsStat.session,
_handleCount = 0, // not a Unix concept
// We don't currently fill in the following values.
// A few of these could probably be filled in from getrusage,
// but only for the current process or its children, not for
// arbitrary other processes.
_poolPagedBytes = 0,
_poolNonpagedBytes = 0,
_virtualBytesPeak = 0,
_workingSetPeak = 0,
_pageFileBytes = 0,
_pageFileBytesPeak = 0,
_privateBytes = 0,
};
}
catch (FileNotFoundException)
{
// Between the time that we get an ID and the time that we try to read the associated stat
// file(s), the process could be gone.
return(null);
}
// Then read through /proc/pid/task/ to find each thread in the process...
try
{
string tasksDir = Interop.procfs.GetTaskDirectoryPathForProcess(pid);
foreach (string taskDir in Directory.EnumerateDirectories(tasksDir))
{
string dirName = Path.GetFileName(taskDir);
int tid;
if (int.TryParse(dirName, NumberStyles.Integer, CultureInfo.InvariantCulture, out tid))
{
// ...and read its associated /proc/pid/task/tid/stat file to create a ThreadInfo
Interop.procfs.ParsedStat stat = Interop.procfs.ReadStatFile(pid, tid);
pi._threadInfoList.Add(new ThreadInfo
{
_processId = pid,
_threadId = tid,
_basePriority = pi._basePriority,
_currentPriority = (int)stat.nice,
_startAddress = (IntPtr)stat.startstack,
_threadState = ProcFsStateToThreadState(stat.state),
_threadWaitReason = ThreadWaitReason.Unknown
});
}
}
}
catch (FileNotFoundException) { } // process and/or threads may go away by the time we try to read from them
catch (DirectoryNotFoundException) { }
// Finally return what we've built up
return(pi);
}
private void RefreshByModule()
{
Dictionary<string, ProcessInfo> dict = new Dictionary<string, ProcessInfo>(StringComparer.CurrentCultureIgnoreCase);
foreach(Process p in Process.GetProcesses())
{
string procname = GetSafeProcessName(p);
ProcessModuleCollection pmc = null;
try
{
pmc = p.Modules;
}
catch
{
continue;
}
if (pmc != null)
{
string FormattedProcessName = string.Format("{0} [{1}]", procname, p.Id);
foreach (ProcessModule m in pmc)
{
string key = GetSafeModuleName(m);
ProcessInfo pi = null;
try
{
if (dict.ContainsKey(key))
{
pi = dict[key];
}
}
catch
{
}
if (pi == null)
{
pi = new ProcessInfo(key, CurrentDisplayMode);
dict[key] = pi;
}
pi.Dependencies.Add(FormattedProcessName);
}
}
}
Items.Clear();
foreach (ProcessInfo pi in dict.Values)
Items.Add(pi);
}
/// <summary>
/// Creates a ProcessInfo from the data parsed from a /proc/pid/stat file and the associated tasks directory.
/// </summary>
internal static ProcessInfo CreateProcessInfo(Interop.procfs.ParsedStat procFsStat, ReusableTextReader reusableReader)
{
int pid = procFsStat.pid;
var pi = new ProcessInfo()
{
ProcessId = pid,
ProcessName = procFsStat.comm,
BasePriority = (int)procFsStat.nice,
VirtualBytes = (long)procFsStat.vsize,
WorkingSet = procFsStat.rss,
SessionId = procFsStat.session,
// We don't currently fill in the other values.
// A few of these could probably be filled in from getrusage,
// but only for the current process or its children, not for
// arbitrary other processes.
};
// Then read through /proc/pid/task/ to find each thread in the process...
string tasksDir = Interop.procfs.GetTaskDirectoryPathForProcess(pid);
foreach (string taskDir in Directory.EnumerateDirectories(tasksDir))
{
// ...and read its associated /proc/pid/task/tid/stat file to create a ThreadInfo
string dirName = Path.GetFileName(taskDir);
int tid;
Interop.procfs.ParsedStat stat;
if (int.TryParse(dirName, NumberStyles.Integer, CultureInfo.InvariantCulture, out tid) &&
Interop.procfs.TryReadStatFile(pid, tid, out stat, reusableReader))
{
pi._threadInfoList.Add(new ThreadInfo()
{
_processId = pid,
_threadId = (ulong)tid,
_basePriority = pi.BasePriority,
_currentPriority = (int)stat.nice,
_startAddress = (IntPtr)stat.startstack,
_threadState = ProcFsStateToThreadState(stat.state),
_threadWaitReason = ThreadWaitReason.Unknown
});
}
}
// Finally return what we've built up
return pi;
}
private void RefreshByProcess()
{
Items.Clear();
foreach(Process p in Process.GetProcesses())
{
ProcessInfo pi = new ProcessInfo(GetSafeProcessName(p), p.Id, CurrentDisplayMode);
Items.Add(pi);
ProcessModuleCollection pmc = null;
try
{
pmc = p.Modules;
}
catch
{
continue;
}
foreach (ProcessModule m in pmc)
{
pi.Dependencies.Add(GetSafeModuleName(m));
}
}
}
public double[] GetCpuUsage(string processName, bool monitor = false)
{
ArrayList cpuUsage = new ArrayList();
ArrayList threadPool = new ArrayList();
try
{
processName = GetProcessName(processName);
common.LogMessage(processName);
Process[] processes = Process.GetProcessesByName(processName);
foreach (Process p in processes)
{
try
{
// Need to call this once, before calling GetCurrentCpuUsage
ProcessPerformanceCounter perf = new ProcessPerformanceCounter(
common, processName, p.Id);
if (perf != null)
perf = null;
ProcessInfo processInfo = new ProcessInfo();
processInfo.process = p;
processInfo.monitor = monitor;
processInfo.cpuUsage = cpuUsage;
if (processes.Length > 1)
{
// Increased the performance of output
// else for running 10+ instance of an app
// takes lot of time
Thread thread = new Thread(new ParameterizedThreadStart(
GetCurrentCpuUsage));
thread.Start(processInfo);
threadPool.Add(thread);
}
else
GetCurrentCpuUsage(processInfo);
}
catch (Exception ex)
{
common.LogMessage(ex);
}
}
foreach (Thread thread in threadPool)
{
// Wait for each thread to complete its job
thread.Join();
}
if (common.Debug)
{
foreach (double value in cpuUsage)
common.LogMessage(value);
}
return cpuUsage.ToArray(typeof(double)) as double[];
}
catch (Exception ex)
{
common.LogMessage(ex);
return cpuUsage.ToArray(typeof(double)) as double[];
}
finally
{
cpuUsage = null;
threadPool = null;
}
}
private static unsafe ProcessInfo[] GetProcessInfos(IntPtr dataPtr, Predicate <int> processIdFilter)
{
// Use a dictionary to avoid duplicate entries if any
// 60 is a reasonable number for processes on a normal machine.
Dictionary <int, ProcessInfo> processInfos = new Dictionary <int, ProcessInfo>(60);
long totalOffset = 0;
while (true)
{
IntPtr currentPtr = (IntPtr)((long)dataPtr + totalOffset);
ref SystemProcessInformation pi = ref *(SystemProcessInformation *)(currentPtr);
// Process ID shouldn't overflow. OS API GetCurrentProcessID returns DWORD.
var processInfoProcessId = pi.UniqueProcessId.ToInt32();
if (processIdFilter == null || processIdFilter(processInfoProcessId))
{
// get information for a process
ProcessInfo processInfo = new ProcessInfo();
processInfo.ProcessId = processInfoProcessId;
processInfo.SessionId = (int)pi.SessionId;
processInfo.PoolPagedBytes = (long)pi.QuotaPagedPoolUsage;
processInfo.PoolNonPagedBytes = (long)pi.QuotaNonPagedPoolUsage;
processInfo.VirtualBytes = (long)pi.VirtualSize;
processInfo.VirtualBytesPeak = (long)pi.PeakVirtualSize;
processInfo.WorkingSetPeak = (long)pi.PeakWorkingSetSize;
processInfo.WorkingSet = (long)pi.WorkingSetSize;
processInfo.PageFileBytesPeak = (long)pi.PeakPagefileUsage;
processInfo.PageFileBytes = (long)pi.PagefileUsage;
processInfo.PrivateBytes = (long)pi.PrivatePageCount;
processInfo.BasePriority = pi.BasePriority;
processInfo.HandleCount = (int)pi.HandleCount;
if (pi.ImageName.Buffer == IntPtr.Zero)
{
if (processInfo.ProcessId == NtProcessManager.SystemProcessID)
{
processInfo.ProcessName = "System";
}
else if (processInfo.ProcessId == NtProcessManager.IdleProcessID)
{
processInfo.ProcessName = "Idle";
}
else
{
// for normal process without name, using the process ID.
processInfo.ProcessName = processInfo.ProcessId.ToString(CultureInfo.InvariantCulture);
}
}
else
{
string processName = GetProcessShortName(Marshal.PtrToStringUni(pi.ImageName.Buffer, pi.ImageName.Length / sizeof(char)));
processInfo.ProcessName = processName;
}
// get the threads for current process
processInfos[processInfo.ProcessId] = processInfo;
currentPtr = (IntPtr)((long)currentPtr + Marshal.SizeOf(pi));
int i = 0;
while (i < pi.NumberOfThreads)
{
ref SystemThreadInformation ti = ref *(SystemThreadInformation *)(currentPtr);
ThreadInfo threadInfo = new ThreadInfo();
threadInfo._processId = (int)ti.ClientId.UniqueProcess;
threadInfo._threadId = (ulong)ti.ClientId.UniqueThread;
threadInfo._basePriority = ti.BasePriority;
threadInfo._currentPriority = ti.Priority;
threadInfo._startAddress = ti.StartAddress;
threadInfo._threadState = (ThreadState)ti.ThreadState;
threadInfo._threadWaitReason = NtProcessManager.GetThreadWaitReason((int)ti.WaitReason);
processInfo._threadInfoList.Add(threadInfo);
currentPtr = (IntPtr)((long)currentPtr + Marshal.SizeOf(ti));
i++;
}
}
