MaxOS::system::SyscallManager Class Reference

Provides an API for userspace applications to interact with the kernel. More...

#include <syscalls.h>

Inheritance diagram for MaxOS::system::SyscallManager:

Public Member Functions
	SyscallManager ()
	Construct a new Syscall Manager object and register the syscall handlers. Registers to interrupt 0x80.
cpu_status_t *	handle_interrupt (cpu_status_t *esp) final
	Loads the args from the registers and delegates the syscall to the relevant handler if defined.
void	set_syscall_handler (::syscore::SyscallType syscall, syscall_func_t handler)
	Loads a syscall handler into the manager.
void	remove_syscall_handler (::syscore::SyscallType syscall)
	Removes a syscall handler from the manager.

Static Public Member Functions
static syscall_args_t *	syscall_close_process (syscall_args_t *args)
	System call to close a process.
static syscall_args_t *	syscall_klog (syscall_args_t *args)
	System call to log a message to the kernel log.
static syscall_args_t *	syscall_allocate_memory (syscall_args_t *args)
	System call to allocate a block of memory.
static syscall_args_t *	syscall_free_memory (syscall_args_t *args)
	System call to free a block of memory.
static syscall_args_t *	syscall_resource_create (syscall_args_t *args)
	System call to create a resource.
static syscall_args_t *	syscall_resource_open (syscall_args_t *args)
	System call to open a resource.
static syscall_args_t *	syscall_resource_close (syscall_args_t *args)
	System call to close a resource.
static syscall_args_t *	syscall_resource_write (syscall_args_t *args)
	System call to write to a resource.
static syscall_args_t *	syscall_resource_read (syscall_args_t *args)
	System call to read from a resource.
static syscall_args_t *	syscall_thread_yield (syscall_args_t *args)
	System call to yield the current process.
static syscall_args_t *	syscall_thread_sleep (syscall_args_t *args)
	System call to sleep the current process.
static syscall_args_t *	syscall_thread_close (syscall_args_t *args)
	System call to close a thread.

Detailed Description

Provides an API for userspace applications to interact with the kernel.

Todo:

Very c style, should be made class based that automatically registers

Definition at line 58 of file syscalls.h.

Constructor & Destructor Documentation

SyscallManager()

SyscallManager::SyscallManager

(

)

Construct a new Syscall Manager object and register the syscall handlers. Registers to interrupt 0x80.

Definition at line 23 of file syscalls.cpp.

: InterruptHandler(0x80)
{
 
    // Register the handlers
    Logger::INFO() << "Setting up Syscalls \n";
    set_syscall_handler(SyscallType::CLOSE_PROCESS, syscall_close_process);
    set_syscall_handler(SyscallType::KLOG, syscall_klog);
    set_syscall_handler(SyscallType::ALLOCATE_MEMORY, syscall_allocate_memory);
    set_syscall_handler(SyscallType::FREE_MEMORY, syscall_free_memory);
    set_syscall_handler(SyscallType::RESOURCE_CREATE, syscall_resource_create);
    set_syscall_handler(SyscallType::RESOURCE_OPEN, syscall_resource_open);
    set_syscall_handler(SyscallType::RESOURCE_CLOSE, syscall_resource_close);
    set_syscall_handler(SyscallType::RESOURCE_WRITE, syscall_resource_write);
    set_syscall_handler(SyscallType::RESOURCE_READ, syscall_resource_read);
    set_syscall_handler(SyscallType::THREAD_YIELD, syscall_thread_yield);
    set_syscall_handler(SyscallType::THREAD_SLEEP, syscall_thread_sleep);
    set_syscall_handler(SyscallType::THREAD_CLOSE, syscall_thread_close);
 
}

References MaxOS::Logger::INFO(), set_syscall_handler(), syscall_allocate_memory(), syscall_close_process(), syscall_free_memory(), syscall_klog(), syscall_resource_close(), syscall_resource_create(), syscall_resource_open(), syscall_resource_read(), syscall_resource_write(), syscall_thread_close(), syscall_thread_sleep(), and syscall_thread_yield().

Member Function Documentation

handle_interrupt()

cpu_status_t * SyscallManager::handle_interrupt ( cpu_status_t *  status )

finalvirtual

Loads the args from the registers and delegates the syscall to the relevant handler if defined.

Parameters

status

The cpu state

Returns

The cpu state (may be modified with return value in RAX or a new state by the handler)

Reimplemented from MaxOS::hardwarecommunication::InterruptHandler.

Definition at line 52 of file syscalls.cpp.

                                                                   {
 
    // Get the args from the cpu state
    syscall_args_t args;
    args.arg0 = status->rdi;
    args.arg1 = status->rsi;
    args.arg2 = status->rdx;
    args.arg3 = status->r10;
    args.arg4 = status->r8;
    args.arg5 = status->r9;
    args.return_value = 0;
    args.return_state = status;
 
    // Call the handler
    uint64_t syscall = status->rax;
    if (m_syscall_handlers[syscall] != nullptr)
        args = *(m_syscall_handlers[syscall](&args));
    else
        Logger::ERROR() << "Syscall " << syscall << " not found\n";
 
    // If there is a specific return state, use that
    if (args.return_state != status)
        return args.return_state;
 
    // Update the cpu state
    status->rdi = args.arg0;
    status->rsi = args.arg1;
    status->rdx = args.arg2;
    status->r10 = args.arg3;
    status->r8 = args.arg4;
    status->r9 = args.arg5;
    status->rax = args.return_value;
 
    // Return the status
    return status;
}

References MaxOS::Logger::ERROR().

remove_syscall_handler()

void SyscallManager::remove_syscall_handler

(

::syscore::SyscallType

syscall

)

Removes a syscall handler from the manager.

Parameters

syscall

The syscall ID number

Definition at line 105 of file syscalls.cpp.

                                                               {
 
    m_syscall_handlers[(uint8_t) syscall] = nullptr;
}

set_syscall_handler()

void SyscallManager::set_syscall_handler	(	::syscore::SyscallType	syscall,
		syscall_func_t	handler
	)

Loads a syscall handler into the manager.

Parameters

syscall	The syscall ID number
handler	The handler to set

Definition at line 95 of file syscalls.cpp.

                                                                                    {
 
    m_syscall_handlers[(uint8_t) syscall] = handler;
}

Referenced by SyscallManager().

syscall_allocate_memory()

syscall_args_t * SyscallManager::syscall_allocate_memory ( syscall_args_t *  args )

static

System call to allocate a block of memory.

Parameters

args	Arg0 = size

Returns

The address of the memory block or null if failed

Definition at line 169 of file syscalls.cpp.

                                                                            {
 
    // Malloc the memory
    size_t size = args->arg0;
    void* address = MemoryManager::malloc(size);
 
    // Return the address
    args->return_value = (uint64_t)address;
    return args;
}

References MaxOS::memory::MemoryManager::malloc().

Referenced by SyscallManager().

syscall_close_process()

syscall_args_t * SyscallManager::syscall_close_process ( system::syscall_args_t *  args )

static

System call to close a process.

Parameters

args	Arg0 = pid Arg1 = exit code

Returns

Nothing

Definition at line 117 of file syscalls.cpp.

                                                                                {
 
    // Get the args
    uint64_t pid = args->arg0;
    int exit_code = (int) args->arg1;
 
    // Close the process
    Process* process = pid == 0 ? GlobalScheduler::current_process() : GlobalScheduler::get_process(pid);
    GlobalScheduler::system_scheduler()->remove_process(process);
 
    // Schedule the next process
    cpu_status_t* next_process = GlobalScheduler::core_scheduler()->schedule_next(args->return_state);
    args->return_state = next_process;
 
    // Done
    return args;
}

References MaxOS::processes::GlobalScheduler::core_scheduler(), MaxOS::processes::GlobalScheduler::current_process(), MaxOS::processes::GlobalScheduler::get_process(), and MaxOS::processes::GlobalScheduler::system_scheduler().

Referenced by SyscallManager().

syscall_free_memory()

syscall_args_t * SyscallManager::syscall_free_memory ( syscall_args_t *  args )

static

System call to free a block of memory.

Parameters

args	Arg0 = address

Returns

Nothing

Definition at line 186 of file syscalls.cpp.

                                                                        {
 
    // Free the memory
    void* address = (void*) args->arg0;
    MemoryManager::free(address);
 
    return args;
}

References MaxOS::memory::MemoryManager::free().

Referenced by SyscallManager().

syscall_klog()

syscall_args_t * SyscallManager::syscall_klog ( syscall_args_t *  args )

static

System call to log a message to the kernel log.

Parameters

args	Arg0 = message

Returns

The same args structure

Definition at line 141 of file syscalls.cpp.

                                                                 {
 
    s_lock.lock();
 
    // Ensure a message was provided
    char* message = (char*) args->arg0;
    if(!message){
        s_lock.unlock();
        return args;
    }
 
    // If the first two characters are %h then no header
    if (message[0] == '%' && message[1] == 'h')
        Logger::Out() << message + 2;
    else
        Logger::INFO() << message;
 
    s_lock.unlock();
 
    return args;
}

References MaxOS::Logger::INFO(), and MaxOS::Logger::Out().

Referenced by SyscallManager().

syscall_resource_close()

syscall_args_t * SyscallManager::syscall_resource_close ( syscall_args_t *  args )

static

System call to close a resource.

Parameters

args	Arg0 = Handle Arg1 = Flags

Returns

Nothing

Definition at line 240 of file syscalls.cpp.

                                                                           {
 
    // Parse params
    auto handle = (uint64_t )args->arg0;
    auto flags  = (size_t)args->arg1;
 
    // Close the resource
    GlobalScheduler::current_process()->resource_manager.close_resource(handle, flags);
    return args;
}

References MaxOS::processes::GlobalScheduler::current_process().

Referenced by SyscallManager().

syscall_resource_create()

syscall_args_t * SyscallManager::syscall_resource_create ( syscall_args_t *  args )

static

System call to create a resource.

Parameters

args	Arg0 = ResourceType Arg1 = Name Arg2 = Flags

Returns

1 if resource was created sucessfully, 0 otherwise

Definition at line 201 of file syscalls.cpp.

                                                                            {
 
    // Parse params
    auto type   = (ResourceType)args->arg0;
    auto name   = (char*)args->arg1;
    auto flags  = (size_t)args->arg2;
 
    // Try to create the resource
    auto resource = GlobalResourceRegistry::get_registry(type)->create_resource(name, flags);
 
    // Handle response
    args->return_value = resource ? 1 : 0;
    return args;
}

References MaxOS::processes::GlobalResourceRegistry::get_registry().

Referenced by SyscallManager().

syscall_resource_open()

syscall_args_t * SyscallManager::syscall_resource_open ( syscall_args_t *  args )

static

System call to open a resource.

Parameters

args	Arg0 = ResourceType Arg1 = Name Arg2 = Flags

Returns

The handle of the resource or 0 if failed

Definition at line 222 of file syscalls.cpp.

                                                                          {
 
    // Parse params
    auto type   = (ResourceType)args->arg0;
    auto name   = (char*)args->arg1;
    auto flags  = (size_t)args->arg2;
 
    // Open the resource
    args->return_value = GlobalScheduler::current_process()->resource_manager.open_resource(type, name, flags);
    return args;
}

References MaxOS::processes::GlobalScheduler::current_process().

Referenced by SyscallManager().

syscall_resource_read()

syscall_args_t * SyscallManager::syscall_resource_read ( syscall_args_t *  args )

static

System call to read from a resource.

Parameters

args	Arg0 = Handle Arg1 = Buffer Arg2 = Size Arg3 = Flags

Returns

The number of bytes read or 0 if failed

Definition at line 283 of file syscalls.cpp.

                                                                          {
 
    // Parse params
    auto handle = (uint64_t )args->arg0;
    auto buffer = (void*)args->arg1;
    auto size   = (size_t)args->arg2;
    auto flags  = (size_t)args->arg3;
 
    // Open the resource
    auto resource = GlobalScheduler::current_process()->resource_manager.get_resource(handle);
    if(!resource){
        args->return_value = 0;
        return args;
    }
 
    // Write to the resource
    args->return_value = resource->read(buffer,size,flags);
    return args;
}

References MaxOS::processes::GlobalScheduler::current_process().

Referenced by SyscallManager().

syscall_resource_write()

syscall_args_t * SyscallManager::syscall_resource_write ( syscall_args_t *  args )

static

System call to write to a resource.

Parameters

args	Arg0 = Handle Arg1 = Buffer Arg2 = Size Arg3 = Flags

Returns

The number of bytes written or 0 if failed

Definition at line 257 of file syscalls.cpp.

                                                                           {
 
    // Parse params
    auto handle = (uint64_t )args->arg0;
    auto buffer = (void*)args->arg1;
    auto size   = (size_t)args->arg2;
    auto flags  = (size_t)args->arg3;
 
    // Open the resource
    auto resource = GlobalScheduler::current_process()->resource_manager.get_resource(handle);
    if(!resource){
        args->return_value = 0;
        return args;
    }
 
    // Write to the resource
    args->return_value = resource->write(buffer,size,flags);
    return args;
}

References MaxOS::processes::GlobalScheduler::current_process().

Referenced by SyscallManager().

syscall_thread_close()

syscall_args_t * SyscallManager::syscall_thread_close ( syscall_args_t *  args )

static

System call to close a thread.

Parameters

args	Arg0 = tid Arg1 = exit code

Returns

Nothing

Definition at line 342 of file syscalls.cpp.

                                                                         {
 
    // Get the args
    uint64_t tid = args->arg0;
    int exit_code = (int) args->arg1;
 
    // Get the thread if it is 0 then it is the current thread
    Thread* thread = tid == 0 ? GlobalScheduler::current_thread() : GlobalScheduler::get_thread(tid);
    thread->thread_state = ThreadState::STOPPED;
 
    // Schedule the next thread
    if(tid == 0){
        cpu_status_t* next_thread = GlobalScheduler::core_scheduler()->schedule_next(args->return_state);
        args->return_state = next_thread;
    }
 
    // Done
    return args;
}

References MaxOS::processes::GlobalScheduler::core_scheduler(), MaxOS::processes::GlobalScheduler::current_thread(), and MaxOS::processes::GlobalScheduler::get_thread().

Referenced by SyscallManager().

syscall_thread_sleep()

syscall_args_t * SyscallManager::syscall_thread_sleep ( syscall_args_t *  args )

static

System call to sleep the current process.

Parameters

args	Arg0 = milliseconds

Returns

Nothing

Definition at line 323 of file syscalls.cpp.

                                                                         {
 
    // Get the milliseconds
    size_t milliseconds = args->arg0;
 
    // Sleep the thread
    GlobalScheduler::current_thread()->sleep(milliseconds);
    args->return_state = GlobalScheduler::yield(args->return_state);
 
    // Done
    return args;
}

References MaxOS::processes::GlobalScheduler::current_thread(), and MaxOS::processes::GlobalScheduler::yield().

Referenced by SyscallManager().

syscall_thread_yield()

syscall_args_t * SyscallManager::syscall_thread_yield ( syscall_args_t *  args )

static

System call to yield the current process.

Parameters

args

Nothing

Returns

Nothing

Definition at line 309 of file syscalls.cpp.

                                                                         {
 
    // Yield
    args->return_state = GlobalScheduler::yield(args->return_state);
 
    return args;
}

References MaxOS::processes::GlobalScheduler::yield().

Referenced by SyscallManager().

---

The documentation for this class was generated from the following files:

• /home/runner/work/MaxOS/MaxOS/kernel/include/system/syscalls.h
• /home/runner/work/MaxOS/MaxOS/kernel/src/system/syscalls.cpp