1 #include "syscall.h"
2 #include <common/errno.h>
3 #include <common/fcntl.h>
4 #include <common/kthread.h>
5 #include <common/string.h>
6 #include <driver/disk/ahci/ahci.h>
7 #include <exception/gate.h>
8 #include <exception/irq.h>
9 #include <filesystem/vfs/VFS.h>
10 #include <mm/slab.h>
11 #include <process/process.h>
12 #include <time/sleep.h>
13 // 导出系统调用入口函数，定义在entry.S中
14 extern void syscall_int(void);
15
16 extern uint64_t sys_clock(struct pt_regs *regs);
17 extern uint64_t sys_mstat(struct pt_regs *regs);
18 extern uint64_t sys_open(struct pt_regs *regs);
19 extern uint64_t sys_unlink_at(struct pt_regs *regs);
20 extern uint64_t sys_kill(struct pt_regs *regs);
21 extern uint64_t sys_sigaction(struct pt_regs *regs);
22 extern uint64_t sys_rt_sigreturn(struct pt_regs *regs);
23 extern uint64_t sys_getpid(struct pt_regs *regs);
24 extern uint64_t sys_sched(struct pt_regs *regs);
25 extern int sys_dup(int oldfd);
26 extern int sys_dup2(int oldfd, int newfd);
27 extern uint64_t sys_socket(struct pt_regs *regs);
28 extern uint64_t sys_setsockopt(struct pt_regs *regs);
29 extern uint64_t sys_getsockopt(struct pt_regs *regs);
30 extern uint64_t sys_connect(struct pt_regs *regs);
31 extern uint64_t sys_bind(struct pt_regs *regs);
32 extern uint64_t sys_sendto(struct pt_regs *regs);
33 extern uint64_t sys_recvfrom(struct pt_regs *regs);
34 extern uint64_t sys_recvmsg(struct pt_regs *regs);
35 extern uint64_t sys_listen(struct pt_regs *regs);
36 extern uint64_t sys_shutdown(struct pt_regs *regs);
37 extern uint64_t sys_accept(struct pt_regs *regs);
38 extern uint64_t sys_getsockname(struct pt_regs *regs);
39 extern uint64_t sys_getpeername(struct pt_regs *regs);
40 extern uint64_t sys_pipe(struct pt_regs *regs);
41 extern uint64_t sys_mkdir(struct pt_regs *regs);
42 /**
43 * @brief 关闭文件系统调用
44 *
45 * @param fd_num 文件描述符号
46 *
47 * @param regs
48 * @return uint64_t
49 */
50 extern uint64_t sys_close(struct pt_regs *regs);
51
52 /**
53 * @brief 从文件中读取数据
54 *
55 * @param fd_num regs->r8 文件描述符号
56 * @param buf regs->r9 输出缓冲区
57 * @param count regs->r10 要读取的字节数
58 *
59 * @return uint64_t
60 */
61 extern uint64_t sys_read(struct pt_regs *regs);
62
63 /**
64 * @brief 向文件写入数据
65 *
66 * @param fd_num regs->r8 文件描述符号
67 * @param buf regs->r9 输入缓冲区
68 * @param count regs->r10 要写入的字节数
69 *
70 * @return uint64_t
71 */
72 extern uint64_t sys_write(struct pt_regs *regs);
73
74 /**
75 * @brief 调整文件的访问位置
76 *
77 * @param fd_num 文件描述符号
78 * @param offset 偏移量
79 * @param whence 调整模式
80 * @return uint64_t 调整结束后的文件访问位置
81 */
82 extern uint64_t sys_lseek(struct pt_regs *regs);
83
84 /**
85 * @brief 导出系统调用处理函数的符号
86 *
87 */
88
89 /**
90 * @brief 系统调用不存在时的处理函数
91 *
92 * @param regs 进程3特权级下的寄存器
93 * @return ul
94 */
system_call_not_exists(struct pt_regs * regs)95 ul system_call_not_exists(struct pt_regs *regs)
96 {
97 kerror("System call [ ID #%d ] not exists.", regs->rax);
98 return ESYSCALL_NOT_EXISTS;
99 } // 取消前述宏定义
100
101 /**
102 * @brief 重新定义为：把系统调用函数加入系统调用表
103 * @param syscall_num 系统调用号
104 * @param symbol 系统调用处理函数
105 */
106 #define SYSCALL_COMMON(syscall_num, symbol) [syscall_num] = symbol,
107
108 /**
109 * @brief 初始化系统调用模块
110 *
111 */
syscall_init()112 void syscall_init()
113 {
114 kinfo("Initializing syscall...");
115
116 set_system_trap_gate(0x80, 0, syscall_int); // 系统调用门
117 }
118
119 /**
120 * @brief 通过中断进入系统调用
121 *
122 * @param syscall_id
123 * @param arg0
124 * @param arg1
125 * @param arg2
126 * @param arg3
127 * @param arg4
128 * @param arg5
129 * @param arg6
130 * @param arg7
131 * @return long
132 */
133
enter_syscall_int(ul syscall_id,ul arg0,ul arg1,ul arg2,ul arg3,ul arg4,ul arg5,ul arg6,ul arg7)134 long enter_syscall_int(ul syscall_id, ul arg0, ul arg1, ul arg2, ul arg3, ul arg4, ul arg5, ul arg6, ul arg7)
135 {
136 long err_code;
137 __asm__ __volatile__("movq %2, %%r8 \n\t"
138 "movq %3, %%r9 \n\t"
139 "movq %4, %%r10 \n\t"
140 "movq %5, %%r11 \n\t"
141 "movq %6, %%r12 \n\t"
142 "movq %7, %%r13 \n\t"
143 "movq %8, %%r14 \n\t"
144 "movq %9, %%r15 \n\t"
145 "int $0x80 \n\t"
146 : "=a"(err_code)
147 : "a"(syscall_id), "m"(arg0), "m"(arg1), "m"(arg2), "m"(arg3), "m"(arg4), "m"(arg5), "m"(arg6),
148 "m"(arg7)
149 : "memory", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", "rcx", "rdx");
150
151 return err_code;
152 }
153
154 /**
155 * @brief 打印字符串的系统调用
156 *
157 * 当arg1和arg2均为0时，打印黑底白字，否则按照指定的前景色和背景色来打印
158 *
159 * @param regs 寄存器
160 * @param arg0 要打印的字符串
161 * @param arg1 前景色
162 * @param arg2 背景色
163 * @return ul 返回值
164 */
sys_put_string(struct pt_regs * regs)165 ul sys_put_string(struct pt_regs *regs)
166 {
167
168 printk_color(regs->r9, regs->r10, (char *)regs->r8);
169 // printk_color(BLACK, WHITE, (char *)regs->r8);
170
171 return 0;
172 }
173
sys_fork(struct pt_regs * regs)174 uint64_t sys_fork(struct pt_regs *regs)
175 {
176 return do_fork(regs, 0, regs->rsp, 0);
177 }
sys_vfork(struct pt_regs * regs)178 uint64_t sys_vfork(struct pt_regs *regs)
179 {
180 return do_fork(regs, CLONE_VM | CLONE_FS | CLONE_SIGNAL, regs->rsp, 0);
181 }
182
183 /**
184 * @brief 将堆内存调整为arg0
185 *
186 * @param arg0 新的堆区域的结束地址
187 * arg0=-1 ===> 返回堆区域的起始地址
188 * arg0=-2 ===> 返回堆区域的结束地址
189 * @return uint64_t 错误码
190 *
191 */
sys_brk(struct pt_regs * regs)192 uint64_t sys_brk(struct pt_regs *regs)
193 {
194 uint64_t new_brk = PAGE_2M_ALIGN(regs->r8);
195 // kdebug("sys_brk input= %#010lx , new_brk= %#010lx bytes current_pcb->mm->brk_start=%#018lx
196 // current->end_brk=%#018lx", regs->r8, new_brk, current_pcb->mm->brk_start, current_pcb->mm->brk_end);
197 struct mm_struct *mm = current_pcb->mm;
198 if (new_brk < mm->brk_start || new_brk > new_brk >= current_pcb->addr_limit)
199 return mm->brk_end;
200
201 if (mm->brk_end == new_brk)
202 return new_brk;
203
204 int64_t offset;
205 if (new_brk >= current_pcb->mm->brk_end)
206 offset = (int64_t)(new_brk - current_pcb->mm->brk_end);
207 else
208 offset = -(int64_t)(current_pcb->mm->brk_end - new_brk);
209
210 new_brk = mm_do_brk(current_pcb->mm->brk_end, offset); // 扩展堆内存空间
211
212 current_pcb->mm->brk_end = new_brk;
213 return mm->brk_end;
214 }
215
216 /**
217 * @brief 将堆内存空间加上offset（注意，该系统调用只应在普通进程中调用，而不能是内核线程）
218 *
219 * @param arg0 offset偏移量
220 * @return uint64_t the previous program break
221 */
sys_sbrk(struct pt_regs * regs)222 uint64_t sys_sbrk(struct pt_regs *regs)
223 {
224 uint64_t retval = current_pcb->mm->brk_end;
225 if ((int64_t)regs->r8 > 0)
226 {
227
228 uint64_t new_brk = PAGE_2M_ALIGN(retval + regs->r8);
229 if (new_brk > current_pcb->addr_limit) // 堆地址空间超过限制
230 {
231 kdebug("exceed mem limit, new_brk = %#018lx", new_brk);
232 return -ENOMEM;
233 }
234 }
235 else
236 {
237 if ((__int128_t)current_pcb->mm->brk_end + (__int128_t)regs->r8 < current_pcb->mm->brk_start)
238 return retval;
239 }
240 // kdebug("do brk");
241 uint64_t new_brk = mm_do_brk(current_pcb->mm->brk_end, (int64_t)regs->r8); // 调整堆内存空间
242 // kdebug("do brk done, new_brk = %#018lx", new_brk);
243 current_pcb->mm->brk_end = new_brk;
244 return retval;
245 }
246
247 /**
248 * @brief 重启计算机
249 *
250 * @return
251 */
sys_reboot(struct pt_regs * regs)252 uint64_t sys_reboot(struct pt_regs *regs)
253 {
254 // 重启计算机
255 io_out8(0x64, 0xfe);
256
257 return 0;
258 }
259
260 /**
261 * @brief 切换工作目录
262 *
263 * @param dest_path 目标路径
264 * @return
265 +--------------+------------------------+
266 | 返回码 | 描述 |
267 +--------------+------------------------+
268 | 0 | 成功 |
269 | EACCESS | 权限不足 |
270 | ELOOP | 解析path时遇到路径循环 |
271 | ENAMETOOLONG | 路径名过长 |
272 | ENOENT | 目标文件或目录不存在 |
273 | ENODIR | 检索期间发现非目录项 |
274 | ENOMEM | 系统内存不足 |
275 | EFAULT | 错误的地址 |
276 | ENAMETOOLONG | 路径过长 |
277 +--------------+------------------------+
278 */
279 extern uint64_t sys_chdir(struct pt_regs *regs);
280
281 /**
282 * @brief 获取目录中的数据
283 *
284 * @param fd 文件描述符号
285 * @return uint64_t dirent的总大小
286 */
287 extern uint64_t sys_getdents(struct pt_regs *regs);
288
289 /**
290 * @brief 执行新的程序
291 *
292 * @param user_path(r8寄存器) 文件路径
293 * @param argv(r9寄存器) 参数列表
294 * @return uint64_t
295 */
sys_execve(struct pt_regs * regs)296 uint64_t sys_execve(struct pt_regs *regs)
297 {
298
299 char *user_path = (char *)regs->r8;
300 char **argv = (char **)regs->r9;
301
302 int path_len = strnlen_user(user_path, PAGE_4K_SIZE);
303
304 if (path_len >= PAGE_4K_SIZE)
305 return -ENAMETOOLONG;
306 else if (path_len <= 0)
307 return -EFAULT;
308
309 char *path = (char *)kmalloc(path_len + 1, 0);
310 if (path == NULL)
311 return -ENOMEM;
312
313 memset(path, 0, path_len + 1);
314
315 // 拷贝文件路径
316 strncpy_from_user(path, user_path, path_len);
317 path[path_len] = '\0';
318
319 // 执行新的程序
320 uint64_t retval = do_execve(regs, path, argv, NULL);
321
322 kfree(path);
323 return retval;
324 }
325
326 /**
327 * @brief 等待进程退出
328 *
329 * @param pid 目标进程id
330 * @param status 返回的状态信息
331 * @param options 等待选项
332 * @param rusage
333 * @return uint64_t
334 */
sys_wait4(struct pt_regs * regs)335 uint64_t sys_wait4(struct pt_regs *regs)
336 {
337 uint64_t pid = regs->r8;
338 int *status = (int *)regs->r9;
339 int options = regs->r10;
340 void *rusage = (void *)regs->r11;
341
342 struct process_control_block *proc = NULL;
343 struct process_control_block *child_proc = NULL;
344
345 // 查找pid为指定值的进程
346 // ps: 这里判断子进程的方法没有按照posix 2008来写。
347 // todo: 根据进程树判断是否为当前进程的子进程
348 // todo: 当进程管理模块拥有pcblist_lock之后，调用之前，应当对其加锁
349 child_proc = process_find_pcb_by_pid(pid);
350
351 if (child_proc == NULL)
352 return -ECHILD;
353
354 // 暂时不支持options选项，该值目前必须为0
355 if (options != 0)
356 return -EINVAL;
357
358 // 如果子进程没有退出，则等待其退出
359 // BUG: 这里存在问题，由于未对进程管理模块加锁，因此可能会出现子进程退出后，父进程还在等待的情况
360 // （子进程退出后，process_exit_notify消息丢失）
361 while (child_proc->state != PROC_ZOMBIE)
362 wait_queue_sleep_on_interriptible(¤t_pcb->wait_child_proc_exit);
363
364 // 拷贝子进程的返回码
365 if (likely(status != NULL))
366 *status = child_proc->exit_code;
367 // copy_to_user(status, (void*)child_proc->exit_code, sizeof(int));
368
369 process_release_pcb(child_proc);
370 return 0;
371 }
372
373 /**
374 * @brief 进程退出
375 *
376 * @param exit_code 退出返回码
377 * @return uint64_t
378 */
sys_exit(struct pt_regs * regs)379 uint64_t sys_exit(struct pt_regs *regs)
380 {
381 return process_do_exit(regs->r8);
382 }
383
sys_nanosleep(struct pt_regs * regs)384 uint64_t sys_nanosleep(struct pt_regs *regs)
385 {
386 const struct timespec *rqtp = (const struct timespec *)regs->r8;
387 struct timespec *rmtp = (struct timespec *)regs->r9;
388
389 return rs_nanosleep(rqtp, rmtp);
390 }
391
sys_ahci_end_req(struct pt_regs * regs)392 ul sys_ahci_end_req(struct pt_regs *regs)
393 {
394 // ahci_end_request();
395 return 0;
396 }
397
398 // 系统调用的内核入口程序
do_syscall_int(struct pt_regs * regs,unsigned long error_code)399 void do_syscall_int(struct pt_regs *regs, unsigned long error_code)
400 {
401 ul ret = system_call_table[regs->rax](regs);
402 regs->rax = ret; // 返回码
403 }
404
405 system_call_t system_call_table[MAX_SYSTEM_CALL_NUM] = {
406 [0] = system_call_not_exists,
407 [1] = sys_put_string,
408 [2] = sys_open,
409 [3] = sys_close,
410 [4] = sys_read,
411 [5] = sys_write,
412 [6] = sys_lseek,
413 [7] = sys_fork,
414 [8] = sys_vfork,
415 [9] = sys_brk,
416 [10] = sys_sbrk,
417 [11] = sys_reboot,
418 [12] = sys_chdir,
419 [13] = sys_getdents,
420 [14] = sys_execve,
421 [15] = sys_wait4,
422 [16] = sys_exit,
423 [17] = sys_mkdir,
424 [18] = sys_nanosleep,
425 [19] = sys_clock,
426 [20] = sys_pipe,
427 [21] = sys_mstat,
428 [22] = sys_unlink_at,
429 [23] = sys_kill,
430 [24] = sys_sigaction,
431 [25] = sys_rt_sigreturn,
432 [26] = sys_getpid,
433 [27] = sys_sched,
434 [28] = sys_dup,
435 [29] = sys_dup2,
436 [30] = sys_socket,
437 [31] = sys_setsockopt,
438 [32] = sys_getsockopt,
439 [33] = sys_connect,
440 [34] = sys_bind,
441 [35] = sys_sendto,
442 [36] = sys_recvfrom,
443 [37] = sys_recvmsg,
444 [38] = sys_listen,
445 [39] = sys_shutdown,
446 [40] = sys_accept,
447 [41] = sys_getsockname,
448 [42] = sys_getpeername,
449 [43 ... 255] = system_call_not_exists,
450 };
451