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