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

[ox/fs] Make format method static

Browse Source
This commit is contained in:
Gary Talent 2018-12-29 22:29:03 -06:00
parent 713aa7380f
commit 55119253da
14 changed files with 172 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
deps/ox/src/ox/fs/filestore/filestoretemplate.cpp vendored
View File

@ -8,7 +8,7 @@
#include "filestoretemplate.hpp"
namespace ox::fs {
namespace ox {
template class FileStoreTemplate<uint16_t>;
template class FileStoreTemplate<uint32_t>;

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

@ -10,7 +10,7 @@
#include <ox/ptrarith/nodebuffer.hpp>
namespace ox::fs {
namespace ox {
using InodeId_t = uint64_t;
using FsSize_t = std::size_t;
@ -70,12 +70,14 @@ class FileStoreTemplate {
};
size_t m_buffSize = 0;
Buffer *m_buffer = nullptr;
mutable Buffer *m_buffer = nullptr;
public:
FileStoreTemplate() = default;
FileStoreTemplate(void *buff, size_t buffSize);
Error format();
static Error format(void *buffer, size_t bufferSize);
Error setSize(InodeId_t buffSize);
@ -87,11 +89,11 @@ class FileStoreTemplate {
Error remove(InodeId_t id);
Error read(InodeId_t id, void *data, FsSize_t dataSize, FsSize_t *size = nullptr);
Error read(InodeId_t id, void *data, FsSize_t dataSize, FsSize_t *size = nullptr) const;
Error read(InodeId_t id, FsSize_t readStart, FsSize_t readSize, void *data, FsSize_t *size = nullptr);
Error read(InodeId_t id, FsSize_t readStart, FsSize_t readSize, void *data, FsSize_t *size = nullptr) const;
const ptrarith::Ptr<uint8_t, std::size_t> read(InodeId_t id);
const ptrarith::Ptr<uint8_t, std::size_t> read(InodeId_t id) const;
/**
* Reads the "file" at the given id. You are responsible for freeing
@ -106,7 +108,7 @@ class FileStoreTemplate {
template<typename T>
Error read(InodeId_t id, FsSize_t readStart,
FsSize_t readSize, T *data,
FsSize_t *size);
FsSize_t *size) const;
ValErr<StatInfo> stat(InodeId_t id);
@ -114,7 +116,7 @@ class FileStoreTemplate {
InodeId_t spaceNeeded(FsSize_t size);
InodeId_t size();
InodeId_t size() const;
InodeId_t available();
@ -126,10 +128,10 @@ class FileStoreTemplate {
bool valid() const;
private:
void compact();
FileStoreData *fileStoreData();
private:
FileStoreData *fileStoreData() const;
/**
* Places the given Item at the given ID. If it already exists, the
@ -160,17 +162,17 @@ class FileStoreTemplate {
/**
* Finds the parent an inode by its ID.
*/
ItemPtr findParent(ItemPtr ptr, size_t id);
ItemPtr findParent(ItemPtr ptr, size_t id) const;
/**
* Finds an inode by its ID.
*/
ItemPtr find(ItemPtr item, InodeId_t id, int depth = 0);
ItemPtr find(ItemPtr item, InodeId_t id, int depth = 0) const;
/**
* Finds an inode by its ID.
*/
ItemPtr find(InodeId_t id);
ItemPtr find(InodeId_t id) const;
/**
* Gets the root inode.
@ -192,11 +194,11 @@ FileStoreTemplate<size_t>::FileStoreTemplate(void *buff, size_t buffSize) {
}
template<typename size_t>
Error FileStoreTemplate<size_t>::format() {
new (m_buffer) Buffer(m_buffSize);
auto fsData = m_buffer->malloc(sizeof(FileStoreData));
Error FileStoreTemplate<size_t>::format(void *buffer, size_t bufferSize) {
auto nb = new (buffer) Buffer(bufferSize);
auto fsData = nb->malloc(sizeof(FileStoreData));
if (fsData.valid()) {
auto data = m_buffer->template dataOf<FileStoreData>(fsData);
auto data = nb->template dataOf<FileStoreData>(fsData);
if (data.valid()) {
new (data) FileStoreData;
return OxError(0);
@ -301,7 +303,7 @@ Error FileStoreTemplate<size_t>::remove(InodeId_t id) {
}
template<typename size_t>
Error FileStoreTemplate<size_t>::read(InodeId_t id, void *data, FsSize_t dataSize, FsSize_t *size) {
Error FileStoreTemplate<size_t>::read(InodeId_t id, void *data, FsSize_t dataSize, FsSize_t *size) const {
oxTrace("ox::fs::FileStoreTemplate::read") << "Attempting to read from inode" << id;
auto src = find(id);
if (src.valid()) {
@ -327,7 +329,7 @@ Error FileStoreTemplate<size_t>::read(InodeId_t id, void *data, FsSize_t dataSiz
}
template<typename size_t>
Error FileStoreTemplate<size_t>::read(InodeId_t id, FsSize_t readStart, FsSize_t readSize, void *data, FsSize_t *size) {
Error FileStoreTemplate<size_t>::read(InodeId_t id, FsSize_t readStart, FsSize_t readSize, void *data, FsSize_t *size) const {
auto src = find(id);
if (src.valid()) {
auto srcData = src->data();
@ -354,19 +356,19 @@ Error FileStoreTemplate<size_t>::read(InodeId_t id, FsSize_t readStart, FsSize_t
template<typename size_t>
template<typename T>
Error FileStoreTemplate<size_t>::read(InodeId_t id, FsSize_t readStart,
FsSize_t readSize, T *data, FsSize_t *size) {
FsSize_t readSize, T *data, FsSize_t *size) const {
auto src = find(id);
if (src.valid()) {
auto srcData = src->data();
if (srcData.valid()) {
auto sub = srcData.subPtr(readStart, readSize);
auto sub = srcData.template subPtr<T>(readStart, readSize);
if (sub.valid() && sub.size() % sizeof(T)) {
for (FsSize_t i = 0; i < sub.size() / sizeof(T); i++) {
// do byte-by-byte copy to ensure alignment is right when
// copying to final destination
T tmp;
for (size_t i = 0; i < sizeof(T); i++) {
*(reinterpret_cast<uint8_t*>(&tmp)[i]) = *(reinterpret_cast<uint8_t*>(sub.get()) + i);
reinterpret_cast<uint8_t*>(&tmp)[i] = *(reinterpret_cast<const uint8_t*>(sub.get()) + i);
}
*(data + i) = tmp;
}
@ -381,7 +383,7 @@ Error FileStoreTemplate<size_t>::read(InodeId_t id, FsSize_t readStart,
}
template<typename size_t>
const ptrarith::Ptr<uint8_t, std::size_t> FileStoreTemplate<size_t>::read(InodeId_t id) {
const ptrarith::Ptr<uint8_t, std::size_t> FileStoreTemplate<size_t>::read(InodeId_t id) const {
auto item = find(id);
if (item.valid()) {
return item->data();
@ -419,7 +421,7 @@ typename FileStoreTemplate<size_t>::InodeId_t FileStoreTemplate<size_t>::spaceNe
}
template<typename size_t>
typename FileStoreTemplate<size_t>::InodeId_t FileStoreTemplate<size_t>::size() {
typename FileStoreTemplate<size_t>::InodeId_t FileStoreTemplate<size_t>::size() const {
return m_buffer->size();
}
@ -458,10 +460,22 @@ ValErr<typename FileStoreTemplate<size_t>::InodeId_t> FileStoreTemplate<size_t>:
template<typename size_t>
void FileStoreTemplate<size_t>::compact() {
m_buffer->compact([this](uint64_t oldAddr, ItemPtr item) {
if (item.valid()) {
auto parent = findParent(rootInode(), item);
if (parent.valid()) {
if (parent->left == oldAddr) {
parent->left = item;
} else if (parent->right == oldAddr) {
parent->right = item;
}
}
}
});
}
template<typename size_t>
typename FileStoreTemplate<size_t>::FileStoreData *FileStoreTemplate<size_t>::fileStoreData() {
typename FileStoreTemplate<size_t>::FileStoreData *FileStoreTemplate<size_t>::fileStoreData() const {
auto first = m_buffer->firstItem();
if (first.valid()) {
auto data = first->data();
@ -607,23 +621,25 @@ Error FileStoreTemplate<size_t>::remove(ItemPtr item) {
}
template<typename size_t>
typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::findParent(ItemPtr item, size_t id) {
if (id > item->id) {
auto right = m_buffer->ptr(item->right);
if (right.valid()) {
if (right->id == id) {
return item;
} else {
return findParent(right, id);
typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::findParent(ItemPtr item, size_t id) const {
if (item.valid()) {
if (id > item->id) {
auto right = m_buffer->ptr(item->right);
if (right.valid()) {
if (right->id == id) {
return item;
} else {
return findParent(right, id);
}
}
}
} else if (id < item->id) {
auto left = m_buffer->ptr(item->left);
if (left.valid()) {
if (left->id == id) {
return item;
} else {
return findParent(left, id);
} else if (id < item->id) {
auto left = m_buffer->ptr(item->left);
if (left.valid()) {
if (left->id == id) {
return item;
} else {
return findParent(left, id);
}
}
}
}
@ -631,7 +647,7 @@ typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::findParen
}
template<typename size_t>
typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(ItemPtr item, InodeId_t id, int depth) {
typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(ItemPtr item, InodeId_t id, int depth) const {
if (depth < 5000) {
if (item.valid()) {
if (id > item->id) {
@ -654,7 +670,7 @@ typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(Item
}
template<typename size_t>
typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(InodeId_t id) {
typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(InodeId_t id) const {
auto fsData = fileStoreData();
if (fsData) {
auto root = m_buffer->ptr(fsData->rootNode);

2
deps/ox/src/ox/fs/filesystem/directory.cpp vendored
View File

@ -8,7 +8,7 @@
#include "directory.hpp"
namespace ox::fs {
namespace ox {
template class Directory<FileStore16, uint16_t>;
template class Directory<FileStore32, uint32_t>;

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

@ -13,7 +13,7 @@
#include <ox/ptrarith/nodebuffer.hpp>
#include <ox/std/std.hpp>
namespace ox::fs {
namespace ox {
template<typename InodeId_t>
struct __attribute__((packed)) DirectoryEntry {
@ -91,12 +91,12 @@ class Directory {
InodeId_t m_inodeId = 0;
std::size_t m_size = 0;
FileStore *m_fs = nullptr;
FileStore m_fs;
public:
Directory() = default;
Directory(FileStore *fs, InodeId_t inode);
Directory(FileStore fs, InodeId_t inode);
/**
* Initializes Directory.
@ -112,6 +112,9 @@ class Directory {
Error remove(PathIterator it, FileName *nameBuff = nullptr) noexcept;
template<typename F>
Error ls(F cb) noexcept;
ValErr<typename FileStore::InodeId_t> findEntry(const FileName &name) const noexcept;
ValErr<typename FileStore::InodeId_t> find(PathIterator name, FileName *nameBuff = nullptr) const noexcept;
@ -119,10 +122,10 @@ class Directory {
};
template<typename FileStore, typename InodeId_t>
Directory<FileStore, InodeId_t>::Directory(FileStore *fs, InodeId_t inodeId) {
Directory<FileStore, InodeId_t>::Directory(FileStore fs, InodeId_t inodeId) {
m_fs = fs;
m_inodeId = inodeId;
auto buff = fs->read(inodeId).template to<Buffer>();
auto buff = m_fs.read(inodeId).template to<Buffer>();
if (buff.valid()) {
m_size = buff.size();
}
@ -131,8 +134,8 @@ Directory<FileStore, InodeId_t>::Directory(FileStore *fs, InodeId_t inodeId) {
template<typename FileStore, typename InodeId_t>
Error Directory<FileStore, InodeId_t>::init() noexcept {
constexpr auto Size = sizeof(Buffer);
oxReturnError(m_fs->write(m_inodeId, nullptr, Size));
auto buff = m_fs->read(m_inodeId);
oxReturnError(m_fs.write(m_inodeId, nullptr, Size));
auto buff = m_fs.read(m_inodeId);
if (buff.valid()) {
new (buff) Buffer(Size);
m_size = Size;
@ -161,7 +164,7 @@ Error Directory<FileStore, InodeId_t>::mkdir(PathIterator path, bool parents, Fi
if (!parents && path.hasNext()) {
return OxError(1);
}
childInode = m_fs->generateInodeId();
childInode = m_fs.generateInodeId();
oxLogError(childInode.error);
oxReturnError(childInode.error);
@ -173,7 +176,7 @@ Error Directory<FileStore, InodeId_t>::mkdir(PathIterator path, bool parents, Fi
if (err) {
oxLogError(err);
// could not index the directory, delete it
oxLogError(m_fs->remove(childInode));
oxLogError(m_fs.remove(childInode));
return err;
}
}
@ -225,7 +228,7 @@ Error Directory<FileStore, InodeId_t>::write(PathIterator path, InodeId_t inode,
// find existing version of directory
oxTrace("ox::fs::Directory::write") << "Searching for inode" << m_inodeId;
auto old = m_fs->read(m_inodeId);
auto old = m_fs.read(m_inodeId);
if (old.valid()) {
const auto entrySize = DirectoryEntry<InodeId_t>::spaceNeeded(name->len());
const auto entryDataSize =DirectoryEntry<InodeId_t>::DirectoryEntryData::spaceNeeded(name->len());
@ -239,7 +242,7 @@ Error Directory<FileStore, InodeId_t>::write(PathIterator path, InodeId_t inode,
if (val.valid()) {
oxTrace("ox::fs::Directory::write") << "Attempting to write Directory to FileStore";
val->init(inode, name->data(), entrySize);
return m_fs->write(m_inodeId, cpy, cpy->size());
return m_fs.write(m_inodeId, cpy, cpy->size());
} else {
oxTrace("ox::fs::Directory::write::fail") << "Could not allocate memory for new directory entry";
return OxError(1);
@ -266,7 +269,7 @@ Error Directory<FileStore, InodeId_t>::remove(PathIterator path, FileName *nameB
oxReturnError(path.get(&name));
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()) {
oxTrace("ox::fs::Directory::remove") << "Found directory buffer.";
for (auto i = buff->iterator(); i.valid(); i.next()) {
@ -286,10 +289,33 @@ Error Directory<FileStore, InodeId_t>::remove(PathIterator path, FileName *nameB
return OxError(0);
}
template<typename FileStore, typename InodeId_t>
template<typename F>
Error Directory<FileStore, InodeId_t>::ls(F cb) noexcept {
oxTrace("ox::fs::Directory::ls");
auto buff = m_fs.read(m_inodeId).template to<Buffer>();
if (buff.valid()) {
oxTrace("ox::fs::Directory::ls") << "Found directory buffer.";
for (auto i = buff->iterator(); i.valid(); i.next()) {
auto data = i->data();
if (data.valid()) {
oxReturnError(cb(data->name, data->inode));
} else {
oxTrace("ox::fs::Directory::ls") << "INVALID DIRECTORY ENTRY";
}
}
oxTrace("ox::fs::Directory::ls::fail");
return OxError(1);
} else {
oxTrace("ox::fs::Directory::ls::fail") << "Could not directory buffer";
return OxError(2);
}
}
template<typename FileStore, typename InodeId_t>
ValErr<typename FileStore::InodeId_t> Directory<FileStore, InodeId_t>::findEntry(const FileName &name) const noexcept {
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()) {
oxTrace("ox::fs::Directory::findEntry") << "Found directory buffer.";
for (auto i = buff->iterator(); i.valid(); i.next()) {

2
deps/ox/src/ox/fs/filesystem/filesystem.cpp vendored
View File

@ -8,7 +8,7 @@
#include "filesystem.hpp"
namespace ox::fs {
namespace ox {
template class FileSystemTemplate<FileStore16, Directory16>;
template class FileSystemTemplate<FileStore32, Directory32>;

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

@ -13,12 +13,12 @@
#include "directory.hpp"
namespace ox::fs {
namespace ox {
class FileSystem {
public:
virtual Error format() = 0;
virtual ~FileSystem() = default;
virtual Error mkdir(const char *path, bool recursive = false) = 0;
@ -51,7 +51,7 @@ class FileSystem {
virtual uint64_t available() = 0;
virtual uint64_t size() = 0;
virtual uint64_t size() const = 0;
virtual uint8_t *buff() = 0;
@ -76,14 +76,16 @@ class FileSystemTemplate: public FileSystem {
LittleEndian<typename FileStore::InodeId_t> rootDirInode;
};
FileStore *m_fs = nullptr;
FileStore m_fs;
public:
FileSystemTemplate(FileStore *fs);
FileSystemTemplate() = default;
FileSystemTemplate(FileStore fs);
~FileSystemTemplate();
Error format() override;
static Error format(void *buff, uint64_t buffSize);
Error mkdir(const char *path, bool recursive = false) override;
@ -95,6 +97,9 @@ class FileSystemTemplate: public FileSystem {
Error read(uint64_t inode, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) override;
template<typename F>
Error ls(const char *dir, F cb);
Error remove(const char *path, bool recursive = false) override;
void resize(uint64_t size, void *buffer = nullptr) override;
@ -111,7 +116,7 @@ class FileSystemTemplate: public FileSystem {
uint64_t available() override;
uint64_t size() override;
uint64_t size() const override;
uint8_t *buff() override;
@ -132,7 +137,7 @@ class FileSystemTemplate: public FileSystem {
};
template<typename FileStore, typename Directory>
FileSystemTemplate<FileStore, Directory>::FileSystemTemplate(FileStore *fs) {
FileSystemTemplate<FileStore, Directory>::FileSystemTemplate(FileStore fs) {
m_fs = fs;
}
@ -141,19 +146,20 @@ FileSystemTemplate<FileStore, Directory>::~FileSystemTemplate() {
}
template<typename FileStore, typename Directory>
Error FileSystemTemplate<FileStore, Directory>::format() {
oxReturnError(m_fs->format());
Error FileSystemTemplate<FileStore, Directory>::format(void *buff, uint64_t buffSize) {
oxReturnError(FileStore::format(buff, buffSize));
FileStore fs(buff, buffSize);
constexpr auto rootDirInode = MaxValue<typename FileStore::InodeId_t> / 2;
Directory rootDir(m_fs, rootDirInode);
Directory rootDir(fs, rootDirInode);
oxReturnError(rootDir.init());
FileSystemData fd;
fd.rootDirInode = rootDirInode;
oxTrace("ox::fs::FileSystemTemplate::format") << "rootDirInode:" << fd.rootDirInode;
oxReturnError(m_fs->write(InodeFsData, &fd, sizeof(fd)));
oxReturnError(fs.write(InodeFsData, &fd, sizeof(fd)));
if (m_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";
}
@ -192,12 +198,24 @@ Error FileSystemTemplate<FileStore, Directory>::read(const char *path, void *buf
template<typename FileStore, typename Directory>
Error FileSystemTemplate<FileStore, Directory>::read(uint64_t inode, void *buffer, std::size_t buffSize) {
return m_fs->read(inode, buffer, buffSize);
return m_fs.read(inode, buffer, buffSize);
}
template<typename FileStore, typename Directory>
Error FileSystemTemplate<FileStore, Directory>::read(uint64_t inode, std::size_t readStart, std::size_t readSize, void *buffer, std::size_t *size) {
return m_fs->read(inode, readStart, readSize, buffer, size);
return m_fs.read(inode, readStart, readSize, reinterpret_cast<uint8_t*>(buffer), size);
}
template<typename FileStore, typename Directory>
template<typename F>
Error FileSystemTemplate<FileStore, Directory>::ls(const char *path, F cb) {
auto s = stat(path);
oxReturnError(s.error);
Directory dir(m_fs, s.value.inode);
dir.ls(cb);
return OxError(0);
}
template<typename FileStore, typename Directory>
@ -224,14 +242,14 @@ Error FileSystemTemplate<FileStore, Directory>::remove(const char *path, bool re
template<typename FileStore, typename Directory>
void FileSystemTemplate<FileStore, Directory>::resize(uint64_t size, void *buffer) {
m_fs->resize(size, buffer);
m_fs.resize(size, buffer);
}
template<typename FileStore, typename Directory>
Error FileSystemTemplate<FileStore, Directory>::write(const char *path, void *buffer, uint64_t size, uint8_t fileType) {
auto inode = find(path);
if (inode.error) {
inode.value = m_fs->generateInodeId();
inode.value = m_fs.generateInodeId();
}
auto rootDir = this->rootDir();
oxReturnError(rootDir.error);
@ -242,12 +260,12 @@ Error FileSystemTemplate<FileStore, Directory>::write(const char *path, void *bu
template<typename FileStore, typename Directory>
Error FileSystemTemplate<FileStore, Directory>::write(uint64_t inode, void *buffer, uint64_t size, uint8_t fileType) {
return m_fs->write(inode, buffer, size, fileType);
return m_fs.write(inode, buffer, size, fileType);
}
template<typename FileStore, typename Directory>
ValErr<FileStat> FileSystemTemplate<FileStore, Directory>::stat(uint64_t inode) {
auto s = m_fs->stat(inode);
auto s = m_fs.stat(inode);
FileStat out;
out.inode = s.value.inode;
out.links = s.value.links;
@ -267,38 +285,38 @@ ValErr<FileStat> FileSystemTemplate<FileStore, Directory>::stat(const char *path
template<typename FileStore, typename Directory>
uint64_t FileSystemTemplate<FileStore, Directory>::spaceNeeded(uint64_t size) {
return m_fs->spaceNeeded(size);
return m_fs.spaceNeeded(size);
}
template<typename FileStore, typename Directory>
uint64_t FileSystemTemplate<FileStore, Directory>::available() {
return m_fs->available();
return m_fs.available();
}
template<typename FileStore, typename Directory>
uint64_t FileSystemTemplate<FileStore, Directory>::size() {
return m_fs->size();
uint64_t FileSystemTemplate<FileStore, Directory>::size() const {
return m_fs.size();
}
template<typename FileStore, typename Directory>
uint8_t *FileSystemTemplate<FileStore, Directory>::buff() {
return m_fs->buff();
return m_fs.buff();
}
template<typename FileStore, typename Directory>
Error FileSystemTemplate<FileStore, Directory>::walk(Error(*cb)(uint8_t, uint64_t, uint64_t)) {
return m_fs->walk(cb);
return m_fs.walk(cb);
}
template<typename FileStore, typename Directory>
bool FileSystemTemplate<FileStore, Directory>::valid() const {
return m_fs && m_fs->valid();
return m_fs.valid();
}
template<typename FileStore, typename Directory>
ValErr<typename FileSystemTemplate<FileStore, Directory>::FileSystemData> FileSystemTemplate<FileStore, Directory>::fileSystemData() const noexcept {
FileSystemData fd;
auto err = m_fs->read(InodeFsData, &fd, sizeof(fd));
auto err = m_fs.read(InodeFsData, &fd, sizeof(fd));
if (err != 0) {
return {fd, err};
}

3
deps/ox/src/ox/fs/fs.hpp vendored
View File

@ -8,5 +8,6 @@
#pragma once
//#include "filesystem/filesystemtemplate.hpp"
#include "filestore/filestoretemplate.hpp"
#include "filesystem/filesystem.hpp"
#include "filesystem/directory.hpp"

18
deps/ox/src/ox/fs/test/filestore_format.cpp vendored
View File

@ -1,18 +0,0 @@
/*
* Copyright 2015 - 2018 gtalent2@gmail.com
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#include <ox/fs/filestore.hpp>
using namespace ox;
int main() {
const auto size = 65535;
uint8_t volume[size];
uint32_t err = 0;
FileStore32::format(volume, size);
return err;
}

68
deps/ox/src/ox/fs/test/filestoreio.cpp vendored
View File

@ -1,68 +0,0 @@
/*
* Copyright 2015 - 2018 gtalent2@gmail.com
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#include <stdio.h>
#include <ox/std/std.hpp>
#include <ox/fs/filestore.hpp>
using namespace ox;
template<typename FileStore>
int test() {
const uint16_t size = ~0;
uint8_t volume[size];
char out[6];
typename FileStore::FsSize_t outSize;
FileStore::format(volume, size);
FileStore *fs = (FileStore*) volume;
if (fs->write(1, (void*) "Hello", 6) ||
fs->read(1, (char*) out, &outSize) ||
ox_strcmp("Hello", out)) {
printf("Failure 1\n");
return 1;
}
if (fs->write(2, (void*) "World", 6) ||
fs->read(2, (char*) out, &outSize) ||
ox_strcmp("World", out)) {
printf("Failure 2\n");
return 2;
}
// make sure first value was not overwritten
if (fs->read(1, (char*) out, &outSize) ||
ox_strcmp("Hello", out)) {
printf("Failure 3\n");
return 3;
}
if (fs->remove(1)) {
printf("Failure 4\n");
return 4;
}
// make sure inode is not found
if (fs->read(1, (char*) out, &outSize) == 0) {
printf("Failure 5\n");
return 5;
}
// make sure 2 is still available
if (fs->write(2, (void*) "World", 6) ||
fs->read(2, (char*) out, &outSize) ||
ox_strcmp("World", out)) {
printf("Failure 6\n");
return 6;
}
return 0;
}
int main() {
return test<FileStore16>() || test<FileStore32>() | test<FileStore64>();
}

23
deps/ox/src/ox/fs/test/filesystem_format.cpp vendored
View File

@ -1,23 +0,0 @@
/*
* Copyright 2015 - 2018 gtalent2@gmail.com
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#include <ox/fs/fs.hpp>
using namespace ox;
template<typename FileSystem>
int test() {
const uint16_t size = ~0;
uint8_t volume[size];
FileSystem::format(volume, size, true);
return 0;
}
int main() {
return test<FileSystem16>() | test<FileSystem32>() | test<FileSystem64>();
}

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

@ -137,7 +137,7 @@ map<string, int(*)(string)> tests = {
[](string) {
int err = 0;
constexpr auto buffLen = 5000;
auto list = new (ox_alloca(buffLen)) ox::ptrarith::NodeBuffer<uint32_t, ox::fs::FileStoreItem<uint32_t>>(buffLen);
auto list = new (ox_alloca(buffLen)) ox::ptrarith::NodeBuffer<uint32_t, ox::FileStoreItem<uint32_t>>(buffLen);
oxAssert(list->malloc(50).valid(), "NodeBuffer::insert: malloc 1 failed");
oxAssert(list->malloc(50).valid(), "NodeBuffer::insert: malloc 2 failed");
auto first = list->firstItem();
@ -154,9 +154,9 @@ map<string, int(*)(string)> tests = {
constexpr auto str1Len = ox_strlen(str1) + 1;
constexpr auto str2 = "Hello, Moon!";
constexpr auto str2Len = ox_strlen(str2) + 1;
auto list = new (ox_alloca(buffLen)) ox::ptrarith::NodeBuffer<uint32_t, ox::fs::FileStoreItem<uint32_t>>(buffLen);
ox::fs::FileStore32 fileStore(list, buffLen);
oxAssert(fileStore.format() == 0, "FileStore::format failed.");
auto list = new (ox_alloca(buffLen)) ox::ptrarith::NodeBuffer<uint32_t, ox::FileStoreItem<uint32_t>>(buffLen);
oxAssert(ox::FileStore32::format(list, buffLen) == 0, "FileStore::format failed.");
ox::FileStore32 fileStore(list, buffLen);
oxAssert(fileStore.write(4, const_cast<char*>(str1), str1Len, 1) == 0, "FileStore::write 1 failed.");
oxAssert(fileStore.write(5, const_cast<char*>(str2), str2Len, 1) == 0, "FileStore::write 2 failed.");
@ -171,9 +171,9 @@ map<string, int(*)(string)> tests = {
"Directory",
[](string) {
std::array<uint8_t, 5000> fsBuff;
ox::fs::FileStore32 fileStore(fsBuff.data(), fsBuff.size());
fileStore.format();
auto dir = ox_malloca(1000, ox::fs::Directory32, &fileStore, 100);
ox::FileStore32::format(fsBuff.data(), fsBuff.size());
ox::FileStore32 fileStore(fsBuff.data(), fsBuff.size());
auto dir = ox_malloca(1000, ox::Directory32, fileStore, 100);
oxTrace("ox::fs::test::Directory") << "Init";
oxAssert(dir->init(), "Init failed");
@ -198,11 +198,9 @@ map<string, int(*)(string)> tests = {
"FileSystem",
[](string) {
std::array<uint8_t, 5000> fsBuff;
ox::fs::FileStore32 fileStore(fsBuff.data(), fsBuff.size());
ox::fs::FileSystem32 fs(&fileStore);
oxTrace("ox::fs::test::FileSystem") << "format";
oxAssert(fs.format(), "FileSystem format failed");
oxAssert(ox::FileSystem32::format(fsBuff.data(), fsBuff.size()), "FileSystem format failed");
ox::FileSystem32 fs(ox::FileStore32(fsBuff.data(), fsBuff.size()));
oxTrace("ox::fs::test::FileSystem") << "mkdir";
oxAssert(fs.mkdir("/l1d1/l2d1/l3d1", true), "mkdir failed");

20
deps/ox/src/ox/ptrarith/nodebuffer.hpp vendored
View File

@ -142,7 +142,8 @@ class __attribute__((packed)) NodeBuffer {
*/
size_t spaceNeeded(size_t size);
void compact(void (*cb)(ItemPtr itemMoved) = nullptr);
template<typename F>
void compact(F cb = [](uint64_t, ItemPtr) {});
void truncate();
@ -174,7 +175,7 @@ typename NodeBuffer<size_t, Item>::Iterator NodeBuffer<size_t, Item>::iterator()
template<typename size_t, typename Item>
typename NodeBuffer<size_t, Item>::ItemPtr NodeBuffer<size_t, Item>::firstItem() {
oxTrace("ox::ptrarith::NodeBuffer::firstItem") << m_header.firstItem;
//oxTrace("ox::ptrarith::NodeBuffer::firstItem") << m_header.firstItem;
return ptr(m_header.firstItem);
}
@ -215,10 +216,10 @@ typename NodeBuffer<size_t, Item>::ItemPtr NodeBuffer<size_t, Item>::ptr(size_t
itemSpace >= item->fullSize()) {
return ItemPtr(this, m_header.size, itemOffset, item->fullSize());
} else {
oxTrace("ox::ptrarith::NodeBuffer::ptr::null") << "itemOffset:" << itemOffset;
oxTrace("ox::ptrarith::NodeBuffer::ptr::null") << "itemOffset >= sizeof(Header):" << (itemOffset >= sizeof(Header));
oxTrace("ox::ptrarith::NodeBuffer::ptr::null") << "itemSpace >= sizeof(Item):" << (itemSpace >= sizeof(Item));
oxTrace("ox::ptrarith::NodeBuffer::ptr::null") << "itemSpace >= item->fullSize():" << (itemSpace >= item->fullSize());
//oxTrace("ox::ptrarith::NodeBuffer::ptr::null") << "itemOffset:" << itemOffset;
//oxTrace("ox::ptrarith::NodeBuffer::ptr::null") << "itemOffset >= sizeof(Header):" << (itemOffset >= sizeof(Header));
//oxTrace("ox::ptrarith::NodeBuffer::ptr::null") << "itemSpace >= sizeof(Item):" << (itemSpace >= sizeof(Item));
//oxTrace("ox::ptrarith::NodeBuffer::ptr::null") << "itemSpace >= item->fullSize():" << (itemSpace >= item->fullSize());
return ItemPtr(this, m_header.size, 0, 0);
}
}
@ -324,15 +325,14 @@ size_t NodeBuffer<size_t, Item>::spaceNeeded(size_t size) {
}
template<typename size_t, typename Item>
void NodeBuffer<size_t, Item>::compact(void (*cb)(ItemPtr)) {
template<typename F>
void NodeBuffer<size_t, Item>::compact(F cb) {
auto src = firstItem();
auto dest = ptr(sizeof(*this));
while (src.valid() && dest.valid()) {
// move node
ox_memcpy(dest, src, src.size());
if (cb) {
cb(dest);
}
cb(src, dest);
// update surrounding nodes
auto prev = ptr(dest->next);
if (prev.valid()) {

2
deps/ox/src/ox/std/random.hpp vendored
View File

@ -14,7 +14,7 @@ namespace ox {
using RandomSeed = uint64_t[2];
class Random {
class __attribute__((packed)) Random {
private:
RandomSeed m_seed;

4
deps/ox/src/ox/trace/trace.cpp vendored
View File

@ -19,7 +19,11 @@
namespace ox::trace {
#if defined(OX_USE_STDLIB)
static const auto OxPrintTrace = std::getenv("OXTRACE");
#else
static const auto OxPrintTrace = false;
#endif
namespace gdblogger {