/*

* Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.

* Use of this source code is governed by a BSD-style license that can be

* found in the LICENSE file.

*

* Windows platform-specific module methods for _psutil_windows

*/

// Fixes clash between winsock2.h and windows.h

#define WIN32_LEAN_AND_MEAN

#include <Python.h>

#include <windows.h>

#include <Psapi.h>

#include <time.h>

#include <lm.h>

#include <WinIoCtl.h>

#include <tchar.h>

#include <tlhelp32.h>

#include <winsock2.h>

#if (_WIN32_WINNT >= 0x0600) // Windows Vista and above

#include <ws2tcpip.h>

#endif

#include <iphlpapi.h>

#include <wtsapi32.h>

#include <Winsvc.h>

// Link with Iphlpapi.lib

#pragma comment(lib, "IPHLPAPI.lib")

#include "_psutil_common.h"

#include "arch/windows/security.h"

#include "arch/windows/process_info.h"

#include "arch/windows/process_handles.h"

#include "arch/windows/ntextapi.h"

#include "arch/windows/inet_ntop.h"

#include "arch/windows/services.h"

#ifdef __MINGW32__

#include "arch/windows/glpi.h"

#endif

/*

* ============================================================================

* Utilities

* ============================================================================

*/

// a flag for connections without an actual status

static int PSUTIL_CONN_NONE = 128;

#define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x))

#define FREE(x) HeapFree(GetProcessHeap(), 0, (x))

#define LO_T ((float)1e-7)

#define HI_T (LO_T*4294967296.0)

#define BYTESWAP_USHORT(x) ((((USHORT)(x) << 8) | ((USHORT)(x) >> 8)) & 0xffff)

#ifndef AF_INET6

#define AF_INET6 23

#endif

#define _psutil_conn_decref_objs() \

Py_DECREF(_AF_INET); \

Py_DECREF(_AF_INET6);\

Py_DECREF(_SOCK_STREAM);\

Py_DECREF(_SOCK_DGRAM);

typedef BOOL (WINAPI *LPFN_GLPI)

(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, PDWORD);

// fix for mingw32, see

// https://github.com/giampaolo/psutil/issues/351#c2

typedef struct _DISK_PERFORMANCE_WIN_2008 {

LARGE_INTEGER BytesRead;

LARGE_INTEGER BytesWritten;

LARGE_INTEGER ReadTime;

LARGE_INTEGER WriteTime;

LARGE_INTEGER IdleTime;

DWORD ReadCount;

DWORD WriteCount;

DWORD QueueDepth;

DWORD SplitCount;

LARGE_INTEGER QueryTime;

DWORD StorageDeviceNumber;

WCHAR StorageManagerName[8];

} DISK_PERFORMANCE_WIN_2008;

// --- network connections mingw32 support

#ifndef _IPRTRMIB_H

#if (_WIN32_WINNT < 0x0600) // Windows XP

typedef struct _MIB_TCP6ROW_OWNER_PID {

UCHAR ucLocalAddr[16];

DWORD dwLocalScopeId;

DWORD dwLocalPort;

UCHAR ucRemoteAddr[16];

DWORD dwRemoteScopeId;

DWORD dwRemotePort;

DWORD dwState;

DWORD dwOwningPid;

} MIB_TCP6ROW_OWNER_PID, *PMIB_TCP6ROW_OWNER_PID;

typedef struct _MIB_TCP6TABLE_OWNER_PID {

DWORD dwNumEntries;

MIB_TCP6ROW_OWNER_PID table[ANY_SIZE];

} MIB_TCP6TABLE_OWNER_PID, *PMIB_TCP6TABLE_OWNER_PID;

#endif

#endif

#ifndef __IPHLPAPI_H__

typedef struct in6_addr {

union {

UCHAR Byte[16];

USHORT Word[8];

} u;

} IN6_ADDR, *PIN6_ADDR, FAR *LPIN6_ADDR;

typedef enum _UDP_TABLE_CLASS {

UDP_TABLE_BASIC,

UDP_TABLE_OWNER_PID,

UDP_TABLE_OWNER_MODULE

} UDP_TABLE_CLASS, *PUDP_TABLE_CLASS;

typedef struct _MIB_UDPROW_OWNER_PID {

DWORD dwLocalAddr;

DWORD dwLocalPort;

DWORD dwOwningPid;

} MIB_UDPROW_OWNER_PID, *PMIB_UDPROW_OWNER_PID;

typedef struct _MIB_UDPTABLE_OWNER_PID {

DWORD dwNumEntries;

MIB_UDPROW_OWNER_PID table[ANY_SIZE];

} MIB_UDPTABLE_OWNER_PID, *PMIB_UDPTABLE_OWNER_PID;

#endif

#if (_WIN32_WINNT < 0x0600) // Windows XP

typedef struct _MIB_UDP6ROW_OWNER_PID {

UCHAR ucLocalAddr[16];

DWORD dwLocalScopeId;

DWORD dwLocalPort;

DWORD dwOwningPid;

} MIB_UDP6ROW_OWNER_PID, *PMIB_UDP6ROW_OWNER_PID;

typedef struct _MIB_UDP6TABLE_OWNER_PID {

DWORD dwNumEntries;

MIB_UDP6ROW_OWNER_PID table[ANY_SIZE];

} MIB_UDP6TABLE_OWNER_PID, *PMIB_UDP6TABLE_OWNER_PID;

#endif

PIP_ADAPTER_ADDRESSES

psutil_get_nic_addresses() {

// allocate a 15 KB buffer to start with

int outBufLen = 15000;

DWORD dwRetVal = 0;

ULONG attempts = 0;

PIP_ADAPTER_ADDRESSES pAddresses = NULL;

do {

pAddresses = (IP_ADAPTER_ADDRESSES *) malloc(outBufLen);

if (pAddresses == NULL) {

PyErr_NoMemory();

return NULL;

}

dwRetVal = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, pAddresses,

&outBufLen);

if (dwRetVal == ERROR_BUFFER_OVERFLOW) {

free(pAddresses);

pAddresses = NULL;

}

else {

break;

}

attempts++;

} while ((dwRetVal == ERROR_BUFFER_OVERFLOW) && (attempts < 3));

if (dwRetVal != NO_ERROR) {

PyErr_SetString(PyExc_RuntimeError, "GetAdaptersAddresses() failed.");

return NULL;

}

return pAddresses;

}

/*

* ============================================================================

* Public Python API

* ============================================================================

*/

static ULONGLONG (*psutil_GetTickCount64)(void) = NULL;

/*

* Return a Python float representing the system uptime expressed in seconds

* since the epoch.

*/

static PyObject *

psutil_boot_time(PyObject *self, PyObject *args) {

#if (_WIN32_WINNT >= 0x0600) // Windows Vista

ULONGLONG uptime;

#else

double uptime;

#endif

time_t pt;

FILETIME fileTime;

long long ll;

HINSTANCE hKernel32;

psutil_GetTickCount64 = NULL;

GetSystemTimeAsFileTime(&fileTime);

/*

HUGE thanks to:

http://johnstewien.spaces.live.com/blog/cns!E6885DB5CEBABBC8!831.entry

This function converts the FILETIME structure to the 32 bit

Unix time structure.

The time_t is a 32-bit value for the number of seconds since

January 1, 1970. A FILETIME is a 64-bit for the number of

100-nanosecond periods since January 1, 1601. Convert by

subtracting the number of 100-nanosecond period betwee 01-01-1970

and 01-01-1601, from time_t the divide by 1e+7 to get to the same

base granularity.

*/

ll = (((LONGLONG)(fileTime.dwHighDateTime)) << 32) \

+ fileTime.dwLowDateTime;

pt = (time_t)((ll - 116444736000000000ull) / 10000000ull);

// GetTickCount64() is Windows Vista+ only. Dinamically load

// GetTickCount64() at runtime. We may have used

// "#if (_WIN32_WINNT >= 0x0600)" pre-processor but that way

// the produced exe/wheels cannot be used on Windows XP, see:

// https://github.com/giampaolo/psutil/issues/811#issuecomment-230639178

hKernel32 = GetModuleHandleW(L"KERNEL32");

psutil_GetTickCount64 = (void*)GetProcAddress(hKernel32, "GetTickCount64");

if (psutil_GetTickCount64 != NULL) {

// Windows >= Vista

uptime = psutil_GetTickCount64() / (ULONGLONG)1000.00f;

}

else {

// Windows XP.

// GetTickCount() time will wrap around to zero if the

// system is run continuously for 49.7 days.

uptime = GetTickCount() / 1000.00f;

}

return Py_BuildValue("d", (double)pt - (double)uptime);

}

/*

* Return 1 if PID exists in the current process list, else 0.

*/

static PyObject *

psutil_pid_exists(PyObject *self, PyObject *args) {

long pid;

int status;

if (! PyArg_ParseTuple(args, "l", &pid))

return NULL;

status = psutil_pid_is_running(pid);

if (-1 == status)

return NULL; // exception raised in psutil_pid_is_running()

return PyBool_FromLong(status);

}

/*

* Return a Python list of all the PIDs running on the system.

*/

static PyObject *

psutil_pids(PyObject *self, PyObject *args) {

DWORD *proclist = NULL;

DWORD numberOfReturnedPIDs;

DWORD i;

PyObject *py_pid = NULL;

PyObject *py_retlist = PyList_New(0);

if (py_retlist == NULL)

return NULL;

proclist = psutil_get_pids(&numberOfReturnedPIDs);

if (proclist == NULL)

goto error;

for (i = 0; i < numberOfReturnedPIDs; i++) {

py_pid = Py_BuildValue("I", proclist[i]);

if (!py_pid)

goto error;

if (PyList_Append(py_retlist, py_pid))

goto error;

Py_DECREF(py_pid);

}

// free C array allocated for PIDs

free(proclist);

return py_retlist;

error:

Py_XDECREF(py_pid);

Py_DECREF(py_retlist);

if (proclist != NULL)

free(proclist);

return NULL;

}

/*

* Kill a process given its PID.

*/

static PyObject *

psutil_proc_kill(PyObject *self, PyObject *args) {

HANDLE hProcess;

long pid;

if (! PyArg_ParseTuple(args, "l", &pid))

return NULL;

if (pid == 0)

return AccessDenied();

hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pid);

if (hProcess == NULL) {

if (GetLastError() == ERROR_INVALID_PARAMETER) {

// see https://github.com/giampaolo/psutil/issues/24

NoSuchProcess();

}

else {

PyErr_SetFromWindowsErr(0);

}

return NULL;

}

// kill the process

if (! TerminateProcess(hProcess, 0)) {

PyErr_SetFromWindowsErr(0);

CloseHandle(hProcess);

return NULL;

}

CloseHandle(hProcess);

Py_RETURN_NONE;

}

/*

* Wait for process to terminate and return its exit code.

*/

static PyObject *

psutil_proc_wait(PyObject *self, PyObject *args) {

HANDLE hProcess;

DWORD ExitCode;

DWORD retVal;

long pid;

long timeout;

if (! PyArg_ParseTuple(args, "ll", &pid, &timeout))

return NULL;

if (pid == 0)

return AccessDenied();

hProcess = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION,

FALSE, pid);

if (hProcess == NULL) {

if (GetLastError() == ERROR_INVALID_PARAMETER) {

// no such process; we do not want to raise NSP but

// return None instead.

Py_RETURN_NONE;

}

else {

PyErr_SetFromWindowsErr(0);

return NULL;

}

}

// wait until the process has terminated

Py_BEGIN_ALLOW_THREADS

retVal = WaitForSingleObject(hProcess, timeout);

Py_END_ALLOW_THREADS

if (retVal == WAIT_FAILED) {

CloseHandle(hProcess);

return PyErr_SetFromWindowsErr(GetLastError());

}

if (retVal == WAIT_TIMEOUT) {

CloseHandle(hProcess);

return Py_BuildValue("l", WAIT_TIMEOUT);

}

// get the exit code; note: subprocess module (erroneously?) uses

// what returned by WaitForSingleObject

if (GetExitCodeProcess(hProcess, &ExitCode) == 0) {

CloseHandle(hProcess);

return PyErr_SetFromWindowsErr(GetLastError());

}

CloseHandle(hProcess);

#if PY_MAJOR_VERSION >= 3

return PyLong_FromLong((long) ExitCode);

#else

return PyInt_FromLong((long) ExitCode);

#endif

}

/*

* Return a Python tuple (user_time, kernel_time)

*/

static PyObject *

psutil_proc_cpu_times(PyObject *self, PyObject *args) {

long pid;

HANDLE hProcess;

FILETIME ftCreate, ftExit, ftKernel, ftUser;

if (! PyArg_ParseTuple(args, "l", &pid))

return NULL;

hProcess = psutil_handle_from_pid(pid);

if (hProcess == NULL)

return NULL;

if (! GetProcessTimes(hProcess, &ftCreate, &ftExit, &ftKernel, &ftUser)) {

CloseHandle(hProcess);

if (GetLastError() == ERROR_ACCESS_DENIED) {

// usually means the process has died so we throw a NoSuchProcess

// here

return NoSuchProcess();

}

else {

PyErr_SetFromWindowsErr(0);

return NULL;

}

}

CloseHandle(hProcess);

/*

* User and kernel times are represented as a FILETIME structure

* wich contains a 64-bit value representing the number of

* 100-nanosecond intervals since January 1, 1601 (UTC):

* http://msdn.microsoft.com/en-us/library/ms724284(VS.85).aspx

* To convert it into a float representing the seconds that the

* process has executed in user/kernel mode I borrowed the code

* below from Python's Modules/posixmodule.c

*/

return Py_BuildValue(

"(dd)",

(double)(ftUser.dwHighDateTime * 429.4967296 + \

ftUser.dwLowDateTime * 1e-7),

(double)(ftKernel.dwHighDateTime * 429.4967296 + \

ftKernel.dwLowDateTime * 1e-7)

);

}

/*

* Return a Python float indicating the process create time expressed in

* seconds since the epoch.

*/

static PyObject *

psutil_proc_create_time(PyObject *self, PyObject *args) {

long pid;

long long unix_time;

DWORD exitCode;

HANDLE hProcess;

BOOL ret;

FILETIME ftCreate, ftExit, ftKernel, ftUser;

if (! PyArg_ParseTuple(args, "l", &pid))

return NULL;

// special case for PIDs 0 and 4, return system boot time

if (0 == pid || 4 == pid)

return psutil_boot_time(NULL, NULL);

hProcess = psutil_handle_from_pid(pid);

if (hProcess == NULL)

return NULL;

if (! GetProcessTimes(hProcess, &ftCreate, &ftExit, &ftKernel, &ftUser)) {

CloseHandle(hProcess);

if (GetLastError() == ERROR_ACCESS_DENIED) {

// usually means the process has died so we throw a

// NoSuchProcess here

return NoSuchProcess();

}

else {

PyErr_SetFromWindowsErr(0);

return NULL;

}

}

// Make sure the process is not gone as OpenProcess alone seems to be

// unreliable in doing so (it seems a previous call to p.wait() makes

// it unreliable).

// This check is important as creation time is used to make sure the

// process is still running.

ret = GetExitCodeProcess(hProcess, &exitCode);

CloseHandle(hProcess);

if (ret != 0) {

if (exitCode != STILL_ACTIVE)

return NoSuchProcess();

}

else {

// Ignore access denied as it means the process is still alive.

// For all other errors, we want an exception.

if (GetLastError() != ERROR_ACCESS_DENIED) {

PyErr_SetFromWindowsErr(0);

return NULL;

}

}

/*

Convert the FILETIME structure to a Unix time.

It's the best I could find by googling and borrowing code here and there.

The time returned has a precision of 1 second.

*/

unix_time = ((LONGLONG)ftCreate.dwHighDateTime) << 32;

unix_time += ftCreate.dwLowDateTime - 116444736000000000LL;

unix_time /= 10000000;

return Py_BuildValue("d", (double)unix_time);

}

/*

* Return the number of logical CPUs.

*/

static PyObject *

psutil_cpu_count_logical(PyObject *self, PyObject *args) {

SYSTEM_INFO system_info;

system_info.dwNumberOfProcessors = 0;

GetSystemInfo(&system_info);

if (system_info.dwNumberOfProcessors == 0)

Py_RETURN_NONE; // mimic os.cpu_count()

else

return Py_BuildValue("I", system_info.dwNumberOfProcessors);

}

/*

* Return the number of physical CPU cores.

*/

static PyObject *

psutil_cpu_count_phys(PyObject *self, PyObject *args) {

LPFN_GLPI glpi;

DWORD rc;

PSYSTEM_LOGICAL_PROCESSOR_INFORMATION buffer = NULL;

PSYSTEM_LOGICAL_PROCESSOR_INFORMATION ptr = NULL;

DWORD length = 0;

DWORD offset = 0;

int ncpus = 0;

glpi = (LPFN_GLPI)GetProcAddress(GetModuleHandle(TEXT("kernel32")),

"GetLogicalProcessorInformation");

if (glpi == NULL)

goto return_none;

while (1) {

rc = glpi(buffer, &length);

if (rc == FALSE) {

if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {

if (buffer)

free(buffer);

buffer = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)malloc(

length);

if (NULL == buffer) {

PyErr_NoMemory();

return NULL;

}

}

else {

goto return_none;

}

}

else {

break;

}

}

ptr = buffer;

while (offset + sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION) <= length) {

if (ptr->Relationship == RelationProcessorCore)

ncpus += 1;

offset += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);

ptr++;

}

free(buffer);

if (ncpus == 0)

goto return_none;

else

return Py_BuildValue("i", ncpus);

return_none:

// mimic os.cpu_count()

if (buffer != NULL)

free(buffer);

Py_RETURN_NONE;

}

/*

* Return process cmdline as a Python list of cmdline arguments.

*/

static PyObject *

psutil_proc_cmdline(PyObject *self, PyObject *args) {

long pid;

int pid_return;

if (! PyArg_ParseTuple(args, "l", &pid))

return NULL;

if ((pid == 0) || (pid == 4))

return Py_BuildValue("[]");

pid_return = psutil_pid_is_running(pid);

if (pid_return == 0)

return NoSuchProcess();

if (pid_return == -1)

return NULL;

return psutil_get_cmdline(pid);

}

/*

* Return process cmdline as a Python list of cmdline arguments.

*/

static PyObject *

psutil_proc_environ(PyObject *self, PyObject *args) {

long pid;

int pid_return;

if (! PyArg_ParseTuple(args, "l", &pid))

return NULL;

if ((pid == 0) || (pid == 4))

return Py_BuildValue("s", "");

pid_return = psutil_pid_is_running(pid);

if (pid_return == 0)

return NoSuchProcess();

if (pid_return == -1)

return NULL;

return psutil_get_environ(pid);

}

/*

* Return process executable path.

*/

static PyObject *

psutil_proc_exe(PyObject *self, PyObject *args) {

long pid;

HANDLE hProcess;

wchar_t exe[MAX_PATH];

if (! PyArg_ParseTuple(args, "l", &pid))

return NULL;

hProcess = psutil_handle_from_pid_waccess(pid, PROCESS_QUERY_INFORMATION);

if (NULL == hProcess)

return NULL;

if (GetProcessImageFileNameW(hProcess, exe, MAX_PATH) == 0) {

CloseHandle(hProcess);

PyErr_SetFromWindowsErr(0);

return NULL;

}

CloseHandle(hProcess);

return Py_BuildValue("u", exe);

}

/*

* Return process base name.

* Note: psutil_proc_exe() is attempted first because it's faster

* but it raise AccessDenied for processes owned by other users

* in which case we fall back on using this.

*/

static PyObject *

psutil_proc_name(PyObject *self, PyObject *args) {

long pid;

int ok;

PROCESSENTRY32W pentry;

HANDLE hSnapShot;

if (! PyArg_ParseTuple(args, "l", &pid))

return NULL;

hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, pid);

if (hSnapShot == INVALID_HANDLE_VALUE) {

PyErr_SetFromWindowsErr(0);

return NULL;

}

pentry.dwSize = sizeof(PROCESSENTRY32W);

ok = Process32FirstW(hSnapShot, &pentry);

if (! ok) {

CloseHandle(hSnapShot);

PyErr_SetFromWindowsErr(0);

return NULL;

}

while (ok) {

if (pentry.th32ProcessID == pid) {

CloseHandle(hSnapShot);

return PyUnicode_FromWideChar(

pentry.szExeFile, wcslen(pentry.szExeFile));

}

ok = Process32NextW(hSnapShot, &pentry);

}

CloseHandle(hSnapShot);

NoSuchProcess();

return NULL;

}

/*

* Return process memory information as a Python tuple.

*/

static PyObject *

psutil_proc_memory_info(PyObject *self, PyObject *args) {

HANDLE hProcess;

DWORD pid;

#if (_WIN32_WINNT >= 0x0501) // Windows XP with SP2

PROCESS_MEMORY_COUNTERS_EX cnt;

#else

PROCESS_MEMORY_COUNTERS cnt;

#endif

SIZE_T private = 0;

if (! PyArg_ParseTuple(args, "l", &pid))

return NULL;

hProcess = psutil_handle_from_pid(pid);

if (NULL == hProcess)

return NULL;

if (! GetProcessMemoryInfo(hProcess, (PPROCESS_MEMORY_COUNTERS)&cnt,

sizeof(cnt))) {

CloseHandle(hProcess);

return PyErr_SetFromWindowsErr(0);

}

#if (_WIN32_WINNT >= 0x0501) // Windows XP with SP2

private = cnt.PrivateUsage;

#endif

CloseHandle(hProcess);

// PROCESS_MEMORY_COUNTERS values are defined as SIZE_T which on 64bits

// is an (unsigned long long) and on 32bits is an (unsigned int).

// "_WIN64" is defined if we're running a 64bit Python interpreter not

// exclusively if the *system* is 64bit.

#if defined(_WIN64)

return Py_BuildValue(

"(kKKKKKKKKK)",

cnt.PageFaultCount, // unsigned long

(unsigned long long)cnt.PeakWorkingSetSize,

(unsigned long long)cnt.WorkingSetSize,

(unsigned long long)cnt.QuotaPeakPagedPoolUsage,

(unsigned long long)cnt.QuotaPagedPoolUsage,

(unsigned long long)cnt.QuotaPeakNonPagedPoolUsage,

(unsigned long long)cnt.QuotaNonPagedPoolUsage,

(unsigned long long)cnt.PagefileUsage,

(unsigned long long)cnt.PeakPagefileUsage,

(unsigned long long)private);

#else

return Py_BuildValue(

"(kIIIIIIIII)",

cnt.PageFaultCount, // unsigned long

(unsigned int)cnt.PeakWorkingSetSize,

(unsigned int)cnt.WorkingSetSize,

(unsigned int)cnt.QuotaPeakPagedPoolUsage,

(unsigned int)cnt.QuotaPagedPoolUsage,

(unsigned int)cnt.QuotaPeakNonPagedPoolUsage,

(unsigned int)cnt.QuotaNonPagedPoolUsage,

(unsigned int)cnt.PagefileUsage,

(unsigned int)cnt.PeakPagefileUsage,

(unsigned int)private);

#endif

}

/*

* Alternative implementation of the one above but bypasses ACCESS DENIED.

*/

static PyObject *

psutil_proc_memory_info_2(PyObject *self, PyObject *args) {

DWORD pid;

PSYSTEM_PROCESS_INFORMATION process;

PVOID buffer;

SIZE_T private;

unsigned long pfault_count;

#if defined(_WIN64)

unsigned long long m1, m2, m3, m4, m5, m6, m7, m8;

#else

unsigned int m1, m2, m3, m4, m5, m6, m7, m8;

#endif

if (! PyArg_ParseTuple(args, "l", &pid))

return NULL;

if (! psutil_get_proc_info(pid, &process, &buffer))

return NULL;

#if (_WIN32_WINNT >= 0x0501) // Windows XP with SP2

private = process->PrivatePageCount;

#else

private = 0;

#endif

pfault_count = process->PageFaultCount;

m1 = process->PeakWorkingSetSize;

m2 = process->WorkingSetSize;

m3 = process->QuotaPeakPagedPoolUsage;

m4 = process->QuotaPagedPoolUsage;

m5 = process->QuotaPeakNonPagedPoolUsage;

m6 = process->QuotaNonPagedPoolUsage;

m7 = process->PagefileUsage;

m8 = process->PeakPagefileUsage;

free(buffer);

// SYSTEM_PROCESS_INFORMATION values are defined as SIZE_T which on 64

// bits is an (unsigned long long) and on 32bits is an (unsigned int).

// "_WIN64" is defined if we're running a 64bit Python interpreter not

// exclusively if the *system* is 64bit.

#if defined(_WIN64)

return Py_BuildValue("(kKKKKKKKKK)",

#else

return Py_BuildValue("(kIIIIIIIII)",

#endif

pfault_count, m1, m2, m3, m4, m5, m6, m7, m8, private);

}

/**

* Returns the USS of the process.

* Reference:

* https://dxr.mozilla.org/mozilla-central/source/xpcom/base/

* nsMemoryReporterManager.cpp

*/

static PyObject *

psutil_proc_memory_uss(PyObject *self, PyObject *args)

{

DWORD pid;

HANDLE proc;

PSAPI_WORKING_SET_INFORMATION tmp;

DWORD tmp_size = sizeof(tmp);

size_t entries;

size_t private_pages;

size_t i;

DWORD info_array_size;

PSAPI_WORKING_SET_INFORMATION* info_array;

SYSTEM_INFO system_info;

PyObject* py_result = NULL;

unsigned long long total = 0;

if (! PyArg_ParseTuple(args, "l", &pid))

return NULL;

proc = psutil_handle_from_pid(pid);

if (proc == NULL)

return NULL;

// Determine how many entries we need.

memset(&tmp, 0, tmp_size);

if (!QueryWorkingSet(proc, &tmp, tmp_size)) {

// NB: QueryWorkingSet is expected to fail here due to the

// buffer being too small.

if (tmp.NumberOfEntries == 0) {

PyErr_SetFromWindowsErr(0);

goto done;

}

}

// Fudge the size in case new entries are added between calls.

entries = tmp.NumberOfEntries * 2;

if (!entries) {

goto done;

}

info_array_size = tmp_size + (entries * sizeof(PSAPI_WORKING_SET_BLOCK));

info_array = (PSAPI_WORKING_SET_INFORMATION*)malloc(info_array_size);

if (!info_array) {

PyErr_NoMemory();

goto done;

}

if (!QueryWorkingSet(proc, info_array, info_array_size)) {

PyErr_SetFromWindowsErr(0);

goto done;

}

entries = (size_t)info_array->NumberOfEntries;

private_pages = 0;

for (i = 0; i < entries; i++) {

// Count shared pages that only one process is using as private.

if (!info_array->WorkingSetInfo[i].Shared ||

info_array->WorkingSetInfo[i].ShareCount <= 1) {

private_pages++;

}

}

// GetSystemInfo has no return value.

GetSystemInfo(&system_info);

total = private_pages * system_info.dwPageSize;

py_result = Py_BuildValue("K", total);

done:

if (proc) {

CloseHandle(proc);

}

if (info_array) {

free(info_array);

}

return py_result;

}

/*

* Return a Python integer indicating the total amount of physical memory

* in bytes.

*/

static PyObject *

psutil_virtual_mem(PyObject *self, PyObject *args) {

MEMORYSTATUSEX memInfo;

memInfo.dwLength = sizeof(MEMORYSTATUSEX);

if (! GlobalMemoryStatusEx(&memInfo))

return PyErr_SetFromWindowsErr(0);

return Py_BuildValue("(LLLLLL)",

memInfo.ullTotalPhys, // total

memInfo.ullAvailPhys, // avail

memInfo.ullTotalPageFile, // total page file

memInfo.ullAvailPageFile, // avail page file

memInfo.ullTotalVirtual, // total virtual

memInfo.ullAvailVirtual); // avail virtual

}

/*

* Retrieves system CPU timing information as a (user, system, idle)

* tuple. On a multiprocessor system, the values returned are the

* sum of the designated times across all processors.

*/

static PyObject *

psutil_cpu_times(PyObject *self, PyObject *args) {

float idle, kernel, user, system;

FILETIME idle_time, kernel_time, user_time;

if (!GetSystemTimes(&idle_time, &kernel_time, &user_time))

return PyErr_SetFromWindowsErr(0);

idle = (float)((HI_T * idle_time.dwHighDateTime) + \

(LO_T * idle_time.dwLowDateTime));

user = (float)((HI_T * user_time.dwHighDateTime) + \

(LO_T * user_time.dwLowDateTime));

kernel = (float)((HI_T * kernel_time.dwHighDateTime) + \

(LO_T * kernel_time.dwLowDateTime));

// Kernel time includes idle time.

// We return only busy kernel time subtracting idle time from

// kernel time.

system = (kernel - idle);

return Py_BuildValue("(fff)", user, system, idle);

}

/*

* Same as above but for all system CPUs.

*/

static PyObject *

psutil_per_cpu_times(PyObject *self, PyObject *args) {

// NtQuerySystemInformation stuff

typedef DWORD (_stdcall * NTQSI_PROC) (int, PVOID, ULONG, PULONG);

NTQSI_PROC NtQuerySystemInformation;

HINSTANCE hNtDll;

float idle, kernel, systemt, user, interrupt, dpc;

NTSTATUS status;

_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION *sppi = NULL;

SYSTEM_INFO si;

UINT i;

PyObject *py_tuple = NULL;

PyObject *py_retlist = PyList_New(0);

if (py_retlist == NULL)

return NULL;

// obtain NtQuerySystemInformation

hNtDll = LoadLibrary(TEXT("ntdll.dll"));

if (hNtDll == NULL) {

PyErr_SetFromWindowsErr(0);

goto error;

}

NtQuerySystemInformation = (NTQSI_PROC)GetProcAddress(

hNtDll, "NtQuerySystemInformation");

if (NtQuerySystemInformation == NULL) {

PyErr_SetFromWindowsErr(0);

goto error;

}