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
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
/* SPDX-License-Identifier: copyleft-next-0.3.1 */
/* Copyright 2021 - 2022, Kim Kuparinen < kimi.h.kuparinen@gmail.com > */
/**
* @file proc.c
* Process/thread handling syscall implementations.
*/
#include <kmi/elf.h>
#include <kmi/uapi.h>
#include <kmi/proc.h>
#include <kmi/bits.h>
#include <kmi/notify.h>
#include <kmi/mem_regions.h>
/**
* Create syscall handler.
*
* @param t Current tcb.
* @param func Function to jump to at thread creation.
* @param d0 Argument 0.
* @param d1 Argument 1.
* @param d2 Argument 2.
* @param d3 Argument 3.
*
* @return ERR_OOMEM if thread creation was unsuccessful, otherwise OK and the
* thread id.
*/
SYSCALL_DEFINE5(create)(struct tcb *t, sys_arg_t func,
sys_arg_t d0, sys_arg_t d1, sys_arg_t d2, sys_arg_t d3)
{
struct tcb *c = create_thread(t);
if (!c)
return_args1(t, ERR_OOMEM);
alloc_stack(c);
set_args5(c, c->tid, d0, d1, d2, d3);
set_return(c, func);
c->notify_id = t->notify_id;
return_args2(t, OK, c->tid);
}
/**
* Fork syscall handler.
*
* \todo Not entirely sure how I should handle forks/execs etc, mostly whether I
* should allow forks/execs to be called directly or only though the process
* manager. Probably though the process manager, although that will add in a
* slight bit of delay.
*
* I suppose I could add in a runtime parameter
* that would allow them to be called directly, and then the process manager
* would have to periodically ask the kernel about all threads it is aware of
* via sys_sync. Dunno.
*
* @param t Current tcb.
* @return \ref OK and 0.
*/
SYSCALL_DEFINE0(fork)(struct tcb *t)
{
struct tcb *c = get_cproc(t);
if (!(has_cap(c->caps, CAP_PROC)))
return_args1(t, ERR_PERM);
struct tcb *n = create_proc(get_eproc(t));
if (!n)
return_args1(t, ERR_OOMEM);
/* prepare args for when we eventually swap to the new proc, giving
* parent ID as third return value */
set_args3(n, OK, 0, get_eproc(t)->pid);
n->notify_id = c->notify_id;
return_args2(t, OK, n->pid);
}
/**
* Exec syscall handler.
*
* @param t Current tcb.
* @param bin Binary to execute.
* @param interp Optional interpreter binary.
*
* @return \see prepare_proc().
*/
SYSCALL_DEFINE2(exec)(struct tcb *t, sys_arg_t bin, sys_arg_t interp)
{
/** @todo probably make sure thread is root thread of process? */
/* mark binary to be kept */
struct mem_region *b = find_used_region(&t->sp_r, bin);
if (!b)
return_args1(t, ERR_INVAL);
set_bit(b->flags, MR_KEEP);
struct mem_region *i = 0;
if (interp) {
/* mark interpreter to be kept */
i = find_used_region(&t->sp_r, interp);
if (!i)
return_args1(t, ERR_INVAL);
set_bit(i->flags, MR_KEEP);
}
/* free everything except regions to be kept */
clear_uvmem(t);
/* restore to normal */
clear_bit(b->flags, MR_KEEP);
if (interp)
clear_bit(b->flags, MR_KEEP);
return_args1(t, prepare_proc(t, bin, interp));
}
/**
* Spawn syscall handler.
*
* @param t Current tcb.
* @param bin Binary to execute.
* @param interp Optional interpreter binary.
*
* @return \see prepare_proc() and process id of the new process.
*/
SYSCALL_DEFINE2(spawn)(struct tcb *t, sys_arg_t bin, sys_arg_t interp)
{
struct tcb *c = get_proc(t);
if (!(has_cap(c->caps, CAP_PROC)))
return_args1(t, ERR_PERM);
struct tcb *n = create_proc(NULL);
if (!n)
return_args1(t, ERR_OOMEM);
n->notify_id = c->notify_id;
return_args2(t, prepare_proc(n, bin, interp), n->pid);
}
/**
* Kill syscall handler.
*
* @param t Current tcb.
* @param tid Thread to kill.
* \todo Implement.
*
* @return ERR_PERM if not capable to kill, otherwise OK.
*/
SYSCALL_DEFINE1(kill)(struct tcb *t, sys_arg_t tid)
{
struct tcb *c = get_cproc(t);
if (!(has_cap(c->caps, CAP_PROC)))
return_args1(t, ERR_PERM);
/** @todo implement */
/** @todo remember to unregister IRQ handlers */
return_args1(t, OK);
}
/**
* Swap syscall handler.
*
* \todo Implement.
* \todo Should swap return the registers of the new thread that would be used
* for message passing?
*
* @param t Current tcb.
* @param tid Thread ID to swap to.
*
* @return \ref OK.
*/
SYSCALL_DEFINE1(swap)(struct tcb *t, sys_arg_t tid){
struct tcb *c = get_cproc(t);
if (!(has_cap(c->caps, CAP_PROC)))
return_args1(t, ERR_PERM);
struct tcb *s = get_tcb(tid);
if (!s)
return_args1(t, ERR_INVAL);
/* switch over to new thread */
use_tcb(s);
/* set return value for current thread */
set_args1(t, OK);
/* not running anymore lol */
if (t->notify_state == NOTIFY_RUNNING)
t->notify_state = NOTIFY_WAITING;
/* handle possible queued notification */
if (s->notify_state == NOTIFY_QUEUED)
notify(s, 0);
/* get register state for new thread */
return_args(s, get_args(s));
}
|
