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
|
#pragma once
#include "types.h"
#include "IPC.h"
#include "DoublyLinkedList.h"
#include "String.h"
#include "TSS.h"
#include "Vector.h"
#include "i386.h"
//#define TASK_SANITY_CHECKS
class FileHandle;
class Task : public DoublyLinkedListNode<Task> {
friend class DoublyLinkedListNode<Task>;
public:
#ifdef TASK_SANITY_CHECKS
static void checkSanity(const char* msg = nullptr);
#else
static void checkSanity(const char*) { }
#endif
enum State {
Invalid = 0,
Runnable = 1,
Running = 2,
BlockedReceive = 3,
BlockedSend = 4,
BlockedSleep = 5,
Terminated = 6,
};
enum RingLevel {
Ring0 = 0,
Ring3 = 3,
};
static Task* fromPID(pid_t);
static Task* fromIPCHandle(IPC::Handle);
static Task* kernelTask();
Task(void (*entry)(), const char* name, IPC::Handle, RingLevel);
~Task();
const String& name() const { return m_name; }
pid_t pid() const { return m_pid; }
DWORD ticks() const { return m_ticks; }
WORD selector() const { return m_farPtr.selector; }
TSS32& tss() { return m_tss; }
State state() const { return m_state; }
IPC::Handle handle() const { return m_handle; }
const FarPtr& farPtr() const { return m_farPtr; }
FileHandle* fileHandleIfExists(int fd);
FileHandle* createFileHandle();
bool acceptsMessageFrom(Task&);
void block(Task::State);
void unblock();
void setWakeupTime(DWORD t) { m_wakeupTime = t; }
DWORD wakeupTime() const { return m_wakeupTime; }
static void prepForIRETToNewTask();
bool tick() { ++m_ticks; return --m_ticksLeft; }
void setTicksLeft(DWORD t) { m_ticksLeft = t; }
void setSelector(WORD s) { m_farPtr.selector = s; }
void setState(State s) { m_state = s; }
uid_t sys$getuid();
int sys$open(const char* path, size_t pathLength);
int sys$close(int fd);
int sys$read(int fd, void* outbuf, size_t nread);
int sys$seek(int fd, int offset);
int sys$kill(pid_t pid, int sig);
int sys$geterror() { return m_error; }
void sys$sleep(DWORD ticks);
struct
{
IPC::Message msg;
IPC::Handle dst;
IPC::Handle src;
DWORD notifies { 0 };
} ipc;
static void initialize();
void setError(int);
private:
FileHandle* openFile(String&&);
void allocateLDT();
Task* m_prev { nullptr };
Task* m_next { nullptr };
String m_name;
void (*m_entry)() { nullptr };
pid_t m_pid { 0 };
uid_t m_uid { 0 };
DWORD m_ticks { 0 };
DWORD m_ticksLeft { 0 };
IPC::Handle m_handle { 0 };
DWORD m_stackTop { 0 };
FarPtr m_farPtr;
State m_state { Invalid };
DWORD m_wakeupTime { 0 };
TSS32 m_tss;
Descriptor* m_ldtEntries { nullptr };
Vector<FileHandle*> m_fileHandles;
RingLevel m_ring { Ring0 };
int m_error { 0 };
};
extern void task_init();
extern void yield();
extern bool scheduleNewTask();
extern void block(Task::State);
extern void sleep(DWORD ticks);
/* The currently executing task. NULL during kernel bootup. */
extern Task* current;
|
