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 */ 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 */ 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 */ 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 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 */ 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 */ 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 */ 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 */ 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 */ 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 254 uint64_t sys_fork(struct pt_regs *regs) 255 { 256 return do_fork(regs, 0, regs->rsp, 0); 257 } 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 539 uint64_t sys_exit(struct pt_regs *regs) 540 { 541 return process_do_exit(regs->r8); 542 } 543 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 552 ul sys_ahci_end_req(struct pt_regs *regs) 553 { 554 ahci_end_request(); 555 return 0; 556 } 557 558 // 系统调用的内核入口程序 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