posix_spawn.cpp

/*
 * Copyright (c) 2025, Tomás Simões <tomasprsimoes@tecnico.ulisboa.pt>
 * Copyright (c) 2026, Fırat Kızılboğa <firatkizilboga11@gmail.com>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <Kernel/API/spawn.h>
#include <Kernel/Debug.h>
#include <Kernel/Devices/BaseDevices.h>
#include <Kernel/Devices/Device.h>
#include <Kernel/Devices/Generic/NullDevice.h>
#include <Kernel/Devices/TTY/TTY.h>
#include <Kernel/FileSystem/Custody.h>
#include <Kernel/FileSystem/VirtualFileSystem.h>
#include <Kernel/Memory/Region.h>
#include <Kernel/Net/LocalSocket.h>
#include <Kernel/Tasks/PerformanceManager.h>
#include <Kernel/Tasks/Process.h>
#include <Kernel/Tasks/Scheduler.h>
#include <Kernel/Tasks/ScopedProcessList.h>

namespace Kernel {

ErrorOr<void> Process::execute_file_actions(ReadonlyBytes file_actions_data)
{
    size_t offset = 0;
    while (offset < file_actions_data.size()) {
        if (offset + sizeof(SpawnFileActionHeader) > file_actions_data.size())
            return EINVAL;

        auto const* header = reinterpret_cast<SpawnFileActionHeader const*>(file_actions_data.data() + offset);
        if (header->record_length < sizeof(SpawnFileActionHeader))
            return EINVAL;
        if (offset + header->record_length > file_actions_data.size())
            return EINVAL;

        switch (header->type) {
        case SpawnFileActionType::Dup2: {
            if (header->record_length < sizeof(SpawnFileActionDup2))
                return EINVAL;

            auto const* action = reinterpret_cast<SpawnFileActionDup2 const*>(header);
            TRY(m_fds.with_exclusive([&](auto& fds) -> ErrorOr<void> {
                if (action->new_fd < 0 || static_cast<size_t>(action->new_fd) >= fds.max_open())
                    return EINVAL;

                auto description = TRY(fds.open_file_description(action->old_fd));
                if (action->old_fd != action->new_fd) {

                    if (fds.m_fds_metadatas[action->new_fd].is_allocated()) {
                        if (auto* old_description = fds[action->new_fd].description())
                            (void)old_description->close();
                        fds[action->new_fd].clear();
                    } else {
                        fds.m_fds_metadatas[action->new_fd].allocate();
                    }

                    fds[action->new_fd].set(move(description));
                }
                return {};
            }));
            break;
        }
        case SpawnFileActionType::Close: {
            if (header->record_length < sizeof(SpawnFileActionClose))
                return EINVAL;

            auto const* action = reinterpret_cast<SpawnFileActionClose const*>(header);
            TRY(m_fds.with_exclusive([&](auto& fds) -> ErrorOr<void> {
                auto description = TRY(fds.open_file_description(action->fd));
                TRY(description->close());
                fds[action->fd].clear();
                return {};
            }));
            break;
        }
        case SpawnFileActionType::Open: {
            if (header->record_length < sizeof(SpawnFileActionOpen))
                return EINVAL;

            auto const* action = reinterpret_cast<SpawnFileActionOpen const*>(header);
            if (header->record_length < sizeof(SpawnFileActionOpen) + action->path_length)
                return EINVAL;

            auto path = TRY(KString::try_create(StringView { action->path, action->path_length }));
            CustodyBase base(AT_FDCWD, path->view());
            auto description = TRY(VirtualFileSystem::open(
                vfs_root_context(), credentials(), path->view(),
                action->flags, action->mode & ~umask(), base));

            if (description->inode() && description->inode()->bound_socket())
                return ENXIO;

            TRY(m_fds.with_exclusive([&](auto& fds) -> ErrorOr<void> {
                if (action->fd < 0 || static_cast<size_t>(action->fd) >= fds.max_open())
                    return EINVAL;

                if (fds.m_fds_metadatas[action->fd].is_allocated()) {
                    if (auto* old_description = fds[action->fd].description())
                        (void)old_description->close();
                    fds[action->fd].clear();
                } else {
                    fds.m_fds_metadatas[action->fd].allocate();
                }

                u32 fd_flags = (action->flags & O_CLOEXEC) ? FD_CLOEXEC : 0;
                fds[action->fd].set(move(description), fd_flags);
                return {};
            }));
            break;
        }

        case SpawnFileActionType::Chdir: {
            if (header->record_length < sizeof(SpawnFileActionChdir))
                return EINVAL;

            auto const* action = reinterpret_cast<SpawnFileActionChdir const*>(header);
            if (header->record_length < sizeof(SpawnFileActionChdir) + action->path_length)
                return EINVAL;

            auto path = TRY(KString::try_create(StringView { action->path, action->path_length }));
            auto new_directory = TRY(VirtualFileSystem::open_directory(
                vfs_root_context(), credentials(), path->view(), current_directory()));
            m_current_directory.with([&](auto& current_directory) {
                current_directory = move(new_directory);
            });
            break;
        }
        case SpawnFileActionType::Fchdir: {
            if (header->record_length < sizeof(SpawnFileActionFchdir))
                return EINVAL;

            auto const* action = reinterpret_cast<SpawnFileActionFchdir const*>(header);
            auto description = TRY(open_file_description(action->fd));
            if (!description->is_directory())
                return ENOTDIR;

            // Check for search (+x) permission on the directory.
            if (!description->metadata().may_execute(credentials()))
                return EACCES;

            m_current_directory.with([&](auto& current_directory) {
                current_directory = description->custody();
            });
            break;
        }
        default:
            return EINVAL;
        }

        offset += header->record_length;
    }
    return {};
}

// https://pubs.opengroup.org/onlinepubs/9799919799/functions/posix_spawn.html
ErrorOr<FlatPtr> Process::sys$posix_spawn(Userspace<Syscall::SC_posix_spawn_params const*> user_params)
{
    VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
    TRY(require_promise(Pledge::proc));
    TRY(require_promise(Pledge::exec));

    auto params = TRY(copy_typed_from_user(user_params));

    if (params.arguments.length > ARG_MAX || params.environment.length > ARG_MAX)
        return E2BIG;
    if (params.arguments.length == 0)
        return EINVAL;

    if (params.attr_data.ptr() != 0 || params.attr_data_size != 0) {
        // FIXME: Implement spawn attributes handling.
        return ENOTSUP;
    }

    // Copy file actions buffer from userspace
    OwnPtr<KBuffer> file_actions_buffer;
    if (params.serialized_file_actions_data.ptr() != 0 && params.serialized_file_actions_data_size != 0) {

        if (params.serialized_file_actions_data_size > 1 * MiB)
            return E2BIG;
        file_actions_buffer = TRY(KBuffer::try_create_with_size("posix_spawn file actions"sv, params.serialized_file_actions_data_size));
        TRY(copy_from_user(file_actions_buffer->data(), Userspace<u8 const*> { params.serialized_file_actions_data.ptr() }, params.serialized_file_actions_data_size));
    }

    auto path = TRY(get_syscall_path_argument(params.path));

    auto copy_user_strings = [](auto const& list, auto& output) -> ErrorOr<void> {
        if (!list.length)
            return {};
        Checked<size_t> size = sizeof(*list.strings);
        size *= list.length;
        if (size.has_overflow())
            return EOVERFLOW;
        Vector<Syscall::StringArgument, 32> strings;
        TRY(strings.try_resize(list.length));
        TRY(copy_from_user(strings.data(), list.strings, size.value()));
        for (size_t i = 0; i < list.length; ++i) {
            auto string = TRY(try_copy_kstring_from_user(strings[i]));
            TRY(output.try_append(move(string)));
        }
        return {};
    };

    Vector<NonnullOwnPtr<KString>> arguments;
    TRY(copy_user_strings(params.arguments, arguments));

    Vector<NonnullOwnPtr<KString>> environment;
    TRY(copy_user_strings(params.environment, environment));

    auto const& credentials = this->credentials();
    VERIFY(!m_is_kernel_process);
    auto [child, child_first_thread] = TRY(Process::create_spawned(credentials->uid(), credentials->gid(), pid(), vfs_root_context(), hostname_context(), current_directory(), tty()));

    ArmedScopeGuard thread_finalizer_guard = [&child_first_thread]() {
        SpinlockLocker lock(g_scheduler_lock);
        child_first_thread->detach();
        child_first_thread->set_state(Thread::State::Dying);
    };

    // "It is implementation-defined whether the fork handlers are run when posix_spawn() or posix_spawnp() is called."
    // We don't run them, as they are currently implemented in LibC.

    TRY(child->m_fds.with_exclusive([&](auto& child_fds) {
        return m_fds.with_exclusive([&](auto const& parent_fds) {
            return child_fds.try_clone(parent_fds);
        });

        // FD_CLOEXEC is handled by do_exec().
        // FIXME: Support FD_CLOFORK.
    }));

    // Execute file actions on the child's FD table
    if (file_actions_buffer) {
        TRY(child->execute_file_actions(file_actions_buffer->bytes()));
    }

    // FIXME: "If file descriptor 0, 1, or 2 would otherwise be closed in the new process image created by posix_spawn() or posix_spawnp(),
    //         implementations may open an unspecified file for the file descriptor in the new process image."

    // Copy protected data which isn't set by do_exec().
    child->with_mutable_protected_data([&](auto& child_protected_data) {
        with_protected_data([&](auto const& parent_protected_data) {
            child_protected_data.umask = parent_protected_data.umask;
            child_protected_data.process_group = parent_protected_data.process_group;
            child_protected_data.credentials = parent_protected_data.credentials;
        });
    });

    dbgln_if(FORK_DEBUG, "posix_spawn: child={}", child);

    // A child created via posix_spawn inherits a copy of its parent's signal mask
    child_first_thread->update_signal_mask(Thread::current()->signal_mask());

    Thread* new_main_thread = nullptr;
    InterruptsState previous_interrupts_state = InterruptsState::Enabled;
    TRY(child->exec(move(path), move(arguments), move(environment), new_main_thread, previous_interrupts_state, ProcessEventType::Create));
    thread_finalizer_guard.disarm();

    m_scoped_process_list.with([&](auto const& list_ptr) {
        if (list_ptr) {
            child->m_scoped_process_list.with([&](auto& child_list_ptr) {
                child_list_ptr = list_ptr;
            });
            list_ptr->attach(*child);
        }
    });

    commit_creation(child);

    SpinlockLocker lock(g_scheduler_lock);
    new_main_thread->set_affinity(Thread::current()->affinity());
    new_main_thread->set_state(Thread::State::Runnable);

    return child->pid().value();
}
}