How does the operating system handle system calls?

Processing of system calls (syscalls) in the operating system occurs as follows:

1. Transition from user mode to kernel mode: when an application invokes a system call, the processor switches to privileged mode (kernel mode).

2. Saving context: the OS saves the current process state (registers, stack pointer, etc.) for later restoration.

3. Kernel handles the call: the kernel analyzes the syscall number and parameters passed from user space and performs the corresponding operation (e.g., reading a file, allocating memory).

4. Returning the result: after executing the operation, the kernel returns the result (error code or data) back to user space.

5. Restoring context: the process returns to user mode, continuing execution from the call site.

In Go, system calls are usually wrapped in the standard library, for example, through the syscall package or higher-level abstractions. An example of a file read system call:

package main

import (
    "fmt"
    "os"
)

func main() {
    file, err := os.Open("example.txt")
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()

    buf := make([]byte, 100)
    n, err := file.Read(buf)
    if err != nil {
        fmt.Println("Error reading file:", err)
        return
    }

    fmt.Printf("Read %d bytes: %s\n", n, string(buf[:n]))
}

Here, the calls to Open and Read invoke the corresponding OS system calls, providing interaction with the filesystem.