d8/ddf/program__syscalls_8h_source.html

#pragma once


#include <cstdint>

#include <vector>


#include "contur/core/types.h"


#include "contur/arch/block.h"

#include "contur/arch/interrupt.h"

#include "contur/arch/program_builder.h"

#include "contur/fs/file_descriptor.h"

#include "contur/io/io_types.h"

#include "contur/syscall/syscall_conventions.h"

#include "contur/syscall/syscall_ids.h"


namespace contur {


    inline void emitOpen(std::vector<Block> &code, RegisterValue resourceId, IoResourceKind kind, OpenMode mode)

    {

        constexpr auto kSyscall = SYSCALL_ID_REGISTER;

        constexpr auto kArg0 = SYSCALL_ARG_REGISTERS[0];

        constexpr auto kArg1 = SYSCALL_ARG_REGISTERS[1];

        constexpr auto kArg2 = SYSCALL_ARG_REGISTERS[2];

        constexpr auto kArg3 = SYSCALL_ARG_REGISTERS[3];


        code.push_back(movImm(kSyscall, static_cast<RegisterValue>(SyscallId::Open)));

        code.push_back(movImm(kArg0, resourceId));

        code.push_back(movImm(kArg1, static_cast<RegisterValue>(kind)));

        code.push_back(movImm(kArg2, static_cast<RegisterValue>(mode)));

        code.push_back(movImm(kArg3, 0));

        code.push_back(interrupt(Interrupt::SystemCall));

    }


    inline void emitRead(std::vector<Block> &code, std::uint8_t fdReg)

    {

        constexpr auto kSyscall = SYSCALL_ID_REGISTER;

        constexpr auto kArg0 = SYSCALL_ARG_REGISTERS[0];


        code.push_back(movImm(kSyscall, static_cast<RegisterValue>(SyscallId::Read)));

        code.push_back(movReg(kArg0, fdReg));

        code.push_back(interrupt(Interrupt::SystemCall));

    }


    inline void emitWrite(std::vector<Block> &code, std::uint8_t fdReg, std::uint8_t valReg)

    {

        constexpr auto kSyscall = SYSCALL_ID_REGISTER;

        constexpr auto kArg0 = SYSCALL_ARG_REGISTERS[0];

        constexpr auto kArg1 = SYSCALL_ARG_REGISTERS[1];


        code.push_back(movImm(kSyscall, static_cast<RegisterValue>(SyscallId::Write)));

        code.push_back(movReg(kArg0, fdReg));

        code.push_back(movReg(kArg1, valReg));

        code.push_back(interrupt(Interrupt::SystemCall));

    }


    inline void emitClose(std::vector<Block> &code, std::uint8_t fdReg)

    {

        constexpr auto kSyscall = SYSCALL_ID_REGISTER;

        constexpr auto kArg0 = SYSCALL_ARG_REGISTERS[0];


        code.push_back(movImm(kSyscall, static_cast<RegisterValue>(SyscallId::Close)));

        code.push_back(movReg(kArg0, fdReg));

        code.push_back(interrupt(Interrupt::SystemCall));

    }


} // namespace contur

block.h
Block — the fundamental unit of simulated memory.

file_descriptor.h
File descriptor types and descriptor-table abstraction.

interrupt.h
Interrupt enum class — hardware and software interrupt codes.

io_types.h
Common I/O descriptor and resource-type definitions.

contur
Definition block.h:15

contur::Interrupt::SystemCall
@ SystemCall
Software interrupt — syscall entry.
Definition interrupt.h:21

contur::interrupt
Block interrupt(Interrupt code) noexcept
Raises a software interrupt.
Definition program_builder.h:196

contur::movReg
Block movReg(std::uint8_t dst, std::uint8_t src) noexcept
Copies the value of one register into another.
Definition program_builder.h:32

contur::emitClose
void emitClose(std::vector< Block > &code, std::uint8_t fdReg)
Emits instructions to close a kernel I/O descriptor.
Definition program_syscalls.h:92

contur::SYSCALL_ID_REGISTER
constexpr std::uint8_t SYSCALL_ID_REGISTER
Register used to pass syscall id and receive return value.
Definition syscall_conventions.h:14

contur::emitRead
void emitRead(std::vector< Block > &code, std::uint8_t fdReg)
Emits instructions to read one value from a kernel I/O descriptor.
Definition program_syscalls.h:59

contur::movImm
Block movImm(std::uint8_t reg, RegisterValue value) noexcept
Loads an immediate value into a register.
Definition program_builder.h:23

contur::OpenMode
OpenMode
Open mode bit flags.
Definition file_descriptor.h:40

contur::SyscallId::Write
@ Write
Write bytes to a kernel-managed sink.
Definition syscall_ids.h:16

contur::SyscallId::Read
@ Read
Read bytes from a kernel-managed source.
Definition syscall_ids.h:18

contur::SyscallId::Open
@ Open
Open file/device.
Definition syscall_ids.h:26

contur::SyscallId::Close
@ Close
Close file/device.
Definition syscall_ids.h:28

contur::emitWrite
void emitWrite(std::vector< Block > &code, std::uint8_t fdReg, std::uint8_t valReg)
Emits instructions to write one value to a kernel I/O descriptor.
Definition program_syscalls.h:76

contur::IoResourceKind
IoResourceKind
Resource kinds supported by the kernel I/O layer.
Definition io_types.h:31

contur::SYSCALL_ARG_REGISTERS
constexpr std::array< std::uint8_t, 4 > SYSCALL_ARG_REGISTERS
Registers used to pass syscall arguments.
Definition syscall_conventions.h:17

contur::RegisterValue
std::int32_t RegisterValue
Value stored in a CPU register.
Definition types.h:21

contur::emitOpen
void emitOpen(std::vector< Block > &code, RegisterValue resourceId, IoResourceKind kind, OpenMode mode)
Emits instructions to open a kernel I/O resource.
Definition program_syscalls.h:36

program_builder.h
Inline Block construction helpers for assembling bytecode programs.

syscall_conventions.h
Register conventions for system call dispatch.

syscall_ids.h
Syscall IDs for the user-kernel boundary.

types.h
Common type aliases, sentinel constants, and forward declarations used throughout the Contur 2 kernel...