System call என்றால் என்ன, மேலும் user mode மற்றும் kernel mode என்றால் என்ன?

Question

IT Interview Practice · Accepted Answer

ஒரு **system call (syscall)** என்பது ஒரு user-space program kernel-இடமிருந்து ஒரு சேவையைக் கோர — file திறத்தல், network data அனுப்புதல், memory allocate செய்தல், ஒரு process உருவாக்குதல் — பயன்படுத்தும் வழிமுறை. இந்த செயல்கள் hardware-ஐத் தொடுகின்றன அல்லது மற்ற processes-ஐப் பாதிக்கின்றன என்பதால், **kernel** மட்டுமே அவற்றைச் செய்ய முடியும், எனவே ஒரு syscall வேண்டுமென்றே பாதுகாப்பு எல்லையைக் கடக்கிறது.

## User mode vs kernel mode

CPU (குறைந்தது) இரண்டு privilege நிலைகளில் ஒன்றில் இயங்குகிறது:

```text
 user mode   → restricted: no direct hardware access, no privileged instructions
 kernel mode → full access: hardware, all memory, privileged CPU instructions
```

ஒரு சாதாரண function call user mode-இலேயே இருக்கிறது. ஒரு syscall kernel mode-இற்குள் ஒரு கட்டுப்படுத்தப்பட்ட **mode switch**-ஐச் செய்து, நம்பகமான kernel code-ஐ இயக்கி, பிறகு திரும்புகிறது:

```text
  user code            kernel
  ─────────            ──────
  read(fd, buf, n)
      │  trap (syscall instruction)
      └──────────────▶ enter kernel mode
                       validate args, do the I/O
      ◀────────────── return value, back to user mode
  continue
```

## நடைமுறையில் இது எப்படி வேலை செய்கிறது

நீங்கள் அரிதாகவே trap-ஐ நீங்களே எழுதுகிறீர்கள் — C library அதை wrap செய்கிறது. உங்கள் code-இல் உள்ள `fopen`/`fread` இறுதியில் `open`/`read` syscalls-ஐ அழைக்கின்றன:

```c
// glibc's read() places the syscall number + args in registers,
// then executes a trap instruction (e.g. `syscall` on x86-64).
ssize_t n = read(fd, buffer, 4096);   // → traps into the kernel
```

Trap (ஒரு software interrupt / அர்ப்பணிக்கப்பட்ட instruction) தான் privilege நிலையைப் பாதுகாப்பாக மாற்றுவது — user code kernel-இற்குள் வெறுமனே "குதிக்க" முடியாது; அது தங்கள் arguments-ஐ validate செய்யும் வரையறுக்கப்பட்ட syscall entry points-இல் மட்டுமே நுழைய முடியும்.

## இது ஏன் முக்கியம்

User/kernel பிரிவு OS security மற்றும் நிலைத்தன்மையின் அடித்தளம்: ஒரு process ஏன் hardware-இல் அல்லது இன்னொரு process-இன் memory-இல் கிறுக்க முடியாது என்பதற்கான காரணம் இதுவே. Syscalls-ஐப் புரிந்துகொள்வது performance-ஐயும் விளக்குகிறது — ஒவ்வொன்றும் ஒரு mode switch (நூற்றுக்கணக்கான nanoseconds) செலவாகிறது, அதனால்தான் I/O-ஐ batch செய்வது அல்லது syscall எண்ணிக்கையைக் குறைக்க `mmap`/`io_uring`-ஐப் பயன்படுத்துவது முக்கியம், மேலும் `strace` (ஒரு program-இன் syscalls-ஐப் பட்டியலிடுவது) ஏன் அத்தகைய சக்திவாய்ந்த debugging கருவி என்பதையும் விளக்குகிறது.

User mode vs kernel mode

நடைமுறையில் இது எப்படி வேலை செய்கிறது

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்