TheCloud/thor-os
1
0
Fork 0
mirror of https://github.com/wichtounet/thor-os.git synced 2025-09-17 00:26:44 -04:00
Code Issues Packages Projects Releases Wiki Activity

Store the name of the processes

Browse Source
This commit is contained in:
Baptiste Wicht 2016-08-07 19:41:56 +02:00
parent d660e4fba0
commit 68cbf3d3d5
7 changed files with 26 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
kernel/include/process.hpp
View File

@ -68,6 +68,8 @@ struct process_t {
volatile interrupt::syscall_regs* context;
std::vector<segment_t> segments;
std::string name;
};
constexpr const size_t program_base = 0x8000000000;

4
kernel/include/scheduler.hpp
View File

@ -56,8 +56,8 @@ void set_working_directory(const std::vector<std::string>& directory);
void block_process_light(pid_t pid);
//TODO Maybe do that for unblock as well!
process_t& create_kernel_task(char* user_stack, char* kernel_stack, void (*fun)());
process_t& create_kernel_task_args(char* user_stack, char* kernel_stack, void (*fun)(void*), void* data);
process_t& create_kernel_task(const char* name, char* user_stack, char* kernel_stack, void (*fun)());
process_t& create_kernel_task_args(const char* name, char* user_stack, char* kernel_stack, void (*fun)(void*), void* data);
void queue_system_process(pid_t pid);
/*!

3
kernel/src/fs/procfs.cpp
View File

@ -46,6 +46,8 @@ std::string get_value(uint64_t pid, const std::string& name){
return process.process.system ? "true" : "false";
} else if(name == "priority"){
return std::to_string(process.process.priority);
} else if(name == "name"){
return process.process.name;
} else {
return "";
}
@ -63,6 +65,7 @@ procfs::procfs_file_system::procfs_file_system(std::string mp) : mount_point(mp)
standard_contents.emplace_back("state", false, false, false, 0);
standard_contents.emplace_back("system", false, false, false, 0);
standard_contents.emplace_back("priority", false, false, false, 0);
standard_contents.emplace_back("name", false, false, false, 0);
}
procfs::procfs_file_system::~procfs_file_system(){

4
kernel/src/network.cpp
View File

@ -107,8 +107,8 @@ void network::finalize(){
auto* tx_user_stack = new char[scheduler::user_stack_size];
auto* tx_kernel_stack = new char[scheduler::kernel_stack_size];
auto& rx_process = scheduler::create_kernel_task_args(rx_user_stack, rx_kernel_stack, &rx_thread, &interface);
auto& tx_process = scheduler::create_kernel_task_args(tx_user_stack, tx_kernel_stack, &tx_thread, &interface);
auto& rx_process = scheduler::create_kernel_task_args("net_rx", rx_user_stack, rx_kernel_stack, &rx_thread, &interface);
auto& tx_process = scheduler::create_kernel_task_args("net_tx", tx_user_stack, tx_kernel_stack, &tx_thread, &interface);
rx_process.ppid = 1;
tx_process.ppid = 1;

17
kernel/src/scheduler.cpp
View File

@ -229,7 +229,7 @@ void queue_process(scheduler::pid_t pid){
}
void create_idle_task(){
auto& idle_process = scheduler::create_kernel_task(new char[scheduler::user_stack_size], new char[scheduler::kernel_stack_size], &idle_task);
auto& idle_process = scheduler::create_kernel_task("idle", new char[scheduler::user_stack_size], new char[scheduler::kernel_stack_size], &idle_task);
idle_process.ppid = 0;
idle_process.priority = scheduler::MIN_PRIORITY;
@ -240,7 +240,7 @@ void create_idle_task(){
}
void create_init_task(){
auto& init_process = scheduler::create_kernel_task(new char[scheduler::user_stack_size], new char[scheduler::kernel_stack_size], &init_task);
auto& init_process = scheduler::create_kernel_task("init", new char[scheduler::user_stack_size], new char[scheduler::kernel_stack_size], &init_task);
init_process.ppid = 0;
init_process.priority = scheduler::MIN_PRIORITY + 1;
@ -249,7 +249,7 @@ void create_init_task(){
}
void create_gc_task(){
auto& gc_process = scheduler::create_kernel_task(new char[scheduler::user_stack_size], new char[scheduler::kernel_stack_size], &gc_task);
auto& gc_process = scheduler::create_kernel_task("gc", new char[scheduler::user_stack_size], new char[scheduler::kernel_stack_size], &gc_task);
gc_process.ppid = 1;
gc_process.priority = scheduler::MIN_PRIORITY + 1;
@ -260,7 +260,7 @@ void create_gc_task(){
}
void create_post_init_task(){
auto& post_init_process = scheduler::create_kernel_task(new char[scheduler::user_stack_size], new char[scheduler::kernel_stack_size], &post_init_task);
auto& post_init_process = scheduler::create_kernel_task("post_init", new char[scheduler::user_stack_size], new char[scheduler::kernel_stack_size], &post_init_task);
post_init_process.ppid = 1;
post_init_process.priority = scheduler::MAX_PRIORITY;
@ -632,6 +632,8 @@ int64_t scheduler::exec(const std::string& file, const std::vector<std::string>&
auto& process = new_process();
process.name = file;
if(!create_paging(buffer, process)){
logging::log(logging::log_level::DEBUG, "scheduler:exec: Impossible to create paging\n");
@ -896,12 +898,13 @@ void scheduler::set_working_directory(const std::vector<std::string>& directory)
pcb[current_pid].working_directory = directory;
}
scheduler::process_t& scheduler::create_kernel_task(char* user_stack, char* kernel_stack, void (*fun)()){
scheduler::process_t& scheduler::create_kernel_task(const char* name, char* user_stack, char* kernel_stack, void (*fun)()){
auto& process = new_process();
process.system = true;
process.physical_cr3 = paging::get_physical_pml4t();
process.paging_size = 0;
process.name = name;
// Directly uses memory of the executable
process.physical_user_stack = 0;
@ -931,8 +934,8 @@ scheduler::process_t& scheduler::create_kernel_task(char* user_stack, char* kern
return process;
}
scheduler::process_t& scheduler::create_kernel_task_args(char* user_stack, char* kernel_stack, void (*fun)(void*), void* data){
auto& process = scheduler::create_kernel_task(user_stack, kernel_stack, reinterpret_cast<void(*)()>(fun));
scheduler::process_t& scheduler::create_kernel_task_args(const char* name, char* user_stack, char* kernel_stack, void (*fun)(void*), void* data){
auto& process = scheduler::create_kernel_task(name, user_stack, kernel_stack, reinterpret_cast<void(*)()>(fun));
// rdi is the first register used for integers parameter passing
process.context->rdi = reinterpret_cast<size_t>(data);

2
kernel/src/thor_acpi.cpp
View File

@ -186,7 +186,7 @@ ACPI_STATUS AcpiOsExecute(ACPI_EXECUTE_TYPE /*type*/, ACPI_OSD_EXEC_CALLBACK fun
auto* user_stack = new char[scheduler::user_stack_size];
auto* kernel_stack = new char[scheduler::kernel_stack_size];
auto& process = scheduler::create_kernel_task_args(user_stack, kernel_stack, function, context);
auto& process = scheduler::create_kernel_task_args("acpi", user_stack, kernel_stack, function, context);
process.ppid = scheduler::get_pid();
logging::logf(logging::log_level::DEBUG, "ACPICA new process %u\n", process.pid);

9
programs/ps/src/main.cpp
View File

@ -58,7 +58,7 @@ const char* state_str(uint64_t state){
case 1:
return "NEW";
case 2:
return "READ";
return "READY";
case 3:
return "RUNNING";
case 4:
@ -79,6 +79,8 @@ const char* state_str(uint64_t state){
int main(int /*argc*/, char* /*argv*/[]){
auto fd = open("/proc/");
printf("PID PPID Pri State Name\n");
if(fd.valid()){
auto info = stat(*fd);
@ -101,11 +103,12 @@ int main(int /*argc*/, char* /*argv*/[]){
auto system = read_file(base_path + entry_name + "/system") == "true";
auto priority = parse(read_file(base_path + entry_name + "/priority"));
auto state = parse(read_file(base_path + entry_name + "/state"));
auto name = read_file(base_path + entry_name + "/name");
if(system){
printf("%u %u %u %s [kernel]\n", pid, ppid, priority, state_str(state));
printf("%3u %4u %3u %10s %s [kernel]\n", pid, ppid, priority, state_str(state), name.c_str());
} else {
printf("%u %u %u %s \n", pid, ppid, priority, state_str(state));
printf("%3u %4u %3u %10s %s \n", pid, ppid, priority, state_str(state), name.c_str());
}
if(!entry->offset_next){