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
|
/* SPDX-License-Identifier: GPL-3.0-or-later */
/* Copyright 2021 - 2022, Kim Kuparinen < kimi.h.kuparinen@gmail.com > */
/**
* @file proc.c
* Process/thread handling syscall implementations.
*/
#include <apos/elf.h>
#include <apos/uapi.h>
#include <apos/proc.h>
#include <apos/bits.h>
#include <apos/mem_regions.h>
/**
* Create syscall handler.
*
* \todo Implement.
*
* @param func Function to jump to at thread creation.
* @param arg Argument to pass to the function.
*
* @return \ref OK and 0.
*/
SYSCALL_DEFINE2(create)(sys_arg_t func, sys_arg_t arg){
return (struct sys_ret){ OK, 0, 0, 0, 0, 0 };
}
/**
* 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.
*
* @return \ref OK and 0.
*/
SYSCALL_DEFINE0(fork)(){
return (struct sys_ret){ OK, 0, 0, 0, 0, 0 };
}
/**
* Exec syscall handler.
*
* @param bin Binary to execute.
* @param interp Optional interpreter binary.
* @return \see prepare_proc() and 0.
*/
SYSCALL_DEFINE2(exec)(sys_arg_t bin, sys_arg_t interp){
/** \todo execute new process, probably with more sensible argc passing */
struct tcb *r = cur_tcb();
/* mark binary to be kept */
struct mem_region *b = find_used_region(&r->sp_r, bin);
if (!b)
return (struct sys_ret){ERR_INVAL, 0, 0, 0, 0, 0};
set_bit(b->flags, MR_KEEP);
struct mem_region *i = 0;
if (interp) {
/* mark interpreter to be kept */
i = find_used_region(&r->sp_r, interp);
if (!i)
return (struct sys_ret){ERR_INVAL, 1, 0, 0, 0, 0};
set_bit(i->flags, MR_KEEP);
}
/* free everything except regions to be kept */
clear_uvmem(r);
/* restore to normal */
clear_bit(b->flags, MR_KEEP);
if (interp)
clear_bit(b->flags, MR_KEEP);
return (struct sys_ret){ prepare_proc(r, bin, interp), 0, 0, 0, 0, 0 };
}
/**
* Spawn syscall handler.
*
* @param bin Binary to execute.
* @param interp Optional interpreter binary.
* @return \see prepare_proc() and 0.
*/
SYSCALL_DEFINE2(spawn)(sys_arg_t bin, sys_arg_t interp)
{
/* @todo implement */
}
/**
* Kill syscall handler.
*
* @param tid Thread to kill.
* \todo Implement.
*
* @return No?
*/
SYSCALL_DEFINE1(kill)(sys_arg_t tid)
{
return (struct sys_ret){ OK, 0, 0, 0, 0, 0};
}
/**
* Swap syscall handler.
*
* \todo Implement.
* \todo Should swap return the registers of the new thread that would be used
* for message passing?
*
* @param tid Thread ID to swap to.
* @return \ref OK and 0.
*/
SYSCALL_DEFINE1(swap)(sys_arg_t tid){
/** \todo switch to process */
/** \todo should switch return the registers of the new thread that would
* be used for message passing? */
return (struct sys_ret){ OK, 0, 0, 0, 0, 0 };
}
/**
* Assign syscall handler.
*
* \todo Implement.
* @param tid Thread to assign to \p cpu.
* @param cpu Cpu to run \p tid on.
* @return \ref OK.
*/
SYSCALL_DEFINE2(assign)(sys_arg_t tid, sys_arg_t cpu)
{
return (struct sys_ret){OK, 0, 0, 0, 0, 0};
}
|
