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