如何在OS161中添加开放系统调用的两个变体?

在OS161的手册页中:

#include <unistd.h>
#include <fcntl.h>

int
open(const char *filename, int flags);
int
open(const char *filename, int flags, mode_t mode);

如何定义标准c库函数open:

int open(const char *filename, int flags, ...);

声明:

/*
 * Definition for each syscall.
 * All we do is load the syscall number into v0, the register the
 * kernel expects to find it in, and jump to the shared syscall code.
 * (Note that the addiu instruction is in the jump's delay slot.)
 */

#define SYS_open         45

#define SYSCALL(sym, num) \
   .set noreorder       ; \
   .globl sym           ; \
   .type sym,@function      ; \
   .ent sym         ; \
sym:                ; \
   j __syscall                  ; \
   addiu v0, $0, SYS_##sym  ; \
   .end sym         ; \
   .set reorder

SYSCALL(open, 45)

发出syscall时，将调用syscall调度程序. syscall调度程序采用指向trapframe的指针，该指针包括在发出syscall之前的寄存器值.寄存器之一包含系统调用号，调度程序将其分配给正确的系统调用功能.调度程序看起来像这样:

When a syscall is issued, a syscall dispatcher is called. The syscall dispatcher takes a pointer to a trapframe which includes the values of registers before the syscall is issued. One of the registers contains the syscall number, which the dispatcher uses to dispatch to the right syscall function. The dispatcher looks like this:

void
syscall(struct trapframe *tf)
{
    int callno;

    ...

    callno = tf->tf_v0;

    ...

    switch (callno) {
        case SYS_reboot:
        err = sys_reboot(tf->tf_a0);
        break;

        case SYS___time:
        err = sys___time((userptr_t)tf->tf_a0,
                 (userptr_t)tf->tf_a1);

    ...

}

这是一条注释，描述了如何传递参数以及如何返回值:

Here is a comment that describes how arguments are passed and how to return values:

 * The calling conventions for syscalls are as follows: Like ordinary
 * function calls, the first 4 32-bit arguments are passed in the 4
 * argument registers a0-a3. 64-bit arguments are passed in *aligned*
 * pairs of registers, that is, either a0/a1 or a2/a3. This means that
 * if the first argument is 32-bit and the second is 64-bit, a1 is
 * unused.
 *
 * This much is the same as the calling conventions for ordinary
 * function calls. In addition, the system call number is passed in
 * the v0 register.
 *
 * On successful return, the return value is passed back in the v0
 * register, or v0 and v1 if 64-bit. This is also like an ordinary
 * function call, and additionally the a3 register is also set to 0 to
 * indicate success.
 *
 * On an error return, the error code is passed back in the v0
 * register, and the a3 register is set to 1 to indicate failure.
 * (Userlevel code takes care of storing the error code in errno and
 * returning the value -1 from the actual userlevel syscall function.
 * See src/user/lib/libc/arch/mips/syscalls-mips.S and related files.)

您可以看到例如sys_reboot用tf->tf_a0调用，这是因为在发出系统调用之前，寄存器a0包含系统调用的第一个(也是唯一的)参数.

You can see that for example sys_reboot is called with tf->tf_a0, That's because before the syscall is issued, the register a0 contained the first (and only) parameter for the syscall.

为了简单起见，我不会深入研究细节，因为这可能无关紧要.例如，发出系统调用的过程要复杂一些，但是我只提到了相关的内容.同样也不会谈论如何从堆栈中获取参数，因为在这里我不需要它.

I'm not gonna dive into details for simplicity and because it's probably irrelevant. For example, the process of issuing a syscall is a bit more complicated, but I've mentioned only the relevant stuff. Also not gonna talk about how to get arguments off the stack since I'll not need it here.

我应该实现sys_open syscall，但是我不确定如何知道open函数的哪个变体已被调用...

I'm supposed to implement the sys_open syscall, but I'm not sure how to know which variant of the open functions has been called...

我所拥有的只是系统调用号和寄存器的值，其中包括四个参数寄存器，堆栈指针和其他寄存器.

All I have is the syscall number and the values of the registers, which includes the four arguments registers, the stack pointer and the other registers.

如何确定我是面对第一个变化(仅具有两个参数)还是面对第二个变化(具有3个参数)，以便我能够表现得相对应?

How can I determine whether I'm facing the first variation (with only two parameters) or the second one (with 3 parameters) so that I can behave accordingly?

整个系统调用代码为 OS161的整个仓库位于此处.

The whole repo for OS161 is here.

在此处引导期间，异常处理程序代码已加载到内存中.

The exception handler code is loaded into memory during the boot here.

异常处理程序的代码(发出系统调用时运行的第一个代码)为

The code for the exception handler (the first code that runs when a syscall is issued) is here.

异常处理程序是一个名为mips_general_handler的函数，它仅调用一个函数common_exception.

The exception handler is a function called mips_general_handler that just calls a function common_exception.

mips_general_handler是 common_exception是 common_exception将寄存器的所有值压入堆栈，还将指针压入压入值的开头(即已传递给被调用函数的指针)，然后调用函数mips_trap在此处找到

common_exception pushed all the values of the registers onto the stack, also pushes a pointer to the beginning of the pushed values (that's the pointer that's passed to the function being called) and calls the function mips_trap which can be found here.

函数misp_trap寻找异常的原因，如果是系统调用，则调用上面给出的函数syscall.

The function misp_trap looks for the cause of the exception, and if it's a syscall, calls the function syscall which is given above.