drinkingtea/nostalgia
drinkingtea/nostalgia
2
0
Fork 0
Code Issues 6 Pull Requests Actions Releases 9 Activity

[ox/fs] Cleanup

Browse Source
This commit is contained in:
Gary Talent 2021-07-01 00:27:14 -05:00
parent 50715ff663
commit 66a11eae31
11 changed files with 255 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

368
deps/ox/src/ox/fs/filestore/filestoretemplate.hpp vendored
View File

@ -39,6 +39,7 @@ struct OX_PACKED FileStoreItem: public ptrarith::Item<size_t> {
/** /**
* @return the size of the data + the size of the Item type * @return the size of the data + the size of the Item type
*/ */
[[nodiscard]]
size_t fullSize() const { size_t fullSize() const {
return sizeof(*this) + this->size(); return sizeof(*this) + this->size();
} }
@ -85,11 +86,11 @@ class FileStoreTemplate {
Error decLinks(InodeId_t id); Error decLinks(InodeId_t id);
Error write(InodeId_t id, const void *data, FsSize_t dataLen, uint8_t fileType = 0); Error write(InodeId_t id, const void *data, FsSize_t dataSize, uint8_t fileType = 0);
Error remove(InodeId_t id); Error remove(InodeId_t id);
Error read(InodeId_t id, void *data, FsSize_t dataSize, FsSize_t *size = nullptr) const; Error read(InodeId_t id, void *out, FsSize_t outSize, FsSize_t *size = nullptr) const;
Error read(InodeId_t id, FsSize_t readStart, FsSize_t readSize, void *data, FsSize_t *size = nullptr) const; Error read(InodeId_t id, FsSize_t readStart, FsSize_t readSize, void *data, FsSize_t *size = nullptr) const;
@ -116,13 +117,17 @@ class FileStoreTemplate {
Error resize(std::size_t size, void *newBuff = nullptr); Error resize(std::size_t size, void *newBuff = nullptr);
[[nodiscard]] InodeId_t spaceNeeded(FsSize_t size); [[nodiscard]]
InodeId_t spaceNeeded(FsSize_t size);
[[nodiscard]] InodeId_t size() const; [[nodiscard]]
InodeId_t size() const;
[[nodiscard]] InodeId_t available(); [[nodiscard]]
InodeId_t available();
[[nodiscard]] char *buff(); [[nodiscard]]
char *buff();
Error walk(Error(*cb)(uint8_t, uint64_t, uint64_t)); Error walk(Error(*cb)(uint8_t, uint64_t, uint64_t));
@ -164,7 +169,7 @@ class FileStoreTemplate {
/** /**
* Finds the parent an inode by its ID. * Finds the parent an inode by its ID.
*/ */
ItemPtr findParent(ItemPtr ptr, size_t id, size_t oldAddr) const; ItemPtr findParent(ItemPtr item, size_t id, size_t oldAddr) const;
/** /**
* Finds an inode by its ID. * Finds an inode by its ID.
@ -204,11 +209,10 @@ Error FileStoreTemplate<size_t>::format(void *buffer, size_t bufferSize) {
if (data.valid()) { if (data.valid()) {
new (data) FileStoreData; new (data) FileStoreData;
return OxError(0); return OxError(0);
} else {
oxTrace("ox::fs::FileStoreTemplate::format::fail") << "Could not read data section of FileStoreData";
} }
} }
return OxError(1); oxTrace("ox::fs::FileStoreTemplate::format::fail", "Could not read data section of FileStoreData");
return OxError(1, "Could not read data section of FileStoreData");
} }
template<typename size_t> template<typename size_t>
@ -221,30 +225,24 @@ Error FileStoreTemplate<size_t>::setSize(InodeId_t size) {
template<typename size_t> template<typename size_t>
Error FileStoreTemplate<size_t>::incLinks(InodeId_t id) { Error FileStoreTemplate<size_t>::incLinks(InodeId_t id) {
auto item = find(id); oxRequireM(item, find(id).validate());
if (item.valid()) { item->links++;
item->links++; return OxError(0);
return OxError(0);
}
return OxError(1);
} }
template<typename size_t> template<typename size_t>
Error FileStoreTemplate<size_t>::decLinks(InodeId_t id) { Error FileStoreTemplate<size_t>::decLinks(InodeId_t id) {
auto item = find(id); oxRequireM(item, find(id).validate());
if (item.valid()) { item->links--;
item->links--; if (item->links == 0) {
if (item->links == 0) { oxReturnError(remove(item));
oxReturnError(remove(item));
}
return OxError(0);
} }
return OxError(1); return OxError(0);
} }
template<typename size_t> template<typename size_t>
Error FileStoreTemplate<size_t>::write(InodeId_t id, const void *data, FsSize_t dataSize, uint8_t fileType) { Error FileStoreTemplate<size_t>::write(InodeId_t id, const void *data, FsSize_t dataSize, uint8_t fileType) {
oxTrace("ox::fs::FileStoreTemplate::write") << "Attempting to write to inode" << id; oxTracef("ox::fs::FileStoreTemplate::write", "Attempting to write to inode {}", id);
auto existing = find(id); auto existing = find(id);
if (!canWrite(existing, dataSize)) { if (!canWrite(existing, dataSize)) {
oxReturnError(compact()); oxReturnError(compact());
@ -254,25 +252,24 @@ Error FileStoreTemplate<size_t>::write(InodeId_t id, const void *data, FsSize_t
if (canWrite(existing, dataSize)) { if (canWrite(existing, dataSize)) {
// delete the old node if it exists // delete the old node if it exists
if (existing.valid()) { if (existing.valid()) {
oxTrace("ox::fs::FileStoreTemplate::write") << "Freeing old version of inode found at offset:" << existing.offset(); oxTracef("ox::fs::FileStoreTemplate::write", "Freeing old version of inode found at offset: {}", existing.offset());
auto err = m_buffer->free(existing); auto err = m_buffer->free(existing);
if (err) { if (err) {
oxTrace("ox::fs::FileStoreTemplate::write::fail") << "Free of old version of inode failed"; oxTrace("ox::fs::FileStoreTemplate::write::fail", "Free of old version of inode failed");
return err; return err;
} }
existing = nullptr; existing = nullptr;
} }
// write the given data // write the given data
auto dest = m_buffer->malloc(dataSize); auto dest = m_buffer->malloc(dataSize);
// if first malloc failed, compact and try again // if first malloc failed, compact and try again
if (!dest.valid()) { if (!dest.valid()) {
oxTrace("ox::fs::FileStoreTemplate::write") << "Allocation failed, compacting"; oxTrace("ox::fs::FileStoreTemplate::write", "Allocation failed, compacting");
oxReturnError(compact()); oxReturnError(compact());
dest = m_buffer->malloc(dataSize); dest = m_buffer->malloc(dataSize);
} }
if (dest.valid()) { if (dest.valid()) {
oxTrace("ox::fs::FileStoreTemplate::write") << "Memory allocated"; oxTrace("ox::fs::FileStoreTemplate::write", "Memory allocated");
dest->id = id; dest->id = id;
dest->fileType = fileType; dest->fileType = fileType;
auto destData = m_buffer->template dataOf<uint8_t>(dest); auto destData = m_buffer->template dataOf<uint8_t>(dest);
@ -281,24 +278,26 @@ Error FileStoreTemplate<size_t>::write(InodeId_t id, const void *data, FsSize_t
// write data if any was provided // write data if any was provided
if (data != nullptr) { if (data != nullptr) {
ox_memcpy(destData, data, dest->size()); ox_memcpy(destData, data, dest->size());
oxTrace("ox::fs::FileStoreTemplate::write") << "Data written"; oxTrace("ox::fs::FileStoreTemplate::write", "Data written");
} }
auto fsData = fileStoreData(); auto fsData = fileStoreData();
if (fsData) { if (fsData) {
oxTrace("ox::fs::FileStoreTemplate::write") << "Searching for root node at" << fsData->rootNode; oxTracef("ox::fs::FileStoreTemplate::write", "Searching for root node at {}", fsData->rootNode.get());
auto root = m_buffer->ptr(fsData->rootNode); auto root = m_buffer->ptr(fsData->rootNode);
if (root.valid()) { if (root.valid()) {
oxTrace("ox::fs::FileStoreTemplate::write") << "Placing" << dest->id << "on" << root->id << "at" << destData.offset(); oxTracef("ox::fs::FileStoreTemplate::write",
"Placing {} on {} at {}", dest->id.get(), root->id.get(), destData.offset());
return placeItem(dest); return placeItem(dest);
} else { } else {
oxTrace("ox::fs::FileStoreTemplate::write") << "Initializing root inode:" << dest->id << "( offset:" << dest.offset() oxTracef("ox::fs::FileStoreTemplate::write",
<< ", data size:" << destData.size() << ")"; "Initializing root inode: {} (offset: {}, data size: {})",
dest->id.get(), dest.offset(), destData.size());
fsData->rootNode = dest.offset(); fsData->rootNode = dest.offset();
oxTrace("ox::fs::FileStoreTemplate::write") << "Root inode:" << dest->id; oxTracef("ox::fs::FileStoreTemplate::write", "Root inode: {}", dest->id.get());
return OxError(0); return OxError(0);
} }
} else { } else {
oxTrace("ox::fs::FileStoreTemplate::write::fail") << "Could not place item due to absence of FileStore header."; oxTrace("ox::fs::FileStoreTemplate::write::fail", "Could not place item due to absence of FileStore header.");
} }
} }
} }
@ -314,28 +313,24 @@ Error FileStoreTemplate<size_t>::remove(InodeId_t id) {
template<typename size_t> template<typename size_t>
Error FileStoreTemplate<size_t>::read(InodeId_t id, void *out, FsSize_t outSize, FsSize_t *size) const { Error FileStoreTemplate<size_t>::read(InodeId_t id, void *out, FsSize_t outSize, FsSize_t *size) const {
oxTrace("ox::fs::FileStoreTemplate::read") << "Attempting to read from inode" << id; oxTracef("ox::fs::FileStoreTemplate::read", "Attempting to read from inode {}", id);
auto src = find(id); auto src = find(id);
// error check // error check
if (!src.valid()) { if (!src.valid()) {
oxTrace("ox::fs::FileStoreTemplate::read::fail") << "Could not find requested item:" << id; oxTracef("ox::fs::FileStoreTemplate::read::fail", "Could not find requested item: {}", id);
return OxError(1); return OxError(1);
} }
auto srcData = m_buffer->template dataOf<uint8_t>(src); auto srcData = m_buffer->template dataOf<uint8_t>(src);
oxTrace("ox::fs::FileStoreTemplate::read::found") << id << "found at"<< src.offset() oxTracef("ox::fs::FileStoreTemplate::read::found", "{} found at {} with data section at {}",
<< "with data section at" << srcData.offset(); id, src.offset(), srcData.offset());
oxTrace("ox::fs::FileStoreTemplate::read::outSize") << srcData.offset() << srcData.size() << outSize; oxTracef("ox::fs::FileStoreTemplate::read::outSize", "{} {} {}", srcData.offset(), srcData.size(), outSize);
// error check // error check
if (!(srcData.valid() && srcData.size() <= outSize)) { if (!(srcData.valid() && srcData.size() <= outSize)) {
oxTrace("ox::fs::FileStoreTemplate::read::fail") oxTracef("ox::fs::FileStoreTemplate::read::fail", "Could not read data section of item: {}", id);
<< "Could not read data section of item:" << id; oxTracef("ox::fs::FileStoreTemplate::read::fail",
oxTrace("ox::fs::FileStoreTemplate::read::fail").del("") "Item data section size: {}, Expected size: {}", srcData.size(), outSize);
<< "Item data section size: " << srcData.size()
<< ", Expected size: " << outSize;
return OxError(1); return OxError(1);
} }
@ -349,54 +344,37 @@ Error FileStoreTemplate<size_t>::read(InodeId_t id, void *out, FsSize_t outSize,
template<typename size_t> template<typename size_t>
Error FileStoreTemplate<size_t>::read(InodeId_t id, FsSize_t readStart, FsSize_t readSize, void *data, FsSize_t *size) const { Error FileStoreTemplate<size_t>::read(InodeId_t id, FsSize_t readStart, FsSize_t readSize, void *data, FsSize_t *size) const {
auto src = find(id); oxRequireM(src, find(id).validate());
if (src.valid()) { oxRequireM(srcData, src->data().validate());
auto srcData = src->data(); oxRequire(sub, srcData.template subPtr<uint8_t>(readStart, readSize).validate());
if (srcData.valid()) { memcpy(data, sub, sub.size());
auto sub = srcData.template subPtr<uint8_t>(readStart, readSize); if (size) {
if (sub.valid()) { *size = sub.size();
ox_memcpy(data, sub, sub.size());
if (size) {
*size = sub.size();
}
return OxError(0);
} else {
oxTrace("ox::fs::FileStoreTemplate::read::fail") << "Could not read requested data sub-section of item:" << id;
}
} else {
oxTrace("ox::fs::FileStoreTemplate::read::fail") << "Could not read data section of item:" << id;
}
} else {
oxTrace("ox::fs::FileStoreTemplate::read::fail") << "Could not find requested item:" << id;
} }
return OxError(1); return OxError(0);
} }
template<typename size_t> template<typename size_t>
template<typename T> template<typename T>
Error FileStoreTemplate<size_t>::read(InodeId_t id, FsSize_t readStart, Error FileStoreTemplate<size_t>::read(InodeId_t id, FsSize_t readStart,
FsSize_t readSize, T *data, FsSize_t *size) const { FsSize_t readSize, T *data, FsSize_t *size) const {
auto src = find(id); oxRequireM(src, find(id).validate());
if (src.valid()) { oxRequireM(srcData, src->data().validate());
auto srcData = src->data(); auto sub = srcData.template subPtr<uint8_t>(readStart, readSize);
if (srcData.valid()) { if (sub.valid() && sub.size() % sizeof(T)) {
auto sub = srcData.template subPtr<uint8_t>(readStart, readSize); for (FsSize_t i = 0; i < sub.size() / sizeof(T); i++) {
if (sub.valid() && sub.size() % sizeof(T)) { // do byte-by-byte copy to ensure alignment is right when
for (FsSize_t i = 0; i < sub.size() / sizeof(T); i++) { // copying to final destination
// do byte-by-byte copy to ensure alignment is right when T tmp;
// copying to final destination for (size_t ii = 0; ii < sizeof(T); ii++) {
T tmp; reinterpret_cast<uint8_t*>(&tmp)[ii] = *(sub.get() + ii);
for (size_t ii = 0; ii < sizeof(T); ii++) {
reinterpret_cast<uint8_t*>(&tmp)[ii] = *(sub.get() + ii);
}
*(data + i) = tmp;
}
if (size) {
*size = sub.size();
}
return OxError(0);
} }
*(data + i) = tmp;
} }
if (size) {
*size = sub.size();
}
return OxError(0);
} }
return OxError(1); return OxError(1);
} }
@ -415,9 +393,9 @@ template<typename size_t>
Error FileStoreTemplate<size_t>::resize() { Error FileStoreTemplate<size_t>::resize() {
oxReturnError(compact()); oxReturnError(compact());
const auto newSize = size() - available(); const auto newSize = size() - available();
oxTrace("ox::fs::FileStoreTemplate::resize") << "resize to:" << newSize; oxTracef("ox::fs::FileStoreTemplate::resize", "resize to: {}", newSize);
oxReturnError(m_buffer->setSize(newSize)); oxReturnError(m_buffer->setSize(newSize));
oxTrace("ox::fs::FileStoreTemplate::resize") << "resized to:" << m_buffer->size(); oxTracef("ox::fs::FileStoreTemplate::resize", "resized to: {}", m_buffer->size());
return OxError(0); return OxError(0);
} }
@ -436,16 +414,13 @@ Error FileStoreTemplate<size_t>::resize(std::size_t size, void *newBuff) {
template<typename size_t> template<typename size_t>
Result<StatInfo> FileStoreTemplate<size_t>::stat(InodeId_t id) { Result<StatInfo> FileStoreTemplate<size_t>::stat(InodeId_t id) {
auto inode = find(id); oxRequireM(inode, find(id).validate());
if (inode.valid()) { return StatInfo {
return Result<StatInfo>({ id,
id, inode->links,
inode->links, inode->size(),
inode->size(), inode->fileType,
inode->fileType, };
});
}
return {};
} }
template<typename size_t> template<typename size_t>
@ -479,16 +454,16 @@ Error FileStoreTemplate<size_t>::walk(Error(*cb)(uint8_t, uint64_t, uint64_t)) {
template<typename size_t> template<typename size_t>
Result<typename FileStoreTemplate<size_t>::InodeId_t> FileStoreTemplate<size_t>::generateInodeId() { Result<typename FileStoreTemplate<size_t>::InodeId_t> FileStoreTemplate<size_t>::generateInodeId() {
auto fsData = fileStoreData(); auto fsData = fileStoreData();
if (fsData) { if (!fsData) {
for (auto i = 0; i < 100; i++) { return OxError(1);
auto inode = fsData->random.gen() % MaxValue<InodeId_t>;
if (inode > ReservedInodeEnd && !find(inode).valid()) {
return inode;
}
}
return OxError(2);
} }
return OxError(1); for (auto i = 0; i < 100; i++) {
auto inode = fsData->random.gen() % MaxValue<InodeId_t>;
if (inode > ReservedInodeEnd && !find(inode).valid()) {
return inode;
}
}
return OxError(2);
} }
template<typename size_t> template<typename size_t>
@ -502,10 +477,7 @@ Error FileStoreTemplate<size_t>::compact() {
if (!item.valid()) { if (!item.valid()) {
return OxError(1); return OxError(1);
} }
oxTrace("ox::FileStoreTemplate::compact::moveItem") oxTracef("ox::FileStoreTemplate::compact::moveItem", "Moving Item: {} from {} to {}", item->id.get(), oldAddr, item.offset());
<< "Moving Item:" << item->id
<< "from" << oldAddr
<< "to" << item.offset();
// update rootInode if this is it // update rootInode if this is it
auto fsData = fileStoreData(); auto fsData = fileStoreData();
if (fsData && oldAddr == fsData->rootNode) { if (fsData && oldAddr == fsData->rootNode) {
@ -540,109 +512,104 @@ typename FileStoreTemplate<size_t>::FileStoreData *FileStoreTemplate<size_t>::fi
template<typename size_t> template<typename size_t>
Error FileStoreTemplate<size_t>::placeItem(ItemPtr item) { Error FileStoreTemplate<size_t>::placeItem(ItemPtr item) {
auto fsData = fileStoreData(); auto fsData = fileStoreData();
if (fsData) { if (!fsData) {
auto root = m_buffer->ptr(fsData->rootNode); return OxError(1);
if (root.valid()) { }
if (root->id == item->id) { oxRequireM(root, m_buffer->ptr(fsData->rootNode).validate());
fsData->rootNode = item; if (root->id == item->id) {
item->left = root->left; fsData->rootNode = item;
item->right = root->right; item->left = root->left;
oxTrace("ox::fs::FileStoreTemplate::placeItem") << "Overwrote Root Item:" << item->id; item->right = root->right;
return OxError(0); oxTracef("ox::fs::FileStoreTemplate::placeItem", "Overwrote Root Item: {}", item->id.get());
} else { return OxError(0);
return placeItem(root, item); } else {
} return placeItem(root, item);
}
} }
return OxError(1);
} }
template<typename size_t> template<typename size_t>
Error FileStoreTemplate<size_t>::placeItem(ItemPtr root, ItemPtr item, int depth) { Error FileStoreTemplate<size_t>::placeItem(ItemPtr root, ItemPtr item, int depth) {
if (depth < 5000) { if (depth > 5000) {
if (item->id > root->id) { oxTrace("ox::fs::FileStoreTemplate::placeItem::fail", "Excessive recursion depth, stopping before stack overflow.");
auto right = m_buffer->ptr(root->right); return OxError(2);
if (!right.valid() || right->id == item->id) { }
root->right = item.offset(); if (item->id > root->id) {
if (right.valid()) { auto right = m_buffer->ptr(root->right);
item->left = right->left; if (!right.valid() || right->id == item->id) {
item->right = right->right; root->right = item.offset();
} if (right.valid()) {
oxTrace("ox::fs::FileStoreTemplate::placeItem") << "Placed Item:" << item->id; item->left = right->left;
return OxError(0); item->right = right->right;
} else {
return placeItem(right, item, depth + 1);
}
} else if (item->id < root->id) {
auto left = m_buffer->ptr(root->left);
if (!left.valid() || left->id == item->id) {
root->left = item.offset();
if (left.valid()) {
item->left = left->left;
item->right = left->right;
}
oxTrace("ox::fs::FileStoreTemplate::placeItem") << "Placed Item:" << item->id;
return OxError(0);
} else {
return placeItem(left, item, depth + 1);
} }
oxTracef("ox::fs::FileStoreTemplate::placeItem", "Placed Item: {}", item->id.get());
return OxError(0);
} else { } else {
oxTrace("ox::fs::FileStoreTemplate::placeItem::fail") << "Cannot insert an item on itself."; return placeItem(right, item, depth + 1);
return OxError(1); }
} else if (item->id < root->id) {
auto left = m_buffer->ptr(root->left);
if (!left.valid() || left->id == item->id) {
root->left = item.offset();
if (left.valid()) {
item->left = left->left;
item->right = left->right;
}
oxTracef("ox::fs::FileStoreTemplate::placeItem", "Placed Item: {}", item->id.get());
return OxError(0);
} else {
return placeItem(left, item, depth + 1);
} }
} else { } else {
oxTrace("ox::fs::FileStoreTemplate::placeItem::fail") << "Excessive recursion depth, stopping before stack overflow."; oxTrace("ox::fs::FileStoreTemplate::placeItem::fail", "Cannot insert an item on itself.");
return OxError(2); return OxError(1, "Cannot insert an item on itself.");
} }
} }
template<typename size_t> template<typename size_t>
Error FileStoreTemplate<size_t>::unplaceItem(ItemPtr item) { Error FileStoreTemplate<size_t>::unplaceItem(ItemPtr item) {
auto fsData = fileStoreData(); auto fsData = fileStoreData();
if (fsData) { if (!fsData) {
auto root = m_buffer->ptr(fsData->rootNode); return OxError(1);
if (root.valid()) { }
if (root->id == item->id) { oxRequireM(root, m_buffer->ptr(fsData->rootNode).validate());
item->left = root->left; if (root->id == item->id) {
item->right = root->right; item->left = root->left;
auto left = m_buffer->ptr(item->left); item->right = root->right;
auto right = m_buffer->ptr(item->right); auto left = m_buffer->ptr(item->left);
if (right.valid()) { auto right = m_buffer->ptr(item->right);
auto oldRoot = fsData->rootNode; if (right.valid()) {
fsData->rootNode = item->right; auto oldRoot = fsData->rootNode;
if (left.valid()) { fsData->rootNode = item->right;
auto err = placeItem(left); if (left.valid()) {
// undo if unable to place the left side of the tree auto err = placeItem(left);
if (err) { // undo if unable to place the left side of the tree
fsData->rootNode = oldRoot; if (err) {
return err; fsData->rootNode = oldRoot;
} return err;
} }
} else if (left.valid()) { }
fsData->rootNode = item->left; } else if (left.valid()) {
} else { fsData->rootNode = item->left;
fsData->rootNode = 0; } else {
} fsData->rootNode = 0;
return OxError(0); }
} else { return OxError(0);
return unplaceItem(root, item); } else {
} return unplaceItem(root, item);
}
} }
return OxError(1);
} }
template<typename size_t> template<typename size_t>
Error FileStoreTemplate<size_t>::unplaceItem(ItemPtr root, ItemPtr item, int depth) { Error FileStoreTemplate<size_t>::unplaceItem(ItemPtr root, ItemPtr item, int depth) {
if (depth >= 5000) { if (depth >= 5000) {
oxTrace("ox::fs::FileStoreTemplate::unplaceItem::fail") << "Excessive recursion depth, stopping before stack overflow."; oxTrace("ox::fs::FileStoreTemplate::unplaceItem::fail", "Excessive recursion depth, stopping before stack overflow.");
return OxError(1); return OxError(1, "Excessive recursion depth, stopping before stack overflow.");
} }
if (item->id > root->id) { if (item->id > root->id) {
auto right = m_buffer->ptr(root->right); auto right = m_buffer->ptr(root->right);
if (right->id == item->id) { if (right->id == item->id) {
root->right = 0; root->right = 0;
oxTrace("ox::fs::FileStoreTemplate::unplaceItem") << "Unplaced Item:" << item->id; oxTracef("ox::fs::FileStoreTemplate::unplaceItem", "Unplaced Item: {}", item->id.get());
} else { } else {
return unplaceItem(right, item, depth + 1); return unplaceItem(right, item, depth + 1);
} }
@ -650,7 +617,7 @@ Error FileStoreTemplate<size_t>::unplaceItem(ItemPtr root, ItemPtr item, int dep
auto left = m_buffer->ptr(root->left); auto left = m_buffer->ptr(root->left);
if (left->id == item->id) { if (left->id == item->id) {
root->left = 0; root->left = 0;
oxTrace("ox::fs::FileStoreTemplate::unplaceItem") << "Unplaced Item:" << item->id; oxTracef("ox::fs::FileStoreTemplate::unplaceItem", "Unplaced Item: {}", item->id.get());
} else { } else {
return unplaceItem(left, item, depth + 1); return unplaceItem(left, item, depth + 1);
} }
@ -705,31 +672,30 @@ typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::findParen
template<typename size_t> template<typename size_t>
typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(ItemPtr item, InodeId_t id, int depth) const { typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(ItemPtr item, InodeId_t id, int depth) const {
if (depth > 5000) { if (depth > 5000) {
oxTrace("ox::fs::FileStoreTemplate::find::fail") << "Excessive recursion depth, stopping before stack overflow. Search for:" << id; oxTracef("ox::fs::FileStoreTemplate::find::fail", "Excessive recursion depth, stopping before stack overflow. Search for: {}", id);
return nullptr; return nullptr;
} }
if (!item.valid()) { if (!item.valid()) {
oxTrace("ox::fs::FileStoreTemplate::find::fail") << "item invalid"; oxTrace("ox::fs::FileStoreTemplate::find::fail", "item invalid");
return nullptr; return nullptr;
} }
// do search
if (id > item->id) { if (id > item->id) {
oxTrace("ox::fs::FileStoreTemplate::find") << "Not a match, searching on" << item->right; oxTracef("ox::fs::FileStoreTemplate::find", "Not a match, searching on {}", item->right.get());
return find(m_buffer->ptr(item->right), id, depth + 1); return find(m_buffer->ptr(item->right), id, depth + 1);
} else if (id < item->id) { } else if (id < item->id) {
oxTrace("ox::fs::FileStoreTemplate::find") << "Not a match, searching on" << item->left; oxTracef("ox::fs::FileStoreTemplate::find", "Not a match, searching on {}", item->left.get());
return find(m_buffer->ptr(item->left), id, depth + 1); return find(m_buffer->ptr(item->left), id, depth + 1);
} else if (id == item->id) { } else if (id == item->id) {
oxTrace("ox::fs::FileStoreTemplate::find") << "Found" << id << "at" << item; oxTracef("ox::fs::FileStoreTemplate::find", "Found {} at {}", id, item.offset());
return item; return item;
} }
return nullptr; return nullptr;
} }
template<typename size_t> template<typename size_t>
typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(InodeId_t id) const { typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(InodeId_t id) const {
oxTrace("ox::fs::FileStoreTemplate::find") << "Searching for inode:" << id; oxTracef("ox::fs::FileStoreTemplate::find", "Searching for inode: {}", id);
auto fsData = fileStoreData(); auto fsData = fileStoreData();
if (fsData) { if (fsData) {
auto root = m_buffer->ptr(fsData->rootNode); auto root = m_buffer->ptr(fsData->rootNode);
@ -737,10 +703,10 @@ typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(Inod
auto item = find(root, id); auto item = find(root, id);
return item; return item;
} else { } else {
oxTrace("ox::fs::FileStoreTemplate::find::fail") << "No root node"; oxTrace("ox::fs::FileStoreTemplate::find::fail", "No root node");
} }
} else { } else {
oxTrace("ox::fs::FileStoreTemplate::find::fail") << "No FileStore Data"; oxTrace("ox::fs::FileStoreTemplate::find::fail", "No FileStore Data");
} }
return nullptr; return nullptr;
} }

77
deps/ox/src/ox/fs/filesystem/directory.hpp vendored
View File

@ -55,7 +55,7 @@ struct OX_PACKED DirectoryEntry {
} }
ptrarith::Ptr<DirectoryEntryData, InodeId_t> data() { ptrarith::Ptr<DirectoryEntryData, InodeId_t> data() {
oxTrace("ox::fs::DirectoryEntry::data") << this->fullSize() << sizeof(*this) << this->size(); oxTracef("ox::fs::DirectoryEntry::data", "{} {} {}", this->fullSize(), sizeof(*this), this->size());
return ptrarith::Ptr<DirectoryEntryData, InodeId_t>(this, this->fullSize(), sizeof(*this), this->size(), this->size()); return ptrarith::Ptr<DirectoryEntryData, InodeId_t>(this, this->fullSize(), sizeof(*this), this->size(), this->size());
} }
@ -132,7 +132,7 @@ Directory<FileStore, InodeId_t>::Directory(FileStore fs, InodeId_t inodeId) {
template<typename FileStore, typename InodeId_t> template<typename FileStore, typename InodeId_t>
Error Directory<FileStore, InodeId_t>::init() noexcept { Error Directory<FileStore, InodeId_t>::init() noexcept {
constexpr auto Size = sizeof(Buffer); constexpr auto Size = sizeof(Buffer);
oxTrace("ox::fs::Directory::init") << "Initializing Directory with Inode ID:" << m_inodeId; oxTracef("ox::fs::Directory::init", "Initializing Directory with Inode ID: {}", m_inodeId);
oxReturnError(m_fs.write(m_inodeId, nullptr, Size, static_cast<uint8_t>(FileType::Directory))); oxReturnError(m_fs.write(m_inodeId, nullptr, Size, static_cast<uint8_t>(FileType::Directory)));
auto buff = m_fs.read(m_inodeId).template to<Buffer>(); auto buff = m_fs.read(m_inodeId).template to<Buffer>();
if (!buff.valid()) { if (!buff.valid()) {
@ -147,7 +147,7 @@ Error Directory<FileStore, InodeId_t>::init() noexcept {
template<typename FileStore, typename InodeId_t> template<typename FileStore, typename InodeId_t>
Error Directory<FileStore, InodeId_t>::mkdir(PathIterator path, bool parents, FileName *nameBuff) { Error Directory<FileStore, InodeId_t>::mkdir(PathIterator path, bool parents, FileName *nameBuff) {
if (path.valid()) { if (path.valid()) {
oxTrace("ox::fs::Directory::mkdir") << path.fullPath(); oxTrace("ox::fs::Directory::mkdir", path.fullPath());
// reuse nameBuff if it has already been allocated, as it is a rather large variable // reuse nameBuff if it has already been allocated, as it is a rather large variable
if (nameBuff == nullptr) { if (nameBuff == nullptr) {
nameBuff = new (ox_alloca(sizeof(FileName))) FileName; nameBuff = new (ox_alloca(sizeof(FileName))) FileName;
@ -164,7 +164,7 @@ Error Directory<FileStore, InodeId_t>::mkdir(PathIterator path, bool parents, Fi
return OxError(1); return OxError(1);
} }
childInode = m_fs.generateInodeId(); childInode = m_fs.generateInodeId();
oxTrace("ox::fs::Directory::mkdir") << "Generated Inode ID:" << childInode.value; oxTracef("ox::fs::Directory::mkdir", "Generated Inode ID: {}", childInode.value);
oxLogError(childInode.error); oxLogError(childInode.error);
oxReturnError(childInode.error); oxReturnError(childInode.error);
@ -199,38 +199,34 @@ Error Directory<FileStore, InodeId_t>::write(PathIterator path, InodeId_t inode,
if (path.next().hasNext()) { // not yet at target directory, recurse to next one if (path.next().hasNext()) { // not yet at target directory, recurse to next one
oxReturnError(path.get(name)); oxReturnError(path.get(name));
oxTracef("ox::fs::Directory::write", "Attempting to write to next sub-Directory: {} of {}",
oxTrace("ox::fs::Directory::write") << "Attempting to write to next sub-Directory: " name->c_str(), path.fullPath());
<< name->c_str() << " of " << path.fullPath();
oxRequire(nextChild, findEntry(*name)); oxRequire(nextChild, findEntry(*name));
oxTrace("ox::fs::Directory::write") << name->c_str() << ": " << nextChild; oxTracef("ox::fs::Directory::write", "{}: {}", name->c_str(), nextChild);
if (nextChild) { if (nextChild) {
// reuse name because it is a rather large variable and will not be used again // reuse name because it is a rather large variable and will not be used again
// be attentive that this remains true // be attentive that this remains true
name = nullptr; name = nullptr;
return Directory(m_fs, nextChild).write(path.next(), inode, nameBuff); return Directory(m_fs, nextChild).write(path.next(), inode, nameBuff);
} else { } else {
oxTrace("ox::fs::Directory::write") << name->c_str() oxTracef("ox::fs::Directory::write", "{} not found and not allowed to create it.", name->c_str());
<< "not found and not allowed to create it."; return OxError(1, "File not found and not allowed to create it.");
return OxError(1);
} }
} else { } else {
oxTrace("ox::fs::Directory::write") << path.fullPath(); oxTrace("ox::fs::Directory::write", path.fullPath());
// insert the new entry on this directory // insert the new entry on this directory
// get the name // get the name
oxReturnError(path.next(name)); oxReturnError(path.next(name));
// find existing version of directory // find existing version of directory
oxTrace("ox::fs::Directory::write") << "Searching for directory inode" << m_inodeId; oxTracef("ox::fs::Directory::write", "Searching for directory inode {}", m_inodeId);
oxRequire(oldStat, m_fs.stat(m_inodeId)); oxRequire(oldStat, m_fs.stat(m_inodeId));
oxTrace("ox::fs::Directory::write") << "Found existing directory of size" << oldStat.size; oxTracef("ox::fs::Directory::write", "Found existing directory of size {}", oldStat.size);
auto old = m_fs.read(m_inodeId).template to<Buffer>(); auto old = m_fs.read(m_inodeId).template to<Buffer>();
if (!old.valid()) { if (!old.valid()) {
oxTrace("ox::fs::Directory::write::fail") << "Could not read existing version of Directory"; oxTrace("ox::fs::Directory::write::fail", "Could not read existing version of Directory");
return OxError(1); return OxError(1, "Could not read existing version of Directory");
} }
const auto pathSize = name->len() + 1; const auto pathSize = name->len() + 1;
@ -238,20 +234,19 @@ Error Directory<FileStore, InodeId_t>::write(PathIterator path, InodeId_t inode,
const auto newSize = oldStat.size + Buffer::spaceNeeded(entryDataSize); const auto newSize = oldStat.size + Buffer::spaceNeeded(entryDataSize);
auto cpy = ox_malloca(newSize, Buffer, *old, oldStat.size); auto cpy = ox_malloca(newSize, Buffer, *old, oldStat.size);
if (cpy == nullptr) { if (cpy == nullptr) {
oxTrace("ox::fs::Directory::write::fail") << "Could not allocate memory for copy of Directory"; oxTrace("ox::fs::Directory::write::fail", "Could not allocate memory for copy of Directory");
return OxError(1); return OxError(1, "Could not allocate memory for copy of Directory");
} }
// TODO: look for old version of this entry and delete it // TODO: look for old version of this entry and delete it
oxReturnError(cpy->setSize(newSize)); oxReturnError(cpy->setSize(newSize));
auto val = cpy->malloc(entryDataSize); auto val = cpy->malloc(entryDataSize);
if (!val.valid()) { if (!val.valid()) {
oxTrace("ox::fs::Directory::write::fail") << "Could not allocate memory for new directory entry"; oxTrace("ox::fs::Directory::write::fail", "Could not allocate memory for new directory entry");
return OxError(1); return OxError(1, "Could not allocate memory for new directory entry");
} }
oxTrace("ox::fs::Directory::write") << "Attempting to write Directory entry:" << name->data(); oxTracef("ox::fs::Directory::write", "Attempting to write Directory entry: {}", name->data());
oxTrace("ox::fs::Directory::write") << "Attempting to write Directory to FileStore";
oxReturnError(val->init(inode, name->data(), val.size())); oxReturnError(val->init(inode, name->data(), val.size()));
return m_fs.write(m_inodeId, cpy, cpy->size(), static_cast<uint8_t>(FileType::Directory)); return m_fs.write(m_inodeId, cpy, cpy->size(), static_cast<uint8_t>(FileType::Directory));
} }
@ -266,10 +261,10 @@ Error Directory<FileStore, InodeId_t>::remove(PathIterator path, FileName *nameB
auto &name = *nameBuff; auto &name = *nameBuff;
oxReturnError(path.get(&name)); oxReturnError(path.get(&name));
oxTrace("ox::fs::Directory::remove") << name.c_str(); oxTrace("ox::fs::Directory::remove", name.c_str());
auto buff = m_fs.read(m_inodeId).template to<Buffer>(); auto buff = m_fs.read(m_inodeId).template to<Buffer>();
if (buff.valid()) { if (buff.valid()) {
oxTrace("ox::fs::Directory::remove") << "Found directory buffer."; oxTrace("ox::fs::Directory::remove", "Found directory buffer.");
for (auto i = buff->iterator(); i.valid(); i.next()) { for (auto i = buff->iterator(); i.valid(); i.next()) {
auto data = i->data(); auto data = i->data();
if (data.valid()) { if (data.valid()) {
@ -277,12 +272,12 @@ Error Directory<FileStore, InodeId_t>::remove(PathIterator path, FileName *nameB
oxReturnError(buff->free(i)); oxReturnError(buff->free(i));
} }
} else { } else {
oxTrace("ox::fs::Directory::remove") << "INVALID DIRECTORY ENTRY"; oxTrace("ox::fs::Directory::remove", "INVALID DIRECTORY ENTRY");
} }
} }
} else { } else {
oxTrace("ox::fs::Directory::remove::fail") << "Could not find directory buffer"; oxTrace("ox::fs::Directory::remove::fail", "Could not find directory buffer");
return OxError(1); return OxError(1, "Could not find directory buffer");
} }
return OxError(0); return OxError(0);
} }
@ -293,17 +288,17 @@ Error Directory<FileStore, InodeId_t>::ls(F cb) noexcept {
oxTrace("ox::fs::Directory::ls"); oxTrace("ox::fs::Directory::ls");
auto buff = m_fs.read(m_inodeId).template to<Buffer>(); auto buff = m_fs.read(m_inodeId).template to<Buffer>();
if (!buff.valid()) { if (!buff.valid()) {
oxTrace("ox::fs::Directory::ls::fail") << "Could not directory buffer"; oxTrace("ox::fs::Directory::ls::fail", "Could not directory buffer");
return OxError(1); return OxError(1, "Could not directory buffer");
} }
oxTrace("ox::fs::Directory::ls") << "Found directory buffer."; oxTrace("ox::fs::Directory::ls", "Found directory buffer.");
for (auto i = buff->iterator(); i.valid(); i.next()) { for (auto i = buff->iterator(); i.valid(); i.next()) {
auto data = i->data(); auto data = i->data();
if (data.valid()) { if (data.valid()) {
oxReturnError(cb(data->name, data->inode)); oxReturnError(cb(data->name, data->inode));
} else { } else {
oxTrace("ox::fs::Directory::ls") << "INVALID DIRECTORY ENTRY"; oxTrace("ox::fs::Directory::ls", "INVALID DIRECTORY ENTRY");
} }
} }
@ -312,27 +307,27 @@ Error Directory<FileStore, InodeId_t>::ls(F cb) noexcept {
template<typename FileStore, typename InodeId_t> template<typename FileStore, typename InodeId_t>
Result<typename FileStore::InodeId_t> Directory<FileStore, InodeId_t>::findEntry(const FileName &name) const noexcept { Result<typename FileStore::InodeId_t> Directory<FileStore, InodeId_t>::findEntry(const FileName &name) const noexcept {
oxTrace("ox::fs::Directory::findEntry") << name.c_str(); oxTrace("ox::fs::Directory::findEntry", name.c_str());
auto buff = m_fs.read(m_inodeId).template to<Buffer>(); auto buff = m_fs.read(m_inodeId).template to<Buffer>();
if (!buff.valid()) { if (!buff.valid()) {
oxTrace("ox::fs::Directory::findEntry::fail") << "Could not findEntry directory buffer"; oxTrace("ox::fs::Directory::findEntry::fail", "Could not findEntry directory buffer");
return OxError(2); return OxError(2, "Could not findEntry directory buffer");
} }
oxTrace("ox::fs::Directory::findEntry") << "Found directory buffer, size:" << buff.size(); oxTracef("ox::fs::Directory::findEntry", "Found directory buffer, size: {}", buff.size());
for (auto i = buff->iterator(); i.valid(); i.next()) { for (auto i = buff->iterator(); i.valid(); i.next()) {
auto data = i->data(); auto data = i->data();
if (data.valid()) { if (data.valid()) {
oxTrace("ox::fs::Directory::findEntry").del("") << "Comparing \"" << name.c_str() << "\" to \"" << data->name << "\""; oxTracef("ox::fs::Directory::findEntry", "Comparing \"{}\" to \"{}\"", name.c_str(), data->name);
if (ox_strncmp(data->name, name.c_str(), MaxFileNameLength) == 0) { if (ox_strncmp(data->name, name.c_str(), MaxFileNameLength) == 0) {
oxTrace("ox::fs::Directory::findEntry").del("") << "\"" << name.c_str() << "\" match found."; oxTracef("ox::fs::Directory::findEntry", "\"{}\" match found.", name.c_str());
return static_cast<InodeId_t>(data->inode); return static_cast<InodeId_t>(data->inode);
} }
} else { } else {
oxTrace("ox::fs::Directory::findEntry") << "INVALID DIRECTORY ENTRY"; oxTrace("ox::fs::Directory::findEntry") << "INVALID DIRECTORY ENTRY";
} }
} }
oxTrace("ox::fs::Directory::findEntry::fail") << "Entry not present"; oxTrace("ox::fs::Directory::findEntry::fail", "Entry not present");
return OxError(1); return OxError(1, "Entry not present");
} }
template<typename FileStore, typename InodeId_t> template<typename FileStore, typename InodeId_t>

4
deps/ox/src/ox/fs/filesystem/filelocation.cpp vendored
View File

@ -49,7 +49,7 @@ FileAddress::~FileAddress() noexcept {
cleanup(); cleanup();
} }
const FileAddress &FileAddress::operator=(const FileAddress &other) noexcept { FileAddress &FileAddress::operator=(const FileAddress &other) noexcept {
cleanup(); cleanup();
m_type = other.m_type; m_type = other.m_type;
switch (m_type) { switch (m_type) {
@ -70,7 +70,7 @@ const FileAddress &FileAddress::operator=(const FileAddress &other) noexcept {
return *this; return *this;
} }
const FileAddress &FileAddress::operator=(FileAddress &&other) noexcept { FileAddress &FileAddress::operator=(FileAddress &&other) noexcept {
cleanup(); cleanup();
m_type = other.m_type; m_type = other.m_type;
memcpy(this, &other, sizeof(*this)); memcpy(this, &other, sizeof(*this));

4
deps/ox/src/ox/fs/filesystem/filelocation.hpp vendored
View File

@ -58,9 +58,9 @@ class FileAddress {
~FileAddress() noexcept; ~FileAddress() noexcept;
const FileAddress &operator=(const FileAddress &other) noexcept; FileAddress &operator=(const FileAddress &other) noexcept;
const FileAddress &operator=(FileAddress &&other) noexcept; FileAddress &operator=(FileAddress &&other) noexcept;
[[nodiscard]] [[nodiscard]]
constexpr FileAddressType type() const noexcept { constexpr FileAddressType type() const noexcept {

8
deps/ox/src/ox/fs/filesystem/filesystem.hpp vendored
View File

@ -209,11 +209,11 @@ Error FileSystemTemplate<FileStore, Directory>::format(void *buff, uint64_t buff
FileSystemData fd; FileSystemData fd;
fd.rootDirInode = rootDirInode; fd.rootDirInode = rootDirInode;
oxTrace("ox::fs::FileSystemTemplate::format") << "rootDirInode:" << fd.rootDirInode; oxTracef("ox::fs::FileSystemTemplate::format", "rootDirInode: {}", fd.rootDirInode.get());
oxReturnError(fs.write(InodeFsData, &fd, sizeof(fd))); oxReturnError(fs.write(InodeFsData, &fd, sizeof(fd)));
if (!fs.read(fd.rootDirInode).valid()) { if (!fs.read(fd.rootDirInode).valid()) {
oxTrace("ox::fs::FileSystemTemplate::format::error") << "FileSystemTemplate::format did not correctly create root directory"; oxTrace("ox::fs::FileSystemTemplate::format::error", "FileSystemTemplate::format did not correctly create root directory");
return OxError(1); return OxError(1);
} }
@ -285,7 +285,7 @@ Result<Vector<String>> FileSystemTemplate<FileStore, Directory>::ls(const char *
template<typename FileStore, typename Directory> template<typename FileStore, typename Directory>
template<typename F> template<typename F>
Error FileSystemTemplate<FileStore, Directory>::ls(const char *path, F cb) { Error FileSystemTemplate<FileStore, Directory>::ls(const char *path, F cb) {
oxTrace("ox::fs::FileSystemTemplate::ls") << "path:" << path; oxTracef("ox::fs::FileSystemTemplate::ls", "path: {}", path);
oxRequire(s, stat(path)); oxRequire(s, stat(path));
Directory dir(m_fs, s.inode); Directory dir(m_fs, s.inode);
return dir.ls(cb); return dir.ls(cb);
@ -304,7 +304,7 @@ Error FileSystemTemplate<FileStore, Directory>::remove(const char *path, bool re
return err; return err;
} }
} else { } else {
oxTrace("FileSystemTemplate::remove::fail") << "Tried to remove directory without recursive setting."; oxTrace("FileSystemTemplate::remove::fail", "Tried to remove directory without recursive setting.");
return OxError(1); return OxError(1);
} }
return OxError(0); return OxError(0);

10
deps/ox/src/ox/fs/filesystem/passthroughfs.cpp vendored
View File

@ -31,7 +31,7 @@ Error PassThroughFS::mkdir(const char *path, bool recursive) noexcept {
bool success = false; bool success = false;
const auto p = m_path / stripSlash(path); const auto p = m_path / stripSlash(path);
const auto u8p = p.u8string(); const auto u8p = p.u8string();
oxTrace("ox::fs::PassThroughFS::mkdir") << u8p.c_str(); oxTrace("ox::fs::PassThroughFS::mkdir", u8p.c_str());
if (recursive) { if (recursive) {
std::error_code ec; std::error_code ec;
const auto isDir = std::filesystem::is_directory(p, ec); const auto isDir = std::filesystem::is_directory(p, ec);
@ -65,7 +65,7 @@ Error PassThroughFS::read(const char *path, void *buffer, std::size_t buffSize)
const std::size_t size = file.tellg(); const std::size_t size = file.tellg();
file.seekg(0, std::ios::beg); file.seekg(0, std::ios::beg);
if (size > buffSize) { if (size > buffSize) {
oxTrace("ox::fs::PassThroughFS::read::error") << "Read failed: Buffer too small:" << path; oxTracef("ox::fs::PassThroughFS::read::error", "Read failed: Buffer too small: {}", path);
return OxError(1); return OxError(1);
} }
file.read(static_cast<char*>(buffer), buffSize); file.read(static_cast<char*>(buffer), buffSize);
@ -146,10 +146,10 @@ Result<FileStat> PassThroughFS::stat(const char *path) noexcept {
const auto p = m_path / stripSlash(path); const auto p = m_path / stripSlash(path);
const FileType type = std::filesystem::is_directory(p, ec) ? const FileType type = std::filesystem::is_directory(p, ec) ?
FileType::Directory : FileType::NormalFile; FileType::Directory : FileType::NormalFile;
oxTrace("ox::fs::PassThroughFS::stat") << ec.message().c_str() << path; oxTracef("ox::fs::PassThroughFS::stat", "{} {}", ec.message().c_str(), path);
const uint64_t size = type == FileType::Directory ? 0 : std::filesystem::file_size(p, ec); const uint64_t size = type == FileType::Directory ? 0 : std::filesystem::file_size(p, ec);
oxTrace("ox::fs::PassThroughFS::stat") << ec.message().c_str() << path; oxTracef("ox::fs::PassThroughFS::stat", "{} {}", ec.message().c_str(), path);
oxTrace("ox::fs::PassThroughFS::stat::size") << path << size; oxTracef("ox::fs::PassThroughFS::stat::size", "{} {}", path, size);
oxReturnError(OxError(ec.value())); oxReturnError(OxError(ec.value()));
return FileStat{0, 0, size, type}; return FileStat{0, 0, size, type};
} }

4
deps/ox/src/ox/fs/filesystem/pathiterator.cpp vendored
View File

@ -61,11 +61,11 @@ Error PathIterator::fileName(char *out, std::size_t outSize) {
Error PathIterator::get(char *pathOut, std::size_t pathOutSize) { Error PathIterator::get(char *pathOut, std::size_t pathOutSize) {
std::size_t size = 0; std::size_t size = 0;
if (m_iterator >= m_maxSize) { if (m_iterator >= m_maxSize) {
oxTrace("ox::fs::PathIterator::get") << "m_iterator >= m_maxSize"; oxTracef("ox::fs::PathIterator::get", "m_iterator ({}) >= m_maxSize ({})", m_iterator, m_maxSize);
return OxError(1); return OxError(1);
} }
if (!ox_strlen(&m_path[m_iterator])) { if (!ox_strlen(&m_path[m_iterator])) {
oxTrace("ox::fs::PathIterator::get") << "!ox_strlen(&m_path[m_iterator])"; oxTrace("ox::fs::PathIterator::get", "!ox_strlen(&m_path[m_iterator])");
return OxError(1); return OxError(1);
} }
auto start = m_iterator; auto start = m_iterator;

6
deps/ox/src/ox/fs/filesystem/pathiterator.hpp vendored
View File

@ -61,12 +61,16 @@ class PathIterator {
*/ */
Result<std::size_t> nextSize() const; Result<std::size_t> nextSize() const;
[[nodiscard]]
bool hasNext() const; bool hasNext() const;
[[nodiscard]]
bool valid() const; bool valid() const;
[[nodiscard]] PathIterator next() const; [[nodiscard]]
PathIterator next() const;
[[nodiscard]]
const char *fullPath() const; const char *fullPath() const;
}; };

26
deps/ox/src/ox/fs/ptrarith/nodebuffer.hpp vendored
View File

@ -180,7 +180,7 @@ NodeBuffer<size_t, Item>::NodeBuffer(size_t size) noexcept {
template<typename size_t, typename Item> template<typename size_t, typename Item>
NodeBuffer<size_t, Item>::NodeBuffer(const NodeBuffer &other, size_t size) noexcept { NodeBuffer<size_t, Item>::NodeBuffer(const NodeBuffer &other, size_t size) noexcept {
oxTrace("ox::ptrarith::NodeBuffer::copy") << "other.m_header.firstItem:" << other.m_header.firstItem; oxTracef("ox::ptrarith::NodeBuffer::copy", "other.m_header.firstItem: {}", other.m_header.firstItem.get());
auto data = reinterpret_cast<uint8_t*>(this) + sizeof(*this); auto data = reinterpret_cast<uint8_t*>(this) + sizeof(*this);
ox_memset(data, 0, size - sizeof(*this)); ox_memset(data, 0, size - sizeof(*this));
ox_memcpy(this, &other, size); ox_memcpy(this, &other, size);
@ -268,7 +268,7 @@ typename NodeBuffer<size_t, Item>::ItemPtr NodeBuffer<size_t, Item>::ptr(size_t
template<typename size_t, typename Item> template<typename size_t, typename Item>
typename NodeBuffer<size_t, Item>::ItemPtr NodeBuffer<size_t, Item>::malloc(size_t size) noexcept { typename NodeBuffer<size_t, Item>::ItemPtr NodeBuffer<size_t, Item>::malloc(size_t size) noexcept {
oxTrace("ox::ptrarith::NodeBuffer::malloc") << "Size:" << size; oxTracef("ox::ptrarith::NodeBuffer::malloc", "Size: {}", size);
size_t fullSize = size + sizeof(Item); size_t fullSize = size + sizeof(Item);
if (m_header.size - m_header.bytesUsed >= fullSize) { if (m_header.size - m_header.bytesUsed >= fullSize) {
auto last = lastItem(); auto last = lastItem();
@ -278,18 +278,18 @@ typename NodeBuffer<size_t, Item>::ItemPtr NodeBuffer<size_t, Item>::malloc(size
} else { } else {
// there is no first item, so this must be the first item // there is no first item, so this must be the first item
if (!m_header.firstItem) { if (!m_header.firstItem) {
oxTrace("ox::ptrarith::NodeBuffer::malloc") << "No first item, initializing."; oxTrace("ox::ptrarith::NodeBuffer::malloc", "No first item, initializing.");
m_header.firstItem = sizeof(m_header); m_header.firstItem = sizeof(m_header);
addr = m_header.firstItem; addr = m_header.firstItem;
} else { } else {
oxTrace("ox::ptrarith::NodeBuffer::malloc::fail") << "NodeBuffer is in invalid state."; oxTrace("ox::ptrarith::NodeBuffer::malloc::fail", "NodeBuffer is in invalid state.");
return nullptr; return nullptr;
} }
} }
oxTracef("ox::ptrarith::NodeBuffer::malloc", "buffer size: {}; addr: {}; fullSize: {}", m_header.size.get(), addr, fullSize); oxTracef("ox::ptrarith::NodeBuffer::malloc", "buffer size: {}; addr: {}; fullSize: {}", m_header.size.get(), addr, fullSize);
auto out = ItemPtr(this, m_header.size, addr, fullSize); auto out = ItemPtr(this, m_header.size, addr, fullSize);
if (!out.valid()) { if (!out.valid()) {
oxTrace("ox::ptrarith::NodeBuffer::malloc::fail") << "Unknown"; oxTrace("ox::ptrarith::NodeBuffer::malloc::fail", "Unknown");
return nullptr; return nullptr;
} }
ox_memset(out, 0, fullSize); ox_memset(out, 0, fullSize);
@ -302,7 +302,7 @@ typename NodeBuffer<size_t, Item>::ItemPtr NodeBuffer<size_t, Item>::malloc(size
if (first.valid()) { if (first.valid()) {
first->prev = out.offset(); first->prev = out.offset();
} else { } else {
oxTrace("ox::ptrarith::NodeBuffer::malloc::fail") << "NodeBuffer malloc failed due to invalid first element pointer."; oxTrace("ox::ptrarith::NodeBuffer::malloc::fail", "NodeBuffer malloc failed due to invalid first element pointer.");
return nullptr; return nullptr;
} }
@ -312,22 +312,22 @@ typename NodeBuffer<size_t, Item>::ItemPtr NodeBuffer<size_t, Item>::malloc(size
} else { // check to see if this is the first allocation } else { // check to see if this is the first allocation
if (out.offset() != first.offset()) { if (out.offset() != first.offset()) {
// if this is not the first allocation, there should be an oldLast // if this is not the first allocation, there should be an oldLast
oxTrace("ox::ptrarith::NodeBuffer::malloc::fail") << "NodeBuffer malloc failed due to invalid last element pointer."; oxTrace("ox::ptrarith::NodeBuffer::malloc::fail", "NodeBuffer malloc failed due to invalid last element pointer.");
return nullptr; return nullptr;
} }
out->prev = out.offset(); out->prev = out.offset();
} }
m_header.bytesUsed += out.size(); m_header.bytesUsed += out.size();
oxTrace("ox::ptrarith::NodeBuffer::malloc") << "Offset:" << out.offset(); oxTracef("ox::ptrarith::NodeBuffer::malloc", "Offset: {}", out.offset());
return out; return out;
} }
oxTrace("ox::ptrarith::NodeBuffer::malloc::fail") << "Insufficient space:" << fullSize << "needed," << available() << "available"; oxTracef("ox::ptrarith::NodeBuffer::malloc::fail", "Insufficient space: {} needed, {} available", fullSize, available());
return nullptr; return nullptr;
} }
template<typename size_t, typename Item> template<typename size_t, typename Item>
Error NodeBuffer<size_t, Item>::free(ItemPtr item) noexcept { Error NodeBuffer<size_t, Item>::free(ItemPtr item) noexcept {
oxTrace("ox::ptrarith::NodeBuffer::free") << "offset:" << item.offset(); oxTracef("ox::ptrarith::NodeBuffer::free", "offset: {}", item.offset());
auto prev = this->prev(item); auto prev = this->prev(item);
auto next = this->next(item); auto next = this->next(item);
if (prev.valid() && next.valid()) { if (prev.valid() && next.valid()) {
@ -339,16 +339,16 @@ Error NodeBuffer<size_t, Item>::free(ItemPtr item) noexcept {
} }
} else { } else {
// only one item, null out first // only one item, null out first
oxTrace("ox::ptrarith::NodeBuffer::free") << "Nulling out firstItem."; oxTrace("ox::ptrarith::NodeBuffer::free", "Nulling out firstItem.");
m_header.firstItem = 0; m_header.firstItem = 0;
} }
} else { } else {
if (!prev.valid()) { if (!prev.valid()) {
oxTrace("ox::ptrarith::NodeBuffer::free::fail") << "NodeBuffer free failed due to invalid prev element pointer:" << prev.offset(); oxTracef("ox::ptrarith::NodeBuffer::free::fail", "NodeBuffer free failed due to invalid prev element pointer: {}", prev.offset());
return OxError(1); return OxError(1);
} }
if (!next.valid()) { if (!next.valid()) {
oxTrace("ox::ptrarith::NodeBuffer::free::fail") << "NodeBuffer free failed due to invalid next element pointer:" << next.offset(); oxTracef("ox::ptrarith::NodeBuffer::free::fail", "NodeBuffer free failed due to invalid next element pointer: {}", next.offset());
return OxError(1); return OxError(1);
} }
} }

20
deps/ox/src/ox/fs/ptrarith/ptr.hpp vendored
View File

@ -29,7 +29,7 @@ class [[nodiscard]] Ptr {
constexpr Ptr(std::nullptr_t) noexcept; constexpr Ptr(std::nullptr_t) noexcept;
constexpr Ptr(void *dataStart, size_t dataSize, size_t itemStart, size_t itemSize = sizeof(T), size_t itemTypeSize = sizeof(T)) noexcept; constexpr Ptr(void *dataStart, size_t dataSize, size_t itemStart, size_t itemSize = sizeof(T), size_t itemTypeSize = sizeof(T), bool prevalidated = false) noexcept;
[[nodiscard]] [[nodiscard]]
constexpr bool valid() const noexcept; constexpr bool valid() const noexcept;
@ -77,6 +77,8 @@ class [[nodiscard]] Ptr {
template<typename SubT> template<typename SubT>
constexpr const Ptr<SubT, size_t, minOffset> to() const noexcept; constexpr const Ptr<SubT, size_t, minOffset> to() const noexcept;
constexpr Result<Ptr<T, size_t, minOffset>> validate() const noexcept;
}; };
template<typename T, typename size_t, size_t minOffset> template<typename T, typename size_t, size_t minOffset>
@ -84,7 +86,7 @@ constexpr Ptr<T, size_t, minOffset>::Ptr(std::nullptr_t) noexcept {
} }
template<typename T, typename size_t, size_t minOffset> template<typename T, typename size_t, size_t minOffset>
constexpr Ptr<T, size_t, minOffset>::Ptr(void *dataStart, size_t dataSize, size_t itemStart, size_t itemSize, size_t itemTypeSize) noexcept { constexpr Ptr<T, size_t, minOffset>::Ptr(void *dataStart, size_t dataSize, size_t itemStart, size_t itemSize, size_t itemTypeSize, bool prevalidated) noexcept {
// do some sanity checks before assuming this is valid // do some sanity checks before assuming this is valid
if (itemSize >= itemTypeSize && if (itemSize >= itemTypeSize &&
dataStart && dataStart &&
@ -94,6 +96,7 @@ constexpr Ptr<T, size_t, minOffset>::Ptr(void *dataStart, size_t dataSize, size_
m_dataSize = dataSize; m_dataSize = dataSize;
m_itemOffset = itemStart; m_itemOffset = itemStart;
m_itemSize = itemSize; m_itemSize = itemSize;
m_validated = prevalidated;
} }
} }
@ -205,7 +208,7 @@ constexpr const Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(s
template<typename T, typename size_t, size_t minOffset> template<typename T, typename size_t, size_t minOffset>
template<typename SubT> template<typename SubT>
constexpr const Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(size_t offset) const noexcept { constexpr const Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(size_t offset) const noexcept {
oxTrace("ox::fs::Ptr::subPtr") << m_itemOffset << this->size() << offset << m_itemSize << (m_itemSize - offset); oxTracef("ox::fs::Ptr::subPtr", "{} {} {} {} {}", m_itemOffset, this->size(), offset, m_itemSize, (m_itemSize - offset));
return subPtr<SubT>(offset, m_itemSize - offset); return subPtr<SubT>(offset, m_itemSize - offset);
} }
@ -218,7 +221,8 @@ constexpr Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(size_t
template<typename T, typename size_t, size_t minOffset> template<typename T, typename size_t, size_t minOffset>
template<typename SubT> template<typename SubT>
constexpr Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(size_t offset) noexcept { constexpr Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(size_t offset) noexcept {
oxTrace("ox::fs::Ptr::subPtr") << m_itemOffset << this->size() << offset << m_itemSize << (m_itemSize - offset); oxTracef("ox::fs::Ptr::subPtr", "{} {} {} {} {}", m_itemOffset, this->size(), offset, m_itemSize, (m_itemSize - offset));
return subPtr<SubT>(offset, m_itemSize - offset);
return subPtr<SubT>(offset, m_itemSize - offset); return subPtr<SubT>(offset, m_itemSize - offset);
} }
@ -228,4 +232,12 @@ constexpr const Ptr<SubT, size_t, minOffset> Ptr<T, size_t, minOffset>::to() con
return Ptr<SubT, size_t, minOffset>(m_dataStart, m_dataSize, m_itemOffset, m_itemSize); return Ptr<SubT, size_t, minOffset>(m_dataStart, m_dataSize, m_itemOffset, m_itemSize);
} }
template<typename T, typename size_t, size_t minOffset>
constexpr Result<Ptr<T, size_t, minOffset>> Ptr<T, size_t, minOffset>::validate() const noexcept {
if (valid()) {
return *this;
}
return OxError(1);
}
} }

5
deps/ox/src/ox/fs/test/tests.cpp vendored
View File

@ -20,6 +20,7 @@
template<typename T> template<typename T>
struct OX_PACKED NodeType: public ox::ptrarith::Item<T> { struct OX_PACKED NodeType: public ox::ptrarith::Item<T> {
public: public:
[[nodiscard]]
size_t fullSize() const { size_t fullSize() const {
return this->size() + sizeof(*this); return this->size() + sizeof(*this);
} }
@ -239,12 +240,12 @@ int main(int argc, const char **args) {
int retval = -1; int retval = -1;
if (argc > 1) { if (argc > 1) {
std::string_view testName = args[1]; std::string_view testName = args[1];
std::string_view testArg = ""; std::string_view testArg;
if (args[2]) { if (args[2]) {
testArg = args[2]; testArg = args[2];
} }
if (tests.find(testName) != tests.end()) { if (tests.find(testName) != tests.end()) {
retval = tests.at(testName)(testArg); retval = static_cast<int>(tests.at(testName)(testArg));
} }
} }
return retval; return retval;