path: root/Kernel/CoreDump.cpp

/*
 * Copyright (c) 2019-2020, Jesse Buhagiar <jooster669@gmail.com>
 * Copyright (c) 2020, Itamar S. <itamar8910@gmail.com>
 * 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/ByteBuffer.h>
#include <AK/JsonObject.h>
#include <Kernel/CoreDump.h>
#include <Kernel/FileSystem/Custody.h>
#include <Kernel/FileSystem/FileDescription.h>
#include <Kernel/FileSystem/VirtualFileSystem.h>
#include <Kernel/Process.h>
#include <Kernel/Ptrace.h>
#include <Kernel/RTC.h>
#include <Kernel/SpinLock.h>
#include <Kernel/VM/ProcessPagingScope.h>
#include <LibELF/CoreDump.h>
#include <LibELF/exec_elf.h>

namespace Kernel {

OwnPtr<CoreDump> CoreDump::create(NonnullRefPtr<Process> process, const String& output_path)
{
    if (!process->is_dumpable()) {
        dbgln("Refusing to generate CoreDump for non-dumpable process {}", process->pid().value());
        return nullptr;
    }

    auto fd = create_target_file(process, output_path);
    if (!fd)
        return nullptr;
    return adopt_own(*new CoreDump(move(process), fd.release_nonnull()));
}

CoreDump::CoreDump(NonnullRefPtr<Process> process, NonnullRefPtr<FileDescription>&& fd)
    : m_process(move(process))
    , m_fd(move(fd))
    , m_num_program_headers(m_process->m_regions.size() + 1) // +1 for NOTE segment
{
}

CoreDump::~CoreDump()
{
}

RefPtr<FileDescription> CoreDump::create_target_file(const Process& process, const String& output_path)
{
    LexicalPath lexical_path(output_path);
    auto output_directory = lexical_path.dirname();
    if (VFS::the().open_directory(output_directory, VFS::the().root_custody()).is_error()) {
        auto res = VFS::the().mkdir(output_directory, 0777, VFS::the().root_custody());
        if (res.is_error())
            return nullptr;
    }
    auto tmp_dir = VFS::the().open_directory(output_directory, VFS::the().root_custody());
    if (tmp_dir.is_error())
        return nullptr;
    auto fd_or_error = VFS::the().open(
        lexical_path.basename(),
        O_CREAT | O_WRONLY | O_EXCL,
        0, // We will enable reading from userspace when we finish generating the coredump file
        *tmp_dir.value(),
        UidAndGid { process.uid(), process.gid() });

    if (fd_or_error.is_error())
        return nullptr;

    return fd_or_error.value();
}

KResult CoreDump::write_elf_header()
{
    Elf32_Ehdr elf_file_header;
    elf_file_header.e_ident[EI_MAG0] = 0x7f;
    elf_file_header.e_ident[EI_MAG1] = 'E';
    elf_file_header.e_ident[EI_MAG2] = 'L';
    elf_file_header.e_ident[EI_MAG3] = 'F';
    elf_file_header.e_ident[EI_CLASS] = ELFCLASS32;
    elf_file_header.e_ident[EI_DATA] = ELFDATA2LSB;
    elf_file_header.e_ident[EI_VERSION] = EV_CURRENT;
    elf_file_header.e_ident[EI_OSABI] = 0; // ELFOSABI_NONE
    elf_file_header.e_ident[EI_ABIVERSION] = 0;
    elf_file_header.e_ident[EI_PAD + 1] = 0;
    elf_file_header.e_ident[EI_PAD + 2] = 0;
    elf_file_header.e_ident[EI_PAD + 3] = 0;
    elf_file_header.e_ident[EI_PAD + 4] = 0;
    elf_file_header.e_ident[EI_PAD + 5] = 0;
    elf_file_header.e_ident[EI_PAD + 6] = 0;
    elf_file_header.e_type = ET_CORE;
    elf_file_header.e_machine = EM_386;
    elf_file_header.e_version = 1;
    elf_file_header.e_entry = 0;
    elf_file_header.e_phoff = sizeof(Elf32_Ehdr);
    elf_file_header.e_shoff = 0;
    elf_file_header.e_flags = 0;
    elf_file_header.e_ehsize = sizeof(Elf32_Ehdr);
    elf_file_header.e_shentsize = sizeof(Elf32_Shdr);
    elf_file_header.e_phentsize = sizeof(Elf32_Phdr);
    elf_file_header.e_phnum = m_num_program_headers;
    elf_file_header.e_shnum = 0;
    elf_file_header.e_shstrndx = SHN_UNDEF;

    auto result = m_fd->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&elf_file_header)), sizeof(Elf32_Ehdr));
    if (result.is_error())
        return result.error();
    return KSuccess;
}

KResult CoreDump::write_program_headers(size_t notes_size)
{
    size_t offset = sizeof(Elf32_Ehdr) + m_num_program_headers * sizeof(Elf32_Phdr);
    for (auto& region : m_process->m_regions) {
        Elf32_Phdr phdr {};

        phdr.p_type = PT_LOAD;
        phdr.p_offset = offset;
        phdr.p_vaddr = reinterpret_cast<uint32_t>(region.vaddr().as_ptr());
        phdr.p_paddr = 0;

        phdr.p_filesz = region.page_count() * PAGE_SIZE;
        phdr.p_memsz = region.page_count() * PAGE_SIZE;
        phdr.p_align = 0;

        phdr.p_flags = region.is_readable() ? PF_R : 0;
        if (region.is_writable())
            phdr.p_flags |= PF_W;
        if (region.is_executable())
            phdr.p_flags |= PF_X;

        offset += phdr.p_filesz;

        [[maybe_unused]] auto rc = m_fd->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&phdr)), sizeof(Elf32_Phdr));
    }

    Elf32_Phdr notes_pheader {};
    notes_pheader.p_type = PT_NOTE;
    notes_pheader.p_offset = offset;
    notes_pheader.p_vaddr = 0;
    notes_pheader.p_paddr = 0;
    notes_pheader.p_filesz = notes_size;
    notes_pheader.p_memsz = notes_size;
    notes_pheader.p_align = 0;
    notes_pheader.p_flags = 0;

    auto result = m_fd->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&notes_pheader)), sizeof(Elf32_Phdr));
    if (result.is_error())
        return result.error();
    return KSuccess;
}

KResult CoreDump::write_regions()
{
    for (auto& region : m_process->m_regions) {
        if (region.is_kernel())
            continue;

        region.set_readable(true);
        region.remap();

        for (size_t i = 0; i < region.page_count(); i++) {
            auto* page = region.physical_page(i);

            uint8_t zero_buffer[PAGE_SIZE] = {};
            Optional<UserOrKernelBuffer> src_buffer;

            if (page) {
                src_buffer = UserOrKernelBuffer::for_user_buffer(reinterpret_cast<uint8_t*>((region.vaddr().as_ptr() + (i * PAGE_SIZE))), PAGE_SIZE);
            } else {
                // If the current page is not backed by a physical page, we zero it in the coredump file.
                // TODO: Do we want to include the contents of pages that have not been faulted-in in the coredump?
                //       (A page may not be backed by a physical page because it has never been faulted in when the process ran).
                src_buffer = UserOrKernelBuffer::for_kernel_buffer(zero_buffer);
            }
            auto result = m_fd->write(src_buffer.value(), PAGE_SIZE);
            if (result.is_error())
                return result.error();
        }
    }
    return KSuccess;
}

KResult CoreDump::write_notes_segment(ByteBuffer& notes_segment)
{
    auto result = m_fd->write(UserOrKernelBuffer::for_kernel_buffer(notes_segment.data()), notes_segment.size());
    if (result.is_error())
        return result.error();
    return KSuccess;
}

ByteBuffer CoreDump::create_notes_process_data() const
{
    ByteBuffer process_data;

    ELF::Core::ProcessInfo info {};
    info.header.type = ELF::Core::NotesEntryHeader::Type::ProcessInfo;
    info.pid = m_process->pid().value();

    process_data.append((void*)&info, sizeof(info));

    auto executable_path = String::empty();
    if (auto executable = m_process->executable())
        executable_path = executable->absolute_path();
    process_data.append(executable_path.characters(), executable_path.length() + 1);

    return process_data;
}

ByteBuffer CoreDump::create_notes_threads_data() const
{
    ByteBuffer threads_data;

    m_process->for_each_thread([&](Thread& thread) {
        ByteBuffer entry_buff;

        ELF::Core::ThreadInfo info {};
        info.header.type = ELF::Core::NotesEntryHeader::Type::ThreadInfo;
        info.tid = thread.tid().value();
        Ptrace::copy_kernel_registers_into_ptrace_registers(info.regs, thread.get_register_dump_from_stack());

        entry_buff.append((void*)&info, sizeof(info));

        threads_data += entry_buff;

        return IterationDecision::Continue;
    });
    return threads_data;
}

ByteBuffer CoreDump::create_notes_regions_data() const
{
    ByteBuffer regions_data;
    for (size_t region_index = 0; region_index < m_process->m_regions.size(); ++region_index) {

        ByteBuffer memory_region_info_buffer;
        ELF::Core::MemoryRegionInfo info {};
        info.header.type = ELF::Core::NotesEntryHeader::Type::MemoryRegionInfo;

        auto& region = m_process->m_regions[region_index];
        info.region_start = reinterpret_cast<uint32_t>(region.vaddr().as_ptr());
        info.region_end = reinterpret_cast<uint32_t>(region.vaddr().as_ptr() + region.size());
        info.program_header_index = region_index;

        memory_region_info_buffer.append((void*)&info, sizeof(info));

        auto name = region.name();
        if (name.is_null())
            name = String::empty();
        memory_region_info_buffer.append(name.characters(), name.length() + 1);

        regions_data += memory_region_info_buffer;
    }
    return regions_data;
}

ByteBuffer CoreDump::create_notes_metadata_data() const
{
    ByteBuffer metadata_data;

    ELF::Core::Metadata metadata {};
    metadata.header.type = ELF::Core::NotesEntryHeader::Type::Metadata;
    metadata_data.append((void*)&metadata, sizeof(metadata));

    JsonObject metadata_obj;
    for (auto& it : m_process->coredump_metadata())
        metadata_obj.set(it.key, it.value);
    auto json_data = metadata_obj.to_string();
    metadata_data.append(json_data.characters(), json_data.length() + 1);

    return metadata_data;
}

ByteBuffer CoreDump::create_notes_segment_data() const
{
    ByteBuffer notes_buffer;

    notes_buffer += create_notes_process_data();
    notes_buffer += create_notes_threads_data();
    notes_buffer += create_notes_regions_data();
    notes_buffer += create_notes_metadata_data();

    ELF::Core::NotesEntryHeader null_entry {};
    null_entry.type = ELF::Core::NotesEntryHeader::Type::Null;
    notes_buffer.append(&null_entry, sizeof(null_entry));

    return notes_buffer;
}

KResult CoreDump::write()
{
    ScopedSpinLock lock(m_process->get_lock());
    ProcessPagingScope scope(m_process);

    ByteBuffer notes_segment = create_notes_segment_data();

    auto result = write_elf_header();
    if (result.is_error())
        return result;
    result = write_program_headers(notes_segment.size());
    if (result.is_error())
        return result;
    result = write_regions();
    if (result.is_error())
        return result;
    result = write_notes_segment(notes_segment);
    if (result.is_error())
        return result;

    return m_fd->chmod(0400); // Make coredump file readable
}

}