ReactOS 0.4.15-dev-5672-gf73ac17
cminit.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/config/cminit.c
5 * PURPOSE: Configuration Manager - Hive Initialization
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 */
8
9/* INCLUDES ******************************************************************/
10
11#include "ntoskrnl.h"
12#define NDEBUG
13#include "debug.h"
14
15/* FUNCTIONS *****************************************************************/
16
20 IN ULONG OperationType,
21 IN ULONG HiveFlags,
23 IN PVOID HiveData OPTIONAL,
24 IN HANDLE Primary,
25 IN HANDLE Log,
28 IN ULONG CheckFlags)
29{
30 PCMHIVE Hive;
32 FILE_FS_SIZE_INFORMATION FileSizeInformation;
34 ULONG Cluster;
35
36 /* Assume failure */
37 *CmHive = NULL;
38
39 /*
40 * The following are invalid:
41 * - An external hive that is also internal.
42 * - A log hive that is not a primary hive too.
43 * - A volatile hive that is linked to permanent storage,
44 * unless this hive is a shared system hive.
45 * - An in-memory initialization without hive data.
46 * - A log hive that is not linked to a correct file type.
47 */
48 if (((External) && ((Primary) || (Log))) ||
49 ((Log) && !(Primary)) ||
50 (!(CmpShareSystemHives) && (HiveFlags & HIVE_VOLATILE) &&
51 ((Primary) || (External) || (Log))) ||
52 ((OperationType == HINIT_MEMORY) && (!HiveData)) ||
53 ((Log) && (FileType != HFILE_TYPE_LOG)))
54 {
55 /* Fail the request */
57 }
58
59 /* Check if this is a primary hive */
60 if (Primary)
61 {
62 /* Get the cluster size */
65 &FileSizeInformation,
68 if (!NT_SUCCESS(Status)) return Status;
69
70 /* Make sure it's not larger then the block size */
71 if (FileSizeInformation.BytesPerSector > HBLOCK_SIZE)
72 {
73 /* Fail */
75 }
76
77 /* Otherwise, calculate the cluster */
78 Cluster = FileSizeInformation.BytesPerSector / HSECTOR_SIZE;
79 Cluster = max(1, Cluster);
80 }
81 else
82 {
83 /* Otherwise use cluster 1 */
84 Cluster = 1;
85 }
86
87 /* Allocate the hive */
89 if (!Hive) return STATUS_INSUFFICIENT_RESOURCES;
90
91 /* Setup null fields */
92 Hive->UnloadEvent = NULL;
93 Hive->RootKcb = NULL;
94 Hive->Frozen = FALSE;
95 Hive->UnloadWorkItem = NULL;
96 Hive->GrowOnlyMode = FALSE;
97 Hive->GrowOffset = 0;
98 Hive->CellRemapArray = NULL;
99 Hive->UseCountLog.Next = 0;
100 Hive->LockHiveLog.Next = 0;
101 Hive->FileObject = NULL;
102 Hive->NotifyList.Flink = NULL;
103 Hive->NotifyList.Blink = NULL;
104
105 /* Set the loading flag */
106 Hive->HiveIsLoading = TRUE;
107
108 /* Set the current thread as creator */
110
111 /* Initialize lists */
115
116 /* Allocate the view log */
118 sizeof(KGUARDED_MUTEX),
119 TAG_CMHIVE);
120 if (!Hive->ViewLock)
121 {
122 /* Cleanup allocation and fail */
125 }
126
127 /* Allocate the flush lock */
129 sizeof(ERESOURCE),
130 TAG_CMHIVE);
131 if (!Hive->FlusherLock)
132 {
133 /* Cleanup allocations and fail */
137 }
138
139 /* Setup the handles */
140 Hive->FileHandles[HFILE_TYPE_PRIMARY] = Primary;
141 Hive->FileHandles[HFILE_TYPE_LOG] = Log;
143
144 /* Initailize the guarded mutex */
146 Hive->ViewLockOwner = NULL;
147
148 /* Initialize the flush lock */
150
151 /* Setup hive locks */
153 Hive->HiveLockOwner = NULL;
155 Hive->WriterLockOwner = NULL;
158
159 /* Clear file names */
160 RtlInitEmptyUnicodeString(&Hive->FileUserName, NULL, 0);
161 RtlInitEmptyUnicodeString(&Hive->FileFullPath, NULL, 0);
162
163 /* Initialize the view list */
165
166 /* Initailize the security cache */
168
169 /* Setup flags */
170 Hive->Flags = 0;
171 Hive->FlushCount = 0;
172
173 /* Initialize it */
174 Status = HvInitialize(&Hive->Hive,
175 OperationType,
176 HiveFlags,
177 FileType,
178 HiveData,
180 CmpFree,
185 Cluster,
186 FileName);
187 if (!NT_SUCCESS(Status))
188 {
189 /* Cleanup allocations and fail */
194 return Status;
195 }
196
197 /* Check if we should verify the registry */
198 if ((OperationType == HINIT_FILE) ||
199 (OperationType == HINIT_MEMORY) ||
200 (OperationType == HINIT_MEMORY_INPLACE) ||
201 (OperationType == HINIT_MAPFILE))
202 {
203 /* Verify integrity */
204 ULONG CheckStatus = CmCheckRegistry(Hive, CheckFlags);
205 if (CheckStatus != 0)
206 {
207 /* Cleanup allocations and fail */
213 }
214 }
215
216 /* Reset the loading flag */
217 Hive->HiveIsLoading = FALSE;
218
219 /* Lock the hive list */
221
222 /* Insert this hive */
224
225 /* Release the lock */
227
228 /* Return the hive and success */
229 *CmHive = Hive;
230 return STATUS_SUCCESS;
231}
232
234NTAPI
236{
237 /* Remove the hive from the list */
239 RemoveEntryList(&CmHive->HiveList);
241
242 /* Destroy the security descriptor cache */
244
245 /* Destroy the view list */
247
248 /* Delete the flusher lock */
249 ExDeleteResourceLite(CmHive->FlusherLock);
250 ExFreePoolWithTag(CmHive->FlusherLock, TAG_CMHIVE);
251
252 /* Delete the view lock */
253 ExFreePoolWithTag(CmHive->ViewLock, TAG_CMHIVE);
254
255 /* Free the hive storage */
256 HvFree(&CmHive->Hive);
257
258 /* Free the hive */
259 CmpFree(CmHive, TAG_CM);
260
261 return STATUS_SUCCESS;
262}
263
265NTAPI
268 OUT PHANDLE Primary,
269 OUT PHANDLE Log,
270 OUT PULONG PrimaryDisposition,
271 OUT PULONG LogDisposition,
272 IN BOOLEAN CreateAllowed,
273 IN BOOLEAN MarkAsSystemHive,
274 IN BOOLEAN NoBuffering,
276{
280 UNICODE_STRING FullName, ExtensionName;
281 PWCHAR NameBuffer;
285 ULONG AttributeFlags, ShareMode, DesiredAccess, CreateDisposition, IoFlags;
286 USHORT CompressionState;
288 FILE_FS_SIZE_INFORMATION FsSizeInformation;
289
290 /* Create event */
292 if (!NT_SUCCESS(Status)) return Status;
293
294 /* Initialize the full name */
295 RtlInitEmptyUnicodeString(&FullName, NULL, 0);
296 Length = BaseName->Length;
297
298 /* Check if we have an extension */
299 if (Extension)
300 {
301 /* Update the name length */
302 Length += (USHORT)wcslen(Extension) * sizeof(WCHAR) + sizeof(UNICODE_NULL);
303
304 /* Allocate the buffer for the full name */
306 if (!NameBuffer)
307 {
308 /* Fail */
311 return STATUS_NO_MEMORY;
312 }
313
314 /* Build the full name */
315 FullName.Buffer = NameBuffer;
317 RtlCopyUnicodeString(&FullName, BaseName);
318 }
319 else
320 {
321 /* The base name is the full name */
322 FullName = *BaseName;
323 NameBuffer = NULL;
324 }
325
326 /* Initialize the attributes */
328 &FullName,
330 NULL,
331 NULL);
332
333 /* Check if we can create the hive */
334 if ((CreateAllowed) && !(CmpShareSystemHives))
335 {
336 /* Open only or create */
338 }
339 else
340 {
341 /* Open only */
343 }
344
345 /* Setup the flags */
346 // FIXME : FILE_OPEN_FOR_BACKUP_INTENT is unimplemented and breaks 3rd stage boot
347 IoFlags = //FILE_OPEN_FOR_BACKUP_INTENT |
350 (NoBuffering ? FILE_NO_INTERMEDIATE_BUFFERING : 0);
351
352 /* Set share and access modes */
354 {
355 /* We're on Live CD or otherwise sharing */
357 ShareMode = FILE_SHARE_READ;
358 }
359 else
360 {
361 /* We want to write exclusively */
362 ShareMode = 0;
364 }
365
366 /* Default attributes */
367 AttributeFlags = FILE_ATTRIBUTE_NORMAL;
368
369 /* Now create the file.
370 * Note: We use FILE_SYNCHRONOUS_IO_NONALERT here to simplify CmpFileRead/CmpFileWrite.
371 * Windows does async I/O and therefore does not use this flag (or SYNCHRONIZE).
372 */
373 Status = ZwCreateFile(Primary,
377 NULL,
378 AttributeFlags,
379 ShareMode,
382 NULL,
383 0);
384 /* Check if anything failed until now */
385 if (!NT_SUCCESS(Status))
386 {
387 DPRINT1("ZwCreateFile(%wZ) failed, Status 0x%08lx.\n", ObjectAttributes.ObjectName, Status);
388
389 /* Close handles and free buffers */
390 if (NameBuffer) ExFreePoolWithTag(NameBuffer, TAG_CM);
393 *Primary = NULL;
394 return Status;
395 }
396
397 if (MarkAsSystemHive)
398 {
399 /* We opened it, mark it as a system hive */
400 Status = ZwFsControlFile(*Primary,
402 NULL,
403 NULL,
406 NULL,
407 0,
408 NULL,
409 0);
410 if (Status == STATUS_PENDING)
411 {
412 /* Wait for completion */
414 Executive,
416 FALSE,
417 NULL);
419 }
420
421 /* If we don't support it, ignore the failure */
423
424 if (!NT_SUCCESS(Status))
425 {
426 /* Close handles and free buffers */
427 if (NameBuffer) ExFreePoolWithTag(NameBuffer, TAG_CM);
430 ZwClose(*Primary);
431 *Primary = NULL;
432 return Status;
433 }
434 }
435
436 /* Disable compression */
437 CompressionState = 0;
438 Status = ZwFsControlFile(*Primary,
440 NULL,
441 NULL,
444 &CompressionState,
445 sizeof(CompressionState),
446 NULL,
447 0);
448 if (Status == STATUS_PENDING)
449 {
450 /* Wait for completion */
452 Executive,
454 FALSE,
455 NULL);
456 }
457
458 /* Get the disposition */
459 *PrimaryDisposition = (ULONG)IoStatusBlock.Information;
461 {
462 /* Check how large the file is */
463 Status = ZwQueryInformationFile(*Primary,
466 sizeof(FileInformation),
468 if (NT_SUCCESS(Status))
469 {
470 /* Check if it's 0 bytes */
471 if (!FileInformation.EndOfFile.QuadPart)
472 {
473 /* Assume it's a new file */
474 *PrimaryDisposition = FILE_CREATED;
475 }
476 }
477 }
478
479 /* Check if the caller wants cluster size returned */
480 if (ClusterSize)
481 {
482 /* Query it */
485 &FsSizeInformation,
486 sizeof(FsSizeInformation),
488 if (!NT_SUCCESS(Status))
489 {
490 /* Close handles and free buffers */
491 if (NameBuffer) ExFreePoolWithTag(NameBuffer, TAG_CM);
494 return Status;
495 }
496
497 /* Check if the sector size is invalid */
498 if (FsSizeInformation.BytesPerSector > HBLOCK_SIZE)
499 {
500 /* Close handles and free buffers */
501 if (NameBuffer) ExFreePoolWithTag(NameBuffer, TAG_CM);
505 }
506
507 /* Return cluster size */
508 *ClusterSize = max(1, FsSizeInformation.BytesPerSector / HSECTOR_SIZE);
509 }
510
511 /* Check if we don't need to create a log file */
512 if (!Extension)
513 {
514 /* We're done, close handles */
517 return STATUS_SUCCESS;
518 }
519
520 /* Check if we can create the hive */
522 if (*PrimaryDisposition == FILE_CREATED)
523 {
524 /* Over-write the existing log file, since this is a new hive */
526 }
527
528 /* Setup the name */
529 RtlInitUnicodeString(&ExtensionName, Extension);
531
532 /* Initialize the attributes */
534 &FullName,
536 NULL,
537 NULL);
538
539 /* Setup the flags */
541
542 /* Check if this is a log file */
543 if (!_wcsnicmp(Extension, L".log", 4))
544 {
545 /* Hide log files */
546 AttributeFlags |= FILE_ATTRIBUTE_HIDDEN;
547 }
548
549 /* Now create the file.
550 * Note: We use FILE_SYNCHRONOUS_IO_NONALERT here to simplify CmpFileRead/CmpFileWrite.
551 * Windows does async I/O and therefore does not use this flag (or SYNCHRONIZE).
552 */
553 Status = ZwCreateFile(Log,
557 NULL,
558 AttributeFlags,
559 ShareMode,
562 NULL,
563 0);
564 if ((NT_SUCCESS(Status)) && (MarkAsSystemHive))
565 {
566 /* We opened it, mark it as a system hive */
567 Status = ZwFsControlFile(*Log,
569 NULL,
570 NULL,
573 NULL,
574 0,
575 NULL,
576 0);
577 if (Status == STATUS_PENDING)
578 {
579 /* Wait for completion */
581 Executive,
583 FALSE,
584 NULL);
586 }
587
588 /* If we don't support it, ignore the failure */
590
591 /* If we failed, close the handle */
592 if (!NT_SUCCESS(Status)) ZwClose(*Log);
593 }
594
595 /* Check if anything failed until now */
596 if (!NT_SUCCESS(Status))
597 {
598 /* Clear the handle */
599 *Log = NULL;
600 }
601 else
602 {
603 /* Disable compression */
604 Status = ZwFsControlFile(*Log,
606 NULL,
607 NULL,
610 &CompressionState,
611 sizeof(CompressionState),
612 NULL,
613 0);
614 if (Status == STATUS_PENDING)
615 {
616 /* Wait for completion */
618 Executive,
620 FALSE,
621 NULL);
622 }
623
624 /* Return the disposition */
625 *LogDisposition = (ULONG)IoStatusBlock.Information;
626 }
627
628 /* We're done, close handles and free buffers */
629 if (NameBuffer) ExFreePoolWithTag(NameBuffer, TAG_CM);
632 return STATUS_SUCCESS;
633}
634
635VOID
636NTAPI
638{
639 ULONG i;
640
641 for (i = 0; i < HFILE_TYPE_MAX; i++)
642 {
643 if (Hive->FileHandles[i] != NULL)
644 {
645 ZwClose(Hive->FileHandles[i]);
646 Hive->FileHandles[i] = NULL;
647 }
648 }
649}
unsigned char BOOLEAN
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
DWORD ClusterSize
Definition: format.c:67
PVOID NTAPI CmpAllocate(_In_ SIZE_T Size, _In_ BOOLEAN Paged, _In_ ULONG Tag)
Definition: bootreg.c:90
VOID NTAPI CmpFree(_In_ PVOID Ptr, _In_ ULONG Quota)
Definition: bootreg.c:105
ULONG NTAPI CmCheckRegistry(IN PCMHIVE RegistryHive, IN ULONG Flags)
Definition: cmcheck.c:21
EX_PUSH_LOCK CmpHiveListHeadLock
Definition: cmdata.c:39
BOOLEAN CmpMiniNTBoot
Definition: cmdata.c:60
BOOLEAN CmpShareSystemHives
Definition: cmdata.c:57
#define TAG_CMHIVE
Definition: cmlib.h:207
NTSTATUS CMAPI HvInitialize(PHHIVE RegistryHive, ULONG OperationType, ULONG HiveFlags, ULONG FileType, PVOID HiveData OPTIONAL, PALLOCATE_ROUTINE Allocate, PFREE_ROUTINE Free, PFILE_SET_SIZE_ROUTINE FileSetSize, PFILE_WRITE_ROUTINE FileWrite, PFILE_READ_ROUTINE FileRead, PFILE_FLUSH_ROUTINE FileFlush, ULONG Cluster OPTIONAL, PCUNICODE_STRING FileName OPTIONAL)
Definition: hiveinit.c:522
#define TAG_CM
Definition: cmlib.h:205
VOID CMAPI HvFree(PHHIVE RegistryHive)
Definition: hiveinit.c:628
VOID NTAPI CmpDestroyHiveViewList(IN PCMHIVE Hive)
Definition: cmmapvw.c:35
VOID NTAPI CmpInitHiveViewList(IN PCMHIVE Hive)
Definition: cmmapvw.c:21
VOID NTAPI CmpDestroySecurityCache(IN PCMHIVE Hive)
Definition: cmsecach.c:41
VOID NTAPI CmpInitSecurityCache(IN PCMHIVE Hive)
Definition: cmsecach.c:21
LIST_ENTRY CmpHiveListHead
Definition: cmsysini.c:18
BOOLEAN NTAPI CmpFileWrite(IN PHHIVE RegistryHive, IN ULONG FileType, IN PULONG FileOffset, IN PVOID Buffer, IN SIZE_T BufferLength)
Definition: cmwraprs.c:99
BOOLEAN NTAPI CmpFileSetSize(IN PHHIVE RegistryHive, IN ULONG FileType, IN ULONG FileSize, IN ULONG OldFileSize)
Definition: cmwraprs.c:132
BOOLEAN NTAPI CmpFileFlush(IN PHHIVE RegistryHive, IN ULONG FileType, IN OUT PLARGE_INTEGER FileOffset, IN ULONG Length)
Definition: cmwraprs.c:169
NTSTATUS NTAPI CmpCreateEvent(IN EVENT_TYPE EventType, OUT PHANDLE EventHandle, OUT PKEVENT *Event)
Definition: cmwraprs.c:19
BOOLEAN NTAPI CmpFileRead(IN PHHIVE RegistryHive, IN ULONG FileType, IN PULONG FileOffset, OUT PVOID Buffer, IN SIZE_T BufferLength)
Definition: cmwraprs.c:73
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
#define FILE_SHARE_READ
Definition: compat.h:136
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
#define InsertHeadList(ListHead, Entry)
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
NTSTATUS ExInitializeResourceLite(PULONG res)
Definition: env_spec_w32.h:641
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
#define ExDeleteResourceLite(res)
Definition: env_spec_w32.h:647
#define NonPagedPool
Definition: env_spec_w32.h:307
ULONG ERESOURCE
Definition: env_spec_w32.h:594
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define PagedPool
Definition: env_spec_w32.h:308
FORCEINLINE VOID ExReleasePushLock(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1295
#define ExInitializePushLock
Definition: ex.h:1012
FORCEINLINE VOID ExAcquirePushLockExclusive(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1035
_Inout_opt_ PUNICODE_STRING Extension
Definition: fltkernel.h:1092
#define FILE_NO_COMPRESSION
Definition: from_kernel.h:43
#define FILE_OPEN
Definition: from_kernel.h:54
#define FILE_SYNCHRONOUS_IO_NONALERT
Definition: from_kernel.h:31
@ FileFsSizeInformation
Definition: from_kernel.h:221
#define FILE_NO_INTERMEDIATE_BUFFERING
Definition: from_kernel.h:28
#define FILE_RANDOM_ACCESS
Definition: from_kernel.h:38
#define FILE_OPEN_IF
Definition: from_kernel.h:56
#define FILE_SUPERSEDE
Definition: from_kernel.h:53
Status
Definition: gdiplustypes.h:25
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31
#define KeGetCurrentThread
Definition: hal.h:55
#define HBLOCK_SIZE
Definition: hivedata.h:41
#define HINIT_FILE
Definition: hivedata.h:15
#define HINIT_MEMORY
Definition: hivedata.h:14
#define HFILE_TYPE_MAX
Definition: hivedata.h:36
#define HFILE_TYPE_LOG
Definition: hivedata.h:34
#define HIVE_VOLATILE
Definition: hivedata.h:23
#define HFILE_TYPE_PRIMARY
Definition: hivedata.h:33
#define HINIT_MAPFILE
Definition: hivedata.h:18
#define HFILE_TYPE_EXTERNAL
Definition: hivedata.h:35
#define HINIT_MEMORY_INPLACE
Definition: hivedata.h:16
#define HSECTOR_SIZE
Definition: hivedata.h:42
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
if(dx< 0)
Definition: linetemp.h:194
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
static IDispatch External
Definition: htmldoc.c:521
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
static OUT PIO_STATUS_BLOCK OUT PVOID FileInformation
Definition: pipe.c:75
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
#define KernelMode
Definition: asm.h:34
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
#define SYNCHRONIZE
Definition: nt_native.h:61
#define FILE_WRITE_DATA
Definition: nt_native.h:631
#define FILE_READ_DATA
Definition: nt_native.h:628
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
#define FILE_ATTRIBUTE_HIDDEN
Definition: nt_native.h:703
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define FILE_CREATED
Definition: nt_native.h:770
#define FSCTL_MARK_AS_SYSTEM_HIVE
Definition: nt_native.h:845
#define FSCTL_SET_COMPRESSION
Definition: nt_native.h:842
#define UNICODE_NULL
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
@ NotificationEvent
NTSYSAPI NTSTATUS NTAPI ZwFsControlFile(IN HANDLE DeviceHandle, IN HANDLE Event OPTIONAL, IN PIO_APC_ROUTINE ApcRoutine OPTIONAL, IN PVOID ApcContext OPTIONAL, OUT PIO_STATUS_BLOCK IoStatusBlock, IN ULONG IoControlCode, IN PVOID InputBuffer, IN ULONG InputBufferSize, OUT PVOID OutputBuffer, IN ULONG OutputBufferSize)
NTSYSAPI NTSTATUS NTAPI ZwQueryVolumeInformationFile(IN HANDLE FileHandle, OUT PIO_STATUS_BLOCK IoStatusBlock, OUT PVOID FsInformation, IN ULONG Length, IN FS_INFORMATION_CLASS FsInformationClass)
NTSTATUS NTAPI CmpInitializeHive(OUT PCMHIVE *CmHive, IN ULONG OperationType, IN ULONG HiveFlags, IN ULONG FileType, IN PVOID HiveData OPTIONAL, IN HANDLE Primary, IN HANDLE Log, IN HANDLE External, IN PCUNICODE_STRING FileName OPTIONAL, IN ULONG CheckFlags)
Definition: cminit.c:19
VOID NTAPI CmpCloseHiveFiles(IN PCMHIVE Hive)
Definition: cminit.c:637
NTSTATUS NTAPI CmpOpenHiveFiles(IN PCUNICODE_STRING BaseName, IN PCWSTR Extension OPTIONAL, OUT PHANDLE Primary, OUT PHANDLE Log, OUT PULONG PrimaryDisposition, OUT PULONG LogDisposition, IN BOOLEAN CreateAllowed, IN BOOLEAN MarkAsSystemHive, IN BOOLEAN NoBuffering, OUT PULONG ClusterSize OPTIONAL)
Definition: cminit.c:266
NTSTATUS NTAPI CmpDestroyHive(IN PCMHIVE CmHive)
Definition: cminit.c:235
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:455
#define STATUS_PENDING
Definition: ntstatus.h:82
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define STATUS_CANNOT_LOAD_REGISTRY_FILE
Definition: ntstatus.h:668
#define STATUS_REGISTRY_CORRUPT
Definition: ntstatus.h:568
#define STATUS_REGISTRY_IO_FAILED
Definition: ntstatus.h:569
#define L(x)
Definition: ntvdm.h:50
unsigned short USHORT
Definition: pedump.c:61
#define FileStandardInformation
Definition: propsheet.cpp:61
_Check_return_ _CRTIMP int __cdecl _wcsnicmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)
#define STATUS_SUCCESS
Definition: shellext.h:65
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
Definition: cmlib.h:245
ULONG FlushCount
Definition: cmlib.h:285
PKTHREAD HiveSecurityLockOwner
Definition: cmlib.h:258
HHIVE Hive
Definition: cmlib.h:246
BOOLEAN HiveIsLoading
Definition: cmlib.h:286
LIST_ENTRY NotifyList
Definition: cmlib.h:248
BOOLEAN Frozen
Definition: cmlib.h:274
PKGUARDED_MUTEX ViewLock
Definition: cmlib.h:252
LIST_ENTRY HiveList
Definition: cmlib.h:249
EX_PUSH_LOCK WriterLock
Definition: cmlib.h:254
PKTHREAD HiveLockOwner
Definition: cmlib.h:251
PERESOURCE FlusherLock
Definition: cmlib.h:256
PKTHREAD WriterLockOwner
Definition: cmlib.h:255
BOOLEAN GrowOnlyMode
Definition: cmlib.h:276
LIST_ENTRY KnodeConvertListHead
Definition: cmlib.h:279
EX_PUSH_LOCK SecurityLock
Definition: cmlib.h:257
PWORK_QUEUE_ITEM UnloadWorkItem
Definition: cmlib.h:275
PKTHREAD CreatorOwner
Definition: cmlib.h:287
LIST_ENTRY TrustClassEntry
Definition: cmlib.h:284
ULONG Flags
Definition: cmlib.h:283
CM_USE_COUNT_LOG UseCountLog
Definition: cmlib.h:281
HANDLE FileHandles[HFILE_TYPE_MAX]
Definition: cmlib.h:247
LIST_ENTRY KcbConvertListHead
Definition: cmlib.h:278
PKEVENT UnloadEvent
Definition: cmlib.h:272
UNICODE_STRING FileUserName
Definition: cmlib.h:263
PFILE_OBJECT FileObject
Definition: cmlib.h:261
PCM_KEY_CONTROL_BLOCK RootKcb
Definition: cmlib.h:273
PKTHREAD ViewLockOwner
Definition: cmlib.h:253
PCM_CELL_REMAP_BLOCK CellRemapArray
Definition: cmlib.h:280
ULONG GrowOffset
Definition: cmlib.h:277
EX_PUSH_LOCK HiveLock
Definition: cmlib.h:250
CM_USE_COUNT_LOG LockHiveLog
Definition: cmlib.h:282
UNICODE_STRING FileFullPath
Definition: cmlib.h:262
USHORT Next
Definition: cmlib.h:236
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
void * Buffer
Definition: sprintf.c:453
unsigned short MaximumLength
Definition: sprintf.c:452
#define max(a, b)
Definition: svc.c:63
uint32_t * PULONG
Definition: typedefs.h:59
const uint16_t * PCWSTR
Definition: typedefs.h:57
#define NTAPI
Definition: typedefs.h:36
#define IN
Definition: typedefs.h:39
uint16_t * PWCHAR
Definition: typedefs.h:56
uint32_t ULONG
Definition: typedefs.h:59
#define OUT
Definition: typedefs.h:40
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_Must_inspect_result_ _In_ WDFDEVICE _In_ ULONG _In_ ACCESS_MASK DesiredAccess
Definition: wdfdevice.h:2658
_In_ WDFDEVICE _In_ WDF_SPECIAL_FILE_TYPE FileType
Definition: wdfdevice.h:2741
_Must_inspect_result_ _In_opt_ WDFKEY _In_ PCUNICODE_STRING _In_ ACCESS_MASK _In_ ULONG _Out_opt_ PULONG CreateDisposition
Definition: wdfregistry.h:120
_Out_ PHANDLE EventHandle
Definition: iofuncs.h:857
@ Executive
Definition: ketypes.h:403
#define ObDereferenceObject
Definition: obfuncs.h:203
_In_ PSTRING FullName
Definition: rtlfuncs.h:1648
__wchar_t WCHAR
Definition: xmlstorage.h:180