The initial project within a course dedicated to kernel hacking introduces students to the intricacies of operating system $($OS$)$ development through hands$-$on projects, specifically focusing on the xv$6$ kernela modern reimplementation of the sixth edition Unix operating system designed to run on x$86$ processors. Developed at MIT, xv$6$ serves as an ideal platform for understanding OS principles due to its simplicity and comprehensibility. The primary objective of this initial project is to augment the xv$6$ kernel with two new system calls: $`$getreadcount$()`$ and $`$getopenfilecount$()`.$ The former tracks the total number of times the $`$read$()`$ system call has been invoked since the kernel was booted, while the latter counts the number of files opened by the calling process up to the point of invocation.To embark on this endeavor, students are required to set up a development environment conducive to kernel development. This setup involves installing a modern Linux distribution within a virtualized environment using VirtualBox or$,$ for systems with Apple's M$1/$M$2$ chips, alternatives like Multipass or VMware. Following the establishment of a Linux environment, the necessary toolchaincomprising a compiler, assembler, linker, and debuggeris to be installed to facilitate the compilation and debugging of the xv$6$ kernel. The xv$6$ source code is then obtained via Git, and the compilation process leverages tools such as $`$gcc$`,`$make$`,$ and the QEMU emulator for kernel execution and testing.The project necessitates a deep dive into the xv$6$ kernel's system call implementation mechanism, which is quintessential for adding new system calls. This exploration begins at the user level, where system calls are initiated by applications through a library routine that triggers a trap $($interrupt$),$ thereby transitioning control from user mode to kernel mode. On the kernel side, this transition is managed through trap tables that direct the hardware to execute specific kernel code in response to different traps. The xv$6$ kernel initializes these trap tables at boot time, informing the hardware of the kernel code to execute upon a system call invocation.Once a trap is triggered, control is passed to a generic C trap handler within the kernel, which discerns the nature of the trap using the trap number and executes the corresponding system call handler. This process involves a series of context switches and privilege escalations, meticulously orchestrated to ensure the integrity and security of the kernel environment. The implementation of the new system calls requires modifications to several kernel source files, including $`$syscall$.$h$`,`$syscall$.$c$`,`$user$.$h$`,`$usys$.$S$`,$ and either $`$sysfile$.$c$`$ or $`$sysproc$.$c$`,$ to integrate the functionality of counting read operations and opened files.Testing the newly implemented system calls is conducted through a custom test program, $`$syscallTest$.$c$`,$ which validates the correctness of the system calls by comparing the expected and actual counts of read operations and opened files. Successful implementation is indicated by the test program outputting "TEST PASSED".In summary, this project not only introduces students to the fundamentals of kernel development but also challenges them to apply their understanding by extending the functionality of the xv$6$ kernel. Through this hands$-$on approach, students gain invaluable insights into the operation of system calls within an OS kernel, laying a solid foundation for more advanced topics in OS development.