/*

* Copyright (c) 2018-2020, Andreas Kling <[email protected]>

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are met:

*

* 1. Redistributions of source code must retain the above copyright notice, this

* list of conditions and the following disclaimer.

*

* 2. Redistributions in binary form must reproduce the above copyright notice,

* this list of conditions and the following disclaimer in the documentation

* and/or other materials provided with the distribution.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include <AK/Demangle.h>

#include <AK/RefPtr.h>

#include <AK/ScopeGuard.h>

#include <AK/StdLibExtras.h>

#include <AK/StringBuilder.h>

#include <AK/Time.h>

#include <AK/Types.h>

#include <Kernel/ACPI/Parser.h>

#include <Kernel/Arch/i386/CPU.h>

#include <Kernel/Console.h>

#include <Kernel/Devices/BlockDevice.h>

#include <Kernel/Devices/KeyboardDevice.h>

#include <Kernel/Devices/NullDevice.h>

#include <Kernel/Devices/PCSpeaker.h>

#include <Kernel/Devices/RandomDevice.h>

#include <Kernel/FileSystem/Custody.h>

#include <Kernel/FileSystem/DevPtsFS.h>

#include <Kernel/FileSystem/Ext2FileSystem.h>

#include <Kernel/FileSystem/FIFO.h>

#include <Kernel/FileSystem/FileDescription.h>

#include <Kernel/FileSystem/InodeWatcher.h>

#include <Kernel/FileSystem/ProcFS.h>

#include <Kernel/FileSystem/TmpFS.h>

#include <Kernel/FileSystem/VirtualFileSystem.h>

#include <Kernel/Heap/kmalloc.h>

#include <Kernel/IO.h>

#include <Kernel/KBufferBuilder.h>

#include <Kernel/KSyms.h>

#include <Kernel/Module.h>

#include <Kernel/Multiboot.h>

#include <Kernel/Net/Socket.h>

#include <Kernel/PerformanceEventBuffer.h>

#include <Kernel/Process.h>

#include <Kernel/Profiling.h>

#include <Kernel/Ptrace.h>

#include <Kernel/RTC.h>

#include <Kernel/Random.h>

#include <Kernel/Scheduler.h>

#include <Kernel/SharedBuffer.h>

#include <Kernel/StdLib.h>

#include <Kernel/Syscall.h>

#include <Kernel/TTY/MasterPTY.h>

#include <Kernel/TTY/TTY.h>

#include <Kernel/Thread.h>

#include <Kernel/ThreadTracer.h>

#include <Kernel/Time/TimeManagement.h>

#include <Kernel/VM/PageDirectory.h>

#include <Kernel/VM/PrivateInodeVMObject.h>

#include <Kernel/VM/ProcessPagingScope.h>

#include <Kernel/VM/PurgeableVMObject.h>

#include <Kernel/VM/SharedInodeVMObject.h>

#include <LibC/errno_numbers.h>

#include <LibC/limits.h>

#include <LibC/signal_numbers.h>

#include <LibELF/Loader.h>

#include <LibELF/Validation.h>

//#define PROCESS_DEBUG

//#define DEBUG_POLL_SELECT

//#define DEBUG_IO

//#define TASK_DEBUG

//#define FORK_DEBUG

//#define EXEC_DEBUG

//#define SIGNAL_DEBUG

//#define SHARED_BUFFER_DEBUG

namespace Kernel {

static void create_signal_trampolines();

Process* Process::current;

static pid_t next_pid;

InlineLinkedList<Process>* g_processes;

static String* s_hostname;

static Lock* s_hostname_lock;

VirtualAddress g_return_to_ring3_from_signal_trampoline;

HashMap<String, OwnPtr<Module>>* g_modules;

pid_t Process::allocate_pid()

{

InterruptDisabler disabler;

return next_pid++;

}

void Process::initialize()

{

g_modules = new HashMap<String, OwnPtr<Module>>;

next_pid = 0;

g_processes = new InlineLinkedList<Process>;

s_hostname = new String("courage");

s_hostname_lock = new Lock;

create_signal_trampolines();

}

Vector<pid_t> Process::all_pids()

{

Vector<pid_t> pids;

InterruptDisabler disabler;

pids.ensure_capacity((int)g_processes->size_slow());

for (auto& process : *g_processes)

pids.append(process.pid());

return pids;

}

Vector<Process*> Process::all_processes()

{

Vector<Process*> processes;

InterruptDisabler disabler;

processes.ensure_capacity((int)g_processes->size_slow());

for (auto& process : *g_processes)

processes.append(&process);

return processes;

}

bool Process::in_group(gid_t gid) const

{

return m_gid == gid || m_extra_gids.contains(gid);

}

Range Process::allocate_range(VirtualAddress vaddr, size_t size, size_t alignment)

{

vaddr.mask(PAGE_MASK);

size = PAGE_ROUND_UP(size);

if (vaddr.is_null())

return page_directory().range_allocator().allocate_anywhere(size, alignment);

return page_directory().range_allocator().allocate_specific(vaddr, size);

}

static unsigned prot_to_region_access_flags(int prot)

{

unsigned access = 0;

if (prot & PROT_READ)

access |= Region::Access::Read;

if (prot & PROT_WRITE)

access |= Region::Access::Write;

if (prot & PROT_EXEC)

access |= Region::Access::Execute;

return access;

}

Region& Process::allocate_split_region(const Region& source_region, const Range& range, size_t offset_in_vmobject)

{

auto& region = add_region(Region::create_user_accessible(range, source_region.vmobject(), offset_in_vmobject, source_region.name(), source_region.access()));

region.set_mmap(source_region.is_mmap());

region.set_stack(source_region.is_stack());

size_t page_offset_in_source_region = (offset_in_vmobject - source_region.offset_in_vmobject()) / PAGE_SIZE;

for (size_t i = 0; i < region.page_count(); ++i) {

if (source_region.should_cow(page_offset_in_source_region + i))

region.set_should_cow(i, true);

}

return region;

}

Region* Process::allocate_region(const Range& range, const String& name, int prot, bool should_commit)

{

ASSERT(range.is_valid());

auto vmobject = AnonymousVMObject::create_with_size(range.size());

auto region = Region::create_user_accessible(range, vmobject, 0, name, prot_to_region_access_flags(prot));

region->map(page_directory());

if (should_commit && !region->commit())

return nullptr;

return &add_region(move(region));

}

Region* Process::allocate_region(VirtualAddress vaddr, size_t size, const String& name, int prot, bool should_commit)

{

auto range = allocate_range(vaddr, size);

if (!range.is_valid())

return nullptr;

return allocate_region(range, name, prot, should_commit);

}

Region* Process::allocate_region_with_vmobject(const Range& range, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, const String& name, int prot)

{

ASSERT(range.is_valid());

size_t end_in_vmobject = offset_in_vmobject + range.size();

if (end_in_vmobject <= offset_in_vmobject) {

dbg() << "allocate_region_with_vmobject: Overflow (offset + size)";

return nullptr;

}

if (offset_in_vmobject >= vmobject->size()) {

dbg() << "allocate_region_with_vmobject: Attempt to allocate a region with an offset past the end of its VMObject.";

return nullptr;

}

if (end_in_vmobject > vmobject->size()) {

dbg() << "allocate_region_with_vmobject: Attempt to allocate a region with an end past the end of its VMObject.";

return nullptr;

}

offset_in_vmobject &= PAGE_MASK;

auto& region = add_region(Region::create_user_accessible(range, move(vmobject), offset_in_vmobject, name, prot_to_region_access_flags(prot)));

region.map(page_directory());

return &region;

}

Region* Process::allocate_region_with_vmobject(VirtualAddress vaddr, size_t size, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, const String& name, int prot)

{

auto range = allocate_range(vaddr, size);

if (!range.is_valid())

return nullptr;

return allocate_region_with_vmobject(range, move(vmobject), offset_in_vmobject, name, prot);

}

bool Process::deallocate_region(Region& region)

{

InterruptDisabler disabler;

if (m_region_lookup_cache.region == &region)

m_region_lookup_cache.region = nullptr;

for (size_t i = 0; i < m_regions.size(); ++i) {

if (&m_regions[i] == &region) {

m_regions.unstable_remove(i);

return true;

}

}

return false;

}

Region* Process::region_from_range(const Range& range)

{

if (m_region_lookup_cache.range == range && m_region_lookup_cache.region)

return m_region_lookup_cache.region;

size_t size = PAGE_ROUND_UP(range.size());

for (auto& region : m_regions) {

if (region.vaddr() == range.base() && region.size() == size) {

m_region_lookup_cache.range = range;

m_region_lookup_cache.region = region.make_weak_ptr();

return &region;

}

}

return nullptr;

}

Region* Process::region_containing(const Range& range)

{

for (auto& region : m_regions) {

if (region.contains(range))

return &region;

}

return nullptr;

}

int Process::sys$set_mmap_name(const Syscall::SC_set_mmap_name_params* user_params)

{

REQUIRE_PROMISE(stdio);

Syscall::SC_set_mmap_name_params params;

if (!validate_read_and_copy_typed(&params, user_params))

return -EFAULT;

if (params.name.length > PATH_MAX)

return -ENAMETOOLONG;

auto name = validate_and_copy_string_from_user(params.name);

if (name.is_null())

return -EFAULT;

auto* region = region_from_range({ VirtualAddress(params.addr), params.size });

if (!region)

return -EINVAL;

if (!region->is_mmap())

return -EPERM;

region->set_name(name);

return 0;

}

static bool validate_mmap_prot(int prot, bool map_stack)

{

bool readable = prot & PROT_READ;

bool writable = prot & PROT_WRITE;

bool executable = prot & PROT_EXEC;

if (writable && executable)

return false;

if (map_stack) {

if (executable)

return false;

if (!readable || !writable)

return false;

}

return true;

}

static bool validate_inode_mmap_prot(const Process& process, int prot, const Inode& inode, bool map_shared)

{

auto metadata = inode.metadata();

if ((prot & PROT_READ) && !metadata.may_read(process))

return false;

if (map_shared) {

// FIXME: What about readonly filesystem mounts? We cannot make a

// decision here without knowing the mount flags, so we would need to

// keep a Custody or something from mmap time.

if ((prot & PROT_WRITE) && !metadata.may_write(process))

return false;

InterruptDisabler disabler;

if (inode.shared_vmobject()) {

if ((prot & PROT_EXEC) && inode.shared_vmobject()->writable_mappings())

return false;

if ((prot & PROT_WRITE) && inode.shared_vmobject()->executable_mappings())

return false;

}

}

return true;

}

// Carve out a virtual address range from a region and return the two regions on either side

Vector<Region*, 2> Process::split_region_around_range(const Region& source_region, const Range& desired_range)

{

Range old_region_range = source_region.range();

auto remaining_ranges_after_unmap = old_region_range.carve(desired_range);

ASSERT(!remaining_ranges_after_unmap.is_empty());

auto make_replacement_region = [&](const Range& new_range) -> Region& {

ASSERT(old_region_range.contains(new_range));

size_t new_range_offset_in_vmobject = source_region.offset_in_vmobject() + (new_range.base().get() - old_region_range.base().get());

return allocate_split_region(source_region, new_range, new_range_offset_in_vmobject);

};

Vector<Region*, 2> new_regions;

for (auto& new_range : remaining_ranges_after_unmap) {

new_regions.unchecked_append(&make_replacement_region(new_range));

}

return new_regions;

}

void* Process::sys$mmap(const Syscall::SC_mmap_params* user_params)

{

REQUIRE_PROMISE(stdio);

Syscall::SC_mmap_params params;

if (!validate_read_and_copy_typed(&params, user_params))

return (void*)-EFAULT;

void* addr = (void*)params.addr;

size_t size = params.size;

size_t alignment = params.alignment;

int prot = params.prot;

int flags = params.flags;

int fd = params.fd;

int offset = params.offset;

if (alignment & ~PAGE_MASK)

return (void*)-EINVAL;

if (!is_user_range(VirtualAddress(addr), size))

return (void*)-EFAULT;

String name;

if (params.name.characters) {

if (params.name.length > PATH_MAX)

return (void*)-ENAMETOOLONG;

name = validate_and_copy_string_from_user(params.name);

if (name.is_null())

return (void*)-EFAULT;

}

if (size == 0)

return (void*)-EINVAL;

if ((FlatPtr)addr & ~PAGE_MASK)

return (void*)-EINVAL;

bool map_shared = flags & MAP_SHARED;

bool map_anonymous = flags & MAP_ANONYMOUS;

bool map_purgeable = flags & MAP_PURGEABLE;

bool map_private = flags & MAP_PRIVATE;

bool map_stack = flags & MAP_STACK;

bool map_fixed = flags & MAP_FIXED;

if (map_shared && map_private)

return (void*)-EINVAL;

if (!map_shared && !map_private)

return (void*)-EINVAL;

if (!validate_mmap_prot(prot, map_stack))

return (void*)-EINVAL;

if (map_stack && (!map_private || !map_anonymous))

return (void*)-EINVAL;

Region* region = nullptr;

auto range = allocate_range(VirtualAddress(addr), size, alignment);

if (!range.is_valid())

return (void*)-ENOMEM;

if (map_purgeable) {

auto vmobject = PurgeableVMObject::create_with_size(size);

region = allocate_region_with_vmobject(range, vmobject, 0, !name.is_null() ? name : "mmap (purgeable)", prot);

if (!region && (!map_fixed && addr != 0))

region = allocate_region_with_vmobject({}, size, vmobject, 0, !name.is_null() ? name : "mmap (purgeable)", prot);

} else if (map_anonymous) {

region = allocate_region(range, !name.is_null() ? name : "mmap", prot, false);

if (!region && (!map_fixed && addr != 0))

region = allocate_region(allocate_range({}, size), !name.is_null() ? name : "mmap", prot, false);

} else {

if (offset < 0)

return (void*)-EINVAL;

if (static_cast<size_t>(offset) & ~PAGE_MASK)

return (void*)-EINVAL;

auto description = file_description(fd);

if (!description)

return (void*)-EBADF;

if (description->is_directory())

return (void*)-ENODEV;

// Require read access even when read protection is not requested.

if (!description->is_readable())

return (void*)-EACCES;

if (map_shared) {

if ((prot & PROT_WRITE) && !description->is_writable())

return (void*)-EACCES;

}

if (description->inode()) {

if (!validate_inode_mmap_prot(*this, prot, *description->inode(), map_shared))

return (void*)-EACCES;

}

auto region_or_error = description->mmap(*this, VirtualAddress(addr), static_cast<size_t>(offset), size, prot, map_shared);

if (region_or_error.is_error()) {

// Fail if MAP_FIXED or address is 0, retry otherwise

if (map_fixed || addr == 0)

return (void*)(int)region_or_error.error();

region_or_error = description->mmap(*this, {}, static_cast<size_t>(offset), size, prot, map_shared);

}

if (region_or_error.is_error())

return (void*)(int)region_or_error.error();

region = region_or_error.value();

}

if (!region)

return (void*)-ENOMEM;

region->set_mmap(true);

if (map_shared)

region->set_shared(true);

if (map_stack)

region->set_stack(true);

if (!name.is_null())

region->set_name(name);

return region->vaddr().as_ptr();

}

int Process::sys$munmap(void* addr, size_t size)

{

REQUIRE_PROMISE(stdio);

if (!size)

return -EINVAL;

if (!is_user_range(VirtualAddress(addr), size))

return -EFAULT;

Range range_to_unmap { VirtualAddress(addr), size };

if (auto* whole_region = region_from_range(range_to_unmap)) {

if (!whole_region->is_mmap())

return -EPERM;

bool success = deallocate_region(*whole_region);

ASSERT(success);

return 0;

}

if (auto* old_region = region_containing(range_to_unmap)) {

if (!old_region->is_mmap())

return -EPERM;

auto new_regions = split_region_around_range(*old_region, range_to_unmap);

// We manually unmap the old region here, specifying that we *don't* want the VM deallocated.

old_region->unmap(Region::ShouldDeallocateVirtualMemoryRange::No);

deallocate_region(*old_region);

// Instead we give back the unwanted VM manually.

page_directory().range_allocator().deallocate(range_to_unmap);

// And finally we map the new region(s) using our page directory (they were just allocated and don't have one).

for (auto* new_region : new_regions) {

new_region->map(page_directory());

}

return 0;

}

// FIXME: We should also support munmap() across multiple regions. (#175)

return -EINVAL;

}

int Process::sys$mprotect(void* addr, size_t size, int prot)

{

REQUIRE_PROMISE(stdio);

if (!size)

return -EINVAL;

if (!is_user_range(VirtualAddress(addr), size))

return -EFAULT;

Range range_to_mprotect = { VirtualAddress(addr), size };

if (auto* whole_region = region_from_range(range_to_mprotect)) {

if (!whole_region->is_mmap())

return -EPERM;

if (!validate_mmap_prot(prot, whole_region->is_stack()))

return -EINVAL;

if (whole_region->access() == prot_to_region_access_flags(prot))

return 0;

if (whole_region->vmobject().is_inode()

&& !validate_inode_mmap_prot(*this, prot, static_cast<const InodeVMObject&>(whole_region->vmobject()).inode(), whole_region->is_shared())) {

return -EACCES;

}

whole_region->set_readable(prot & PROT_READ);

whole_region->set_writable(prot & PROT_WRITE);

whole_region->set_executable(prot & PROT_EXEC);

whole_region->remap();

return 0;

}

// Check if we can carve out the desired range from an existing region

if (auto* old_region = region_containing(range_to_mprotect)) {

if (!old_region->is_mmap())

return -EPERM;

if (!validate_mmap_prot(prot, old_region->is_stack()))

return -EINVAL;

if (old_region->access() == prot_to_region_access_flags(prot))

return 0;

if (old_region->vmobject().is_inode()

&& !validate_inode_mmap_prot(*this, prot, static_cast<const InodeVMObject&>(old_region->vmobject()).inode(), old_region->is_shared())) {

return -EACCES;

}

// This vector is the region(s) adjacent to our range.

// We need to allocate a new region for the range we wanted to change permission bits on.

auto adjacent_regions = split_region_around_range(*old_region, range_to_mprotect);

size_t new_range_offset_in_vmobject = old_region->offset_in_vmobject() + (range_to_mprotect.base().get() - old_region->range().base().get());

auto& new_region = allocate_split_region(*old_region, range_to_mprotect, new_range_offset_in_vmobject);

new_region.set_readable(prot & PROT_READ);

new_region.set_writable(prot & PROT_WRITE);

new_region.set_executable(prot & PROT_EXEC);

// Unmap the old region here, specifying that we *don't* want the VM deallocated.

old_region->unmap(Region::ShouldDeallocateVirtualMemoryRange::No);

deallocate_region(*old_region);

// Map the new regions using our page directory (they were just allocated and don't have one).

for (auto* adjacent_region : adjacent_regions) {

adjacent_region->map(page_directory());

}

new_region.map(page_directory());

return 0;

}

// FIXME: We should also support mprotect() across multiple regions. (#175) (#964)

return -EINVAL;

}

int Process::sys$madvise(void* address, size_t size, int advice)

{

REQUIRE_PROMISE(stdio);

if (!size)

return -EINVAL;

if (!is_user_range(VirtualAddress(address), size))

return -EFAULT;

auto* region = region_from_range({ VirtualAddress(address), size });

if (!region)

return -EINVAL;

if (!region->is_mmap())

return -EPERM;

if ((advice & MADV_SET_VOLATILE) && (advice & MADV_SET_NONVOLATILE))

return -EINVAL;

if (advice & MADV_SET_VOLATILE) {

if (!region->vmobject().is_purgeable())

return -EPERM;

auto& vmobject = static_cast<PurgeableVMObject&>(region->vmobject());

vmobject.set_volatile(true);

return 0;

}

if (advice & MADV_SET_NONVOLATILE) {

if (!region->vmobject().is_purgeable())

return -EPERM;

auto& vmobject = static_cast<PurgeableVMObject&>(region->vmobject());

if (!vmobject.is_volatile())

return 0;

vmobject.set_volatile(false);

bool was_purged = vmobject.was_purged();

vmobject.set_was_purged(false);

return was_purged ? 1 : 0;

}

if (advice & MADV_GET_VOLATILE) {

if (!region->vmobject().is_purgeable())

return -EPERM;

auto& vmobject = static_cast<PurgeableVMObject&>(region->vmobject());

return vmobject.is_volatile() ? 0 : 1;

}

return -EINVAL;

}

int Process::sys$minherit(void* address, size_t size, int inherit)

{

REQUIRE_PROMISE(stdio);

auto* region = region_from_range({ VirtualAddress(address), size });

if (!region)

return -EINVAL;

if (!region->is_mmap())

return -EINVAL;

if (region->is_shared())

return -EINVAL;

if (!region->vmobject().is_anonymous())

return -EINVAL;

switch (inherit) {

case MAP_INHERIT_ZERO:

region->set_inherit_mode(Region::InheritMode::ZeroedOnFork);

return 0;

}

return -EINVAL;

}

int Process::sys$purge(int mode)

{

REQUIRE_NO_PROMISES;

if (!is_superuser())

return -EPERM;

int purged_page_count = 0;

if (mode & PURGE_ALL_VOLATILE) {

NonnullRefPtrVector<PurgeableVMObject> vmobjects;

{

InterruptDisabler disabler;

MM.for_each_vmobject_of_type<PurgeableVMObject>([&](auto& vmobject) {

vmobjects.append(vmobject);

return IterationDecision::Continue;

});

}

for (auto& vmobject : vmobjects) {

purged_page_count += vmobject.purge();

}

}

if (mode & PURGE_ALL_CLEAN_INODE) {

NonnullRefPtrVector<InodeVMObject> vmobjects;

{

InterruptDisabler disabler;

MM.for_each_vmobject_of_type<InodeVMObject>([&](auto& vmobject) {

vmobjects.append(vmobject);

return IterationDecision::Continue;

});

}

for (auto& vmobject : vmobjects) {

purged_page_count += vmobject.release_all_clean_pages();

}

}

return purged_page_count;

}

int Process::sys$gethostname(char* buffer, ssize_t size)

{

REQUIRE_PROMISE(stdio);

if (size < 0)

return -EINVAL;

if (!validate_write(buffer, size))

return -EFAULT;

LOCKER(*s_hostname_lock, Lock::Mode::Shared);

if ((size_t)size < (s_hostname->length() + 1))

return -ENAMETOOLONG;

copy_to_user(buffer, s_hostname->characters(), s_hostname->length() + 1);

return 0;

}

int Process::sys$sethostname(const char* hostname, ssize_t length)

{

REQUIRE_NO_PROMISES;

if (!is_superuser())

return -EPERM;

if (length < 0)

return -EINVAL;

LOCKER(*s_hostname_lock, Lock::Mode::Exclusive);

if (length > 64)

return -ENAMETOOLONG;

*s_hostname = validate_and_copy_string_from_user(hostname, length);

return 0;

}

pid_t Process::sys$fork(RegisterState& regs)

{

REQUIRE_PROMISE(proc);

Thread* child_first_thread = nullptr;

auto* child = new Process(child_first_thread, m_name, m_uid, m_gid, m_pid, m_ring, m_cwd, m_executable, m_tty, this);

child->m_root_directory = m_root_directory;

child->m_root_directory_relative_to_global_root = m_root_directory_relative_to_global_root;

child->m_promises = m_promises;

child->m_execpromises = m_execpromises;

child->m_veil_state = m_veil_state;

child->m_unveiled_paths = m_unveiled_paths;

child->m_fds = m_fds;

child->m_sid = m_sid;

child->m_pgid = m_pgid;

child->m_umask = m_umask;

#ifdef FORK_DEBUG

dbg() << "fork: child=" << child;

#endif

for (auto& region : m_regions) {

#ifdef FORK_DEBUG

dbg() << "fork: cloning Region{" << &region << "} '" << region.name() << "' @ " << region.vaddr();

#endif

auto& child_region = child->add_region(region.clone());

child_region.map(child->page_directory());

if (&region == m_master_tls_region)

child->m_master_tls_region = child_region.make_weak_ptr();

}

child->m_extra_gids = m_extra_gids;

auto& child_tss = child_first_thread->m_tss;

child_tss.eax = 0; // fork() returns 0 in the child :^)

child_tss.ebx = regs.ebx;

child_tss.ecx = regs.ecx;

child_tss.edx = regs.edx;

child_tss.ebp = regs.ebp;

child_tss.esp = regs.userspace_esp;

child_tss.esi = regs.esi;

child_tss.edi = regs.edi;

child_tss.eflags = regs.eflags;

child_tss.eip = regs.eip;

child_tss.cs = regs.cs;

child_tss.ds = regs.ds;

child_tss.es = regs.es;

child_tss.fs = regs.fs;

child_tss.gs = regs.gs;

child_tss.ss = regs.userspace_ss;

#ifdef FORK_DEBUG

dbg() << "fork: child will begin executing at " << String::format("%w", child_tss.cs) << ":" << String::format("%x", child_tss.eip) << " with stack " << String::format("%w", child_tss.ss) << ":" << String::format("%x", child_tss.esp) << ", kstack " << String::format("%w", child_tss.ss0) << ":" << String::format("%x", child_tss.esp0);

#endif

{

InterruptDisabler disabler;

g_processes->prepend(child);

}

#ifdef TASK_DEBUG

klog() << "Process " << child->pid() << " (" << child->name().characters() << ") forked from " << m_pid << " @ " << String::format("%p", child_tss.eip);

#endif

child_first_thread->set_state(Thread::State::Skip1SchedulerPass);

return child->pid();

}

void Process::kill_threads_except_self()

{

InterruptDisabler disabler;

if (m_thread_count <= 1)

return;

for_each_thread([&](Thread& thread) {

if (&thread == Thread::current

|| thread.state() == Thread::State::Dead

|| thread.state() == Thread::State::Dying)

return IterationDecision::Continue;

// At this point, we have no joiner anymore

thread.m_joiner = nullptr;

thread.set_should_die();

if (thread.state() != Thread::State::Dead)

thread.set_state(Thread::State::Dying);

return IterationDecision::Continue;

});

big_lock().clear_waiters();

}

void Process::kill_all_threads()

{

for_each_thread([&](Thread& thread) {

thread.set_should_die();

return IterationDecision::Continue;

});

}

int Process::do_exec(NonnullRefPtr<FileDescription> main_program_description, Vector<String> arguments, Vector<String> environment, RefPtr<FileDescription> interpreter_description)

{

ASSERT(is_ring3());

auto path = main_program_description->absolute_path();

dbg() << "do_exec(" << path << ")";

size_t total_blob_size = 0;

for (auto& a : arguments)

total_blob_size += a.length() + 1;

for (auto& e : environment)

total_blob_size += e.length() + 1;

size_t total_meta_size = sizeof(char*) * (arguments.size() + 1) + sizeof(char*) * (environment.size() + 1);

// FIXME: How much stack space does process startup need?

if ((total_blob_size + total_meta_size) >= Thread::default_userspace_stack_size)

return -E2BIG;

auto parts = path.split('/');

if (parts.is_empty())

return -ENOENT;

auto& inode = interpreter_description ? *interpreter_description->inode() : *main_program_description->inode();

auto vmobject = SharedInodeVMObject::create_with_inode(inode);

if (static_cast<const SharedInodeVMObject&>(*vmobject).writable_mappings()) {

dbg() << "Refusing to execute a write-mapped program";

return -ETXTBSY;

}

// Disable profiling temporarily in case it's running on this process.

bool was_profiling = is_profiling();

TemporaryChange profiling_disabler(m_profiling, false);

// Mark this thread as the current thread that does exec

// No other thread from this process will be scheduled to run

m_exec_tid = Thread::current->tid();

auto old_page_directory = move(m_page_directory);

auto old_regions = move(m_regions);

m_page_directory = PageDirectory::create_for_userspace(*this);

#ifdef MM_DEBUG

dbg() << "Process " << pid() << " exec: PD=" << m_page_directory.ptr() << " created";

#endif

InodeMetadata loader_metadata;

// FIXME: Hoooo boy this is a hack if I ever saw one.

// This is the 'random' offset we're giving to our ET_DYN exectuables to start as.

// It also happens to be the static Virtual Addresss offset every static exectuable gets :)

// Without this, some assumptions by the ELF loading hooks below are severely broken.

// 0x08000000 is a verified random number chosen by random dice roll https://xkcd.com/221/

u32 totally_random_offset = interpreter_description ? 0x08000000 : 0;

// FIXME: We should be able to load both the PT_INTERP interpreter and the main program... once the RTLD is smart enough

if (interpreter_description) {

loader_metadata = interpreter_description->metadata();

// we don't need the interpreter file desciption after we've loaded (or not) it into memory

interpreter_description = nullptr;

} else {

loader_metadata = main_program_description->metadata();

}

auto region = MM.allocate_kernel_region_with_vmobject(*vmobject, PAGE_ROUND_UP(loader_metadata.size), "ELF loading", Region::Access::Read);

if (!region)

return -ENOMEM;

Region* master_tls_region { nullptr };

size_t master_tls_size = 0;

size_t master_tls_alignment = 0;

u32 entry_eip = 0;

MM.enter_process_paging_scope(*this);

RefPtr<ELF::Loader> loader;

{

ArmedScopeGuard rollback_regions_guard([&]() {

ASSERT(Process::current == this);

m_page_directory = move(old_page_directory);

m_regions = move(old_regions);

MM.enter_process_paging_scope(*this);

});

loader = ELF::Loader::create(region->vaddr().as_ptr(), loader_metadata.size);

// Load the correct executable -- either interp or main program.

// FIXME: Once we actually load both interp and main, we'll need to be more clever about this.

// In that case, both will be ET_DYN objects, so they'll both be completely relocatable.

// That means, we can put them literally anywhere in User VM space (ASLR anyone?).

// ALSO FIXME: Reminder to really really fix that 'totally random offset' business.

loader->map_section_hook = [&](VirtualAddress vaddr, size_t size, size_t alignment, size_t offset_in_image, bool is_readable, bool is_writable, bool is_executable, const String& name) -> u8* {

ASSERT(size);

ASSERT(alignment == PAGE_SIZE);

int prot = 0;

if (is_readable)

prot |= PROT_READ;

if (is_writable)

prot |= PROT_WRITE;

if (is_executable)

prot |= PROT_EXEC;

if (auto* region = allocate_region_with_vmobject(vaddr.offset(totally_random_offset), size, *vmobject, offset_in_image, String(name), prot)) {

region->set_shared(true);

return region->vaddr().as_ptr();

}

return nullptr;

};

loader->alloc_section_hook = [&](VirtualAddress vaddr, size_t size, size_t alignment, bool is_readable, bool is_writable, const String& name) -> u8* {

ASSERT(size);

ASSERT(alignment == PAGE_SIZE);

int prot = 0;

if (is_readable)

prot |= PROT_READ;

if (is_writable)

prot |= PROT_WRITE;

if (auto* region = allocate_region(vaddr.offset(totally_random_offset), size, String(name), prot))

return region->vaddr().as_ptr();

return nullptr;

};

// FIXME: Move TLS region allocation to userspace: LibC and the dynamic loader.

// LibC if we end up with a statically linked executable, and the

// dynamic loader so that it can create new TLS blocks for each shared libarary

// that gets loaded as part of DT_NEEDED processing, and via dlopen()

// If that doesn't happen quickly, at least pass the location of the TLS region

// some ELF Auxilliary Vector so the loader can use it/create new ones as necessary.

loader->tls_section_hook = [&](size_t size, size_t alignment) {

ASSERT(size);

master_tls_region = allocate_region({}, size, String(), PROT_READ | PROT_WRITE);

master_tls_size = size;

master_tls_alignment = alignment;

return master_tls_region->vaddr().as_ptr();

};

bool success = loader->load();

if (!success) {

klog() << "do_exec: Failure loading " << path.characters();

return -ENOEXEC;

}

// FIXME: Validate that this virtual address is within executable region,

// instead of just non-null. You could totally have a DSO with entry point of

// the beginning of the text segement.

if (!loader->entry().offset(totally_random_offset).get()) {

klog() << "do_exec: Failure loading " << path.characters() << ", entry pointer is invalid! (" << loader->entry().offset(totally_random_offset) << ")";

return -ENOEXEC;

}

rollback_regions_guard.disarm();

// NOTE: At this point, we've committed to the new executable.

entry_eip = loader->entry().offset(totally_random_offset).get();

kill_threads_except_self();

#ifdef EXEC_DEBUG

klog() << "Memory layout after ELF load:";

dump_regions();

#endif

}

m_executable = main_program_description->custody();

m_promises = m_execpromises;

m_veil_state = VeilState::None;

m_unveiled_paths.clear();

// Copy of the master TLS region that we will clone for new threads

m_master_tls_region = master_tls_region->make_weak_ptr();

auto main_program_metadata = main_program_description->metadata();

if (!(main_program_description->custody()->mount_flags() & MS_NOSUID)) {

if (main_program_metadata.is_setuid())

m_euid = main_program_metadata.uid;

if (main_program_metadata.is_setgid())

m_egid = main_program_metadata.gid;

}

Thread::current->set_default_signal_dispositions();

Thread::current->m_signal_mask = 0;

Thread::current->m_pending_signals = 0;

m_futex_queues.clear();

m_region_lookup_cache = {};