Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-06-29 01:12:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update EPROCESS to latest version. Basic Fast Referencing Stubs to allow Token access. Needs to be implemented. Use ActiveProcessLinks instead of ros-specific list.

Browse source 
svn path=/trunk/; revision=15065
This commit is contained in:
Alex Ionescu 2005-05-06 22:54:40 +00:00
parent 6ab4605c43
commit 8c4f9d3417
22 changed files with 419 additions and 220 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
reactos/include/ddk/extypes.h
View file

@ -94,6 +94,28 @@ typedef struct _EX_RUNDOWN_REF {
}; };
} EX_RUNDOWN_REF, *PEX_RUNDOWN_REF; } EX_RUNDOWN_REF, *PEX_RUNDOWN_REF;
typedef struct _EX_FAST_REF {
union {
PVOID Object;
ULONG RefCnt:3;
ULONG Value;
};
} EX_FAST_REF, *PEX_FAST_REF;
typedef struct _EX_PUSH_LOCK {
union {
struct {
ULONG Locked:1;
ULONG Waiting:1;
ULONG Waking:1;
ULONG MultipleShared:1;
ULONG Shared:28;
};
ULONG Value;
PVOID Ptr;
};
} EX_PUSH_LOCK, *PEX_PUSH_LOCK;
typedef struct typedef struct
{ {
LONG Count; LONG Count;

6
reactos/include/ddk/setypes.h
View file

@ -151,6 +151,12 @@ typedef struct _SECURITY_CLIENT_CONTEXT
TOKEN_CONTROL ClientTokenControl; TOKEN_CONTROL ClientTokenControl;
} SECURITY_CLIENT_CONTEXT, *PSECURITY_CLIENT_CONTEXT; } SECURITY_CLIENT_CONTEXT, *PSECURITY_CLIENT_CONTEXT;
#ifndef __USE_W32API
typedef struct _SE_AUDIT_PROCESS_CREATION_INFO
{
struct _OBJECT_NAME_INFORMATION *ImageFileName;
} SE_AUDIT_PROCESS_CREATION_INFO, *PSE_AUDIT_PROCESS_CREATION_INFO;
#endif
typedef struct _SE_EXPORTS typedef struct _SE_EXPORTS
{ {

24
reactos/ntoskrnl/ex/sysinfo.c
View file

@ -633,23 +633,17 @@ QSI_DEF(SystemProcessInformation)
SpiCur->InheritedFromUniqueProcessId = pr->InheritedFromUniqueProcessId; SpiCur->InheritedFromUniqueProcessId = pr->InheritedFromUniqueProcessId;
SpiCur->HandleCount = (pr->ObjectTable ? ObpGetHandleCountByHandleTable(pr->ObjectTable) : 0); SpiCur->HandleCount = (pr->ObjectTable ? ObpGetHandleCountByHandleTable(pr->ObjectTable) : 0);
SpiCur->PeakVirtualSize = pr->PeakVirtualSize; SpiCur->PeakVirtualSize = pr->PeakVirtualSize;
SpiCur->VirtualSize = pr->VirtualSize.QuadPart; SpiCur->VirtualSize = pr->VirtualSize;
SpiCur->PageFaultCount = pr->LastFaultCount; SpiCur->PageFaultCount = pr->Vm.PageFaultCount;
SpiCur->PeakWorkingSetSize = pr->Vm.PeakWorkingSetSize; // Is this right using ->Vm. here ? SpiCur->PeakWorkingSetSize = pr->Vm.PeakWorkingSetSize; // Is this right using ->Vm. here ?
SpiCur->WorkingSetSize = pr->Vm.WorkingSetSize; // Is this right using ->Vm. here ? SpiCur->WorkingSetSize = pr->Vm.WorkingSetSize; // Is this right using ->Vm. here ?
SpiCur->QuotaPeakPagedPoolUsage = SpiCur->QuotaPeakPagedPoolUsage = pr->QuotaPeak[0];
pr->QuotaPeakPoolUsage[0]; SpiCur->QuotaPagedPoolUsage = pr->QuotaUsage[0];
SpiCur->QuotaPagedPoolUsage = SpiCur->QuotaPeakNonPagedPoolUsage = pr->QuotaPeak[1];
pr->QuotaPoolUsage[0]; SpiCur->QuotaNonPagedPoolUsage = pr->QuotaUsage[1];
SpiCur->QuotaPeakNonPagedPoolUsage = SpiCur->PagefileUsage = pr->QuotaUsage[3];
pr->QuotaPeakPoolUsage[1]; SpiCur->PeakPagefileUsage = pr->QuotaPeak[3];
SpiCur->QuotaNonPagedPoolUsage = SpiCur->PrivateUsage = pr->CommitCharge;
pr->QuotaPoolUsage[1];
SpiCur->PagefileUsage = pr->PagefileUsage; // FIXME
SpiCur->PeakPagefileUsage = pr->PeakPagefileUsage;
// KJK::Hyperion: I don't know what does this mean. VM_COUNTERS
// doesn't seem to contain any equivalent field
//SpiCur->TotalPrivateBytes = pr->NumberOfPrivatePages; //FIXME: bytes != pages
current_entry = pr->ThreadListHead.Flink; current_entry = pr->ThreadListHead.Flink;
while (current_entry != &pr->ThreadListHead) while (current_entry != &pr->ThreadListHead)

22
reactos/ntoskrnl/include/internal/mm.h
View file

@ -188,6 +188,28 @@ typedef struct _PAGEFAULT_HISTORY
#endif /* __USE_W32API */ #endif /* __USE_W32API */
typedef struct _MMADDRESS_NODE
{
union {
ULONG Balance:2;
struct _MMADDRESS_NODE *Parent;
} u1;
struct _MMADDRESS_NODE *LeftChild;
struct _MMADDRESS_NODE *RightChild;
ULONG StartingVpn;
ULONG EndingVpn;
} MMADDRESS_NODE, *PMMADDRESS_NODE;
typedef struct _MM_AVL_TABLE
{
MMADDRESS_NODE BalancedRoot;
ULONG DepthOfTree:5;
ULONG Unused:3;
ULONG NumberGenericTableElements:24;
PVOID NodeHint;
PVOID NodeFreeHint;
} MM_AVL_TABLE, *PMM_AVL_TABLE;
typedef struct _MEMORY_AREA typedef struct _MEMORY_AREA
{ {
PVOID StartingAddress; PVOID StartingAddress;

20
reactos/ntoskrnl/include/internal/ob.h
View file

@ -209,7 +209,6 @@ typedef struct _TYPE_OBJECT
POBJECT_TYPE ObjectType; POBJECT_TYPE ObjectType;
} TYPE_OBJECT, *PTYPE_OBJECT; } TYPE_OBJECT, *PTYPE_OBJECT;
/* /*
* Enumeration of object types * Enumeration of object types
*/ */
@ -326,6 +325,25 @@ ObpReferenceCachedSecurityDescriptor(IN PSECURITY_DESCRIPTOR SecurityDescriptor)
VOID VOID
ObpDereferenceCachedSecurityDescriptor(IN PSECURITY_DESCRIPTOR SecurityDescriptor); ObpDereferenceCachedSecurityDescriptor(IN PSECURITY_DESCRIPTOR SecurityDescriptor);
VOID
FASTCALL
ObInitializeFastReference(IN PEX_FAST_REF FastRef,
PVOID Object);
PVOID
FASTCALL
ObFastReplaceObject(IN PEX_FAST_REF FastRef,
PVOID Object);
PVOID
FASTCALL
ObFastReferenceObject(IN PEX_FAST_REF FastRef);
VOID
FASTCALL
ObFastDereferenceObject(IN PEX_FAST_REF FastRef,
PVOID Object);
/* Secure object information functions */ /* Secure object information functions */
typedef struct _CAPTURED_OBJECT_ATTRIBUTES typedef struct _CAPTURED_OBJECT_ATTRIBUTES

247
reactos/ntoskrnl/include/internal/ps.h
View file

@ -126,127 +126,140 @@ typedef struct _ETHREAD
typedef struct _ETHREAD *PETHREAD; typedef struct _ETHREAD *PETHREAD;
#endif /* __USE_W32API */ #endif /* __USE_W32API */
#include <pshpack4.h>
struct _EPROCESS struct _EPROCESS
{ {
/* Microkernel specific process state. */ KPROCESS Pcb; /* 000 */
KPROCESS Pcb; /* 000 */ EX_PUSH_LOCK ProcessLock; /* 078 */
/* Exit status of the process. */ LARGE_INTEGER CreateTime; /* 080 */
NTSTATUS ExitStatus; /* 068 */ LARGE_INTEGER ExitTime; /* 088 */
/* Unknown. */ EX_RUNDOWN_REF RundownProtect; /* 090 */
KEVENT LockEvent; /* 06C */ HANDLE UniqueProcessId; /* 094 */
/* Unknown. */ LIST_ENTRY ActiveProcessLinks; /* 098 */
ULONG LockCount; /* 07C */ ULONG QuotaUsage[3]; /* 0A0 */
ULONG QuotaPeak[3]; /* 0AC */
ULONG CommitCharge; /* 0B8 */
ULONG PeakVirtualSize; /* 0BC */
ULONG VirtualSize; /* 0C0 */
LIST_ENTRY SessionProcessLinks; /* 0C4 */
PVOID DebugPort; /* 0CC */
PVOID ExceptionPort; /* 0D0 */
PHANDLE_TABLE ObjectTable; /* 0D4 */
EX_FAST_REF Token; /* 0D8 */
ULONG WorkingSetPage; /* 0DC */
KGUARDED_MUTEX AddressCreationLock; /* 0E0 */
KSPIN_LOCK HyperSpaceLock; /* 100 */
PETHREAD ForkInProgress; /* 104 */
ULONG HardwareTrigger; /* 108 */
MM_AVL_TABLE PhysicalVadroot; /* 10C */
PVOID CloneRoot; /* 110 */
ULONG NumberOfPrivatePages; /* 114 */
ULONG NumberOfLockedPages; /* 118 */
PVOID *Win32Process; /* 11C */
struct _EJOB *Job; /* 120 */
PVOID SectionObject; /* 124 */
PVOID SectionBaseAddress; /* 128 */
PEPROCESS_QUOTA_BLOCK QuotaBlock; /* 12C */
PPAGEFAULT_HISTORY WorkingSetWatch; /* 130 */
PVOID Win32WindowStation; /* 134 */
HANDLE InheritedFromUniqueProcessId; /* 138 */
PVOID LdtInformation; /* 13C */
PVOID VadFreeHint; /* 140 */
PVOID VdmObjects; /* 144 */
PVOID DeviceMap; /* 148 */
PVOID Spare0[3]; /* 14C */
union {
HARDWARE_PTE_X86 PagedirectoryPte; /* 158 */
ULONGLONG Filler; /* 158 */
};
ULONG Session; /* 160 */
UCHAR ImageFileName[16]; /* 164 */
LIST_ENTRY JobLinks; /* 174 */
PVOID LockedPagesList; /* 17C */
LIST_ENTRY ThreadListHead; /* 184 */
PVOID SecurityPort; /* 188 */
PVOID PaeTop; /* 18C */
ULONG ActiveThreds; /* 190 */
ACCESS_MASK GrantedAccess; /* 194 */
ULONG DefaultHardErrorProcessing; /* 198 */
NTSTATUS LastThreadExitStatus; /* 19C */
PPEB Peb; /* 1A0 */
EX_FAST_REF PrefetchTrace; /* 1A4 */
LARGE_INTEGER ReadOperationCount; /* 1A8 */
LARGE_INTEGER WriteOperationCount; /* 1B0 */
LARGE_INTEGER OtherOperationCount; /* 1B8 */
LARGE_INTEGER ReadTransferCount; /* 1C0 */
LARGE_INTEGER WriteTransferCount; /* 1C8 */
LARGE_INTEGER OtherTransferCount; /* 1D0 */
ULONG CommitChargeLimit; /* 1D8 */
ULONG CommitChargePeak; /* 1DC */
PVOID AweInfo; /* 1E0 */
SE_AUDIT_PROCESS_CREATION_INFO SeAuditProcessCreationInfo; /* 1E4 */
MMSUPPORT Vm; /* 1E8 */
LIST_ENTRY MmProcessLinks; /* 230 */
ULONG ModifiedPageCount; /* 238 */
ULONG JobStatus; /* 23C */
union {
struct {
ULONG CreateReported:1;
ULONG NoDebugInherit:1;
ULONG ProcessExiting:1;
ULONG ProcessDelete:1;
ULONG Wow64SplitPages:1;
ULONG VmDeleted:1;
ULONG OutswapEnabled:1;
ULONG Outswapped:1;
ULONG ForkFailed:1;
ULONG Wow64VaSpace4Gb:1;
ULONG AddressSpaceInitialized:2;
ULONG SetTimerResolution:1;
ULONG BreakOnTermination:1;
ULONG SessionCreationUnderway:1;
ULONG WriteWatch:1;
ULONG ProcessInSession:1;
ULONG OverrideAddressSpace:1;
ULONG HasAddressSpace:1;
ULONG LaunchPrefetched:1;
ULONG InjectInpageErrors:1;
ULONG VmTopDown:1;
ULONG ImageNotifyDone:1;
ULONG PdeUpdateNeeded:1;
ULONG VdmAllowed:1;
ULONG SmapAllowed:1;
ULONG CreateFailed:1;
ULONG DefaultIoPriority:3;
ULONG Spare1:1;
ULONG Spare2:1;
};
ULONG Flags; /* 240 */
};
NTSTATUS ExitStatus; /* 244 */
USHORT NextPageColor; /* 248 */
union {
struct {
UCHAR SubSystemMinorVersion; /* 24A */
UCHAR SubSystemMajorVersion; /* 24B */
};
USHORT SubSystemVersion; /* 24A */
};
UCHAR PriorityClass; /* 24C */
MM_AVL_TABLE VadRoot; /* 250 */
ULONG Cookie; /* 270 */
/* Time of process creation. */ /***************************************************************
LARGE_INTEGER CreateTime; /* 080 */ * REACTOS SPECIFIC START
***************************************************************/
/* Time of process exit. */ /* FIXME WILL BE DEPRECATED WITH PUSHLOCK SUPPORT IN 0.3.0 */
LARGE_INTEGER ExitTime; /* 088 */ KEVENT LockEvent; /* 274 */
/* Unknown. */ ULONG LockCount; /* 284 */
PKTHREAD LockOwner; /* 090 */ struct _KTHREAD *LockOwner; /* 288 */
/* Process id. */
HANDLE UniqueProcessId; /* 094 */ /* FIXME MOVE TO AVL TREES */
/* Unknown. */ MADDRESS_SPACE AddressSpace; /* 28C */
LIST_ENTRY ActiveProcessLinks; /* 098 */
/* Unknown. */
ULONG QuotaPeakPoolUsage[2]; /* 0A0 */
/* Unknown. */
ULONG QuotaPoolUsage[2]; /* 0A8 */
/* Unknown. */
ULONG PagefileUsage; /* 0B0 */
/* Unknown. */
ULONG CommitCharge; /* 0B4 */
/* Unknown. */
ULONG PeakPagefileUsage; /* 0B8 */
/* Unknown. */
ULONG PeakVirtualSize; /* 0BC */
/* Unknown. */
LARGE_INTEGER VirtualSize; /* 0C0 */
MMSUPPORT Vm;
LIST_ENTRY SessionProcessLinks;
struct _EPORT *DebugPort;
struct _EPORT *ExceptionPort;
PHANDLE_TABLE ObjectTable;
PVOID Token;
FAST_MUTEX WorkingSetLock;
ULONG WorkingSetPage;
UCHAR ProcessOutswapEnabled;
UCHAR ProcessOutswapped;
UCHAR AddressSpaceInitialized;
UCHAR AddressSpaceDeleted;
FAST_MUTEX AddressCreationLock;
KSPIN_LOCK HyperSpaceLock;
PETHREAD ForkInProgress;
USHORT VmOperation;
UCHAR ForkWasSuccessful;
UCHAR MmAgressiveWsTrimMask;
PKEVENT VmOperationEvent;
PVOID PaeTop;
ULONG LastFaultCount;
ULONG ModifiedPageCount;
PVOID VadRoot;
PVOID VadHint;
PVOID CloneRoot;
ULONG NumberOfPrivatePages;
ULONG NumberOfLockedPages;
USHORT NextPageColor;
UCHAR ExitProcessCalled;
UCHAR CreateProcessReported;
HANDLE SectionHandle;
PPEB Peb;
PVOID SectionBaseAddress;
PEPROCESS_QUOTA_BLOCK QuotaBlock;
NTSTATUS LastThreadExitStatus;
PPAGEFAULT_HISTORY WorkingSetWatch;
HANDLE Win32WindowStation;
HANDLE InheritedFromUniqueProcessId;
ULONG GrantedAccess;
ULONG DefaultHardErrorProcessing;
PVOID LdtInformation;
PVOID VadFreeHint;
PVOID VdmObjects;
PVOID DeviceObjects;
ULONG SessionId;
LIST_ENTRY PhysicalVadList;
HARDWARE_PTE_X86 PageDirectoryPte;
ULONGLONG Filler;
ULONG PaePageDirectoryPage;
CHAR ImageFileName[16];
ULONG VmTrimFaultValue;
UCHAR SetTimerResolution;
UCHAR PriorityClass;
UCHAR SubSystemMinorVersion;
UCHAR SubSystemMajorVersion;
USHORT SubSystemVersion;
struct _W32PROCESS *Win32Process;
struct _EJOB *Job;
ULONG JobStatus;
LIST_ENTRY JobLinks;
PVOID LockedPagesList;
struct _EPORT *SecurityPort;
PWOW64_PROCESS Wow64;
LARGE_INTEGER ReadOperationCount;
LARGE_INTEGER WriteOperationCount;
LARGE_INTEGER OtherOperationCount;
LARGE_INTEGER ReadTransferCount;
LARGE_INTEGER WriteTransferCount;
LARGE_INTEGER OtherTransferCount;
ULONG CommitChargeLimit;
ULONG CommitChargePeak;
LIST_ENTRY ThreadListHead;
PRTL_BITMAP VadPhysicalPagesBitMap;
ULONG VadPhysicalPages;
KSPIN_LOCK AweLock;
ULONG Cookie;
/*
* FIXME - ReactOS specified - remove the following fields ASAP!!!
*/
MADDRESS_SPACE AddressSpace;
LIST_ENTRY ProcessListEntry;
}; };
#include <poppack.h>
#define PROCESS_STATE_TERMINATED (1) #define PROCESS_STATE_TERMINATED (1)
#define PROCESS_STATE_ACTIVE (2) #define PROCESS_STATE_ACTIVE (2)

3
reactos/ntoskrnl/include/internal/se.h
View file

@ -20,7 +20,6 @@
#ifndef __NTOSKRNL_INCLUDE_INTERNAL_SE_H #ifndef __NTOSKRNL_INCLUDE_INTERNAL_SE_H
#define __NTOSKRNL_INCLUDE_INTERNAL_SE_H #define __NTOSKRNL_INCLUDE_INTERNAL_SE_H
extern POBJECT_TYPE SepTokenObjectType; extern POBJECT_TYPE SepTokenObjectType;
/* SID Authorities */ /* SID Authorities */
@ -110,6 +109,8 @@ BOOLEAN SepInitSecurityIDs(VOID);
BOOLEAN SepInitDACLs(VOID); BOOLEAN SepInitDACLs(VOID);
BOOLEAN SepInitSDs(VOID); BOOLEAN SepInitSDs(VOID);
VOID SeDeassignPrimaryToken(struct _EPROCESS *Process);
NTSTATUS STDCALL NTSTATUS STDCALL
SepCreateImpersonationTokenDacl(PTOKEN Token, SepCreateImpersonationTokenDacl(PTOKEN Token,
PTOKEN PrimaryToken, PTOKEN PrimaryToken,

2
reactos/ntoskrnl/io/irp.c
View file

@ -901,7 +901,7 @@ STDCALL
IoGetRequestorSessionId(IN PIRP Irp, IoGetRequestorSessionId(IN PIRP Irp,
OUT PULONG pSessionId) OUT PULONG pSessionId)
{ {
*pSessionId = IoGetRequestorProcess(Irp)->SessionId; *pSessionId = IoGetRequestorProcess(Irp)->Session;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }

6
reactos/ntoskrnl/kd/wrappers/gdbstub.c
View file

@ -789,7 +789,7 @@ GspQuery(PCHAR Request)
AProcess = PsActiveProcessHead.Flink; AProcess = PsActiveProcessHead.Flink;
while(AProcess != &PsActiveProcessHead) while(AProcess != &PsActiveProcessHead)
{ {
Process = CONTAINING_RECORD(AProcess, EPROCESS, ProcessListEntry); Process = CONTAINING_RECORD(AProcess, EPROCESS, ActiveProcessLinks);
AThread = Process->ThreadListHead.Flink; AThread = Process->ThreadListHead.Flink;
if(AThread != &Process->ThreadListHead) if(AThread != &Process->ThreadListHead)
{ {
@ -831,10 +831,10 @@ GspQuery(PCHAR Request)
else else
{ {
PETHREAD Thread = NULL; PETHREAD Thread = NULL;
AProcess = Process->ProcessListEntry.Flink; AProcess = Process->ActiveProcessLinks.Flink;
while(AProcess != &PsActiveProcessHead) while(AProcess != &PsActiveProcessHead)
{ {
Process = CONTAINING_RECORD(AProcess, EPROCESS, ProcessListEntry); Process = CONTAINING_RECORD(AProcess, EPROCESS, ActiveProcessLinks);
AThread = Process->ThreadListHead.Flink; AThread = Process->ThreadListHead.Flink;
if(AThread != &Process->ThreadListHead) if(AThread != &Process->ThreadListHead)
{ {

2
reactos/ntoskrnl/kdbg/kdb_cli.c
View file

@ -1078,7 +1078,7 @@ KdbpCmdProc(ULONG Argc, PCHAR Argv[])
KdbpPrint(" PID State Filename\n"); KdbpPrint(" PID State Filename\n");
do do
{ {
Process = CONTAINING_RECORD(Entry, EPROCESS, ProcessListEntry); Process = CONTAINING_RECORD(Entry, EPROCESS, ActiveProcessLinks);
if (Process == KdbCurrentProcess) if (Process == KdbCurrentProcess)
{ {

65
reactos/ntoskrnl/ob/object.c
View file

@ -507,7 +507,7 @@ ObFindObject(POBJECT_ATTRIBUTES ObjectAttributes,
if (current) if (current)
RtlpCreateUnicodeString (RemainingPath, current, NonPagedPool); RtlpCreateUnicodeString (RemainingPath, current, NonPagedPool);
ExFreePool(PathString.Buffer); RtlFreeUnicodeString (&PathString);
*ReturnedObject = CurrentObject; *ReturnedObject = CurrentObject;
return STATUS_SUCCESS; return STATUS_SUCCESS;
@ -806,7 +806,7 @@ ObCreateObject (IN KPROCESSOR_MODE ObjectAttributesAccessMode OPTIONAL,
} }
RtlFreeUnicodeString(&Header->Name); RtlFreeUnicodeString(&Header->Name);
RtlFreeUnicodeString(&RemainingPath); RtlFreeUnicodeString(&RemainingPath);
ExFreePoolWithTag(Header, Header->ObjectType->Tag); ExFreePool(Header);
DPRINT("Create Failed\n"); DPRINT("Create Failed\n");
return Status; return Status;
} }
@ -1000,7 +1000,7 @@ ObpDeleteObject(POBJECT_HEADER Header)
} }
DPRINT("ObPerformRetentionChecks() = Freeing object\n"); DPRINT("ObPerformRetentionChecks() = Freeing object\n");
ExFreePoolWithTag(Header, Header->ObjectType->Tag); ExFreePool(Header);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
@ -1010,14 +1010,16 @@ VOID STDCALL
ObpDeleteObjectWorkRoutine (IN PVOID Parameter) ObpDeleteObjectWorkRoutine (IN PVOID Parameter)
{ {
PRETENTION_CHECK_PARAMS Params = (PRETENTION_CHECK_PARAMS)Parameter; PRETENTION_CHECK_PARAMS Params = (PRETENTION_CHECK_PARAMS)Parameter;
ULONG Tag; /* ULONG Tag; */ /* See below */
ASSERT(Params); ASSERT(Params);
ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL); /* We need PAGED_CODE somewhere... */ ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL); /* We need PAGED_CODE somewhere... */
Tag = Params->ObjectHeader->ObjectType->Tag; /* Turn this on when we have ExFreePoolWithTag
Tag = Params->ObjectHeader->ObjectType->Tag; */
ObpDeleteObject(Params->ObjectHeader); ObpDeleteObject(Params->ObjectHeader);
ExFreePoolWithTag(Params, Tag); ExFreePool(Params);
/* ExFreePoolWithTag(Params, Tag); */
} }
@ -1115,7 +1117,6 @@ ObfReferenceObject(IN PVOID Object)
} }
/********************************************************************** /**********************************************************************
* NAME EXPORTED * NAME EXPORTED
* ObfDereferenceObject@4 * ObfDereferenceObject@4
@ -1161,6 +1162,56 @@ ObfDereferenceObject(IN PVOID Object)
} }
} }
VOID
FASTCALL
ObInitializeFastReference(IN PEX_FAST_REF FastRef,
PVOID Object)
{
/* FIXME: Fast Referencing is Unimplemented */
FastRef->Object = Object;
}
PVOID
FASTCALL
ObFastReferenceObject(IN PEX_FAST_REF FastRef)
{
/* FIXME: Fast Referencing is Unimplemented */
/* Do a normal Reference */
ObReferenceObject(FastRef->Object);
/* Return the Object */
return FastRef->Object;
}
VOID
FASTCALL
ObFastDereferenceObject(IN PEX_FAST_REF FastRef,
PVOID Object)
{
/* FIXME: Fast Referencing is Unimplemented */
/* Do a normal Dereference */
ObDereferenceObject(FastRef->Object);
}
PVOID
FASTCALL
ObFastReplaceObject(IN PEX_FAST_REF FastRef,
PVOID Object)
{
PVOID OldObject = FastRef->Object;
/* FIXME: Fast Referencing is Unimplemented */
FastRef->Object = Object;
/* Do a normal Dereference */
ObDereferenceObject(OldObject);
/* Return old Object*/
return OldObject;
}
/********************************************************************** /**********************************************************************
* NAME EXPORTED * NAME EXPORTED

3
reactos/ntoskrnl/ps/debug.c
View file

@ -280,9 +280,8 @@ PspDumpThreads(BOOLEAN IncludeSystem)
CurrentProcess = PsActiveProcessHead.Flink; CurrentProcess = PsActiveProcessHead.Flink;
while(CurrentProcess != &PsActiveProcessHead) while(CurrentProcess != &PsActiveProcessHead)
{ {
/* Get the process */ /* Get the process */
Process = CONTAINING_RECORD(CurrentProcess, EPROCESS, ProcessListEntry); Process = CONTAINING_RECORD(CurrentProcess, EPROCESS, ActiveProcessLinks);
/* Skip the Initial Process if requested */ /* Skip the Initial Process if requested */
if((Process != PsInitialSystemProcess) || if((Process != PsInitialSystemProcess) ||

4
reactos/ntoskrnl/ps/job.c
View file

@ -160,7 +160,7 @@ NtAssignProcessToJobObject (
Status = PsLockProcess(Process, FALSE); Status = PsLockProcess(Process, FALSE);
if(NT_SUCCESS(Status)) if(NT_SUCCESS(Status))
{ {
if(Process->Job == NULL && Process->SessionId == Job->SessionId) if(Process->Job == NULL && Process->Session == Job->SessionId)
{ {
/* Just store the pointer to the job object in the process, we'll /* Just store the pointer to the job object in the process, we'll
assign it later. The reason we can't do this here is that locking assign it later. The reason we can't do this here is that locking
@ -263,7 +263,7 @@ NtCreateJobObject (
/* setup the job object */ /* setup the job object */
InitializeListHead(&Job->ProcessListHead); InitializeListHead(&Job->ProcessListHead);
Job->SessionId = CurrentProcess->SessionId; /* inherit the session id from the caller */ Job->SessionId = CurrentProcess->Session; /* inherit the session id from the caller */
Status = ExInitializeResource(&Job->JobLock); Status = ExInitializeResource(&Job->JobLock);
if(!NT_SUCCESS(Status)) if(!NT_SUCCESS(Status))

10
reactos/ntoskrnl/ps/kill.c
View file

@ -93,7 +93,7 @@ PspKillMostProcesses(VOID)
current_entry = PsActiveProcessHead.Flink; current_entry = PsActiveProcessHead.Flink;
while (current_entry != &PsActiveProcessHead) while (current_entry != &PsActiveProcessHead)
{ {
current = CONTAINING_RECORD(current_entry, EPROCESS, ProcessListEntry); current = CONTAINING_RECORD(current_entry, EPROCESS, ActiveProcessLinks);
current_entry = current_entry->Flink; current_entry = current_entry->Flink;
if (current->UniqueProcessId != PsInitialSystemProcess->UniqueProcessId && if (current->UniqueProcessId != PsInitialSystemProcess->UniqueProcessId &&
@ -150,7 +150,7 @@ PspDeleteProcess(PVOID ObjectBody)
/* Remove it from the Active List */ /* Remove it from the Active List */
ExAcquireFastMutex(&PspActiveProcessMutex); ExAcquireFastMutex(&PspActiveProcessMutex);
RemoveEntryList(&Process->ProcessListEntry); RemoveEntryList(&Process->ActiveProcessLinks);
ExReleaseFastMutex(&PspActiveProcessMutex); ExReleaseFastMutex(&PspActiveProcessMutex);
/* Delete the CID Handle */ /* Delete the CID Handle */
@ -162,8 +162,10 @@ PspDeleteProcess(PVOID ObjectBody)
/* KDB hook */ /* KDB hook */
KDB_DELETEPROCESS_HOOK(Process); KDB_DELETEPROCESS_HOOK(Process);
/* Dereference the Token and release Memory Information */ /* Dereference the Token */
ObDereferenceObject(Process->Token); SeDeassignPrimaryToken(Process);
/* Release Memory Information */
MmReleaseMmInfo(Process); MmReleaseMmInfo(Process);
/* Delete the W32PROCESS structure if there's one associated */ /* Delete the W32PROCESS structure if there's one associated */

14
reactos/ntoskrnl/ps/process.c
View file

@ -135,12 +135,12 @@ PsGetNextProcess(PEPROCESS OldProcess)
{ {
/* Get the Process Link */ /* Get the Process Link */
PLIST_ENTRY Flink = (NextProcess == PsIdleProcess ? PsActiveProcessHead.Flink : PLIST_ENTRY Flink = (NextProcess == PsIdleProcess ? PsActiveProcessHead.Flink :
NextProcess->ProcessListEntry.Flink); NextProcess->ActiveProcessLinks.Flink);
/* Move to the next Process if we're not back at the beginning */ /* Move to the next Process if we're not back at the beginning */
if (Flink != &PsActiveProcessHead) if (Flink != &PsActiveProcessHead)
{ {
NextProcess = CONTAINING_RECORD(Flink, EPROCESS, ProcessListEntry); NextProcess = CONTAINING_RECORD(Flink, EPROCESS, ActiveProcessLinks);
} }
else else
{ {
@ -292,7 +292,7 @@ PspCreateProcess(OUT PHANDLE ProcessHandle,
if (pParentProcess) if (pParentProcess)
{ {
Process->InheritedFromUniqueProcessId = pParentProcess->UniqueProcessId; Process->InheritedFromUniqueProcessId = pParentProcess->UniqueProcessId;
Process->SessionId = pParentProcess->SessionId; Process->Session = pParentProcess->Session;
} }
/* FIXME: Set up the Quota Block from the Parent /* FIXME: Set up the Quota Block from the Parent
@ -393,7 +393,7 @@ PspCreateProcess(OUT PHANDLE ProcessHandle,
/* W00T! The process can now be activated */ /* W00T! The process can now be activated */
DPRINT("Inserting into Active Process List\n"); DPRINT("Inserting into Active Process List\n");
ExAcquireFastMutex(&PspActiveProcessMutex); ExAcquireFastMutex(&PspActiveProcessMutex);
InsertTailList(&PsActiveProcessHead, &Process->ProcessListEntry); InsertTailList(&PsActiveProcessHead, &Process->ActiveProcessLinks);
ExReleaseFastMutex(&PspActiveProcessMutex); ExReleaseFastMutex(&PspActiveProcessMutex);
/* FIXME: SeCreateAccessStateEx */ /* FIXME: SeCreateAccessStateEx */
@ -547,7 +547,7 @@ BOOLEAN
STDCALL STDCALL
PsGetProcessExitProcessCalled(PEPROCESS Process) PsGetProcessExitProcessCalled(PEPROCESS Process)
{ {
return Process->ExitProcessCalled; return Process->ProcessExiting;
} }
/* /*
@ -636,7 +636,7 @@ ULONG
STDCALL STDCALL
PsGetCurrentProcessSessionId(VOID) PsGetCurrentProcessSessionId(VOID)
{ {
return PsGetCurrentProcess()->SessionId; return PsGetCurrentProcess()->Session;
} }
/* /*
@ -666,7 +666,7 @@ HANDLE
STDCALL STDCALL
PsGetProcessSessionId(PEPROCESS Process) PsGetProcessSessionId(PEPROCESS Process)
{ {
return (HANDLE)Process->SessionId; return (HANDLE)Process->Session;
} }
/* /*

6
reactos/ntoskrnl/ps/psmgr.c
View file

@ -186,7 +186,7 @@ PsInitProcessManagment(VOID)
PsIdleProcess->Pcb.QuantumReset = 6; PsIdleProcess->Pcb.QuantumReset = 6;
InitializeListHead(&PsIdleProcess->Pcb.ThreadListHead); InitializeListHead(&PsIdleProcess->Pcb.ThreadListHead);
InitializeListHead(&PsIdleProcess->ThreadListHead); InitializeListHead(&PsIdleProcess->ThreadListHead);
InitializeListHead(&PsIdleProcess->ProcessListEntry); InitializeListHead(&PsIdleProcess->ActiveProcessLinks);
KeInitializeDispatcherHeader(&PsIdleProcess->Pcb.Header, KeInitializeDispatcherHeader(&PsIdleProcess->Pcb.Header,
ProcessObject, ProcessObject,
sizeof(EPROCESS), sizeof(EPROCESS),
@ -248,7 +248,7 @@ PsInitProcessManagment(VOID)
PsInitialSystemProcess->Win32WindowStation = (HANDLE)0; PsInitialSystemProcess->Win32WindowStation = (HANDLE)0;
InsertHeadList(&PsActiveProcessHead, InsertHeadList(&PsActiveProcessHead,
&PsInitialSystemProcess->ProcessListEntry); &PsInitialSystemProcess->ActiveProcessLinks);
InitializeListHead(&PsInitialSystemProcess->ThreadListHead); InitializeListHead(&PsInitialSystemProcess->ThreadListHead);
#ifndef SCHED_REWRITE #ifndef SCHED_REWRITE
@ -257,7 +257,7 @@ PsInitProcessManagment(VOID)
/* No parent, this is the Initial System Process. Assign Boot Token */ /* No parent, this is the Initial System Process. Assign Boot Token */
BootToken = SepCreateSystemProcessToken(); BootToken = SepCreateSystemProcessToken();
BootToken->TokenInUse = TRUE; BootToken->TokenInUse = TRUE;
PsInitialSystemProcess->Token = BootToken; PsInitialSystemProcess->Token.Object = BootToken; /* FIXME */
ObReferenceObject(BootToken); ObReferenceObject(BootToken);
#endif #endif
} }

18
reactos/ntoskrnl/ps/query.c
View file

@ -287,7 +287,7 @@ NtQueryInformationProcess(IN HANDLE ProcessHandle,
_SEH_TRY _SEH_TRY
{ {
SessionInfo->SessionId = Process->SessionId; SessionInfo->SessionId = Process->Session;
if (ReturnLength) if (ReturnLength)
{ {
*ReturnLength = sizeof(PROCESS_SESSION_INFORMATION); *ReturnLength = sizeof(PROCESS_SESSION_INFORMATION);
@ -318,16 +318,16 @@ NtQueryInformationProcess(IN HANDLE ProcessHandle,
* incompatibilities in current headers (no unnamed union), * incompatibilities in current headers (no unnamed union),
* I opted for cast. * I opted for cast.
*/ */
pOut->VirtualSize = (ULONG)Process->VirtualSize.QuadPart; pOut->VirtualSize = (ULONG)Process->VirtualSize;
pOut->PageFaultCount = Process->Vm.PageFaultCount; pOut->PageFaultCount = Process->Vm.PageFaultCount;
pOut->PeakWorkingSetSize = Process->Vm.PeakWorkingSetSize; pOut->PeakWorkingSetSize = Process->Vm.PeakWorkingSetSize;
pOut->WorkingSetSize = Process->Vm.WorkingSetSize; pOut->WorkingSetSize = Process->Vm.WorkingSetSize;
pOut->QuotaPeakPagedPoolUsage = Process->QuotaPeakPoolUsage[0]; // TODO: Verify! pOut->QuotaPeakPagedPoolUsage = Process->QuotaPeak[0]; // TODO: Verify!
pOut->QuotaPagedPoolUsage = Process->QuotaPoolUsage[0]; // TODO: Verify! pOut->QuotaPagedPoolUsage = Process->QuotaUsage[0]; // TODO: Verify!
pOut->QuotaPeakNonPagedPoolUsage = Process->QuotaPeakPoolUsage[1]; // TODO: Verify! pOut->QuotaPeakNonPagedPoolUsage = Process->QuotaPeak[1]; // TODO: Verify!
pOut->QuotaNonPagedPoolUsage = Process->QuotaPoolUsage[1]; // TODO: Verify! pOut->QuotaNonPagedPoolUsage = Process->QuotaUsage[1]; // TODO: Verify!
pOut->PagefileUsage = Process->PagefileUsage; pOut->PagefileUsage = Process->QuotaUsage[2];
pOut->PeakPagefileUsage = Process->PeakPagefileUsage; pOut->PeakPagefileUsage = Process->QuotaPeak[2];
if (ReturnLength) if (ReturnLength)
{ {
@ -841,7 +841,7 @@ NtSetInformationProcess(IN HANDLE ProcessHandle,
Status = PsLockProcess(Process, FALSE); Status = PsLockProcess(Process, FALSE);
if(NT_SUCCESS(Status)) if(NT_SUCCESS(Status))
{ {
Process->SessionId = SessionInfo.SessionId; Process->Session = SessionInfo.SessionId;
/* Update the session id in the PEB structure */ /* Update the session id in the PEB structure */
if(Process->Peb != NULL) if(Process->Peb != NULL)

89
reactos/ntoskrnl/ps/security.c
View file

@ -13,6 +13,32 @@
#define NDEBUG #define NDEBUG
#include <internal/debug.h> #include <internal/debug.h>
/* INTERNAL ******************************************************************/
/* FIXME: Turn into Macro */
VOID
STDCALL
PspLockProcessSecurityShared(PEPROCESS Process)
{
/* Enter a Guarded Region */
KeEnterGuardedRegion();
/* Lock the Process */
//ExAcquirePushLockShared(&Process->ProcessLock);
}
/* FIXME: Turn into Macro */
VOID
STDCALL
PspUnlockProcessSecurityShared(PEPROCESS Process)
{
/* Unlock the Process */
//ExReleasePushLockShared(&Process->ProcessLock);
/* Leave Guarded Region */
KeLeaveGuardedRegion();
}
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
/* /*
@ -104,12 +130,26 @@ PACCESS_TOKEN
STDCALL STDCALL
PsReferencePrimaryToken(PEPROCESS Process) PsReferencePrimaryToken(PEPROCESS Process)
{ {
/* Reference and return the Token */ PACCESS_TOKEN Token;
ObReferenceObjectByPointer(Process->Token,
TOKEN_ALL_ACCESS, /* Fast Reference the Token */
SepTokenObjectType, Token = ObFastReferenceObject(&Process->Token);
KernelMode);
return(Process->Token); /* Check if we got the Token or if we got locked */
if (!Token)
{
/* Lock the Process */
PspLockProcessSecurityShared(Process);
/* Do a Locked Fast Reference */
//Token = ObFastReferenceObjectLocked(&Process->Token);
/* Unlock the Process */
PspUnlockProcessSecurityShared(Process);
}
/* Return the Token */
return Token;
} }
/* /*
@ -156,7 +196,8 @@ PspInitializeProcessSecurity(PEPROCESS Process,
PTOKEN pParentToken; PTOKEN pParentToken;
OBJECT_ATTRIBUTES ObjectAttributes; OBJECT_ATTRIBUTES ObjectAttributes;
pParentToken = (PACCESS_TOKEN)Parent->Token; /* Get the Parent Token */
pParentToken = PsReferencePrimaryToken(Parent);
/* Initialize the Object Attributes */ /* Initialize the Object Attributes */
InitializeObjectAttributes(&ObjectAttributes, InitializeObjectAttributes(&ObjectAttributes,
@ -180,7 +221,11 @@ PspInitializeProcessSecurity(PEPROCESS Process,
return Status; return Status;
} }
Process->Token = pNewToken; /* Dereference the Token */
ObFastDereferenceObject(&Parent->Token, pParentToken);
/* Set the new Token */
ObInitializeFastReference(&Process->Token, pNewToken);
} else { } else {
@ -227,7 +272,6 @@ PspAssignPrimaryToken(PEPROCESS Process,
Status = SeExchangePrimaryToken(Process, Token, &OldToken); Status = SeExchangePrimaryToken(Process, Token, &OldToken);
/* Derefernece Tokens and Return */ /* Derefernece Tokens and Return */
if (NT_SUCCESS(Status)) ObDereferenceObject(OldToken);
ObDereferenceObject(Token); ObDereferenceObject(Token);
return(Status); return(Status);
} }
@ -356,22 +400,37 @@ PsReferenceEffectiveToken(PETHREAD Thread,
PEPROCESS Process; PEPROCESS Process;
PACCESS_TOKEN Token; PACCESS_TOKEN Token;
if (Thread->ActiveImpersonationInfo == FALSE) { if (Thread->ActiveImpersonationInfo == FALSE)
{
Process = Thread->ThreadsProcess; Process = Thread->ThreadsProcess;
*TokenType = TokenPrimary; *TokenType = TokenPrimary;
*EffectiveOnly = FALSE; *EffectiveOnly = FALSE;
Token = Process->Token;
} else { /* Fast Reference the Token */
Token = ObFastReferenceObject(&Process->Token);
/* Check if we got the Token or if we got locked */
if (!Token)
{
/* Lock the Process */
PspLockProcessSecurityShared(Process);
/* Do a Locked Fast Reference */
//Token = ObFastReferenceObjectLocked(&Process->Token);
/* Unlock the Process */
PspUnlockProcessSecurityShared(Process);
}
}
else
{
Token = Thread->ImpersonationInfo->Token; Token = Thread->ImpersonationInfo->Token;
*TokenType = TokenImpersonation; *TokenType = TokenImpersonation;
*EffectiveOnly = Thread->ImpersonationInfo->EffectiveOnly; *EffectiveOnly = Thread->ImpersonationInfo->EffectiveOnly;
*Level = Thread->ImpersonationInfo->ImpersonationLevel; *Level = Thread->ImpersonationInfo->ImpersonationLevel;
} }
return(Token); return Token;
} }
NTSTATUS NTSTATUS

2
reactos/ntoskrnl/ps/thread.c
View file

@ -423,7 +423,7 @@ HANDLE
STDCALL STDCALL
PsGetThreadSessionId(PETHREAD Thread) PsGetThreadSessionId(PETHREAD Thread)
{ {
return (HANDLE)Thread->ThreadsProcess->SessionId; return (HANDLE)Thread->ThreadsProcess->Session;
} }
/* /*

2
reactos/ntoskrnl/ps/win32.c
View file

@ -54,7 +54,7 @@ PsGetWin32Thread(VOID)
PW32PROCESS STDCALL PW32PROCESS STDCALL
PsGetWin32Process(VOID) PsGetWin32Process(VOID)
{ {
return(PsGetCurrentProcess()->Win32Process); return (PW32PROCESS)PsGetCurrentProcess()->Win32Process;
} }
NTSTATUS STDCALL NTSTATUS STDCALL

60
reactos/ntoskrnl/se/token.c
View file

@ -79,33 +79,45 @@ NTSTATUS SepCopyProxyData(PVOID* Dest, PVOID Src)
return(STATUS_NOT_IMPLEMENTED); return(STATUS_NOT_IMPLEMENTED);
} }
NTSTATUS SeExchangePrimaryToken(PEPROCESS Process, NTSTATUS
PACCESS_TOKEN NewTokenP, SeExchangePrimaryToken(PEPROCESS Process,
PACCESS_TOKEN* OldTokenP) PACCESS_TOKEN NewTokenP,
PACCESS_TOKEN* OldTokenP)
{ {
PTOKEN OldToken; PTOKEN OldToken;
PTOKEN NewToken = (PTOKEN)NewTokenP; PTOKEN NewToken = (PTOKEN)NewTokenP;
PAGED_CODE(); PAGED_CODE();
if (NewToken->TokenType != TokenPrimary) if (NewToken->TokenType != TokenPrimary) return(STATUS_BAD_TOKEN_TYPE);
{ if (NewToken->TokenInUse) return(STATUS_TOKEN_ALREADY_IN_USE);
return(STATUS_UNSUCCESSFUL);
} /* Mark new token in use */
if (NewToken->TokenInUse != 0) NewToken->TokenInUse = 1;
{
return(STATUS_UNSUCCESSFUL); /* Reference the New Token */
} ObReferenceObject(NewToken);
OldToken = Process->Token;
Process->Token = NewToken; /* Replace the old with the new */
NewToken->TokenInUse = 1; OldToken = ObFastReplaceObject(&Process->Token, NewToken);
ObReferenceObjectByPointer(NewToken,
TOKEN_ALL_ACCESS, /* Mark the Old Token as free */
SepTokenObjectType, OldToken->TokenInUse = 0;
KernelMode);
OldToken->TokenInUse = 0; *OldTokenP = (PACCESS_TOKEN)OldToken;
*OldTokenP = (PACCESS_TOKEN)OldToken; return STATUS_SUCCESS;
return(STATUS_SUCCESS); }
VOID
SeDeassignPrimaryToken(PEPROCESS Process)
{
PTOKEN OldToken;
/* Remove the Token */
OldToken = ObFastReplaceObject(&Process->Token, NULL);
/* Mark the Old Token as free */
OldToken->TokenInUse = 0;
} }
static ULONG static ULONG

12
reactos/w32api/include/ddk/winddk.h
View file

@ -929,12 +929,17 @@ typedef struct _FAST_MUTEX {
ULONG OldIrql; ULONG OldIrql;
} FAST_MUTEX, *PFAST_MUTEX; } FAST_MUTEX, *PFAST_MUTEX;
typedef struct _KGATE
{
DISPATCHER_HEADER Header;
} KGATE, *PKGATE, *RESTRICTED_POINTER PRKGATE;
typedef struct _KGUARDED_MUTEX typedef struct _KGUARDED_MUTEX
{ {
LONG Count; LONG Count;
struct _KTHREAD* Owner; struct _KTHREAD* Owner;
ULONG Contention; ULONG Contention;
struct _KGATE* Gate; KGATE Gate;
union { union {
struct { struct {
SHORT KernelApcDisable; SHORT KernelApcDisable;
@ -960,11 +965,6 @@ typedef struct _KMUTANT {
UCHAR ApcDisable; UCHAR ApcDisable;
} KMUTANT, *PKMUTANT, *RESTRICTED_POINTER PRKMUTANT, KMUTEX, *PKMUTEX, *RESTRICTED_POINTER PRKMUTEX; } KMUTANT, *PKMUTANT, *RESTRICTED_POINTER PRKMUTANT, KMUTEX, *PKMUTEX, *RESTRICTED_POINTER PRKMUTEX;
typedef struct _KGATE
{
DISPATCHER_HEADER Header;
} KGATE, *PKGATE, *RESTRICTED_POINTER PRKGATE;
typedef enum _TIMER_TYPE { typedef enum _TIMER_TYPE {
NotificationTimer, NotificationTimer,
SynchronizationTimer SynchronizationTimer