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
|
#pragma once
#include "types.h"
#include "IPC.h"
#include "InlineLinkedList.h"
#include <AK/String.h>
#include "TSS.h"
#include <AK/Vector.h>
#include "i386.h"
//#define TASK_SANITY_CHECKS
class FileHandle;
class Zone;
class Task : public InlineLinkedListNode<Task> {
friend class InlineLinkedListNode<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,
Crashing = 7,
Exiting = 8,
};
enum RingLevel {
Ring0 = 0,
Ring3 = 3,
};
bool isRing0() const { return m_ring == Ring0; }
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);
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);
void sys$exit(int status);
struct
{
IPC::Message msg;
IPC::Handle dst;
IPC::Handle src;
DWORD notifies { 0 };
} ipc;
static void initialize();
void setError(int);
static void taskDidCrash(Task*);
void dumpRegions();
void didSchedule() { ++m_timesScheduled; }
dword timesScheduled() const { return m_timesScheduled; }
private:
friend class MemoryManager;
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<OwnPtr<FileHandle>> m_fileHandles;
RingLevel m_ring { Ring0 };
int m_error { 0 };
void* m_kernelStack { nullptr };
dword m_timesScheduled { 0 };
struct Region {
Region(LinearAddress, size_t, RetainPtr<Zone>&&, String&&);
~Region();
LinearAddress linearAddress;
size_t size { 0 };
RetainPtr<Zone> zone;
String name;
};
Region* allocateRegion(size_t, String&& name);
Vector<OwnPtr<Region>> m_regions;
// FIXME: Implement some kind of ASLR?
LinearAddress m_nextRegion;
};
extern void task_init();
extern void yield();
extern bool scheduleNewTask();
extern void switchNow();
extern void block(Task::State);
extern void sleep(DWORD ticks);
/* The currently executing task. NULL during kernel bootup. */
extern Task* current;
|
