reactos/ntoskrnl/ps/quota.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS kernel
   4  * FILE:            ntoskrnl/ps/quota.c
   5  * PURPOSE:         Process Pool Quotas
   6  *
   7  * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
   8  */
   9
  10 /* INCLUDES **************************************************************/
  11
  12 #include <ntoskrnl.h>
  13 #define NDEBUG
  14 #include <internal/debug.h>
  15
  16 EPROCESS_QUOTA_BLOCK PspDefaultQuotaBlock;
  17
  18 /* FUNCTIONS ***************************************************************/
  19
  20 VOID
  21 NTAPI
  22 PsInitializeQuotaSystem(VOID)
  23 {
  24     RtlZeroMemory(&PspDefaultQuotaBlock, sizeof(PspDefaultQuotaBlock));
  25     PspDefaultQuotaBlock.QuotaEntry[PagedPool].Limit = (SIZE_T)-1;
  26     PspDefaultQuotaBlock.QuotaEntry[NonPagedPool].Limit = (SIZE_T)-1;
  27     PspDefaultQuotaBlock.QuotaEntry[2].Limit = (SIZE_T)-1; /* Page file */
  28     PsGetCurrentProcess()->QuotaBlock = &PspDefaultQuotaBlock;
  29 }
  30
  31 VOID
  32 STDCALL
  33 PspInheritQuota(PEPROCESS Process, PEPROCESS ParentProcess)
  34 {
  35     if (ParentProcess != NULL)
  36     {
  37         PEPROCESS_QUOTA_BLOCK QuotaBlock = ParentProcess->QuotaBlock;
  38
  39         ASSERT(QuotaBlock != NULL);
  40
  41         (void)InterlockedIncrementUL(&QuotaBlock->ReferenceCount);
  42
  43         Process->QuotaBlock = QuotaBlock;
  44     }
  45     else
  46         Process->QuotaBlock = &PspDefaultQuotaBlock;
  47 }
  48
  49 VOID
  50 STDCALL
  51 PspDestroyQuotaBlock(PEPROCESS Process)
  52 {
  53     PEPROCESS_QUOTA_BLOCK QuotaBlock = Process->QuotaBlock;
  54
  55     if (QuotaBlock != &PspDefaultQuotaBlock &&
  56         InterlockedDecrementUL(&QuotaBlock->ReferenceCount) == 0)
  57     {
  58         ExFreePool(QuotaBlock);
  59     }
  60 }
  61
  62 /*
  63  * @implemented
  64  */
  65 VOID
  66 STDCALL
  67 PsChargePoolQuota(IN PEPROCESS Process,
  68                   IN POOL_TYPE PoolType,
  69                   IN ULONG Amount)
  70 {
  71     NTSTATUS Status;
  72
  73     /* Charge the usage */
  74     Status = PsChargeProcessPoolQuota(Process, PoolType, Amount);
  75
  76     /* Raise Exception */
  77     if (!NT_SUCCESS(Status))
  78     {
  79         ExRaiseStatus(Status);
  80     }
  81 }
  82
  83 /*
  84  * @implemented
  85  */
  86 NTSTATUS
  87 STDCALL
  88 PsChargeProcessNonPagedPoolQuota(IN PEPROCESS Process,
  89                                  IN ULONG_PTR Amount)
  90 {
  91     /* Call the general function */
  92     return PsChargeProcessPoolQuota(Process, NonPagedPool, Amount);
  93 }
  94
  95 /*
  96  * @implemented
  97  */
  98 NTSTATUS
  99 STDCALL
 100 PsChargeProcessPagedPoolQuota(IN PEPROCESS Process,
 101                               IN ULONG_PTR Amount)
 102 {
 103     /* Call the general function */
 104     return PsChargeProcessPoolQuota(Process, PagedPool, Amount);
 105 }
 106
 107 /*
 108  * @implemented
 109  */
 110 NTSTATUS
 111 STDCALL
 112 PsChargeProcessPoolQuota(IN PEPROCESS Process,
 113                          IN POOL_TYPE PoolType,
 114                          IN ULONG Amount)
 115 {
 116     PEPROCESS_QUOTA_BLOCK QuotaBlock;
 117     ULONG NewUsageSize;
 118     ULONG NewMaxQuota;
 119
 120     /* Get current Quota Block */
 121     QuotaBlock = Process->QuotaBlock;
 122
 123     /* Quota Operations are not to be done on the SYSTEM Process */
 124     if (Process == PsInitialSystemProcess) return STATUS_SUCCESS;
 125
 126     /* New Size in use */
 127     NewUsageSize = QuotaBlock->QuotaEntry[PoolType].Usage + Amount;
 128
 129     /* Does this size respect the quota? */
 130     if (NewUsageSize > QuotaBlock->QuotaEntry[PoolType].Limit)
 131     {
 132         /* It doesn't, so keep raising the Quota */
 133         while (MiRaisePoolQuota(PoolType,
 134                QuotaBlock->QuotaEntry[PoolType].Limit,
 135                &NewMaxQuota))
 136         {
 137             /* Save new Maximum Quota */
 138             QuotaBlock->QuotaEntry[PoolType].Limit = NewMaxQuota;
 139
 140             /* See if the new Maximum Quota fulfills our need */
 141             if (NewUsageSize <= NewMaxQuota) goto QuotaChanged;
 142         }
 143
 144         return STATUS_QUOTA_EXCEEDED;
 145     }
 146
 147 QuotaChanged:
 148     /* Save new Usage */
 149     QuotaBlock->QuotaEntry[PoolType].Usage = NewUsageSize;
 150
 151     /* Is this a new peak? */
 152     if (NewUsageSize > QuotaBlock->QuotaEntry[PoolType].Peak)
 153     {
 154         QuotaBlock->QuotaEntry[PoolType].Peak = NewUsageSize;
 155     }
 156
 157     /* All went well */
 158     return STATUS_SUCCESS;
 159 }
 160
 161 /*
 162  * @unimplemented
 163  */
 164 VOID
 165 STDCALL
 166 PsReturnPoolQuota(IN PEPROCESS Process,
 167                   IN POOL_TYPE PoolType,
 168                   IN ULONG_PTR Amount)
 169 {
 170     UNIMPLEMENTED;
 171 }
 172
 173 /*
 174  * @unimplemented
 175  */
 176 VOID
 177 STDCALL
 178 PsReturnProcessNonPagedPoolQuota(IN PEPROCESS Process,
 179                                  IN ULONG_PTR Amount)
 180 {
 181     UNIMPLEMENTED;
 182 }
 183
 184 /*
 185  * @unimplemented
 186  */
 187 VOID
 188 STDCALL
 189 PsReturnProcessPagedPoolQuota(IN PEPROCESS Process,
 190                               IN ULONG_PTR Amount)
 191 {
 192     UNIMPLEMENTED;
 193 }
 194
 195 /* EOF */