-/* $Id: proc.c,v 1.59 2004/01/23 21:16:04 ekohl Exp $
+/* $Id: proc.c,v 1.72 2004/11/05 12:26:55 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
#include <k32.h>
-
#define NDEBUG
#include "../include/debug.h"
VOID STDCALL
RegisterWaitForInputIdle(WaitForInputIdleType lpfnRegisterWaitForInputIdle);
-BOOL STDCALL
-InternalGetProcessId (HANDLE hProcess, LPDWORD lpProcessId);
-
-
/* FUNCTIONS ****************************************************************/
/*
LPDWORD lpSystemAffinityMask)
{
PROCESS_BASIC_INFORMATION ProcessInfo;
- ULONG BytesWritten;
NTSTATUS Status;
Status = NtQueryInformationProcess (hProcess,
ProcessBasicInformation,
(PVOID)&ProcessInfo,
sizeof(PROCESS_BASIC_INFORMATION),
- &BytesWritten);
+ NULL);
if (!NT_SUCCESS(Status))
{
- SetLastError (Status);
+ SetLastErrorByStatus (Status);
return FALSE;
}
sizeof(DWORD));
if (!NT_SUCCESS(Status))
{
- SetLastError (Status);
+ SetLastErrorByStatus (Status);
return FALSE;
}
sizeof(CSRSS_API_REPLY));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrReply.Status))
{
- SetLastError(Status);
+ SetLastErrorByStatus (Status);
return(FALSE);
}
sizeof(CSRSS_API_REPLY));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrReply.Status))
{
- SetLastError(Status);
+ SetLastErrorByStatus (Status);
return(FALSE);
}
*/
BOOL STDCALL
GetProcessWorkingSetSize (HANDLE hProcess,
- LPDWORD lpMinimumWorkingSetSize,
- LPDWORD lpMaximumWorkingSetSize)
+ PSIZE_T lpMinimumWorkingSetSize,
+ PSIZE_T lpMaximumWorkingSetSize)
{
QUOTA_LIMITS QuotaLimits;
NTSTATUS Status;
return(FALSE);
}
- *lpMinimumWorkingSetSize = (DWORD)QuotaLimits.MinimumWorkingSetSize;
- *lpMaximumWorkingSetSize = (DWORD)QuotaLimits.MaximumWorkingSetSize;
+ *lpMinimumWorkingSetSize = QuotaLimits.MinimumWorkingSetSize;
+ *lpMaximumWorkingSetSize = QuotaLimits.MaximumWorkingSetSize;
return(TRUE);
}
/*
- * @unimplemented
+ * @implemented
*/
BOOL STDCALL
SetProcessWorkingSetSize(HANDLE hProcess,
- DWORD dwMinimumWorkingSetSize,
- DWORD dwMaximumWorkingSetSize)
+ SIZE_T dwMinimumWorkingSetSize,
+ SIZE_T dwMaximumWorkingSetSize)
{
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return(FALSE);
+ QUOTA_LIMITS QuotaLimits;
+ NTSTATUS Status;
+
+ QuotaLimits.MinimumWorkingSetSize = dwMinimumWorkingSetSize;
+ QuotaLimits.MaximumWorkingSetSize = dwMaximumWorkingSetSize;
+
+ Status = NtSetInformationProcess(hProcess,
+ ProcessQuotaLimits,
+ &QuotaLimits,
+ sizeof(QUOTA_LIMITS));
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ return(FALSE);
+ }
+
+ return(TRUE);
}
LPDWORD lpExitCode)
{
PROCESS_BASIC_INFORMATION ProcessBasic;
- ULONG BytesWritten;
NTSTATUS Status;
Status = NtQueryInformationProcess(hProcess,
ProcessBasicInformation,
&ProcessBasic,
sizeof(PROCESS_BASIC_INFORMATION),
- &BytesWritten);
+ NULL);
if (!NT_SUCCESS(Status))
{
SetLastErrorByStatus(Status);
/*
* @implemented
*/
-BOOL STDCALL
-InternalGetProcessId(HANDLE hProcess,
- LPDWORD lpProcessId)
+DWORD
+STDCALL
+GetProcessId(HANDLE Process)
{
PROCESS_BASIC_INFORMATION ProcessBasic;
- ULONG BytesWritten;
NTSTATUS Status;
- Status = NtQueryInformationProcess(hProcess,
+ Status = NtQueryInformationProcess(Process,
ProcessBasicInformation,
&ProcessBasic,
sizeof(PROCESS_BASIC_INFORMATION),
- &BytesWritten);
+ NULL);
if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus(Status);
- return(FALSE);
- }
-
- memcpy(lpProcessId, &ProcessBasic.UniqueProcessId, sizeof(DWORD));
+ {
+ SetLastErrorByStatus(Status);
+ return 0;
+ }
- return(TRUE);
+ return ProcessBasic.UniqueProcessId;
}
NTSTATUS errCode;
HANDLE ProcessHandle;
OBJECT_ATTRIBUTES ObjectAttributes;
- CLIENT_ID ClientId ;
+ CLIENT_ID ClientId;
ClientId.UniqueProcess = (HANDLE)dwProcessId;
ClientId.UniqueThread = INVALID_HANDLE_VALUE;
{
STARTUPINFOA StartupInfo;
PROCESS_INFORMATION ProcessInformation;
- HINSTANCE hInst;
DWORD dosErr;
+ RtlZeroMemory(&StartupInfo, sizeof(StartupInfo));
StartupInfo.cb = sizeof(STARTUPINFOA);
StartupInfo.wShowWindow = uCmdShow;
StartupInfo.dwFlags = 0;
- hInst = (HINSTANCE)CreateProcessA(NULL,
- (PVOID)lpCmdLine,
- NULL,
- NULL,
- FALSE,
- 0,
- NULL,
- NULL,
- &StartupInfo,
- &ProcessInformation);
- if ( hInst == NULL )
+ if (! CreateProcessA(NULL,
+ (PVOID)lpCmdLine,
+ NULL,
+ NULL,
+ FALSE,
+ 0,
+ NULL,
+ NULL,
+ &StartupInfo,
+ &ProcessInformation))
{
dosErr = GetLastError();
- return dosErr;
+ return dosErr < 32 ? dosErr : ERROR_BAD_FORMAT;
}
if (NULL != lpfnGlobalRegisterWaitForInputIdle)
- {
- lpfnGlobalRegisterWaitForInputIdle (
- ProcessInformation.hProcess,
- 10000
+ {
+ lpfnGlobalRegisterWaitForInputIdle (
+ ProcessInformation.hProcess,
+ 10000
);
- }
- NtClose (ProcessInformation.hProcess);
- NtClose (ProcessInformation.hThread);
- return 0;
+ }
+ NtClose(ProcessInformation.hProcess);
+ NtClose(ProcessInformation.hThread);
+
+ return 33; /* Something bigger than 31 means success. */
}
sizeof(CSRSS_API_REPLY));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrReply.Status))
{
- DbgPrint("Failed to tell csrss about terminating process. "
- "Expect trouble.\n");
+ DPRINT("Failed to tell csrss about terminating process\n");
}
uExitCode);
/* should never get here */
- assert(0);
+ ASSERT(0);
while(1);
}
* @implemented
*/
DWORD STDCALL
-GetPriorityClass (HANDLE hProcess)
-{
- HANDLE hProcessTmp;
- DWORD CsrPriorityClass = 0; // This tells CSRSS we want to GET it!
- NTSTATUS Status;
-
- Status =
- NtDuplicateObject (GetCurrentProcess(),
- hProcess,
- GetCurrentProcess(),
- &hProcessTmp,
- (PROCESS_SET_INFORMATION | PROCESS_QUERY_INFORMATION),
- FALSE,
- 0);
- if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus (Status);
- return (0); /* ERROR */
- }
- /* Ask CSRSS to set it */
- CsrSetPriorityClass (hProcessTmp, &CsrPriorityClass);
- NtClose (hProcessTmp);
- /* Translate CSR->W32 priorities */
- switch (CsrPriorityClass)
+GetPriorityClass (HANDLE hProcess)
+{
+ NTSTATUS Status;
+ PROCESS_PRIORITY_CLASS PriorityClass;
+
+ Status = NtQueryInformationProcess(hProcess,
+ ProcessPriorityClass,
+ &PriorityClass,
+ sizeof(PROCESS_PRIORITY_CLASS),
+ NULL);
+ if(NT_SUCCESS(Status))
+ {
+ switch(PriorityClass.PriorityClass)
{
- case CSR_PRIORITY_CLASS_NORMAL:
- return (NORMAL_PRIORITY_CLASS); /* 32 */
- case CSR_PRIORITY_CLASS_IDLE:
- return (IDLE_PRIORITY_CLASS); /* 64 */
- case CSR_PRIORITY_CLASS_HIGH:
- return (HIGH_PRIORITY_CLASS); /* 128 */
- case CSR_PRIORITY_CLASS_REALTIME:
- return (REALTIME_PRIORITY_CLASS); /* 256 */
+ case PROCESS_PRIORITY_CLASS_IDLE:
+ return IDLE_PRIORITY_CLASS;
+
+ case PROCESS_PRIORITY_CLASS_BELOW_NORMAL:
+ return BELOW_NORMAL_PRIORITY_CLASS;
+
+ case PROCESS_PRIORITY_CLASS_NORMAL:
+ return NORMAL_PRIORITY_CLASS;
+
+ case PROCESS_PRIORITY_CLASS_ABOVE_NORMAL:
+ return ABOVE_NORMAL_PRIORITY_CLASS;
+
+ case PROCESS_PRIORITY_CLASS_HIGH:
+ return HIGH_PRIORITY_CLASS;
+
+ case PROCESS_PRIORITY_CLASS_REALTIME:
+ return REALTIME_PRIORITY_CLASS;
+
+ default:
+ return NORMAL_PRIORITY_CLASS;
}
- SetLastError (ERROR_ACCESS_DENIED);
- return (0); /* ERROR */
+ }
+
+ SetLastErrorByStatus(Status);
+ return FALSE;
}
* @implemented
*/
BOOL STDCALL
-SetPriorityClass (HANDLE hProcess,
+SetPriorityClass (HANDLE hProcess,
DWORD dwPriorityClass)
{
- HANDLE hProcessTmp;
- DWORD CsrPriorityClass;
- NTSTATUS Status;
+ NTSTATUS Status;
+ PROCESS_PRIORITY_CLASS PriorityClass;
- switch (dwPriorityClass)
- {
- case NORMAL_PRIORITY_CLASS: /* 32 */
- CsrPriorityClass = CSR_PRIORITY_CLASS_NORMAL;
+ switch(dwPriorityClass)
+ {
+ case IDLE_PRIORITY_CLASS:
+ PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_IDLE;
break;
- case IDLE_PRIORITY_CLASS: /* 64 */
- CsrPriorityClass = CSR_PRIORITY_CLASS_IDLE;
+
+ case BELOW_NORMAL_PRIORITY_CLASS:
+ PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_BELOW_NORMAL;
break;
- case HIGH_PRIORITY_CLASS: /* 128 */
- CsrPriorityClass = CSR_PRIORITY_CLASS_HIGH;
+
+ case NORMAL_PRIORITY_CLASS:
+ PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL;
break;
- case REALTIME_PRIORITY_CLASS: /* 256 */
- CsrPriorityClass = CSR_PRIORITY_CLASS_REALTIME;
+
+ case ABOVE_NORMAL_PRIORITY_CLASS:
+ PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_ABOVE_NORMAL;
break;
+
+ case HIGH_PRIORITY_CLASS:
+ PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_HIGH;
+ break;
+
+ case REALTIME_PRIORITY_CLASS:
+ PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_REALTIME;
+ break;
+
default:
- SetLastError (ERROR_INVALID_PARAMETER);
- return (FALSE);
- }
- Status =
- NtDuplicateObject (GetCurrentProcess(),
- hProcess,
- GetCurrentProcess(),
- &hProcessTmp,
- (PROCESS_SET_INFORMATION | PROCESS_QUERY_INFORMATION),
- FALSE,
- 0);
- if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus (Status);
- return (FALSE); /* ERROR */
- }
- /* Ask CSRSS to set it */
- Status = CsrSetPriorityClass (hProcessTmp, &CsrPriorityClass);
- NtClose (hProcessTmp);
- if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus (Status);
- return (FALSE);
- }
- return (TRUE);
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+
+ PriorityClass.Foreground = FALSE;
+
+ Status = NtSetInformationProcess(hProcess,
+ ProcessPriorityClass,
+ &PriorityClass,
+ sizeof(PROCESS_PRIORITY_CLASS));
+
+ if(!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ return FALSE;
+ }
+
+ return TRUE;
}
return (Version);
}
+
+/*
+ * @implemented
+ */
+BOOL
+STDCALL
+GetProcessIoCounters(
+ HANDLE hProcess,
+ PIO_COUNTERS lpIoCounters)
+{
+ NTSTATUS Status;
+
+ Status = NtQueryInformationProcess(hProcess,
+ ProcessIoCounters,
+ lpIoCounters,
+ sizeof(IO_COUNTERS),
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ return(FALSE);
+ }
+
+ return TRUE;
+}
+
+
+/*
+ * @implemented
+ */
+BOOL
+STDCALL
+GetProcessPriorityBoost(HANDLE hProcess,
+ PBOOL pDisablePriorityBoost)
+{
+ NTSTATUS Status;
+ BOOL PriorityBoost;
+
+ Status = NtQueryInformationProcess(hProcess,
+ ProcessPriorityBoost,
+ &PriorityBoost,
+ sizeof(BOOL),
+ NULL);
+ if (NT_SUCCESS(Status))
+ {
+ *pDisablePriorityBoost = PriorityBoost;
+ return TRUE;
+ }
+
+ SetLastErrorByStatus(Status);
+ return FALSE;
+}
+
+
+/*
+ * @implemented
+ */
+BOOL
+STDCALL
+SetProcessPriorityBoost(HANDLE hProcess,
+ BOOL bDisablePriorityBoost)
+{
+ NTSTATUS Status;
+ BOOL PriorityBoost = (bDisablePriorityBoost ? TRUE : FALSE); /* prevent setting values other than 1 and 0 */
+
+ Status = NtSetInformationProcess(hProcess,
+ ProcessPriorityBoost,
+ &PriorityBoost,
+ sizeof(BOOL));
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+
+/*
+ * @implemented
+ */
+BOOL
+STDCALL
+GetProcessHandleCount(HANDLE hProcess,
+ PDWORD pdwHandleCount)
+{
+ ULONG phc;
+ NTSTATUS Status;
+
+ Status = NtQueryInformationProcess(hProcess,
+ ProcessHandleCount,
+ &phc,
+ sizeof(ULONG),
+ NULL);
+ if(NT_SUCCESS(Status))
+ {
+ *pdwHandleCount = phc;
+ return TRUE;
+ }
+
+ SetLastErrorByStatus(Status);
+ return FALSE;
+}
+
/* EOF */
projects / reactos.git / blobdiff