forked from Bananymous/banan-os
Kernel: Rework filesystem reading
We now read from a filesystem to user provided buffer. Read sizes are determined by read call. You should now get file descriptors and do reading through Process::current()
This commit is contained in:
Bananymous
parent
ceb53533be
commit
1a26a318a4
|
|
@ -131,12 +131,13 @@ namespace Kernel
|
|||
|
||||
virtual BAN::StringView name() const override { return m_name; }
|
||||
|
||||
virtual BAN::ErrorOr<BAN::Vector<uint8_t>> read_all() override;
|
||||
virtual BAN::ErrorOr<size_t> read(size_t, void*, size_t) override;
|
||||
virtual BAN::ErrorOr<BAN::Vector<BAN::RefPtr<Inode>>> directory_inodes() override;
|
||||
virtual BAN::ErrorOr<BAN::RefPtr<Inode>> directory_find(BAN::StringView) override;
|
||||
|
||||
private:
|
||||
BAN::ErrorOr<void> for_each_block(BAN::Function<BAN::ErrorOr<bool>(const BAN::Vector<uint8_t>&)>&);
|
||||
using block_callback_t = BAN::ErrorOr<bool>(*)(const BAN::Vector<uint8_t>&, void*);
|
||||
BAN::ErrorOr<void> for_each_block(block_callback_t, void*);
|
||||
|
||||
private:
|
||||
Ext2Inode() {}
|
||||
|
|
|
|||
|
|
@ -36,6 +36,8 @@ namespace Kernel
|
|||
};
|
||||
|
||||
public:
|
||||
virtual ~Inode() {}
|
||||
|
||||
bool ifdir() const { return mode().IFDIR; }
|
||||
bool ifreg() const { return mode().IFREG; }
|
||||
|
||||
|
|
@ -47,7 +49,7 @@ namespace Kernel
|
|||
|
||||
virtual BAN::StringView name() const = 0;
|
||||
|
||||
virtual BAN::ErrorOr<BAN::Vector<uint8_t>> read_all() = 0;
|
||||
virtual BAN::ErrorOr<size_t> read(size_t, void*, size_t) = 0;
|
||||
virtual BAN::ErrorOr<BAN::Vector<BAN::RefPtr<Inode>>> directory_inodes() = 0;
|
||||
virtual BAN::ErrorOr<BAN::RefPtr<Inode>> directory_find(BAN::StringView) = 0;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -15,18 +15,21 @@ namespace Kernel
|
|||
static VirtualFileSystem& get();
|
||||
virtual ~VirtualFileSystem() {};
|
||||
|
||||
virtual const BAN::RefPtr<Inode> root_inode() const override;
|
||||
virtual const BAN::RefPtr<Inode> root_inode() const override { return m_root_inode; }
|
||||
|
||||
void close_inode(BAN::StringView);
|
||||
|
||||
BAN::ErrorOr<BAN::RefPtr<Inode>> from_absolute_path(BAN::StringView);
|
||||
struct File
|
||||
{
|
||||
BAN::RefPtr<Inode> inode;
|
||||
BAN::String canonical_path;
|
||||
};
|
||||
BAN::ErrorOr<File> file_from_absolute_path(BAN::StringView);
|
||||
|
||||
private:
|
||||
VirtualFileSystem() = default;
|
||||
BAN::ErrorOr<void> initialize_impl();
|
||||
|
||||
private:
|
||||
BAN::HashMap<BAN::String, BAN::RefPtr<Inode>> m_open_inodes;
|
||||
BAN::RefPtr<Inode> m_root_inode;
|
||||
BAN::Vector<StorageController*> m_storage_controllers;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,9 @@
|
|||
#pragma once
|
||||
|
||||
#include <BAN/String.h>
|
||||
#include <BAN/StringView.h>
|
||||
#include <BAN/Vector.h>
|
||||
#include <kernel/FS/Inode.h>
|
||||
#include <kernel/Thread.h>
|
||||
|
||||
namespace Kernel
|
||||
|
|
@ -24,12 +26,39 @@ namespace Kernel
|
|||
|
||||
pid_t pid() const { return m_pid; }
|
||||
|
||||
BAN::ErrorOr<int> open(BAN::StringView, int);
|
||||
BAN::ErrorOr<void> close(int);
|
||||
BAN::ErrorOr<size_t> read(int, void*, size_t);
|
||||
|
||||
BAN::StringView working_directory() const { return m_working_directory; }
|
||||
BAN::ErrorOr<void> set_working_directory(BAN::StringView);
|
||||
|
||||
Inode& inode_for_fd(int);
|
||||
|
||||
static BAN::RefPtr<Process> current() { return Thread::current()->process(); }
|
||||
|
||||
private:
|
||||
Process(pid_t pid) : m_pid(pid) {}
|
||||
|
||||
BAN::ErrorOr<BAN::String> absolute_path_of(BAN::StringView) const;
|
||||
|
||||
private:
|
||||
struct OpenFileDescription
|
||||
{
|
||||
BAN::RefPtr<Inode> inode;
|
||||
BAN::String path;
|
||||
size_t offset = 0;
|
||||
uint8_t flags = 0;
|
||||
|
||||
BAN::ErrorOr<size_t> read(void*, size_t);
|
||||
};
|
||||
|
||||
BAN::ErrorOr<void> validate_fd(int);
|
||||
OpenFileDescription& open_file_description(int);
|
||||
BAN::ErrorOr<int> get_free_fd();
|
||||
|
||||
BAN::Vector<OpenFileDescription> m_open_files;
|
||||
|
||||
pid_t m_pid = 0;
|
||||
BAN::String m_working_directory;
|
||||
BAN::Vector<BAN::RefPtr<Thread>> m_threads;
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ namespace Kernel
|
|||
public:
|
||||
Shell(TTY*);
|
||||
Shell(const Shell&) = delete;
|
||||
void set_prompt(BAN::StringView);
|
||||
BAN::ErrorOr<void> set_prompt(BAN::StringView);
|
||||
void run();
|
||||
|
||||
private:
|
||||
|
|
@ -21,11 +21,13 @@ namespace Kernel
|
|||
BAN::Vector<BAN::String> parse_arguments(BAN::StringView) const;
|
||||
BAN::ErrorOr<void> process_command(const BAN::Vector<BAN::String>&);
|
||||
void key_event_callback(Input::KeyEvent);
|
||||
BAN::ErrorOr<void> update_prompt();
|
||||
|
||||
private:
|
||||
TTY* m_tty;
|
||||
BAN::Vector<BAN::String> m_old_buffer;
|
||||
BAN::Vector<BAN::String> m_buffer;
|
||||
BAN::String m_prompt_string;
|
||||
BAN::String m_prompt;
|
||||
uint32_t m_prompt_length = 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -138,7 +138,7 @@ namespace Kernel
|
|||
|
||||
}
|
||||
|
||||
BAN::ErrorOr<void> Ext2Inode::for_each_block(BAN::Function<BAN::ErrorOr<bool>(const BAN::Vector<uint8_t>&)>& func)
|
||||
BAN::ErrorOr<void> Ext2Inode::for_each_block(block_callback_t callback, void* callback_data)
|
||||
{
|
||||
uint32_t data_blocks_left = m_inode.blocks / (2 << m_fs->superblock().log_block_size);
|
||||
uint32_t block_array_block_count = (1024 << m_fs->superblock().log_block_size) / sizeof(uint32_t);
|
||||
|
|
@ -150,7 +150,7 @@ namespace Kernel
|
|||
continue;
|
||||
|
||||
auto block_data = TRY(m_fs->read_block(m_inode.block[i]));
|
||||
if (!TRY(func(block_data)))
|
||||
if (!TRY(callback(block_data, callback_data)))
|
||||
return {};
|
||||
if (--data_blocks_left == 0)
|
||||
return {};
|
||||
|
|
@ -166,7 +166,7 @@ namespace Kernel
|
|||
if (block == 0)
|
||||
continue;
|
||||
auto block_data = TRY(m_fs->read_block(block));
|
||||
if (!TRY(func(block_data)))
|
||||
if (!TRY(callback(block_data, callback_data)))
|
||||
return {};
|
||||
if (--data_blocks_left == 0)
|
||||
return {};
|
||||
|
|
@ -187,7 +187,7 @@ namespace Kernel
|
|||
if (block == 0)
|
||||
continue;
|
||||
auto block_data = TRY(m_fs->read_block(block));
|
||||
if (!TRY(func(block_data)))
|
||||
if (!TRY(callback(block_data, callback_data)))
|
||||
return {};
|
||||
if (--data_blocks_left == 0)
|
||||
return {};
|
||||
|
|
@ -213,7 +213,7 @@ namespace Kernel
|
|||
if (block == 0)
|
||||
continue;
|
||||
auto block_data = TRY(m_fs->read_block(block));
|
||||
if (!TRY(func(block_data)))
|
||||
if (!TRY(callback(block_data, callback_data)))
|
||||
return {};
|
||||
if (--data_blocks_left == 0)
|
||||
return {};
|
||||
|
|
@ -225,32 +225,63 @@ namespace Kernel
|
|||
return BAN::Error::from_c_string("Inode did not contain enough blocks");
|
||||
}
|
||||
|
||||
BAN::ErrorOr<BAN::Vector<uint8_t>> Ext2Inode::read_all()
|
||||
BAN::ErrorOr<size_t> Ext2Inode::read(size_t offset, void* buffer, size_t count)
|
||||
{
|
||||
if (ifdir())
|
||||
return BAN::Error::from_errno(EISDIR);
|
||||
|
||||
BAN::Vector<uint8_t> data_buffer;
|
||||
TRY(data_buffer.resize(m_inode.size));
|
||||
|
||||
uint32_t bytes_done = 0;
|
||||
uint32_t bytes_left = m_inode.size;
|
||||
|
||||
BAN::Function<BAN::ErrorOr<bool>(const BAN::Vector<uint8_t>&)> read_func(
|
||||
[&](const BAN::Vector<uint8_t>& block_data)
|
||||
struct read_info
|
||||
{
|
||||
uint32_t to_copy = BAN::Math::min<uint32_t>(block_data.size(), bytes_left);
|
||||
memcpy(data_buffer.data() + bytes_done, block_data.data(), to_copy);
|
||||
bytes_done += to_copy;
|
||||
bytes_left -= to_copy;
|
||||
return bytes_left > 0;
|
||||
size_t file_current_offset;
|
||||
size_t file_start_offset;
|
||||
size_t file_bytes_left;
|
||||
uint8_t* out_byte_buffer;
|
||||
size_t out_bytes_read;
|
||||
size_t out_byte_buffer_size;
|
||||
};
|
||||
|
||||
read_info info;
|
||||
info.file_current_offset = 0;
|
||||
info.file_start_offset = offset;
|
||||
info.file_bytes_left = m_inode.size;
|
||||
info.out_byte_buffer = (uint8_t*)buffer;
|
||||
info.out_bytes_read = 0;
|
||||
info.out_byte_buffer_size = count;
|
||||
|
||||
block_callback_t read_func =
|
||||
[](const BAN::Vector<uint8_t>& block_data, void* info_) -> BAN::ErrorOr<bool>
|
||||
{
|
||||
read_info& info = *(read_info*)info_;
|
||||
|
||||
size_t block_size = BAN::Math::min<size_t>(block_data.size(), info.file_bytes_left);
|
||||
|
||||
// Skip blocks before 'offset'
|
||||
if (info.file_current_offset + block_size <= info.file_start_offset)
|
||||
{
|
||||
info.file_current_offset += block_size;
|
||||
info.file_bytes_left -= block_size;
|
||||
return info.file_bytes_left > 0;
|
||||
}
|
||||
);
|
||||
|
||||
TRY(for_each_block(read_func));
|
||||
ASSERT(bytes_left == 0);
|
||||
size_t read_offset = 0;
|
||||
if (info.file_current_offset < info.file_start_offset)
|
||||
read_offset = info.file_start_offset - info.file_current_offset;
|
||||
|
||||
return data_buffer;
|
||||
size_t to_read = BAN::Math::min<size_t>(block_size - read_offset, info.out_byte_buffer_size - info.out_bytes_read);
|
||||
memcpy(info.out_byte_buffer + info.out_bytes_read, block_data.data() + read_offset, to_read);
|
||||
|
||||
info.out_bytes_read += to_read;
|
||||
if (info.out_bytes_read >= info.out_byte_buffer_size)
|
||||
return false;
|
||||
|
||||
info.file_current_offset += block_size;
|
||||
info.file_bytes_left -= block_size;
|
||||
return info.file_bytes_left > 0;
|
||||
};
|
||||
|
||||
TRY(for_each_block(read_func, &info));
|
||||
|
||||
return info.out_bytes_read;
|
||||
}
|
||||
|
||||
BAN::ErrorOr<BAN::RefPtr<Inode>> Ext2Inode::directory_find(BAN::StringView file_name)
|
||||
|
|
@ -258,33 +289,45 @@ namespace Kernel
|
|||
if (!ifdir())
|
||||
return BAN::Error::from_errno(ENOTDIR);
|
||||
|
||||
BAN::RefPtr<Inode> result;
|
||||
BAN::Function<BAN::ErrorOr<bool>(const BAN::Vector<uint8_t>&)> function(
|
||||
[&](const BAN::Vector<uint8_t>& block_data) -> BAN::ErrorOr<bool>
|
||||
struct search_info
|
||||
{
|
||||
BAN::StringView file_name;
|
||||
BAN::RefPtr<Inode> result;
|
||||
Ext2FS* fs;
|
||||
};
|
||||
|
||||
search_info info;
|
||||
info.file_name = file_name;
|
||||
info.result = {};
|
||||
info.fs = m_fs;
|
||||
|
||||
block_callback_t function =
|
||||
[](const BAN::Vector<uint8_t>& block_data, void* info_) -> BAN::ErrorOr<bool>
|
||||
{
|
||||
search_info& info = *(search_info*)info_;
|
||||
|
||||
uintptr_t block_data_end = (uintptr_t)block_data.data() + block_data.size();
|
||||
uintptr_t entry_addr = (uintptr_t)block_data.data();
|
||||
while (entry_addr < block_data_end)
|
||||
{
|
||||
Ext2::LinkedDirectoryEntry* entry = (Ext2::LinkedDirectoryEntry*)entry_addr;
|
||||
BAN::StringView entry_name = BAN::StringView(entry->name, entry->name_len);
|
||||
if (entry->inode && file_name == entry_name)
|
||||
if (entry->inode && info.file_name == entry_name)
|
||||
{
|
||||
Ext2Inode* inode = new Ext2Inode(m_fs, TRY(m_fs->read_inode(entry->inode)), entry_name);
|
||||
Ext2Inode* inode = new Ext2Inode(info.fs, TRY(info.fs->read_inode(entry->inode)), entry_name);
|
||||
if (inode == nullptr)
|
||||
return BAN::Error::from_errno(ENOMEM);
|
||||
result = BAN::RefPtr<Inode>::adopt(inode);
|
||||
info.result = BAN::RefPtr<Inode>::adopt(inode);
|
||||
return false;
|
||||
}
|
||||
entry_addr += entry->rec_len;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
TRY(for_each_block(function));
|
||||
if (result)
|
||||
return result;
|
||||
TRY(for_each_block(function, &info));
|
||||
if (info.result)
|
||||
return info.result;
|
||||
return BAN::Error::from_errno(ENOENT);
|
||||
}
|
||||
|
||||
|
|
@ -293,10 +336,21 @@ namespace Kernel
|
|||
if (!ifdir())
|
||||
return BAN::Error::from_errno(ENOTDIR);
|
||||
|
||||
BAN::Vector<BAN::RefPtr<Inode>> inodes;
|
||||
BAN::Function<BAN::ErrorOr<bool>(const BAN::Vector<uint8_t>&)> function(
|
||||
[&](const BAN::Vector<uint8_t>& block_data) -> BAN::ErrorOr<bool>
|
||||
struct directory_info
|
||||
{
|
||||
BAN::Vector<BAN::RefPtr<Inode>> inodes;
|
||||
Ext2FS* fs;
|
||||
};
|
||||
|
||||
directory_info info;
|
||||
info.inodes = {};
|
||||
info.fs = m_fs;
|
||||
|
||||
block_callback_t function =
|
||||
[](const BAN::Vector<uint8_t>& block_data, void* info_) -> BAN::ErrorOr<bool>
|
||||
{
|
||||
directory_info& info = *(directory_info*)info_;
|
||||
|
||||
uintptr_t block_data_end = (uintptr_t)block_data.data() + block_data.size();
|
||||
uintptr_t entry_addr = (uintptr_t)block_data.data();
|
||||
while (entry_addr < block_data_end)
|
||||
|
|
@ -305,22 +359,21 @@ namespace Kernel
|
|||
if (entry->inode)
|
||||
{
|
||||
BAN::StringView entry_name = BAN::StringView(entry->name, entry->name_len);
|
||||
Ext2::Inode current_inode = TRY(m_fs->read_inode(entry->inode));
|
||||
Ext2::Inode current_inode = TRY(info.fs->read_inode(entry->inode));
|
||||
|
||||
Ext2Inode* inode = new Ext2Inode(m_fs, BAN::move(current_inode), entry_name);
|
||||
Ext2Inode* inode = new Ext2Inode(info.fs, BAN::move(current_inode), entry_name);
|
||||
if (inode == nullptr)
|
||||
return BAN::Error::from_errno(ENOMEM);
|
||||
TRY(inodes.push_back(BAN::RefPtr<Inode>::adopt(inode)));
|
||||
TRY(info.inodes.push_back(BAN::RefPtr<Inode>::adopt(inode)));
|
||||
}
|
||||
entry_addr += entry->rec_len;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
TRY(for_each_block(function));
|
||||
TRY(for_each_block(function, &info));
|
||||
|
||||
return inodes;
|
||||
return info.inodes;
|
||||
}
|
||||
|
||||
BAN::ErrorOr<Ext2FS*> Ext2FS::create(StorageDevice::Partition& partition)
|
||||
|
|
|
|||
|
|
@ -103,7 +103,7 @@ namespace Kernel
|
|||
else
|
||||
// FIXME: We leave a dangling pointer to ext2fs. This might be okay since
|
||||
// root fs sould probably be always mounted
|
||||
TRY(m_open_inodes.insert("/"sv, ext2fs_or_error.release_value()->root_inode()));
|
||||
m_root_inode = ext2fs_or_error.value()->root_inode();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -115,40 +115,52 @@ namespace Kernel
|
|||
return {};
|
||||
}
|
||||
|
||||
const BAN::RefPtr<Inode> VirtualFileSystem::root_inode() const
|
||||
{
|
||||
if (!m_open_inodes.contains("/"sv))
|
||||
return nullptr;
|
||||
return m_open_inodes["/"sv];
|
||||
}
|
||||
|
||||
void VirtualFileSystem::close_inode(BAN::StringView path)
|
||||
{
|
||||
ASSERT(m_open_inodes.contains(path));
|
||||
|
||||
// Delete the cached inode, if we are the only one holding a reference to it
|
||||
if (m_open_inodes[path]->ref_count() == 1)
|
||||
m_open_inodes.remove(path);
|
||||
}
|
||||
|
||||
BAN::ErrorOr<BAN::RefPtr<Inode>> VirtualFileSystem::from_absolute_path(BAN::StringView path)
|
||||
BAN::ErrorOr<VirtualFileSystem::File> VirtualFileSystem::file_from_absolute_path(BAN::StringView path)
|
||||
{
|
||||
ASSERT(path.front() == '/');
|
||||
|
||||
if (m_open_inodes.contains(path))
|
||||
return m_open_inodes[path];
|
||||
|
||||
auto inode = root_inode();
|
||||
if (!inode)
|
||||
return BAN::Error::from_c_string("No root inode available");
|
||||
|
||||
auto path_parts = TRY(path.split('/'));
|
||||
for (BAN::StringView part : path_parts)
|
||||
inode = TRY(inode->directory_find(part));
|
||||
|
||||
TRY(m_open_inodes.insert(path, inode));
|
||||
for (size_t i = 0; i < path_parts.size();)
|
||||
{
|
||||
if (path_parts[i] == "."sv)
|
||||
{
|
||||
path_parts.remove(i);
|
||||
}
|
||||
else if (path_parts[i] == ".."sv)
|
||||
{
|
||||
inode = TRY(inode->directory_find(path_parts[i]));
|
||||
path_parts.remove(i);
|
||||
if (i > 0)
|
||||
{
|
||||
path_parts.remove(i - 1);
|
||||
i--;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
inode = TRY(inode->directory_find(path_parts[i]));
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
return inode;
|
||||
File file;
|
||||
file.inode = inode;
|
||||
|
||||
for (const auto& part : path_parts)
|
||||
{
|
||||
TRY(file.canonical_path.push_back('/'));
|
||||
TRY(file.canonical_path.append(part));
|
||||
}
|
||||
|
||||
if (file.canonical_path.empty())
|
||||
TRY(file.canonical_path.push_back('/'));
|
||||
|
||||
return file;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,6 +1,9 @@
|
|||
#include <BAN/UTF8.h>
|
||||
#include <BAN/ScopeGuard.h>
|
||||
#include <kernel/Font.h>
|
||||
#include <kernel/FS/VirtualFileSystem.h>
|
||||
#include <kernel/Process.h>
|
||||
|
||||
#include <fcntl.h>
|
||||
|
||||
#define PSF1_MODE_512 0x01
|
||||
#define PSF1_MODE_HASTAB 0x02
|
||||
|
|
@ -25,9 +28,13 @@ namespace Kernel
|
|||
|
||||
BAN::ErrorOr<Font> Font::load(BAN::StringView path)
|
||||
{
|
||||
auto inode = TRY(VirtualFileSystem::get().from_absolute_path(path));
|
||||
int fd = TRY(Process::current()->open(path, O_RDONLY));
|
||||
BAN::ScopeGuard _([fd] { MUST(Process::current()->close(fd)); });
|
||||
|
||||
auto file_data = TRY(inode->read_all());
|
||||
size_t file_size = Process::current()->inode_for_fd(fd).size();
|
||||
BAN::Vector<uint8_t> file_data;
|
||||
TRY(file_data.resize(file_size));
|
||||
TRY(Process::current()->read(fd, file_data.data(), file_size));
|
||||
|
||||
if (file_data.size() < 4)
|
||||
return BAN::Error::from_c_string("Font file is too small");
|
||||
|
|
|
|||
|
|
@ -1,6 +1,9 @@
|
|||
#include <BAN/StringView.h>
|
||||
#include <kernel/Process.h>
|
||||
#include <kernel/Scheduler.h>
|
||||
#include <kernel/FS/VirtualFileSystem.h>
|
||||
|
||||
#include <fcntl.h>
|
||||
|
||||
namespace Kernel
|
||||
{
|
||||
|
|
@ -9,8 +12,8 @@ namespace Kernel
|
|||
{
|
||||
static pid_t next_pid = 1;
|
||||
auto process = TRY(BAN::RefPtr<Process>::create(next_pid++));
|
||||
TRY(process->m_working_directory.push_back('/'));
|
||||
TRY(process->add_thread(entry, data));
|
||||
TRY(process->m_working_directory.append("/"sv));
|
||||
return process;
|
||||
}
|
||||
|
||||
|
|
@ -24,14 +27,112 @@ namespace Kernel
|
|||
return res;
|
||||
}
|
||||
|
||||
dprintln("add thread {} to process {}", thread->tid(), pid());
|
||||
|
||||
return {};
|
||||
}
|
||||
|
||||
void Process::on_thread_exit(Thread& thread)
|
||||
{
|
||||
dprintln("thread {} exited from process", thread.tid(), pid());
|
||||
(void)thread;
|
||||
}
|
||||
|
||||
BAN::ErrorOr<int> Process::open(BAN::StringView path, int flags)
|
||||
{
|
||||
if (flags != O_RDONLY)
|
||||
return BAN::Error::from_errno(ENOTSUP);
|
||||
|
||||
BAN::String absolute_path = TRY(absolute_path_of(path));
|
||||
|
||||
auto file = TRY(VirtualFileSystem::get().file_from_absolute_path(absolute_path));
|
||||
|
||||
int fd = TRY(get_free_fd());
|
||||
auto& open_file_description = m_open_files[fd];
|
||||
open_file_description.inode = file.inode;
|
||||
open_file_description.path = BAN::move(file.canonical_path);
|
||||
open_file_description.offset = 0;
|
||||
open_file_description.flags = flags;
|
||||
|
||||
return fd;
|
||||
}
|
||||
|
||||
BAN::ErrorOr<void> Process::close(int fd)
|
||||
{
|
||||
TRY(validate_fd(fd));
|
||||
auto& open_file_description = this->open_file_description(fd);
|
||||
open_file_description.inode = nullptr;
|
||||
return {};
|
||||
}
|
||||
|
||||
BAN::ErrorOr<size_t> Process::read(int fd, void* buffer, size_t count)
|
||||
{
|
||||
TRY(validate_fd(fd));
|
||||
auto& open_file_description = this->open_file_description(fd);
|
||||
if (open_file_description.offset >= open_file_description.inode->size())
|
||||
return 0;
|
||||
size_t n_read = TRY(open_file_description.read(buffer, count));
|
||||
return n_read;
|
||||
}
|
||||
|
||||
Inode& Process::inode_for_fd(int fd)
|
||||
{
|
||||
MUST(validate_fd(fd));
|
||||
return *open_file_description(fd).inode;
|
||||
}
|
||||
|
||||
BAN::ErrorOr<void> Process::set_working_directory(BAN::StringView path)
|
||||
{
|
||||
BAN::String absolute_path = TRY(absolute_path_of(path));
|
||||
|
||||
auto file = TRY(VirtualFileSystem::get().file_from_absolute_path(absolute_path));
|
||||
if (!file.inode->ifdir())
|
||||
return BAN::Error::from_errno(ENOTDIR);
|
||||
|
||||
m_working_directory = BAN::move(file.canonical_path);
|
||||
|
||||
return {};
|
||||
}
|
||||
|
||||
BAN::ErrorOr<BAN::String> Process::absolute_path_of(BAN::StringView path) const
|
||||
{
|
||||
if (path.empty())
|
||||
return m_working_directory;
|
||||
BAN::String absolute_path;
|
||||
if (path.front() != '/')
|
||||
{
|
||||
TRY(absolute_path.append(m_working_directory));
|
||||
if (m_working_directory.sv().back() != '/')
|
||||
TRY(absolute_path.push_back('/'));
|
||||
}
|
||||
TRY(absolute_path.append(path));
|
||||
return absolute_path;
|
||||
}
|
||||
|
||||
BAN::ErrorOr<size_t> Process::OpenFileDescription::read(void* buffer, size_t count)
|
||||
{
|
||||
size_t n_read = TRY(inode->read(offset, buffer, count));
|
||||
offset += n_read;
|
||||
return n_read;
|
||||
}
|
||||
|
||||
BAN::ErrorOr<void> Process::validate_fd(int fd)
|
||||
{
|
||||
if (fd < 0 || m_open_files.size() <= (size_t)fd || !m_open_files[fd].inode)
|
||||
return BAN::Error::from_errno(EBADF);
|
||||
return {};
|
||||
}
|
||||
|
||||
Process::OpenFileDescription& Process::open_file_description(int fd)
|
||||
{
|
||||
MUST(validate_fd(fd));
|
||||
return m_open_files[fd];
|
||||
}
|
||||
|
||||
BAN::ErrorOr<int> Process::get_free_fd()
|
||||
{
|
||||
for (size_t fd = 0; fd < m_open_files.size(); fd++)
|
||||
if (!m_open_files[fd].inode)
|
||||
return fd;
|
||||
TRY(m_open_files.push_back({}));
|
||||
return m_open_files.size() - 1;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,16 +1,17 @@
|
|||
#include <BAN/Math.h>
|
||||
#include <BAN/ScopeGuard.h>
|
||||
#include <BAN/StringView.h>
|
||||
#include <BAN/Vector.h>
|
||||
#include <kernel/CPUID.h>
|
||||
#include <kernel/Input.h>
|
||||
#include <kernel/IO.h>
|
||||
#include <kernel/PIT.h>
|
||||
#include <kernel/PCI.h>
|
||||
#include <kernel/Process.h>
|
||||
#include <kernel/RTC.h>
|
||||
#include <kernel/Shell.h>
|
||||
|
||||
#include <kernel/FS/VirtualFileSystem.h>
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#define TTY_PRINT(...) Formatter::print([this](char c) { m_tty->putchar(c); }, __VA_ARGS__)
|
||||
|
|
@ -20,38 +21,62 @@ namespace Kernel
|
|||
{
|
||||
using namespace BAN;
|
||||
|
||||
static auto s_default_prompt = "\\[\e[32m\\]user\\[\e[m\\]# "sv;
|
||||
static auto s_default_prompt = "\\[\e[32m\\]user\\[\e[m\\]:\\[\e[34m\\]\\w\\[\e[m\\]# "sv;
|
||||
|
||||
Shell::Shell(TTY* tty)
|
||||
: m_tty(tty)
|
||||
{
|
||||
Input::register_key_event_callback({ &Shell::key_event_callback, this });
|
||||
set_prompt(s_default_prompt);
|
||||
MUST(set_prompt(s_default_prompt));
|
||||
MUST(m_buffer.push_back(""sv));
|
||||
}
|
||||
|
||||
void Shell::set_prompt(StringView prompt)
|
||||
BAN::ErrorOr<void> Shell::set_prompt(StringView prompt)
|
||||
{
|
||||
m_prompt_string = prompt;
|
||||
TRY(update_prompt());
|
||||
return {};
|
||||
}
|
||||
|
||||
BAN::ErrorOr<void> Shell::update_prompt()
|
||||
{
|
||||
m_prompt_length = 0;
|
||||
m_prompt = String();
|
||||
|
||||
bool skipping = false;
|
||||
for (size_t i = 0; i < prompt.size(); i++)
|
||||
for (size_t i = 0; i < m_prompt_string.size(); i++)
|
||||
{
|
||||
if (i < prompt.size() - 1 && prompt[i] == '\\')
|
||||
if (i < m_prompt_string.size() - 1 && m_prompt_string[i] == '\\')
|
||||
{
|
||||
if (prompt[i + 1] == '[')
|
||||
switch (m_prompt_string[i + 1])
|
||||
{
|
||||
case '[':
|
||||
skipping = true;
|
||||
if (prompt[i + 1] == ']')
|
||||
break;
|
||||
case ']':
|
||||
skipping = false;
|
||||
break;
|
||||
case 'w':
|
||||
{
|
||||
auto working_directory = Process::current()->working_directory();
|
||||
TRY(m_prompt.append(working_directory));
|
||||
m_prompt_length += working_directory.size();
|
||||
break;
|
||||
}
|
||||
default:
|
||||
dprintln("unknown escape character '{}' in shell prompt", m_prompt_string[i + 1]);
|
||||
break;
|
||||
}
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
|
||||
MUST(m_prompt.push_back(prompt[i]));
|
||||
TRY(m_prompt.push_back(m_prompt_string[i]));
|
||||
if (!skipping)
|
||||
m_prompt_length++;
|
||||
}
|
||||
|
||||
return {};
|
||||
}
|
||||
|
||||
void Shell::run()
|
||||
|
|
@ -276,12 +301,13 @@ argument_done:
|
|||
if (arguments.size() > 2)
|
||||
return BAN::Error::from_c_string("usage: 'ls [path]'");
|
||||
|
||||
BAN::StringView path = (arguments.size() == 2) ? arguments[1].sv() : "/";
|
||||
if (path.front() != '/')
|
||||
return BAN::Error::from_c_string("ls currently works only with absolute paths");
|
||||
BAN::StringView path = (arguments.size() == 2) ? arguments[1].sv() : Process::current()->working_directory();
|
||||
|
||||
auto directory = TRY(VirtualFileSystem::get().from_absolute_path(path));
|
||||
auto inodes = TRY(directory->directory_inodes());
|
||||
int fd = TRY(Process::current()->open(path, O_RDONLY));
|
||||
BAN::ScopeGuard _([fd] { MUST(Process::current()->close(fd)); });
|
||||
|
||||
auto& directory = Process::current()->inode_for_fd(fd);
|
||||
auto inodes = TRY(directory.directory_inodes());
|
||||
|
||||
auto mode_string = [](Inode::Mode mode)
|
||||
{
|
||||
|
|
@ -299,7 +325,6 @@ argument_done:
|
|||
return (const char*)buffer;
|
||||
};
|
||||
|
||||
TTY_PRINTLN("{}", path);
|
||||
for (auto& inode : inodes)
|
||||
if (inode->ifdir())
|
||||
TTY_PRINTLN(" {} {7} \e[34m{}\e[m", mode_string(inode->mode()), inode->size(), inode->name());
|
||||
|
|
@ -312,9 +337,26 @@ argument_done:
|
|||
if (arguments.size() != 2)
|
||||
return BAN::Error::from_c_string("usage: 'cat path'");
|
||||
|
||||
auto file = TRY(VirtualFileSystem::get().from_absolute_path(arguments[1]));
|
||||
auto data = TRY(file->read_all());
|
||||
TTY_PRINTLN("{}", BAN::StringView((const char*)data.data(), data.size()));
|
||||
int fd = TRY(Process::current()->open(arguments[1], O_RDONLY));
|
||||
BAN::ScopeGuard _([fd] { MUST(Process::current()->close(fd)); });
|
||||
|
||||
char buffer[1024] {};
|
||||
while (true)
|
||||
{
|
||||
size_t n_read = TRY(Process::current()->read(fd, buffer, sizeof(buffer)));
|
||||
if (n_read == 0)
|
||||
break;
|
||||
TTY_PRINT("{}", BAN::StringView(buffer, n_read));
|
||||
}
|
||||
TTY_PRINTLN("");
|
||||
}
|
||||
else if (arguments.front() == "cd")
|
||||
{
|
||||
if (arguments.size() > 2)
|
||||
return BAN::Error::from_c_string("usage 'cd path'");
|
||||
BAN::StringView path = arguments.size() == 2 ? arguments[1].sv() : "/"sv;
|
||||
TRY(Process::current()->set_working_directory(path));
|
||||
TRY(update_prompt());
|
||||
}
|
||||
else if (arguments.front() == "loadfont")
|
||||
{
|
||||
|
|
|
|||
|
|
@ -196,12 +196,6 @@ void init2(void* tty1_ptr)
|
|||
|
||||
MUST(VirtualFileSystem::initialize());
|
||||
|
||||
auto font_or_error = Font::load("/usr/share/fonts/zap-ext-vga16.psf");
|
||||
if (font_or_error.is_error())
|
||||
dprintln("{}", font_or_error.error());
|
||||
else
|
||||
tty1->set_font(font_or_error.release_value());
|
||||
|
||||
MUST(Process::create_kernel(
|
||||
[](void* tty1)
|
||||
{
|
||||
|
|
|
|||
Loading…
Reference in New Issue