xref: /reactos/ntoskrnl/config/cminit.c (revision d09998df) 
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 
17 NTSTATUS
18 NTAPI
19 CmpInitializeHive(OUT PCMHIVE *CmHive,
20                   IN ULONG OperationType,
21                   IN ULONG HiveFlags,
22                   IN ULONG FileType,
23                   IN PVOID HiveData OPTIONAL,
24                   IN HANDLE Primary,
25                   IN HANDLE Log,
26                   IN HANDLE External,
27                   IN PCUNICODE_STRING FileName OPTIONAL,
28                   IN ULONG CheckFlags)
29 {
30     PCMHIVE Hive;
31     IO_STATUS_BLOCK IoStatusBlock;
32     FILE_FS_SIZE_INFORMATION FileSizeInformation;
33     NTSTATUS Status;
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 */
56         return STATUS_INVALID_PARAMETER;
57     }
58 
59     /* Check if this is a primary hive */
60     if (Primary)
61     {
62         /* Get the cluster size */
63         Status = ZwQueryVolumeInformationFile(Primary,
64                                               &IoStatusBlock,
65                                               &FileSizeInformation,
66                                               sizeof(FILE_FS_SIZE_INFORMATION),
67                                               FileFsSizeInformation);
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 */
74             return STATUS_REGISTRY_IO_FAILED;
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 */
88     Hive = ExAllocatePoolWithTag(NonPagedPool, sizeof(CMHIVE), TAG_CMHIVE);
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 loading flag */
106     Hive->HiveIsLoading = TRUE;
107 
108     /* Set the current thread as creator */
109     Hive->CreatorOwner = KeGetCurrentThread();
110 
111     /* Initialize lists */
112     InitializeListHead(&Hive->KcbConvertListHead);
113     InitializeListHead(&Hive->KnodeConvertListHead);
114     InitializeListHead(&Hive->TrustClassEntry);
115 
116     /* Allocate the view log */
117     Hive->ViewLock = ExAllocatePoolWithTag(NonPagedPool,
118                                            sizeof(KGUARDED_MUTEX),
119                                            TAG_CMHIVE);
120     if (!Hive->ViewLock)
121     {
122         /* Cleanup allocation and fail */
123         ExFreePoolWithTag(Hive, TAG_CMHIVE);
124         return STATUS_INSUFFICIENT_RESOURCES;
125     }
126 
127     /* Allocate the flush lock */
128     Hive->FlusherLock = ExAllocatePoolWithTag(NonPagedPool,
129                                               sizeof(ERESOURCE),
130                                               TAG_CMHIVE);
131     if (!Hive->FlusherLock)
132     {
133         /* Cleanup allocations and fail */
134         ExFreePoolWithTag(Hive->ViewLock, TAG_CMHIVE);
135         ExFreePoolWithTag(Hive, TAG_CMHIVE);
136         return STATUS_INSUFFICIENT_RESOURCES;
137     }
138 
139     /* Setup the handles */
140     Hive->FileHandles[HFILE_TYPE_PRIMARY] = Primary;
141     Hive->FileHandles[HFILE_TYPE_LOG] = Log;
142     Hive->FileHandles[HFILE_TYPE_EXTERNAL] = External;
143 
144     /* Initailize the guarded mutex */
145     KeInitializeGuardedMutex(Hive->ViewLock);
146     Hive->ViewLockOwner = NULL;
147 
148     /* Initialize the flush lock */
149     ExInitializeResourceLite(Hive->FlusherLock);
150 
151     /* Setup hive locks */
152     ExInitializePushLock(&Hive->HiveLock);
153     Hive->HiveLockOwner = NULL;
154     ExInitializePushLock(&Hive->WriterLock);
155     Hive->WriterLockOwner = NULL;
156     ExInitializePushLock(&Hive->SecurityLock);
157     Hive->HiveSecurityLockOwner = NULL;
158 
159     /* Clear file names */
160     RtlInitEmptyUnicodeString(&Hive->FileUserName, NULL, 0);
161     RtlInitEmptyUnicodeString(&Hive->FileFullPath, NULL, 0);
162 
163     /* Initialize the view list */
164     CmpInitHiveViewList(Hive);
165 
166     /* Initailize the security cache */
167     CmpInitSecurityCache(Hive);
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,
179                           CmpAllocate,
180                           CmpFree,
181                           CmpFileSetSize,
182                           CmpFileWrite,
183                           CmpFileRead,
184                           CmpFileFlush,
185                           Cluster,
186                           FileName);
187     if (!NT_SUCCESS(Status))
188     {
189         /* Cleanup allocations and fail */
190         ExDeleteResourceLite(Hive->FlusherLock);
191         ExFreePoolWithTag(Hive->FlusherLock, TAG_CMHIVE);
192         ExFreePoolWithTag(Hive->ViewLock, TAG_CMHIVE);
193         ExFreePoolWithTag(Hive, TAG_CMHIVE);
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 */
208             ExDeleteResourceLite(Hive->FlusherLock);
209             ExFreePoolWithTag(Hive->FlusherLock, TAG_CMHIVE);
210             ExFreePoolWithTag(Hive->ViewLock, TAG_CMHIVE);
211             ExFreePoolWithTag(Hive, TAG_CMHIVE);
212             return STATUS_REGISTRY_CORRUPT;
213         }
214     }
215 
216     /* Lock the hive list */
217     ExAcquirePushLockExclusive(&CmpHiveListHeadLock);
218 
219     /* Insert this hive */
220     InsertHeadList(&CmpHiveListHead, &Hive->HiveList);
221 
222     /* Release the lock */
223     ExReleasePushLock(&CmpHiveListHeadLock);
224 
225     /* Return the hive and success */
226     *CmHive = Hive;
227     return STATUS_SUCCESS;
228 }
229 
230 NTSTATUS
231 NTAPI
232 CmpDestroyHive(IN PCMHIVE CmHive)
233 {
234     /* Remove the hive from the list */
235     ExAcquirePushLockExclusive(&CmpHiveListHeadLock);
236     RemoveEntryList(&CmHive->HiveList);
237     ExReleasePushLock(&CmpHiveListHeadLock);
238 
239     /* Destroy the security descriptor cache */
240     CmpDestroySecurityCache(CmHive);
241 
242     /* Destroy the view list */
243     CmpDestroyHiveViewList(CmHive);
244 
245     /* Delete the flusher lock */
246     ExDeleteResourceLite(CmHive->FlusherLock);
247     ExFreePoolWithTag(CmHive->FlusherLock, TAG_CMHIVE);
248 
249     /* Delete the view lock */
250     ExFreePoolWithTag(CmHive->ViewLock, TAG_CMHIVE);
251 
252     /* Free the hive storage */
253     HvFree(&CmHive->Hive);
254 
255     /* Free the hive */
256     CmpFree(CmHive, TAG_CM);
257 
258     return STATUS_SUCCESS;
259 }
260 
261 NTSTATUS
262 NTAPI
263 CmpOpenHiveFiles(IN PCUNICODE_STRING BaseName,
264                  IN PCWSTR Extension OPTIONAL,
265                  OUT PHANDLE Primary,
266                  OUT PHANDLE Log,
267                  OUT PULONG PrimaryDisposition,
268                  OUT PULONG LogDisposition,
269                  IN BOOLEAN CreateAllowed,
270                  IN BOOLEAN MarkAsSystemHive,
271                  IN BOOLEAN NoBuffering,
272                  OUT PULONG ClusterSize OPTIONAL)
273 {
274     HANDLE EventHandle;
275     PKEVENT Event;
276     NTSTATUS Status;
277     UNICODE_STRING FullName, ExtensionName;
278     PWCHAR NameBuffer;
279     USHORT Length;
280     OBJECT_ATTRIBUTES ObjectAttributes;
281     IO_STATUS_BLOCK IoStatusBlock;
282     ULONG AttributeFlags, ShareMode, DesiredAccess, CreateDisposition, IoFlags;
283     USHORT CompressionState;
284     FILE_STANDARD_INFORMATION FileInformation;
285     FILE_FS_SIZE_INFORMATION FsSizeInformation;
286 
287     /* Create event */
288     Status = CmpCreateEvent(NotificationEvent, &EventHandle, &Event);
289     if (!NT_SUCCESS(Status)) return Status;
290 
291     /* Initialize the full name */
292     RtlInitEmptyUnicodeString(&FullName, NULL, 0);
293     Length = BaseName->Length;
294 
295     /* Check if we have an extension */
296     if (Extension)
297     {
298         /* Update the name length */
299         Length += (USHORT)wcslen(Extension) * sizeof(WCHAR) + sizeof(UNICODE_NULL);
300 
301         /* Allocate the buffer for the full name */
302         NameBuffer = ExAllocatePoolWithTag(PagedPool, Length, TAG_CM);
303         if (!NameBuffer)
304         {
305             /* Fail */
306             ObDereferenceObject(Event);
307             ZwClose(EventHandle);
308             return STATUS_NO_MEMORY;
309         }
310 
311         /* Build the full name */
312         FullName.Buffer = NameBuffer;
313         FullName.MaximumLength = Length;
314         RtlCopyUnicodeString(&FullName, BaseName);
315     }
316     else
317     {
318         /* The base name is the full name */
319         FullName = *BaseName;
320         NameBuffer = NULL;
321     }
322 
323     /* Initialize the attributes */
324     InitializeObjectAttributes(&ObjectAttributes,
325                                &FullName,
326                                OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
327                                NULL,
328                                NULL);
329 
330     /* Check if we can create the hive */
331     if ((CreateAllowed) && !(CmpShareSystemHives))
332     {
333         /* Open only or create */
334         CreateDisposition = FILE_OPEN_IF;
335     }
336     else
337     {
338         /* Open only */
339         CreateDisposition = FILE_OPEN;
340     }
341 
342     /* Setup the flags */
343     // FIXME : FILE_OPEN_FOR_BACKUP_INTENT is unimplemented and breaks 3rd stage boot
344     IoFlags = //FILE_OPEN_FOR_BACKUP_INTENT |
345               FILE_NO_COMPRESSION |
346               FILE_RANDOM_ACCESS |
347               (NoBuffering ? FILE_NO_INTERMEDIATE_BUFFERING : 0);
348 
349     /* Set share and access modes */
350     if ((CmpMiniNTBoot) && (CmpShareSystemHives))
351     {
352         /* We're on Live CD or otherwise sharing */
353         DesiredAccess = FILE_READ_DATA;
354         ShareMode = FILE_SHARE_READ;
355     }
356     else
357     {
358         /* We want to write exclusively */
359         ShareMode = 0;
360         DesiredAccess = FILE_READ_DATA | FILE_WRITE_DATA;
361     }
362 
363     /* Default attributes */
364     AttributeFlags = FILE_ATTRIBUTE_NORMAL;
365 
366     /* Now create the file */
367     Status = ZwCreateFile(Primary,
368                           DesiredAccess | SYNCHRONIZE,
369                           &ObjectAttributes,
370                           &IoStatusBlock,
371                           NULL,
372                           AttributeFlags,
373                           ShareMode,
374                           CreateDisposition,
375                           FILE_SYNCHRONOUS_IO_NONALERT | IoFlags,
376                           NULL,
377                           0);
378     /* Check if anything failed until now */
379     if (!NT_SUCCESS(Status))
380     {
381         DPRINT1("ZwCreateFile(%wZ) failed, Status 0x%08lx.\n", ObjectAttributes.ObjectName, Status);
382 
383         /* Close handles and free buffers */
384         if (NameBuffer) ExFreePoolWithTag(NameBuffer, TAG_CM);
385         ObDereferenceObject(Event);
386         ZwClose(EventHandle);
387         *Primary = NULL;
388         return Status;
389     }
390 
391     if (MarkAsSystemHive)
392     {
393         /* We opened it, mark it as a system hive */
394         Status = ZwFsControlFile(*Primary,
395                                  EventHandle,
396                                  NULL,
397                                  NULL,
398                                  &IoStatusBlock,
399                                  FSCTL_MARK_AS_SYSTEM_HIVE,
400                                  NULL,
401                                  0,
402                                  NULL,
403                                  0);
404         if (Status == STATUS_PENDING)
405         {
406             /* Wait for completion */
407             KeWaitForSingleObject(Event,
408                                   Executive,
409                                   KernelMode,
410                                   FALSE,
411                                   NULL);
412             Status = IoStatusBlock.Status;
413         }
414 
415         /* If we don't support it, ignore the failure */
416         if (Status == STATUS_INVALID_DEVICE_REQUEST) Status = STATUS_SUCCESS;
417 
418         if (!NT_SUCCESS(Status))
419         {
420             /* Close handles and free buffers */
421             if (NameBuffer) ExFreePoolWithTag(NameBuffer, TAG_CM);
422             ObDereferenceObject(Event);
423             ZwClose(EventHandle);
424             ZwClose(*Primary);
425             *Primary = NULL;
426             return Status;
427         }
428     }
429 
430     /* Disable compression */
431     CompressionState = 0;
432     Status = ZwFsControlFile(*Primary,
433                              EventHandle,
434                              NULL,
435                              NULL,
436                              &IoStatusBlock,
437                              FSCTL_SET_COMPRESSION,
438                              &CompressionState,
439                              sizeof(CompressionState),
440                              NULL,
441                              0);
442     if (Status == STATUS_PENDING)
443     {
444         /* Wait for completion */
445         KeWaitForSingleObject(Event,
446                               Executive,
447                               KernelMode,
448                               FALSE,
449                               NULL);
450     }
451 
452     /* Get the disposition */
453     *PrimaryDisposition = (ULONG)IoStatusBlock.Information;
454     if (IoStatusBlock.Information != FILE_CREATED)
455     {
456         /* Check how large the file is */
457         Status = ZwQueryInformationFile(*Primary,
458                                         &IoStatusBlock,
459                                         &FileInformation,
460                                         sizeof(FileInformation),
461                                         FileStandardInformation);
462         if (NT_SUCCESS(Status))
463         {
464             /* Check if it's 0 bytes */
465             if (!FileInformation.EndOfFile.QuadPart)
466             {
467                 /* Assume it's a new file */
468                 *PrimaryDisposition = FILE_CREATED;
469             }
470         }
471     }
472 
473     /* Check if the caller wants cluster size returned */
474     if (ClusterSize)
475     {
476         /* Query it */
477         Status = ZwQueryVolumeInformationFile(*Primary,
478                                               &IoStatusBlock,
479                                               &FsSizeInformation,
480                                               sizeof(FsSizeInformation),
481                                               FileFsSizeInformation);
482         if (!NT_SUCCESS(Status))
483         {
484             /* Close handles and free buffers */
485             if (NameBuffer) ExFreePoolWithTag(NameBuffer, TAG_CM);
486             ObDereferenceObject(Event);
487             ZwClose(EventHandle);
488             return Status;
489         }
490 
491         /* Check if the sector size is invalid */
492         if (FsSizeInformation.BytesPerSector > HBLOCK_SIZE)
493         {
494             /* Close handles and free buffers */
495             if (NameBuffer) ExFreePoolWithTag(NameBuffer, TAG_CM);
496             ObDereferenceObject(Event);
497             ZwClose(EventHandle);
498             return STATUS_CANNOT_LOAD_REGISTRY_FILE;
499         }
500 
501         /* Return cluster size */
502         *ClusterSize = max(1, FsSizeInformation.BytesPerSector / HSECTOR_SIZE);
503     }
504 
505     /* Check if we don't need to create a log file */
506     if (!Extension)
507     {
508         /* We're done, close handles */
509         ObDereferenceObject(Event);
510         ZwClose(EventHandle);
511         return STATUS_SUCCESS;
512     }
513 
514     /* Check if we can create the hive */
515     CreateDisposition = CmpShareSystemHives ? FILE_OPEN : FILE_OPEN_IF;
516     if (*PrimaryDisposition == FILE_CREATED)
517     {
518         /* Over-write the existing log file, since this is a new hive */
519         CreateDisposition = FILE_SUPERSEDE;
520     }
521 
522     /* Setup the name */
523     RtlInitUnicodeString(&ExtensionName, Extension);
524     RtlAppendUnicodeStringToString(&FullName, &ExtensionName);
525 
526     /* Initialize the attributes */
527     InitializeObjectAttributes(&ObjectAttributes,
528                                &FullName,
529                                OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
530                                NULL,
531                                NULL);
532 
533     /* Setup the flags */
534     IoFlags = FILE_NO_COMPRESSION | FILE_NO_INTERMEDIATE_BUFFERING;
535 
536     /* Check if this is a log file */
537     if (!_wcsnicmp(Extension, L".log", 4))
538     {
539         /* Hide log files */
540         AttributeFlags |= FILE_ATTRIBUTE_HIDDEN;
541     }
542 
543     /* Now create the file */
544     Status = ZwCreateFile(Log,
545                           DesiredAccess,
546                           &ObjectAttributes,
547                           &IoStatusBlock,
548                           NULL,
549                           AttributeFlags,
550                           ShareMode,
551                           CreateDisposition,
552                           IoFlags,
553                           NULL,
554                           0);
555     if ((NT_SUCCESS(Status)) && (MarkAsSystemHive))
556     {
557         /* We opened it, mark it as a system hive */
558         Status = ZwFsControlFile(*Log,
559                                  EventHandle,
560                                  NULL,
561                                  NULL,
562                                  &IoStatusBlock,
563                                  FSCTL_MARK_AS_SYSTEM_HIVE,
564                                  NULL,
565                                  0,
566                                  NULL,
567                                  0);
568         if (Status == STATUS_PENDING)
569         {
570             /* Wait for completion */
571             KeWaitForSingleObject(Event,
572                                   Executive,
573                                   KernelMode,
574                                   FALSE,
575                                   NULL);
576             Status = IoStatusBlock.Status;
577         }
578 
579         /* If we don't support it, ignore the failure */
580         if (Status == STATUS_INVALID_DEVICE_REQUEST) Status = STATUS_SUCCESS;
581 
582         /* If we failed, close the handle */
583         if (!NT_SUCCESS(Status)) ZwClose(*Log);
584     }
585 
586     /* Check if anything failed until now */
587     if (!NT_SUCCESS(Status))
588     {
589         /* Clear the handle */
590         *Log = NULL;
591     }
592     else
593     {
594         /* Disable compression */
595         Status = ZwFsControlFile(*Log,
596                                  EventHandle,
597                                  NULL,
598                                  NULL,
599                                  &IoStatusBlock,
600                                  FSCTL_SET_COMPRESSION,
601                                  &CompressionState,
602                                  sizeof(CompressionState),
603                                  NULL,
604                                  0);
605         if (Status == STATUS_PENDING)
606         {
607             /* Wait for completion */
608             KeWaitForSingleObject(Event,
609                                   Executive,
610                                   KernelMode,
611                                   FALSE,
612                                   NULL);
613         }
614 
615         /* Return the disposition */
616         *LogDisposition = (ULONG)IoStatusBlock.Information;
617     }
618 
619     /* We're done, close handles and free buffers */
620     if (NameBuffer) ExFreePoolWithTag(NameBuffer, TAG_CM);
621     ObDereferenceObject(Event);
622     ZwClose(EventHandle);
623     return STATUS_SUCCESS;
624 }
625 
626 VOID
627 NTAPI
628 CmpCloseHiveFiles(IN PCMHIVE Hive)
629 {
630     ULONG i;
631 
632     for (i = 0; i < HFILE_TYPE_MAX; i++)
633     {
634         if (Hive->FileHandles[i] != NULL)
635         {
636             ZwClose(Hive->FileHandles[i]);
637             Hive->FileHandles[i] = NULL;
638         }
639     }
640 }
641