RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 03:07:44 +00:00
Code Issues Activity Actions

Kernel: Simplify ProcFS callbacks by using function pointers directly

Browse source
This commit is contained in:
Tom 2020-09-18 17:06:28 -06:00 • committed by Andreas Kling
parent 31e7f73aae
commit ba238ac62a
2 changed files with 19 additions and 25 deletions
Download patch file Download diff file Expand all files Collapse all files

34
Kernel/FileSystem/ProcFS.cpp
View file

@ -961,7 +961,7 @@ SysVariable& SysVariable::for_inode(InodeIdentifier id)
return variable; return variable;
} }
static ByteBuffer read_sys_bool(InodeIdentifier inode_id) static Optional<KBuffer> read_sys_bool(InodeIdentifier inode_id)
{ {
auto& variable = SysVariable::for_inode(inode_id); auto& variable = SysVariable::for_inode(inode_id);
ASSERT(variable.type == SysVariable::Type::Boolean); ASSERT(variable.type == SysVariable::Type::Boolean);
@ -1005,7 +1005,7 @@ static ssize_t write_sys_bool(InodeIdentifier inode_id, const UserOrKernelBuffer
return (ssize_t)size; return (ssize_t)size;
} }
static ByteBuffer read_sys_string(InodeIdentifier inode_id) static Optional<KBuffer> read_sys_string(InodeIdentifier inode_id)
{ {
auto& variable = SysVariable::for_inode(inode_id); auto& variable = SysVariable::for_inode(inode_id);
ASSERT(variable.type == SysVariable::Type::String); ASSERT(variable.type == SysVariable::Type::String);
@ -1206,32 +1206,28 @@ ssize_t ProcFSInode::read_bytes(off_t offset, ssize_t count, UserOrKernelBuffer&
auto* directory_entry = fs().get_directory_entry(identifier()); auto* directory_entry = fs().get_directory_entry(identifier());
Function<Optional<KBuffer>(InodeIdentifier)> callback_tmp; Optional<KBuffer>(*read_callback)(InodeIdentifier) = nullptr;
Function<Optional<KBuffer>(InodeIdentifier)>* read_callback { nullptr };
if (directory_entry) if (directory_entry)
read_callback = &directory_entry->read_callback; read_callback = directory_entry->read_callback;
else else
switch (to_proc_parent_directory(identifier())) { switch (to_proc_parent_directory(identifier())) {
case PDI_PID_fd: case PDI_PID_fd:
callback_tmp = procfs$pid_fd_entry; read_callback = procfs$pid_fd_entry;
read_callback = &callback_tmp;
break; break;
case PDI_PID_stacks: case PDI_PID_stacks:
callback_tmp = procfs$tid_stack; read_callback = procfs$tid_stack;
read_callback = &callback_tmp;
break; break;
case PDI_Root_sys: case PDI_Root_sys:
switch (SysVariable::for_inode(identifier()).type) { switch (SysVariable::for_inode(identifier()).type) {
case SysVariable::Type::Invalid: case SysVariable::Type::Invalid:
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
case SysVariable::Type::Boolean: case SysVariable::Type::Boolean:
callback_tmp = read_sys_bool; read_callback = read_sys_bool;
break; break;
case SysVariable::Type::String: case SysVariable::Type::String:
callback_tmp = read_sys_string; read_callback = read_sys_string;
break; break;
} }
read_callback = &callback_tmp;
break; break;
default: default:
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
@ -1241,7 +1237,7 @@ ssize_t ProcFSInode::read_bytes(off_t offset, ssize_t count, UserOrKernelBuffer&
Optional<KBuffer> generated_data; Optional<KBuffer> generated_data;
if (!description) { if (!description) {
generated_data = (*read_callback)(identifier()); generated_data = read_callback(identifier());
} else { } else {
if (!description->generator_cache().has_value()) if (!description->generator_cache().has_value())
description->generator_cache() = (*read_callback)(identifier()); description->generator_cache() = (*read_callback)(identifier());
@ -1486,8 +1482,7 @@ ssize_t ProcFSInode::write_bytes(off_t offset, ssize_t size, const UserOrKernelB
auto* directory_entry = fs().get_directory_entry(identifier()); auto* directory_entry = fs().get_directory_entry(identifier());
Function<ssize_t(InodeIdentifier, const UserOrKernelBuffer&, size_t)> callback_tmp; ssize_t(*write_callback)(InodeIdentifier, const UserOrKernelBuffer&, size_t) = nullptr;
Function<ssize_t(InodeIdentifier, const UserOrKernelBuffer&, size_t)>* write_callback { nullptr };
if (directory_entry == nullptr) { if (directory_entry == nullptr) {
if (to_proc_parent_directory(identifier()) == PDI_Root_sys) { if (to_proc_parent_directory(identifier()) == PDI_Root_sys) {
@ -1495,25 +1490,24 @@ ssize_t ProcFSInode::write_bytes(off_t offset, ssize_t size, const UserOrKernelB
case SysVariable::Type::Invalid: case SysVariable::Type::Invalid:
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
case SysVariable::Type::Boolean: case SysVariable::Type::Boolean:
callback_tmp = write_sys_bool; write_callback = write_sys_bool;
break; break;
case SysVariable::Type::String: case SysVariable::Type::String:
callback_tmp = write_sys_string; write_callback = write_sys_string;
break; break;
} }
write_callback = &callback_tmp;
} else } else
return -EPERM; return -EPERM;
} else { } else {
if (!directory_entry->write_callback) if (!directory_entry->write_callback)
return -EPERM; return -EPERM;
write_callback = &directory_entry->write_callback; write_callback = directory_entry->write_callback;
} }
ASSERT(is_persistent_inode(identifier())); ASSERT(is_persistent_inode(identifier()));
// FIXME: Being able to write into ProcFS at a non-zero offset seems like something we should maybe support.. // FIXME: Being able to write into ProcFS at a non-zero offset seems like something we should maybe support..
ASSERT(offset == 0); ASSERT(offset == 0);
ssize_t nwritten = (*write_callback)(identifier(), buffer, (size_t)size); ssize_t nwritten = write_callback(identifier(), buffer, (size_t)size);
if (nwritten < 0) if (nwritten < 0)
klog() << "ProcFS: Writing " << size << " bytes failed: " << nwritten; klog() << "ProcFS: Writing " << size << " bytes failed: " << nwritten;
return nwritten; return nwritten;

10
Kernel/FileSystem/ProcFS.h
View file

@ -59,12 +59,12 @@ private:
struct ProcFSDirectoryEntry { struct ProcFSDirectoryEntry {
ProcFSDirectoryEntry() { } ProcFSDirectoryEntry() { }
ProcFSDirectoryEntry(const char* a_name, unsigned a_proc_file_type, bool a_supervisor_only, Function<Optional<KBuffer>(InodeIdentifier)>&& a_read_callback = nullptr, Function<ssize_t(InodeIdentifier, const UserOrKernelBuffer&, size_t)>&& a_write_callback = nullptr, RefPtr<ProcFSInode>&& a_inode = nullptr) ProcFSDirectoryEntry(const char* a_name, unsigned a_proc_file_type, bool a_supervisor_only, Optional<KBuffer>(*read_callback)(InodeIdentifier) = nullptr, ssize_t(*write_callback)(InodeIdentifier, const UserOrKernelBuffer&, size_t) = nullptr, RefPtr<ProcFSInode>&& a_inode = nullptr)
: name(a_name) : name(a_name)
, proc_file_type(a_proc_file_type) , proc_file_type(a_proc_file_type)
, supervisor_only(a_supervisor_only) , supervisor_only(a_supervisor_only)
, read_callback(move(a_read_callback)) , read_callback(read_callback)
, write_callback(move(a_write_callback)) , write_callback(write_callback)
, inode(move(a_inode)) , inode(move(a_inode))
{ {
} }
@ -72,8 +72,8 @@ private:
const char* name { nullptr }; const char* name { nullptr };
unsigned proc_file_type { 0 }; unsigned proc_file_type { 0 };
bool supervisor_only { false }; bool supervisor_only { false };
Function<Optional<KBuffer>(InodeIdentifier)> read_callback; Optional<KBuffer>(*read_callback)(InodeIdentifier);
Function<ssize_t(InodeIdentifier, const UserOrKernelBuffer&, size_t)> write_callback; ssize_t(*write_callback)(InodeIdentifier, const UserOrKernelBuffer&, size_t);
RefPtr<ProcFSInode> inode; RefPtr<ProcFSInode> inode;
InodeIdentifier identifier(unsigned fsid) const; InodeIdentifier identifier(unsigned fsid) const;
}; };