syscall.c 16 KB

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