ApfelTeeSaft/reactos
1
0
Fork 0
mirror of https://github.com/ApfelTeeSaft/reactos.git synced 2026-08-29 19:26:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make Object Type creation compatible with OB 2.0 from the caller's point of view. Use real structures for Object Type and ObjectType Initializer. Added two more hacks that I'll remove in the next commit

Browse Source 
svn path=/trunk/; revision=15317
This commit is contained in:
Alex Ionescu
2005-05-15 17:59:33 +00:00
parent 523c60c5d5
commit cf6037ee37
34 changed files with 600 additions and 783 deletions
Download Patch File Download Diff File Expand all files Collapse all files
reactos/include/ddk/pstypes.h
+57 -26
View File
@@ -66,48 +66,79 @@ typedef NTSTATUS STDCALL_FUNC
typedef NTSTATUS STDCALL_FUNC
(*PW32_THREAD_CALLBACK)(struct _ETHREAD *Thread,
BOOLEAN Create);
typedef enum _OB_OPEN_REASON
{
ObCreateHandle,
ObOpenHandle,
ObDuplicateHandle,
ObInheritHandle,
ObMaxOpenReason
} OB_OPEN_REASON;
/*
* Callbacks used for Win32 objects... this define won't be needed after the Object Manager
* rewrite -- Alex
*/
/* TEMPORARY HACK */
typedef NTSTATUS STDCALL_FUNC
(*OBJECT_CREATE_ROUTINE)(PVOID ObjectBody,
PVOID Parent,
PWSTR RemainingPath,
struct _OBJECT_ATTRIBUTES* ObjectAttributes);
(*OB_CREATE_METHOD)(PVOID ObjectBody,
PVOID Parent,
PWSTR RemainingPath,
struct _OBJECT_ATTRIBUTES* ObjectAttributes);
typedef NTSTATUS STDCALL_FUNC
(*OBJECT_OPEN_ROUTINE)(ULONG Reason,
PVOID ObjectBody,
PEPROCESS Process,
ULONG HandleCount,
ACCESS_MASK GrantedAccess);
(*OB_OPEN_METHOD)(OB_OPEN_REASON Reason,
PVOID ObjectBody,
PEPROCESS Process,
ULONG HandleCount,
ACCESS_MASK GrantedAccess);
typedef NTSTATUS STDCALL_FUNC
(*OBJECT_PARSE_ROUTINE)(PVOID Object,
PVOID *NextObject,
PUNICODE_STRING FullPath,
PWSTR *Path,
ULONG Attributes);
(*OB_PARSE_METHOD)(PVOID Object,
PVOID *NextObject,
PUNICODE_STRING FullPath,
PWSTR *Path,
ULONG Attributes);
typedef VOID STDCALL_FUNC
(*OBJECT_DELETE_ROUTINE)(PVOID DeletedObject);
(*OB_DELETE_METHOD)(PVOID DeletedObject);
typedef VOID STDCALL_FUNC
(*OB_CLOSE_METHOD)(PVOID ClosedObject, ULONG HandleCount);
typedef VOID STDCALL_FUNC
(*OB_DUMP_METHOD)(VOID);
typedef NTSTATUS STDCALL_FUNC
(*OB_OKAYTOCLOSE_METHOD)(VOID);
typedef NTSTATUS STDCALL_FUNC
(*OB_QUERYNAME_METHOD)(PVOID ObjectBody,
POBJECT_NAME_INFORMATION ObjectNameInfo,
ULONG Length,
PULONG ReturnLength);
typedef PVOID STDCALL_FUNC
(*OBJECT_FIND_ROUTINE)(PVOID WinStaObject,
PWSTR Name,
ULONG Attributes);
(*OB_FIND_METHOD)(PVOID WinStaObject,
PWSTR Name,
ULONG Attributes);
typedef NTSTATUS STDCALL_FUNC
(*OB_SECURITY_METHOD)(PVOID ObjectBody,
SECURITY_OPERATION_CODE OperationCode,
SECURITY_INFORMATION SecurityInformation,
PSECURITY_DESCRIPTOR SecurityDescriptor,
PULONG BufferLength);
typedef struct _W32_OBJECT_CALLBACK {
OBJECT_OPEN_ROUTINE WinStaCreate;
OBJECT_PARSE_ROUTINE WinStaParse;
OBJECT_DELETE_ROUTINE WinStaDelete;
OBJECT_FIND_ROUTINE WinStaFind;
OBJECT_CREATE_ROUTINE DesktopCreate;
OBJECT_DELETE_ROUTINE DesktopDelete;
OB_OPEN_METHOD WinStaCreate;
OB_PARSE_METHOD WinStaParse;
OB_DELETE_METHOD WinStaDelete;
OB_FIND_METHOD WinStaFind;
OB_CREATE_METHOD DesktopCreate;
OB_DELETE_METHOD DesktopDelete;
} W32_OBJECT_CALLBACK, *PW32_OBJECT_CALLBACK;
typedef struct _STACK_INFORMATION
reactos/ntoskrnl/cm/registry.c
+19 -21
View File
@@ -331,7 +331,8 @@ CmInitHives(BOOLEAN SetupBoot)
if (SetupBoot == FALSE) CmInit2((PCHAR)KeLoaderBlock.CommandLine);
}
VOID INIT_FUNCTION
VOID
INIT_FUNCTION
CmInitializeRegistry(VOID)
{
OBJECT_ATTRIBUTES ObjectAttributes;
@@ -346,29 +347,26 @@ CmInitializeRegistry(VOID)
LARGE_INTEGER DueTime;
HANDLE ThreadHandle;
CLIENT_ID ThreadId;
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
UNICODE_STRING Name;
DPRINT1("Creating Registry Object Type\n");
/* Initialize the Key object type */
CmiKeyType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
ASSERT(CmiKeyType);
CmiKeyType->Tag = TAG('R', 'e', 'g', 'K');
CmiKeyType->TotalObjects = 0;
CmiKeyType->TotalHandles = 0;
CmiKeyType->PeakObjects = 0;
CmiKeyType->PeakHandles = 0;
CmiKeyType->PagedPoolCharge = 0;
CmiKeyType->NonpagedPoolCharge = sizeof(KEY_OBJECT);
CmiKeyType->Mapping = &CmiKeyMapping;
CmiKeyType->Dump = NULL;
CmiKeyType->Open = NULL;
CmiKeyType->Close = NULL;
CmiKeyType->Delete = CmiObjectDelete;
CmiKeyType->Parse = CmiObjectParse;
CmiKeyType->Security = CmiObjectSecurity;
CmiKeyType->QueryName = CmiObjectQueryName;
CmiKeyType->OkayToClose = NULL;
RtlInitUnicodeString(&CmiKeyType->TypeName, L"Key");
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"Key");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KEY_OBJECT);
ObjectTypeInitializer.GenericMapping = CmiKeyMapping;
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.ValidAccessMask = KEY_ALL_ACCESS;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObjectTypeInitializer.DeleteProcedure = CmiObjectDelete;
ObjectTypeInitializer.ParseProcedure = CmiObjectParse;
ObjectTypeInitializer.SecurityProcedure = CmiObjectSecurity;
ObjectTypeInitializer.QueryNameProcedure = CmiObjectQueryName;
ObpCreateTypeObject (CmiKeyType);
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &CmiKeyType);
/* Initialize the hive list */
InitializeListHead(&CmiHiveListHead);
reactos/ntoskrnl/ex/callback.c
+11 -23
View File
@@ -42,33 +42,21 @@ ExpInitializeCallbacks(VOID)
NTSTATUS Status;
UNICODE_STRING DirName;
UNICODE_STRING CallbackName;
UNICODE_STRING Name;
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
HANDLE DirectoryHandle;
ULONG i;
/* Allocate memory for Object */
ExCallbackObjectType = ExAllocatePoolWithTag(NonPagedPool, sizeof(OBJECT_TYPE), CALLBACK_TAG);
/* Initialize the Callback Object type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"Callback");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(_INT_CALLBACK_OBJECT);
ObjectTypeInitializer.GenericMapping = ExpCallbackMapping;
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.UseDefaultObject = TRUE;
/* Initialize name */
RtlInitUnicodeString(&ExCallbackObjectType->TypeName, L"Callback");
/* Create the Object Type */
ExCallbackObjectType->Tag = CALLBACK_TAG;
ExCallbackObjectType->TotalObjects = 0;
ExCallbackObjectType->TotalHandles = 0;
ExCallbackObjectType->PeakObjects = 0;
ExCallbackObjectType->PeakHandles = 0;
ExCallbackObjectType->PagedPoolCharge = 0;
ExCallbackObjectType->Dump = NULL;
ExCallbackObjectType->Open = NULL;
ExCallbackObjectType->Close = NULL;
ExCallbackObjectType->Delete = NULL;
ExCallbackObjectType->Parse = NULL;
ExCallbackObjectType->Security = NULL;
ExCallbackObjectType->QueryName = NULL;
ExCallbackObjectType->OkayToClose = NULL;
ExCallbackObjectType->Mapping = &ExpCallbackMapping;
ExCallbackObjectType->NonpagedPoolCharge = sizeof(_INT_CALLBACK_OBJECT);
Status = ObpCreateTypeObject(ExCallbackObjectType);
Status = ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ExCallbackObjectType);
/* Fail if it wasn't created successfully */
if (!NT_SUCCESS(Status))
reactos/ntoskrnl/ex/event.c
+15 -20
View File
@@ -36,26 +36,21 @@ VOID
INIT_FUNCTION
ExpInitializeEventImplementation(VOID)
{
/* Create the Event Object Type */
ExEventObjectType = ExAllocatePool(NonPagedPool,sizeof(OBJECT_TYPE));
RtlInitUnicodeString(&ExEventObjectType->TypeName, L"Event");
ExEventObjectType->Tag = TAG('E', 'V', 'T', 'T');
ExEventObjectType->PeakObjects = 0;
ExEventObjectType->PeakHandles = 0;
ExEventObjectType->TotalObjects = 0;
ExEventObjectType->TotalHandles = 0;
ExEventObjectType->PagedPoolCharge = 0;
ExEventObjectType->NonpagedPoolCharge = sizeof(KEVENT);
ExEventObjectType->Mapping = &ExpEventMapping;
ExEventObjectType->Dump = NULL;
ExEventObjectType->Open = NULL;
ExEventObjectType->Close = NULL;
ExEventObjectType->Delete = NULL;
ExEventObjectType->Parse = NULL;
ExEventObjectType->Security = NULL;
ExEventObjectType->QueryName = NULL;
ExEventObjectType->OkayToClose = NULL;
ObpCreateTypeObject(ExEventObjectType);
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
UNICODE_STRING Name;
DPRINT1("Creating Event Object Type\n");
/* Create the Event Object Type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"Event");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KEVENT);
ObjectTypeInitializer.GenericMapping = ExpEventMapping;
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.ValidAccessMask = EVENT_ALL_ACCESS;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ExEventObjectType);
}
/*
reactos/ntoskrnl/ex/evtpair.c
+15 -20
View File
@@ -33,26 +33,21 @@ VOID
INIT_FUNCTION
ExpInitializeEventPairImplementation(VOID)
{
/* Create the Event Pair Object Type */
ExEventPairObjectType = ExAllocatePool(NonPagedPool,sizeof(OBJECT_TYPE));
RtlInitUnicodeString(&ExEventPairObjectType->TypeName, L"EventPair");
ExEventPairObjectType->Tag = TAG('E', 'v', 'P', 'a');
ExEventPairObjectType->PeakObjects = 0;
ExEventPairObjectType->PeakHandles = 0;
ExEventPairObjectType->TotalObjects = 0;
ExEventPairObjectType->TotalHandles = 0;
ExEventPairObjectType->PagedPoolCharge = 0;
ExEventPairObjectType->NonpagedPoolCharge = sizeof(KEVENT_PAIR);
ExEventPairObjectType->Mapping = &ExEventPairMapping;
ExEventPairObjectType->Dump = NULL;
ExEventPairObjectType->Open = NULL;
ExEventPairObjectType->Close = NULL;
ExEventPairObjectType->Delete = NULL;
ExEventPairObjectType->Parse = NULL;
ExEventPairObjectType->Security = NULL;
ExEventPairObjectType->QueryName = NULL;
ExEventPairObjectType->OkayToClose = NULL;
ObpCreateTypeObject(ExEventPairObjectType);
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
UNICODE_STRING Name;
DPRINT1("Creating Event Pair Object Type\n");
/* Create the Event Pair Object Type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"EventPair");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KEVENT_PAIR);
ObjectTypeInitializer.GenericMapping = ExEventPairMapping;
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.ValidAccessMask = EVENT_PAIR_ALL_ACCESS;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ExEventPairObjectType);
}
NTSTATUS
reactos/ntoskrnl/ex/mutant.c
+15 -23
View File
@@ -49,30 +49,22 @@ VOID
INIT_FUNCTION
ExpInitializeMutantImplementation(VOID)
{
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
UNICODE_STRING Name;
/* Allocate the Object Type */
ExMutantObjectType = ExAllocatePoolWithTag(NonPagedPool, sizeof(OBJECT_TYPE), TAG('M', 't', 'n', 't'));
/* Create the Object Type */
RtlInitUnicodeString(&ExMutantObjectType->TypeName, L"Mutant");
ExMutantObjectType->Tag = TAG('M', 't', 'n', 't');
ExMutantObjectType->PeakObjects = 0;
ExMutantObjectType->PeakHandles = 0;
ExMutantObjectType->TotalObjects = 0;
ExMutantObjectType->TotalHandles = 0;
ExMutantObjectType->PagedPoolCharge = 0;
ExMutantObjectType->NonpagedPoolCharge = sizeof(KMUTANT);
ExMutantObjectType->Mapping = &ExpMutantMapping;
ExMutantObjectType->Dump = NULL;
ExMutantObjectType->Open = NULL;
ExMutantObjectType->Close = NULL;
ExMutantObjectType->Delete = ExpDeleteMutant;
ExMutantObjectType->Parse = NULL;
ExMutantObjectType->Open = NULL;
ExMutantObjectType->Security = NULL;
ExMutantObjectType->QueryName = NULL;
ExMutantObjectType->OkayToClose = NULL;
ObpCreateTypeObject(ExMutantObjectType);
DPRINT1("Creating Mutant Object Type\n");
/* Create the Event Pair Object Type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"Mutant");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KMUTANT);
ObjectTypeInitializer.GenericMapping = ExpMutantMapping;
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.DeleteProcedure = ExpDeleteMutant;
ObjectTypeInitializer.ValidAccessMask = MUTANT_ALL_ACCESS;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ExMutantObjectType);
}
/*
reactos/ntoskrnl/ex/profile.c
+16 -21
View File
@@ -75,30 +75,25 @@ VOID
INIT_FUNCTION
ExpInitializeProfileImplementation(VOID)
{
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
UNICODE_STRING Name;
/* Initialize the Mutex to lock the States */
KeInitializeMutex(&ExpProfileMutex, 0x40);
/* Create the Object Type */
ExProfileObjectType = ExAllocatePool(NonPagedPool,sizeof(OBJECT_TYPE));
RtlInitUnicodeString(&ExProfileObjectType->TypeName, L"Profile");
ExProfileObjectType->Tag = TAG('P', 'R', 'O', 'F');
ExProfileObjectType->PeakObjects = 0;
ExProfileObjectType->PeakHandles = 0;
ExProfileObjectType->TotalObjects = 0;
ExProfileObjectType->TotalHandles = 0;
ExProfileObjectType->PagedPoolCharge = 0;
ExProfileObjectType->NonpagedPoolCharge = sizeof(EPROFILE);
ExProfileObjectType->Mapping = &ExpProfileMapping;
ExProfileObjectType->Dump = NULL;
ExProfileObjectType->Open = NULL;
ExProfileObjectType->Close = NULL;
ExProfileObjectType->Delete = ExpDeleteProfile;
ExProfileObjectType->Parse = NULL;
ExProfileObjectType->Open = NULL;
ExProfileObjectType->Security = NULL;
ExProfileObjectType->QueryName = NULL;
ExProfileObjectType->OkayToClose = NULL;
ObpCreateTypeObject(ExProfileObjectType);
DPRINT1("Creating Profile Object Type\n");
/* Create the Event Pair Object Type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"Profile");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KPROFILE);
ObjectTypeInitializer.GenericMapping = ExpProfileMapping;
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.DeleteProcedure = ExpDeleteProfile;
ObjectTypeInitializer.ValidAccessMask = STANDARD_RIGHTS_ALL;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ExProfileObjectType);
}
NTSTATUS
reactos/ntoskrnl/ex/sem.c
+14 -20
View File
@@ -34,27 +34,21 @@ VOID
INIT_FUNCTION
ExpInitializeSemaphoreImplementation(VOID)
{
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
UNICODE_STRING Name;
/* Create the Semaphore Object */
ExSemaphoreObjectType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
RtlInitUnicodeString(&ExSemaphoreObjectType->TypeName, L"Semaphore");
ExSemaphoreObjectType->Tag = TAG('S', 'E', 'M', 'T');
ExSemaphoreObjectType->PeakObjects = 0;
ExSemaphoreObjectType->PeakHandles = 0;
ExSemaphoreObjectType->TotalObjects = 0;
ExSemaphoreObjectType->TotalHandles = 0;
ExSemaphoreObjectType->PagedPoolCharge = 0;
ExSemaphoreObjectType->NonpagedPoolCharge = sizeof(KSEMAPHORE);
ExSemaphoreObjectType->Mapping = &ExSemaphoreMapping;
ExSemaphoreObjectType->Dump = NULL;
ExSemaphoreObjectType->Open = NULL;
ExSemaphoreObjectType->Close = NULL;
ExSemaphoreObjectType->Delete = NULL;
ExSemaphoreObjectType->Parse = NULL;
ExSemaphoreObjectType->Security = NULL;
ExSemaphoreObjectType->QueryName = NULL;
ExSemaphoreObjectType->OkayToClose = NULL;
ObpCreateTypeObject(ExSemaphoreObjectType);
DPRINT1("Creating Semaphore Object Type\n");
/* Create the Event Pair Object Type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"Semaphore");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KSEMAPHORE);
ObjectTypeInitializer.GenericMapping = ExSemaphoreMapping;
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.ValidAccessMask = SEMAPHORE_ALL_ACCESS;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ExSemaphoreObjectType);
}
/*
reactos/ntoskrnl/ex/timer.c
+14 -24
View File
@@ -223,31 +223,21 @@ VOID
INIT_FUNCTION
ExpInitializeTimerImplementation(VOID)
{
DPRINT("ExpInitializeTimerImplementation()\n");
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
UNICODE_STRING Name;
/* Allocate Memory for the Timer */
ExTimerType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
/* Create the Executive Timer Object */
RtlInitUnicodeString(&ExTimerType->TypeName, L"Timer");
ExTimerType->Tag = TAG('T', 'I', 'M', 'T');
ExTimerType->PeakObjects = 0;
ExTimerType->PeakHandles = 0;
ExTimerType->TotalObjects = 0;
ExTimerType->TotalHandles = 0;
ExTimerType->PagedPoolCharge = 0;
ExTimerType->NonpagedPoolCharge = sizeof(ETIMER);
ExTimerType->Mapping = &ExpTimerMapping;
ExTimerType->Dump = NULL;
ExTimerType->Open = NULL;
ExTimerType->Close = NULL;
ExTimerType->Delete = ExpDeleteTimer;
ExTimerType->Parse = NULL;
ExTimerType->Security = NULL;
ExTimerType->Open = NULL;
ExTimerType->QueryName = NULL;
ExTimerType->OkayToClose = NULL;
ObpCreateTypeObject(ExTimerType);
DPRINT1("Creating Timer Object Type\n");
/* Create the Event Pair Object Type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"Timer");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KTIMER);
ObjectTypeInitializer.GenericMapping = ExpTimerMapping;
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.ValidAccessMask = TIMER_ALL_ACCESS;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ExTimerType);
/* Initialize the Wait List and Lock */
KeInitializeSpinLock(&ExpWakeListLock);
reactos/ntoskrnl/ex/win32k.c
+30 -45
View File
@@ -39,12 +39,12 @@ static GENERIC_MAPPING ExpDesktopMapping = {
DESKTOP_READOBJECTS | DESKTOP_SWITCHDESKTOP | DESKTOP_WRITEOBJECTS
};
OBJECT_OPEN_ROUTINE ExpWindowStationObjectOpen = NULL;
OBJECT_PARSE_ROUTINE ExpWindowStationObjectParse = NULL;
OBJECT_DELETE_ROUTINE ExpWindowStationObjectDelete = NULL;
OBJECT_FIND_ROUTINE ExpWindowStationObjectFind = NULL;
OBJECT_CREATE_ROUTINE ExpDesktopObjectCreate = NULL;
OBJECT_DELETE_ROUTINE ExpDesktopObjectDelete = NULL;
OB_OPEN_METHOD ExpWindowStationObjectOpen = NULL;
OB_PARSE_METHOD ExpWindowStationObjectParse = NULL;
OB_DELETE_METHOD ExpWindowStationObjectDelete = NULL;
OB_FIND_METHOD ExpWindowStationObjectFind = NULL;
OB_CREATE_METHOD ExpDesktopObjectCreate = NULL;
OB_DELETE_METHOD ExpDesktopObjectDelete = NULL;
/* FUNCTIONS ****************************************************************/
@@ -126,48 +126,33 @@ VOID
INIT_FUNCTION
ExpWin32kInit(VOID)
{
/* Create window station object type */
ExWindowStationObjectType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
ExWindowStationObjectType->Tag = TAG('W', 'I', 'N', 'S');
ExWindowStationObjectType->TotalObjects = 0;
ExWindowStationObjectType->TotalHandles = 0;
ExWindowStationObjectType->PeakObjects = 0;
ExWindowStationObjectType->PeakHandles = 0;
ExWindowStationObjectType->PagedPoolCharge = 0;
ExWindowStationObjectType->NonpagedPoolCharge = sizeof(WINSTATION_OBJECT);
ExWindowStationObjectType->Mapping = &ExpWindowStationMapping;
ExWindowStationObjectType->Dump = NULL;
ExWindowStationObjectType->Open = ExpWinStaObjectOpen;
ExWindowStationObjectType->Close = NULL;
ExWindowStationObjectType->Delete = ExpWinStaObjectDelete;
ExWindowStationObjectType->Parse = ExpWinStaObjectParse;
ExWindowStationObjectType->Security = NULL;
ExWindowStationObjectType->QueryName = NULL;
ExWindowStationObjectType->OkayToClose = NULL;
RtlInitUnicodeString(&ExWindowStationObjectType->TypeName, L"WindowStation");
ObpCreateTypeObject(ExWindowStationObjectType);
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
UNICODE_STRING Name;
DPRINT1("Creating window station Object Type\n");
/* Create the window station Object Type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"WindowStation");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(WINSTATION_OBJECT);
ObjectTypeInitializer.GenericMapping = ExpWindowStationMapping;
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObjectTypeInitializer.OpenProcedure = ExpWinStaObjectOpen;
ObjectTypeInitializer.DeleteProcedure = ExpWinStaObjectDelete;
ObjectTypeInitializer.ParseProcedure = ExpWinStaObjectParse;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ExWindowStationObjectType);
/* Create desktop object type */
ExDesktopObjectType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
ExDesktopObjectType->Tag = TAG('D', 'E', 'S', 'K');
ExDesktopObjectType->TotalObjects = 0;
ExDesktopObjectType->TotalHandles = 0;
ExDesktopObjectType->PeakObjects = 0;
ExDesktopObjectType->PeakHandles = 0;
ExDesktopObjectType->PagedPoolCharge = 0;
ExDesktopObjectType->NonpagedPoolCharge = sizeof(DESKTOP_OBJECT);
ExDesktopObjectType->Mapping = &ExpDesktopMapping;
ExDesktopObjectType->Dump = NULL;
ExDesktopObjectType->Open = NULL;
ExDesktopObjectType->Close = NULL;
ExDesktopObjectType->Delete = ExpDesktopDelete;
ExDesktopObjectType->Parse = NULL;
ExDesktopObjectType->Security = NULL;
ExDesktopObjectType->QueryName = NULL;
ExDesktopObjectType->OkayToClose = NULL;
RtlInitUnicodeString(&Name, L"Desktop");
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(DESKTOP_OBJECT);
ObjectTypeInitializer.GenericMapping = ExpDesktopMapping;
ObjectTypeInitializer.OpenProcedure = NULL;
ObjectTypeInitializer.DeleteProcedure = ExpDesktopDelete;
ObjectTypeInitializer.ParseProcedure = NULL;
RtlInitUnicodeString(&ExDesktopObjectType->TypeName, L"Desktop");
ObpCreateTypeObject(ExDesktopObjectType);
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ExDesktopObjectType);
}
/* EOF */
reactos/ntoskrnl/include/internal/io.h
+1
View File
@@ -42,6 +42,7 @@
#define IO_METHOD_FROM_CTL_CODE(ctlCode) (ctlCode&0x00000003)
struct _DEVICE_OBJECT_POWER_EXTENSION;
extern POBJECT_TYPE IoCompletionType;
/* This is like the IRP Overlay so we can optimize its insertion */
typedef struct _IO_COMPLETION_PACKET
reactos/ntoskrnl/include/internal/ob.h
+38 -120
View File
@@ -16,15 +16,6 @@
struct _EPROCESS;
typedef enum _OB_OPEN_REASON
{
ObCreateHandle,
ObOpenHandle,
ObDuplicateHandle,
ObInheritHandle,
ObMaxOpenReason
} OB_OPEN_REASON;
typedef struct
{
CSHORT Type;
@@ -33,121 +24,46 @@ typedef struct
typedef PVOID POBJECT;
typedef struct _OBJECT_TYPE_INITIALIZER
{
WORD Length;
UCHAR UseDefaultObject;
UCHAR CaseInsensitive;
ULONG InvalidAttributes;
GENERIC_MAPPING GenericMapping;
ULONG ValidAccessMask;
UCHAR SecurityRequired;
UCHAR MaintainHandleCount;
UCHAR MaintainTypeList;
POOL_TYPE PoolType;
ULONG DefaultPagedPoolCharge;
ULONG DefaultNonPagedPoolCharge;
OB_DUMP_METHOD DumpProcedure;
OB_OPEN_METHOD OpenProcedure;
OB_CLOSE_METHOD CloseProcedure;
OB_DELETE_METHOD DeleteProcedure;
OB_PARSE_METHOD ParseProcedure;
OB_SECURITY_METHOD SecurityProcedure;
OB_QUERYNAME_METHOD QueryNameProcedure;
OB_OKAYTOCLOSE_METHOD OkayToCloseProcedure;
} OBJECT_TYPE_INITIALIZER, *POBJECT_TYPE_INITIALIZER;
typedef struct _OBJECT_TYPE
{
/*
* PURPOSE: Tag to be used when allocating objects of this type
*/
ULONG Tag;
/*
* PURPOSE: Name of the type
*/
UNICODE_STRING TypeName;
/*
* PURPOSE: Total number of objects of this type
*/
ULONG TotalObjects;
/*
* PURPOSE: Total number of handles of this type
*/
ULONG TotalHandles;
/*
* PURPOSE: Peak objects of this type
*/
ULONG PeakObjects;
/*
* PURPOSE: Peak handles of this type
*/
ULONG PeakHandles;
/*
* PURPOSE: Paged pool charge
*/
ULONG PagedPoolCharge;
/*
* PURPOSE: Nonpaged pool charge
*/
ULONG NonpagedPoolCharge;
/*
* PURPOSE: Mapping of generic access rights
*/
PGENERIC_MAPPING Mapping;
/*
* PURPOSE: Dumps the object
* NOTE: To be defined
*/
VOID STDCALL_FUNC (*Dump)(VOID);
/*
* PURPOSE: Called to close an object if OkayToClose returns true
*/
VOID STDCALL_FUNC (*Close)(PVOID ObjectBody,
ULONG HandleCount);
/*
* PURPOSE: Called to delete an object when the last reference is removed
*/
VOID STDCALL_FUNC (*Delete)(PVOID ObjectBody);
/*
* PURPOSE: Called when an open attempts to open a file apparently
* residing within the object
* RETURNS
* STATUS_SUCCESS NextObject was found
* STATUS_UNSUCCESSFUL NextObject not found
* STATUS_REPARSE Path changed, restart parsing the path
*/
NTSTATUS STDCALL_FUNC (*Parse)(PVOID ParsedObject,
PVOID *NextObject,
PUNICODE_STRING FullPath,
PWSTR *Path,
ULONG Attributes);
/*
* PURPOSE: Called to set, query, delete or assign a security-descriptor
* to the object
* RETURNS
* STATUS_SUCCESS NextObject was found
*/
NTSTATUS STDCALL_FUNC (*Security)(PVOID ObjectBody,
SECURITY_OPERATION_CODE OperationCode,
SECURITY_INFORMATION SecurityInformation,
PSECURITY_DESCRIPTOR SecurityDescriptor,
PULONG BufferLength);
/*
* PURPOSE: Called to query the name of the object
* RETURNS
* STATUS_SUCCESS NextObject was found
*/
NTSTATUS STDCALL_FUNC (*QueryName)(PVOID ObjectBody,
POBJECT_NAME_INFORMATION ObjectNameInfo,
ULONG Length,
PULONG ReturnLength);
/*
* PURPOSE: Called when a process asks to close the object
*/
VOID STDCALL_FUNC (*OkayToClose)(VOID);
NTSTATUS STDCALL_FUNC (*Open)(OB_OPEN_REASON Reason,
PVOID ObjectBody,
PEPROCESS Process,
ULONG HandleCount,
ACCESS_MASK GrantedAccess);
ERESOURCE Mutex; /* Used to lock the Object Type */
LIST_ENTRY TypeList; /* Links all the Types Together for Debugging */
UNICODE_STRING Name; /* Name of the Type */
PVOID DefaultObject; /* What Object to use during a Wait (ie, FileObjects wait on FileObject->Event) */
ULONG Index; /* Index of this Type in the Object Directory */
ULONG TotalNumberOfObjects; /* Total number of objects of this type */
ULONG TotalNumberOfHandles; /* Total number of handles of this type */
ULONG HighWaterNumberOfObjects; /* Peak number of objects of this type */
ULONG HighWaterNumberOfHandles; /* Peak number of handles of this type */
OBJECT_TYPE_INITIALIZER TypeInfo; /* Information captured during type creation */
ULONG Key; /* Key to use when allocating objects of this type */
ERESOURCE ObjectLocks[4]; /* Locks for locking the Objects */
} OBJECT_TYPE;
typedef struct _OBJECT_HEADER
/*
* PURPOSE: Header for every object managed by the object manager
@@ -281,7 +197,9 @@ ObpSetHandleAttributes(HANDLE Handle,
POBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleInfo);
NTSTATUS
ObpCreateTypeObject(POBJECT_TYPE ObjectType);
ObpCreateTypeObject(POBJECT_TYPE_INITIALIZER ObjectTypeInitializer,
PUNICODE_STRING TypeName,
POBJECT_TYPE *ObjectType);
ULONG
ObGetObjectHandleCount(PVOID Object);
reactos/ntoskrnl/include/internal/port.h
+2 -2
View File
@@ -98,10 +98,10 @@ typedef struct _QUEUEDMESSAGE
/* Code in ntoskrnl/lpc/close.h */
VOID STDCALL
NiClosePort (PVOID ObjectBody,
LpcpClosePort (PVOID ObjectBody,
ULONG HandleCount);
VOID STDCALL
NiDeletePort (IN PVOID ObjectBody);
LpcpDeletePort (IN PVOID ObjectBody);
/* Code in ntoskrnl/lpc/queue.c */
reactos/ntoskrnl/io/driver.c
+16 -20
View File
@@ -85,29 +85,25 @@ IopDeleteDriver(PVOID ObjectBody);
/* PRIVATE FUNCTIONS **********************************************************/
VOID INIT_FUNCTION
VOID
INIT_FUNCTION
IopInitDriverImplementation(VOID)
{
/* Register the process object type */
IoDriverObjectType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
IoDriverObjectType->Tag = TAG('D', 'R', 'V', 'R');
IoDriverObjectType->TotalObjects = 0;
IoDriverObjectType->TotalHandles = 0;
IoDriverObjectType->PeakObjects = 0;
IoDriverObjectType->PeakHandles = 0;
IoDriverObjectType->PagedPoolCharge = 0;
IoDriverObjectType->NonpagedPoolCharge = sizeof(DRIVER_OBJECT);
IoDriverObjectType->Dump = NULL;
IoDriverObjectType->Open = NULL;
IoDriverObjectType->Close = NULL;
IoDriverObjectType->Delete = IopDeleteDriver;
IoDriverObjectType->Parse = NULL;
IoDriverObjectType->Security = NULL;
IoDriverObjectType->QueryName = NULL;
IoDriverObjectType->OkayToClose = NULL;
RtlInitUnicodeString(&IoDriverObjectType->TypeName, L"Driver");
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
UNICODE_STRING Name;
ObpCreateTypeObject(IoDriverObjectType);
DPRINT1("Creating Registry Object Type\n");
/* Initialize the Driver object type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"Driver");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(DRIVER_OBJECT);
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObjectTypeInitializer.DeleteProcedure = IopDeleteDriver;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &IoDriverObjectType);
InitializeListHead(&DriverReinitListHead);
KeInitializeSpinLock(&DriverReinitListLock);
reactos/ntoskrnl/io/file.c
+2 -2
View File
@@ -776,7 +776,7 @@ IoCreateFile(OUT PHANDLE FileHandle,
}
}
RtlMapGenericMask(&DesiredAccess,
BODY_TO_HEADER(FileObject)->ObjectType->Mapping);
&BODY_TO_HEADER(FileObject)->ObjectType->TypeInfo.GenericMapping);
Status = ObInsertObject ((PVOID)FileObject,
NULL,
@@ -2695,7 +2695,7 @@ NtSetInformationFile(HANDLE FileHandle,
/* Reference the Port */
Status = ObReferenceObjectByHandle(CompletionInfo->IoCompletionHandle,
IO_COMPLETION_MODIFY_STATE,
ExIoCompletionType,
IoCompletionType,
PreviousMode,
(PVOID*)&Queue,
NULL);
reactos/ntoskrnl/io/iocomp.c
+25 -28
View File
@@ -15,11 +15,11 @@
#define IOC_TAG TAG('I', 'O', 'C', 'T')
POBJECT_TYPE ExIoCompletionType;
POBJECT_TYPE IoCompletionType;
NPAGED_LOOKASIDE_LIST IoCompletionPacketLookaside;
static GENERIC_MAPPING ExIoCompletionMapping =
static GENERIC_MAPPING IopCompletionMapping =
{
STANDARD_RIGHTS_READ | IO_COMPLETION_QUERY_STATE,
STANDARD_RIGHTS_WRITE | IO_COMPLETION_MODIFY_STATE,
@@ -27,7 +27,7 @@ static GENERIC_MAPPING ExIoCompletionMapping =
IO_COMPLETION_ALL_ACCESS
};
static const INFORMATION_CLASS_INFO ExIoCompletionInfoClass[] = {
static const INFORMATION_CLASS_INFO IoCompletionInfoClass[] = {
/* IoCompletionBasicInformation */
ICI_SQ_SAME( sizeof(IO_COMPLETION_BASIC_INFORMATION), sizeof(ULONG), ICIF_QUERY ),
@@ -203,25 +203,22 @@ VOID
FASTCALL
IopInitIoCompletionImplementation(VOID)
{
/* Create the IO Completion Type */
ExIoCompletionType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
RtlInitUnicodeString(&ExIoCompletionType->TypeName, L"IoCompletion");
ExIoCompletionType->Tag = IOC_TAG;
ExIoCompletionType->PeakObjects = 0;
ExIoCompletionType->PeakHandles = 0;
ExIoCompletionType->TotalObjects = 0;
ExIoCompletionType->TotalHandles = 0;
ExIoCompletionType->PagedPoolCharge = 0;
ExIoCompletionType->NonpagedPoolCharge = sizeof(KQUEUE);
ExIoCompletionType->Mapping = &ExIoCompletionMapping;
ExIoCompletionType->Dump = NULL;
ExIoCompletionType->Open = NULL;
ExIoCompletionType->Close = NULL;
ExIoCompletionType->Delete = IopDeleteIoCompletion;
ExIoCompletionType->Parse = NULL;
ExIoCompletionType->Security = NULL;
ExIoCompletionType->QueryName = NULL;
ExIoCompletionType->OkayToClose = NULL;
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
UNICODE_STRING Name;
DPRINT1("Creating IoCompletion Object Type\n");
/* Initialize the Driver object type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"IoCompletion");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KQUEUE);
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.ValidAccessMask = IO_COMPLETION_ALL_ACCESS;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObjectTypeInitializer.GenericMapping = IopCompletionMapping;
ObjectTypeInitializer.DeleteProcedure = IopDeleteIoCompletion;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &IoCompletionType);
}
NTSTATUS
@@ -258,7 +255,7 @@ NtCreateIoCompletion(OUT PHANDLE IoCompletionHandle,
/* Create the Object */
Status = ObCreateObject(PreviousMode,
ExIoCompletionType,
IoCompletionType,
ObjectAttributes,
PreviousMode,
NULL,
@@ -330,7 +327,7 @@ NtOpenIoCompletion(OUT PHANDLE IoCompletionHandle,
/* Open the Object */
Status = ObOpenObjectByName(ObjectAttributes,
ExIoCompletionType,
IoCompletionType,
NULL,
PreviousMode,
DesiredAccess,
@@ -369,7 +366,7 @@ NtQueryIoCompletion(IN HANDLE IoCompletionHandle,
/* Check buffers and parameters */
DefaultQueryInfoBufferCheck(IoCompletionInformationClass,
ExIoCompletionInfoClass,
IoCompletionInfoClass,
IoCompletionInformation,
IoCompletionInformationLength,
ResultLength,
@@ -384,7 +381,7 @@ NtQueryIoCompletion(IN HANDLE IoCompletionHandle,
/* Get the Object */
Status = ObReferenceObjectByHandle(IoCompletionHandle,
IO_COMPLETION_QUERY_STATE,
ExIoCompletionType,
IoCompletionType,
PreviousMode,
(PVOID*)&Queue,
NULL);
@@ -468,7 +465,7 @@ NtRemoveIoCompletion(IN HANDLE IoCompletionHandle,
/* Open the Object */
Status = ObReferenceObjectByHandle(IoCompletionHandle,
IO_COMPLETION_MODIFY_STATE,
ExIoCompletionType,
IoCompletionType,
PreviousMode,
(PVOID*)&Queue,
NULL);
@@ -549,7 +546,7 @@ NtSetIoCompletion(IN HANDLE IoCompletionPortHandle,
/* Get the Object */
Status = ObReferenceObjectByHandle(IoCompletionPortHandle,
IO_COMPLETION_MODIFY_STATE,
ExIoCompletionType,
IoCompletionType,
ExGetPreviousMode(),
(PVOID*)&Queue,
NULL);
reactos/ntoskrnl/io/iomgr.c
+39 -71
View File
@@ -29,6 +29,7 @@
POBJECT_TYPE EXPORTED IoDeviceObjectType = NULL;
POBJECT_TYPE EXPORTED IoFileObjectType = NULL;
extern POBJECT_TYPE IoControllerObjectType;
ULONG EXPORTED IoReadOperationCount = 0;
ULONGLONG EXPORTED IoReadTransferCount = 0;
ULONG EXPORTED IoWriteOperationCount = 0;
@@ -188,79 +189,46 @@ VOID
INIT_FUNCTION
IoInit (VOID)
{
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING DirName;
UNICODE_STRING LinkName;
HANDLE Handle;
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
UNICODE_STRING Name;
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING DirName;
UNICODE_STRING LinkName;
HANDLE Handle;
IopInitDriverImplementation();
IopInitDriverImplementation();
/*
* Register iomgr types: DeviceObjectType
*/
IoDeviceObjectType = ExAllocatePool (NonPagedPool,
sizeof (OBJECT_TYPE));
IoDeviceObjectType->Tag = TAG_DEVICE_TYPE;
IoDeviceObjectType->TotalObjects = 0;
IoDeviceObjectType->TotalHandles = 0;
IoDeviceObjectType->PeakObjects = 0;
IoDeviceObjectType->PeakHandles = 0;
IoDeviceObjectType->PagedPoolCharge = 0;
IoDeviceObjectType->NonpagedPoolCharge = sizeof (DEVICE_OBJECT);
IoDeviceObjectType->Mapping = &IopFileMapping;
IoDeviceObjectType->Dump = NULL;
IoDeviceObjectType->Open = NULL;
IoDeviceObjectType->Close = NULL;
IoDeviceObjectType->Delete = NULL;
IoDeviceObjectType->Parse = NULL;
IoDeviceObjectType->Security = NULL;
IoDeviceObjectType->QueryName = NULL;
IoDeviceObjectType->OkayToClose = NULL;
RtlInitUnicodeString(&IoDeviceObjectType->TypeName, L"Device");
ObpCreateTypeObject(IoDeviceObjectType);
/*
* Register iomgr types: FileObjectType
* (alias DriverObjectType)
*/
IoFileObjectType = ExAllocatePool (NonPagedPool, sizeof (OBJECT_TYPE));
IoFileObjectType->Tag = TAG_FILE_TYPE;
IoFileObjectType->TotalObjects = 0;
IoFileObjectType->TotalHandles = 0;
IoFileObjectType->PeakObjects = 0;
IoFileObjectType->PeakHandles = 0;
IoFileObjectType->PagedPoolCharge = 0;
IoFileObjectType->NonpagedPoolCharge = sizeof(FILE_OBJECT);
IoFileObjectType->Mapping = &IopFileMapping;
IoFileObjectType->Dump = NULL;
IoFileObjectType->Open = NULL;
IoFileObjectType->Close = IopCloseFile;
IoFileObjectType->Delete = IopDeleteFile;
IoFileObjectType->Parse = NULL;
IoFileObjectType->Security = IopSecurityFile;
IoFileObjectType->QueryName = IopQueryNameFile;
IoFileObjectType->OkayToClose = NULL;
RtlInitUnicodeString(&IoFileObjectType->TypeName, L"File");
ObpCreateTypeObject(IoFileObjectType);
/*
* Register iomgr types: AdapterObjectType
*/
IoAdapterObjectType = ExAllocatePool (NonPagedPool,
sizeof (OBJECT_TYPE));
RtlZeroMemory(IoAdapterObjectType, sizeof(OBJECT_TYPE));
IoAdapterObjectType->Tag = TAG_ADAPTER_TYPE;
IoAdapterObjectType->PeakObjects = 0;
IoAdapterObjectType->PeakHandles = 0;
IoDeviceObjectType->Mapping = &IopFileMapping;
RtlInitUnicodeString(&IoAdapterObjectType->TypeName, L"Adapter");
ObpCreateTypeObject(IoAdapterObjectType);
DPRINT1("Creating Device Object Type\n");
/* Initialize the Driver object type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"Device");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(DEVICE_OBJECT);
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.ValidAccessMask = FILE_ALL_ACCESS;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObjectTypeInitializer.GenericMapping = IopFileMapping;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &IoDeviceObjectType);
/* Do the Adapter Type */
RtlInitUnicodeString(&Name, L"Adapter");
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &IoAdapterObjectType);
/* Do the Controller Type */
RtlInitUnicodeString(&Name, L"Controller");
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(CONTROLLER_OBJECT);
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &IoControllerObjectType);
/* Initialize the File object type */
RtlInitUnicodeString(&Name, L"File");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(FILE_OBJECT);
ObjectTypeInitializer.CloseProcedure = IopCloseFile;
ObjectTypeInitializer.DeleteProcedure = IopDeleteFile;
ObjectTypeInitializer.SecurityProcedure = IopSecurityFile;
ObjectTypeInitializer.QueryNameProcedure = IopQueryNameFile;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &IoFileObjectType);
/*
* Create the '\Driver' object directory
reactos/ntoskrnl/io/share.c
+1 -1
View File
@@ -198,7 +198,7 @@ IoCheckDesiredAccess(IN OUT PACCESS_MASK DesiredAccess,
PAGED_CODE();
RtlMapGenericMask(DesiredAccess,
IoFileObjectType->Mapping);
&IoFileObjectType->TypeInfo.GenericMapping);
if ((~(*DesiredAccess) & GrantedAccess) != 0)
return STATUS_ACCESS_DENIED;
reactos/ntoskrnl/ke/wait.c
+1 -1
View File
@@ -800,7 +800,7 @@ KiIsObjectWaitable(PVOID Object)
Header = BODY_TO_HEADER(Object);
if (Header->ObjectType == ExEventObjectType ||
Header->ObjectType == ExIoCompletionType ||
Header->ObjectType == IoCompletionType ||
Header->ObjectType == ExMutantObjectType ||
Header->ObjectType == ExSemaphoreObjectType ||
Header->ObjectType == ExTimerType ||
reactos/ntoskrnl/lpc/close.c
+2 -2
View File
@@ -28,7 +28,7 @@
* REVISIONS
*/
VOID STDCALL
NiClosePort (PVOID ObjectBody, ULONG HandleCount)
LpcpClosePort (PVOID ObjectBody, ULONG HandleCount)
{
PEPORT Port = (PEPORT)ObjectBody;
LPC_MESSAGE Message;
@@ -85,7 +85,7 @@ NiClosePort (PVOID ObjectBody, ULONG HandleCount)
* REVISIONS
*/
VOID STDCALL
NiDeletePort (PVOID ObjectBody)
LpcpDeletePort (PVOID ObjectBody)
{
// PEPORT Port = (PEPORT)ObjectBody;
reactos/ntoskrnl/lpc/port.c
+26 -34
View File
@@ -21,11 +21,13 @@ POBJECT_TYPE LpcPortObjectType = 0;
ULONG LpcpNextMessageId = 0; /* 0 is not a valid ID */
FAST_MUTEX LpcpLock; /* global internal sync in LPC facility */
static GENERIC_MAPPING ExpPortMapping = {
STANDARD_RIGHTS_READ,
STANDARD_RIGHTS_WRITE,
0,
PORT_ALL_ACCESS};
static GENERIC_MAPPING LpcpPortMapping =
{
STANDARD_RIGHTS_READ,
STANDARD_RIGHTS_WRITE,
0,
PORT_ALL_ACCESS
};
/* FUNCTIONS *****************************************************************/
@@ -33,37 +35,27 @@ static GENERIC_MAPPING ExpPortMapping = {
NTSTATUS INIT_FUNCTION
LpcpInitSystem (VOID)
{
/* Allocate Memory for the LPC Object */
LpcPortObjectType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
RtlZeroMemory (LpcPortObjectType, sizeof (OBJECT_TYPE));
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
UNICODE_STRING Name;
RtlInitUnicodeString(&LpcPortObjectType->TypeName,L"Port");
DPRINT1("Creating Port Object Type\n");
/* Create the window station Object Type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"Port");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(EPORT);
ObjectTypeInitializer.GenericMapping = LpcpPortMapping;
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObjectTypeInitializer.CloseProcedure = LpcpClosePort;
ObjectTypeInitializer.DeleteProcedure = LpcpDeletePort;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &LpcPortObjectType);
LpcpNextMessageId = 0;
ExInitializeFastMutex (& LpcpLock);
LpcPortObjectType->Tag = TAG('L', 'P', 'R', 'T');
LpcPortObjectType->PeakObjects = 0;
LpcPortObjectType->PeakHandles = 0;
LpcPortObjectType->TotalObjects = 0;
LpcPortObjectType->TotalHandles = 0;
LpcPortObjectType->PagedPoolCharge = 0;
LpcPortObjectType->NonpagedPoolCharge = sizeof(EPORT);
LpcPortObjectType->Mapping = &ExpPortMapping;
LpcPortObjectType->Dump = NULL;
LpcPortObjectType->Open = NULL;
LpcPortObjectType->Close = NiClosePort;
LpcPortObjectType->Delete = NiDeletePort;
LpcPortObjectType->Parse = NULL;
LpcPortObjectType->Security = NULL;
LpcPortObjectType->QueryName = NULL;
LpcPortObjectType->Open = NULL;
LpcPortObjectType->OkayToClose = NULL;
ObpCreateTypeObject(LpcPortObjectType);
LpcpNextMessageId = 0;
ExInitializeFastMutex (& LpcpLock);
return(STATUS_SUCCESS);
return(STATUS_SUCCESS);
}
reactos/ntoskrnl/mm/section.c
+15 -27
View File
@@ -2107,34 +2107,22 @@ MmCreatePhysicalMemorySection(VOID)
NTSTATUS INIT_FUNCTION
MmInitSectionImplementation(VOID)
{
MmSectionObjectType = ExAllocatePool(NonPagedPool,sizeof(OBJECT_TYPE));
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
UNICODE_STRING Name;
RtlInitUnicodeString(&MmSectionObjectType->TypeName, L"Section");
MmSectionObjectType->Tag = TAG('S', 'E', 'C', 'T');
MmSectionObjectType->TotalObjects = 0;
MmSectionObjectType->TotalHandles = 0;
MmSectionObjectType->PeakObjects = 0;
MmSectionObjectType->PeakHandles = 0;
MmSectionObjectType->PagedPoolCharge = 0;
MmSectionObjectType->NonpagedPoolCharge = sizeof(SECTION_OBJECT);
MmSectionObjectType->Mapping = &MmpSectionMapping;
MmSectionObjectType->Dump = NULL;
MmSectionObjectType->Open = NULL;
MmSectionObjectType->Close = MmpCloseSection;
MmSectionObjectType->Delete = MmpDeleteSection;
MmSectionObjectType->Parse = NULL;
MmSectionObjectType->Open = NULL;
MmSectionObjectType->Security = NULL;
MmSectionObjectType->QueryName = NULL;
MmSectionObjectType->OkayToClose = NULL;
/*
* NOTE: Do not register the section object type here because
* the object manager it not initialized yet!
* The section object type will be created in ObInit().
*/
ObpCreateTypeObject(MmSectionObjectType);
DPRINT1("Creating Section Object Type\n");
/* Initialize the Section object type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"Section");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(SECTION_OBJECT);
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObjectTypeInitializer.GenericMapping = MmpSectionMapping;
ObjectTypeInitializer.DeleteProcedure = MmpDeleteSection;
ObjectTypeInitializer.CloseProcedure = MmpCloseSection;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &MmSectionObjectType);
return(STATUS_SUCCESS);
}
reactos/ntoskrnl/ob/dirobj.c
+2 -2
View File
@@ -254,10 +254,10 @@ NtQueryDirectoryObject (IN HANDLE DirectoryHandle,
/* calculate the size of the required buffer space for this entry */
Name = (EntryHeader->Name.Length != 0 ? &EntryHeader->Name : NULL);
Type = &EntryHeader->ObjectType->TypeName;
Type = &EntryHeader->ObjectType->Name;
EntrySize = sizeof(OBJECT_DIRECTORY_INFORMATION) +
((Name != NULL) ? ((ULONG)Name->Length + sizeof(WCHAR)) : 0) +
(ULONG)EntryHeader->ObjectType->TypeName.Length + sizeof(WCHAR);
(ULONG)EntryHeader->ObjectType->Name.Length + sizeof(WCHAR);
if(RequiredSize + EntrySize <= BufferLength)
{
reactos/ntoskrnl/ob/handle.c
+6 -6
View File
@@ -55,11 +55,11 @@ ObpDecrementHandleCount(PVOID ObjectBody)
LONG NewHandleCount = InterlockedDecrement(&ObjectHeader->HandleCount);
if ((ObjectHeader->ObjectType != NULL) &&
(ObjectHeader->ObjectType->Close != NULL))
(ObjectHeader->ObjectType->TypeInfo.CloseProcedure != NULL))
{
/* the handle count should be decremented but we pass the previous value
to the callback */
ObjectHeader->ObjectType->Close(ObjectBody, NewHandleCount + 1);
ObjectHeader->ObjectType->TypeInfo.CloseProcedure(ObjectBody, NewHandleCount + 1);
}
if(NewHandleCount == 0)
@@ -287,7 +287,7 @@ ObDuplicateObject(PEPROCESS SourceProcess,
if (DesiredAccess & GENERIC_ANY)
{
RtlMapGenericMask(&DesiredAccess,
ObjectHeader->ObjectType->Mapping);
&ObjectHeader->ObjectType->TypeInfo.GenericMapping);
}
NewHandleEntry.u2.GrantedAccess = DesiredAccess;
}
@@ -456,7 +456,7 @@ NtDuplicateObject (IN HANDLE SourceProcessHandle,
if (DesiredAccess & GENERIC_ANY)
{
RtlMapGenericMask(&DesiredAccess,
ObjectType->Mapping);
&ObjectType->TypeInfo.GenericMapping);
}
}
Status = ObpCreateHandle(TargetProcess,
@@ -623,7 +623,7 @@ ObpCreateHandle(PEPROCESS Process,
if (GrantedAccess & GENERIC_ANY)
{
RtlMapGenericMask(&GrantedAccess,
ObjectHeader->ObjectType->Mapping);
&ObjectHeader->ObjectType->TypeInfo.GenericMapping);
}
NewEntry.u1.Object = ObjectHeader;
@@ -830,7 +830,7 @@ ObReferenceObjectByHandle(HANDLE Handle,
if (DesiredAccess & GENERIC_ANY)
{
RtlMapGenericMask(&DesiredAccess,
BODY_TO_HEADER(ObjectBody)->ObjectType->Mapping);
&BODY_TO_HEADER(ObjectBody)->ObjectType->TypeInfo.GenericMapping);
}
GrantedAccess = HandleEntry->u2.GrantedAccess;
reactos/ntoskrnl/ob/namespc.c
+97 -68
View File
@@ -367,6 +367,43 @@ ObpParseDirectory(PVOID Object,
return STATUS_SUCCESS;
}
/* HACKS FOR COMPATIBILITY. TEMPORARY */
NTSTATUS
ObpCreateInitTypeObject(POBJECT_TYPE ObjectType)
{
OBJECT_ATTRIBUTES ObjectAttributes;
WCHAR NameString[120];
PTYPE_OBJECT TypeObject = NULL;
UNICODE_STRING Name;
NTSTATUS Status;
DPRINT("ObpCreateTypeObject(ObjectType: %wZ)\n", &ObjectType->Name);
wcscpy(NameString, L"\\ObjectTypes\\");
wcscat(NameString, ObjectType->Name.Buffer);
RtlInitUnicodeString(&Name,
NameString);
InitializeObjectAttributes(&ObjectAttributes,
&Name,
OBJ_PERMANENT,
NULL,
NULL);
Status = ObCreateObject(KernelMode,
ObTypeObjectType,
&ObjectAttributes,
KernelMode,
NULL,
sizeof(TYPE_OBJECT),
0,
0,
(PVOID*)&TypeObject);
if (NT_SUCCESS(Status))
{
TypeObject->ObjectType = ObjectType;
}
return(STATUS_SUCCESS);
}
VOID INIT_FUNCTION
ObInit(VOID)
@@ -381,51 +418,27 @@ ObInit(VOID)
/* Initialize the security descriptor cache */
ObpInitSdCache();
/* HACKS FOR COMPATIBILITY. TEMPORARY */
/* create 'directory' object type */
ObDirectoryType = ExAllocatePool(NonPagedPool,sizeof(OBJECT_TYPE));
RtlZeroMemory(ObDirectoryType, sizeof(OBJECT_TYPE));
ObDirectoryType->TypeInfo.DefaultNonPagedPoolCharge = sizeof(DIRECTORY_OBJECT);
ObDirectoryType->TypeInfo.GenericMapping = ObpDirectoryMapping;
ObDirectoryType->TypeInfo.ParseProcedure = ObpParseDirectory;
ObDirectoryType->TypeInfo.OpenProcedure = ObpCreateDirectory;
ObDirectoryType->Tag = TAG('D', 'I', 'R', 'T');
ObDirectoryType->TotalObjects = 0;
ObDirectoryType->TotalHandles = 0;
ObDirectoryType->PeakObjects = 0;
ObDirectoryType->PeakHandles = 0;
ObDirectoryType->PagedPoolCharge = 0;
ObDirectoryType->NonpagedPoolCharge = sizeof(DIRECTORY_OBJECT);
ObDirectoryType->Mapping = &ObpDirectoryMapping;
ObDirectoryType->Dump = NULL;
ObDirectoryType->Open = NULL;
ObDirectoryType->Close = NULL;
ObDirectoryType->Delete = NULL;
ObDirectoryType->Parse = ObpParseDirectory;
ObDirectoryType->Security = NULL;
ObDirectoryType->QueryName = NULL;
ObDirectoryType->OkayToClose = NULL;
ObDirectoryType->Open = ObpCreateDirectory;
RtlInitUnicodeString(&ObDirectoryType->TypeName,
RtlInitUnicodeString(&ObDirectoryType->Name,
L"Directory");
/* HACKS FOR COMPATIBILITY. TEMPORARY */
/* create 'type' object type*/
ObTypeObjectType = ExAllocatePool(NonPagedPool,sizeof(OBJECT_TYPE));
RtlZeroMemory(ObTypeObjectType, sizeof(OBJECT_TYPE));
ObTypeObjectType->TypeInfo.DefaultNonPagedPoolCharge = sizeof(TYPE_OBJECT);
ObTypeObjectType->TypeInfo.GenericMapping = ObpTypeMapping;
ObTypeObjectType->Tag = TAG('T', 'y', 'p', 'T');
ObTypeObjectType->TotalObjects = 0;
ObTypeObjectType->TotalHandles = 0;
ObTypeObjectType->PeakObjects = 0;
ObTypeObjectType->PeakHandles = 0;
ObTypeObjectType->PagedPoolCharge = 0;
ObTypeObjectType->NonpagedPoolCharge = sizeof(TYPE_OBJECT);
ObTypeObjectType->Mapping = &ObpTypeMapping;
ObTypeObjectType->Dump = NULL;
ObTypeObjectType->Open = NULL;
ObTypeObjectType->Close = NULL;
ObTypeObjectType->Delete = NULL;
ObTypeObjectType->Parse = NULL;
ObTypeObjectType->Security = NULL;
ObTypeObjectType->QueryName = NULL;
ObTypeObjectType->OkayToClose = NULL;
RtlInitUnicodeString(&ObTypeObjectType->TypeName,
RtlInitUnicodeString(&ObTypeObjectType->Name,
L"ObjectType");
/* Create security descriptor */
@@ -479,8 +492,9 @@ ObInit(VOID)
0,
NULL);
ObpCreateTypeObject(ObDirectoryType);
ObpCreateTypeObject(ObTypeObjectType);
/* HACKS FOR COMPATIBILITY. TEMPORARY */
ObpCreateInitTypeObject(ObDirectoryType);
ObpCreateInitTypeObject(ObTypeObjectType);
/* Create 'symbolic link' object type */
ObInitSymbolicLinkImplementation();
@@ -492,40 +506,55 @@ ObInit(VOID)
NTSTATUS
ObpCreateTypeObject(POBJECT_TYPE ObjectType)
ObpCreateTypeObject(POBJECT_TYPE_INITIALIZER ObjectTypeInitializer,
PUNICODE_STRING TypeName,
POBJECT_TYPE *ObjectType)
{
OBJECT_ATTRIBUTES ObjectAttributes;
WCHAR NameString[120];
PTYPE_OBJECT TypeObject = NULL;
UNICODE_STRING Name;
NTSTATUS Status;
OBJECT_ATTRIBUTES ObjectAttributes;
WCHAR NameString[120];
PTYPE_OBJECT TypeObject = NULL;
POBJECT_TYPE LocalObjectType;
UNICODE_STRING Name;
NTSTATUS Status;
DPRINT("ObpCreateTypeObject(ObjectType: %wZ)\n", &ObjectType->TypeName);
wcscpy(NameString, L"\\ObjectTypes\\");
wcscat(NameString, ObjectType->TypeName.Buffer);
RtlInitUnicodeString(&Name,
NameString);
InitializeObjectAttributes(&ObjectAttributes,
&Name,
OBJ_PERMANENT,
NULL,
NULL);
Status = ObCreateObject(KernelMode,
ObTypeObjectType,
&ObjectAttributes,
KernelMode,
NULL,
sizeof(TYPE_OBJECT),
0,
0,
(PVOID*)&TypeObject);
if (NT_SUCCESS(Status))
DPRINT("ObpCreateTypeObject(ObjectType: %wZ)\n", TypeName);
/* Set up the Name */
wcscpy(NameString, L"\\ObjectTypes\\");
wcscat(NameString, TypeName->Buffer);
RtlInitUnicodeString(&Name, NameString);
/* Allocate the Object Type */
LocalObjectType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
/* Set it up */
LocalObjectType->TypeInfo = *ObjectTypeInitializer;
LocalObjectType->Name = *TypeName;
/* FIXME: Generate Tag */
/* Create the Object Type Type (WRONG, it shoudl be OBJECT_TYPE itself!) */
InitializeObjectAttributes(&ObjectAttributes,
&Name,
OBJ_PERMANENT,
NULL,
NULL);
Status = ObCreateObject(KernelMode,
ObTypeObjectType,
&ObjectAttributes,
KernelMode,
NULL,
sizeof(TYPE_OBJECT),
0,
0,
(PVOID*)&TypeObject);
if (NT_SUCCESS(Status))
{
TypeObject->ObjectType = ObjectType;
TypeObject->ObjectType = LocalObjectType;
*ObjectType = LocalObjectType;
}
return(STATUS_SUCCESS);
}
return Status;
}
/* EOF */
reactos/ntoskrnl/ob/object.c
+16 -16
View File
@@ -481,12 +481,12 @@ ObFindObject(POBJECT_ATTRIBUTES ObjectAttributes,
DPRINT("Current ObjectType %wZ\n",
&CurrentHeader->ObjectType->TypeName);
if (CurrentHeader->ObjectType->Parse == NULL)
if (CurrentHeader->ObjectType->TypeInfo.ParseProcedure == NULL)
{
DPRINT("Current object can't parse\n");
break;
}
Status = CurrentHeader->ObjectType->Parse(CurrentObject,
Status = CurrentHeader->ObjectType->TypeInfo.ParseProcedure(CurrentObject,
&NextObject,
&PathString,
&current,
@@ -559,10 +559,10 @@ ObQueryNameString (IN PVOID Object,
ObjectHeader = BODY_TO_HEADER(Object);
if (ObjectHeader->ObjectType != NULL &&
ObjectHeader->ObjectType->QueryName != NULL)
ObjectHeader->ObjectType->TypeInfo.QueryNameProcedure != NULL)
{
DPRINT ("Calling %x\n", ObjectHeader->ObjectType->QueryName);
Status = ObjectHeader->ObjectType->QueryName (Object,
DPRINT ("Calling %x\n", ObjectHeader->ObjectType->TypeInfo.QueryNameProcedure);
Status = ObjectHeader->ObjectType->TypeInfo.QueryNameProcedure (Object,
ObjectNameInfo,
Length,
ReturnLength);
@@ -742,7 +742,7 @@ ObCreateObject (IN KPROCESSOR_MODE ObjectAttributesAccessMode OPTIONAL,
DPRINT("Allocating memory\n");
Header = (POBJECT_HEADER)ExAllocatePoolWithTag(NonPagedPool,
OBJECT_ALLOC_SIZE(ObjectSize),
Type->Tag);
Type->Key);
if (Header == NULL) {
DPRINT1("Not enough memory!\n");
return STATUS_INSUFFICIENT_RESOURCES;
@@ -795,7 +795,7 @@ ObCreateObject (IN KPROCESSOR_MODE ObjectAttributesAccessMode OPTIONAL,
if ((Header->ObjectType == IoFileObjectType) ||
(Header->ObjectType == ExDesktopObjectType) ||
(Header->ObjectType->Open != NULL))
(Header->ObjectType->TypeInfo.OpenProcedure != NULL))
{
DPRINT("About to call Open Routine\n");
if (Header->ObjectType == IoFileObjectType)
@@ -816,10 +816,10 @@ ObCreateObject (IN KPROCESSOR_MODE ObjectAttributesAccessMode OPTIONAL,
RemainingPath.Buffer,
ObjectAttributes);
}
else if (Header->ObjectType->Open != NULL)
else if (Header->ObjectType->TypeInfo.OpenProcedure != NULL)
{
DPRINT("Calling %x\n", Header->ObjectType->Open);
Status = Header->ObjectType->Open(ObCreateHandle,
DPRINT("Calling %x\n", Header->ObjectType->TypeInfo.OpenProcedure);
Status = Header->ObjectType->TypeInfo.OpenProcedure(ObCreateHandle,
HEADER_TO_BODY(Header),
NULL,
0,
@@ -855,16 +855,16 @@ ObCreateObject (IN KPROCESSOR_MODE ObjectAttributesAccessMode OPTIONAL,
&NewSecurityDescriptor,
(Header->ObjectType == ObDirectoryType),
&SubjectContext,
Header->ObjectType->Mapping,
&Header->ObjectType->TypeInfo.GenericMapping,
PagedPool);
if (NT_SUCCESS(Status))
{
DPRINT("NewSecurityDescriptor %p\n", NewSecurityDescriptor);
if (Header->ObjectType->Security != NULL)
if (Header->ObjectType->TypeInfo.SecurityProcedure != NULL)
{
/* Call the security method */
Status = Header->ObjectType->Security(HEADER_TO_BODY(Header),
Status = Header->ObjectType->TypeInfo.SecurityProcedure(HEADER_TO_BODY(Header),
AssignSecurityDescriptor,
0,
NewSecurityDescriptor,
@@ -1021,9 +1021,9 @@ ObpDeleteObject(POBJECT_HEADER Header)
}
if (Header->ObjectType != NULL &&
Header->ObjectType->Delete != NULL)
Header->ObjectType->TypeInfo.DeleteProcedure != NULL)
{
Header->ObjectType->Delete(HEADER_TO_BODY(Header));
Header->ObjectType->TypeInfo.DeleteProcedure(HEADER_TO_BODY(Header));
}
if (Header->Name.Buffer != NULL)
@@ -1096,7 +1096,7 @@ ObpDeleteObjectDpcLevel(IN POBJECT_HEADER ObjectHeader,
Params = (PRETENTION_CHECK_PARAMS)
ExAllocatePoolWithTag(NonPagedPoolMustSucceed,
sizeof(RETENTION_CHECK_PARAMS),
ObjectHeader->ObjectType->Tag);
ObjectHeader->ObjectType->Key);
Params->ObjectHeader = ObjectHeader;
ExInitializeWorkItem(&Params->WorkItem,
ObpDeleteObjectWorkRoutine,
reactos/ntoskrnl/ob/security.c
+10 -10
View File
@@ -36,15 +36,15 @@ ObAssignSecurity(IN PACCESS_STATE AccessState,
&NewDescriptor,
(Type == ObDirectoryType),
&AccessState->SubjectSecurityContext,
Type->Mapping,
&Type->TypeInfo.GenericMapping,
PagedPool);
if (!NT_SUCCESS(Status))
return Status;
if (Type->Security != NULL)
if (Type->TypeInfo.SecurityProcedure != NULL)
{
/* Call the security method */
Status = Type->Security(Object,
Status = Type->TypeInfo.SecurityProcedure(Object,
AssignSecurityDescriptor,
0,
NewDescriptor,
@@ -82,7 +82,7 @@ ObGetObjectSecurity(IN PVOID Object,
if (Header->ObjectType == NULL)
return STATUS_UNSUCCESSFUL;
if (Header->ObjectType->Security == NULL)
if (Header->ObjectType->TypeInfo.SecurityProcedure == NULL)
{
ObpReferenceCachedSecurityDescriptor(Header->SecurityDescriptor);
*SecurityDescriptor = Header->SecurityDescriptor;
@@ -92,7 +92,7 @@ ObGetObjectSecurity(IN PVOID Object,
/* Get the security descriptor size */
Length = 0;
Status = Header->ObjectType->Security(Object,
Status = Header->ObjectType->TypeInfo.SecurityProcedure(Object,
QuerySecurityDescriptor,
OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION,
@@ -108,7 +108,7 @@ ObGetObjectSecurity(IN PVOID Object,
return STATUS_INSUFFICIENT_RESOURCES;
/* Query security descriptor */
Status = Header->ObjectType->Security(Object,
Status = Header->ObjectType->TypeInfo.SecurityProcedure(Object,
QuerySecurityDescriptor,
OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION,
@@ -187,10 +187,10 @@ NtQuerySecurityObject(IN HANDLE Handle,
return STATUS_UNSUCCESSFUL;
}
if (Header->ObjectType->Security != NULL)
if (Header->ObjectType->TypeInfo.SecurityProcedure != NULL)
{
*ResultLength = Length;
Status = Header->ObjectType->Security(Object,
Status = Header->ObjectType->TypeInfo.SecurityProcedure(Object,
QuerySecurityDescriptor,
SecurityInformation,
SecurityDescriptor,
@@ -259,9 +259,9 @@ NtSetSecurityObject(IN HANDLE Handle,
return STATUS_UNSUCCESSFUL;
}
if (Header->ObjectType->Security != NULL)
if (Header->ObjectType->TypeInfo.SecurityProcedure != NULL)
{
Status = Header->ObjectType->Security(Object,
Status = Header->ObjectType->TypeInfo.SecurityProcedure(Object,
SetSecurityDescriptor,
SecurityInformation,
SecurityDescriptor,
reactos/ntoskrnl/ob/symlink.c
+19 -25
View File
@@ -133,33 +133,27 @@ ObpParseSymbolicLink(PVOID Object,
*
* REVISIONS
*/
VOID INIT_FUNCTION
VOID
INIT_FUNCTION
ObInitSymbolicLinkImplementation (VOID)
{
ObSymbolicLinkType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
ObSymbolicLinkType->Tag = TAG('S', 'Y', 'M', 'T');
ObSymbolicLinkType->TotalObjects = 0;
ObSymbolicLinkType->TotalHandles = 0;
ObSymbolicLinkType->PeakObjects = 0;
ObSymbolicLinkType->PeakHandles = 0;
ObSymbolicLinkType->PagedPoolCharge = 0;
ObSymbolicLinkType->NonpagedPoolCharge = sizeof(SYMLINK_OBJECT);
ObSymbolicLinkType->Mapping = &ObpSymbolicLinkMapping;
ObSymbolicLinkType->Dump = NULL;
ObSymbolicLinkType->Open = NULL;
ObSymbolicLinkType->Close = NULL;
ObSymbolicLinkType->Delete = ObpDeleteSymbolicLink;
ObSymbolicLinkType->Parse = ObpParseSymbolicLink;
ObSymbolicLinkType->Security = NULL;
ObSymbolicLinkType->Open = NULL;
ObSymbolicLinkType->QueryName = NULL;
ObSymbolicLinkType->OkayToClose = NULL;
RtlInitUnicodeString(&ObSymbolicLinkType->TypeName,
L"SymbolicLink");
ObpCreateTypeObject(ObSymbolicLinkType);
UNICODE_STRING Name;
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
DPRINT1("Creating SymLink Object Type\n");
/* Initialize the Directory type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"SymbolicLink");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(SYMLINK_OBJECT);
ObjectTypeInitializer.GenericMapping = ObpSymbolicLinkMapping;
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.ValidAccessMask = SYMBOLIC_LINK_ALL_ACCESS;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObjectTypeInitializer.ParseProcedure = ObpParseSymbolicLink;
ObjectTypeInitializer.DeleteProcedure = ObpDeleteSymbolicLink;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &ObSymbolicLinkType);
}
reactos/ntoskrnl/ob/wait.c
+2 -2
View File
@@ -91,7 +91,7 @@ NtWaitForMultipleObjects(IN ULONG ObjectCount,
if (NT_SUCCESS(Status))
{
DPRINT1("Waiting for object type '%wZ' is not supported\n",
&BODY_TO_HEADER(ObjectPtrArray[i])->ObjectType->TypeName);
&BODY_TO_HEADER(ObjectPtrArray[i])->ObjectType->Name);
Status = STATUS_HANDLE_NOT_WAITABLE;
i++;
}
@@ -178,7 +178,7 @@ NtWaitForSingleObject(IN HANDLE ObjectHandle,
if (!KiIsObjectWaitable(ObjectPtr))
{
DPRINT1("Waiting for object type '%wZ' is not supported\n",
&BODY_TO_HEADER(ObjectPtr)->ObjectType->TypeName);
&BODY_TO_HEADER(ObjectPtr)->ObjectType->Name);
Status = STATUS_HANDLE_NOT_WAITABLE;
}
else
reactos/ntoskrnl/ps/cid.c
+2 -2
View File
@@ -48,7 +48,7 @@ PsCreateCidHandle(PVOID Object, POBJECT_TYPE ObjectType, PHANDLE Handle)
NewEntry.u2.GrantedAccess = CID_FLAG_PROCESS;
else
{
DPRINT1("Can't create CID handles for %wZ objects\n", &ObjectType->TypeName);
DPRINT1("Can't create CID handles for %wZ objects\n", &ObjectType->Name);
KEBUGCHECK(0);
}
@@ -120,7 +120,7 @@ PsLookupCidHandle(HANDLE CidHandle, POBJECT_TYPE ObjectType, PVOID *Object)
else
{
DPRINT1("CID Obj type mismatch handle 0x%x %wZ vs 0x%x\n", CidHandle,
&ObjectType->TypeName, Entry->u2.GrantedAccess);
&ObjectType->Name, Entry->u2.GrantedAccess);
ExUnlockHandleTableEntry(PspCidTable,
Entry);
}
reactos/ntoskrnl/ps/job.c
+18 -25
View File
@@ -56,33 +56,26 @@ PiDeleteJob ( PVOID ObjectBody )
ExDeleteResource(&Job->JobLock);
}
VOID INIT_FUNCTION
VOID
INIT_FUNCTION
PsInitJobManagment ( VOID )
{
PsJobType = ExAllocatePoolWithTag (
NonPagedPool, sizeof(OBJECT_TYPE), TAG_EJOB );
PsJobType->Tag = TAG_EJOB;
PsJobType->TotalObjects = 0;
PsJobType->TotalHandles = 0;
PsJobType->PeakObjects = 0;
PsJobType->PeakHandles = 0;
PsJobType->PagedPoolCharge = 0;
PsJobType->NonpagedPoolCharge = sizeof(EJOB);
PsJobType->Mapping = &PiJobMapping;
PsJobType->Dump = NULL;
PsJobType->Open = NULL;
PsJobType->Close = NULL;
PsJobType->Delete = PiDeleteJob;
PsJobType->Parse = NULL;
PsJobType->Security = NULL;
PsJobType->QueryName = NULL;
PsJobType->OkayToClose = NULL;
PsJobType->Open = NULL;
RtlInitUnicodeString(&PsJobType->TypeName, L"Job");
ObpCreateTypeObject(PsJobType);
UNICODE_STRING Name;
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
DPRINT1("Creating Job Object Type\n");
/* Initialize the Job type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"Job");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(EJOB);
ObjectTypeInitializer.GenericMapping = PiJobMapping;
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.ValidAccessMask = JOB_OBJECT_ALL_ACCESS;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObjectTypeInitializer.DeleteProcedure = PiDeleteJob;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &PsJobType);
InitializeListHead(&PsJobListHead);
ExInitializeFastMutex(&PsJobListLock);
reactos/ntoskrnl/ps/psmgr.c
+30 -46
View File
@@ -71,6 +71,8 @@ PsInitThreadManagment(VOID)
* FUNCTION: Initialize thread managment
*/
{
UNICODE_STRING Name;
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
PETHREAD FirstThread;
ULONG i;
@@ -79,29 +81,19 @@ PsInitThreadManagment(VOID)
InitializeListHead(&PriorityListHead[i]);
}
PsThreadType = ExAllocatePool(NonPagedPool,sizeof(OBJECT_TYPE));
PsThreadType->Tag = TAG('T', 'H', 'R', 'T');
PsThreadType->TotalObjects = 0;
PsThreadType->TotalHandles = 0;
PsThreadType->PeakObjects = 0;
PsThreadType->PeakHandles = 0;
PsThreadType->PagedPoolCharge = 0;
PsThreadType->NonpagedPoolCharge = sizeof(ETHREAD);
PsThreadType->Mapping = &PiThreadMapping;
PsThreadType->Dump = NULL;
PsThreadType->Open = NULL;
PsThreadType->Close = NULL;
PsThreadType->Delete = PspDeleteThread;
PsThreadType->Parse = NULL;
PsThreadType->Security = NULL;
PsThreadType->QueryName = NULL;
PsThreadType->OkayToClose = NULL;
PsThreadType->Open = NULL;
RtlInitUnicodeString(&PsThreadType->TypeName, L"Thread");
ObpCreateTypeObject(PsThreadType);
DPRINT1("Creating Thread Object Type\n");
/* Initialize the Thread type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"Thread");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(ETHREAD);
ObjectTypeInitializer.GenericMapping = PiThreadMapping;
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.ValidAccessMask = THREAD_ALL_ACCESS;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObjectTypeInitializer.DeleteProcedure = PspDeleteThread;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &PsThreadType);
PsInitializeIdleOrFirstThread(PsInitialSystemProcess, &FirstThread, NULL, KernelMode, TRUE);
FirstThread->Tcb.State = Running;
@@ -123,6 +115,8 @@ PsInitProcessManagment(VOID)
{
PKPROCESS KProcess;
NTSTATUS Status;
UNICODE_STRING Name;
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
ShortPsLockDelay.QuadPart = -100LL;
PsLockTimeout.QuadPart = -10000000LL; /* one second */
@@ -130,29 +124,19 @@ PsInitProcessManagment(VOID)
* Register the process object type
*/
PsProcessType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
PsProcessType->Tag = TAG('P', 'R', 'O', 'C');
PsProcessType->TotalObjects = 0;
PsProcessType->TotalHandles = 0;
PsProcessType->PeakObjects = 0;
PsProcessType->PeakHandles = 0;
PsProcessType->PagedPoolCharge = 0;
PsProcessType->NonpagedPoolCharge = sizeof(EPROCESS);
PsProcessType->Mapping = &PiProcessMapping;
PsProcessType->Dump = NULL;
PsProcessType->Open = NULL;
PsProcessType->Close = NULL;
PsProcessType->Delete = PspDeleteProcess;
PsProcessType->Parse = NULL;
PsProcessType->Security = NULL;
PsProcessType->QueryName = NULL;
PsProcessType->OkayToClose = NULL;
PsProcessType->Open = NULL;
RtlInitUnicodeString(&PsProcessType->TypeName, L"Process");
ObpCreateTypeObject(PsProcessType);
DPRINT1("Creating Process Object Type\n");
/* Initialize the Thread type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"Process");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(EPROCESS);
ObjectTypeInitializer.GenericMapping = PiProcessMapping;
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.ValidAccessMask = PROCESS_ALL_ACCESS;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObjectTypeInitializer.DeleteProcedure = PspDeleteProcess;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &PsProcessType);
InitializeListHead(&PsActiveProcessHead);
ExInitializeFastMutex(&PspActiveProcessMutex);
reactos/ntoskrnl/ps/win32.c
+6 -6
View File
@@ -21,12 +21,12 @@ static PW32_THREAD_CALLBACK PspWin32ThreadCallback = NULL;
static ULONG PspWin32ProcessSize = 0;
static ULONG PspWin32ThreadSize = 0;
extern OBJECT_OPEN_ROUTINE ExpWindowStationObjectOpen;
extern OBJECT_PARSE_ROUTINE ExpWindowStationObjectParse;
extern OBJECT_DELETE_ROUTINE ExpWindowStationObjectDelete;
extern OBJECT_FIND_ROUTINE ExpWindowStationObjectFind;
extern OBJECT_CREATE_ROUTINE ExpDesktopObjectCreate;
extern OBJECT_DELETE_ROUTINE ExpDesktopObjectDelete;
extern OB_OPEN_METHOD ExpWindowStationObjectOpen;
extern OB_PARSE_METHOD ExpWindowStationObjectParse;
extern OB_DELETE_METHOD ExpWindowStationObjectDelete;
extern OB_FIND_METHOD ExpWindowStationObjectFind;
extern OB_CREATE_METHOD ExpDesktopObjectCreate;
extern OB_DELETE_METHOD ExpDesktopObjectDelete;
#ifndef ALEX_CB_REWRITE
typedef struct _NTW32CALL_SAVED_STATE
reactos/ntoskrnl/se/token.c
+18 -24
View File
@@ -560,30 +560,24 @@ SepDeleteToken(PVOID ObjectBody)
VOID INIT_FUNCTION
SepInitializeTokenImplementation(VOID)
{
ExInitializeResource(&SepTokenLock);
SepTokenObjectType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
SepTokenObjectType->Tag = TAG('T', 'O', 'K', 'T');
SepTokenObjectType->PeakObjects = 0;
SepTokenObjectType->PeakHandles = 0;
SepTokenObjectType->TotalObjects = 0;
SepTokenObjectType->TotalHandles = 0;
SepTokenObjectType->PagedPoolCharge = 0;
SepTokenObjectType->NonpagedPoolCharge = sizeof(TOKEN);
SepTokenObjectType->Mapping = &SepTokenMapping;
SepTokenObjectType->Dump = NULL;
SepTokenObjectType->Open = NULL;
SepTokenObjectType->Close = NULL;
SepTokenObjectType->Delete = SepDeleteToken;
SepTokenObjectType->Parse = NULL;
SepTokenObjectType->Security = NULL;
SepTokenObjectType->QueryName = NULL;
SepTokenObjectType->OkayToClose = NULL;
SepTokenObjectType->Open = NULL;
RtlInitUnicodeString(&SepTokenObjectType->TypeName, L"Token");
ObpCreateTypeObject (SepTokenObjectType);
UNICODE_STRING Name;
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
ExInitializeResource(&SepTokenLock);
DPRINT1("Creating Token Object Type\n");
/* Initialize the Token type */
RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
RtlInitUnicodeString(&Name, L"Token");
ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(TOKEN);
ObjectTypeInitializer.GenericMapping = SepTokenMapping;
ObjectTypeInitializer.PoolType = NonPagedPool;
ObjectTypeInitializer.ValidAccessMask = TOKEN_ALL_ACCESS;
ObjectTypeInitializer.UseDefaultObject = TRUE;
ObjectTypeInitializer.DeleteProcedure = SepDeleteToken;
ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &SepTokenObjectType);
}