i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

A couple of endian fixes, inspired by Ingo - there might be some more left, though,

Browse Source 
it's untested yet.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@15693 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
2005-12-28 14:03:10 +00:00
parent c004406e92
commit 5e796c3bb3
1 changed files with 33 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/file_systems/bfs/BPlusTree.cpp
+33 -30
View File
@@ -737,14 +737,17 @@ BPlusTree::FindFreeDuplicateFragment(Transaction &transaction,
{
off_t *values = node->Values();
for (int32 i = 0; i < node->NumKeys(); i++) {
off_t value = BFS_ENDIAN_TO_HOST_INT64(values[i]);
// does the value link to a duplicate fragment?
if (bplustree_node::LinkType(values[i]) != BPLUSTREE_DUPLICATE_FRAGMENT)
if (bplustree_node::LinkType(value) != BPLUSTREE_DUPLICATE_FRAGMENT)
continue;
const bplustree_node *fragment = cached.SetTo(
bplustree_node::FragmentOffset(values[i]), false);
bplustree_node::FragmentOffset(value), false);
if (fragment == NULL) {
FATAL(("Could not get duplicate fragment at %Ld\n", values[i]));
FATAL(("Could not get duplicate fragment at %Ld\n",
BFS_ENDIAN_TO_HOST_INT64(values[i])));
continue;
}
@@ -759,7 +762,7 @@ BPlusTree::FindFreeDuplicateFragment(Transaction &transaction,
if (*_fragment == NULL)
return B_IO_ERROR;
*_offset = bplustree_node::FragmentOffset(values[i]);
*_offset = bplustree_node::FragmentOffset(value);
*_index = j;
return B_OK;
}
@@ -775,15 +778,14 @@ BPlusTree::InsertDuplicate(Transaction &transaction, CachedNode &cached,
{
CachedNode cachedDuplicate(this);
off_t *values = node->Values();
off_t oldValue = values[index];
off_t oldValue = BFS_ENDIAN_TO_HOST_INT64(values[index]);
status_t status;
off_t offset;
if (bplustree_node::IsDuplicate(oldValue)) {
//
// If it's a duplicate fragment, try to insert it into that, or if it
// doesn't fit anymore, create a new duplicate node
//
if (bplustree_node::LinkType(oldValue) == BPLUSTREE_DUPLICATE_FRAGMENT) {
bplustree_node *duplicate = cachedDuplicate.SetToWritable(transaction,
bplustree_node::FragmentOffset(oldValue), false);
@@ -816,7 +818,7 @@ BPlusTree::InsertDuplicate(Transaction &transaction, CachedNode &cached,
array->Insert(value);
} else {
// create a new duplicate node
cachedDuplicate.UnsetUnchanged(transaction);
// the old duplicate has not been touched, so we can reuse it
@@ -831,7 +833,7 @@ BPlusTree::InsertDuplicate(Transaction &transaction, CachedNode &cached,
memcpy(&newDuplicate->all_key_count, &array->values[0],
array->count * sizeof(off_t));
memset(array, 0, (NUM_FRAGMENT_VALUES + 1) * sizeof(off_t));
array = newDuplicate->DuplicateArray();
array->Insert(value);
}
@@ -840,7 +842,7 @@ BPlusTree::InsertDuplicate(Transaction &transaction, CachedNode &cached,
if (cached.MakeWritable(transaction) == NULL)
return B_IO_ERROR;
values[index] = bplustree_node::MakeLink(BPLUSTREE_DUPLICATE_NODE, offset);
values[index] = HOST_ENDIAN_TO_BFS_INT64(bplustree_node::MakeLink(BPLUSTREE_DUPLICATE_NODE, offset));
}
return B_OK;
@@ -918,7 +920,7 @@ BPlusTree::InsertDuplicate(Transaction &transaction, CachedNode &cached,
if (cached.MakeWritable(transaction) == NULL)
return B_IO_ERROR;
values[index] = bplustree_node::MakeLink(BPLUSTREE_DUPLICATE_FRAGMENT, offset, fragmentIndex);
values[index] = HOST_ENDIAN_TO_BFS_INT64(bplustree_node::MakeLink(BPLUSTREE_DUPLICATE_FRAGMENT, offset, fragmentIndex));
return B_OK;
}
@@ -946,7 +948,7 @@ BPlusTree::InsertKey(bplustree_node *node, uint16 index, uint8 *key, uint16 keyL
memmove(newValues + index + 1, values + index, sizeof(off_t) * (node->NumKeys() - 1 - index));
memmove(newValues, values, sizeof(off_t) * index);
newValues[index] = value;
newValues[index] = HOST_ENDIAN_TO_BFS_INT64(value);
// move and update key length index
for (uint16 i = node->NumKeys(); i-- > index + 1;)
@@ -1008,8 +1010,8 @@ BPlusTree::SplitNode(bplustree_node *node, off_t nodeOffset, bplustree_node *oth
}
out++;
if (round_up(sizeof(bplustree_node) + bytesBefore + bytesAfter + bytes) +
out * (sizeof(uint16) + sizeof(off_t)) >= size) {
if (round_up(sizeof(bplustree_node) + bytesBefore + bytesAfter + bytes)
+ out * (sizeof(uint16) + sizeof(off_t)) >= size) {
// we have found the number of keys in the new node!
break;
}
@@ -1042,7 +1044,7 @@ BPlusTree::SplitNode(bplustree_node *node, off_t nodeOffset, bplustree_node *oth
// copy the newly inserted key
memcpy(outKeys + bytesBefore, key, bytes);
outKeyLengths[keyIndex] = bytes + bytesBefore;
outKeyValues[keyIndex] = *_value;
outKeyValues[keyIndex] = HOST_ENDIAN_TO_BFS_INT64(*_value);
if (bytesAfter) {
// copy the keys after the new key
@@ -1171,7 +1173,7 @@ BPlusTree::SplitNode(bplustree_node *node, off_t nodeOffset, bplustree_node *oth
// finally, copy the newly inserted key (don't overwrite anything)
memcpy(inKeys + bytesBefore, key, bytes);
outKeyLengths[keyIndex] = bytes + bytesBefore;
outKeyValues[keyIndex] = *_value;
outKeyValues[keyIndex] = HOST_ENDIAN_TO_BFS_INT64(*_value);
}
// Prepare the key that will be inserted in the parent node which
@@ -1334,7 +1336,7 @@ BPlusTree::RemoveDuplicate(Transaction &transaction, const bplustree_node *node,
CachedNode &cached, uint16 index, off_t value)
{
off_t *values = node->Values();
off_t oldValue = values[index];
off_t oldValue = BFS_ENDIAN_TO_HOST_INT64(values[index]);
CachedNode cachedDuplicate(this);
off_t duplicateOffset = bplustree_node::FragmentOffset(oldValue);
@@ -1379,14 +1381,13 @@ BPlusTree::RemoveDuplicate(Transaction &transaction, const bplustree_node *node,
return B_OK;
}
//
// Remove value from a duplicate node!
//
duplicate_array *array = NULL;
if (duplicate->LeftLink() != BPLUSTREE_NULL) {
FATAL(("invalid duplicate node: first left link points to %Ld!\n", duplicate->LeftLink()));
FATAL(("invalid duplicate node: first left link points to %Ld!\n",
duplicate->LeftLink()));
return B_BAD_DATA;
}
@@ -1437,8 +1438,8 @@ BPlusTree::RemoveDuplicate(Transaction &transaction, const bplustree_node *node,
values[index] = array->values[0];
} else {
// move the duplicate link to the next node
values[index] = bplustree_node::MakeLink(BPLUSTREE_DUPLICATE_NODE,
right);
values[index] = HOST_ENDIAN_TO_BFS_INT64(bplustree_node::MakeLink(
BPLUSTREE_DUPLICATE_NODE, right));
}
}
@@ -1486,7 +1487,7 @@ BPlusTree::RemoveDuplicate(Transaction &transaction, const bplustree_node *node,
// move to other node
duplicate_array *target = fragment->FragmentAt(fragmentIndex);
memcpy(target, array, (NUM_FRAGMENT_VALUES + 1) * sizeof(off_t));
cachedDuplicate.Free(transaction, duplicateOffset);
duplicateOffset = offset;
} else {
@@ -1499,8 +1500,8 @@ BPlusTree::RemoveDuplicate(Transaction &transaction, const bplustree_node *node,
if (cached.MakeWritable(transaction) == NULL)
return B_IO_ERROR;
values[index] = bplustree_node::MakeLink(BPLUSTREE_DUPLICATE_FRAGMENT,
duplicateOffset, fragmentIndex);
values[index] = HOST_ENDIAN_TO_BFS_INT64(bplustree_node::MakeLink(
BPLUSTREE_DUPLICATE_FRAGMENT, duplicateOffset, fragmentIndex));
}
return B_OK;
}
@@ -1607,10 +1608,12 @@ BPlusTree::Remove(Transaction &transaction, const uint8 *key, uint16 keyLength,
next : BPLUSTREE_NULL, nodeAndKey.keyIndex, 0 , -1);
// is this a duplicate entry?
if (bplustree_node::IsDuplicate(node->Values()[nodeAndKey.keyIndex])) {
if (fAllowDuplicates)
return RemoveDuplicate(transaction, node, cached, nodeAndKey.keyIndex, value);
else {
if (bplustree_node::IsDuplicate(BFS_ENDIAN_TO_HOST_INT64(
node->Values()[nodeAndKey.keyIndex]))) {
if (fAllowDuplicates) {
return RemoveDuplicate(transaction, node, cached,
nodeAndKey.keyIndex, value);
} else {
FATAL(("dupliate node found where no duplicates are allowed!\n"));
RETURN_ERROR(B_ERROR);
}
@@ -1705,7 +1708,7 @@ BPlusTree::Replace(Transaction &transaction, const uint8 *key, uint16 keyLength,
if (status == B_OK) {
bplustree_node *writableNode = cached.MakeWritable(transaction);
if (writableNode != NULL)
writableNode->Values()[keyIndex] = value;
writableNode->Values()[keyIndex] = HOST_ENDIAN_TO_BFS_INT64(value);
else
status = B_IO_ERROR;
}