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