[NTOS] Minor formatting + don't hardcode sizeof(UCHAR) value.
[reactos.git] / ntoskrnl / ex / uuid.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * FILE: ntoskrnl/ex/uuid.c
5 * PURPOSE: UUID generator
6 * PROGRAMMERS: Eric Kohl
7 * Thomas Weidenmueller
8 */
9
10 /* INCLUDES *****************************************************************/
11
12 #include <ntoskrnl.h>
13 #define NDEBUG
14 #include <debug.h>
15
16 #define SEED_BUFFER_SIZE 6
17
18 /* Number of 100ns ticks per clock tick. To be safe, assume that the clock
19 resolution is at least 1000 * 100 * (1/1000000) = 1/10 of a second */
20 #define TICKS_PER_CLOCK_TICK 1000
21 #define SECSPERDAY 86400
22 #define TICKSPERSEC 10000000
23
24 /* UUID system time starts at October 15, 1582 */
25 #define SECS_15_OCT_1582_TO_1601 ((17 + 30 + 31 + 365 * 18 + 5) * SECSPERDAY)
26 #define TICKS_15_OCT_1582_TO_1601 ((ULONGLONG)SECS_15_OCT_1582_TO_1601 * TICKSPERSEC)
27
28 #if defined (ALLOC_PRAGMA)
29 #pragma alloc_text(INIT, ExpInitUuids)
30 #endif
31
32
33 /* GLOBALS ****************************************************************/
34
35 static FAST_MUTEX UuidMutex;
36 static ULARGE_INTEGER UuidLastTime;
37 static ULONG UuidSequence;
38 static BOOLEAN UuidSequenceInitialized = FALSE;
39 static BOOLEAN UuidSequenceChanged = FALSE;
40 static UCHAR UuidSeed[SEED_BUFFER_SIZE];
41 static ULONG UuidCount;
42 static LARGE_INTEGER LuidIncrement;
43 static LARGE_INTEGER LuidValue;
44
45 /* FUNCTIONS ****************************************************************/
46
47 VOID
48 INIT_FUNCTION
49 NTAPI
50 ExpInitUuids(VOID)
51 {
52 ExInitializeFastMutex(&UuidMutex);
53
54 KeQuerySystemTime((PLARGE_INTEGER)&UuidLastTime);
55 UuidLastTime.QuadPart += TICKS_15_OCT_1582_TO_1601;
56
57 UuidCount = TICKS_PER_CLOCK_TICK;
58 RtlZeroMemory(UuidSeed, SEED_BUFFER_SIZE);
59 }
60
61
62 #define VALUE_BUFFER_SIZE 256
63
64 static NTSTATUS
65 ExpLoadUuidSequence(PULONG Sequence)
66 {
67 UCHAR ValueBuffer[VALUE_BUFFER_SIZE];
68 PKEY_VALUE_PARTIAL_INFORMATION ValueInfo;
69 OBJECT_ATTRIBUTES ObjectAttributes;
70 UNICODE_STRING Name;
71 HANDLE KeyHandle;
72 ULONG ValueLength;
73 NTSTATUS Status;
74
75 RtlInitUnicodeString(&Name,
76 L"\\Registry\\Machine\\Software\\Microsoft\\Rpc");
77 InitializeObjectAttributes(&ObjectAttributes,
78 &Name,
79 OBJ_CASE_INSENSITIVE,
80 NULL,
81 NULL);
82 Status = ZwOpenKey(&KeyHandle,
83 KEY_QUERY_VALUE,
84 &ObjectAttributes);
85 if (!NT_SUCCESS(Status))
86 {
87 DPRINT("ZwOpenKey() failed (Status %lx)\n", Status);
88 return Status;
89 }
90
91 RtlInitUnicodeString(&Name, L"UuidSequenceNumber");
92
93 ValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)ValueBuffer;
94 Status = ZwQueryValueKey(KeyHandle,
95 &Name,
96 KeyValuePartialInformation,
97 ValueBuffer,
98 VALUE_BUFFER_SIZE,
99 &ValueLength);
100 ZwClose(KeyHandle);
101 if (!NT_SUCCESS(Status))
102 {
103 DPRINT("ZwQueryValueKey() failed (Status %lx)\n", Status);
104 return Status;
105 }
106
107 *Sequence = *((PULONG)ValueInfo->Data);
108
109 DPRINT("Loaded sequence %lx\n", *Sequence);
110
111 return STATUS_SUCCESS;
112 }
113 #undef VALUE_BUFFER_SIZE
114
115
116 static NTSTATUS
117 ExpSaveUuidSequence(PULONG Sequence)
118 {
119 OBJECT_ATTRIBUTES ObjectAttributes;
120 UNICODE_STRING Name;
121 HANDLE KeyHandle;
122 NTSTATUS Status;
123
124 RtlInitUnicodeString(&Name,
125 L"\\Registry\\Machine\\Software\\Microsoft\\Rpc");
126 InitializeObjectAttributes(&ObjectAttributes,
127 &Name,
128 OBJ_CASE_INSENSITIVE,
129 NULL,
130 NULL);
131 Status = ZwOpenKey(&KeyHandle,
132 KEY_SET_VALUE,
133 &ObjectAttributes);
134 if (!NT_SUCCESS(Status))
135 {
136 DPRINT("ZwOpenKey() failed (Status %lx)\n", Status);
137 return Status;
138 }
139
140 RtlInitUnicodeString(&Name, L"UuidSequenceNumber");
141 Status = ZwSetValueKey(KeyHandle,
142 &Name,
143 0,
144 REG_DWORD,
145 Sequence,
146 sizeof(ULONG));
147 ZwClose(KeyHandle);
148 if (!NT_SUCCESS(Status))
149 {
150 DPRINT("ZwSetValueKey() failed (Status %lx)\n", Status);
151 }
152
153 return Status;
154 }
155
156
157 static VOID
158 ExpGetRandomUuidSequence(PULONG Sequence)
159 {
160 LARGE_INTEGER Counter;
161 LARGE_INTEGER Frequency;
162 ULONG Value;
163
164 Counter = KeQueryPerformanceCounter(&Frequency);
165 Value = Counter.u.LowPart ^ Counter.u.HighPart;
166
167 *Sequence = *Sequence ^ Value;
168
169 DPRINT("Sequence %lx\n", *Sequence);
170 }
171
172
173 static NTSTATUS
174 ExpCreateUuids(PULARGE_INTEGER Time,
175 PULONG Range,
176 PULONG Sequence)
177 {
178 /*
179 * Generate time element of the UUID. Account for going faster
180 * than our clock as well as the clock going backwards.
181 */
182 while (1)
183 {
184 KeQuerySystemTime((PLARGE_INTEGER)Time);
185 Time->QuadPart += TICKS_15_OCT_1582_TO_1601;
186
187 if (Time->QuadPart > UuidLastTime.QuadPart)
188 {
189 UuidCount = 0;
190 break;
191 }
192
193 if (Time->QuadPart < UuidLastTime.QuadPart)
194 {
195 (*Sequence)++;
196 UuidSequenceChanged = TRUE;
197 UuidCount = 0;
198 break;
199 }
200
201 if (UuidCount < TICKS_PER_CLOCK_TICK)
202 {
203 UuidCount++;
204 break;
205 }
206 }
207
208 UuidLastTime.QuadPart = Time->QuadPart;
209 Time->QuadPart += UuidCount;
210
211 *Range = 10000; /* What does this mean? Ticks per millisecond?*/
212
213 return STATUS_SUCCESS;
214 }
215
216 VOID
217 INIT_FUNCTION
218 NTAPI
219 ExpInitLuid(VOID)
220 {
221 LUID DummyLuidValue = SYSTEM_LUID;
222
223 LuidValue.u.HighPart = DummyLuidValue.HighPart;
224 LuidValue.u.LowPart = DummyLuidValue.LowPart;
225 LuidIncrement.QuadPart = 1;
226 }
227
228
229 VOID
230 NTAPI
231 ExAllocateLocallyUniqueId(OUT LUID *LocallyUniqueId)
232 {
233 LARGE_INTEGER NewLuid, PrevLuid;
234
235 /* atomically increment the luid */
236 do
237 {
238 PrevLuid = LuidValue;
239 NewLuid = RtlLargeIntegerAdd(PrevLuid,
240 LuidIncrement);
241 } while(ExInterlockedCompareExchange64(&LuidValue.QuadPart,
242 &NewLuid.QuadPart,
243 &PrevLuid.QuadPart,
244 NULL) != PrevLuid.QuadPart);
245
246 LocallyUniqueId->LowPart = NewLuid.u.LowPart;
247 LocallyUniqueId->HighPart = NewLuid.u.HighPart;
248 }
249
250
251 /*
252 * @implemented
253 */
254 NTSTATUS
255 NTAPI
256 NtAllocateLocallyUniqueId(OUT LUID *LocallyUniqueId)
257 {
258 LUID NewLuid;
259 KPROCESSOR_MODE PreviousMode;
260 NTSTATUS Status;
261 PAGED_CODE();
262
263 /* Probe if user mode */
264 PreviousMode = ExGetPreviousMode();
265 if (PreviousMode != KernelMode)
266 {
267 _SEH2_TRY
268 {
269 ProbeForWrite(LocallyUniqueId,
270 sizeof(LUID),
271 sizeof(ULONG));
272 }
273 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
274 {
275 _SEH2_YIELD(return _SEH2_GetExceptionCode());
276 }
277 _SEH2_END;
278 }
279
280 /* Do the allocation */
281 ExAllocateLocallyUniqueId(&NewLuid);
282 Status = STATUS_SUCCESS;
283
284 /* Write back LUID to caller */
285 _SEH2_TRY
286 {
287 *LocallyUniqueId = NewLuid;
288 }
289 _SEH2_EXCEPT(ExSystemExceptionFilter())
290 {
291 Status = _SEH2_GetExceptionCode();
292 }
293 _SEH2_END;
294 return Status;
295 }
296
297 /*
298 * @unimplemented
299 */
300 NTSTATUS
301 NTAPI
302 ExUuidCreate(OUT UUID *Uuid)
303 {
304 UNIMPLEMENTED;
305 return FALSE;
306 }
307
308 /*
309 * @unimplemented
310 */
311 NTSTATUS
312 NTAPI
313 NtAllocateUuids(OUT PULARGE_INTEGER Time,
314 OUT PULONG Range,
315 OUT PULONG Sequence,
316 OUT PUCHAR Seed)
317 {
318 ULARGE_INTEGER IntTime;
319 ULONG IntRange;
320 NTSTATUS Status;
321 KPROCESSOR_MODE PreviousMode;
322
323 PAGED_CODE();
324
325 /* Probe if user mode */
326 PreviousMode = ExGetPreviousMode();
327 if (PreviousMode != KernelMode)
328 {
329 _SEH2_TRY
330 {
331 ProbeForWrite(Time,
332 sizeof(ULARGE_INTEGER),
333 sizeof(ULONG));
334
335 ProbeForWrite(Range,
336 sizeof(ULONG),
337 sizeof(ULONG));
338
339 ProbeForWrite(Sequence,
340 sizeof(ULONG),
341 sizeof(ULONG));
342
343 ProbeForWrite(Seed,
344 SEED_BUFFER_SIZE,
345 sizeof(UCHAR));
346 }
347 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
348 {
349 _SEH2_YIELD(return _SEH2_GetExceptionCode());
350 }
351 _SEH2_END;
352 }
353
354 ExAcquireFastMutex(&UuidMutex);
355
356 if (!UuidSequenceInitialized)
357 {
358 Status = ExpLoadUuidSequence(&UuidSequence);
359 if (NT_SUCCESS(Status))
360 {
361 UuidSequence++;
362 }
363 else
364 {
365 ExpGetRandomUuidSequence(&UuidSequence);
366 }
367
368 UuidSequenceInitialized = TRUE;
369 UuidSequenceChanged = TRUE;
370 }
371
372 Status = ExpCreateUuids(&IntTime,
373 &IntRange,
374 &UuidSequence);
375 if (!NT_SUCCESS(Status))
376 {
377 ExReleaseFastMutex(&UuidMutex);
378 return Status;
379 }
380
381 if (UuidSequenceChanged)
382 {
383 Status = ExpSaveUuidSequence(&UuidSequence);
384 if (NT_SUCCESS(Status))
385 UuidSequenceChanged = FALSE;
386 }
387
388 ExReleaseFastMutex(&UuidMutex);
389
390 /* Write back UUIDs to caller */
391 _SEH2_TRY
392 {
393 Time->QuadPart = IntTime.QuadPart;
394 *Range = IntRange;
395 *Sequence = UuidSequence;
396
397 RtlCopyMemory(Seed,
398 UuidSeed,
399 SEED_BUFFER_SIZE);
400
401 Status = STATUS_SUCCESS;
402 }
403 _SEH2_EXCEPT(ExSystemExceptionFilter())
404 {
405 Status = _SEH2_GetExceptionCode();
406 }
407 _SEH2_END;
408
409 return Status;
410 }
411
412
413 /*
414 * @implemented
415 */
416 NTSTATUS
417 NTAPI
418 NtSetUuidSeed(IN PUCHAR Seed)
419 {
420 NTSTATUS Status;
421 BOOLEAN GotContext;
422 PACCESS_TOKEN Token;
423 SECURITY_SUBJECT_CONTEXT SubjectContext;
424 LUID CallerLuid, SystemLuid = SYSTEM_LUID;
425
426 PAGED_CODE();
427
428 /* Should only be done by umode */
429 ASSERT(KeGetPreviousMode() != KernelMode);
430
431 /* No context to release */
432 GotContext = FALSE;
433 _SEH2_TRY
434 {
435 /* Get our caller context and remember to release it */
436 SeCaptureSubjectContext(&SubjectContext);
437 GotContext = TRUE;
438
439 /* Get caller access token and its associated ID */
440 Token = SeQuerySubjectContextToken(&SubjectContext);
441 Status = SeQueryAuthenticationIdToken(Token, &CallerLuid);
442 if (!NT_SUCCESS(Status))
443 {
444 RtlRaiseStatus(Status);
445 }
446
447 /* This call is only allowed for SYSTEM */
448 if (!RtlEqualLuid(&CallerLuid, &SystemLuid))
449 {
450 RtlRaiseStatus(STATUS_ACCESS_DENIED);
451 }
452
453 /* Check for buffer validity and then copy it to our seed */
454 ProbeForRead(Seed, SEED_BUFFER_SIZE, sizeof(UCHAR));
455 RtlCopyMemory(UuidSeed, Seed, SEED_BUFFER_SIZE);
456
457 Status = STATUS_SUCCESS;
458 }
459 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
460 {
461 Status = _SEH2_GetExceptionCode();
462 }
463 _SEH2_END;
464
465 /* Release context if required */
466 if (GotContext)
467 {
468 SeReleaseSubjectContext(&SubjectContext);
469 }
470
471 return Status;
472 }
473
474 /* EOF */