# Ma'ruza: Operatsion tizimlarning ichki tuzilishi. OT tuzilishi, POSIX, jarayonlar, oqimlar, xotira va kiritish-chiqarish

## 1. Kirish

Oldingi ma'ruzada biz operatsion tizimning vazifasi, uning asosiy funksiyalari va Unix, Linux hamda Windows rivojlanish tarixini ko'rib chiqdik.

Endi operatsion tizimning tashqi ko'rinishidan uning **ichki tuzilishi**ga o'tamiz.

Zamonaviy operatsion tizim murakkab dasturlar majmuasi bo'lib, u bir vaqtning o'zida:

* protsessorni boshqarishi;
* operativ xotirani taqsimlashi;
* dasturlarni ishga tushirishi va yakunlashi;
* fayllarni boshqarishi;
* qurilmalar bilan o'zaro aloqa qilishi;
* tarmoq ishini ta'minlashi;
* xavfsizlikni nazorat qilishi;
* ilovalarga standartlashtirilgan interfeyslarni taqdim etishi kerak.

Kompyuterning OT darajasida qanday ishlashini tushunish uchun quyidagi tushunchalarni o'rganish zarur:

* yadro;
* tizimli chaqiruv;
* foydalanuvchi va imtiyozli rejim;
* jarayon;
* oqim;
* virtual xotira;
* manzil fazosi;
* kiritish-chiqarish amallari;
* POSIX.

---

# 2. Operatsion tizimning tuzilishi

Operatsion tizimni o'zaro ta'sir etuvchi darajalar to'plami sifatida tasavvur qilish mumkin.

Soddalashtirilgan model:

```text
+------------------------------------------+
|              Foydalanuvchi                |
+------------------------------------------+
                     |
                     v
+------------------------------------------+
|       Amaliy dasturlar                   |
| Browser | IDE | Office | Database        |
+------------------------------------------+
                     |
                     v
+------------------------------------------+
|     Tizimli kutubxonalar / API           |
+------------------------------------------+
                     |
                     v
+------------------------------------------+
|          Tizimli chaqiruvlar             |
+------------------------------------------+
                     |
                     v
+------------------------------------------+
|                  Yadro                   |
|                                          |
| Jarayonlar | Xotira | Fayllar | Tarmoq   |
| Drayverlar | I/O    | Xavfsizlik        |
+------------------------------------------+
                     |
                     v
+------------------------------------------+
|          Apparat ta'minoti               |
| CPU | RAM | SSD | GPU | Network | USB   |
+------------------------------------------+
```

Bunday ko'rinish asosiy g'oyani ko'rsatadi: amaliy dasturlar apparat resurslarini to'g'ridan-to'g'ri boshqarmasligi kerak.

---

# 3. Operatsion tizimning yadrosi

**Yadro (Kernel)** — operatsion tizimning markaziy qismi bo'lib, u eng yuqori imtiyozli apparat resurslari bilan ishlaydi.

Yadro ko'plab vazifalarni bajaradi:

* jarayonlarni yaratadi va yakunlaydi;
* jarayonlarni bajarilishini rejalashtiradi;
* oqimlarni boshqaradi;
* xotirani taqsimlaydi;
* fayl tizimlari bilan ishlaydi;
* qurilmalarni boshqaradi;
* apparat uzilishlarini qayta ishlaydi;
* tarmoq o'zaro aloqasini ta'minlaydi;
* xavfsizlik mexanizmlarini amalga oshiradi.

Yadro dasturlar va apparat ta'minoti o'rtasida bog'lovchi bo'g'in hisoblanadi.

Masalan, ilova faylni o'qimoqchi bo'lganda, u SSD ning qaysi fizik bloklarida ma'lumotlar joylashganini bilishi shart emas.

Dastur OTga murojaat qiladi:

```text
Ilova
    ↓
Tizimli chaqiruv
    ↓
Yadro
    ↓
Fayl tizimi
    ↓
Qurilma drayveri
    ↓
SSD
```

---

# 4. OTni qurishning asosiy yondashuvlari

Turli arxitektura yondashuvlari mavjud.

## 4.1. Monolit yadro

**Monolit arxitektura**da OTning asosiy xizmatlari bitta yadro ichida ishlaydi.

Yadroda quyidagilar joylashishi mumkin:

* jarayonlarni boshqarish;
* xotirani boshqarish;
* fayl tizimlari;
* tarmoq steki;
* drayverlar.

Klassik Unix tizimlari monolit yondashuvdan foydalangan.

Linux ham monolit yadroni ishlatadi, garchi u modulli arxitekturaga ega va ba'zi komponentlarni dinamik ravishda yuklash imkonini beradi.

### Afzalliklari

* yuqori unumdorlik;
* komponentlar o'rtasida tezkor almashinuv;
* tizimli operatsiyalarni bajarishning nisbatan oddiy yo'li.

### Kamchiliklari

* yadroning muhim komponentidagi xato butun tizimning ishdan chiqishiga olib kelishi mumkin;
* yadro juda murakkab tizim hisoblanadi.

---

# 5. Mikroyadro arxitekturasi

**Mikroyadro arxitekturasi**da yadroda faqat eng zarur mexanizmlar qoldiriladi.

Masalan:

* bazaviy xotirani boshqarish;
* rejalashtirish;
* jarayonlararo o'zaro aloqa;
* ba'zi quyi darajadagi funksiyalarni qayta ishlash.

Boshqa komponentlar foydalanuvchi makonida ishlashi mumkin.

Soddalashtirilgan:

```text
+--------------------------------------+
|       Foydalanuvchi xizmatlari       |
| Drivers | File System | Network      |
+--------------------------------------+
                 |
                 v
+--------------------------------------+
|              Microkernel             |
| IPC | Scheduling | Memory           |
+--------------------------------------+
                 |
                 v
+--------------------------------------+
|              Hardware               |
+--------------------------------------+
```

Asosiy g'oya komponentlarning izolyatsiyasini oshirishdan iborat.

Mikroyadro yoki unga yaqin yondashuvlardan foydalanadigan tizimlar va arxitekturalar misollari:

* MINIX;
* QNX;
* seL4.

---

# 6. Gibrid arxitekturalar

Ba'zi zamonaviy OTlar turli yondashuvlarning xususiyatlarini birlashtirgan yechimlardan foydalanadi.

Masalan, Windows NT tarixan gibrid arxitektura tamoyillariga ega tizim sifatida tavsiflanadi.

macOS ham turli darajadagi komponentlarni o'z ichiga oladi, jumladan Mach va BSD elementlarini birlashtirgan XNU yadrosi.

Arxitekturaning asosiy vazifasi — quyidagilar o'rtasida muvozanatni topish:

* unumdorlik;
* ishonchlilik;
* xavfsizlik;
* modullilik;
* ishlab chiqish qulayligi.

---

# 7. Foydalanuvchi rejimi va yadro rejimi

Zamonaviy OTlarning fundamental g'oyalaridan biri — dasturlarni imtiyoz darajalariga ko'ra ajratish.

Odatda quyidagilar ajratiladi:

**Foydalanuvchi rejimi (User Mode)**

va

**Yadro rejimi (Kernel Mode)**.

---

# 8. Foydalanuvchi rejimi

Foydalanuvchi rejimida oddiy dasturlar ishlaydi:

* brauzerlar;
* matn muharrirlari;
* IDE;
* media pleerlar;
* o'yinlar;
* server ilovalari.

Foydalanuvchi rejimidagi dastur barcha apparat resurslariga to'g'ridan-to'g'ri kirish imkoniga ega bo'lmasligi kerak.

Masalan, oddiy ilova shunchaki ixtiyoriy ko'rsatmani bajarib, yadro xotirasiga kira olmaydi.

Bu izolyatsiya va xavfsizlikni ta'minlaydi.

---

# 9. Yadro rejimi

Yadro rejimida kengaytirilgan imtiyozlar talab qiladigan OT komponentlari ishlaydi.

Masalan:

* yadro;
* drayverlar;
* OTning quyi darajadagi komponentlari.

Kernel mode dagi kod ancha ko'p imkoniyatlarga ega.

U quyidagilarni amalga oshira oladi:

* apparat qurilmalariga murojaat qilish;
* xotira sahifalari jadvallarini boshqarish;
* apparat registrlari bilan ishlash;
* jarayonlarni boshqarish;
* drayverlar bilan o'zaro aloqa qilish.

Shuning uchun kernel mode dagi xato oddiy ilovaning xatosidan ancha xavfli bo'lishi mumkin.

---

# 10. Rejimlar o'rtasida o'tish

Ilova imtiyozli operatsiyani bajarishi kerak bo'lganda, u uskunaga to'g'ridan-to'g'ri kirish huquqini olmaydi.

Buning o'rniga maxsus mexanizm — **tizimli chaqiruv** ishlatiladi.

Masalan:

```text
Dastur
   |
   | read()
   v
Tizimli chaqiruv
   |
   v
Yadro rejimi
   |
   v
OT yadrosi
   |
   v
Qurilma
```

Operatsiya tugagandan so'ng boshqaruv foydalanuvchi rejimiga qaytariladi.

---

# 11. Tizimli chaqiruvlar

**Tizimli chaqiruv (system call)** — dastur OT yadrosi funksiyalariga murojaat qiladigan mexanizm.

Operatsiyalar misollari:

* jarayon yaratish;
* faylni ochish;
* ma'lumotlarni o'qish;
* ma'lumotlarni yozish;
* xotira ajratish;
* soket yaratish;
* hodisa kutish.

Unix-ga o'xshash tizimlarda tez-tez uchraydigan tizimli chaqiruvlar:

```c
open()
read()
write()
close()
fork()
execve()
wait()
mmap()
```

Standart kutubxona funksiyasi va tizimli chaqiruv bir xil narsa bo'lmasligi mumkinligini tushunish muhim.

Masalan:

```c
printf("Hello");
```

oxir-oqibat yozish tizimli operatsiyalarining bajarilishiga olib kelishi mumkin, ammo ilova va yadro o'rtasida kutubxona buferizatsiyasi mavjud bo'lishi mumkin.

---

# 12. API interfeysi va tizimli chaqiruvlar

Ikki tushunchani farqlash kerak.

### API

**API (Application Programming Interface)** — kutubxona, platforma yoki OT tomonidan taqdim etiladigan dasturiy interfeys.

### System Call

Tizimli chaqiruv — yadro funksiyalariga bevosita murojaat qilish mexanizmi.

Buni quyidagicha tasavvur qilish mumkin:

```text
Dastur
   ↓
API / kutubxona
   ↓
System Call
   ↓
Kernel
   ↓
Hardware
```

Masalan, dasturchi odatda kutubxonalar va API bilan ishlaydi, yadro rejimiga o'tish uchun mashina ko'rsatmalarini qo'lda shakllantirmaydi.

---

# 13. POSIX standarti

**POSIX (Portable Operating System Interface)** — operatsion tizimlarning mosligini ta'minlash uchun interfeyslar, xatti-harakatlar va kelishuvlarni belgilaydigan standartlar oilasi.

POSIX dasturlarni Unix-ga o'xshash tizimlar o'rtasida osonroq ko'chirish uchun ishlab chiqilgan.

Asosiy g'oya:

> standart POSIX-interfeyslaridan foydalanib yozilgan dastur mos keluvchi tizimlar o'rtasida kamroq o'zgartirishlar bilan ko'chirilishi kerak.

---

# 14. POSIX nima uchun kerak?

Umumiy standartlar paydo bo'lishidan oldin Unix-ga o'xshash tizimlar sezilarli darajada farqlanishi mumkin edi.

Dasturchi quyidagilarni hisobga olishi kerak edi:

* turli tizimli chaqiruvlar;
* turli kutubxonalar;
* turli funksiya nomlari;
* tizim xatti-harakatlaridagi farqlar.

POSIX umumiy qoidalar to'plamini shakllantirdi.

Masalan, tanish funksiyalar:

```c
open()
read()
write()
close()
fork()
exec()
wait()
```

an'anaviy Unix/POSIX-dasturlashtirishning bir qismi hisoblanadi.

---

# 15. POSIX API

POSIX ko'p sonli interfeyslarni tavsiflaydi.

Eng muhimlari orasida:

### Fayllar bilan ishlash

```c
open()
read()
write()
close()
```

### Jarayonlar

```c
fork()
exec()
wait()
exit()
```

### Signallar

```c
signal()
sigaction()
```

### Oqimlar

POSIX Threads:

```c
pthread_create()
pthread_join()
pthread_mutex_lock()
pthread_mutex_unlock()
```

### Tarmoq funksiyalari

Unix/POSIX-muhitida standart soket mexanizmlari ishlatiladi:

```c
socket()
bind()
listen()
accept()
connect()
```

---

# 16. POSIX va Linux

Linux POSIX-interfeyslar bilan katta darajada mos keladi, garchi Linux shunchaki "POSIX-operatsion tizimi" emas.

Linux quyidagilarni taqdim etadi:

* POSIX-interfeyslar;
* qo'shimcha tizimli chaqiruvlar;
* o'ziga xos kengaytmalar;
* yadroning maxsus mexanizmlari.

Masalan, Linux bazaviy POSIXda bo'lmagan funksiyalar va mexanizmlarni taqdim etadi.

Bu dasturchilarga ko'chma kodni ham, Linuxning maxsus imkoniyatlarini ham ishlatish imkonini beradi.

---

# 17. POSIX va Windows

Windows Unix tizimi emas va tarixan POSIX atrofida qurilmagan.

Ammo Microsoft turli davrlarda Unix/POSIX-dasturlari bilan moslik texnologiyalarini taqdim etgan.

Zamonaviy Windows tizimlarida **WSL (Windows Subsystem for Linux)** muhim rol o'ynaydi, u Linux muhitini to'g'ridan-to'g'ri Windows ichida ishga tushirish imkonini beradi.

Bu ayniqsa quyidagilar bilan ishlaydigan dasturchilar uchun foydali:

* Bash;
* Linux-vositalar;
* Python;
* Node.js;
* Git;
* Docker;
* server ilovalari.

---

# 18. Dasturlarni bajarish rejimlari

Dasturlar protsessorning ma'lum rejimida bajariladi.

Zamonaviy protsessorlar imtiyoz darajalarini qo'llab-quvvatlaydi.

Asosiy g'oya:

```text
Yuqori imtiyozlar
       ↓
   Kernel Mode
       ↓
-------------------
       ↓
   User Mode
       ↓
Past imtiyozlar
```

x86 arxitekturasida tarixan **rings** deb ataladigan imtiyoz darajalari mavjud.

Eng muhimlari:

* Ring 0 — eng yuqori imtiyozli daraja;
* Ring 3 — foydalanuvchi darajasi.

Odatda yadro Ring 0 da, ilovalar esa Ring 3 da bajariladi.

---

# 19. Nima uchun turli rejimlar kerak?

Asosiy sabab — **tizimni himoya qilish**.

Faraz qilaylik, oddiy dastur xotiraga cheklanmagan kirish huquqini olsa.

U quyidagilarni amalga oshirishi mumkin edi:

* boshqa jarayonning ma'lumotlarini o'zgartirish;
* yadro ma'lumotlarini buzish;
* qurilmaga ixtiyoriy ma'lumotlarni yozish;
* xavfsizlik mexanizmlarini o'chirish;
* tizim ishdan chiqishiga sabab bo'lish.

Shuning uchun operatsion tizim jarayonlarni bir-biridan izolyatsiya qiladi.

---

# 20. Apparat uzilishlari

Operatsion tizim kompyuterda sodir bo'layotgan hodisalarga javob berishi kerak.

Buning uchun **uzilishlar (interrupts)** ishlatiladi.

Masalan:

* klaviatura tugma bosilganligi haqida xabar beradi;
* tarmoq adapteri paket oldi;
* taymer hodisa generatsiya qiladi;
* disk operatsiyani yakunladi.

Soddalashtirilgan:

```text
Qurilma
     |
     | Interrupt
     v
Protsessor
     |
     v
OT ishlov beruvchisi
     |
     v
Zaruriy javob
```

Uzilishlar protsessorga har bir qurilmani doimiy so'ramasdan hodisalarga javob berish imkonini beradi.

---

# 21. Jarayon nima?

**Jarayon** — bajarilayotgan dasturning nusxasi bo'lib, uning bajarilishi uchun zarur bo'lgan resurslar va holatga ega.

Farqlash muhim:

**Dastur** — ko'rsatmalarning passiv to'plami.

**Jarayon** — shu dasturning bajarilayotgan nusxasi.

Masalan, fayl:

```text
firefox.exe
```

dastur hisoblanadi.

Foydalanuvchi Firefoxni ishga tushirganda, operatsion tizim ushbu dasturni bajaradigan jarayonlarni yaratadi.

---

# 22. Jarayon nimalardan tashkil topgan?

Jarayonda quyidagilar mavjud:

* manzil fazosi;
* dastur kodi;
* ma'lumotlar;
* stek;
* dinamik xotira;
* ochiq fayllar;
* holat haqida ma'lumot;
* jarayon identifikatori;
* kirish huquqlari;
* bir yoki bir nechta oqim.

Soddalashtirilgan:

```text
+--------------------------+
|       Process            |
+--------------------------+
| Code                     |
| Data                     |
| Heap                     |
| Stack                    |
| Open Files               |
| Process State            |
| Threads                  |
+--------------------------+
```

---

# 23. Jarayon identifikatori

Har bir jarayon identifikator oladi.

Unix/Linuxda **PID (Process ID)** ishlatiladi.

Masalan:

```bash
ps
```

quyidagilarni ko'rsatishi mumkin:

```text
PID   COMMAND
1012  bash
1524  python
1640  nginx
```

PID operatsion tizim va administratorlarga jarayonni bir ma'noli aniqlash imkonini beradi.

---

# 24. Jarayon holatlari

Jarayon har doim ham to'g'ridan-to'g'ri CPUda bajarilmaydi.

U turli holatlarda bo'lishi mumkin.

Odatiy model:

```text
        +---------+
        |  New    |
        +----+----+
             |
             v
        +---------+
        | Ready   |
        +----+----+
             |
             v
        +---------+
        | Running |
        +----+----+
          /     \
         /       \
        v         v
   Waiting      Terminated
```

### New

Jarayon yaratilmoqda.

### Ready

Jarayon bajarilishga tayyor va protsessorni kutmoqda.

### Running

Jarayon protsessorda bajarilmoqda.

### Waiting / Blocked

Jarayon hodisani kutmoqda, masalan kiritish-chiqarish operatsiyasining tugashini.

### Terminated

Jarayon yakunlangan.

---

# 25. Jarayonlarni rejalashtirish

Kompyuterda bir vaqtning o'zida ko'plab jarayonlar mavjud bo'lishi mumkin, protsessor yadrolari esa ancha kam bo'lishi mumkin.

Shuning uchun OT hal qilishi kerak:

> Hozir qaysi jarayonga protsessor berilsin?

Bu bilan **rejalashtiruvchi (scheduler)** shug'ullanadi.

Rejalashtiruvchi quyidagilarni aniqlaydi:

* qaysi jarayonni ishga tushirish;
* uni qaysi yadroda bajarish;
* qachon boshqa jarayonga o'tish;
* qaysi jarayon ko'proq protsessor vaqtini olishi kerak.

---

# 26. Kontekstni almashtirish

Protsessor bir jarayondan boshqasiga o'tganda, OT joriy jarayonning holatini saqlashi va boshqasining holatini tiklashi kerak.

Bu **kontekstni almashtirish (context switch)** deb ataladi.

Shartli ravishda:

```text
Process A
   |
   | save context
   v
Scheduler
   |
   | load context
   v
Process B
```

Almashtirish vaqt talab qiladi, shuning uchun juda ko'p almashtirishlar unumdorlikka salbiy ta'sir ko'rsatishi mumkin.

---

# 27. Oqim nima?

**Oqim (Thread)** — jarayon ichidagi minimal bajarilish birligi.

Bitta jarayon quyidagilarga ega bo'lishi mumkin:

* bitta oqim;
* bir nechta oqim;
* o'nlab va yuzlab oqimlar.

Bitta jarayonning barcha oqimlari jarayonning umumiy manzil fazosidan foydalanadi, ammo o'zlarining bajarilish holati va stekiga ega.

---

# 28. Jarayon va oqim

Asosiy farq:

**Jarayon** — resurslar va manzil fazosining konteyneri.

**Oqim** — jarayon ichidagi bajarilish birligi.

Soddalashtirilgan:

```text
+--------------------------------+
|           Process              |
|                                |
|  +--------+  +--------+        |
|  |Thread 1|  |Thread 2|        |
|  +--------+  +--------+        |
|                                |
|  Shared Memory                 |
|  Files                         |
|  Resources                     |
+--------------------------------+
```

---

# 29. Oqimlar nima uchun kerak?

Oqimlar bitta ilovaning turli qismlarini bir vaqtda bajarish imkonini beradi.

Masalan, veb-brauzer quyidagilar uchun alohida oqimlardan foydalanishi mumkin:

* foydalanuvchi interfeysini qayta ishlash;
* tarmoq operatsiyalari;
* fayllarni yuklash;
* fon vazifalarini bajarish.

Boshqa misol — server.

Bitta server jarayoni bir nechta oqimlardan foydalanib ko'plab so'rovlarni xizmat qilishi mumkin.

---

# 30. Oqimlarning afzalliklari

Oqimlardan foydalanish quyidagilarga imkon beradi:

* vazifalarni parallel bajarish;
* ko'p yadroli protsessorlardan yaxshiroq foydalanish;
* interfeysni bloklamaslik;
* server vazifalarini samarali bajarish;
* katta vazifalarni mustaqil qismlarga bo'lish.

Ammo ko'p oqimlilik dasturlashni murakkablashtiradi.

---

# 31. Ko'p oqimlilik muammolari

Bitta jarayonning oqimlari umumiy xotiradan foydalanganligi sababli, ikki oqim bir vaqtda bitta o'zgaruvchini o'zgartirgan holat yuzaga kelishi mumkin.

Masalan:

```text
Thread A: counter = 10 ni o'qiydi
Thread B: counter = 10 ni o'qiydi

Thread A: 11 ni yozadi
Thread B: 11 ni yozadi
```

Ikki marta oshirishdan so'ng kutilgan natija:

```text
12
```

Olingan natija:

```text
11
```

Bu **poyga holati (race condition)** ga misol.

---

# 32. Oqimlarni sinxronlash

Mojarolarning oldini olish uchun sinxronizatsiya mexanizmlari qo'llaniladi:

* mutex;
* semaphore;
* condition variable;
* spinlock;
* read-write lock.

Masalan:

```c
pthread_mutex_lock(&mutex);

/* kritik seksiya */

pthread_mutex_unlock(&mutex);
```

**Kritik seksiya** — dasturning bir vaqtda kirish nazorat qilinishi kerak bo'lgan qismi.

---

# 33. Xotirani boshqarish

Operativ xotira — kompyuterning eng muhim resurslaridan biri.

Operatsion tizim quyidagilarni bajarishi kerak:

* jarayonlarga xotira ajratish;
* xotirani bo'shatish;
* manzil fazolarini himoya qilish;
* xotiradan birgalikda foydalanishni ta'minlash;
* virtual xotirani boshqarish;
* xotira sahifalari bilan ishlash.

---

# 34. Fizik va virtual xotira

Fizik xotira — bu haqiqatda o'rnatilgan RAM.

Masalan:

```text
Kompyuter:
32 GB RAM
```

Ammo dasturlar odatda fizik manzillar bilan to'g'ridan-to'g'ri ishlamaydi.

Ular **virtual manzillar**dan foydalanadi.

Soddalashtirilgan:

```text
Jarayon
   |
   | Virtual Address
   v
MMU
   |
   | Physical Address
   v
RAM
```

MMU — Memory Management Unit — virtual manzillarni fizik manzillarga aylantishda ishtirok etuvchi protsessorning apparat mexanizmi.

---

# 35. Jarayonning manzil fazosi

Har bir jarayon odatda o'ziga xos virtual manzil fazosini oladi.

Soddalashtirilgan model:

```text
Yuqori manzillar
+---------------------+
|       Stack         |
+---------------------+
|                     |
|       bo'sh         |
|                     |
+---------------------+
|        Heap         |
+---------------------+
|       Data          |
+---------------------+
|       Code          |
+---------------------+
Past manzillar
```

Asosiy g'oya — bitta jarayonning xotirasi boshqa jarayonning xotirasidan izolyatsiya qilingan.

---

# 36. Xotiraning sahifali tashkil etilishi

Zamonaviy OTlarda virtual xotira odatda sahifalar bo'yicha tashkil etilgan.

Xotira belgilangan o'lchamdagi bloklarga — **sahifalarga (pages)** bo'linadi.

Fizik xotira ham tegishli bloklarga — **framlar**ga bo'linadi.

Soddalashtirilgan:

```text
Virtual Memory
Page 0 ─────────> Frame 8
Page 1 ─────────> Frame 3
Page 2 ─────────> Frame 15
Page 3 ─────────> Frame 1
```

Operatsion tizim va xotiraning apparat mexanizmlari virtual sahifalar va fizik kadrlar o'rtasidagi moslikni qo'llab-quvvatlaydi.

---

# 37. Sahifalar jadvali

Virtual manzillarni fizik manzillarga xaritalash uchun **sahifalar jadvallari (page tables)** ishlatiladi.

Masalan:

```text
Virtual Page    Physical Frame
-----------     --------------
0               15
1               3
2               8
3               12
```

Bu jarayonga uzluksiz virtual manzil fazosidan foydalanish imkonini beradi, hatto fizik xotira bo'laklangan bo'lsa ham.

---

# 38. Xotirani himoya qilish

Virtual xotira mexanizmi kirish huquqlarini o'rnatish imkonini beradi.

Sahifa uchun quyidagi ruxsatlar belgilanishi mumkin:

* Read — o'qish;
* Write — yozish;
* Execute — bajarish.

Masalan:

```text
Code  → Read + Execute
Data  → Read + Write
Stack → Read + Write
```

Bu tizim xavfsizligini oshiradi.

Masalan, bajarish taqiqlangan xotira maydonidan kodni bajarishga urinish istisno holatiga olib kelishi mumkin.

---

# 39. Virtual xotira va swap

Agar fizik RAM yetarli bo'lmasa, OT disk makonidan foydalanishi mumkin.

Linuxda bu odatda **swap** bilan bog'liq.

Masalan:

```text
RAM = 16 GB
Swap = 8 GB
```

Kamdan-kam ishlatiladigan sahifalarning bir qismi vaqtincha RAMdan diskka ko'chirilishi mumkin.

Ammo disk RAMdan sezilarli darajada sekinroq, shuning uchun swap dan intensiv foydalanish odatda unumdorlikning pasayishiga olib keladi.

---

# 40. Xotira ajratish

Dasturlarga xotirani dinamik ravishda ajratish talab qilinadi.

C tilida quyidagilardan foydalanish mumkin:

```c
malloc()
calloc()
realloc()
free()
```

Masalan:

```c
int *data = malloc(100 * sizeof(int));

/* xotira bilan ishlash */

free(data);
```

Bu yerda kutubxona OT mexanizmlari va jarayonning o'z xotira menejeri bilan o'zaro aloqa qiladi.

Zamonaviy dasturlash tillarida xotira avtomatik ravishda boshqarilishi mumkin.

Masalan:

* Java Garbage Collector dan foydalanadi;
* Python o'zining xotirani boshqarish tizimi va axlat yig'ish mexanizmidan foydalanadi;
* JavaScript avtomatik xotirani boshqarishni amalga oshiradi.

---

# 41. Xotira oqishi

**Xotira oqishi (memory leak)** dastur xotira ajratganda, ammo u endi kerak bo'lmagandan keyin bo'shatmaganda yuzaga keladi.

Masalan:

```c
while (1) {
    void *p = malloc(1024);
}
```

Agar xotira doimiy ravishda ajratilsa va bo'shatilmasa, jarayon asta-sekin katta miqdordagi RAMni iste'mol qilishi mumkin.

Uzoq ishlaydigan server dasturlarida xotira oqishi jiddiy muammo bo'lishi mumkin.

---

# 42. Kiritish-chiqarish amallari

**Kiritish-chiqarish (I/O — Input/Output)** — dastur va tashqi qurilmalar yoki tizimli obyektlar o'rtasida ma'lumot almashish.

Kiritish misollari:

* klaviaturadan o'qish;
* tarmoqdan ma'lumot olish;
* faylni o'qish;
* kameradan ma'lumot olish.

Chiqarish misollari:

* faylga yozish;
* tasvirni chiqarish;
* tarmoq paketini yuborish;
* hujjatni chop etish.

---

# 43. Nima uchun I/O hisob-kitoblardan farq qiladi?

CPU operatsiyalari odatda ko'plab kiritish-chiqarish operatsiyalaridan ancha tezroq bajariladi.

Masalan, SSD yoki tarmoq qurilmasi bitta operatsiyani bajarayotganda, protsessor juda ko'p miqdordagi ko'rsatmalarni bajara oladi.

Shuning uchun I/O kutayotgan jarayon odatda protsessorni egallamasligi kerak.

Sxema:

```text
Process
   |
   | read()
   v
Waiting
   |
   | Device completes I/O
   v
Ready
   |
   v
Running
```

---

# 44. Sinxron kiritish-chiqarish

Sinxron operatsiyada dastur operatsiya tugashini kutadi.

Masalan:

```text
read()
   |
   v
Qurilmani kutish
   |
   v
Ma'lumotlar olinadi
   |
   v
Dastur davom etadi
```

Afzalligi — dasturlash soddaligi.

Kamchiligi — jarayon qurilmani uzoq vaqt kutishi mumkin.

---

# 45. Asinxron kiritish-chiqarish

Asinxron yondashuvda ilova operatsiyani boshlaydi va boshqa ishni davom ettiradi.

Soddalashtirilgan:

```text
Dastur
   |
   +----> I/O ni boshlash
   |
   +----> Hisob-kitoblarni davom ettirish
   |
   +----> Bildirishnoma olish
              |
              v
          Ma'lumotlarni qayta ishlash
```

Bu yondashuv ayniqsa quyidagilar uchun muhim:

* serverlar;
* tarmoq ilovalari;
* yuqori yuklamali tizimlar;
* ko'p sonli bir vaqtdagi ulanishlar bilan ilovalar.

---

# 46. Buferizatsiya

Unumdorlikni oshirish uchun ko'pincha **buferizatsiya** ishlatiladi.

Bufer — ma'lumotlar vaqtincha saqlanadigan xotira maydoni.

Masalan:

```text
Dastur
   |
   v
Buffer
   |
   v
Operatsion tizim
   |
   v
Disk
```

Ko'p sonli kichik operatsiyalar o'rniga tizim ma'lumotlarni birlashtirib, bitta samaraliroq operatsiyani bajarishi mumkin.

---

# 47. Keshlash

**Keshlash** tez-tez ishlatiladigan ma'lumotlarni ulardan foydalanish joyiga yaqinroq saqlash imkonini beradi.

Masalan:

```text
CPU Cache
   ↓
RAM
   ↓
SSD
   ↓
HDD
```

Ma'lumotlar CPUga qanchalik yaqin bo'lsa, kirish kechikishi odatda shunchalik kam.

Operatsion tizimlar quyidagilar uchun turli keshlardan ham foydalanadi:

* fayllar;
* xotira sahifalari;
* tarmoq ma'lumotlari;
* fayl tizimi metama'lumotlari.

---

# 48. Qurilma drayverlari

Operatsion tizim har bir qurilmaning noyob tafsilotlarini to'g'ridan-to'g'ri bilishi shart emas.

Bu bilan **drayverlar** shug'ullanadi.

Masalan:

```text
Ilova
     ↓
OT
     ↓
SSD drayveri
     ↓
SSD kontrolleri
     ↓
SSD
```

Drayver OTga muayyan turdagi uskuna bilan ishlash uchun standart interfeys taqdim etadi.

---

# 49. Blokviy va belgiviy qurilmalar

Unix-ga o'xshash OTlarda qurilmalar an'anaviy ravishda turli toifalarga bo'linadi.

### Blokviy qurilmalar

Ma'lumot bloklari bilan ishlaydi.

Misollar:

* HDD;
* SSD;
* USB-xotira qurilmalari.

### Belgiviy qurilmalar

Baytlar ketma-ketligi bilan ishlaydi.

Misollarga quyidagilar kirishi mumkin:

* terminal qurilmalari;
* ketma-ket portlar;
* ba'zi maxsus qurilmalar.

Bunday ajratish Unix-ga o'xshash tizimlar uchun tarixan muhim.

---

# 50. Faylli kiritish-chiqarish

Unix-ga o'xshash tizimlarda quyidagi kontseptsiya katta ahamiyatga ega:

> **"Everything is a file." (Hamma narsa fayl.)**

Bu shuni anglatadiki, tizimning ko'plab resurslari fayl interfeysi orqali taqdim etiladi.

Masalan:

```c
int fd = open("data.txt", O_RDONLY);
read(fd, buffer, size);
close(fd);
```

Bu yerda fayl deskriptori ishlatiladi.

---

# 51. Fayl deskriptori

**File Descriptor (FD)** — jarayon ochiq resursga murojaat qilish uchun foydalanadigan kichik butun son.

Unixning standart deskriptorlari:

```text
0 → stdin
1 → stdout
2 → stderr
```

Masalan:

```bash
echo "Hello" > output.txt
```

Operatsiyaning ma'nosi standart chiqishni faylga yo'naltirish.

---

# 52. Standart kiritish, chiqarish va xatolik

Unix-dasturlari odatda uchta standart fayl deskriptorini oladi:

### stdin — 0

Standart kiritish.

Masalan, klaviaturadan ma'lumotlar.

### stdout — 1

Standart chiqarish.

Masalan, terminalga chiqarish.

### stderr — 2

Standart xatolar oqimi.

Masalan:

```bash
python program.py > output.txt 2> errors.txt
```

Bu yerda oddiy chiqish `output.txt` ga, xato xabarlari esa `errors.txt` ga yoziladi.

---

# 53. Unix konveyerlari

Unixning muhim xususiyatlaridan biri dasturlarni **pipe** orqali birlashtirish imkoniyatidir.

Masalan:

```bash
cat users.txt | grep "admin" | sort
```

Sxema:

```text
cat
 |
 v
grep
 |
 v
sort
```

Bitta dasturning chiqishi boshqasining kiritishiga aylanadi.

Bu kichik dasturlarni birlashtirish modelining kuchli namunasi.

---

# 54. Blokirovka qiluvchi va blokirovka qilmaydigan I/O

**Blokirovka qiluvchi kiritish-chiqarish**da oqim operatsiya tugaguncha to'xtashi mumkin.

**Blokirovka qilmaydigan I/O** da dastur bajarilishni davom ettirishi mumkin.

Bu ayniqsa tarmoq dasturlashda muhim.

Masalan, server har bir kichik hodisa uchun alohida blokirovka qiluvchi oqim yaratmasdan bir vaqtda minglab ulanishlarni xizmat qilishi mumkin.

Unix/Linuxda ko'p sonli hodisalar bilan samarali ishlash uchun quyidagi mexanizmlar ishlatiladi:

* `select`;
* `poll`;
* `epoll`.

BSD-tizimlarida va macOSda `kqueue` ham ishlatiladi.

---

# 55. Kiritish-chiqarish interfeysi

Umumiy holda o'zaro aloqa zanjiri quyidagicha ko'rinadi:

```text
Application
     |
     v
Library / API
     |
     v
System Call
     |
     v
Kernel
     |
     v
Device Driver
     |
     v
Hardware
```

Masalan, faylni o'qishda:

```text
Python
  ↓
open()/read()
  ↓
OS
  ↓
Filesystem
  ↓
Driver
  ↓
SSD
```

---

# 56. Operatsion tizim dasturni qanday ishga tushiradi?

Dasturni ishga tushirishning soddalashtirilgan jarayonini ko'rib chiqaylik.

Foydalanuvchi bajaradi:

```bash
python app.py
```

Quyidagi ketma-ketlik sodir bo'ladi:

```text
Shell
  ↓
Jarayon yaratish
  ↓
Manzil fazosini tayyorlash
  ↓
Dasturni yuklash
  ↓
Oqimni ishga tushirish
  ↓
CPU ni rejalashtirish
  ↓
Bajarish
```

Unix-ga o'xshash tizimlarda `fork()` va `exec()` mexanizmlari tarixan muhim rol o'ynaydi.

---

# 57. Fork va Exec

`fork()` mavjud jarayon asosida yangi jarayon yaratadi.

Keyin `exec()` jarayonning tarkibini yangi dastur bilan almashtiradi.

Soddalashtirilgan:

```text
Shell
  |
  +---- fork()
           |
           v
       Child process
           |
           +---- exec()
                  |
                  v
              New program
```

Masalan, Bash qobig'i bolalar jarayonini yaratib, unda kerakli dasturni ishga tushirishi mumkin.

---

# 58. Jarayonlar o'zaro aloqasi

Jarayonlar ma'lumot almashishi mumkin.

Buning uchun **IPC (Inter-Process Communication)** mexanizmlari mavjud.

Asosiy variantlar:

* pipes;
* named pipes;
* shared memory;
* message queues;
* signals;
* sockets;
* fayllar.

Masalan:

```text
Process A
   |
   | pipe
   v
Process B
```

Yoki:

```text
Process A
     \
      \
     Shared Memory
      /
     /
Process B
```

---

# 59. Jarayon, oqim va xotira — o'zaro bog'liqlik

Uchta tushunchani to'g'ri tushunish muhim:

### Jarayon

Izolyatsiya qilingan manzil fazosi va resurslarni taqdim etadi.

### Oqim

Jarayon ichida ko'rsatmalarni bajaradi.

### Xotira

Jarayon tomonidan ishlatiladigan kod, ma'lumotlar, stek va boshqa obyektlarni o'z ichiga oladi.

Soddalashtirilgan:

```text
+--------------------------------+
|             Jarayon            |
|                                |
|  +---------+  +---------+      |
|  | Thread1 |  | Thread2 |      |
|  +---------+  +---------+      |
|       |             |          |
|       +------+------+          |
|              |                 |
|        Shared Address          |
|           Space                |
+--------------------------------+
```

---

# 60. Amaliy misol

Oddiy serverni ko'rib chiqaylik.

Faraz qilaylik, server HTTP-so'rovlarni qabul qiladi.

Mumkin bo'lgan arxitektura:

```text
             Server Process
                    |
        +-----------+-----------+
        |           |           |
      Thread 1    Thread 2    Thread 3
        |           |           |
     Client A    Client B    Client C
```

Har bir oqim o'z so'rovini qayta ishlaydi.

Bunda barcha oqimlar jarayonning umumiy xotirasidan foydalanadi.

Agar bitta oqim umumiy ma'lumotlar strukturasini o'zgartirsa, mutex kerak bo'lishi mumkin.

---

# 61. CPU, xotira va I/O qanday o'zaro aloqa qiladi?

Odatiy dasturni ko'rib chiqaylik:

```python
data = open("data.txt").read()
result = process(data)
print(result)
```

Soddalashtirilgan:

### 1-qadam

Dastur faylni o'qish operatsiyasini chaqiradi.

### 2-qadam

OT kirish huquqlarini tekshiradi.

### 3-qadam

Yadro fayl tizimiga murojaat qiladi.

### 4-qadam

Fayl tizimi drayver bilan o'zaro aloqa qiladi.

### 5-qadam

Qurilma ma'lumotlarni qaytaradi.

### 6-qadam

Ma'lumotlar xotiraga tushadi.

### 7-qadam

CPU qayta ishlashni bajaradi.

### 8-qadam

Natija standart chiqishga uzatiladi.

Natija:

```text
SSD
 ↓
Kernel
 ↓
RAM
 ↓
CPU
 ↓
RAM
 ↓
Kernel
 ↓
Terminal
```

Bu oddiy misol dasturning bitta qatorini bajarishda ham operatsion tizim qanchalik ko'p ish bajarishini ko'rsatadi.

---

# 62. OTning asosiy ichki quyi tizimlari

Zamonaviy operatsion tizimni shartli ravishda quyidagi quyi tizimlarga bo'lish mumkin:

```text
+--------------------------------+
|        User Applications       |
+--------------------------------+
|        System Libraries        |
+--------------------------------+
|          System Calls          |
+--------------------------------+
|             Kernel             |
|                                |
| Process Management             |
| Memory Management              |
| File Systems                   |
| I/O Management                 |
| Networking                     |
| Security                       |
| Device Drivers                 |
+--------------------------------+
|            Hardware            |
+--------------------------------+
```

Har bir quyi tizim o'ziga xos vazifalar sinfini hal qiladi.

---

# 63. Asosiy mexanizmlar aloqasi

Ko'rib chiqilgan barcha tushunchalarni yagona modelda birlashtirish mumkin:

```text
                 APPLICATION
                      |
                      v
                    API
                      |
                      v
                SYSTEM CALL
                      |
                      v
               USER / KERNEL
                 TRANSITION
                      |
                      v
+------------------------------------------------+
|                    KERNEL                      |
|                                                |
| Scheduler | Processes | Threads | Memory       |
|                                                |
| File System | I/O | Network | Drivers         |
+------------------------------------------------+
                      |
                      v
                  HARDWARE
```

Bu sxema aksariyat tizimli operatsiyalarning bajarilish yo'lini tavsiflaydi.

---

# 64. Nimani eslab qolish muhim

## 1. OT tuzilishi

Operatsion tizim o'zaro ta'sir etuvchi komponentlardan iborat bo'lib, ularning markaziysi yadro hisoblanadi.

## 2. Kernel Mode va User Mode

Rejimlarni ajratish xavfsizlik va izolyatsiyani ta'minlaydi.

## 3. Tizimli chaqiruvlar

System calllar ilovalarga yadro funksiyalariga nazorat qilingan kirishni taqdim etadi.

## 4. POSIX

POSIX ko'plab Unix-ga o'xshash interfeyslarni standartlashtiradi va dasturlarni mos keluvchi tizimlar o'rtasida ko'chirishni osonlashtiradi.

## 5. Jarayon

Jarayon — o'z manzil fazosi va resurslariga ega bo'lgan dasturning bajarilayotgan nusxasi.

## 6. Oqim

Oqim — jarayon ichidagi bajarilish birligi.

## 7. Xotirani boshqarish

OT xotirani taqsimlash, virtual adreslash, himoya va xotiradan birgalikda foydalanishni ta'minlaydi.

## 8. Kiritish-chiqarish

I/O dasturlarga fayllar, tarmoq va qurilmalar bilan o'zaro aloqa qilish imkonini beradi.

---

# 65. Nazorat savollari

1. Operatsion tizimning yadrosi nima?
2. OT tuzilishiga qaysi asosiy komponentlar kiradi?
3. Monolit yadro mikroyadrodan nimasi bilan farq qiladi?
4. Foydalanuvchi rejimi nima?
5. Yadro rejimi nima?
6. Nima uchun oddiy ilovaga apparat ta'minotiga to'liq kirish ruxsat berib bo'lmaydi?
7. Tizimli chaqiruv nima?
8. API tizimli chaqiruvdan nimasi bilan farq qiladi?
9. POSIX nima?
10. POSIX standarti nima uchun yaratilgan?
11. Bir nechta POSIX-funksiyalarni nomlang.
12. Jarayon nima?
13. Jarayon qaysi asosiy komponentlardan tashkil topgan?
14. PID nima?
15. Jarayon qanday holatlarga ega bo'lishi mumkin?
16. Jarayonlar rejalashtiruvchisi nima qiladi?
17. Context switch nima?
18. Oqim nima?
19. Oqim jarayondan nimasi bilan farq qiladi?
20. Nima uchun ko'p oqimlilik sinxronizatsiya muammolari yaratishi mumkin?
21. Race condition nima?
22. Mutex nima?
23. Virtual xotira nima?
24. Virtual manzil fizik manzildan nimasi bilan farq qiladi?
25. Xotira sahifasi nima?
26. Sahifalar jadvali nima?
27. Swap nima?
28. Kiritish-chiqarish nima?
29. Sinxron I/O asinxrondan nimasi bilan farq qiladi?
30. Buferizatsiya nima?
31. Fayl deskriptori nima?
32. `stdin`, `stdout` va `stderr` nima?
33. Pipe nima?
34. Qurilma drayveri nima?
35. Nima uchun jarayonlar kutish holatiga o'tishi mumkin?
36. Jarayon, oqim va virtual xotira qanday bog'langan?

---

# 66. Amaliy topshiriqlar

## Topshiriq 1. Linuxda jarayonlarni tadqiq qilish

Bajaring:

```bash
ps aux
```

Keyin:

```bash
top
```

Quyidagilarni toping:

* jarayonning PID si;
* jarayon nomi;
* CPU foydalanishi;
* xotira foydalanishi.

Javob bering:

1. Qaysi jarayon eng ko'p CPU ishlatadi?
2. Qaysi jarayon eng ko'p RAM ishlatadi?
3. Qaysi jarayonlar sizning foydalanuvchingizga tegishli?

---

## Topshiriq 2. Xotirani tadqiq qilish

Linuxda bajaring:

```bash
free -h
```

O'rganing:

* total;
* used;
* free;
* available;
* swap.

`free` va `available` o'rtasidagi farqni tushuntiring.

---

## Topshiriq 3. Fayl deskriptorlarini tadqiq qilish

Ishga tushiring:

```bash
ls -l /proc/$$/fd
```

Aniqlang:

* qaysi deskriptor stdinga mos keladi;
* qaysi stdout;
* qaysi stderr.

---

## Topshiriq 4. Jarayonlar bilan tajriba

Dastur yarating:

```python
import os
import time

print("PID:", os.getpid())
print("Parent PID:", os.getppid())

while True:
    time.sleep(1)
```

Uni ishga tushiring:

```bash
python process.py
```

Boshqa terminalda bajaring:

```bash
ps aux | grep process.py
```

Jarayonning PID sini aniqlang.

Keyin uni yakunlang:

```bash
kill PID
```

---

## Topshiriq 5. Oqimlarni tadqiq qilish

Dastur yarating:

```python
import threading
import time

def worker(name):
    for i in range(5):
        print(name, i)
        time.sleep(1)

t1 = threading.Thread(target=worker, args=("Thread-1",))
t2 = threading.Thread(target=worker, args=("Thread-2",))

t1.start()
t2.start()

t1.join()
t2.join()
```

Javob bering:

1. Dastur nechta oqim yaratadi?
2. Nima uchun oqimlarning chiqishi aralashib ketishi mumkin?
3. Oqimlar jarayonning bitta xotirasini ishlatadimi?
4. Agar ikki oqim bir vaqtda bitta umumiy o'zgaruvchini o'zgartirsa nima bo'ladi?

---

# 67. Ma'ruzaning yakuniy sxemasi

```text
                    OPERATSION TIZIM
                             |
        +--------------------+--------------------+
        |                    |                    |
        v                    v                    v
     PROCESSES            MEMORY                 I/O
        |                    |                    |
        v                    v                    v
     THREADS              PAGES                DRIVERS
        |                    |                    |
        +----------+---------+---------+----------+
                   |                   |
                   v                   v
              SYSTEM CALLS         FILE SYSTEM
                   |
                   v
              KERNEL MODE
                   |
                   v
             HARDWARE
```

# Xulosa

Operatsion tizimning ichki tuzilishi bir nechta fundamental mexanizmlarga asoslangan.

**Yadro** kompyuterning asosiy resurslarini boshqaradi va apparat ta'minoti bilan o'zaro aloqa qiladi.

**User Mode va Kernel Mode rejimlari** imtiyozlarni ajratishni ta'minlaydi va tizimni ilovalarning noto'g'ri xatti-harakatidan himoya qiladi.

**Tizimli chaqiruvlar** ilovalar va yadro o'rtasida nazorat qilinadigan interfeys yaratadi.

**POSIX** ko'plab Unix-ga o'xshash interfeyslarni standartlashtiradi va dasturiy ta'minotning ko'chma bo'lishiga yordam beradi.

**Jarayonlar** bajarilayotgan dasturlarning izolyatsiyasini ta'minlaydi, **oqimlar** esa bitta jarayon ichida bir nechta mustaqil bajarilish ketma-ketliklarini tashkil etish imkonini beradi.

**Xotirani boshqarish** har bir jarayonga o'zining virtual manzil fazosi bilan ishlash imkonini beradi, xotirani himoya qilishni ta'minlaydi va fizik RAMdan samarali foydalanadi.

**Kiritish-chiqarish** dasturlarning disklar, tarmoq, klaviatura, ekran va boshqa qurilmalar bilan o'zaro aloqasini ta'minlaydi.

Shunday qilib, OTning asosiy mexanizmlari bir-biri bilan chambarchas bog'langan:

**jarayon oqimda bajariladi → oqim virtual xotiradan foydalanadi → resurslarga kirish uchun tizimli chaqiruvlar bajariladi → yadro resurslarni boshqaradi → drayverlar apparat ta'minoti bilan o'zaro aloqa qiladi.**

Aynan shu mexanizmlar Linux, Windows, macOS va boshqa zamonaviy operatsion tizimlarning ishlashi asosida yotadi.