03d6c8bede9fd4908c9bbeb3ef2664fe306eb207
[reactos.git] / ntoskrnl / config / cmvalche.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/config/cmvalche.c
5 * PURPOSE: Configuration Manager - Value Cell Cache
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 FORCEINLINE
16 BOOLEAN
17 CmpIsValueCached(IN HCELL_INDEX CellIndex)
18 {
19 /* Make sure that the cell is valid in the first place */
20 if (CellIndex == HCELL_NIL) return FALSE;
21
22 /*Is this cell actually a pointer to the cached value data? */
23 if (CellIndex & 1) return TRUE;
24
25 /* This is a regular cell */
26 return FALSE;
27 }
28
29 FORCEINLINE
30 VOID
31 CmpSetValueCached(IN PHCELL_INDEX CellIndex)
32 {
33 /* Set the cached bit */
34 *CellIndex |= 1;
35 }
36
37 #define ASSERT_VALUE_CACHE() \
38 ASSERTMSG("Cached Values Not Yet Supported!", FALSE);
39
40 /* FUNCTIONS *****************************************************************/
41
42 VALUE_SEARCH_RETURN_TYPE
43 NTAPI
44 CmpGetValueListFromCache(IN PCM_KEY_CONTROL_BLOCK Kcb,
45 OUT PCELL_DATA *CellData,
46 OUT BOOLEAN *IndexIsCached,
47 OUT PHCELL_INDEX ValueListToRelease)
48 {
49 PHHIVE Hive;
50 PCACHED_CHILD_LIST ChildList;
51 HCELL_INDEX CellToRelease;
52
53 /* Set defaults */
54 *ValueListToRelease = HCELL_NIL;
55 *IndexIsCached = FALSE;
56
57 /* Get the hive and value cache */
58 Hive = Kcb->KeyHive;
59 ChildList = &Kcb->ValueCache;
60
61 /* Check if the value is cached */
62 if (CmpIsValueCached(ChildList->ValueList))
63 {
64 /* It is: we don't expect this yet! */
65 ASSERT_VALUE_CACHE();
66 *IndexIsCached = TRUE;
67 *CellData = NULL;
68 }
69 else
70 {
71 /* Make sure the KCB is locked exclusive */
72 if (!(CmpIsKcbLockedExclusive(Kcb)) &&
73 !(CmpTryToConvertKcbSharedToExclusive(Kcb)))
74 {
75 /* We need the exclusive lock */
76 return SearchNeedExclusiveLock;
77 }
78
79 /* Select the value list as our cell, and get the actual list array */
80 CellToRelease = ChildList->ValueList;
81 *CellData = (PCELL_DATA)HvGetCell(Hive, CellToRelease);
82 if (!(*CellData)) return SearchFail;
83
84 /* FIXME: Here we would cache the value */
85
86 /* Return the cell to be released */
87 *ValueListToRelease = CellToRelease;
88 }
89
90 /* If we got here, then the value list was found */
91 return SearchSuccess;
92 }
93
94 VALUE_SEARCH_RETURN_TYPE
95 NTAPI
96 CmpGetValueKeyFromCache(IN PCM_KEY_CONTROL_BLOCK Kcb,
97 IN PCELL_DATA CellData,
98 IN ULONG Index,
99 OUT PCM_CACHED_VALUE **CachedValue,
100 OUT PCM_KEY_VALUE *Value,
101 IN BOOLEAN IndexIsCached,
102 OUT BOOLEAN *ValueIsCached,
103 OUT PHCELL_INDEX CellToRelease)
104 {
105 PHHIVE Hive;
106 PCM_KEY_VALUE KeyValue;
107 HCELL_INDEX Cell;
108
109 /* Set defaults */
110 *CellToRelease = HCELL_NIL;
111 *Value = NULL;
112 *ValueIsCached = FALSE;
113
114 /* Get the hive */
115 Hive = Kcb->KeyHive;
116
117 /* Check if the index was cached */
118 if (IndexIsCached)
119 {
120 /* Not expected yet! */
121 ASSERT_VALUE_CACHE();
122 *ValueIsCached = TRUE;
123 }
124 else
125 {
126 /* Get the cell index and the key value associated to it */
127 Cell = CellData->u.KeyList[Index];
128 KeyValue = (PCM_KEY_VALUE)HvGetCell(Hive, Cell);
129 if (!KeyValue) return SearchFail;
130
131 /* Return the cell and the actual key value */
132 *CellToRelease = Cell;
133 *Value = KeyValue;
134 }
135
136 /* If we got here, then we found the key value */
137 return SearchSuccess;
138 }
139
140 VALUE_SEARCH_RETURN_TYPE
141 NTAPI
142 CmpGetValueDataFromCache(IN PCM_KEY_CONTROL_BLOCK Kcb,
143 IN PCM_CACHED_VALUE *CachedValue,
144 IN PCELL_DATA ValueKey,
145 IN BOOLEAN ValueIsCached,
146 OUT PVOID *DataPointer,
147 OUT PBOOLEAN Allocated,
148 OUT PHCELL_INDEX CellToRelease)
149 {
150 PHHIVE Hive;
151 ULONG Length;
152
153 /* Sanity checks */
154 ASSERT(MAXIMUM_CACHED_DATA < CM_KEY_VALUE_BIG);
155 ASSERT((ValueKey->u.KeyValue.DataLength & CM_KEY_VALUE_SPECIAL_SIZE) == 0);
156
157 /* Set defaults */
158 *DataPointer = NULL;
159 *Allocated = FALSE;
160 *CellToRelease = HCELL_NIL;
161
162 /* Get the hive */
163 Hive = Kcb->KeyHive;
164
165 /* Check it the value is cached */
166 if (ValueIsCached)
167 {
168 /* This isn't expected! */
169 ASSERT_VALUE_CACHE();
170 }
171 else
172 {
173 /* It's not, get the value data using the typical routine */
174 if (!CmpGetValueData(Hive,
175 &ValueKey->u.KeyValue,
176 &Length,
177 DataPointer,
178 Allocated,
179 CellToRelease))
180 {
181 /* Nothing found: make sure no data was allocated */
182 ASSERT(*Allocated == FALSE);
183 ASSERT(*DataPointer == NULL);
184 return SearchFail;
185 }
186 }
187
188 /* We found the actual data, return success */
189 return SearchSuccess;
190 }
191
192 VALUE_SEARCH_RETURN_TYPE
193 NTAPI
194 CmpFindValueByNameFromCache(IN PCM_KEY_CONTROL_BLOCK Kcb,
195 IN PCUNICODE_STRING Name,
196 OUT PCM_CACHED_VALUE **CachedValue,
197 OUT ULONG *Index,
198 OUT PCM_KEY_VALUE *Value,
199 OUT BOOLEAN *ValueIsCached,
200 OUT PHCELL_INDEX CellToRelease)
201 {
202 PHHIVE Hive;
203 VALUE_SEARCH_RETURN_TYPE SearchResult = SearchFail;
204 LONG Result;
205 UNICODE_STRING SearchName;
206 PCELL_DATA CellData;
207 PCACHED_CHILD_LIST ChildList;
208 PCM_KEY_VALUE KeyValue;
209 BOOLEAN IndexIsCached;
210 ULONG i = 0;
211 HCELL_INDEX Cell = HCELL_NIL;
212
213 /* Set defaults */
214 *CellToRelease = HCELL_NIL;
215 *Value = NULL;
216
217 /* Get the hive and child list */
218 Hive = Kcb->KeyHive;
219 ChildList = &Kcb->ValueCache;
220
221 /* Check if the child list has any entries */
222 if (ChildList->Count != 0)
223 {
224 /* Get the value list associated to this child list */
225 SearchResult = CmpGetValueListFromCache(Kcb,
226 &CellData,
227 &IndexIsCached,
228 &Cell);
229 if (SearchResult != SearchSuccess)
230 {
231 /* We either failed or need the exclusive lock */
232 ASSERT((SearchResult == SearchFail) || !(CmpIsKcbLockedExclusive(Kcb)));
233 ASSERT(Cell == HCELL_NIL);
234 return SearchResult;
235 }
236
237 /* The index shouldn't be cached right now */
238 if (IndexIsCached) ASSERT_VALUE_CACHE();
239
240 /* Loop every value */
241 while (TRUE)
242 {
243 /* Check if there's any cell to release */
244 if (*CellToRelease != HCELL_NIL)
245 {
246 /* Release it now */
247 HvReleaseCell(Hive, *CellToRelease);
248 *CellToRelease = HCELL_NIL;
249 }
250
251 /* Get the key value for this index */
252 SearchResult = CmpGetValueKeyFromCache(Kcb,
253 CellData,
254 i,
255 CachedValue,
256 Value,
257 IndexIsCached,
258 ValueIsCached,
259 CellToRelease);
260 if (SearchResult != SearchSuccess)
261 {
262 /* We either failed or need the exclusive lock */
263 ASSERT((SearchResult == SearchFail) || !(CmpIsKcbLockedExclusive(Kcb)));
264 ASSERT(Cell == HCELL_NIL);
265 return SearchResult;
266 }
267
268 /* Check if the both the index and the value are cached */
269 if (IndexIsCached && *ValueIsCached)
270 {
271 /* We don't expect this yet */
272 ASSERT_VALUE_CACHE();
273 Result = -1;
274 }
275 else
276 {
277 /* No cache, so try to compare the name. Is it compressed? */
278 KeyValue = *Value;
279 if (KeyValue->Flags & VALUE_COMP_NAME)
280 {
281 /* It is, do a compressed name comparison */
282 Result = CmpCompareCompressedName(Name,
283 KeyValue->Name,
284 KeyValue->NameLength);
285 }
286 else
287 {
288 /* It's not compressed, so do a standard comparison */
289 SearchName.Length = KeyValue->NameLength;
290 SearchName.MaximumLength = SearchName.Length;
291 SearchName.Buffer = KeyValue->Name;
292 Result = RtlCompareUnicodeString(Name, &SearchName, TRUE);
293 }
294 }
295
296 /* Check if we found the value data */
297 if (!Result)
298 {
299 /* We have, return the index of the value and success */
300 *Index = i;
301 SearchResult = SearchSuccess;
302 goto Quickie;
303 }
304
305 /* We didn't find it, try the next entry */
306 if (++i == ChildList->Count)
307 {
308 /* The entire list was parsed, fail */
309 *Value = NULL;
310 SearchResult = SearchFail;
311 goto Quickie;
312 }
313 }
314 }
315
316 /* We should only get here if the child list is empty */
317 ASSERT(ChildList->Count == 0);
318
319 Quickie:
320 /* Release the value list cell if required, and return search result */
321 if (Cell != HCELL_NIL) HvReleaseCell(Hive, Cell);
322 return SearchResult;
323 }
324
325 VALUE_SEARCH_RETURN_TYPE
326 NTAPI
327 CmpQueryKeyValueData(IN PCM_KEY_CONTROL_BLOCK Kcb,
328 IN PCM_CACHED_VALUE *CachedValue,
329 IN PCM_KEY_VALUE ValueKey,
330 IN BOOLEAN ValueIsCached,
331 IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
332 IN PVOID KeyValueInformation,
333 IN ULONG Length,
334 OUT PULONG ResultLength,
335 OUT PNTSTATUS Status)
336 {
337 PKEY_VALUE_INFORMATION Info = (PKEY_VALUE_INFORMATION)KeyValueInformation;
338 PCELL_DATA CellData;
339 USHORT NameSize;
340 ULONG Size, MinimumSize, SizeLeft, KeySize, AlignedData = 0, DataOffset;
341 PVOID Buffer;
342 BOOLEAN IsSmall, BufferAllocated = FALSE;
343 HCELL_INDEX CellToRelease = HCELL_NIL;
344 VALUE_SEARCH_RETURN_TYPE Result = SearchSuccess;
345
346 /* Get the value data */
347 CellData = (PCELL_DATA)ValueKey;
348
349 /* Check if the value is compressed */
350 if (CellData->u.KeyValue.Flags & VALUE_COMP_NAME)
351 {
352 /* Get the compressed name size */
353 NameSize = CmpCompressedNameSize(CellData->u.KeyValue.Name,
354 CellData->u.KeyValue.NameLength);
355 }
356 else
357 {
358 /* Get the real size */
359 NameSize = CellData->u.KeyValue.NameLength;
360 }
361
362 /* Check what kind of information the caller is requesting */
363 switch (KeyValueInformationClass)
364 {
365 /* Basic information */
366 case KeyValueBasicInformation:
367
368 /* This is how much size we'll need */
369 Size = FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name) + NameSize;
370
371 /* This is the minimum we can work with */
372 MinimumSize = FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name);
373
374 /* Return the size we'd like, and assume success */
375 *ResultLength = Size;
376 *Status = STATUS_SUCCESS;
377
378 /* Check if the caller gave us below our minimum */
379 if (Length < MinimumSize)
380 {
381 /* Then we must fail */
382 *Status = STATUS_BUFFER_TOO_SMALL;
383 break;
384 }
385
386 /* Fill out the basic information */
387 Info->KeyValueBasicInformation.TitleIndex = 0;
388 Info->KeyValueBasicInformation.Type = CellData->u.KeyValue.Type;
389 Info->KeyValueBasicInformation.NameLength = NameSize;
390
391 /* Now only the name is left */
392 SizeLeft = Length - MinimumSize;
393 Size = NameSize;
394
395 /* Check if the remaining buffer is too small for the name */
396 if (SizeLeft < Size)
397 {
398 /* Copy only as much as can fit, and tell the caller */
399 Size = SizeLeft;
400 *Status = STATUS_BUFFER_OVERFLOW;
401 }
402
403 /* Check if this is a compressed name */
404 if (CellData->u.KeyValue.Flags & VALUE_COMP_NAME)
405 {
406 /* Copy as much as we can of the compressed name */
407 CmpCopyCompressedName(Info->KeyValueBasicInformation.Name,
408 Size,
409 CellData->u.KeyValue.Name,
410 CellData->u.KeyValue.NameLength);
411 }
412 else
413 {
414 /* Copy as much as we can of the raw name */
415 RtlCopyMemory(Info->KeyValueBasicInformation.Name,
416 CellData->u.KeyValue.Name,
417 Size);
418 }
419
420 /* We're all done */
421 break;
422
423 /* Full key information */
424 case KeyValueFullInformation:
425 case KeyValueFullInformationAlign64:
426
427 /* Check if this is a small key and compute key size */
428 IsSmall = CmpIsKeyValueSmall(&KeySize,
429 CellData->u.KeyValue.DataLength);
430
431 /* Calculate the total size required */
432 Size = FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION, Name) +
433 NameSize +
434 KeySize;
435
436 /* And this is the least we can work with */
437 MinimumSize = FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION, Name);
438
439 /* Check if there's any key data */
440 if (KeySize > 0)
441 {
442 /* Calculate the data offset */
443 DataOffset = Size - KeySize;
444
445 #ifdef _WIN64
446 /* On 64-bit, always align to 8 bytes */
447 AlignedData = ALIGN_UP(DataOffset, ULONGLONG);
448 #else
449 /* On 32-bit, align the offset to 4 or 8 bytes */
450 if (KeyValueInformationClass == KeyValueFullInformationAlign64)
451 {
452 AlignedData = ALIGN_UP(DataOffset, ULONGLONG);
453 }
454 else
455 {
456 AlignedData = ALIGN_UP(DataOffset, ULONG);
457 }
458 #endif
459 /* If alignment was required, we'll need more space */
460 if (AlignedData > DataOffset) Size += (AlignedData-DataOffset);
461 }
462
463 /* Tell the caller the size we'll finally need, and set success */
464 *ResultLength = Size;
465 *Status = STATUS_SUCCESS;
466
467 /* Check if the caller is giving us too little */
468 if (Length < MinimumSize)
469 {
470 /* Then fail right now */
471 *Status = STATUS_BUFFER_TOO_SMALL;
472 break;
473 }
474
475 /* Fill out the basic information */
476 Info->KeyValueFullInformation.TitleIndex = 0;
477 Info->KeyValueFullInformation.Type = CellData->u.KeyValue.Type;
478 Info->KeyValueFullInformation.DataLength = KeySize;
479 Info->KeyValueFullInformation.NameLength = NameSize;
480
481 /* Only the name is left now */
482 SizeLeft = Length - MinimumSize;
483 Size = NameSize;
484
485 /* Check if the name fits */
486 if (SizeLeft < Size)
487 {
488 /* It doesn't, truncate what we'll copy, and tell the caller */
489 Size = SizeLeft;
490 *Status = STATUS_BUFFER_OVERFLOW;
491 }
492
493 /* Check if this key value is compressed */
494 if (CellData->u.KeyValue.Flags & VALUE_COMP_NAME)
495 {
496 /* It is, copy the compressed name */
497 CmpCopyCompressedName(Info->KeyValueFullInformation.Name,
498 Size,
499 CellData->u.KeyValue.Name,
500 CellData->u.KeyValue.NameLength);
501 }
502 else
503 {
504 /* It's not, copy the raw name */
505 RtlCopyMemory(Info->KeyValueFullInformation.Name,
506 CellData->u.KeyValue.Name,
507 Size);
508 }
509
510 /* Now check if the key had any data */
511 if (KeySize > 0)
512 {
513 /* Was it a small key? */
514 if (IsSmall)
515 {
516 /* Then the data is directly into the cell */
517 Buffer = &CellData->u.KeyValue.Data;
518 }
519 else
520 {
521 /* Otherwise, we must retrieve it from the value cache */
522 Result = CmpGetValueDataFromCache(Kcb,
523 CachedValue,
524 CellData,
525 ValueIsCached,
526 &Buffer,
527 &BufferAllocated,
528 &CellToRelease);
529 if (Result != SearchSuccess)
530 {
531 /* We failed, nothing should be allocated */
532 ASSERT(Buffer == NULL);
533 ASSERT(BufferAllocated == FALSE);
534 *Status = STATUS_INSUFFICIENT_RESOURCES;
535 }
536 }
537
538 /* Now that we know we truly have data, set its offset */
539 Info->KeyValueFullInformation.DataOffset = AlignedData;
540
541 /* Only the data remains to be copied */
542 SizeLeft = (((LONG)Length - (LONG)AlignedData) < 0) ?
543 0 : (Length - AlignedData);
544 Size = KeySize;
545
546 /* Check if the caller has no space for it */
547 if (SizeLeft < Size)
548 {
549 /* Truncate what we'll copy, and tell the caller */
550 Size = SizeLeft;
551 *Status = STATUS_BUFFER_OVERFLOW;
552 }
553
554 /* Sanity check */
555 ASSERT((IsSmall ? (Size <= CM_KEY_VALUE_SMALL) : TRUE));
556
557 /* Make sure we have a valid buffer */
558 if (Buffer)
559 {
560 /* Copy the data into the aligned offset */
561 RtlCopyMemory((PVOID)((ULONG_PTR)Info + AlignedData),
562 Buffer,
563 Size);
564 }
565 }
566 else
567 {
568 /* We don't have any data, set the offset to -1, not 0! */
569 Info->KeyValueFullInformation.DataOffset = 0xFFFFFFFF;
570 }
571
572 /* We're done! */
573 break;
574
575 /* Partial information requested (no name or alignment!) */
576 case KeyValuePartialInformation:
577
578 /* Check if this is a small key and compute key size */
579 IsSmall = CmpIsKeyValueSmall(&KeySize,
580 CellData->u.KeyValue.DataLength);
581
582 /* Calculate the total size required */
583 Size = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data) + KeySize;
584
585 /* And this is the least we can work with */
586 MinimumSize = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data);
587
588 /* Tell the caller the size we'll finally need, and set success */
589 *ResultLength = Size;
590 *Status = STATUS_SUCCESS;
591
592 /* Check if the caller is giving us too little */
593 if (Length < MinimumSize)
594 {
595 /* Then fail right now */
596 *Status = STATUS_BUFFER_TOO_SMALL;
597 break;
598 }
599
600 /* Fill out the basic information */
601 Info->KeyValuePartialInformation.TitleIndex = 0;
602 Info->KeyValuePartialInformation.Type = CellData->u.KeyValue.Type;
603 Info->KeyValuePartialInformation.DataLength = KeySize;
604
605 /* Now check if the key had any data */
606 if (KeySize > 0)
607 {
608 /* Was it a small key? */
609 if (IsSmall)
610 {
611 /* Then the data is directly into the cell */
612 Buffer = &CellData->u.KeyValue.Data;
613 }
614 else
615 {
616 /* Otherwise, we must retrieve it from the value cache */
617 Result = CmpGetValueDataFromCache(Kcb,
618 CachedValue,
619 CellData,
620 ValueIsCached,
621 &Buffer,
622 &BufferAllocated,
623 &CellToRelease);
624 if (Result != SearchSuccess)
625 {
626 /* We failed, nothing should be allocated */
627 ASSERT(Buffer == NULL);
628 ASSERT(BufferAllocated == FALSE);
629 *Status = STATUS_INSUFFICIENT_RESOURCES;
630 }
631 }
632
633 /* Only the data remains to be copied */
634 SizeLeft = Length - MinimumSize;
635 Size = KeySize;
636
637 /* Check if the caller has no space for it */
638 if (SizeLeft < Size)
639 {
640 /* Truncate what we'll copy, and tell the caller */
641 Size = SizeLeft;
642 *Status = STATUS_BUFFER_OVERFLOW;
643 }
644
645 /* Sanity check */
646 ASSERT((IsSmall ? (Size <= CM_KEY_VALUE_SMALL) : TRUE));
647
648 /* Make sure we have a valid buffer */
649 if (Buffer)
650 {
651 /* Copy the data into the aligned offset */
652 RtlCopyMemory(Info->KeyValuePartialInformation.Data,
653 Buffer,
654 Size);
655 }
656 }
657
658 /* We're done! */
659 break;
660
661 /* Other information class */
662 default:
663
664 /* We got some class that we don't support */
665 DPRINT1("Caller requested unknown class: %lx\n", KeyValueInformationClass);
666 *Status = STATUS_INVALID_PARAMETER;
667 break;
668 }
669
670 /* Return the search result as well */
671 return Result;
672 }
673
674 VALUE_SEARCH_RETURN_TYPE
675 NTAPI
676 CmpCompareNewValueDataAgainstKCBCache(IN PCM_KEY_CONTROL_BLOCK Kcb,
677 IN PUNICODE_STRING ValueName,
678 IN ULONG Type,
679 IN PVOID Data,
680 IN ULONG DataSize)
681 {
682 VALUE_SEARCH_RETURN_TYPE SearchResult;
683 PCM_KEY_NODE KeyNode;
684 PCM_CACHED_VALUE *CachedValue;
685 ULONG Index;
686 PCM_KEY_VALUE Value;
687 BOOLEAN ValueCached, BufferAllocated = FALSE;
688 PVOID Buffer;
689 HCELL_INDEX ValueCellToRelease = HCELL_NIL, CellToRelease = HCELL_NIL;
690 BOOLEAN IsSmall;
691 ULONG_PTR CompareResult;
692 PAGED_CODE();
693
694 /* Check if this is a symlink */
695 if (Kcb->Flags & KEY_SYM_LINK)
696 {
697 /* We need the exclusive lock */
698 if (!(CmpIsKcbLockedExclusive(Kcb)) &&
699 !(CmpTryToConvertKcbSharedToExclusive(Kcb)))
700 {
701 /* We need the exclusive lock */
702 return SearchNeedExclusiveLock;
703 }
704
705 /* Otherwise, get the key node */
706 KeyNode = (PCM_KEY_NODE)HvGetCell(Kcb->KeyHive, Kcb->KeyCell);
707 if (!KeyNode) return SearchFail;
708
709 /* Cleanup the KCB cache */
710 CmpCleanUpKcbValueCache(Kcb);
711
712 /* Sanity checks */
713 ASSERT(!(CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList)));
714 ASSERT(!(Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND));
715
716 /* Set the value cache */
717 Kcb->ValueCache.Count = KeyNode->ValueList.Count;
718 Kcb->ValueCache.ValueList = KeyNode->ValueList.List;
719
720 /* Release the cell */
721 HvReleaseCell(Kcb->KeyHive, Kcb->KeyCell);
722 }
723
724 /* Do the search */
725 SearchResult = CmpFindValueByNameFromCache(Kcb,
726 ValueName,
727 &CachedValue,
728 &Index,
729 &Value,
730 &ValueCached,
731 &ValueCellToRelease);
732 if (SearchResult == SearchNeedExclusiveLock)
733 {
734 /* We need the exclusive lock */
735 ASSERT(!CmpIsKcbLockedExclusive(Kcb));
736 ASSERT(ValueCellToRelease == HCELL_NIL);
737 ASSERT(Value == NULL);
738 goto Quickie;
739 }
740 else if (SearchResult == SearchSuccess)
741 {
742 /* Sanity check */
743 ASSERT(Value);
744
745 /* First of all, check if the key size and type matches */
746 if ((Type == Value->Type) &&
747 (DataSize == (Value->DataLength & ~CM_KEY_VALUE_SPECIAL_SIZE)))
748 {
749 /* Check if this is a small key */
750 IsSmall = (DataSize <= CM_KEY_VALUE_SMALL) ? TRUE: FALSE;
751 if (IsSmall)
752 {
753 /* Compare against the data directly */
754 Buffer = &Value->Data;
755 }
756 else
757 {
758 /* Do a search */
759 SearchResult = CmpGetValueDataFromCache(Kcb,
760 CachedValue,
761 (PCELL_DATA)Value,
762 ValueCached,
763 &Buffer,
764 &BufferAllocated,
765 &CellToRelease);
766 if (SearchResult != SearchSuccess)
767 {
768 /* Sanity checks */
769 ASSERT(Buffer == NULL);
770 ASSERT(BufferAllocated == FALSE);
771 goto Quickie;
772 }
773 }
774
775 /* Now check the data size */
776 if (DataSize)
777 {
778 /* Do the compare */
779 CompareResult = RtlCompareMemory(Buffer,
780 Data,
781 DataSize &
782 ~CM_KEY_VALUE_SPECIAL_SIZE);
783 }
784 else
785 {
786 /* It's equal */
787 CompareResult = 0;
788 }
789
790 /* Now check if the compare wasn't equal */
791 if (CompareResult != DataSize) SearchResult = SearchFail;
792 }
793 else
794 {
795 /* The length or type isn't equal */
796 SearchResult = SearchFail;
797 }
798 }
799
800 Quickie:
801 /* Release the value cell */
802 if (ValueCellToRelease) HvReleaseCell(Kcb->KeyHive, ValueCellToRelease);
803
804 /* Free the buffer */
805 if (BufferAllocated) CmpFree(Buffer, 0);
806
807 /* Free the cell */
808 if (CellToRelease) HvReleaseCell(Kcb->KeyHive, CellToRelease);
809
810 /* Return the search result */
811 return SearchResult;
812 }