MaxOS::processes::resources::ProcessResourceRegistry Class Reference

Manages the creation, retention and destruction of resources representing processes. More...

#include <scheduler_resources.h>

Inheritance diagram for MaxOS::processes::resources::ProcessResourceRegistry:

Public Member Functions
Resource *	get_resource (const string &name) final
	The.
Resource *	create_resource (const string &name, size_t flags, uintptr_t data) final
	Opens an executable.
Public Member Functions inherited from MaxOS::processes::resources::ResourceRegistry< ProcessResource >
	ResourceRegistry (resource_type_t type)
	Constructor for ResourceRegistry of a specific type.
Resource *	create_resource (const string &name, size_t flags, uintptr_t data) override
	Create a new resource of the specific type.
Public Member Functions inherited from MaxOS::processes::resources::BaseResourceRegistry
	BaseResourceRegistry (resource_type_t type)
	Constructs a new BaseResourceRegistry object and registers it globally.
	~BaseResourceRegistry ()
	Destructor for BaseResourceRegistry, removes it from the global list.
resource_type_t	type ()
	Gets the type of resources this registry handles.
bool	register_resource (Resource *resource)
	Registers a resource in the registry.
void	close_resource (Resource *resource, size_t flags)
	Close the resource provided, if it exists in this registry.

Additional Inherited Members
Protected Attributes inherited from MaxOS::processes::resources::BaseResourceRegistry
common::Map< string, Resource * >	m_resources
	The map of resource names to resource instances.
common::Map< string, uint64_t >	m_resource_uses
	The map of resource names to how many processes are using them.
common::Spinlock	m_lock
	The lock to make the registry threadsafe.
resource_type_t	m_type
	The resource type that this registry manages.

Detailed Description

Manages the creation, retention and destruction of resources representing processes.

Definition at line 93 of file scheduler_resources.h.

Constructor & Destructor Documentation

ProcessResourceRegistry()

ProcessResourceRegistry::ProcessResourceRegistry

(

)

Definition at line 347 of file scheduler_resources.cpp.

: ResourceRegistry<ProcessResource>(resource_type_t::PROCESS)
{
 
}

Member Function Documentation

create_resource()

Resource * ProcessResourceRegistry::create_resource ( const string &  name, size_t  flags, uintptr_t  data  )

finalvirtual

Opens an executable.

Parameters

name	The path to the executable to open
flags	td

Returns

The Process resource created from the executable or nullptr if failed to open/execute

Todo:

Process needs to own the Elf pointer and free it in destructor (do this when moving ELF as a superclass)

Reimplemented from MaxOS::processes::resources::BaseResourceRegistry.

Definition at line 362 of file scheduler_resources.cpp.

                                                                                                   {
 
    // Get the command
    auto command = (execute_command_t*)data;
    if (!command)
        return nullptr;
 
    // Kernel copy (@todo copy the data page into the new process so dont get unmapped error and also thus dont need a copy)
    auto exec_buffer = buffer_t(command->file_data_size);
    exec_buffer.copy_from(command->file_data, command->file_data_size);
 
    // Copy the args into userspace (@todo bad, two copies)
    uint64_t argc = command->args_count;
    size_t arg_size = argc * sizeof(void*);
    void* argv = MemoryManager::kmalloc(arg_size);
    for (int i = 0; i < argc; i++) {
 
        // Copy each argument
        size_t len = strlen(((char**)command->args)[i]) + 1;
        ((char**)argv)[i] = (char*) MemoryManager::kmalloc(len);
        memcpy((void*) ((char**)argv)[i], (void*) ((char**)command->args)[i], len);
    }
 
    // Load the elf
    auto elf = new ELF64((uintptr_t)exec_buffer.raw());
    if (!elf->is_valid())
        return nullptr;
 
    // Create the processs
    auto process    = new Process(name, argv, argc, elf);
    GlobalScheduler::system_scheduler() -> add_process(process);
 
    // Create the resource
    auto resource   = new ProcessResource(name, flags, resource_type_t::PROCESS);
    resource->process = process;
 
    // Clean up
    // for (int i = 0; i < argc; i++)
    //  delete ((char**)argv)[i];
    // delete argv;
 
 
    // Switch back to the caller proc
    MemoryManager::switch_active_memory_manager(GlobalScheduler::current_process()->memory_manager);
    return resource;
}

References MaxOS::processes::GlobalScheduler::current_process(), MaxOS::memory::MemoryManager::kmalloc(), and MaxOS::processes::GlobalScheduler::system_scheduler().

get_resource()

Resource * ProcessResourceRegistry::get_resource ( const string &  name )

finalvirtual

The.

Parameters

name

Returns

Todo:

'this' is a bit mess

Reimplemented from MaxOS::processes::resources::BaseResourceRegistry.

Definition at line 417 of file scheduler_resources.cpp.

                                                                  {
 
    // Resource already opened
    auto resource = BaseResourceRegistry::get_resource(name);
    if(resource != nullptr)
        return resource;
 
    // Get the process
    uint64_t pid = name.to_int();
    auto process = name == "this" ? GlobalScheduler::current_process() : GlobalScheduler::get_process(pid);
 
    // Self refrence may already be open
    resource = BaseResourceRegistry::get_resource(string(process -> pid()));
    if(resource != nullptr)
        return resource;
 
    // Create the resource
    auto process_resource = new ProcessResource(string(process -> pid()), 0, resource_type_t::PROCESS);
    process_resource->process = process;
 
    register_resource(process_resource);
    return process_resource;
}

References MaxOS::processes::GlobalScheduler::current_process(), MaxOS::processes::GlobalScheduler::get_process(), MaxOS::processes::resources::BaseResourceRegistry::get_resource(), and MaxOS::processes::resources::BaseResourceRegistry::register_resource().

---

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

• /home/runner/work/MaxOS/MaxOS/kernel/include/processes/resources/scheduler_resources.h
• /home/runner/work/MaxOS/MaxOS/kernel/src/processes/resources/scheduler_resources.cpp