1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
// http://hosted.cjmovie.net/TutMultitask.htm
//
//
#include "kernel.h"
#include "lib/logger/log.h" // logger facilities
#include "lib/buffer/ringbuffer.h"
#include "mem.h"
#include "timer.h"
#include "console.h"
#include "x86.h"
#include "vmem.h"
#include "syscalls.h"
#include "fs/fs.h"
#include "fs/ext2.h"
#define FOOLOS_MODULE_NAME "task"
#define MAX_TASKS 10
static volatile int volatile current_task=-1;
static volatile struct task_list_struct
{
volatile int parent;
volatile bool active;
volatile uint32_t esp; // stack pointer of the task;
volatile pdirectory *vmem; // number of virtual memory table to switch to
volatile bool waiting;
volatile bool skipwait;
volatile uint32_t brk;
}volatile task_list[MAX_TASKS];
volatile int add_task(uint32_t esp, uint32_t vmem)
{
for(int i=0;i<MAX_TASKS;i++)
{
if(task_list[i].active!=true)
{
task_list[i].parent=current_task;
task_list[i].vmem=vmem;
task_list[i].esp=esp;
task_list[i].active=true;
task_list[i].waiting=false;
task_list[i].skipwait=false;
task_list[i].brk=task_list[current_task].brk;
return i;
}
}
panic(FOOLOS_MODULE_NAME,"out of task slots!");
}
volatile uint32_t my_scheduler(uint32_t oldesp)
{
task_list[current_task].esp=oldesp;
for(int i=0;i<MAX_TASKS;i++)
{
int pid=(current_task+1+i)%MAX_TASKS; // schedule round robin style
if(task_list[pid].active && !task_list[pid].waiting)
{
// if(current_task!=pid)
// log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"switch from %d to %d", current_task, pid);
current_task=pid;
vmem_set_dir(task_list[pid].vmem);
return task_list[pid].esp;
}
}
panic(FOOLOS_MODULE_NAME,"nothing to schedule!");
}
// this gets called by our clock interrupt regularly!
volatile uint32_t task_switch_next(uint32_t oldesp)
{
// syscall_write(1,"*tick*",10);
timer_tick();
// check if multitasking has been started
if(current_task<0)return oldesp;
return my_scheduler(oldesp);
}
//TODO: free vmem too!
//TODO: notify waiting parent when child finished;
volatile uint32_t task_exit(uint32_t oldesp)
{
task_list[current_task].active=false;
int parent_pid=task_list[current_task].parent;
log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"[%d] exit ", current_task);
if(task_list[parent_pid].active)
{
if(task_list[parent_pid].waiting)
{
log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"[%d] wake up", parent_pid);
task_list[parent_pid].waiting=false;
}
else
{
log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"[%d] skipwait", parent_pid);
task_list[parent_pid].skipwait=true;
}
}
vmem_free_dir(task_list[current_task].vmem);
return my_scheduler(oldesp);
}
volatile uint32_t task_wait(uint32_t oldesp)
{
log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"[%d] wait", current_task);
if(task_list[current_task].skipwait)
{
task_list[current_task].skipwait=false;
}
else
{
task_list[current_task].waiting=true;
}
return my_scheduler(oldesp);
}
volatile uint32_t task_fork(uint32_t oldesp)
{
int pid=add_task(oldesp,vmem_new_space_dir(task_list[current_task].vmem));
log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"[%d] forked -> [%d] (free blocks remaining: %d )", current_task, pid,mem_get_free_blocks_count());
return pid;
}
// init task (root of all other tasks / processes) //
volatile void task_init(pdirectory *dir)
{
// this is our main task on slot 0
task_list[0].parent=0;
task_list[0].active=true;
task_list[0].waiting=false;
task_list[0].vmem=dir;
task_list[0].esp = 0; // will be set by next task_switch_next() call.
current_task=0;
// while(1);
switch_to_user_mode();
//syscall_execve("/bin/foolshell",argv_init,env_init);
//syscall_execve("/bin/tput",argv,env);
}
volatile int task_get_current_pid()
{
return current_task;
}
volatile uint32_t task_get_brk()
{
return task_list[current_task].brk;
}
volatile void task_set_brk(uint32_t brk)
{
task_list[current_task].brk=brk;
}
|
