mirror of
https://github.com/SerenityOS/serenity
synced 2024-09-20 00:12:20 +00:00
12b6e69150
The new ProcFS design consists of two main parts: 1. The representative ProcFS class, which is derived from the FS class. The ProcFS and its inodes are much more lean - merely 3 classes to represent the common type of inodes - regular files, symbolic links and directories. They're backed by a ProcFSExposedComponent object, which is responsible for the functional operation behind the scenes. 2. The backend of the ProcFS - the ProcFSComponentsRegistrar class and all derived classes from the ProcFSExposedComponent class. These together form the entire backend and handle all the functions you can expect from the ProcFS. The ProcFSExposedComponent derived classes split to 3 types in the manner of lifetime in the kernel: 1. Persistent objects - this category includes all basic objects, like the root folder, /proc/bus folder, main blob files in the root folders, etc. These objects are persistent and cannot die ever. 2. Semi-persistent objects - this category includes all PID folders, and subdirectories to the PID folders. It also includes exposed objects like the unveil JSON'ed blob. These object are persistent as long as the the responsible process they represent is still alive. 3. Dynamic objects - this category includes files in the subdirectories of a PID folder, like /proc/PID/fd/* or /proc/PID/stacks/*. Essentially, these objects are always created dynamically and when no longer in need after being used, they're deallocated. Nevertheless, the new allocated backend objects and inodes try to use the same InodeIndex if possible - this might change only when a thread dies and a new thread is born with a new thread stack, or when a file descriptor is closed and a new one within the same file descriptor number is opened. This is needed to actually be able to do something useful with these objects. The new design assures that many ProcFS instances can be used at once, with one backend for usage for all instances.
129 lines
4.5 KiB
C++
129 lines
4.5 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <Kernel/Debug.h>
|
|
#include <Kernel/FileSystem/Custody.h>
|
|
#include <Kernel/FileSystem/FileDescription.h>
|
|
#include <Kernel/Panic.h>
|
|
#include <Kernel/PerformanceManager.h>
|
|
#include <Kernel/Process.h>
|
|
#include <Kernel/VM/Region.h>
|
|
|
|
namespace Kernel {
|
|
|
|
KResultOr<FlatPtr> Process::sys$fork(RegisterState& regs)
|
|
{
|
|
REQUIRE_PROMISE(proc);
|
|
RefPtr<Thread> child_first_thread;
|
|
auto child = Process::create(child_first_thread, m_name, uid(), gid(), pid(), m_is_kernel_process, m_cwd, m_executable, m_tty, this);
|
|
if (!child || !child_first_thread)
|
|
return ENOMEM;
|
|
child->m_root_directory = m_root_directory;
|
|
child->m_root_directory_relative_to_global_root = m_root_directory_relative_to_global_root;
|
|
child->m_veil_state = m_veil_state;
|
|
child->m_unveiled_paths = m_unveiled_paths.deep_copy();
|
|
child->m_fds = m_fds;
|
|
child->m_pg = m_pg;
|
|
|
|
{
|
|
ProtectedDataMutationScope scope { *child };
|
|
child->m_promises = m_promises;
|
|
child->m_execpromises = m_execpromises;
|
|
child->m_has_promises = m_has_promises;
|
|
child->m_has_execpromises = m_has_execpromises;
|
|
child->m_sid = m_sid;
|
|
child->m_extra_gids = m_extra_gids;
|
|
child->m_umask = m_umask;
|
|
child->m_signal_trampoline = m_signal_trampoline;
|
|
child->m_dumpable = m_dumpable;
|
|
}
|
|
|
|
dbgln_if(FORK_DEBUG, "fork: child={}", child);
|
|
child->space().set_enforces_syscall_regions(space().enforces_syscall_regions());
|
|
|
|
#if ARCH(I386)
|
|
auto& child_regs = child_first_thread->m_regs;
|
|
child_regs.eax = 0; // fork() returns 0 in the child :^)
|
|
child_regs.ebx = regs.ebx;
|
|
child_regs.ecx = regs.ecx;
|
|
child_regs.edx = regs.edx;
|
|
child_regs.ebp = regs.ebp;
|
|
child_regs.esp = regs.userspace_esp;
|
|
child_regs.esi = regs.esi;
|
|
child_regs.edi = regs.edi;
|
|
child_regs.eflags = regs.eflags;
|
|
child_regs.eip = regs.eip;
|
|
child_regs.cs = regs.cs;
|
|
child_regs.ds = regs.ds;
|
|
child_regs.es = regs.es;
|
|
child_regs.fs = regs.fs;
|
|
child_regs.gs = regs.gs;
|
|
child_regs.ss = regs.userspace_ss;
|
|
|
|
dbgln_if(FORK_DEBUG, "fork: child will begin executing at {:04x}:{:08x} with stack {:04x}:{:08x}, kstack {:04x}:{:08x}",
|
|
child_regs.cs, child_regs.eip, child_regs.ss, child_regs.esp, child_regs.ss0, child_regs.esp0);
|
|
#else
|
|
auto& child_regs = child_first_thread->m_regs;
|
|
child_regs.rax = 0; // fork() returns 0 in the child :^)
|
|
child_regs.rbx = regs.rbx;
|
|
child_regs.rcx = regs.rcx;
|
|
child_regs.rdx = regs.rdx;
|
|
child_regs.rbp = regs.rbp;
|
|
child_regs.rsp = regs.userspace_rsp;
|
|
child_regs.rsi = regs.rsi;
|
|
child_regs.rdi = regs.rdi;
|
|
child_regs.r8 = regs.r8;
|
|
child_regs.r9 = regs.r9;
|
|
child_regs.r10 = regs.r10;
|
|
child_regs.r11 = regs.r11;
|
|
child_regs.r12 = regs.r12;
|
|
child_regs.r13 = regs.r13;
|
|
child_regs.r14 = regs.r14;
|
|
child_regs.r15 = regs.r15;
|
|
child_regs.rflags = regs.rflags;
|
|
child_regs.rip = regs.rip;
|
|
child_regs.cs = regs.cs;
|
|
|
|
dbgln_if(FORK_DEBUG, "fork: child will begin executing at {:04x}:{:16x} with stack {:08x}, kstack {:08x}",
|
|
child_regs.cs, child_regs.rip, child_regs.rsp, child_regs.rsp0);
|
|
#endif
|
|
|
|
{
|
|
ScopedSpinLock lock(space().get_lock());
|
|
for (auto& region : space().regions()) {
|
|
dbgln_if(FORK_DEBUG, "fork: cloning Region({}) '{}' @ {}", region, region->name(), region->vaddr());
|
|
auto region_clone = region->clone(*child);
|
|
if (!region_clone) {
|
|
dbgln("fork: Cannot clone region, insufficient memory");
|
|
// TODO: tear down new process?
|
|
return ENOMEM;
|
|
}
|
|
|
|
auto& child_region = child->space().add_region(region_clone.release_nonnull());
|
|
child_region.map(child->space().page_directory(), ShouldFlushTLB::No);
|
|
|
|
if (region == m_master_tls_region.unsafe_ptr())
|
|
child->m_master_tls_region = child_region;
|
|
}
|
|
|
|
Process::register_new(*child);
|
|
}
|
|
|
|
PerformanceManager::add_process_created_event(*child);
|
|
|
|
ScopedSpinLock lock(g_scheduler_lock);
|
|
child_first_thread->set_affinity(Thread::current()->affinity());
|
|
child_first_thread->set_state(Thread::State::Runnable);
|
|
|
|
auto child_pid = child->pid().value();
|
|
// We need to leak one reference so we don't destroy the Process,
|
|
// which will be dropped by Process::reap
|
|
(void)child.leak_ref();
|
|
return child_pid;
|
|
}
|
|
|
|
}
|