mirror of
https://github.com/Fennix-Project/Kernel.git
synced 2025-05-25 22:14:37 +00:00
435 lines
8.8 KiB
C++
435 lines
8.8 KiB
C++
/*
|
|
This file is part of Fennix Kernel.
|
|
|
|
Fennix Kernel is free software: you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation, either version 3 of
|
|
the License, or (at your option) any later version.
|
|
|
|
Fennix Kernel is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <filesystem.hpp>
|
|
|
|
#include <smart_ptr.hpp>
|
|
#include <convert.h>
|
|
#include <task.hpp>
|
|
#include <printf.h>
|
|
#include <lock.hpp>
|
|
#include <cwalk.h>
|
|
|
|
#include "../kernel.h"
|
|
|
|
namespace VirtualFileSystem
|
|
{
|
|
ReadFSFunction(fd_Read)
|
|
{
|
|
if (!Size)
|
|
Size = node->Length;
|
|
|
|
if (RefOffset > node->Length)
|
|
return 0;
|
|
|
|
if (RefOffset + (off_t)Size > node->Length)
|
|
Size = node->Length - RefOffset;
|
|
|
|
memcpy(Buffer, (uint8_t *)(node->Address + RefOffset), Size);
|
|
return Size;
|
|
}
|
|
|
|
WriteFSFunction(fd_Write)
|
|
{
|
|
if (!Size)
|
|
Size = node->Length;
|
|
|
|
if (RefOffset > node->Length)
|
|
return 0;
|
|
|
|
if (RefOffset + (off_t)Size > node->Length)
|
|
Size = node->Length - RefOffset;
|
|
|
|
memcpy((uint8_t *)(node->Address + RefOffset), Buffer, Size);
|
|
return Size;
|
|
}
|
|
|
|
VirtualFileSystem::FileSystemOperations fd_op = {
|
|
.Name = "fd",
|
|
// .Read = fd_Read,
|
|
// .Write = fd_Write,
|
|
};
|
|
|
|
FileDescriptorTable::FileDescriptor
|
|
FileDescriptorTable::GetFileDescriptor(int FileDescriptor)
|
|
{
|
|
foreach (auto fd in FileDescriptors)
|
|
{
|
|
if (fd.Descriptor == FileDescriptor)
|
|
return fd;
|
|
}
|
|
return {.Descriptor = -1};
|
|
}
|
|
|
|
int FileDescriptorTable::ProbeMode(mode_t Mode, int Flags)
|
|
{
|
|
if (Flags & O_RDONLY)
|
|
{
|
|
if (!(Mode & S_IRUSR))
|
|
return -EACCES;
|
|
}
|
|
|
|
if (Flags & O_WRONLY)
|
|
{
|
|
if (!(Mode & S_IWUSR))
|
|
return -EACCES;
|
|
}
|
|
|
|
if (Flags & O_RDWR)
|
|
{
|
|
if (!(Mode & S_IRUSR) ||
|
|
!(Mode & S_IWUSR))
|
|
return -EACCES;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int FileDescriptorTable::AddFileDescriptor(const char *AbsolutePath,
|
|
mode_t Mode, int Flags)
|
|
{
|
|
Tasking::PCB *pcb = thisProcess;
|
|
|
|
if (ProbeMode(Mode, Flags) < 0)
|
|
{
|
|
errno = EACCES;
|
|
return -1;
|
|
}
|
|
|
|
if (Flags & O_CREAT)
|
|
{
|
|
Node *n = vfs->Create(AbsolutePath,
|
|
NodeFlags::FILE,
|
|
pcb->CurrentWorkingDirectory);
|
|
|
|
if (!n)
|
|
{
|
|
error("Failed to create file %s: %d",
|
|
AbsolutePath, errno);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (Flags & O_EXCL)
|
|
{
|
|
RefNode *File = vfs->Open(AbsolutePath,
|
|
pcb->CurrentWorkingDirectory);
|
|
|
|
if (!File)
|
|
{
|
|
errno = EEXIST;
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (Flags & O_TRUNC)
|
|
{
|
|
fixme("Implement O_TRUNC");
|
|
}
|
|
|
|
if (Flags & O_APPEND)
|
|
{
|
|
fixme("Implement O_APPEND");
|
|
}
|
|
|
|
if (Flags & O_CLOEXEC)
|
|
{
|
|
fixme("Implement O_CLOEXEC");
|
|
}
|
|
|
|
RefNode *File = vfs->Open(AbsolutePath,
|
|
pcb->CurrentWorkingDirectory);
|
|
|
|
if (!File)
|
|
{
|
|
error("Failed to open file %s: %d",
|
|
AbsolutePath, errno);
|
|
return -1;
|
|
}
|
|
|
|
FileDescriptorTable::FileDescriptor fd;
|
|
fd.Descriptor = GetFreeFileDescriptor();
|
|
|
|
if (fd.Descriptor < 0)
|
|
{
|
|
errno = EMFILE;
|
|
return -1;
|
|
}
|
|
|
|
fd.Mode = Mode;
|
|
fd.Flags = Flags;
|
|
fd.Handle = File;
|
|
|
|
FileDescriptors.push_back(fd);
|
|
|
|
char FileName[64];
|
|
sprintf(FileName, "%d", fd.Descriptor);
|
|
VirtualFileSystem::Node *n = vfs->Create(FileName, VirtualFileSystem::NodeFlags::FILE, this->fdDir);
|
|
if (n)
|
|
{
|
|
/* FIXME: Implement proper file descriptors */
|
|
n->Address = (uintptr_t)0xdeadbeef;
|
|
n->Length = File->FileSize;
|
|
n->Operator = &fd_op;
|
|
}
|
|
|
|
return fd.Descriptor;
|
|
}
|
|
|
|
int FileDescriptorTable::RemoveFileDescriptor(int FileDescriptor)
|
|
{
|
|
forItr(itr, FileDescriptors)
|
|
{
|
|
if (itr->Descriptor == FileDescriptor)
|
|
{
|
|
FileDescriptors.erase(itr);
|
|
|
|
char FileName[64];
|
|
sprintf(FileName, "%d", FileDescriptor);
|
|
vfs->Delete(FileName, false, this->fdDir);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
errno = EBADF;
|
|
return -1;
|
|
}
|
|
|
|
int FileDescriptorTable::GetFreeFileDescriptor()
|
|
{
|
|
int i = 0;
|
|
while (true)
|
|
{
|
|
bool Found = false;
|
|
foreach (auto fd in FileDescriptors)
|
|
{
|
|
if (fd.Descriptor == i)
|
|
{
|
|
Found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!Found)
|
|
return i;
|
|
i++;
|
|
}
|
|
|
|
errno = EMFILE;
|
|
return -1;
|
|
}
|
|
|
|
std::string FileDescriptorTable::GetAbsolutePath(int FileDescriptor)
|
|
{
|
|
FileDescriptorTable::FileDescriptor fd =
|
|
this->GetFileDescriptor(FileDescriptor);
|
|
if (fd.Descriptor == -1)
|
|
return "";
|
|
|
|
Node *node = fd.Handle->node;
|
|
std::string absolutePath = vfs->GetPathFromNode(node);
|
|
std::string path = absolutePath.c_str();
|
|
return path;
|
|
}
|
|
|
|
int FileDescriptorTable::_open(const char *pathname, int flags,
|
|
mode_t mode)
|
|
{
|
|
if (pathname == nullptr)
|
|
{
|
|
errno = EFAULT;
|
|
return -1;
|
|
}
|
|
|
|
return AddFileDescriptor(pathname, mode, flags);
|
|
}
|
|
|
|
int FileDescriptorTable::_creat(const char *pathname, mode_t mode)
|
|
{
|
|
return _open(pathname, O_WRONLY | O_CREAT | O_TRUNC, mode);
|
|
}
|
|
|
|
ssize_t FileDescriptorTable::_read(int fd, void *buf, size_t count)
|
|
{
|
|
FileDescriptor fdesc;
|
|
fdesc = this->GetFileDescriptor(fd);
|
|
|
|
if (fdesc.Descriptor < 0)
|
|
{
|
|
errno = EBADF;
|
|
return -1;
|
|
}
|
|
|
|
return fdesc.Handle->Read((uint8_t *)buf, count);
|
|
}
|
|
|
|
ssize_t FileDescriptorTable::_write(int fd, const void *buf,
|
|
size_t count)
|
|
{
|
|
FileDescriptor fdesc;
|
|
fdesc = this->GetFileDescriptor(fd);
|
|
|
|
if (fdesc.Descriptor < 0)
|
|
return -1;
|
|
|
|
return fdesc.Handle->Write((uint8_t *)buf, count);
|
|
}
|
|
|
|
int FileDescriptorTable::_close(int fd)
|
|
{
|
|
FileDescriptor fdesc;
|
|
fdesc = this->GetFileDescriptor(fd);
|
|
|
|
if (fdesc.Descriptor < 0)
|
|
{
|
|
errno = EBADF;
|
|
return -1;
|
|
}
|
|
|
|
if (RemoveFileDescriptor(fd) < 0)
|
|
{
|
|
errno = EBADF;
|
|
return -1;
|
|
}
|
|
|
|
delete fdesc.Handle;
|
|
return 0;
|
|
}
|
|
|
|
off_t FileDescriptorTable::_lseek(int fd, off_t offset, int whence)
|
|
{
|
|
FileDescriptor fdesc;
|
|
fdesc = this->GetFileDescriptor(fd);
|
|
|
|
if (fdesc.Descriptor < 0)
|
|
{
|
|
errno = EBADF;
|
|
return -1;
|
|
}
|
|
|
|
return fdesc.Handle->Seek(offset, whence);
|
|
}
|
|
|
|
int FileDescriptorTable::_stat(const char *pathname,
|
|
struct stat *statbuf)
|
|
{
|
|
if (pathname == nullptr)
|
|
{
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
RefNode *file = vfs->Open(pathname,
|
|
thisProcess->CurrentWorkingDirectory);
|
|
|
|
if (!file)
|
|
{
|
|
error("Failed to open file %s: %d",
|
|
pathname, errno);
|
|
return -1;
|
|
}
|
|
|
|
Node *node = file->node;
|
|
statbuf->st_dev = 0; /* FIXME: stub */
|
|
statbuf->st_ino = node->IndexNode;
|
|
statbuf->st_mode = node->Flags | node->Mode;
|
|
statbuf->st_nlink = 0; /* FIXME: stub */
|
|
statbuf->st_uid = node->UserIdentifier;
|
|
statbuf->st_gid = node->GroupIdentifier;
|
|
statbuf->st_rdev = 0; /* FIXME: stub */
|
|
statbuf->st_size = node->Length;
|
|
statbuf->st_blksize = 0; /* FIXME: stub */
|
|
statbuf->st_blocks = 0; /* FIXME: stub */
|
|
statbuf->st_attr = 0; /* FIXME: stub */
|
|
return 0;
|
|
}
|
|
|
|
int FileDescriptorTable::_fstat(int fd, struct stat *statbuf)
|
|
{
|
|
FileDescriptor fdesc;
|
|
fdesc = this->GetFileDescriptor(fd);
|
|
|
|
if (fdesc.Descriptor < 0)
|
|
{
|
|
errno = EBADF;
|
|
return -1;
|
|
}
|
|
|
|
Node *node = fdesc.Handle->node;
|
|
statbuf->st_dev = 0; /* FIXME: stub */
|
|
statbuf->st_ino = node->IndexNode;
|
|
statbuf->st_mode = node->Flags | node->Mode;
|
|
statbuf->st_nlink = 0; /* FIXME: stub */
|
|
statbuf->st_uid = node->UserIdentifier;
|
|
statbuf->st_gid = node->GroupIdentifier;
|
|
statbuf->st_rdev = 0; /* FIXME: stub */
|
|
statbuf->st_size = node->Length;
|
|
statbuf->st_blksize = 0; /* FIXME: stub */
|
|
statbuf->st_blocks = 0; /* FIXME: stub */
|
|
statbuf->st_attr = 0; /* FIXME: stub */
|
|
return 0;
|
|
}
|
|
|
|
int FileDescriptorTable::_lstat(const char *pathname,
|
|
struct stat *statbuf)
|
|
{
|
|
if (pathname == nullptr)
|
|
{
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
RefNode *file = vfs->Open(pathname,
|
|
thisProcess->CurrentWorkingDirectory);
|
|
|
|
if (!file)
|
|
{
|
|
error("Failed to open file %s: %d",
|
|
pathname, errno);
|
|
return -1;
|
|
}
|
|
|
|
Node *node = file->node;
|
|
statbuf->st_dev = 0; /* FIXME: stub */
|
|
statbuf->st_ino = node->IndexNode;
|
|
statbuf->st_mode = node->Flags | node->Mode;
|
|
statbuf->st_nlink = 0; /* FIXME: stub */
|
|
statbuf->st_uid = node->UserIdentifier;
|
|
statbuf->st_gid = node->GroupIdentifier;
|
|
statbuf->st_rdev = 0; /* FIXME: stub */
|
|
statbuf->st_size = node->Length;
|
|
statbuf->st_blksize = 0; /* FIXME: stub */
|
|
statbuf->st_blocks = 0; /* FIXME: stub */
|
|
statbuf->st_attr = 0; /* FIXME: stub */
|
|
return 0;
|
|
}
|
|
|
|
FileDescriptorTable::FileDescriptorTable(void *Owner)
|
|
{
|
|
this->fdDir = vfs->Create("fd", VirtualFileSystem::NodeFlags::DIRECTORY,
|
|
((Tasking::PCB *)Owner)->ProcessDirectory);
|
|
}
|
|
|
|
FileDescriptorTable::~FileDescriptorTable()
|
|
{
|
|
foreach (auto var in FileDescriptors)
|
|
{
|
|
this->RemoveFileDescriptor(var.Descriptor);
|
|
delete var.Handle;
|
|
}
|
|
}
|
|
}
|