Allow me to defend myself from this long absence of journaling. I was just busy making the virtual file system on my other project (the "microkernel" project.)

Despite that I figured out something interesting that can revive this project again and even make my idea reality. I finally understood how system call works in linux. It was quite simple but quite complicating.. Basically, there is an array of handlers called "sys_call_table" corresponding to each system call numbers. If I change this table, I can just basically change pretty much everything about the system call with minimal modification.

For each architecture, there exists that array of system call handler called "sys_call_table" declared in somewhere of architecture-dependent codes. (For x86_64 that will'll be focus on, "sys_call_table" is declared in file "arch/x86/um/sys_call_table_64.c")

// SPDX-License-Identifier: GPL-2.0
/*
 * System call table for UML/x86-64, copied from arch/x86/kernel/syscall_*.c
 * with some changes for UML.
 */

#include <linux/linkage.h>
#include <linux/sys.h>
#include <linux/cache.h>
#include <asm/syscall.h>

/*
 * Below you can see, in terms of #define's, the differences between the x86-64
 * and the UML syscall table.
 */

/* Not going to be implemented by UML, since we have no hardware. */
#define sys_iopl sys_ni_syscall
#define sys_ioperm sys_ni_syscall

#define __SYSCALL(nr, sym) extern asmlinkage long sym(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long);
#include <asm/syscalls_64.h>

#undef __SYSCALL
#define __SYSCALL(nr, sym) sym,

extern asmlinkage long sys_ni_syscall(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long);

const sys_call_ptr_t sys_call_table[] ____cacheline_aligned = {
#include <asm/syscalls_64.h>
};

int syscall_table_size = sizeof(sys_call_table);

asm/syscalls_64.h fills out the array of handler by using convenient macros declared on the line 25 in the code above. (By the way, the file asm/syscalls_64.h is located in the folder arch/x86/include/generated. I think this file is "generated" by something from a file, because it's in the folder called "generated".. but idk it's my speculation.)

__SYSCALL(0, sys_read)
__SYSCALL(1, sys_write)
__SYSCALL(2, sys_open)
__SYSCALL(3, sys_close)
__SYSCALL(4, sys_newstat)
__SYSCALL(5, sys_newfstat)
__SYSCALL(6, sys_newlstat)
...

Now that we know where the list of system calls is located, we can actually make something that can swap this table. I am thinking of system that swaps this system call table very quickly for each context switching. When the process is created, the system call that process uses will be detected using some kind of "detector" that detects the platform of program and determines what system call it uses.

Overall system.. I guess

Now I need figure out these questions :

1. How does context switching work in linux, and how can I incorporate the system call switching into it?
2. How should I change sys_call_table from an array into a pointer?
3. How does PCB organized in linux kernel? Where does it exist and how can I modify it?

.. and also try to "actually" implement this system into the kernel. I'll just start with the system call detectors. Maybe we need to integrate this with the parts of kernel that manages program execution(I mean the execve stuff), because an executable requires the identification for matching suitable system call at which it is being loaded. (Is this grammatically correct? idk)

...
Lots of works, lots of joys and lots of stresses. I endure every day as if I only live that one day. Good luck to me of tomorrow I guess.