[NTOS] Configuration Manager fixes.
[reactos.git] / ntoskrnl / config / cmlazy.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/config/cmlazy.c
5 * PURPOSE: Configuration Manager - Internal Registry APIs
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 /* GLOBALS ********************************************************************/
16
17 KTIMER CmpLazyFlushTimer;
18 KDPC CmpLazyFlushDpc;
19 WORK_QUEUE_ITEM CmpLazyWorkItem;
20 KTIMER CmpEnableLazyFlushTimer;
21 KDPC CmpEnableLazyFlushDpc;
22 BOOLEAN CmpLazyFlushPending;
23 BOOLEAN CmpForceForceFlush;
24 BOOLEAN CmpHoldLazyFlush = TRUE;
25 ULONG CmpLazyFlushIntervalInSeconds = 5;
26 static ULONG CmpLazyFlushHiveCount = 7;
27 ULONG CmpLazyFlushCount = 1;
28 LONG CmpFlushStarveWriters;
29
30 /* FUNCTIONS ******************************************************************/
31
32 BOOLEAN
33 NTAPI
34 CmpDoFlushNextHive(_In_ BOOLEAN ForceFlush,
35 _Out_ PBOOLEAN Error,
36 _Out_ PULONG DirtyCount)
37 {
38 NTSTATUS Status;
39 PLIST_ENTRY NextEntry;
40 PCMHIVE CmHive;
41 BOOLEAN Result;
42 ULONG HiveCount = CmpLazyFlushHiveCount;
43
44 /* Set Defaults */
45 *Error = FALSE;
46 *DirtyCount = 0;
47
48 /* Don't do anything if we're not supposed to */
49 if (CmpNoWrite) return TRUE;
50
51 /* Make sure we have to flush at least one hive */
52 if (!HiveCount) HiveCount = 1;
53
54 /* Acquire the list lock and loop */
55 ExAcquirePushLockShared(&CmpHiveListHeadLock);
56 NextEntry = CmpHiveListHead.Flink;
57 while ((NextEntry != &CmpHiveListHead) && HiveCount)
58 {
59 /* Get the hive and check if we should flush it */
60 CmHive = CONTAINING_RECORD(NextEntry, CMHIVE, HiveList);
61 if (!(CmHive->Hive.HiveFlags & HIVE_NOLAZYFLUSH) &&
62 (CmHive->FlushCount != CmpLazyFlushCount))
63 {
64 /* Great sucess! */
65 Result = TRUE;
66
67 /* One less to flush */
68 HiveCount--;
69
70 /* Ignore clean or volatile hives */
71 if ((!CmHive->Hive.DirtyCount && !ForceFlush) ||
72 (CmHive->Hive.HiveFlags & HIVE_VOLATILE))
73 {
74 /* Don't do anything but do update the count */
75 CmHive->FlushCount = CmpLazyFlushCount;
76 DPRINT("Hive %wZ is clean.\n", &CmHive->FileFullPath);
77 }
78 else
79 {
80 /* Do the sync */
81 DPRINT("Flushing: %wZ\n", &CmHive->FileFullPath);
82 DPRINT("Handle: %p\n", CmHive->FileHandles[HFILE_TYPE_PRIMARY]);
83 Status = HvSyncHive(&CmHive->Hive);
84 if(!NT_SUCCESS(Status))
85 {
86 /* Let them know we failed */
87 DPRINT1("Failed to flush %wZ on handle %p (status 0x%08lx)\n",
88 &CmHive->FileFullPath, CmHive->FileHandles[HFILE_TYPE_PRIMARY], Status);
89 *Error = TRUE;
90 Result = FALSE;
91 break;
92 }
93 CmHive->FlushCount = CmpLazyFlushCount;
94 }
95 }
96 else if ((CmHive->Hive.DirtyCount) &&
97 (!(CmHive->Hive.HiveFlags & HIVE_VOLATILE)) &&
98 (!(CmHive->Hive.HiveFlags & HIVE_NOLAZYFLUSH)))
99 {
100 /* Use another lazy flusher for this hive */
101 ASSERT(CmHive->FlushCount == CmpLazyFlushCount);
102 *DirtyCount += CmHive->Hive.DirtyCount;
103 DPRINT("CmHive %wZ already uptodate.\n", &CmHive->FileFullPath);
104 }
105
106 /* Try the next one */
107 NextEntry = NextEntry->Flink;
108 }
109
110 /* Check if we've flushed everything */
111 if (NextEntry == &CmpHiveListHead)
112 {
113 /* We have, tell the caller we're done */
114 Result = FALSE;
115 }
116 else
117 {
118 /* We need to be called again */
119 Result = TRUE;
120 }
121
122 /* Unlock the list and return the result */
123 ExReleasePushLock(&CmpHiveListHeadLock);
124 return Result;
125 }
126
127 _Function_class_(KDEFERRED_ROUTINE)
128 VOID
129 NTAPI
130 CmpEnableLazyFlushDpcRoutine(IN PKDPC Dpc,
131 IN PVOID DeferredContext,
132 IN PVOID SystemArgument1,
133 IN PVOID SystemArgument2)
134 {
135 /* Don't stop lazy flushing from happening anymore */
136 CmpHoldLazyFlush = FALSE;
137 }
138
139 _Function_class_(KDEFERRED_ROUTINE)
140 VOID
141 NTAPI
142 CmpLazyFlushDpcRoutine(IN PKDPC Dpc,
143 IN PVOID DeferredContext,
144 IN PVOID SystemArgument1,
145 IN PVOID SystemArgument2)
146 {
147 /* Check if we should queue the lazy flush worker */
148 DPRINT("Flush pending: %s, Holding lazy flush: %s.\n", CmpLazyFlushPending ? "yes" : "no", CmpHoldLazyFlush ? "yes" : "no");
149 if ((!CmpLazyFlushPending) && (!CmpHoldLazyFlush))
150 {
151 CmpLazyFlushPending = TRUE;
152 ExQueueWorkItem(&CmpLazyWorkItem, DelayedWorkQueue);
153 }
154 }
155
156 VOID
157 NTAPI
158 CmpLazyFlush(VOID)
159 {
160 LARGE_INTEGER DueTime;
161 PAGED_CODE();
162
163 /* Check if we should set the lazy flush timer */
164 if ((!CmpNoWrite) && (!CmpHoldLazyFlush))
165 {
166 /* Do it */
167 DueTime.QuadPart = Int32x32To64(CmpLazyFlushIntervalInSeconds,
168 -10 * 1000 * 1000);
169 KeSetTimer(&CmpLazyFlushTimer, DueTime, &CmpLazyFlushDpc);
170 }
171 }
172
173 _Function_class_(WORKER_THREAD_ROUTINE)
174 VOID
175 NTAPI
176 CmpLazyFlushWorker(IN PVOID Parameter)
177 {
178 BOOLEAN ForceFlush, Result, MoreWork = FALSE;
179 ULONG DirtyCount = 0;
180 PAGED_CODE();
181
182 /* Don't do anything if lazy flushing isn't enabled yet */
183 if (CmpHoldLazyFlush)
184 {
185 DPRINT1("Lazy flush held. Bye bye.\n");
186 CmpLazyFlushPending = FALSE;
187 return;
188 }
189
190 /* Check if we are forcing a flush */
191 ForceFlush = CmpForceForceFlush;
192 if (ForceFlush)
193 {
194 DPRINT("Forcing flush.\n");
195 /* Lock the registry exclusively */
196 CmpLockRegistryExclusive();
197 }
198 else
199 {
200 DPRINT("Not forcing flush.\n");
201 /* Starve writers before locking */
202 InterlockedIncrement(&CmpFlushStarveWriters);
203 CmpLockRegistry();
204 }
205
206 /* Flush the next hive */
207 MoreWork = CmpDoFlushNextHive(ForceFlush, &Result, &DirtyCount);
208 if (!MoreWork)
209 {
210 /* We're done */
211 InterlockedIncrement((PLONG)&CmpLazyFlushCount);
212 }
213
214 /* Check if we have starved writers */
215 if (!ForceFlush)
216 InterlockedDecrement(&CmpFlushStarveWriters);
217
218 /* Not pending anymore, release the registry lock */
219 CmpLazyFlushPending = FALSE;
220 CmpUnlockRegistry();
221
222 DPRINT("Lazy flush done. More work to be done: %s. Entries still dirty: %u.\n",
223 MoreWork ? "Yes" : "No", DirtyCount);
224
225 if (MoreWork)
226 {
227 /* Relaunch the flush timer, so the remaining hives get flushed */
228 CmpLazyFlush();
229 }
230 }
231
232 VOID
233 NTAPI
234 CmpCmdInit(IN BOOLEAN SetupBoot)
235 {
236 LARGE_INTEGER DueTime;
237 PAGED_CODE();
238
239 /* Setup the lazy DPC */
240 KeInitializeDpc(&CmpLazyFlushDpc, CmpLazyFlushDpcRoutine, NULL);
241
242 /* Setup the lazy timer */
243 KeInitializeTimer(&CmpLazyFlushTimer);
244
245 /* Setup the lazy worker */
246 ExInitializeWorkItem(&CmpLazyWorkItem, CmpLazyFlushWorker, NULL);
247
248 /* Setup the forced-lazy DPC and timer */
249 KeInitializeDpc(&CmpEnableLazyFlushDpc,
250 CmpEnableLazyFlushDpcRoutine,
251 NULL);
252 KeInitializeTimer(&CmpEnableLazyFlushTimer);
253
254 /* Enable lazy flushing after 10 minutes */
255 DueTime.QuadPart = Int32x32To64(600, -10 * 1000 * 1000);
256 KeSetTimer(&CmpEnableLazyFlushTimer, DueTime, &CmpEnableLazyFlushDpc);
257
258 /* Setup flush variables */
259 CmpNoWrite = CmpMiniNTBoot;
260 CmpWasSetupBoot = SetupBoot;
261
262 /* Testing: Force Lazy Flushing */
263 CmpHoldLazyFlush = FALSE;
264
265 /* Setup the hive list if this is not a Setup boot */
266 if (!SetupBoot)
267 CmpInitializeHiveList();
268 }
269
270 NTSTATUS
271 NTAPI
272 CmpCmdHiveOpen(IN POBJECT_ATTRIBUTES FileAttributes,
273 IN PSECURITY_CLIENT_CONTEXT ImpersonationContext,
274 IN OUT PBOOLEAN Allocate,
275 OUT PCMHIVE *NewHive,
276 IN ULONG CheckFlags)
277 {
278 NTSTATUS Status;
279 UNICODE_STRING FileName;
280 PWCHAR FilePath;
281 UCHAR Buffer[sizeof(OBJECT_NAME_INFORMATION) + MAX_PATH * sizeof(WCHAR)];
282 ULONG Length = sizeof(Buffer);
283 POBJECT_NAME_INFORMATION FileNameInfo = (POBJECT_NAME_INFORMATION)Buffer;
284
285 PAGED_CODE();
286
287 if (FileAttributes->RootDirectory)
288 {
289 /*
290 * Validity check: The ObjectName is relative to RootDirectory,
291 * therefore it must not start with a path separator.
292 */
293 if (FileAttributes->ObjectName && FileAttributes->ObjectName->Buffer &&
294 FileAttributes->ObjectName->Length >= sizeof(WCHAR) &&
295 *FileAttributes->ObjectName->Buffer == OBJ_NAME_PATH_SEPARATOR)
296 {
297 return STATUS_OBJECT_PATH_SYNTAX_BAD;
298 }
299
300 /* Try to get the value */
301 Status = ZwQueryObject(FileAttributes->RootDirectory,
302 ObjectNameInformation,
303 FileNameInfo,
304 Length,
305 &Length);
306 if (!NT_SUCCESS(Status))
307 {
308 /* Fail */
309 DPRINT1("CmpCmdHiveOpen(): Root directory handle object name query failed, Status = 0x%08lx\n", Status);
310 return Status;
311 }
312
313 /* Null-terminate and add the length of the terminator */
314 Length -= sizeof(OBJECT_NAME_INFORMATION);
315 FilePath = FileNameInfo->Name.Buffer;
316 FilePath[Length / sizeof(WCHAR)] = UNICODE_NULL;
317 Length += sizeof(UNICODE_NULL);
318
319 /* Compute the size of the full path; Length already counts the terminating NULL */
320 Length = Length + sizeof(WCHAR) + FileAttributes->ObjectName->Length;
321 if (Length > MAXUSHORT)
322 {
323 /* Name size too long, bail out */
324 return STATUS_OBJECT_PATH_INVALID;
325 }
326
327 /* Build the full path */
328 RtlInitEmptyUnicodeString(&FileName, NULL, 0);
329 FileName.Buffer = ExAllocatePoolWithTag(PagedPool, Length, TAG_CM);
330 if (!FileName.Buffer)
331 {
332 /* Fail */
333 DPRINT1("CmpCmdHiveOpen(): Unable to allocate memory\n");
334 return STATUS_INSUFFICIENT_RESOURCES;
335 }
336 FileName.MaximumLength = Length;
337 RtlCopyUnicodeString(&FileName, &FileNameInfo->Name);
338
339 /*
340 * Append a path terminator if needed (we have already accounted
341 * for a possible extra one when allocating the buffer).
342 */
343 if (/* FileAttributes->ObjectName->Buffer[0] != OBJ_NAME_PATH_SEPARATOR && */ // We excluded ObjectName starting with a path separator above.
344 FileName.Length > 0 && FileName.Buffer[FileName.Length / sizeof(WCHAR) - 1] != OBJ_NAME_PATH_SEPARATOR)
345 {
346 /* ObjectName does not start with '\' and PathBuffer does not end with '\' */
347 FileName.Buffer[FileName.Length / sizeof(WCHAR)] = OBJ_NAME_PATH_SEPARATOR;
348 FileName.Length += sizeof(WCHAR);
349 FileName.Buffer[FileName.Length / sizeof(WCHAR)] = UNICODE_NULL;
350 }
351
352 /* Append the object name */
353 Status = RtlAppendUnicodeStringToString(&FileName, FileAttributes->ObjectName);
354 if (!NT_SUCCESS(Status))
355 {
356 /* Fail */
357 DPRINT1("CmpCmdHiveOpen(): RtlAppendUnicodeStringToString() failed, Status = 0x%08lx\n", Status);
358 ExFreePoolWithTag(FileName.Buffer, TAG_CM);
359 return Status;
360 }
361 }
362 else
363 {
364 FileName = *FileAttributes->ObjectName;
365 }
366
367 /* Open the file in the current security context */
368 Status = CmpInitHiveFromFile(&FileName,
369 0,
370 NewHive,
371 Allocate,
372 CheckFlags);
373 if (((Status == STATUS_ACCESS_DENIED) ||
374 (Status == STATUS_NO_SUCH_USER) ||
375 (Status == STATUS_WRONG_PASSWORD) ||
376 (Status == STATUS_ACCOUNT_EXPIRED) ||
377 (Status == STATUS_ACCOUNT_DISABLED) ||
378 (Status == STATUS_ACCOUNT_RESTRICTION)) &&
379 (ImpersonationContext))
380 {
381 /* We failed due to an account/security error, impersonate SYSTEM */
382 Status = SeImpersonateClientEx(ImpersonationContext, NULL);
383 if (NT_SUCCESS(Status))
384 {
385 /* Now try again */
386 Status = CmpInitHiveFromFile(&FileName,
387 0,
388 NewHive,
389 Allocate,
390 CheckFlags);
391
392 /* Restore impersonation token */
393 PsRevertToSelf();
394 }
395 }
396
397 if (FileAttributes->RootDirectory)
398 {
399 ExFreePoolWithTag(FileName.Buffer, TAG_CM);
400 }
401
402 /* Return status of open attempt */
403 return Status;
404 }
405
406 VOID
407 NTAPI
408 CmpShutdownWorkers(VOID)
409 {
410 /* Stop lazy flushing */
411 PAGED_CODE();
412 KeCancelTimer(&CmpLazyFlushTimer);
413 }
414
415 VOID
416 NTAPI
417 CmSetLazyFlushState(IN BOOLEAN Enable)
418 {
419 /* Set state for lazy flusher */
420 CmpHoldLazyFlush = !Enable;
421 }
422
423 /* EOF */