1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 19:37:35 +00:00

Kernel/aarch64: Unify building kernel source files in CMakeLists.txt

This now builds most of the kernel source files for both x86(_64) and
the aarch64 build. Also remove a bunch of stubbed functions. :^)
This commit is contained in:
Timon Kruiper 2022-10-25 18:55:42 +02:00 committed by Gunnar Beutner
parent f661f1a674
commit 8364135939
2 changed files with 73 additions and 531 deletions

View file

@ -7,22 +7,10 @@
#include <AK/Singleton.h>
#include <AK/Types.h>
#include <Kernel/Coredump.h>
#include <Kernel/FileSystem/Inode.h>
#include <Kernel/FileSystem/ProcFS.h>
#include <Kernel/KString.h>
#include <Kernel/Locking/SpinlockProtected.h>
#include <Kernel/Memory/SharedInodeVMObject.h>
#include <Kernel/Panic.h>
#include <Kernel/PhysicalAddress.h>
#include <Kernel/Arch/Delay.h>
#include <Kernel/Process.h>
#include <Kernel/ProcessExposed.h>
#include <Kernel/Scheduler.h>
#include <Kernel/Sections.h>
#include <Kernel/TTY/TTY.h>
#include <Kernel/ThreadTracer.h>
#include <Kernel/TimerQueue.h>
#include <Kernel/UserOrKernelBuffer.h>
#include <Kernel/kstdio.h>
// Process
char const* asm_signal_trampoline = nullptr;
@ -44,430 +32,40 @@ ErrorOr<void> Process::exec(NonnullOwnPtr<KString>, NonnullOwnPtrVector<KString>
}
// OpenFileDescription
// Delay.cpp
namespace Kernel {
OpenFileDescription::~OpenFileDescription()
{
TODO_AARCH64();
}
ErrorOr<size_t> OpenFileDescription::write(UserOrKernelBuffer const&, size_t)
{
TODO_AARCH64();
}
}
// Custody
namespace Kernel {
SpinlockProtected<Custody::AllCustodiesList>& Custody::all_instances()
{
TODO_AARCH64();
}
Custody::~Custody()
{
TODO_AARCH64();
}
}
// VirtualFileSystem
namespace Kernel {
VirtualFileSystem& VirtualFileSystem::the()
{
TODO_AARCH64();
}
NonnullRefPtr<Custody> VirtualFileSystem::root_custody()
{
TODO_AARCH64();
}
ErrorOr<NonnullLockRefPtr<OpenFileDescription>> VirtualFileSystem::open(Credentials const&, StringView, int, mode_t, Custody&, Optional<UidAndGid>)
{
TODO_AARCH64();
}
}
// ProcFS
namespace Kernel {
ProcFSInode::~ProcFSInode()
{
TODO_AARCH64();
}
ErrorOr<NonnullLockRefPtr<ProcFSProcessDirectoryInode>> ProcFSProcessDirectoryInode::try_create(ProcFS const&, ProcessID)
{
TODO_AARCH64();
}
ProcFSComponentRegistry& ProcFSComponentRegistry::the()
{
TODO_AARCH64();
}
ErrorOr<NonnullLockRefPtr<Inode>> ProcFSInode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
{
TODO_AARCH64();
}
ErrorOr<void> ProcFSInode::add_child(Inode&, StringView, mode_t)
{
TODO_AARCH64();
}
ErrorOr<void> ProcFSInode::remove_child(StringView)
{
TODO_AARCH64();
}
ErrorOr<void> ProcFSInode::chmod(mode_t)
{
TODO_AARCH64();
}
ErrorOr<void> ProcFSInode::chown(UserID, GroupID)
{
TODO_AARCH64();
}
ErrorOr<void> ProcFSInode::flush_metadata()
{
TODO_AARCH64();
}
ErrorOr<void> ProcFSGlobalInode::attach(OpenFileDescription&)
{
TODO_AARCH64();
}
ErrorOr<size_t> ProcFSGlobalInode::read_bytes_locked(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
{
TODO_AARCH64();
}
StringView ProcFSGlobalInode::name() const
{
TODO_AARCH64();
}
ErrorOr<void> ProcFSGlobalInode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const
{
TODO_AARCH64();
}
ErrorOr<NonnullLockRefPtr<Inode>> ProcFSGlobalInode::lookup(StringView)
{
TODO_AARCH64();
}
ErrorOr<void> ProcFSGlobalInode::truncate(u64)
{
TODO_AARCH64();
}
ErrorOr<void> ProcFSGlobalInode::update_timestamps(Optional<time_t>, Optional<time_t>, Optional<time_t>)
{
TODO_AARCH64();
}
InodeMetadata ProcFSGlobalInode::metadata() const
{
TODO_AARCH64();
}
void ProcFSGlobalInode::did_seek(OpenFileDescription&, off_t)
{
TODO_AARCH64();
}
ErrorOr<size_t> ProcFSGlobalInode::write_bytes_locked(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*)
{
TODO_AARCH64();
}
}
// ProcessGroup
namespace Kernel {
ProcessGroup::~ProcessGroup()
void microseconds_delay(u32)
{
TODO_AARCH64();
}
}
// ProcessExposed
namespace Kernel {
// Initializer.cpp
namespace Kernel::PCI {
ErrorOr<NonnullLockRefPtr<Inode>> ProcFSExposedComponent::to_inode(ProcFS const&) const
{
TODO_AARCH64();
}
bool g_pci_access_io_probe_failed { false };
bool g_pci_access_is_disabled_from_commandline { false };
InodeIndex SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(ProcessID, SegmentedProcFSIndex::MainProcessProperty)
{
TODO_AARCH64();
}
InodeIndex SegmentedProcFSIndex::build_segmented_index_for_pid_directory(ProcessID)
// kprintf.cpp
void dbgputstr(StringView)
{
TODO_AARCH64();
}
InodeIndex SegmentedProcFSIndex::build_segmented_index_for_sub_directory(ProcessID, ProcessSubDirectory)
void dbgputstr(char const*, size_t)
{
TODO_AARCH64();
}
ProcFSExposedComponent::ProcFSExposedComponent()
void dbgputchar(char)
{
TODO_AARCH64();
}
}
// FileSystem
namespace Kernel {
FileSystem::DirectoryEntryView::DirectoryEntryView(StringView, InodeIdentifier, u8)
{
TODO_AARCH64();
}
}
// Coredump
namespace Kernel {
ErrorOr<NonnullOwnPtr<Coredump>> Coredump::try_create(NonnullLockRefPtr<Process>, StringView)
{
TODO_AARCH64();
}
ErrorOr<void> Coredump::write()
{
TODO_AARCH64();
}
}
// ThreadBlockers
namespace Kernel {
bool Thread::Blocker::setup_blocker()
{
TODO_AARCH64();
}
void Thread::Blocker::finalize()
{
}
Thread::Blocker::~Blocker()
{
TODO_AARCH64();
}
void Thread::Blocker::begin_blocking(Badge<Thread>)
{
TODO_AARCH64();
}
Thread::BlockTimeout::BlockTimeout(bool, Time const*, Time const*, clockid_t)
{
TODO_AARCH64();
}
bool Thread::JoinBlocker::unblock(void*, bool)
{
TODO_AARCH64();
}
bool Thread::SignalBlocker::check_pending_signals(bool)
{
TODO_AARCH64();
}
Thread::SleepBlocker::SleepBlocker(BlockTimeout const&, Time*)
{
TODO_AARCH64();
}
Thread::BlockResult Thread::SleepBlocker::block_result()
{
TODO_AARCH64();
}
Thread::BlockTimeout const& Thread::SleepBlocker::override_timeout(BlockTimeout const&)
{
TODO_AARCH64();
}
void Thread::SleepBlocker::will_unblock_immediately_without_blocking(UnblockImmediatelyReason)
{
TODO_AARCH64();
}
void Thread::SleepBlocker::was_unblocked(bool)
{
TODO_AARCH64();
}
bool Thread::WaitQueueBlocker::unblock()
{
TODO_AARCH64();
}
Thread::WaitQueueBlocker::WaitQueueBlocker(WaitQueue& wait_queue, StringView)
: m_wait_queue(wait_queue)
{
TODO_AARCH64();
}
bool Thread::WaitQueueBlocker::setup_blocker()
{
TODO_AARCH64();
}
Thread::WaitQueueBlocker::~WaitQueueBlocker()
{
TODO_AARCH64();
}
void Thread::WaitBlockerSet::finalize()
{
TODO_AARCH64();
}
bool Thread::WaitBlockerSet::unblock(Process&, WaitBlocker::UnblockFlags, u8)
{
TODO_AARCH64();
}
void Thread::WaitBlockerSet::disowned_by_waiter(Process&)
{
TODO_AARCH64();
}
bool Thread::WaitBlockerSet::should_add_blocker(Blocker&, void*)
{
TODO_AARCH64();
}
Thread::WaitBlockerSet::ProcessBlockInfo::~ProcessBlockInfo()
{
TODO_AARCH64();
}
}
// PerformanceEventBuffer
namespace Kernel {
bool g_profiling_all_threads = false;
PerformanceEventBuffer* g_global_perf_events = nullptr;
ErrorOr<void> PerformanceEventBuffer::append(int, unsigned long, unsigned long, AK::StringView, Kernel::Thread*, unsigned long, u64, ErrorOr<FlatPtr>)
{
TODO_AARCH64();
}
OwnPtr<PerformanceEventBuffer> PerformanceEventBuffer::try_create_with_size(size_t)
{
TODO_AARCH64();
}
ErrorOr<void> PerformanceEventBuffer::add_process(Process const&, ProcessEventType)
{
TODO_AARCH64();
}
ErrorOr<void> PerformanceEventBuffer::to_json(KBufferBuilder&) const
{
TODO_AARCH64();
}
ErrorOr<void> PerformanceEventBuffer::append_with_ip_and_bp(ProcessID, ThreadID,
FlatPtr, FlatPtr, int, u32, FlatPtr, FlatPtr, StringView, FlatPtr, u64, ErrorOr<FlatPtr>)
{
TODO_AARCH64();
}
}
// LockRank
namespace Kernel {
void track_lock_acquire(LockRank) { }
void track_lock_release(LockRank) { }
}
// Inode
namespace Kernel {
static Singleton<SpinlockProtected<Inode::AllInstancesList>> s_all_instances;
SpinlockProtected<Inode::AllInstancesList>& Inode::all_instances()
{
TODO_AARCH64();
return s_all_instances;
}
LockRefPtr<Memory::SharedInodeVMObject> Inode::shared_vmobject() const
{
TODO_AARCH64();
return LockRefPtr<Memory::SharedInodeVMObject>(nullptr);
}
void Inode::will_be_destroyed()
{
TODO_AARCH64();
}
ErrorOr<void> Inode::set_shared_vmobject(Memory::SharedInodeVMObject&)
{
TODO_AARCH64();
return {};
}
ErrorOr<size_t> Inode::read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
{
TODO_AARCH64();
return 0;
}
ErrorOr<size_t> Inode::write_bytes(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*)
{
TODO_AARCH64();
return 0;
}
ErrorOr<void> Inode::update_timestamps([[maybe_unused]] Optional<time_t> atime, [[maybe_unused]] Optional<time_t> ctime, [[maybe_unused]] Optional<time_t> mtime)
{
TODO_AARCH64();
}
ErrorOr<void> Inode::increment_link_count()
{
TODO_AARCH64();
}
ErrorOr<void> Inode::decrement_link_count()
{
TODO_AARCH64();
}
}
// x86 init
multiboot_module_entry_t multiboot_copy_boot_modules_array[16];