116 lines
4.1 KiB
C
116 lines
4.1 KiB
C
#pragma once
|
|
// ke_process.h - process model
|
|
// A process owns a handle table and a list of threads.
|
|
// There is one shared address space - processes do not own one.
|
|
#include <ob_object.h>
|
|
#include <ke_list.h>
|
|
#include <ke_spinlock.h>
|
|
#include <ke_event.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
#include <sys_string.h>
|
|
|
|
#define PROCESS_NAME_MAX 64
|
|
#define HANDLE_TABLE_SIZE 256
|
|
#define PROCESS_MODULE_MAX 16
|
|
#define PROCESS_CWD_MAX 512
|
|
|
|
#define HANDLE_RIGHT_READ 0x00000001u
|
|
#define HANDLE_RIGHT_WRITE 0x00000002u
|
|
#define HANDLE_RIGHT_WAIT 0x00000004u
|
|
#define HANDLE_RIGHT_SIGNAL 0x00000008u
|
|
#define HANDLE_RIGHT_DUPLICATE 0x00000010u
|
|
#define HANDLE_RIGHT_QUERY 0x00000020u
|
|
#define HANDLE_RIGHT_TERMINATE 0x00000040u
|
|
#define HANDLE_RIGHT_ALL 0xFFFFFFFFu
|
|
|
|
typedef struct HANDLE_ENTRY {
|
|
OBJECT* Object;
|
|
uint32_t Rights;
|
|
uint32_t Flags;
|
|
} HANDLE_ENTRY;
|
|
|
|
typedef struct PROCESS_MODULE {
|
|
char Name[32];
|
|
uintptr_t Base;
|
|
size_t Size;
|
|
} PROCESS_MODULE;
|
|
|
|
typedef struct PROCESS {
|
|
OBJECT Header; /* must be first */
|
|
|
|
uint32_t ProcessId;
|
|
char Name[PROCESS_NAME_MAX]; /* UTF-8 */
|
|
|
|
char CurrentDirectory[PROCESS_CWD_MAX];
|
|
size_t CurrentDirectoryLength;
|
|
uint8_t CurrentDrive;
|
|
SPINLOCK CwdLock;
|
|
|
|
/* Thread list. */
|
|
LIST_ENTRY ThreadList; /* links THREAD.ProcessLink */
|
|
uint32_t ThreadCount;
|
|
|
|
/* Handle table.
|
|
Index 0 is always empty (the invalid handle).
|
|
Each live entry holds one object reference plus rights metadata. */
|
|
HANDLE_ENTRY Handles[HANDLE_TABLE_SIZE];
|
|
SPINLOCK HandleLock;
|
|
|
|
int ExitCode;
|
|
volatile long Terminating;
|
|
volatile long Exited;
|
|
|
|
/* Main executable image. Used for cleanup. */
|
|
uintptr_t ImageBase;
|
|
size_t ImageSize;
|
|
|
|
/* User-mode process environment. The initial thread sees this through GS->TEB->PEB. */
|
|
uintptr_t UserPebBase;
|
|
size_t UserPebSize;
|
|
uintptr_t UserImagePathBase;
|
|
size_t UserImagePathSize;
|
|
uintptr_t UserCmdlineBase;
|
|
size_t UserCmdlineSize;
|
|
uintptr_t UserCwdBase;
|
|
size_t UserCwdSize;
|
|
|
|
/* Per-process loaded modules (user processes only). */
|
|
PROCESS_MODULE Modules[PROCESS_MODULE_MAX];
|
|
uint32_t ModuleCount;
|
|
|
|
/* Signaled (manual-reset) when the process exits.
|
|
Waiters block on this via KeWaitForEvent. */
|
|
EVENT* ExitEvent;
|
|
|
|
LIST_ENTRY GlobalLink; /* node in the global process list */
|
|
} PROCESS;
|
|
|
|
KSTATUS KeCreateProcess(const char* name, PROCESS **out);
|
|
KSTATUS KeCreateSystemProcess(PROCESS** out);
|
|
KSTATUS KeSetupUserProcessEnvironment(PROCESS* process,
|
|
SYS_STRING_VIEW imagePath,
|
|
SYS_STRING_VIEW commandLine,
|
|
SYS_STRING_VIEW currentDirectory);
|
|
void KeExitProcess(PROCESS* process, int exitCode);
|
|
KSTATUS KeTerminateProcess(PROCESS* process, int exitCode);
|
|
int KeIsProcessTerminating(PROCESS* process);
|
|
KSTATUS KeGetProcessExitCode(PROCESS* process, int* exitCodeOut);
|
|
|
|
/* Handle table operations. */
|
|
KSTATUS KeAllocateHandle(PROCESS* process, OBJECT* object, uint32_t* handleOut);
|
|
KSTATUS KeAllocateHandleWithRights(PROCESS* process, OBJECT* object, uint32_t rights, uint32_t* handleOut);
|
|
void KeCloseHandle(PROCESS* process, uint32_t handle);
|
|
OBJECT* KeLookupHandle(PROCESS* process, uint32_t handle);
|
|
OBJECT* KeLookupHandleWithRights(PROCESS* process, uint32_t handle, uint32_t requiredRights);
|
|
uint32_t KeGetHandleRights(PROCESS* process, uint32_t handle);
|
|
|
|
/* Return the global process list head (kernel-internal). */
|
|
LIST_ENTRY* KeGetProcessList(void);
|
|
PROCESS* KeGetCurrentProcess(void);
|
|
PROCESS* KeGetSystemProcess(void);
|
|
/* Copy a snapshot of process IDs into caller-provided storage. */
|
|
size_t KeCopyProcessIds(uint32_t* pidsOut, size_t maxCount);
|
|
/* Find a live process by its ProcessId. Bumps refcount; caller must ObDereferenceObject. */
|
|
PROCESS* KeGetProcessById(uint32_t pid);
|