/*
- * Copyright (c) 2000, 2005 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2014 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
//
if (curNodeNum == 0)
{
-// Panic("\pSearchTree: curNodeNum is zero!");
+// Panic("SearchTree: curNodeNum is zero!");
err = btBadNode;
goto ErrorExit;
}
- err = GetNode (btreePtr, curNodeNum, &nodeRec);
+ err = GetNode (btreePtr, curNodeNum, 0, &nodeRec);
if (err != noErr)
{
goto ErrorExit;
//
if (((BTNodeDescriptor*)nodeRec.buffer)->height != level)
{
-// Panic("\pIncorrect node height");
+// Panic("Incorrect node height");
err = btBadNode;
goto ReleaseAndExit;
}
// Nodes at level 1 must be leaves, by definition
if (nodeKind != kBTLeafNode)
{
- // Panic("\pIncorrect node type: expected leaf");
+ // Panic("Incorrect node type: expected leaf");
err = btBadNode;
goto ReleaseAndExit;
}
// A node at any other depth must be an index node
if (nodeKind != kBTIndexNode)
{
-// Panic("\pIncorrect node type: expected index");
+// Panic("Incorrect node type: expected index");
err = btBadNode;
goto ReleaseAndExit;
}
{
goto ErrorExit;
}
-
+
// The child node should be at a level one less than the parent.
--level;
}
InsertKey insertKey;
#if defined(applec) && !defined(__SC__)
- PanicIf ((level == 1) && (((NodeDescPtr)targetNode->buffer)->kind != kBTLeafNode), "\P InsertLevel: non-leaf at level 1! ");
+ PanicIf ((level == 1) && (((NodeDescPtr)targetNode->buffer)->kind != kBTLeafNode), " InsertLevel: non-leaf at level 1! ");
#endif
leftNode.buffer = nil;
leftNode.blockHeader = nil;
M_ExitOnError (err);
if ( DEBUG_BUILD && updateParent && newRoot )
- DebugStr("\p InsertLevel: New root from primary key, update from secondary key...");
+ DebugStr(" InsertLevel: New root from primary key, update from secondary key...");
}
//////////////////////// Update Parent(s) ///////////////////////////////
secondaryKey = nil;
- PanicIf ( (level == btreePtr->treeDepth), "\p InsertLevel: unfinished insert!?");
+ PanicIf ( (level == btreePtr->treeDepth), " InsertLevel: unfinished insert!?");
++level;
index = treePathTable [level].index;
parentNodeNum = treePathTable [level].node;
- PanicIf ( parentNodeNum == 0, "\p InsertLevel: parent node is zero!?");
+ PanicIf ( parentNodeNum == 0, " InsertLevel: parent node is zero!?");
- err = GetNode (btreePtr, parentNodeNum, &parentNode); // released as target node in next level up
+ err = GetNode (btreePtr, parentNodeNum, 0, &parentNode); // released as target node in next level up
M_ExitOnError (err);
#if defined(applec) && !defined(__SC__)
if (DEBUG_BUILD && level > 1)
- PanicIf ( ((NodeDescPtr)parentNode.buffer)->kind != kBTIndexNode, "\P InsertLevel: parent node not an index node! ");
+ PanicIf ( ((NodeDescPtr)parentNode.buffer)->kind != kBTIndexNode, " InsertLevel: parent node not an index node! ");
#endif
////////////////////////// Update Parent Index //////////////////////////////
//\80\80 debug: check if ptr == targetNodeNum
GetRecordByIndex (btreePtr, parentNode.buffer, index, &keyPtr, &recPtr, &recSize);
- PanicIf( (*(u_int32_t *) recPtr) != targetNodeNum, "\p InsertLevel: parent ptr doesn't match target node!");
+ PanicIf( (*(u_int32_t *) recPtr) != targetNodeNum, " InsertLevel: parent ptr doesn't match target node!");
// need to delete and re-insert this parent key/ptr
// we delete it here and it gets re-inserted in the
(void) ReleaseNode (btreePtr, targetNode);
(void) ReleaseNode (btreePtr, &leftNode);
- Panic ("\p InsertLevel: an error occurred!");
+ Panic (" InsertLevel: an error occurred!");
return err;
Boolean *insertParent,
Boolean *rootSplit )
{
- BlockDescriptor *targetNode;
+ BlockDescriptor *targetNode = NULL;
u_int32_t leftNodeNum;
u_int16_t recsRotated;
OSErr err;
*rootSplit = false;
- PanicIf ( rightNode->buffer == leftNode->buffer, "\p InsertNode: rightNode == leftNode, huh?");
+ PanicIf ( rightNode->buffer == leftNode->buffer, " InsertNode: rightNode == leftNode, huh?");
leftNodeNum = ((NodeDescPtr) rightNode->buffer)->bLink;
/////////////////////// Try Simple Insert ///////////////////////////////
- if ( node == leftNodeNum )
- targetNode = leftNode;
- else
- targetNode = rightNode;
-
+ /* sanity check our left and right nodes here. */
+ if (node == leftNodeNum) {
+ if (leftNode->buffer == NULL) {
+ err = fsBTInvalidNodeErr;
+ M_ExitOnError(err);
+ }
+ else{
+ targetNode = leftNode;
+ }
+ }
+ else {
+ // we can assume right node is initialized.
+ targetNode = rightNode;
+ }
+
+
recordFit = InsertKeyRecord (btreePtr, targetNode->buffer, index, key->keyPtr, key->keyLength, key->recPtr, key->recSize);
if ( recordFit )
if ( !recordFit && leftNodeNum > 0 )
{
- PanicIf ( leftNode->buffer != nil, "\p InsertNode: leftNode already aquired!");
+ PanicIf ( leftNode->buffer != nil, " InsertNode: leftNode already acquired!");
if ( leftNode->buffer == nil )
{
- err = GetNode (btreePtr, leftNodeNum, leftNode); // will be released by caller or a split below
+ err = GetNode (btreePtr, leftNodeNum, 0, leftNode); // will be released by caller or a split below
M_ExitOnError (err);
// XXXdbg
ModifyBlockStart(btreePtr->fileRefNum, leftNode);
}
- PanicIf ( ((NodeDescPtr) leftNode->buffer)->fLink != node, "\p InsertNode, RotateLeft: invalid sibling link!" );
+ PanicIf ( ((NodeDescPtr) leftNode->buffer)->fLink != node, " InsertNode, RotateLeft: invalid sibling link!" );
if ( !key->skipRotate ) // are rotates allowed?
{
targetNodeNum = treePathTable[level].node;
targetNodePtr = targetNode->buffer;
- PanicIf (targetNodePtr == nil, "\pDeleteTree: targetNode has nil buffer!");
+ PanicIf (targetNodePtr == nil, "DeleteTree: targetNode has nil buffer!");
// XXXdbg
ModifyBlockStart(btreePtr->fileRefNum, targetNode);
siblingNodeNum = targetNodePtr->bLink; // Left Sibling Node
if ( siblingNodeNum != 0 )
{
- err = GetNode (btreePtr, siblingNodeNum, &siblingNode);
+ err = GetNode (btreePtr, siblingNodeNum, 0, &siblingNode);
M_ExitOnError (err);
// XXXdbg
siblingNodeNum = targetNodePtr->fLink; // Right Sibling Node
if ( siblingNodeNum != 0 )
{
- err = GetNode (btreePtr, siblingNodeNum, &siblingNode);
+ err = GetNode (btreePtr, siblingNodeNum, 0, &siblingNode);
M_ExitOnError (err);
// XXXdbg
//// Get Parent Node and index
index = treePathTable [level].index;
- err = GetNode (btreePtr, treePathTable[level].node, &parentNode);
+ err = GetNode (btreePtr, treePathTable[level].node, 0, &parentNode);
M_ExitOnError (err);
if ( updateRequired )
//\80\80 debug: check if ptr == targetNodeNum
GetRecordByIndex (btreePtr, parentNode.buffer, index, &keyPtr, &recPtr, &recSize);
- PanicIf( (*(u_int32_t *) recPtr) != targetNodeNum, "\p DeleteTree: parent ptr doesn't match targetNodeNum!!");
+ PanicIf( (*(u_int32_t *) recPtr) != targetNodeNum, " DeleteTree: parent ptr doesn't match targetNodeNum!!");
// need to delete and re-insert this parent key/ptr
DeleteRecord (btreePtr, parentNode.buffer, index);
M_ExitOnError (err);
//// Get New Root Node
- err = GetNode (btreePtr, btreePtr->rootNode, blockPtr);
+ err = GetNode (btreePtr, btreePtr->rootNode, 0, blockPtr);
M_ExitOnError (err);
// XXXdbg
keyPtr, keyLength, recPtr, recSize);
if ( !didItFit )
{
- Panic ("\pRotateLeft: InsertKeyRecord (left) returned false!");
+ Panic ("RotateLeft: InsertKeyRecord (left) returned false!");
err = fsBTBadRotateErr;
goto ErrorExit;
}
didItFit = RotateRecordLeft (btreePtr, leftNode, rightNode);
if ( !didItFit )
{
- Panic ("\pRotateLeft: RotateRecordLeft returned false!");
+ Panic ("RotateLeft: RotateRecordLeft returned false!");
err = fsBTBadRotateErr;
goto ErrorExit;
}
keyPtr, keyLength, recPtr, recSize);
if ( !didItFit )
{
- Panic ("\pRotateLeft: InsertKeyRecord (right) returned false!");
+ Panic ("RotateLeft: InsertKeyRecord (right) returned false!");
err = fsBTBadRotateErr;
goto ErrorExit;
}
right = rightNode->buffer;
left = leftNode->buffer;
- PanicIf ( right->bLink != 0 && left == 0, "\p SplitLeft: left sibling missing!?" );
+ PanicIf ( right->bLink != 0 && left == 0, " SplitLeft: left sibling missing!?" );
/* type should be kBTLeafNode or kBTIndexNode */
rootNode.buffer = nil;
rootNode.blockHeader = nil;
- PanicIf (leftNode == nil, "\pAddNewRootNode: leftNode == nil");
- PanicIf (rightNode == nil, "\pAddNewRootNode: rightNode == nil");
+ PanicIf (leftNode == nil, "AddNewRootNode: leftNode == nil");
+ PanicIf (rightNode == nil, "AddNewRootNode: rightNode == nil");
/////////////////////// Initialize New Root Node ////////////////////////////
didItFit = InsertKeyRecord ( btreePtr, rootNode.buffer, 0, keyPtr, keyLength,
(u_int8_t *) &rightNode->bLink, 4 );
- PanicIf ( !didItFit, "\pAddNewRootNode:InsertKeyRecord failed for left index record");
+ PanicIf ( !didItFit, "AddNewRootNode:InsertKeyRecord failed for left index record");
//////////////////// Insert Right Node Index Record /////////////////////////
didItFit = InsertKeyRecord ( btreePtr, rootNode.buffer, 1, keyPtr, keyLength,
(u_int8_t *) &leftNode->fLink, 4 );
- PanicIf ( !didItFit, "\pAddNewRootNode:InsertKeyRecord failed for right index record");
+ PanicIf ( !didItFit, "AddNewRootNode:InsertKeyRecord failed for right index record");
/////////////////////////// Release Root Node ///////////////////////////////
// update BTreeInfoRec
btreePtr->rootNode = rootNum;
- btreePtr->flags |= kBTHeaderDirty;
-
+ M_BTreeHeaderDirty(btreePtr);
+
return noErr;
projects / apple / xnu.git / blobdiff