ntoskrnl/config/cmlazy.c

   1 /*
   2  * PROJECT:         ReactOS Kernel
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            ntoskrnl/config/cmapi.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 */
 266     CmpInitializeHiveList(SetupBoot);
 267 }
 268
 269 NTSTATUS
 270 NTAPI
 271 CmpCmdHiveOpen(IN POBJECT_ATTRIBUTES FileAttributes,
 272                IN PSECURITY_CLIENT_CONTEXT ImpersonationContext,
 273                IN OUT PBOOLEAN Allocate,
 274                OUT PCMHIVE *NewHive,
 275                IN ULONG CheckFlags)
 276 {
 277     PUNICODE_STRING FileName;
 278     NTSTATUS Status;
 279     PAGED_CODE();
 280
 281     /* Open the file in the current security context */
 282     FileName = FileAttributes->ObjectName;
 283     Status = CmpInitHiveFromFile(FileName,
 284                                  0,
 285                                  NewHive,
 286                                  Allocate,
 287                                  CheckFlags);
 288     if (((Status == STATUS_ACCESS_DENIED) ||
 289          (Status == STATUS_NO_SUCH_USER) ||
 290          (Status == STATUS_WRONG_PASSWORD) ||
 291          (Status == STATUS_ACCOUNT_EXPIRED) ||
 292          (Status == STATUS_ACCOUNT_DISABLED) ||
 293          (Status == STATUS_ACCOUNT_RESTRICTION)) &&
 294         (ImpersonationContext))
 295     {
 296         /* We failed due to an account/security error, impersonate SYSTEM */
 297         Status = SeImpersonateClientEx(ImpersonationContext, NULL);
 298         if (NT_SUCCESS(Status))
 299         {
 300             /* Now try again */
 301             Status = CmpInitHiveFromFile(FileName,
 302                                          0,
 303                                          NewHive,
 304                                          Allocate,
 305                                          CheckFlags);
 306
 307             /* Restore impersonation token */
 308             PsRevertToSelf();
 309         }
 310     }
 311
 312     /* Return status of open attempt */
 313     return Status;
 314 }
 315
 316 VOID
 317 NTAPI
 318 CmpShutdownWorkers(VOID)
 319 {
 320     /* Stop lazy flushing */
 321     PAGED_CODE();
 322     KeCancelTimer(&CmpLazyFlushTimer);
 323 }
 324
 325 VOID
 326 NTAPI
 327 CmSetLazyFlushState(IN BOOLEAN Enable)
 328 {
 329     /* Set state for lazy flusher */
 330     CmpHoldLazyFlush = !Enable;
 331 }
 332
 333 /* EOF */