From cf6037ee378c2567096d8eb0196ccf58151ff044 Mon Sep 17 00:00:00 2001 From: Alex Ionescu Date: Sun, 15 May 2005 17:59:33 +0000 Subject: [PATCH] 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 svn path=/trunk/; revision=15317 --- reactos/include/ddk/pstypes.h | 83 ++++++++---- reactos/ntoskrnl/cm/registry.c | 40 +++--- reactos/ntoskrnl/ex/callback.c | 34 ++--- reactos/ntoskrnl/ex/event.c | 35 +++-- reactos/ntoskrnl/ex/evtpair.c | 35 +++-- reactos/ntoskrnl/ex/mutant.c | 38 +++--- reactos/ntoskrnl/ex/profile.c | 37 +++-- reactos/ntoskrnl/ex/sem.c | 34 ++--- reactos/ntoskrnl/ex/timer.c | 38 ++---- reactos/ntoskrnl/ex/win32k.c | 75 +++++------ reactos/ntoskrnl/include/internal/io.h | 1 + reactos/ntoskrnl/include/internal/ob.h | 158 ++++++---------------- reactos/ntoskrnl/include/internal/port.h | 4 +- reactos/ntoskrnl/io/driver.c | 36 +++-- reactos/ntoskrnl/io/file.c | 4 +- reactos/ntoskrnl/io/iocomp.c | 53 ++++---- reactos/ntoskrnl/io/iomgr.c | 110 ++++++--------- reactos/ntoskrnl/io/share.c | 2 +- reactos/ntoskrnl/ke/wait.c | 2 +- reactos/ntoskrnl/lpc/close.c | 4 +- reactos/ntoskrnl/lpc/port.c | 60 ++++----- reactos/ntoskrnl/mm/section.c | 42 +++--- reactos/ntoskrnl/ob/dirobj.c | 4 +- reactos/ntoskrnl/ob/handle.c | 12 +- reactos/ntoskrnl/ob/namespc.c | 165 +++++++++++++---------- reactos/ntoskrnl/ob/object.c | 32 ++--- reactos/ntoskrnl/ob/security.c | 20 +-- reactos/ntoskrnl/ob/symlink.c | 44 +++--- reactos/ntoskrnl/ob/wait.c | 4 +- reactos/ntoskrnl/ps/cid.c | 4 +- reactos/ntoskrnl/ps/job.c | 43 +++--- reactos/ntoskrnl/ps/psmgr.c | 76 +++++------ reactos/ntoskrnl/ps/win32.c | 12 +- reactos/ntoskrnl/se/token.c | 42 +++--- 34 files changed, 600 insertions(+), 783 deletions(-) diff --git a/reactos/include/ddk/pstypes.h b/reactos/include/ddk/pstypes.h index 2cca0ef4cb2..b453b9f8835 100644 --- a/reactos/include/ddk/pstypes.h +++ b/reactos/include/ddk/pstypes.h @@ -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 diff --git a/reactos/ntoskrnl/cm/registry.c b/reactos/ntoskrnl/cm/registry.c index bd1d810fb14..91140f38e4f 100644 --- a/reactos/ntoskrnl/cm/registry.c +++ b/reactos/ntoskrnl/cm/registry.c @@ -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); diff --git a/reactos/ntoskrnl/ex/callback.c b/reactos/ntoskrnl/ex/callback.c index 3b017429181..fa0e9cf1ec5 100644 --- a/reactos/ntoskrnl/ex/callback.c +++ b/reactos/ntoskrnl/ex/callback.c @@ -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)) diff --git a/reactos/ntoskrnl/ex/event.c b/reactos/ntoskrnl/ex/event.c index 45220e187ab..05461e3a522 100644 --- a/reactos/ntoskrnl/ex/event.c +++ b/reactos/ntoskrnl/ex/event.c @@ -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); } /* diff --git a/reactos/ntoskrnl/ex/evtpair.c b/reactos/ntoskrnl/ex/evtpair.c index 43c0dd97adb..177782c1d12 100644 --- a/reactos/ntoskrnl/ex/evtpair.c +++ b/reactos/ntoskrnl/ex/evtpair.c @@ -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 diff --git a/reactos/ntoskrnl/ex/mutant.c b/reactos/ntoskrnl/ex/mutant.c index 978a7514064..91e3a098939 100644 --- a/reactos/ntoskrnl/ex/mutant.c +++ b/reactos/ntoskrnl/ex/mutant.c @@ -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); } /* diff --git a/reactos/ntoskrnl/ex/profile.c b/reactos/ntoskrnl/ex/profile.c index 6863bc4ce97..2fde67e5e65 100644 --- a/reactos/ntoskrnl/ex/profile.c +++ b/reactos/ntoskrnl/ex/profile.c @@ -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 diff --git a/reactos/ntoskrnl/ex/sem.c b/reactos/ntoskrnl/ex/sem.c index cc69a8131a5..026ee942336 100644 --- a/reactos/ntoskrnl/ex/sem.c +++ b/reactos/ntoskrnl/ex/sem.c @@ -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); } /* diff --git a/reactos/ntoskrnl/ex/timer.c b/reactos/ntoskrnl/ex/timer.c index 43878f4fc53..386fab368e6 100644 --- a/reactos/ntoskrnl/ex/timer.c +++ b/reactos/ntoskrnl/ex/timer.c @@ -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); diff --git a/reactos/ntoskrnl/ex/win32k.c b/reactos/ntoskrnl/ex/win32k.c index 15f645f4bb6..7b505f3e86e 100644 --- a/reactos/ntoskrnl/ex/win32k.c +++ b/reactos/ntoskrnl/ex/win32k.c @@ -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 */ diff --git a/reactos/ntoskrnl/include/internal/io.h b/reactos/ntoskrnl/include/internal/io.h index e313a04279e..b24d1ab29bf 100644 --- a/reactos/ntoskrnl/include/internal/io.h +++ b/reactos/ntoskrnl/include/internal/io.h @@ -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 diff --git a/reactos/ntoskrnl/include/internal/ob.h b/reactos/ntoskrnl/include/internal/ob.h index 82ee74a9dfb..40d1bc39f27 100644 --- a/reactos/ntoskrnl/include/internal/ob.h +++ b/reactos/ntoskrnl/include/internal/ob.h @@ -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); diff --git a/reactos/ntoskrnl/include/internal/port.h b/reactos/ntoskrnl/include/internal/port.h index 1f2c95a682c..4c6f8464742 100644 --- a/reactos/ntoskrnl/include/internal/port.h +++ b/reactos/ntoskrnl/include/internal/port.h @@ -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 */ diff --git a/reactos/ntoskrnl/io/driver.c b/reactos/ntoskrnl/io/driver.c index a1260b7644b..f4f5941f4aa 100644 --- a/reactos/ntoskrnl/io/driver.c +++ b/reactos/ntoskrnl/io/driver.c @@ -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); diff --git a/reactos/ntoskrnl/io/file.c b/reactos/ntoskrnl/io/file.c index 74c51adee50..6f04adc0dcd 100644 --- a/reactos/ntoskrnl/io/file.c +++ b/reactos/ntoskrnl/io/file.c @@ -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); diff --git a/reactos/ntoskrnl/io/iocomp.c b/reactos/ntoskrnl/io/iocomp.c index 03ad5ed3203..0f21d3aec3a 100644 --- a/reactos/ntoskrnl/io/iocomp.c +++ b/reactos/ntoskrnl/io/iocomp.c @@ -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); diff --git a/reactos/ntoskrnl/io/iomgr.c b/reactos/ntoskrnl/io/iomgr.c index a8f06dfef24..1198b11928e 100644 --- a/reactos/ntoskrnl/io/iomgr.c +++ b/reactos/ntoskrnl/io/iomgr.c @@ -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 diff --git a/reactos/ntoskrnl/io/share.c b/reactos/ntoskrnl/io/share.c index aee0141e46e..fe11e727afb 100644 --- a/reactos/ntoskrnl/io/share.c +++ b/reactos/ntoskrnl/io/share.c @@ -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; diff --git a/reactos/ntoskrnl/ke/wait.c b/reactos/ntoskrnl/ke/wait.c index 9faf3209e19..d34e8973dca 100644 --- a/reactos/ntoskrnl/ke/wait.c +++ b/reactos/ntoskrnl/ke/wait.c @@ -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 || diff --git a/reactos/ntoskrnl/lpc/close.c b/reactos/ntoskrnl/lpc/close.c index b8c681d956b..625406d348c 100644 --- a/reactos/ntoskrnl/lpc/close.c +++ b/reactos/ntoskrnl/lpc/close.c @@ -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; diff --git a/reactos/ntoskrnl/lpc/port.c b/reactos/ntoskrnl/lpc/port.c index bcba731d9d1..1748a1f6510 100644 --- a/reactos/ntoskrnl/lpc/port.c +++ b/reactos/ntoskrnl/lpc/port.c @@ -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); } diff --git a/reactos/ntoskrnl/mm/section.c b/reactos/ntoskrnl/mm/section.c index 5a9f74dc0e0..666d977ecd8 100644 --- a/reactos/ntoskrnl/mm/section.c +++ b/reactos/ntoskrnl/mm/section.c @@ -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); } diff --git a/reactos/ntoskrnl/ob/dirobj.c b/reactos/ntoskrnl/ob/dirobj.c index ac6a02aa4d6..cc374dbed65 100644 --- a/reactos/ntoskrnl/ob/dirobj.c +++ b/reactos/ntoskrnl/ob/dirobj.c @@ -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) { diff --git a/reactos/ntoskrnl/ob/handle.c b/reactos/ntoskrnl/ob/handle.c index 9d5bd4c9a68..9145aa62531 100644 --- a/reactos/ntoskrnl/ob/handle.c +++ b/reactos/ntoskrnl/ob/handle.c @@ -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; diff --git a/reactos/ntoskrnl/ob/namespc.c b/reactos/ntoskrnl/ob/namespc.c index 71253568016..b6301ff2ce5 100644 --- a/reactos/ntoskrnl/ob/namespc.c +++ b/reactos/ntoskrnl/ob/namespc.c @@ -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 */ diff --git a/reactos/ntoskrnl/ob/object.c b/reactos/ntoskrnl/ob/object.c index b59b80d5123..1f48191a2a6 100644 --- a/reactos/ntoskrnl/ob/object.c +++ b/reactos/ntoskrnl/ob/object.c @@ -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, ¤t, @@ -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, diff --git a/reactos/ntoskrnl/ob/security.c b/reactos/ntoskrnl/ob/security.c index 040f3072f54..87e70e41a07 100644 --- a/reactos/ntoskrnl/ob/security.c +++ b/reactos/ntoskrnl/ob/security.c @@ -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, diff --git a/reactos/ntoskrnl/ob/symlink.c b/reactos/ntoskrnl/ob/symlink.c index e7da98edb79..48347025e5d 100644 --- a/reactos/ntoskrnl/ob/symlink.c +++ b/reactos/ntoskrnl/ob/symlink.c @@ -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); } diff --git a/reactos/ntoskrnl/ob/wait.c b/reactos/ntoskrnl/ob/wait.c index 8c832e1e53b..23c8511c02a 100644 --- a/reactos/ntoskrnl/ob/wait.c +++ b/reactos/ntoskrnl/ob/wait.c @@ -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 diff --git a/reactos/ntoskrnl/ps/cid.c b/reactos/ntoskrnl/ps/cid.c index f3f919628fa..c50839043cf 100644 --- a/reactos/ntoskrnl/ps/cid.c +++ b/reactos/ntoskrnl/ps/cid.c @@ -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); } diff --git a/reactos/ntoskrnl/ps/job.c b/reactos/ntoskrnl/ps/job.c index f3cbc510b21..47588371455 100644 --- a/reactos/ntoskrnl/ps/job.c +++ b/reactos/ntoskrnl/ps/job.c @@ -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); diff --git a/reactos/ntoskrnl/ps/psmgr.c b/reactos/ntoskrnl/ps/psmgr.c index 164fdd94274..1a6f2627e7e 100644 --- a/reactos/ntoskrnl/ps/psmgr.c +++ b/reactos/ntoskrnl/ps/psmgr.c @@ -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); diff --git a/reactos/ntoskrnl/ps/win32.c b/reactos/ntoskrnl/ps/win32.c index 4ccf9f06df2..de106b25de6 100644 --- a/reactos/ntoskrnl/ps/win32.c +++ b/reactos/ntoskrnl/ps/win32.c @@ -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 diff --git a/reactos/ntoskrnl/se/token.c b/reactos/ntoskrnl/se/token.c index 523190737b3..843da887926 100644 --- a/reactos/ntoskrnl/se/token.c +++ b/reactos/ntoskrnl/se/token.c @@ -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); }