Fixed the problem that there might be two processes handling page fault
on the same page that is set copy on write. If they see that the
`refcount` is greater than `1`, they might each clone the page and
decrease the `refcount` of the old page. That will leave the old page
unfreed with a `refcount == 0`, which will cause bug in buddy allocator
when it tries to merge adjacent free pages.

There are still some bugs waiting to be fixed. The biggest of all is
that multiple processes call `exit` at the same time will cause
deadlock. This is because we hold `current.inner`, then `init.inner` and
then `child.inner`. And if our children are doing `exit` simultaneously,
they might hold their `current.inner` first and spin on `init.inner`.

This causes the deadlock.

This is a temporary solution. We should use atomic for `refcount` of
pages. But doing so with C++ is bothersome. So we will put that off
until we will rewrite buddy and slab system with Rust.

This might bring significant performance drop.

feat: percpu pointer varaibles

feat(syscall): implement syscall `sigreturn`

We might be doing something in some random context when we receive a
signal or some irq handler is trying to wake us up. We are in Running
state and that could be a problem if we don't allow doing that.

We actually modified the given register. So we need to mark it as
clobbered to inform the compiler of that.

Previous tty job control implementations are totally wrong. Rewrite
these parts and have some changes in `init_script` to correctly assign
a controlling terminal to the shell launched.

We might lock the `MMListInner` in some operation when we do a
task switch. Then in the idle task, we try to switch page table.
But that's impossible because we shouldn't do anything that could
possibly put us in a sleeping state.

Also, when we return from `schedule()` in `CondVar::wait()`, we might
be waken up from some signals. We should clean ourselves from the
waiters queue. Otherwise, we might be accidentally waken up by some
other tasks and ends up in some inconsistent task scheduler state.

update(init_script): write to stderr on errors encountered
chore(Makefile): enable asm demangling
fix(mm_list): call invalidate_tlb after setting up cows
fix(scheduler): make preemption responsibility clear
fix(sys_brk): do not set a marker for the program break in `mm_list`
feat(syscall): print syscall invokes in debug mode
feat(init): open the console for init process

change(ahci): spin for a short time first before switching
              to interrupt wait

feat: add sync primitives like CondVar Mutex Spin Semaphore to rust

change: make Inode a trait again
change: replace some of the Spin's with Mutex's or Semaphore's
change: make kernel stacks 512KB in size
change: save all file references as Dentry
change: enable interrupts for ahci devices

style: update clang-format and rustfmt

fix: remove incorrect slab cache free assertion
change: c style list remove function
add: rust Buffer and RawBuffer for io ops