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); }