ntoskrnl/ex/rundown.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel
   4  * FILE:            ntoskrnl/ex/rundown.c
   5  * PURPOSE:         Rundown and Cache-Aware Rundown Protection
   6  * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
   7  *                  Thomas Weidenmueller
   8  *                  Pierre Schweitzer
   9  */
  10
  11 /* INCLUDES *****************************************************************/
  12
  13 #include <ntoskrnl.h>
  14 #define NDEBUG
  15 #include <debug.h>
  16
  17 /* FUNCTIONS *****************************************************************/
  18
  19 /*++
  20  * @name ExfAcquireRundownProtection
  21  * @implemented NT5.1
  22  *
  23  *     The ExfAcquireRundownProtection routine acquires rundown protection for
  24  *     the specified descriptor.
  25  *
  26  * @param RunRef
  27  *        Pointer to a rundown reference descriptor.
  28  *
  29  * @return TRUE if access to the protected structure was granted, FALSE otherwise.
  30  *
  31  * @remarks Callers of ExfAcquireRundownProtection can be running at any IRQL.
  32  *
  33  *--*/
  34 BOOLEAN
  35 FASTCALL
  36 ExfAcquireRundownProtection(IN PEX_RUNDOWN_REF RunRef)
  37 {
  38     ULONG_PTR Value = RunRef->Count, NewValue;
  39
  40     /* Loop until successfully incremented the counter */
  41     for (;;)
  42     {
  43         /* Make sure a rundown is not active */
  44         if (Value & EX_RUNDOWN_ACTIVE) return FALSE;
  45
  46         /* Add a reference */
  47         NewValue = Value + EX_RUNDOWN_COUNT_INC;
  48
  49         /* Change the value */
  50         NewValue = ExpChangeRundown(RunRef, NewValue, Value);
  51         if (NewValue == Value) return TRUE;
  52
  53         /* Update it */
  54         Value = NewValue;
  55     }
  56 }
  57
  58 /*++
  59  * @name ExfAcquireRundownProtectionEx
  60  * @implemented NT5.2
  61  *
  62  *     The ExfAcquireRundownProtectionEx routine acquires multiple rundown
  63  *     protection references for the specified descriptor.
  64  *
  65  * @param RunRef
  66  *        Pointer to a rundown reference descriptor.
  67  *
  68  * @param Count
  69  *         Number of times to reference the descriptor.
  70  *
  71  * @return TRUE if access to the protected structure was granted, FALSE otherwise.
  72  *
  73  * @remarks Callers of ExfAcquireRundownProtectionEx can be running at any IRQL.
  74  *
  75  *--*/
  76 BOOLEAN
  77 FASTCALL
  78 ExfAcquireRundownProtectionEx(IN PEX_RUNDOWN_REF RunRef,
  79                               IN ULONG Count)
  80 {
  81     ULONG_PTR Value = RunRef->Count, NewValue;
  82
  83     /* Loop until successfully incremented the counter */
  84     for (;;)
  85     {
  86         /* Make sure a rundown is not active */
  87         if (Value & EX_RUNDOWN_ACTIVE) return FALSE;
  88
  89         /* Add references */
  90         NewValue = Value + EX_RUNDOWN_COUNT_INC * Count;
  91
  92         /* Change the value */
  93         NewValue = ExpChangeRundown(RunRef, NewValue, Value);
  94         if (NewValue == Value) return TRUE;
  95
  96         /* Update the value */
  97         Value = NewValue;
  98     }
  99 }
 100
 101 /*++
 102  * @name ExfInitializeRundownProtection
 103  * @implemented NT5.1
 104  *
 105  *     The ExfInitializeRundownProtection routine initializes a rundown
 106  *     protection descriptor.
 107  *
 108  * @param RunRef
 109  *        Pointer to a rundown reference descriptor.
 110  *
 111  * @return None.
 112  *
 113  * @remarks Callers of ExfInitializeRundownProtection can be running at any IRQL.
 114  *
 115  *--*/
 116 VOID
 117 FASTCALL
 118 ExfInitializeRundownProtection(IN PEX_RUNDOWN_REF RunRef)
 119 {
 120     /* Set the count to zero */
 121     RunRef->Count = 0;
 122 }
 123
 124 /*++
 125  * @name ExfReInitializeRundownProtection
 126  * @implemented NT5.1
 127  *
 128  *     The ExfReInitializeRundownProtection routine re-initializes a rundown
 129  *     protection descriptor.
 130  *
 131  * @param RunRef
 132  *        Pointer to a rundown reference descriptor.
 133  *
 134  * @return None.
 135  *
 136  * @remarks Callers of ExfReInitializeRundownProtection can be running at any IRQL.
 137  *
 138  *--*/
 139 VOID
 140 FASTCALL
 141 ExfReInitializeRundownProtection(IN PEX_RUNDOWN_REF RunRef)
 142 {
 143     PAGED_CODE();
 144
 145     /* Sanity check */
 146     ASSERT((RunRef->Count & EX_RUNDOWN_ACTIVE) != 0);
 147
 148     /* Reset the count */
 149     ExpSetRundown(RunRef, 0);
 150 }
 151
 152 /*++
 153  * @name ExfRundownCompleted
 154  * @implemented NT5.1
 155  *
 156  *     The ExfRundownCompleted routine completes the rundown of the specified
 157  *     descriptor by setting the active bit.
 158  *
 159  * @param RunRef
 160  *        Pointer to a rundown reference descriptor.
 161  *
 162  * @return None.
 163  *
 164  * @remarks Callers of ExfRundownCompleted must be running at IRQL <= APC_LEVEL.
 165  *
 166  *--*/
 167 VOID
 168 FASTCALL
 169 ExfRundownCompleted(IN PEX_RUNDOWN_REF RunRef)
 170 {
 171     PAGED_CODE();
 172
 173     /* Sanity check */
 174     ASSERT((RunRef->Count & EX_RUNDOWN_ACTIVE) != 0);
 175
 176     /* Mark the counter as active */
 177     ExpSetRundown(RunRef, EX_RUNDOWN_ACTIVE);
 178 }
 179
 180 /*++
 181  * @name ExfReleaseRundownProtection
 182  * @implemented NT5.1
 183  *
 184  *     The ExfReleaseRundownProtection routine releases the rundown protection
 185  *     reference for the specified descriptor.
 186  *
 187  * @param RunRef
 188  *        Pointer to a rundown reference descriptor.
 189  *
 190  * @return None.
 191  *
 192  * @remarks Callers of ExfReleaseRundownProtection can be running at any IRQL.
 193  *
 194  *--*/
 195 VOID
 196 FASTCALL
 197 ExfReleaseRundownProtection(IN PEX_RUNDOWN_REF RunRef)
 198 {
 199     ULONG_PTR Value = RunRef->Count, NewValue;
 200     PEX_RUNDOWN_WAIT_BLOCK WaitBlock;
 201
 202     /* Loop until successfully incremented the counter */
 203     for (;;)
 204     {
 205         /* Check if rundown is not active */
 206         if (!(Value & EX_RUNDOWN_ACTIVE))
 207         {
 208             /* Sanity check */
 209             ASSERT((Value >= EX_RUNDOWN_COUNT_INC) || (KeNumberProcessors > 1));
 210
 211             /* Get the new value */
 212             NewValue = Value - EX_RUNDOWN_COUNT_INC;
 213
 214             /* Change the value */
 215             NewValue = ExpChangeRundown(RunRef, NewValue, Value);
 216             if (NewValue == Value) break;
 217
 218             /* Update value */
 219             Value = NewValue;
 220         }
 221         else
 222         {
 223             /* Get the wait block */
 224             WaitBlock = (PEX_RUNDOWN_WAIT_BLOCK)(Value & ~EX_RUNDOWN_ACTIVE);
 225             ASSERT((WaitBlock->Count > 0) || (KeNumberProcessors > 1));
 226
 227             /* Remove the one count */
 228             if (!InterlockedDecrementSizeT(&WaitBlock->Count))
 229             {
 230                 /* We're down to 0 now, so signal the event */
 231                 KeSetEvent(&WaitBlock->WakeEvent, IO_NO_INCREMENT, FALSE);
 232             }
 233
 234             /* We're all done */
 235             break;
 236         }
 237     }
 238 }
 239
 240 /*++
 241  * @name ExfReleaseRundownProtectionEx
 242  * @implemented NT5.2
 243  *
 244  *     The ExfReleaseRundownProtectionEx routine releases multiple rundown
 245  *     protection references for the specified descriptor.
 246  *
 247  * @param RunRef
 248  *        Pointer to a rundown reference descriptor.
 249  *
 250  * @param Count
 251  *         Number of times to dereference the descriptor.
 252  *
 253  * @return None.
 254  *
 255  * @remarks Callers of ExfAcquireRundownProtectionEx can be running at any IRQL.
 256  *
 257  *--*/
 258 VOID
 259 FASTCALL
 260 ExfReleaseRundownProtectionEx(IN PEX_RUNDOWN_REF RunRef,
 261                               IN ULONG Count)
 262 {
 263     ULONG_PTR Value = RunRef->Count, NewValue;
 264     PEX_RUNDOWN_WAIT_BLOCK WaitBlock;
 265
 266     /* Loop until successfully incremented the counter */
 267     for (;;)
 268     {
 269         /* Check if rundown is not active */
 270         if (!(Value & EX_RUNDOWN_ACTIVE))
 271         {
 272             /* Sanity check */
 273             ASSERT((Value >= EX_RUNDOWN_COUNT_INC * Count) ||
 274                    (KeNumberProcessors > 1));
 275
 276             /* Get the new value */
 277             NewValue = Value - EX_RUNDOWN_COUNT_INC * Count;
 278
 279             /* Change the value */
 280             NewValue = ExpChangeRundown(RunRef, NewValue, Value);
 281             if (NewValue == Value) break;
 282
 283             /* Update value */
 284             Value = NewValue;
 285         }
 286         else
 287         {
 288             /* Get the wait block */
 289             WaitBlock = (PEX_RUNDOWN_WAIT_BLOCK)(Value & ~EX_RUNDOWN_ACTIVE);
 290             ASSERT((WaitBlock->Count >= Count) || (KeNumberProcessors > 1));
 291
 292             /* Remove the counts */
 293             if (InterlockedExchangeAddSizeT(&WaitBlock->Count,
 294                                             -(LONG)Count) == (LONG)Count)
 295             {
 296                 /* We're down to 0 now, so signal the event */
 297                 KeSetEvent(&WaitBlock->WakeEvent, IO_NO_INCREMENT, FALSE);
 298             }
 299
 300             /* We're all done */
 301             break;
 302         }
 303     }
 304 }
 305
 306 /*++
 307  * @name ExfWaitForRundownProtectionRelease
 308  * @implemented NT5.1
 309  *
 310  *     The ExfWaitForRundownProtectionRelease routine waits until the specified
 311  *     rundown descriptor has been released.
 312  *
 313  * @param RunRef
 314  *        Pointer to a rundown reference descriptor.
 315  *
 316  * @return None.
 317  *
 318  * @remarks Callers of ExfWaitForRundownProtectionRelease must be running
 319  *          at IRQL <= APC_LEVEL.
 320  *
 321  *--*/
 322 VOID
 323 FASTCALL
 324 ExfWaitForRundownProtectionRelease(IN PEX_RUNDOWN_REF RunRef)
 325 {
 326     ULONG_PTR Value, Count, NewValue;
 327     EX_RUNDOWN_WAIT_BLOCK WaitBlock;
 328     PEX_RUNDOWN_WAIT_BLOCK WaitBlockPointer;
 329     PKEVENT Event;
 330     PAGED_CODE();
 331
 332     /* Set the active bit */
 333     Value = ExpChangeRundown(RunRef, EX_RUNDOWN_ACTIVE, 0);
 334     if ((Value == 0) || (Value == EX_RUNDOWN_ACTIVE)) return;
 335
 336     /* No event for now */
 337     Event = NULL;
 338     WaitBlockPointer = (PEX_RUNDOWN_WAIT_BLOCK)((ULONG_PTR)&WaitBlock |
 339                                                 EX_RUNDOWN_ACTIVE);
 340
 341     /* Start waitblock set loop */
 342     for (;;)
 343     {
 344         /* Save the count */
 345         Count = Value >> EX_RUNDOWN_COUNT_SHIFT;
 346
 347         /* If the count is over one and we don't have en event yet, create it */
 348         if ((Count) && !(Event))
 349         {
 350             /* Initialize the event */
 351             KeInitializeEvent(&WaitBlock.WakeEvent,
 352                               SynchronizationEvent,
 353                               FALSE);
 354
 355             /* Set the pointer */
 356             Event = &WaitBlock.WakeEvent;
 357         }
 358
 359         /* Set the count */
 360         WaitBlock.Count = Count;
 361
 362         /* Now set the pointer */
 363         NewValue = ExpChangeRundown(RunRef, (ULONG_PTR)WaitBlockPointer, Value);
 364         if (NewValue == Value) break;
 365
 366         /* Loop again */
 367         Value = NewValue;
 368         ASSERT((Value & EX_RUNDOWN_ACTIVE) == 0);
 369     }
 370
 371     /* If the count was 0, we're done */
 372     if (!Count) return;
 373
 374     /* Wait for whoever needs to release to notify us */
 375     KeWaitForSingleObject(Event, Executive, KernelMode, FALSE, NULL);
 376     ASSERT(WaitBlock.Count == 0);
 377 }
 378
 379 /*
 380  * @implemented NT5.2
 381  */
 382 BOOLEAN
 383 FASTCALL
 384 ExfAcquireRundownProtectionCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware)
 385 {
 386     PEX_RUNDOWN_REF RunRef;
 387
 388     RunRef = ExGetRunRefForGivenProcessor(RunRefCacheAware, KeGetCurrentProcessorNumber());
 389     return _ExAcquireRundownProtection(RunRef);
 390 }
 391
 392 /*
 393  * @implemented NT5.2
 394  */
 395 BOOLEAN
 396 FASTCALL
 397 ExfAcquireRundownProtectionCacheAwareEx(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware,
 398                                         IN ULONG Count)
 399 {
 400     PEX_RUNDOWN_REF RunRef;
 401
 402     RunRef = ExGetRunRefForGivenProcessor(RunRefCacheAware, KeGetCurrentProcessorNumber());
 403     return ExfAcquireRundownProtectionEx(RunRef, Count);
 404 }
 405
 406 /*
 407  * @implemented NT5.2
 408  */
 409 VOID
 410 FASTCALL
 411 ExfReleaseRundownProtectionCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware)
 412 {
 413     PEX_RUNDOWN_REF RunRef;
 414
 415     RunRef = ExGetRunRefForGivenProcessor(RunRefCacheAware, KeGetCurrentProcessorNumber());
 416     _ExReleaseRundownProtection(RunRef);
 417 }
 418
 419 /*
 420  * @implemented NT5.2
 421  */
 422 VOID
 423 FASTCALL
 424 ExfReleaseRundownProtectionCacheAwareEx(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware,
 425                                         IN ULONG Count)
 426 {
 427     PEX_RUNDOWN_REF RunRef;
 428
 429     RunRef = ExGetRunRefForGivenProcessor(RunRefCacheAware, KeGetCurrentProcessorNumber());
 430     ExfReleaseRundownProtectionEx(RunRef, Count);
 431 }
 432
 433 /*
 434  * @implemented NT5.2
 435  */
 436 VOID
 437 FASTCALL
 438 ExfWaitForRundownProtectionReleaseCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware)
 439 {
 440     PEX_RUNDOWN_REF RunRef;
 441     EX_RUNDOWN_WAIT_BLOCK WaitBlock;
 442     PEX_RUNDOWN_WAIT_BLOCK WaitBlockPointer;
 443     ULONG ProcCount, Current, Value, OldValue, TotalCount;
 444
 445     ProcCount = RunRefCacheAware->Number;
 446     /* No proc, nothing to do */
 447     if (ProcCount == 0)
 448     {
 449         return;
 450     }
 451
 452     TotalCount = 0;
 453     WaitBlock.Count = 0;
 454     WaitBlockPointer = (PEX_RUNDOWN_WAIT_BLOCK)((ULONG_PTR)&WaitBlock |
 455                                                 EX_RUNDOWN_ACTIVE);
 456     /* We will check all our runrefs */
 457     for (Current = 0; Current < ProcCount; ++Current)
 458     {
 459         /* Get the runref for the proc */
 460         RunRef = ExGetRunRefForGivenProcessor(RunRefCacheAware, Current);
 461         /* Loop for setting the wait block */
 462         do
 463         {
 464             Value = RunRef->Count;
 465             ASSERT((Value & EX_RUNDOWN_ACTIVE) == 0);
 466
 467             /* Remove old value and set our waitblock instead */
 468             OldValue = ExpChangeRundown(RunRef, WaitBlockPointer, Value);
 469             if (OldValue == Value)
 470             {
 471                 break;
 472             }
 473
 474             Value = OldValue;
 475         }
 476         while (TRUE);
 477
 478         /* Count the deleted values */
 479         TotalCount += Value;
 480     }
 481
 482     /* Sanity check: we didn't overflow */
 483     ASSERT((LONG)TotalCount >= 0);
 484     if (TotalCount != 0)
 485     {
 486         /* Init the waitblock event */
 487         KeInitializeEvent(&WaitBlock.WakeEvent,
 488                           SynchronizationEvent,
 489                           FALSE);
 490
 491         /* Do we have to wait? If so, go ahead! */
 492         if (InterlockedExchangeAddSizeT(&WaitBlock.Count,
 493                                         (LONG)TotalCount >> EX_RUNDOWN_COUNT_SHIFT) ==
 494                                        -(LONG)(TotalCount >> EX_RUNDOWN_COUNT_SHIFT))
 495         {
 496             KeWaitForSingleObject(&WaitBlock.WakeEvent, Executive, KernelMode, FALSE, NULL);
 497         }
 498     }
 499 }
 500
 501 /*
 502  * @implemented NT5.2
 503  */
 504 VOID
 505 FASTCALL
 506 ExfRundownCompletedCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware)
 507 {
 508     PEX_RUNDOWN_REF RunRef;
 509     ULONG ProcCount, Current;
 510
 511     ProcCount = RunRefCacheAware->Number;
 512     /* No proc, nothing to do */
 513     if (ProcCount == 0)
 514     {
 515         return;
 516     }
 517
 518     /* We will mark all our runrefs active */
 519     for (Current = 0; Current < ProcCount; ++Current)
 520     {
 521         /* Get the runref for the proc */
 522         RunRef = ExGetRunRefForGivenProcessor(RunRefCacheAware, Current);
 523         ASSERT((RunRef->Count & EX_RUNDOWN_ACTIVE) != 0);
 524
 525         ExpSetRundown(RunRef, EX_RUNDOWN_ACTIVE);
 526     }
 527 }
 528
 529 /*
 530  * @implemented NT5.2
 531  */
 532 VOID
 533 FASTCALL
 534 ExfReInitializeRundownProtectionCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware)
 535 {
 536     PEX_RUNDOWN_REF RunRef;
 537     ULONG ProcCount, Current;
 538
 539     ProcCount = RunRefCacheAware->Number;
 540     /* No proc, nothing to do */
 541     if (ProcCount == 0)
 542     {
 543         return;
 544     }
 545
 546     /* We will mark all our runrefs inactive */
 547     for (Current = 0; Current < ProcCount; ++Current)
 548     {
 549         /* Get the runref for the proc */
 550         RunRef = ExGetRunRefForGivenProcessor(RunRefCacheAware, Current);
 551         ASSERT((RunRef->Count & EX_RUNDOWN_ACTIVE) != 0);
 552
 553         ExpSetRundown(RunRef, 0);
 554     }
 555 }
 556
 557 /*
 558  * @implemented NT5.2
 559  */
 560 PEX_RUNDOWN_REF_CACHE_AWARE
 561 NTAPI
 562 ExAllocateCacheAwareRundownProtection(IN POOL_TYPE PoolType,
 563                                       IN ULONG Tag)
 564 {
 565     PEX_RUNDOWN_REF RunRef;
 566     PVOID PoolToFree, RunRefs;
 567     ULONG RunRefSize, Count, Align;
 568     PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware;
 569
 570     PAGED_CODE();
 571
 572     /* Allocate the master structure */
 573     RunRefCacheAware = ExAllocatePoolWithTag(PoolType, sizeof(EX_RUNDOWN_REF_CACHE_AWARE), Tag);
 574     if (RunRefCacheAware == NULL)
 575     {
 576         return NULL;
 577     }
 578
 579     /* Compute the size of each runref */
 580     RunRefCacheAware->Number = KeNumberProcessors;
 581     if (KeNumberProcessors <= 1)
 582     {
 583         RunRefSize = sizeof(EX_RUNDOWN_REF);
 584     }
 585     else
 586     {
 587         Align = KeGetRecommendedSharedDataAlignment();
 588         RunRefSize = Align;
 589         ASSERT((RunRefSize & (RunRefSize - 1)) == 0);
 590     }
 591
 592     /* It must at least hold a EX_RUNDOWN_REF structure */
 593     ASSERT(sizeof(EX_RUNDOWN_REF) <= RunRefSize);
 594     RunRefCacheAware->RunRefSize = RunRefSize;
 595
 596     /* Allocate our runref pool */
 597     PoolToFree = ExAllocatePoolWithTag(PoolType, RunRefSize * RunRefCacheAware->Number, Tag);
 598     if (PoolToFree == NULL)
 599     {
 600         ExFreePoolWithTag(RunRefCacheAware, Tag);
 601         return NULL;
 602     }
 603
 604     /* On SMP, check for alignment */
 605     if (RunRefCacheAware->Number > 1 && (ULONG_PTR)PoolToFree & (Align - 1))
 606     {
 607         /* Not properly aligned, do it again! */
 608         ExFreePoolWithTag(PoolToFree, Tag);
 609
 610         /* Allocate a bigger buffer to be able to align properly */
 611         PoolToFree = ExAllocatePoolWithTag(PoolType, RunRefSize * (RunRefCacheAware->Number + 1), Tag);
 612         if (PoolToFree == NULL)
 613         {
 614             ExFreePoolWithTag(RunRefCacheAware, Tag);
 615             return NULL;
 616         }
 617
 618         RunRefs = (PVOID)ALIGN_UP_BY(PoolToFree, Align);
 619     }
 620     else
 621     {
 622         RunRefs = PoolToFree;
 623     }
 624
 625     RunRefCacheAware->RunRefs = RunRefs;
 626     RunRefCacheAware->PoolToFree = PoolToFree;
 627
 628     /* And initialize runref */
 629     if (RunRefCacheAware->Number != 0)
 630     {
 631         for (Count = 0; Count < RunRefCacheAware->Number; ++Count)
 632         {
 633             RunRef = ExGetRunRefForGivenProcessor(RunRefCacheAware, Count);
 634             _ExInitializeRundownProtection(RunRef);
 635         }
 636     }
 637
 638     return RunRefCacheAware;
 639 }
 640
 641 /*
 642  * @implemented NT5.2
 643  */
 644 VOID
 645 NTAPI
 646 ExFreeCacheAwareRundownProtection(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware)
 647 {
 648     PAGED_CODE();
 649
 650     /*
 651      * This is to be called for RunRefCacheAware that were allocated with
 652      * ExAllocateCacheAwareRundownProtection and not for user-allocated
 653      * ones
 654      */
 655     ASSERT(RunRefCacheAware->PoolToFree != (PVOID)0xBADCA11);
 656
 657     /* We don't know the tag that as used for allocation */
 658     ExFreePoolWithTag(RunRefCacheAware->PoolToFree, 0);
 659     ExFreePoolWithTag(RunRefCacheAware, 0);
 660 }
 661
 662 /*
 663  * @implemented NT5.2
 664  */
 665 VOID
 666 NTAPI
 667 ExInitializeRundownProtectionCacheAware(IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware,
 668                                         IN SIZE_T Size)
 669 {
 670     PVOID Pool;
 671     PEX_RUNDOWN_REF RunRef;
 672     ULONG Count, RunRefSize, Align;
 673
 674     PAGED_CODE();
 675
 676     /* Get the user allocate pool for runrefs */
 677     Pool = (PVOID)((ULONG_PTR)RunRefCacheAware + sizeof(EX_RUNDOWN_REF_CACHE_AWARE));
 678
 679     /* By default a runref is structure-sized */
 680     RunRefSize = sizeof(EX_RUNDOWN_REF);
 681
 682     /*
 683      * If we just have enough room for a single runref, deduce were on a single
 684      * processor machine
 685      */
 686     if (Size == sizeof(EX_RUNDOWN_REF_CACHE_AWARE) + sizeof(EX_RUNDOWN_REF))
 687     {
 688         Count = 1;
 689     }
 690     else
 691     {
 692         /* Get alignment constraint */
 693         Align = KeGetRecommendedSharedDataAlignment();
 694
 695         /* How many runrefs given the alignment? */
 696         RunRefSize = Align;
 697         Count = ((Size - sizeof(EX_RUNDOWN_REF_CACHE_AWARE)) / Align) - 1;
 698         Pool = (PVOID)ALIGN_UP_BY(Pool, Align);
 699     }
 700
 701     /* Initialize the structure */
 702     RunRefCacheAware->RunRefs = Pool;
 703     RunRefCacheAware->RunRefSize = RunRefSize;
 704     RunRefCacheAware->Number = Count;
 705
 706     /* There is no allocated pool! */
 707     RunRefCacheAware->PoolToFree = (PVOID)0xBADCA11u;
 708
 709     /* Initialize runref */
 710     if (RunRefCacheAware->Number != 0)
 711     {
 712         for (Count = 0; Count < RunRefCacheAware->Number; ++Count)
 713         {
 714             RunRef = ExGetRunRefForGivenProcessor(RunRefCacheAware, Count);
 715             _ExInitializeRundownProtection(RunRef);
 716         }
 717     }
 718 }
 719
 720 /*
 721  * @implemented NT5.2
 722  */
 723 SIZE_T
 724 NTAPI
 725 ExSizeOfRundownProtectionCacheAware(VOID)
 726 {
 727     SIZE_T Size;
 728
 729     PAGED_CODE();
 730
 731     /* Compute the needed size for runrefs */
 732     if (KeNumberProcessors <= 1)
 733     {
 734         Size = sizeof(EX_RUNDOWN_REF);
 735     }
 736     else
 737     {
 738         /* We +1, to have enough room for alignment */
 739         Size = (KeNumberProcessors + 1) * KeGetRecommendedSharedDataAlignment();
 740     }
 741
 742     /* Return total size (master structure and runrefs) */
 743     return Size + sizeof(EX_RUNDOWN_REF_CACHE_AWARE);
 744 }
 745