Giriş

Öğrenme Çıktıları

Giriş

İşletim Sistemi Tasarlamak Neden Zor?

Tanenbaum’ın sekiz etkeni. Uzun bakım-onarım ihtiyacı 5. ve 8. maddelerin doğal sonucudur.

Giriş · Adım adım

İşletim Sisteminin Hedefleri

Arayüz Tasarımı

Arayüz Tasarımı İçin Yol Gösterici İlkeler

Arayüz Tasarımı

“Küçük Güzeldir”

Arayüz Tasarımı

Kullanıcı Arayüzü Paradigmaları

Arayüz Tasarımı

Yürütme Paradigmaları

int main(void)
{
    int x, y;
    init();
    do_something();
    read(fd, &x, sizeof x);
    do_something_else();
    write(fd, &y, sizeof y);
    keep_going();
    exit(0);
}

int main(void)
{
    msg_t msg;
    init();
    while (get_message(&msg)) {
        switch (msg.type) {
        case 1: ... ; break;
        case 2: ... ; break;
        case 3: ... ; break;
        }
    }
}

Yürütme paradigmasının seçimi, sistem çağrılarını da biçimlendirir: algoritmik model bloke eden (blocking) read ister; olay güdümlü model ise “sıradaki olayı ver” türünden bir çağrı (get_message, epoll_wait, io_uring_enter) ister.

Arayüz Tasarımı · Kodu adım adım çalıştır

Olay Döngüsü Nasıl Çalışır?

int main(void) {
    msg_t m;
    init();
    while (get_message(&m)) {
        switch (m.type) {
        case KEY:   on_key(&m);   break;
        case CLICK: on_click(&m); break;
        case TIMER: on_timer(&m); break;
        }
    }
    return 0;
}

Arayüz Tasarımı

Veri Paradigmaları

• Ortak bir veri paradigması, aynı aracın (cat, dd, yönlendirme) her kaynakta çalışmasını sağlar: cat /proc/loadavg.
• Bedeli: bazı aygıtlar dosya modeline sığmaz; o zaman her şey ioctl gibi “kaçış kapılarına” yığılır.

Arayüz Tasarımı

Sistem Çağrısı Arayüzü

Sistem Yapısı

Sistem Yapısı Seçenekleri

Sistem Yapısı · Adım adım

Katmanlı Sistemler: Yedi Katmanlı Bir Tasarım

Katmanların sırası bağımlılıklardan çıkar: sanal bellek sayfaları diske yazdığı için sürücülerin, dosya sistemi sayfa çerçevesi ayırdığı için sanal belleğin üstündedir. Donanımı gizleyen 1. katman taşınabilirliği sağlar; bedeli her katman geçişinin maliyetidir.

Sistem Yapısı

Genişletilebilir Sistemler

Sistem Yapısı

Çekirdek İş Parçacıkları

Kullanıcı süreçleri çekirdek iş parçacığı oluşturamaz; sistem çağrıları yalnızca çekirdeğin zaten çalıştırdığı iş parçacıklarına iş verebilir (ör. io_uring’in iş havuzu).

Tasarım İlkeleri · Adım adım

Mekanizma ve Politikanın Ayrılması

Diğer örnekler: sayfalama (mekanizma: MMU, çerçeve tahsisi; politika: hangi sayfa çıkarılsın), CPU frekansı (mekanizma: cpufreq sürücüsü; politika: schedutil/powersave yönetici), güvenlik (mekanizma: LSM kancaları; politika: SELinux kuralları).

Tasarım İlkeleri

Diklik (Orthogonality)

Tasarım İlkeleri

Adlandırma: İki Düzeyli Adlar

Ad, insanların hatırlayabileceği biçimde (ASCII/Unicode dizgisi) seçilir; sistem içinde ise hızlı ve benzersiz bir sayı kullanılır. Aradaki eşleme, adı değiştirmeden nesneyi taşımaya olanak verir.

Tasarım İlkeleri · Adım adım

Ad Çözümleme Adım Adım

Tasarım İlkeleri

Bağlama Zamanı

Bağlama zamanı, “bir ad hangi anda gerçek nesneye bağlanır?” sorusudur. İşletim sistemleri genel olarak geç bağlamayı seçer; örneğin sanal bellek, bir sayfanın fiziksel yerini her erişimde (TLB yardımıyla) yeniden çözer.

Tasarım İlkeleri · Kodu adım adım çalıştır

Statik ve Dinamik Yapılar

found = 0;
for (p = &proc_table[0];
     p < &proc_table[PROC_TABLE_SIZE];
     p++) {
    if (p->proc_pid == pid) {
        found = 1;
        break;
    }
}

Statik tablo: basit, ayırıcı gerektirmez, ama dolunca yeni süreç oluşturulamaz (eski UNIX’te NPROC). Dinamik yapı (bağlı liste, hash tablosu, Linux’ta xarray): esnek ve aramada O(1)’e yakın, ama bellek ayırıcı, parçalanma ve karmaşık kilitleme getirir. Ara yol: boyutu ayarlanabilir tablolar (/proc/sys/kernel/pid_max).

Tasarım İlkeleri

Yukarıdan Aşağı ve Aşağıdan Yukarı Gerçekleştirme

Tasarım İlkeleri

Eş Zamanlı ve Eş Zamansız İletişim

Yararlı Teknikler

Donanımı Gizleme

#include "config.h"
void init(void)
{
#if (CPU == X86_64)
    /* x86-64 başlatma kodu */
#endif
#if (CPU == ARM64)
    /* ARM64 başlatma kodu */
#endif
#if (CPU == RISCV64)
    /* RISC-V başlatma kodu */
#endif
}

#include "config.h"
#include <stdint.h>
#if (WORD_LENGTH == 32)
typedef int Register;
#elif (WORD_LENGTH == 64)
typedef long Register;
#else  /* bugün: taşınabilir */
typedef uintptr_t Register;
#endif
Register R0, R1, R2, R3;

Kodlar Tanenbaum’daki Pentium/UltraSPARC örneğinin güncellenmiş hâlidir.

Yararlı Teknikler · Adım adım

Dolaylılık (Indirection)

“Bilgisayar bilimindeki her sorun, bir dolaylılık düzeyi daha ile çözülebilir.” (David Wheeler). İşletim sistemlerinde: sanal bellek (sayfa tablosu), dosya tanımlayıcıları, sembolik bağlar, i-node, aygıt sınıfları.

Yararlı Teknikler

Yeniden Kullanım ve Yeniden Girişlilik

char *strtok(char *s, const char *d)
{
    static char *last; /* paylaşılan durum! */
    ...
}

/* yeniden girişli sürüm: durum çağıranda */
char *strtok_r(char *s, const char *d,
               char **saveptr);

Yararlı Teknikler · Kodu adım adım çalıştır

strtok ve Yeniden Girişlilik: Kod İzleme

char *my_strtok(char *s, char ayr) {
    static char *kalan;     /* herkes paylaşır! */
    if (s) kalan = s;
    if (!kalan || !*kalan) return NULL;
    char *bas = kalan;
    while (*kalan && *kalan != ayr) kalan++;
    if (*kalan) *kalan++ = '\0';
    return bas;
}
/* main:   my_strtok(a, ',')  a = "ali,veli" */
/* kesme:  my_strtok(b, ';')  b = "x;y"      */
/* main:   my_strtok(NULL, ',')              */

Yararlı Teknikler

Kaba Kuvvet ve Önce Hata Denetimi

lock(&tbl_lock);
buf = kmalloc(n, GFP_KERNEL);
if (n > MAX || !access_ok(u, n)) {
    kfree(buf);
    unlock(&tbl_lock);
    return -EINVAL;
}

if (n > MAX || !access_ok(u, n))
    return -EINVAL; /* önce denetle */
buf = kmalloc(n, GFP_KERNEL);
if (!buf)
    return -ENOMEM;
lock(&tbl_lock);
...

Parametreleri kilit ve bellek almadan önce doğrulamak, hata yolundaki geri alma kodunu (ve unutulan unlock hatalarını) ortadan kaldırır.

Performans

Performans: Neden Yavaş, Neyi Hızlandırmalı?

Performans · Kodu adım adım çalıştır

Uzay-Zaman Ödünleşimi: (a) Döngüyle Bit Sayma

#define BYTE_SIZE 8
int bit_count(int byte)
{
    int i, count = 0;
    for (i = 0; i < BYTE_SIZE; i++)
        if ((byte >> i) & 1)
            count++;
    return count;
}

Performans

Uzay-Zaman Ödünleşimi: (b) Makro ve (c) Tablo

/* (b) makro: döngü yok */
#define bit_count(b) ((b&1) + ((b>>1)&1) + \
    ((b>>2)&1) + ... + ((b>>7)&1))

/* (c) tablo: 256 bayt */
char bits[256] =
    {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, ...};
#define bit_count(b) (int) bits[b]

Performans · Kodu adım adım çalıştır

Yarım Bayt Tablosuyla Bit Sayma: Kod İzleme

char yarim[16];          /* 16 bayt */
void tablo_kur(void) {
    yarim[0] = 0;
    for (int i = 1; i < 16; i++)
        yarim[i] = (i & 1) + yarim[i >> 1];
}
int bit_say(unsigned char b) {
    return yarim[b & 0x0F] + yarim[b >> 4];
}

Performans

Uzay-Zaman Ödünleşimi: Renk Paleti

Yer yaklaşık 3 kat azalır; bedeli her piksel gösterilirken bir tablo bakışı (zaman) ve en fazla 256 renk sınırıdır. GIF ve PNG-8 bu yöntemi kullanır (GIF ayrıca LZW ile sıkıştırır). Boyutlar Python ile hesaplanmıştır.

Performans

Önbelleğe Almak (Caching)

Performans · Kodu adım adım çalıştır

Yol Önbelleği ile Ad Çözümleme: Kod İzleme

/* bil[]: "usr","bal","tez.tex"; n = 3 */
int cozumle(char *bil[], int n) {
    int k = n, ino = KOK, okuma = 0;
    while (k > 0 && !onbellekte(bil, k, &ino))
        k--;              /* en uzun önek */
    for (int j = k; j < n; j++) {
        ino = dizinde_ara(ino, bil[j]);
        okuma += 2;       /* i-node + blok */
        onbellege_ekle(bil, j + 1, ino);
    }
    return ino;
}

Performans

İpuçları (Hints)

Performans

Yerelliği Kullanmak (Exploiting Locality)

• Zamansal yerellik: yakın zamanda kullanılan tekrar kullanılır (önbelleğin temeli). Uzamsal yerellik: yakınındaki de kullanılır (önden okuma, büyük sayfalar).
• Birlikte kullanılan verileri yan yana koymak: FFS silindir grupları, ext4 blok grupları; NUMA’da belleği iş parçacığının düğümünden ayırmak.

Performans · Adım adım

Yaygın Durumu Hızlandırmak

Genel ilke (Lampson): yaygın durum hızlı, nadir durum doğru olmalı. Diğer örnekler: sistem çağrılarının hızlı yolu, vDSO ile çekirdeğe girmeden clock_gettime, TLB isabeti.

Proje Yönetimi · Adım adım

Efsanevi Adam-Ay (The Mythical Man-Month)

Brooks’un OS/360 deneyiminden önerdiği zaman dağılımı: 1/3 planlama, 1/6 kodlama, 1/4 modül testi, 1/4 sistem testi. Yani kod yazmak işin yalnızca altıda biridir.

Proje Yönetimi

Takım Yapısı, Deneyim ve “Gümüş Kurşun Yok”

Test ve Hata Ayıklama

İS Kodunu Test Etmek Neden Zor?

İS’de başarısız bir test çoğu zaman makinenin kendisini kaybetmek demektir; bu yüzden testler sanal makinelerde, zaman aşımı ve otomatik yeniden başlatmayla koşulur.

Test ve Hata Ayıklama

Çekirdek Test Piramidi

Test ve Hata Ayıklama

Dinamik Denetleyiciler: KASAN, KCSAN, lockdep

BUG: KASAN: slab-use-after-free in mydrv_release+0x54/0x90
Read of size 8 at addr ffff888012a4c010 by task cat/1432

Test ve Hata Ayıklama · Kodu adım adım çalıştır

KASAN Gölge Bellek Denetimi: Kod İzleme

/* 8 baytlık bölge başına 1 gölge bayt:
   0: hepsi geçerli, 1..7: ilk k bayt,
   < 0: kırmızı bölge ya da serbest */
void kasan_denetle(void *a, int boy) {
    int8_t s = *(int8_t *)(((uintptr_t)a >> 3)
                           + GOLGE_OFS);
    if (s == 0) return;            /* hızlı yol */
    if (((uintptr_t)a & 7) + boy - 1 >= s)
        rapor(a, s);
}
/* p = kmalloc(13); p[3]; p[12]; p[13]; */
/* kfree(p); p[0]; */

Test ve Hata Ayıklama · Kodu adım adım çalıştır

lockdep Kilit Sırası Çizgesi: Kod İzleme

void lock_acquire(task *t, int L) {
    for (int i = 0; i < t->n; i++) {
        int H = t->tutulan[i];
        if (yol_var(L, H))   /* L → … → H */
            uyar("olası kilitlenme", H, L);
        kenar_ekle(H, L);    /* H, L'den önce */
    }
    t->tutulan[t->n++] = L;
}
void lock_release(task *t) { t->n--; }
/* T1: A,B   T2: B,C   T3: C,A */

Test ve Hata Ayıklama · Adım adım

Fuzzing: syzkaller Döngüsü

Fuzzer tek başına yalnız çökmeleri görür; KASAN gibi denetleyiciler sessiz bellek bozulmalarını ilk geçersiz erişimde görünür kılar. Bu yüzden ikisi birlikte kullanılır.

Test ve Hata Ayıklama

Gözlem ve İz Sürme Araçları

# hangi süreç hangi dosyayı açıyor?
bpftrace -e 'tracepoint:syscalls:sys_enter_openat { printf("%s %s\n", comm, str(args.filename)); }'

Önce gözlem, sonra tahmin: log ve izler hipotez kurmayı sağlar. Ama ağır printk zamanlamayı değiştirip yarış hatasını gizleyebilir; düşük yüklü izleyiciler (ftrace, eBPF) bu yüzden tercih edilir.

Test ve Hata Ayıklama

QEMU ve gdb ile Çekirdek Hata Ayıklama

# 1. terminal: -s → gdb sunucusu :1234
#             -S → CPU başta durur
qemu-system-x86_64 -kernel bzImage \
  -append "console=ttyS0 nokaslr" \
  -nographic -s -S
# 2. terminal
gdb vmlinux
(gdb) target remote :1234
(gdb) hbreak start_kernel
(gdb) continue
(gdb) bt
(gdb) lx-dmesg  # çekirdek gdb betiği

BUG: kernel NULL pointer dereference,
     address: 0000000000000010
Oops: 0000 [#1] PREEMPT SMP NOPTI
CPU: 2 PID: 1432 Comm: cat
Tainted: G           O  6.12.0
RIP: 0010:mydrv_read+0x2a/0x80 [mydrv]
Call Trace:
 vfs_read+0xa4/0x2f0
 ksys_read+0x63/0xe0
 do_syscall_64+0x82/0x170

Test ve Hata Ayıklama · Kodu adım adım çalıştır

Regresyon Avı: git bisect

git bisect start
git bisect bad v6.12
git bisect good v6.11
# #500: derle, başlat, sına
git bisect bad
git bisect good   # #250
git bisect good   # #375
git bisect bad    # #437
git bisect run ./sina.sh
git bisect reset

./sina.sh 0 ile biterse commit iyi, 1–127 (125 hariç) ile biterse kötü sayılır; 125 “bu commit sınanamaz, atla” demektir.

Eğilimler

İşletim Sistemlerinde Eğilimler

Eğilimler

Çok Çekirdek ve Geniş Adres Alanları

Eğilimler

Rust, eBPF ve Unikernel’ler

Özet

Özet

Özet

Alıştırma: Test ve Hata Ayıklama

1. Bir sürücüde ara sıra görülen use-after-free hatasını hangi araçlarla, hangi sırayla yakalarsınız? syzkaller neden KASAN açık bir çekirdekle çalıştırılır?
2. v6.11 ile v6.12 arasında 12 000 commit var ve bir performans gerilemesi v6.12’de ortaya çıkmış. git bisect en çok kaç test gerektirir? Sınama betiği hangi çıkış kodlarını kullanmalıdır?
3. Bir yarış hatası printk eklenince kayboluyor. Bunun nedeni nedir; hangi araçlarla incelemeye devam edersiniz?

Özet

Kontrol Soruları

1. Tanenbaum’a göre işletim sistemi tasarımını zorlaştıran sekiz etkenden dördünü açıklayın.
2. Basitlik, bütünlük ve verimlilik ilkelerini birer sistem çağrısı örneğiyle tartışın.
3. Algoritmik ve olay güdümlü yürütme paradigmalarını karşılaştırın. Olay döngüsünde uzun süren bir işleyici neden sorun olur?
4. Yedi katmanlı tasarımda sanal bellek neden aygıt sürücülerinin üstündedir?
5. Mikro çekirdekte bir sürücü çöktüğünde ne olur? Monolitik çekirdekte aynı durum neden daha tehlikelidir?
6. Mekanizma ile politikayı ayırmayı çizelgeleyici örneğiyle açıklayın. sched_ext bu ilkeyi nasıl uygular?
7. /usr/ast/mbox yolunun çözümlenmesi önbelleksiz kaç disk erişimi gerektirir? Önbellek ile ipucu arasındaki fark nedir?
8. Bit sayma örneğinde döngü, makro ve tablo yöntemlerini yer ve zaman açısından karşılaştırın.
9. futex neden yaygın durumu hızlandırmanın iyi bir örneğidir?
10. Brooks yasasını iletişim yolu sayısıyla gerekçelendirin: 10 kişilik ekipte kaç yol vardır?

Özet

Kaynaklar

• A. S. Tanenbaum, H. Bos, Modern Operating Systems, 4. baskı (2014) / 5. baskı (2023), Pearson — Bölüm 12: Operating System Design.
• B. W. Lampson, “Hints for Computer System Design”, ACM SOSP, 1983 (ve 2020 güncellemesi “Hints and Principles for Computer System Design”).
• F. P. Brooks Jr., The Mythical Man-Month: Essays on Software Engineering, 20. yıl baskısı, Addison-Wesley, 1995 — “No Silver Bullet” (1986) dahil.
• J. H. Saltzer, M. F. Kaashoek, Principles of Computer System Design: An Introduction, Morgan Kaufmann, 2009.
• D. R. Engler, M. F. Kaashoek, J. O’Toole, “Exokernel: An Operating System Architecture for Application-Level Resource Management”, SOSP 1995.
• G. Klein vd., “seL4: Formal Verification of an OS Kernel”, SOSP 2009; J. N. Herder vd., MINIX 3 güvenilirlik çalışmaları.
• Linux çekirdeği belgeleri: Rust (docs.kernel.org/rust), BPF ve sched_ext; H. Franke vd., “Fuss, Futexes and Furwocks”, 2002.