cmtredel.c File Reference

#include "cmp.h"

Go to the source code of this file.

Functions
VOID	CmpDeleteTree (PHHIVE Hive, HCELL_INDEX Cell)
NTSTATUS	CmpFreeKeyByCell (PHHIVE Hive, HCELL_INDEX Cell, BOOLEAN Unlink)
BOOLEAN	CmpMarkKeyDirty (PHHIVE Hive, HCELL_INDEX Cell)

---

Function Documentation

VOID CmpDeleteTree (  PHHIVE  Hive, HCELL_INDEX  Cell )

Definition at line 34 of file cmtredel.c. References Cell, CML_MAJOR, CMLOG, CmpFindSubKeyByNumber(), CmpFreeKeyByCell(), CMS_SAVRES, HCELL_INDEX, Hive, HvGetCell, _CM_KEY_NODE::Parent, Stable, _CM_KEY_NODE::SubKeyCounts, TRUE, and Volatile. Referenced by CmpSyncSubKeysAfterDelete(), and CmRestoreKey(). : Delete all child subkeys, recursively, of Hive.Cell. Delete all value entries of Hive.Cell. Do NOT delete Hive.Cell itself. NOTE: If this call fails part way through, it will NOT undo any successfully completed deletes. NOTE: This algorithm can deal with a hive of any depth, at the cost of some "redundent" scaning and mapping. Arguments: Hive - pointer to hive control structure for hive to delete from Cell - index of cell at root of tree to delete Return Value: BOOLEAN - Result code from call, among the following: TRUE - it worked FALSE - the tree delete was not completed (though more than 0 keys may have been deleted) --*/ { ULONG count; HCELL_INDEX ptr1; HCELL_INDEX ptr2; HCELL_INDEX parent; PCM_KEY_NODE Node; CMLOG(CML_MAJOR, CMS_SAVRES) { KdPrint(("CmpDeleteTree:\n")); KdPrint(("\tHive=%08lx Cell=%08lx\n",Hive,Cell)); } ptr1 = Cell; while(TRUE) { Node = (PCM_KEY_NODE)HvGetCell(Hive, ptr1); count = Node->SubKeyCounts[Stable] + Node->SubKeyCounts[Volatile]; parent = Node->Parent; if (count > 0) { // ptr1->count > 0? // // subkeys exist, find and delete them // ptr2 = CmpFindSubKeyByNumber(Hive, Node, 0); Node = (PCM_KEY_NODE)HvGetCell(Hive, ptr2); count = Node->SubKeyCounts[Stable] + Node->SubKeyCounts[Volatile]; if (count > 0) { // ptr2->count > 0? // // subkey has subkeys, descend to next level // ptr1 = ptr2; continue; } else { // // have found leaf, delete it // CmpFreeKeyByCell(Hive, ptr2, TRUE); continue; } } else { // // no more subkeys at this level, we are now a leaf. // if (ptr1 != Cell) { // // we are not at the root cell, so ascend to parent // ptr1 = parent; // ptr1 = ptr1->parent continue; } else { // // we are at the root cell, we are done // return; } } // outer if } // while }

NTSTATUS CmpFreeKeyByCell (  PHHIVE  Hive, HCELL_INDEX  Cell, BOOLEAN  Unlink )

Definition at line 140 of file cmtredel.c. References ASSERT, Cell, CmpFreeKeyBody(), CmpFreeSecurityDescriptor(), CmpFreeValue(), CmpMarkKeyDirty(), CmpRemoveSubKey(), _CHILD_LIST::Count, _CM_KEY_NODE::Flags, Hive, HvFreeCell(), HvGetCell, KEY_HIVE_EXIT, KEY_PREDEF_HANDLE, _CELL_DATA::_u::KeyList, _CELL_DATA::_u::KeyNode, _CHILD_LIST::List, _CM_KEY_NODE::MaxClassLen, _CM_KEY_NODE::MaxNameLen, _CM_KEY_NODE::Parent, Stable, _CM_KEY_NODE::SubKeyCounts, TRUE, _CELL_DATA::u, _CM_KEY_NODE::ValueList, and Volatile. Referenced by CmDeleteKey(), CmpDeleteTree(), CmpDestroyHive(), CmpDoCreate(), CmpSyncSubKeysAfterDelete(), CmRestoreKey(), and EhCreateChild(). : Actually free the storage for the specified cell. We will first remove it from its parent's child key list, then free all of its values, then the key body itself. Arguments: Hive - pointer to hive control structure for hive of interest Cell - index for cell to free storage for (the target) Unlink - if TRUE, target cell will be removed from parent cell's subkeylist, if FALSE, it will NOT be. Return Value: NONE. --*/ { PCELL_DATA ptarget; PCELL_DATA pparent; PCELL_DATA plist; ULONG i; // // Mark dirty everything that we might touch // if (! CmpMarkKeyDirty(Hive, Cell)) { return STATUS_NO_LOG_SPACE; } // // Map in the target // ptarget = HvGetCell(Hive, Cell); ASSERT((ptarget->u.KeyNode.SubKeyCounts[Stable] + ptarget->u.KeyNode.SubKeyCounts[Volatile]) == 0); if (Unlink == TRUE) { BOOLEAN Success; Success = CmpRemoveSubKey(Hive, ptarget->u.KeyNode.Parent, Cell); if (!Success) { return STATUS_INSUFFICIENT_RESOURCES; } pparent = HvGetCell(Hive, ptarget->u.KeyNode.Parent); if ( (pparent->u.KeyNode.SubKeyCounts[Stable] + pparent->u.KeyNode.SubKeyCounts[Volatile]) == 0) { pparent->u.KeyNode.MaxNameLen = 0; pparent->u.KeyNode.MaxClassLen = 0; } } // // Target is now an unreferenced key, free it's actual storage // // // Free misc stuff // if (!(ptarget->u.KeyNode.Flags & KEY_HIVE_EXIT) && !(ptarget->u.KeyNode.Flags & KEY_PREDEF_HANDLE) ) { // // First, free the value entries // if (ptarget->u.KeyNode.ValueList.Count > 0) { // target list plist = HvGetCell(Hive, ptarget->u.KeyNode.ValueList.List); for (i = 0; i < ptarget->u.KeyNode.ValueList.Count; i++) { CmpFreeValue(Hive, plist->u.KeyList[i]); } HvFreeCell(Hive, ptarget->u.KeyNode.ValueList.List); } // // Free the security descriptor // CmpFreeSecurityDescriptor(Hive, Cell); } // // Free the key body itself, and Class data. // CmpFreeKeyBody(Hive, Cell); return STATUS_SUCCESS; }

BOOLEAN CmpMarkKeyDirty (  PHHIVE  Hive, HCELL_INDEX  Cell )

Definition at line 245 of file cmtredel.c. References ASSERT, _CM_KEY_SECURITY::Blink, Cell, _CM_KEY_NODE::Class, CmpIsHKeyValueSmall, CmpMarkIndexDirty(), _CHILD_LIST::Count, _CM_KEY_VALUE::Data, _CM_KEY_VALUE::DataLength, FALSE, _CM_KEY_NODE::Flags, _CM_KEY_SECURITY::Flink, HCELL_NIL, Hive, HvGetCell, HvMarkCellDirty(), KEY_HIVE_ENTRY, KEY_HIVE_EXIT, KEY_PREDEF_HANDLE, _CELL_DATA::_u::KeyList, _CELL_DATA::_u::KeyNode, _CELL_DATA::_u::KeySecurity, _CELL_DATA::_u::KeyValue, _CHILD_LIST::List, _CM_KEY_NODE::Parent, _CM_KEY_NODE::Security, Stable, _CM_KEY_NODE::SubKeyCounts, TRUE, _CELL_DATA::u, _CM_KEY_NODE::ValueList, and Volatile. Referenced by CmpFreeKeyByCell(). 00251 : 00252 00253 Mark all of the cells related to a key being deleted dirty. 00254 Includes the parent, the parent's child list, the key body, 00255 class, security, all value entry bodies, and all of their data cells. 00256 00257 Arguments: 00258 00259 Hive - pointer to hive control structure for hive of interest 00260 00261 Cell - index for cell holding keybody to make dirty 00262 00263 Return Value: 00264 00265 TRUE - it worked 00266 00267 FALSE - some error, most likely cannot get log space 00268 00269 --*/ 00270 { 00271 PCELL_DATA ptarget; 00272 PCELL_DATA plist; 00273 PCELL_DATA security; 00274 PCELL_DATA pvalue; 00275 ULONG i; 00276 ULONG realsize; 00277 00278 00279 // 00280 // Map in the target 00281 // 00282 ptarget = HvGetCell(Hive, Cell); 00283 ASSERT(ptarget->u.KeyNode.SubKeyCounts[Stable] == 0); 00284 ASSERT(ptarget->u.KeyNode.SubKeyCounts[Volatile] == 0); 00285 00286 if (ptarget->u.KeyNode.Flags & KEY_HIVE_EXIT) { 00287 00288 // 00289 // If this is a link node, we are done. Link nodes never have 00290 // classes, values, subkeys, or security descriptors. Since 00291 // they always reside in the master hive, they're always volatile. 00292 // 00293 return(TRUE); 00294 } 00295 00296 // 00297 // mark cell itself 00298 // 00299 if (! HvMarkCellDirty(Hive, Cell)) { 00300 return FALSE; 00301 } 00302 00303 // 00304 // Mark the class 00305 // 00306 if (ptarget->u.KeyNode.Class != HCELL_NIL) { 00307 if (! HvMarkCellDirty(Hive, ptarget->u.KeyNode.Class)) { 00308 return FALSE; 00309 } 00310 } 00311 00312 // 00313 // Mark security 00314 // 00315 if (ptarget->u.KeyNode.Security != HCELL_NIL) { 00316 if (! HvMarkCellDirty(Hive, ptarget->u.KeyNode.Security)) { 00317 return FALSE; 00318 } 00319 00320 security = HvGetCell(Hive, ptarget->u.KeyNode.Security); 00321 if (! (HvMarkCellDirty(Hive, security->u.KeySecurity.Flink) && 00322 HvMarkCellDirty(Hive, security->u.KeySecurity.Blink))) 00323 { 00324 return FALSE; 00325 } 00326 } 00327 00328 // 00329 // Mark the value entries and their data 00330 // 00331 if ( !(ptarget->u.KeyNode.Flags & KEY_PREDEF_HANDLE) && 00332 (ptarget->u.KeyNode.ValueList.Count > 0) 00333 ) { 00334 00335 // target list 00336 if (! HvMarkCellDirty(Hive, ptarget->u.KeyNode.ValueList.List)) { 00337 return FALSE; 00338 } 00339 plist = HvGetCell(Hive, ptarget->u.KeyNode.ValueList.List); 00340 00341 for (i = 0; i < ptarget->u.KeyNode.ValueList.Count; i++) { 00342 if (! HvMarkCellDirty(Hive, plist->u.KeyList[i])) { 00343 return FALSE; 00344 } 00345 00346 pvalue = HvGetCell(Hive, plist->u.KeyList[i]); 00347 00348 if (!CmpIsHKeyValueSmall(realsize, pvalue->u.KeyValue.DataLength)) { 00349 if (! HvMarkCellDirty(Hive, pvalue->u.KeyValue.Data)) { 00350 return(FALSE); 00351 } 00352 } 00353 } 00354 } 00355 00356 if (ptarget->u.KeyNode.Flags & KEY_HIVE_ENTRY) { 00357 00358 // 00359 // if this is an entry node, we are done. our parent will 00360 // be in the master hive (and thus volatile) 00361 // 00362 return TRUE; 00363 } 00364 00365 // 00366 // Mark the parent's Subkey list 00367 // 00368 if (! CmpMarkIndexDirty(Hive, ptarget->u.KeyNode.Parent, Cell)) { 00369 return FALSE; 00370 } 00371 00372 // 00373 // Mark the parent 00374 // 00375 if (! HvMarkCellDirty(Hive, ptarget->u.KeyNode.Parent)) { 00376 return FALSE; 00377 } 00378 00379 00380 return TRUE; 00381 } }

---