System call అంటే ఏమిటి, user mode మరియు kernel mode అంటే ఏమిటి?

Question

IT Interview Practice · Accepted Answer

ఒక **system call (syscall)** అనేది user-space ప్రోగ్రామ్ kernel నుండి ఒక సేవను — file తెరవడం, network డేటా పంపడం, memory కేటాయించడం, ప్రాసెస్ సృష్టించడం — అభ్యర్థించడానికి వాడే యంత్రాంగం. ఈ చర్యలు హార్డ్‌వేర్‌ను తాకుతాయి లేదా ఇతర processలను ప్రభావితం చేస్తాయి కాబట్టి, వాటిని కేవలం **kernel** మాత్రమే చేయగలదు, కాబట్టి ఒక syscall ఉద్దేశపూర్వకంగా protection సరిహద్దును దాటుతుంది.

## 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 నియంత్రిత **mode switch**ను kernel modeలోకి చేస్తుంది, నమ్మదగిన kernel కోడ్‌ను నడుపుతుంది, తర్వాత తిరిగి వస్తుంది:

```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 దాన్ని చుట్టేస్తుంది. మీ కోడ్‌లోని `fopen`/`fread` చివరికి `open`/`read` syscallలను పిలుస్తాయి:

```c
// glibc యొక్క read() syscall number + argsను registersలో ఉంచుతుంది,
// తర్వాత ఒక trap instructionను execute చేస్తుంది (ఉదా. x86-64 మీద `syscall`).
ssize_t n = read(fd, buffer, 4096);   // → kernelలోకి trap చేస్తుంది
```

trap (ఒక software interrupt / అంకిత instruction) అనేది privilege స్థాయిని సురక్షితంగా మార్చే విషయం — user కోడ్ కేవలం kernelలోకి "దూకలేదు"; అది తమ argumentsను validate చేసే నిర్వచించిన syscall entry pointsల వద్ద మాత్రమే ప్రవేశించగలదు.

## ఇది ఎందుకు ముఖ్యం

user/kernel విభజన OS security మరియు stability యొక్క పునాది: ఒక ప్రాసెస్ హార్డ్‌వేర్ మీద లేదా మరొక ప్రాసెస్ మెమరీ మీద గీత గీయలేకపోవడానికి కారణం ఇదే. syscallలను అర్థం చేసుకోవడం పెర్ఫార్మెన్స్‌ను కూడా వివరిస్తుంది — ప్రతి syscall ఒక mode switch (వందల నానోసెకన్లు) ఖర్చవుతుంది, అందుకే I/Oను batch చేయడం లేదా syscall సంఖ్యను తగ్గించడానికి `mmap`/`io_uring` వాడటం ముఖ్యం, మరియు `strace` (ఒక ప్రోగ్రామ్ syscallలను జాబితా చేస్తుంది) అంత శక్తివంతమైన debugging పరికరం ఎందుకో ఇదే.

User mode vs kernel mode

ఆచరణలో ఇది ఎలా పనిచేస్తుంది

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు