406 lines
13 KiB
C++
406 lines
13 KiB
C++
/*
|
|
* Vfs.cpp
|
|
* Virtual File System with numerical logical drive identifiers
|
|
* Copyright (c) 2025 Daniel Hammer
|
|
*/
|
|
|
|
#include "Vfs.hpp"
|
|
#include <Terminal/Terminal.hpp>
|
|
#include <CppLib/Spinlock.hpp>
|
|
|
|
namespace Fs::Vfs {
|
|
|
|
static FsDriver* driveTable[MaxDrives];
|
|
static bool driveActive[MaxDrives];
|
|
static uint32_t driveGeneration[MaxDrives];
|
|
static bool initialized = false;
|
|
|
|
// Protects driver dispatch from concurrent CPU access. Hot-unplug only
|
|
// flips driveActive so an interrupted dispatch never sees a null driver.
|
|
static kcp::Mutex vfsLock;
|
|
|
|
// Parse "N:/path" into drive number and local path.
|
|
// Returns true on success, sets outDrive and outPath.
|
|
static bool ParsePath(const char* path, int& outDrive, const char*& outPath) {
|
|
if (path == nullptr) return false;
|
|
|
|
// Parse decimal drive number before ':'
|
|
int drive = 0;
|
|
int i = 0;
|
|
bool hasDigit = false;
|
|
|
|
while (path[i] >= '0' && path[i] <= '9') {
|
|
drive = drive * 10 + (path[i] - '0');
|
|
hasDigit = true;
|
|
i++;
|
|
}
|
|
|
|
if (!hasDigit) return false;
|
|
if (path[i] != ':') return false;
|
|
|
|
// Everything after "N:" is the local path
|
|
outDrive = drive;
|
|
outPath = &path[i + 1];
|
|
return true;
|
|
}
|
|
|
|
static void BumpDriveGeneration(int driveNumber) {
|
|
driveGeneration[driveNumber]++;
|
|
if (driveGeneration[driveNumber] == 0) {
|
|
driveGeneration[driveNumber] = 1;
|
|
}
|
|
}
|
|
|
|
void Initialize() {
|
|
for (int i = 0; i < MaxDrives; i++) {
|
|
driveTable[i] = nullptr;
|
|
driveActive[i] = false;
|
|
driveGeneration[i] = 1;
|
|
}
|
|
|
|
initialized = true;
|
|
Kt::KernelLogStream(Kt::OK, "VFS") << "Initialized (" << MaxDrives << " drives)";
|
|
}
|
|
|
|
bool IsInitialized() {
|
|
return initialized;
|
|
}
|
|
|
|
int RegisterDrive(int driveNumber, FsDriver* driver) {
|
|
if (driveNumber < 0 || driveNumber >= MaxDrives) return -1;
|
|
if (driver == nullptr) return -1;
|
|
if (!initialized) return -1;
|
|
|
|
vfsLock.Acquire();
|
|
if (driveActive[driveNumber]) {
|
|
vfsLock.Release();
|
|
return -1;
|
|
}
|
|
driveTable[driveNumber] = driver;
|
|
BumpDriveGeneration(driveNumber);
|
|
driveActive[driveNumber] = true;
|
|
vfsLock.Release();
|
|
|
|
Kt::KernelLogStream(Kt::OK, "VFS") << "Registered drive " << driveNumber;
|
|
return 0;
|
|
}
|
|
|
|
int UnregisterDrive(int driveNumber) {
|
|
if (!initialized) return -1;
|
|
if (driveNumber < 0 || driveNumber >= MaxDrives) return -1;
|
|
|
|
vfsLock.Acquire();
|
|
if (!driveActive[driveNumber]) {
|
|
vfsLock.Release();
|
|
return -1;
|
|
}
|
|
driveActive[driveNumber] = false;
|
|
BumpDriveGeneration(driveNumber);
|
|
vfsLock.Release();
|
|
|
|
Kt::KernelLogStream(Kt::OK, "VFS") << "Unregistered drive " << driveNumber;
|
|
return 0;
|
|
}
|
|
|
|
bool IsDriveRegistered(int driveNumber) {
|
|
if (driveNumber < 0 || driveNumber >= MaxDrives) return false;
|
|
vfsLock.Acquire();
|
|
bool registered = driveActive[driveNumber];
|
|
vfsLock.Release();
|
|
return registered;
|
|
}
|
|
|
|
int FindLowestAvailableDrive(int firstDrive) {
|
|
if (!initialized) return -1;
|
|
if (firstDrive < 0) firstDrive = 0;
|
|
|
|
vfsLock.Acquire();
|
|
for (int i = firstDrive; i < MaxDrives; i++) {
|
|
if (!driveActive[i]) {
|
|
vfsLock.Release();
|
|
return i;
|
|
}
|
|
}
|
|
|
|
vfsLock.Release();
|
|
return -1;
|
|
}
|
|
|
|
int OpenBackendFile(const char* path, BackendFile& outFile) {
|
|
outFile.driveNumber = -1;
|
|
outFile.localHandle = -1;
|
|
outFile.generation = 0;
|
|
|
|
int drive;
|
|
const char* localPath;
|
|
|
|
if (!ParsePath(path, drive, localPath)) return -1;
|
|
if (drive < 0 || drive >= MaxDrives || !driveActive[drive] || driveTable[drive] == nullptr) return -1;
|
|
|
|
vfsLock.Acquire();
|
|
FsDriver* driver = driveTable[drive];
|
|
uint32_t generation = driveGeneration[drive];
|
|
int localHandle = (driveActive[drive] && driver) ? driver->Open(localPath) : -1;
|
|
vfsLock.Release();
|
|
if (localHandle < 0) return -1;
|
|
|
|
outFile.driveNumber = drive;
|
|
outFile.localHandle = localHandle;
|
|
outFile.generation = generation;
|
|
return 0;
|
|
}
|
|
|
|
int ReadBackendFile(const BackendFile& file, uint8_t* buffer, uint64_t offset, uint64_t size) {
|
|
vfsLock.Acquire();
|
|
FsDriver* driver = (file.driveNumber >= 0 && file.driveNumber < MaxDrives)
|
|
? driveTable[file.driveNumber]
|
|
: nullptr;
|
|
if (file.driveNumber < 0 || file.driveNumber >= MaxDrives || !driveActive[file.driveNumber] ||
|
|
driver == nullptr ||
|
|
file.generation != driveGeneration[file.driveNumber] ||
|
|
file.localHandle < 0) {
|
|
vfsLock.Release();
|
|
return -1;
|
|
}
|
|
|
|
int result = driver->Read(file.localHandle, buffer, offset, size);
|
|
vfsLock.Release();
|
|
return result;
|
|
}
|
|
|
|
uint64_t GetBackendFileSize(const BackendFile& file) {
|
|
vfsLock.Acquire();
|
|
FsDriver* driver = (file.driveNumber >= 0 && file.driveNumber < MaxDrives)
|
|
? driveTable[file.driveNumber]
|
|
: nullptr;
|
|
if (file.driveNumber < 0 || file.driveNumber >= MaxDrives || !driveActive[file.driveNumber] ||
|
|
driver == nullptr ||
|
|
file.generation != driveGeneration[file.driveNumber] ||
|
|
file.localHandle < 0) {
|
|
vfsLock.Release();
|
|
return 0;
|
|
}
|
|
|
|
uint64_t result = driver->GetSize(file.localHandle);
|
|
vfsLock.Release();
|
|
return result;
|
|
}
|
|
|
|
bool BackendFileCanWrite(const BackendFile& file) {
|
|
vfsLock.Acquire();
|
|
FsDriver* driver = (file.driveNumber >= 0 && file.driveNumber < MaxDrives)
|
|
? driveTable[file.driveNumber]
|
|
: nullptr;
|
|
bool canWrite = file.driveNumber >= 0 && file.driveNumber < MaxDrives &&
|
|
driveActive[file.driveNumber] &&
|
|
driver != nullptr &&
|
|
file.generation == driveGeneration[file.driveNumber] &&
|
|
file.localHandle >= 0 &&
|
|
driver->Write != nullptr;
|
|
vfsLock.Release();
|
|
return canWrite;
|
|
}
|
|
|
|
void CloseBackendFile(BackendFile& file) {
|
|
vfsLock.Acquire();
|
|
FsDriver* driver = (file.driveNumber >= 0 && file.driveNumber < MaxDrives)
|
|
? driveTable[file.driveNumber]
|
|
: nullptr;
|
|
if (file.driveNumber < 0 || file.driveNumber >= MaxDrives || !driveActive[file.driveNumber] ||
|
|
driver == nullptr ||
|
|
file.generation != driveGeneration[file.driveNumber] ||
|
|
file.localHandle < 0) {
|
|
vfsLock.Release();
|
|
file.driveNumber = -1;
|
|
file.localHandle = -1;
|
|
file.generation = 0;
|
|
return;
|
|
}
|
|
|
|
driver->Close(file.localHandle);
|
|
vfsLock.Release();
|
|
|
|
file.driveNumber = -1;
|
|
file.localHandle = -1;
|
|
file.generation = 0;
|
|
}
|
|
|
|
int WriteBackendFile(const BackendFile& file, const uint8_t* buffer, uint64_t offset, uint64_t size) {
|
|
vfsLock.Acquire();
|
|
FsDriver* driver = (file.driveNumber >= 0 && file.driveNumber < MaxDrives)
|
|
? driveTable[file.driveNumber]
|
|
: nullptr;
|
|
if (file.driveNumber < 0 || file.driveNumber >= MaxDrives || !driveActive[file.driveNumber] ||
|
|
driver == nullptr ||
|
|
file.generation != driveGeneration[file.driveNumber] ||
|
|
file.localHandle < 0) {
|
|
vfsLock.Release();
|
|
return -1;
|
|
}
|
|
|
|
if (driver->Write == nullptr) { vfsLock.Release(); return -1; }
|
|
int result = driver->Write(file.localHandle, buffer, offset, size);
|
|
vfsLock.Release();
|
|
return result;
|
|
}
|
|
|
|
int CreateBackendFile(const char* path, BackendFile& outFile) {
|
|
outFile.driveNumber = -1;
|
|
outFile.localHandle = -1;
|
|
outFile.generation = 0;
|
|
|
|
int drive;
|
|
const char* localPath;
|
|
|
|
if (!ParsePath(path, drive, localPath)) return -1;
|
|
if (drive < 0 || drive >= MaxDrives || !driveActive[drive] || driveTable[drive] == nullptr) return -1;
|
|
if (driveTable[drive]->Create == nullptr) return -1;
|
|
|
|
vfsLock.Acquire();
|
|
FsDriver* driver = driveTable[drive];
|
|
uint32_t generation = driveGeneration[drive];
|
|
int localHandle = (driveActive[drive] && driver && driver->Create)
|
|
? driver->Create(localPath)
|
|
: -1;
|
|
vfsLock.Release();
|
|
if (localHandle < 0) return -1;
|
|
|
|
outFile.driveNumber = drive;
|
|
outFile.localHandle = localHandle;
|
|
outFile.generation = generation;
|
|
return 0;
|
|
}
|
|
|
|
int VfsDelete(const char* path) {
|
|
int drive;
|
|
const char* localPath;
|
|
|
|
if (!ParsePath(path, drive, localPath)) return -1;
|
|
if (drive < 0 || drive >= MaxDrives || !driveActive[drive] || driveTable[drive] == nullptr) return -1;
|
|
if (driveTable[drive]->Delete == nullptr) return -1;
|
|
|
|
vfsLock.Acquire();
|
|
FsDriver* driver = driveTable[drive];
|
|
int result = (driveActive[drive] && driver && driver->Delete)
|
|
? driver->Delete(localPath)
|
|
: -1;
|
|
vfsLock.Release();
|
|
return result;
|
|
}
|
|
|
|
int VfsMkdir(const char* path) {
|
|
int drive;
|
|
const char* localPath;
|
|
|
|
if (!ParsePath(path, drive, localPath)) return -1;
|
|
if (drive < 0 || drive >= MaxDrives || !driveActive[drive] || driveTable[drive] == nullptr) return -1;
|
|
if (driveTable[drive]->Mkdir == nullptr) return -1;
|
|
|
|
vfsLock.Acquire();
|
|
FsDriver* driver = driveTable[drive];
|
|
int result = (driveActive[drive] && driver && driver->Mkdir)
|
|
? driver->Mkdir(localPath)
|
|
: -1;
|
|
vfsLock.Release();
|
|
return result;
|
|
}
|
|
|
|
int VfsDriveList(int* outDrives, int maxEntries) {
|
|
vfsLock.Acquire();
|
|
int count = 0;
|
|
for (int i = 0; i < MaxDrives && count < maxEntries; i++) {
|
|
if (driveActive[i]) {
|
|
outDrives[count++] = i;
|
|
}
|
|
}
|
|
vfsLock.Release();
|
|
return count;
|
|
}
|
|
|
|
int VfsDriveLabel(int driveNumber, char* outLabel, int maxLen) {
|
|
if (outLabel == nullptr || maxLen <= 0) return -1;
|
|
outLabel[0] = '\0';
|
|
|
|
vfsLock.Acquire();
|
|
if (driveNumber < 0 || driveNumber >= MaxDrives || !driveActive[driveNumber] ||
|
|
driveTable[driveNumber] == nullptr) {
|
|
vfsLock.Release();
|
|
return -1;
|
|
}
|
|
|
|
if (driveTable[driveNumber]->GetLabel == nullptr) {
|
|
vfsLock.Release();
|
|
return 0;
|
|
}
|
|
|
|
const char* label = driveTable[driveNumber]->GetLabel();
|
|
if (label == nullptr || label[0] == '\0') {
|
|
vfsLock.Release();
|
|
return 0;
|
|
}
|
|
|
|
int copied = 0;
|
|
while (label[copied] != '\0' && copied < maxLen - 1) {
|
|
outLabel[copied] = label[copied];
|
|
copied++;
|
|
}
|
|
outLabel[copied] = '\0';
|
|
|
|
vfsLock.Release();
|
|
return copied;
|
|
}
|
|
|
|
int VfsRename(const char* oldPath, const char* newPath) {
|
|
int oldDrive, newDrive;
|
|
const char* oldLocal;
|
|
const char* newLocal;
|
|
|
|
if (!ParsePath(oldPath, oldDrive, oldLocal)) return -1;
|
|
if (!ParsePath(newPath, newDrive, newLocal)) return -1;
|
|
|
|
// Cross-drive rename not supported
|
|
if (oldDrive != newDrive) return -1;
|
|
if (oldDrive < 0 || oldDrive >= MaxDrives || !driveActive[oldDrive] ||
|
|
driveTable[oldDrive] == nullptr) return -1;
|
|
if (driveTable[oldDrive]->Rename == nullptr) return -1;
|
|
|
|
vfsLock.Acquire();
|
|
FsDriver* driver = driveTable[oldDrive];
|
|
int result = (driveActive[oldDrive] && driver && driver->Rename)
|
|
? driver->Rename(oldLocal, newLocal)
|
|
: -1;
|
|
vfsLock.Release();
|
|
return result;
|
|
}
|
|
|
|
int VfsReadDir(const char* path, const char** outNames, int maxEntries) {
|
|
return VfsReadDirAt(path, outNames, maxEntries, 0);
|
|
}
|
|
|
|
int VfsReadDirAt(const char* path, const char** outNames, int maxEntries, int startIndex) {
|
|
int drive;
|
|
const char* localPath;
|
|
|
|
if (startIndex < 0) return -1;
|
|
if (!ParsePath(path, drive, localPath)) return -1;
|
|
if (drive < 0 || drive >= MaxDrives || !driveActive[drive] || driveTable[drive] == nullptr) return -1;
|
|
|
|
vfsLock.Acquire();
|
|
FsDriver* driver = driveTable[drive];
|
|
int result;
|
|
if (!driveActive[drive] || !driver) {
|
|
result = -1;
|
|
} else if (driver->ReadDirAt) {
|
|
result = driver->ReadDirAt(localPath, outNames, maxEntries, startIndex);
|
|
} else if (driver->ReadDir) {
|
|
// Driver without pagination support: only the first page is reachable.
|
|
result = (startIndex == 0) ? driver->ReadDir(localPath, outNames, maxEntries) : 0;
|
|
} else {
|
|
result = -1;
|
|
}
|
|
vfsLock.Release();
|
|
return result;
|
|
}
|
|
|
|
}
|