How system calls work in Vox?

[rempas]

I got a code snipped from that reply in another post and it seems really cool that we can use the "extern" keyword to use system calls directly without having to write any assembly. However, I want to make some questions.

1. Where to find the system call number and the type of the parameters I must use. One place I found is here but do you know any better place?
2. Why the first parameter in your example is of type "u32" while the "sys_write" system call takes an "i32"? Also why is this possible (which is the main part of this discussion)?

Finally I tried to implement my own "sys_open" based on the system call I saw in the link I gave you and it doesn't work. Maybe I'm blind and I can't find the bug but can you look at it and explain me all that stuff if you can?

Code:

enum u32 stdin = 0;
enum u32 stdout = 1;
enum u32 stderr = 2;

@extern(syscall, 60)
void exit(i32 error_code);

@extern(syscall, 1)
void sys_write(u32 fd, u8* buf, u64 count);

void write(u32 fd, u8[] data) {
    sys_write(fd, data.ptr, data.length);
}

@extern(syscall, 0)
u32 sys_open(u8* buf, i32 flags);

u32 open(u8[] path, i32 mode) {
  return sys_open(path.ptr, mode);
}

void main() {
  u32 my_first_file_in_vox = open("test_file_from_vox.txt", 66);
  write(my_first_file_in_vox, "Hello from vox!!!");
}

Edit:
Found the issue! The updated code that works below:

enum u32 stdin = 0;
enum u32 stdout = 1;
enum u32 stderr = 2;

@extern(syscall, 60)
void exit(i32 error_code);

@extern(syscall, 1)
void sys_write(i32 fd, u8* buf, u64 count);

void write(i32 fd, u8[] data) {
    sys_write(fd, data.ptr, data.length);
}

@extern(syscall, 2)
i32 sys_open(u8* buf, i32 flags, u64 mode);

i32 open(u8[] path, i32 flags, u64 mode) {
  return sys_open(path.ptr, flags, mode);
}

void main() {
  i32 my_first_file_in_vox = open("test_file_from_vox.txt", 66, 420);
  write(my_first_file_in_vox, "Hello from vox!!!");
  exit(0);
}

[MrSmith33]

1. For x86-64 here https://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/ or here https://filippo.io/linux-syscall-table/.
   It says that open should be 2.

   The one that you linked is a bit confusing, because the column S.No. is just the numbering in this table, while actual syscall number that is passed via RAX register is in eax column. Also, your sys_open uses number 0, which is sys_read.

2. As long as bit pattern is the same it doesn't really matter. We are not operating on the number, but transferring it verbatim from one syscall to another. You can of course change it to match the type.

I hope that helped.

[rempas]

Man thanks for the instant reply! First of all it seems that I'm an idiot. Second, I fix the code and tried again but still it doesn't seems to work. The third argument (that who goes in the "%rdx" register) is of type "mode_t" and probably that makes it fail. The new code is now:

enum u32 stdin = 0;
enum u32 stdout = 1;
enum u32 stderr = 2;

@extern(syscall, 60)
void exit(i32 error_code);

@extern(syscall, 1)
void sys_write(i32 fd, u8* buf, u64 count);

void write(i32 fd, u8[] data) {
    sys_write(fd, data.ptr, data.length);
}

@extern(syscall, 2)
i32 sys_open(u8* buf, i32 flags, u64 mode);

i32 open(u8[] path, i32 flags, u64 mode) {
  return sys_open(path.ptr, flags, mode);
}

void main() {
  i32 my_first_file_in_vox = open("test_file_from_vox.txt", 66, 420);
  write(my_first_file_in_vox, "Hello from vox!!!");
}

I also tried to give the type "i32" for the "mode" argument but still it doesn't work. Unless I'm still an idiot and miss something, any ideas what's going one?

[MrSmith33]

Looks like exit(0); at the end is required, otherwise it segfaults for me. With exit(0); the file is created.

[rempas]

HOLY!!! What are these tricks?? Lol!

You are amazing! Man I wanted to write my own library from scratch without having to link to another library but writing assembly was distrusting. I don't know how you can make system calls to work like that (haven't seen it in any other language) but this is straight up awesome!!! I really hope Vox becomes big!

[MrSmith33]

syscalls are almost the same as calling regular C function, the difference is that calling convention is slightly different + you pass syscall number in eax. So I simply implemented it as another calling convention and exposed this as an attribute for external functions.

[rempas]

You are truly a genius! I'll try to make my own library starting from IO! Have a nice day man!