MaxOS::processes::resources::ProcessResource Class Reference

A wrapper for a Process which exposes Process operations as Resource operations. More...

#include <scheduler_resources.h>

Inheritance diagram for MaxOS::processes::resources::ProcessResource:

Public Member Functions
	ProcessResource (const string &name, size_t flags, resource_type_t type)
void	close (size_t flags) final
	Closes the process resource, killing the process and removing it from the scheduler.
int	read (void *buffer, size_t size, size_t flags) final
	Reads data from the process resource.
int	write (const void *buffer, size_t size, size_t flags) final
	Writes data to the process resource.

Public Attributes
Process *	process
	The process that this resource handles & exposes.
uint64_t	exit_code
	The exit code of the process once it has exited.

Detailed Description

A wrapper for a Process which exposes Process operations as Resource operations.

See also

Process

Resource

Note

The process pointer will be freed by scheduler during close()

Definition at line 34 of file scheduler_resources.h.

Constructor & Destructor Documentation

ProcessResource()

ProcessResource::ProcessResource	(	const string &	name,
		size_t	flags,
		resource_type_t	type
	)

Definition at line 20 of file scheduler_resources.cpp.

: Resource(name, flags, type)
{
 
}

Member Function Documentation

close()

void ProcessResource::close ( size_t  flags )

final

Closes the process resource, killing the process and removing it from the scheduler.

Parameters

flags

N/A

Definition at line 31 of file scheduler_resources.cpp.

                                        {
 
    if(process)
        GlobalScheduler::remove_process(process);
}

References process, and MaxOS::processes::GlobalScheduler::remove_process().

read()

int ProcessResource::read ( void *  buffer, size_t  size, size_t  flags  )

final

Reads data from the process resource.

Parameters

buffer	The buffer to read into
size	The number of bytes to read
flags	The flags to pass to the reading

Returns

The number of bytes successfully read or -1 on error

Definition at line 46 of file scheduler_resources.cpp.

                                                                 {
 
    // Process not found (allow reading stats only to get exit code)
    if(!process && flags != (size_t)ProcessFlags::READ_STATS)
        return -1;
 
    switch ((ProcessFlags)flags) {
 
        case ProcessFlags::READ_STATS: {
 
            // Check bounds
            if(size < sizeof(process_stats_t))
                return -1;
 
            // Get the info
            process_stats_t stats = {};
            if(process) {
                stats.pid = process->pid();
                stats.parent_pid = 0; //TODO: store parent pid
                stats.thread_count = process->threads().size();
                stats.total_ticks = process->total_ticks();
                stats.memory_usage = 0; //process->memory_manager->memory_used(); TODO: boken?
                stats.handle_count = process->resource_manager.resources().size();
            }
            stats.exit_code = exit_code;
 
            // Copy across
            memcpy(buffer, &stats, sizeof(process_stats_t));
            return sizeof(process_stats_t);
 
        }
 
        case ProcessFlags::READ_ENVIRONMENT: {
 
            // Check bounds
            if(size < sizeof(process_environment_t))
                return -1;
 
            // Get the info
            process_environment_t info;
            info.args = 0;
            info.arg_count = 0; //TODO: store
            info.env_vars = 0;  //TODO: implement
            info.env_var_count = 0;
            info.working_directory = (const char*)MemoryManager::malloc(process->working_directory.length() + 1);
            info.executable_path = 0;// TODO: store
 
            // Copy the info
            // .. args
            // .. env vars
            memcpy((void*)info.working_directory, process->working_directory.c_str(), process->working_directory.length() + 1);
            // .. executable path
 
            // Copy across
            memcpy(buffer, &info, sizeof(process_environment_t));
            return sizeof(process_environment_t);
 
        }
 
 
        case ProcessFlags::READ_HANDLES: {
 
            // Check bounds
            size_t size_needed = sizeof(handle_info_t) * process->resource_manager.resources().size();
            if(size < size_needed)
                return -1;
 
            for(const auto& resource : process->resource_manager.resources()) {
 
                // Get the info
                handle_info_t handle_info;
                handle_info.handle = resource.first;
                handle_info.type = resource.second->type();
                handle_info.name = (const char*)MemoryManager::malloc(resource.second->name().length() + 1);
                memcpy((void*)handle_info.name, resource.second->name().c_str(), resource.second->name().length() + 1);
 
                // Copy across
                memcpy(buffer, &handle_info, sizeof(handle_info_t));
                buffer = (void*)((uintptr_t)buffer + sizeof(handle_info_t));
            }
 
            return (int)size_needed;
 
        }
 
        default:
            return -1;
    }
}

References exit_code, MaxOS::memory::MemoryManager::malloc(), MaxOS::processes::Process::pid(), process, MaxOS::processes::Process::resource_manager, MaxOS::processes::resources::ResourceManager::resources(), MaxOS::processes::Process::threads(), MaxOS::processes::Process::total_ticks(), and MaxOS::processes::Process::working_directory.

write()

int ProcessResource::write ( const void *  buffer, size_t  size, size_t  flags  )

final

Writes data to the process resource.

Parameters

buffer	The buffer to write from
size	The number of bytes to write
flags	The flags to pass to the writing

Returns

The number of bytes successfully written or -1 on error

Definition at line 145 of file scheduler_resources.cpp.

                                                                        {
 
    // Process not found
    if(!process)
        return -1;
 
    switch ((ProcessFlags)flags) {
 
        case ProcessFlags::WRITE_CHANGE_DIRECTORY: {
 
            // Change the working directory
            string new_directory = string((const char*)buffer);
            process->working_directory = new_directory;
            return size;
        }
 
        case ProcessFlags::WRITE_KILL: {
 
            // Kill the process
            exit_code = *((uint64_t*)buffer);
            GlobalScheduler::remove_process(process);
            process->threads()[0]->yield();
 
            return size;
        }
 
        default:
            return -1;
    }
}

References exit_code, process, MaxOS::processes::GlobalScheduler::remove_process(), MaxOS::processes::Process::threads(), and MaxOS::processes::Process::working_directory.

Member Data Documentation

exit_code

uint64_t MaxOS::processes::resources::ProcessResource::exit_code

The exit code of the process once it has exited.

Definition at line 41 of file scheduler_resources.h.

Referenced by read(), and write().

process

Process* MaxOS::processes::resources::ProcessResource::process

The process that this resource handles & exposes.

Definition at line 40 of file scheduler_resources.h.

Referenced by close(), read(), and write().

---

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