[CMAKE]
[reactos.git] / 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 * Mike Nordell
9 */
10
11 /* INCLUDES **************************************************************/
12
13 #include <ntoskrnl.h>
14 #define NDEBUG
15 #include <debug.h>
16
17 EPROCESS_QUOTA_BLOCK PspDefaultQuotaBlock;
18
19
20 /* Define this macro to enable quota code testing. Once quota code is */
21 /* stable and verified, remove this macro and checks for it. */
22 /*#define PS_QUOTA_ENABLE_QUOTA_CODE*/
23
24
25 /* PRIVATE FUNCTIONS *******************************************************/
26
27 #ifdef PS_QUOTA_ENABLE_QUOTA_CODE
28
29 /*
30 * Private helper to charge the specified process quota.
31 * ReturnsSTATUS_QUOTA_EXCEEDED on quota limit check failure.
32 * Updates QuotaPeak as needed for specified PoolIndex.
33 * TODO: Research and possibly add (the undocumented) enum type PS_QUOTA_TYPE
34 * to replace UCHAR for 'PoolIndex'.
35 * Notes: Conceptually translation unit local/private.
36 */
37 NTSTATUS
38 NTAPI
39 PspChargeProcessQuotaSpecifiedPool(IN PEPROCESS Process,
40 IN UCHAR PoolIndex,
41 IN SIZE_T Amount)
42 {
43 ASSERT(Process);
44 ASSERT(Process != PsInitialSystemProcess);
45 ASSERT(PoolIndex <= 2);
46 ASSERT(Process->QuotaBlock);
47
48 /* Note: Race warning. TODO: Needs to add/use lock for this */
49 if (Process->QuotaUsage[PoolIndex] + Amount >
50 Process->QuotaBlock->QuotaEntry[PoolIndex].Limit)
51 {
52 return STATUS_QUOTA_EXCEEDED; /* caller raises the exception */
53 }
54
55 InterlockedExchangeAdd((LONG*)&Process->QuotaUsage[PoolIndex], Amount);
56
57 /* Note: Race warning. TODO: Needs to add/use lock for this */
58 if (Process->QuotaPeak[PoolIndex] < Process->QuotaUsage[PoolIndex])
59 {
60 Process->QuotaPeak[PoolIndex] = Process->QuotaUsage[PoolIndex];
61 }
62
63 return STATUS_SUCCESS;
64 }
65
66
67 /*
68 * Private helper to remove quota charge from the specified process quota.
69 * TODO: Research and possibly add (the undocumented) enum type PS_QUOTA_TYPE
70 * to replace UCHAR for 'PoolIndex'.
71 * Notes: Conceptually translation unit local/private.
72 */
73 VOID
74 NTAPI
75 PspReturnProcessQuotaSpecifiedPool(IN PEPROCESS Process,
76 IN UCHAR PoolIndex,
77 IN SIZE_T Amount)
78 {
79 ASSERT(Process);
80 ASSERT(Process != PsInitialSystemProcess);
81 ASSERT(PoolIndex <= 2);
82 ASSERT(!(Amount & 0x80000000)); /* we need to be able to negate it */
83 if (Process->QuotaUsage[PoolIndex] < Amount)
84 {
85 DPRINT1("WARNING: Process->QuotaUsage sanity check failed.\n");
86 }
87 else
88 {
89 InterlockedExchangeAdd((LONG*)&Process->QuotaUsage[PoolIndex],
90 -(LONG)Amount);
91 }
92 }
93
94 #endif /* PS_QUOTA_ENABLE_QUOTA_CODE */
95
96
97 /* FUNCTIONS ***************************************************************/
98
99 VOID
100 NTAPI
101 INIT_FUNCTION
102 PsInitializeQuotaSystem(VOID)
103 {
104 RtlZeroMemory(&PspDefaultQuotaBlock, sizeof(PspDefaultQuotaBlock));
105 PspDefaultQuotaBlock.QuotaEntry[PagedPool].Limit = (SIZE_T)-1;
106 PspDefaultQuotaBlock.QuotaEntry[NonPagedPool].Limit = (SIZE_T)-1;
107 PspDefaultQuotaBlock.QuotaEntry[2].Limit = (SIZE_T)-1; /* Page file */
108 PsGetCurrentProcess()->QuotaBlock = &PspDefaultQuotaBlock;
109 }
110
111 VOID
112 NTAPI
113 PspInheritQuota(PEPROCESS Process, PEPROCESS ParentProcess)
114 {
115 if (ParentProcess != NULL)
116 {
117 PEPROCESS_QUOTA_BLOCK QuotaBlock = ParentProcess->QuotaBlock;
118
119 ASSERT(QuotaBlock != NULL);
120
121 (void)InterlockedIncrementUL(&QuotaBlock->ReferenceCount);
122
123 Process->QuotaBlock = QuotaBlock;
124 }
125 else
126 Process->QuotaBlock = &PspDefaultQuotaBlock;
127 }
128
129 VOID
130 NTAPI
131 PspDestroyQuotaBlock(PEPROCESS Process)
132 {
133 PEPROCESS_QUOTA_BLOCK QuotaBlock = Process->QuotaBlock;
134
135 if (QuotaBlock != &PspDefaultQuotaBlock &&
136 InterlockedDecrementUL(&QuotaBlock->ReferenceCount) == 0)
137 {
138 ExFreePool(QuotaBlock);
139 }
140 }
141
142 NTSTATUS
143 NTAPI
144 PsChargeProcessPageFileQuota(IN PEPROCESS Process,
145 IN SIZE_T Amount)
146 {
147 /* Don't do anything for the system process */
148 if (Process == PsInitialSystemProcess) return STATUS_SUCCESS;
149
150 #ifdef PS_QUOTA_ENABLE_QUOTA_CODE
151 return PspChargeProcessQuotaSpecifiedPool(Process, 2, Amount);
152 #else
153 /* Otherwise, not implemented */
154 UNIMPLEMENTED;
155 return STATUS_SUCCESS;
156 #endif
157 }
158
159 /*
160 * @implemented
161 */
162 VOID
163 NTAPI
164 PsChargePoolQuota(IN PEPROCESS Process,
165 IN POOL_TYPE PoolType,
166 IN SIZE_T Amount)
167 {
168 NTSTATUS Status;
169
170 #ifdef PS_QUOTA_ENABLE_QUOTA_CODE
171 /* MS-documented IRQL requirement. Not yet enabled as it */
172 /* needs verification that it does not break ReactOS, */
173 ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
174 #endif
175
176 /* Don't do anything for the system process */
177 if (Process == PsInitialSystemProcess) return;
178
179 /* Charge the usage */
180 Status = PsChargeProcessPoolQuota(Process, PoolType, Amount);
181 if (!NT_SUCCESS(Status)) ExRaiseStatus(Status);
182 }
183
184 /*
185 * @implemented
186 */
187 NTSTATUS
188 NTAPI
189 PsChargeProcessNonPagedPoolQuota(IN PEPROCESS Process,
190 IN SIZE_T Amount)
191 {
192 /* Call the general function */
193 return PsChargeProcessPoolQuota(Process, NonPagedPool, Amount);
194 }
195
196 /*
197 * @implemented
198 */
199 NTSTATUS
200 NTAPI
201 PsChargeProcessPagedPoolQuota(IN PEPROCESS Process,
202 IN SIZE_T Amount)
203 {
204 /* Call the general function */
205 return PsChargeProcessPoolQuota(Process, PagedPool, Amount);
206 }
207
208 /*
209 * @implemented
210 */
211 NTSTATUS
212 NTAPI
213 PsChargeProcessPoolQuota(IN PEPROCESS Process,
214 IN POOL_TYPE PoolType,
215 IN SIZE_T Amount)
216 {
217 /* Don't do anything for the system process */
218 if (Process == PsInitialSystemProcess) return STATUS_SUCCESS;
219
220 #ifdef PS_QUOTA_ENABLE_QUOTA_CODE
221 return PspChargeProcessQuotaSpecifiedPool(Process,
222 (PoolType & PAGED_POOL_MASK),
223 Amount);
224 #else
225 UNIMPLEMENTED;
226 return STATUS_SUCCESS;
227 #endif
228 }
229
230 /*
231 * @unimplemented
232 */
233 VOID
234 NTAPI
235 PsReturnPoolQuota(IN PEPROCESS Process,
236 IN POOL_TYPE PoolType,
237 IN SIZE_T Amount)
238 {
239 #ifdef PS_QUOTA_ENABLE_QUOTA_CODE
240 /* MS-documented IRQL requirement. Not yet enabled as it */
241 /* needs verification that it does not break ReactOS, */
242 ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
243 #endif
244
245 /* Don't do anything for the system process */
246 if (Process == PsInitialSystemProcess) return;
247
248 #ifdef PS_QUOTA_ENABLE_QUOTA_CODE
249 PspReturnProcessQuotaSpecifiedPool(Process,
250 (PoolType & PAGED_POOL_MASK),
251 Amount);
252 #else
253 UNIMPLEMENTED;
254 #endif
255 }
256
257 /*
258 * @unimplemented
259 */
260 VOID
261 NTAPI
262 PsReturnProcessNonPagedPoolQuota(IN PEPROCESS Process,
263 IN SIZE_T Amount)
264 {
265 /* Don't do anything for the system process */
266 if (Process == PsInitialSystemProcess) return;
267
268 #ifdef PS_QUOTA_ENABLE_QUOTA_CODE
269 PsReturnPoolQuota(Process, NonPagedPool, Amount);
270 #else
271 UNIMPLEMENTED;
272 #endif
273 }
274
275 /*
276 * @unimplemented
277 */
278 VOID
279 NTAPI
280 PsReturnProcessPagedPoolQuota(IN PEPROCESS Process,
281 IN SIZE_T Amount)
282 {
283 /* Don't do anything for the system process */
284 if (Process == PsInitialSystemProcess) return;
285
286 #ifdef PS_QUOTA_ENABLE_QUOTA_CODE
287 PsReturnPoolQuota(Process, PagedPool, Amount);
288 #else
289 UNIMPLEMENTED;
290 #endif
291 }
292
293 NTSTATUS
294 NTAPI
295 PsReturnProcessPageFileQuota(IN PEPROCESS Process,
296 IN SIZE_T Amount)
297 {
298 /* Don't do anything for the system process */
299 if (Process == PsInitialSystemProcess) return STATUS_SUCCESS;
300
301 #ifdef PS_QUOTA_ENABLE_QUOTA_CODE
302 PspReturnProcessQuotaSpecifiedPool(Process, 2, Amount);
303 #else
304 /* Otherwise, not implemented */
305 UNIMPLEMENTED;
306 #endif
307 return STATUS_SUCCESS;
308 }
309
310 /* EOF */