2019-02-11 09:30:28 -06:00
|
|
|
#include "tasking_helpers.h"
|
|
|
|
#include "tasking.h"
|
|
|
|
#include "../tasking.h"
|
|
|
|
#include "isr.h"
|
2019-03-23 07:30:18 -05:00
|
|
|
#include <stdio.h>
|
2019-05-11 10:11:28 -05:00
|
|
|
#include <string.h>
|
2019-03-23 07:30:18 -05:00
|
|
|
#include "kmalloc.h"
|
2019-02-11 09:30:28 -06:00
|
|
|
#include "memory.h"
|
2019-03-17 12:22:00 -05:00
|
|
|
#include "gdt.h"
|
2019-04-13 09:23:40 -05:00
|
|
|
#include "paging.h"
|
2019-02-11 09:30:28 -06:00
|
|
|
#include <stdint.h>
|
2019-04-13 09:23:40 -05:00
|
|
|
#include <stdlib.h>
|
2019-06-29 09:04:34 -05:00
|
|
|
#include "../halt.h"
|
2019-08-04 13:14:35 -05:00
|
|
|
#include "serial.h"
|
2019-02-11 09:30:28 -06:00
|
|
|
#define STACK_PAGES 2
|
|
|
|
|
2019-05-21 19:16:19 -05:00
|
|
|
extern void task_init();
|
2019-06-29 09:04:34 -05:00
|
|
|
static uint32_t* kstacks=(uint32_t*)0xF6800000;
|
2019-05-21 19:16:19 -05:00
|
|
|
|
|
|
|
|
2019-02-11 09:30:28 -06:00
|
|
|
uint32_t next_pid;
|
|
|
|
|
2019-05-21 19:16:19 -05:00
|
|
|
Task* currentTask;
|
2019-02-11 09:30:28 -06:00
|
|
|
static Task* headTask;
|
2019-07-20 11:03:27 -05:00
|
|
|
static Task* tailTask;
|
2019-08-04 13:14:35 -05:00
|
|
|
static Task* tasks[32768];
|
2019-05-23 20:21:51 -05:00
|
|
|
Task* tasking_createTaskCr3KmodeParam(void* eip,void* cr3,char kmode,char param1_exists,uint32_t param1_arg,char param2_exists,uint32_t param2_arg);
|
2019-02-11 09:30:28 -06:00
|
|
|
|
2019-05-21 19:16:19 -05:00
|
|
|
void tasking_init(void* esp) {
|
2019-02-11 09:30:28 -06:00
|
|
|
currentTask=NULL;
|
|
|
|
next_pid=0;
|
2019-05-23 20:21:51 -05:00
|
|
|
headTask=tasking_createTaskCr3KmodeParam(NULL,paging_new_address_space(),1,0,0,0,0);
|
2019-02-11 09:30:28 -06:00
|
|
|
currentTask=headTask;
|
2019-07-20 11:03:27 -05:00
|
|
|
tailTask=headTask;
|
2019-02-11 09:30:28 -06:00
|
|
|
}
|
|
|
|
|
2019-05-23 20:21:51 -05:00
|
|
|
Task* tasking_createTaskCr3KmodeParam(void* eip,void* cr3,char kmode,char param1_exists,uint32_t param1_arg,char param2_exists,uint32_t param2_arg) {
|
2019-03-23 07:30:18 -05:00
|
|
|
Task* task=kmalloc(sizeof(Task));
|
2019-06-22 10:21:50 -05:00
|
|
|
map_kstack(next_pid);
|
2019-05-23 20:21:51 -05:00
|
|
|
uint32_t param1;
|
|
|
|
if (param1_exists) {
|
|
|
|
param1=param1_arg;
|
|
|
|
} else {
|
|
|
|
param1=1;
|
|
|
|
}
|
|
|
|
uint32_t param2;
|
|
|
|
if (param2_exists) {
|
|
|
|
param2=param2_arg;
|
|
|
|
} else {
|
|
|
|
param2=2;
|
|
|
|
}
|
2019-05-11 10:11:28 -05:00
|
|
|
task->cr3=(uint32_t)cr3;
|
2019-05-05 13:01:24 -05:00
|
|
|
uint32_t old_cr3;
|
|
|
|
asm volatile("movl %%cr3, %%eax; movl %%eax, %0;":"=m"(old_cr3)::"%eax");
|
2019-05-11 10:11:28 -05:00
|
|
|
load_address_space(task->cr3);
|
2019-05-21 19:16:19 -05:00
|
|
|
if (kmode) {
|
2019-06-22 10:21:50 -05:00
|
|
|
uint32_t top_idx=(1024*(next_pid+1));
|
|
|
|
task->kernel_esp=((uint32_t)(&kstacks[top_idx-5]));
|
|
|
|
task->kernel_esp_top=task->kernel_esp;
|
|
|
|
kstacks[top_idx-5]=0;
|
|
|
|
kstacks[top_idx-4]=0;
|
|
|
|
kstacks[top_idx-3]=0;
|
|
|
|
kstacks[top_idx-2]=0;
|
2019-06-29 09:04:34 -05:00
|
|
|
kstacks[top_idx-1]=(uint32_t)eip;
|
2019-05-21 19:16:19 -05:00
|
|
|
} else {
|
2019-06-22 10:21:50 -05:00
|
|
|
uint32_t top_idx=(1024*(next_pid+1));
|
|
|
|
task->kernel_esp=((uint32_t)(&kstacks[top_idx-7]));
|
|
|
|
task->kernel_esp_top=task->kernel_esp;
|
|
|
|
kstacks[top_idx-7]=0;
|
|
|
|
kstacks[top_idx-6]=0;
|
|
|
|
kstacks[top_idx-5]=0;
|
|
|
|
kstacks[top_idx-4]=0;
|
2019-06-29 09:04:34 -05:00
|
|
|
kstacks[top_idx-3]=(uint32_t)task_init;
|
|
|
|
uint32_t* user_stack=(uint32_t*)(((uint32_t)alloc_pages(1))+0x1000);
|
2019-06-22 10:21:50 -05:00
|
|
|
user_stack-=2;
|
2019-05-23 20:21:51 -05:00
|
|
|
user_stack[0]=param1;
|
|
|
|
user_stack[1]=param2;
|
2019-06-29 09:04:34 -05:00
|
|
|
kstacks[top_idx-2]=(uint32_t)user_stack;
|
|
|
|
kstacks[top_idx-1]=(uint32_t)eip;
|
2019-05-11 10:11:28 -05:00
|
|
|
}
|
2019-05-05 13:01:24 -05:00
|
|
|
load_address_space(old_cr3);
|
2019-02-11 09:30:28 -06:00
|
|
|
task->next=NULL;
|
|
|
|
task->pid=next_pid;
|
2019-08-04 13:14:35 -05:00
|
|
|
tasks[next_pid]=task;
|
2019-02-25 15:42:23 -06:00
|
|
|
task->priv=0;
|
2019-04-08 15:58:30 -05:00
|
|
|
task->errno=0;
|
2019-02-25 15:42:23 -06:00
|
|
|
if (currentTask) {
|
|
|
|
task->priv=currentTask->priv;
|
|
|
|
}
|
|
|
|
if (task->pid==1) {
|
|
|
|
task->priv=1;
|
|
|
|
}
|
2019-02-11 09:30:28 -06:00
|
|
|
next_pid++;
|
2019-06-22 11:11:12 -05:00
|
|
|
if (next_pid>1024*32) {
|
2019-08-04 13:14:35 -05:00
|
|
|
serial_printf("Failed to create a task, as 32k tasks have been created already.\n");
|
2019-06-22 11:11:12 -05:00
|
|
|
halt(); //Cannot ever create more than 32k tasks, as I don't currently reuse PIDs.
|
2019-06-17 08:20:36 -05:00
|
|
|
}
|
2019-07-20 11:03:27 -05:00
|
|
|
if (tailTask) {
|
|
|
|
tailTask->next=task;
|
|
|
|
tailTask=task;
|
2019-02-11 09:30:28 -06:00
|
|
|
}
|
2019-08-04 13:14:35 -05:00
|
|
|
if (task->pid!=0) {
|
|
|
|
serial_printf("Created task with PID %d.\n",task->pid);
|
|
|
|
}
|
2019-02-11 09:30:28 -06:00
|
|
|
return task;
|
|
|
|
}
|
|
|
|
|
2019-04-08 15:58:30 -05:00
|
|
|
int* tasking_get_errno_address() {
|
|
|
|
return &(currentTask->errno);
|
|
|
|
}
|
2019-02-25 15:42:23 -06:00
|
|
|
char isPrivleged(uint32_t pid) {
|
|
|
|
for (Task* task=headTask;task!=NULL;task=task->next) {
|
|
|
|
if (task->pid==pid) {
|
|
|
|
return task->priv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-02-11 09:47:28 -06:00
|
|
|
Task* tasking_createTask(void* eip) {
|
2019-05-23 20:21:51 -05:00
|
|
|
return tasking_createTaskCr3KmodeParam(eip,paging_new_address_space(),0,0,0,0,0);
|
2019-02-11 09:30:28 -06:00
|
|
|
}
|
|
|
|
|
2019-05-11 10:11:28 -05:00
|
|
|
void tasking_yield(registers_t registers) {
|
2019-05-21 19:16:19 -05:00
|
|
|
Task* task=currentTask->next;
|
|
|
|
if (!task) {
|
|
|
|
task=headTask;
|
|
|
|
}
|
2019-08-04 13:14:35 -05:00
|
|
|
serial_printf("Yielding to PID %d.\n",task->pid);
|
|
|
|
load_smap(task->cr3);
|
|
|
|
switch_to_task(task);
|
|
|
|
}
|
|
|
|
|
|
|
|
void tasking_yieldToPID(uint32_t pid) {
|
|
|
|
Task* task=tasks[pid];
|
|
|
|
if (!task) {
|
2019-08-05 14:23:54 -05:00
|
|
|
serial_printf("PID %d does not exist.\n",pid);
|
2019-08-04 13:14:35 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
serial_printf("Yielding to PID %d.\n",task->pid);
|
2019-05-23 17:06:29 -05:00
|
|
|
load_smap(task->cr3);
|
2019-05-21 19:16:19 -05:00
|
|
|
switch_to_task(task);
|
2019-02-11 09:30:28 -06:00
|
|
|
}
|
2019-07-20 11:03:27 -05:00
|
|
|
|
|
|
|
uint32_t getPID() {
|
|
|
|
return currentTask->pid;
|
|
|
|
}
|