Kısım I · Makine · Bölüm 17

Sürücüler ve Giriş/Çıkış

Donanımla konuşmak (Device drivers and I/O)

1. Kat 8–10Ağ, tarayıcı, bizim uygulamaAygıt dili bu katlardan görünmez.
2. Kat 7İşletim sistemiBu bölüm: sürücüler ve kesme işleyicileri. Bölüm 13–18.
3. Kat 0–3Donanım: elektrik, kapılar, devreler, işlemci ve bellekBu bölüm: aygıtlar bu tarafta; yazmaçlarıyla açılırlar.

Örnekler Linux ağırlıklıdır, çünkü kaynaklarımız Linux'u anlatır; macOS ve Windows'taki adları Bölüm 18'de göreceğiz. Bölümün sonunda şunları bileceksin: giriş/çıkış aygıtlarının (klavye, ekran, disk, ağ kartı) bilgisayara nasıl bağlandığını; sürücünün ne olduğunu; işin tamamlandığını öğrenme yöntemlerini (yoklama, kesme) ve veri taşıma yöntemini (DMA) birbirinden ayırmayı; ve Bölüm 1'deki kat planını, bir tuş basışının elektrikten ekrana yolculuğu olarak yeniden okumayı.

17.1 Giriş/çıkış aygıtları: klavye, ekran, disk, ağ kartı

Bölüm 1.1'de her işin dört parçaya ayrıldığını görmüştük: girdi, işlem, çıktı, saklama. İşlemci ve bellek işlemin fiziksel karşılığıydı. Girdi, çıktı ve saklama için giriş/çıkış aygıtı (I/O device) gerekir: bilgisayarın dış dünyayla ya da kalıcı depoyla alışveriş yaptığı her parça. OSTEP şöyle başlar: hiç girdisi olmayan bir program her seferinde aynı sonucu üretir; hiç çıktısı olmayan bir programın çalışmasının ne anlamı olurdu?¹

Dört örnek: klavye ve dokunmatik yüzey yalnızca girdi ("B şıkkı"na dokunmak); ekran yalnızca çıktı (yeşil "Doğru!" ve +10); disk ve ağ kartı (network interface card, NIC) hem girdi hem çıktı (dünkü seriyi saklamak, cevabı sunucuya yollamak).

Aygıtlar neden farklı yollara bağlanır?

Klavyeden saniyede birkaç tuş gelir, ekran kartı milyonlarca pikselin rengini ister; hepsini neden tek yola bağlamıyoruz? OSTEP'in cevabı iki kelime: fizik ve maliyet. Bir yol (veri yolu (bus), ayrıntısı Bölüm 6.3'te) ne kadar hızlıysa o kadar kısa olmak zorundadır; en hızlı yola çok aygıt takacak yer kalmaz, üstelik hızlı yol pahalıdır. Tasarımcılar bu yüzden kademe kurmuştur: hızlı yol işlemciye yakın, yavaş yol uzak.¹

OSTEP'in klasik şemasında hızlı aygıtlar genel bir yola (PCI), yavaşlar çevre birimi yoluna (SCSI, SATA, USB) takılır. OSTEP’in gösterdiği Intel Z270 örneğinde işlemci belleğe ve ekran kartına hızlı bir bağlantıyla (PCIe) konuşur; diğer birçok aygıt ayrı bir giriş/çıkış çipi (I/O chip) üzerinden bağlanır: diskler SATA, klavye ve fare USB, ağ kartı ve hızlı NVMe diskler PCIe ile.¹ Kısaltmaları ezberleme; fikir şu: aygıtlar hıza ve maliyete göre kademelendirilmiş yollara takılır, tıpkı Bölüm 8'deki bellek hiyerarşisi gibi.

Bir aygıtın iki yüzü: arayüz ve iç yapı

Her aygıtın iki parçası vardır; bu, Bölüm 1.4'ün arayüz–gerçekleme ayrımının donanımdaki halidir.¹

• Donanım arayüzü: aygıtın sisteme gösterdiği yüz. OSTEP'in basitleştirilmiş "kanonik aygıtında" üç aygıt yazmacı (device register) vardır: durum yazmacı (status register) (aygıt ne yapıyor, meşgul mü), komut yazmacı (command register) (aygıta iş yaptırmak için) ve veri yazmacı (data register) (veri vermek ya da almak için). Yazmacı Bölüm 5.3'ten tanıyorsun; fark, bunların işlemcide değil aygıtın üzerinde olması.
• İç yapı: arayüzü gerçekten yerine getiren, aygıta özgü kısım. Karmaşık aygıtlar küçük bir işlemci ve bellek taşır; OSTEP'e göre modern bir RAID denetleyicisi yüz binlerce satırlık gömülü yazılım (Bölüm 12) içerebilir.¹

Arayüz de aygıttan aygıta değişir; bunu 17.2'de sürücüyle çözeceğiz.

Disk: aygıtın birimi ile dosya sisteminin birimi

Dosya sistemi dosya ve bloklarla ilgilenirken disk arayüzü okunup yazılabilen sektörler (sectors) sunar. OSTEP'in basitleştirilmiş disk örneğinde sektör 512 byte'tır. Dosya sistemi bloğunu 4096 byte seçersek 4096 ÷ 512 = 8 sektör eder; hesabı Python ile doğruladık. Bu seçilmiş örnektir, bütün disklerde aynı sektör boyu veya güç kesintisi güvencesi var demiyoruz. Üstteki dosya bloğu ile alttaki aygıt aktarım birimi aynı olmak zorunda değildir.²

17.2 Sürücü: işletim sistemi ile donanım arasındaki tercüman

OSTEP sorunu dosya sistemiyle koyar: dosya sistemini SCSI disklerde, IDE disklerde, USB belleklerde aynı şekilde çalışacak biçimde yazmak istiyoruz; bir okuma ya da yazma isteğinin her aygıtta nasıl verildiğinden habersiz kalmasını istiyoruz.¹ Çözüm, Bölüm 1.4'ten tanıdığın soyutlama. En altta, bu bölümdeki çekirdek tabanlı modelde, aygıtın nasıl çalıştığını ayrıntısıyla bilen bir yazılım parçası bulunur: sürücü (device driver). Aygıtla etkileşimin bütün özgül ayrıntıları onun içine kapatılmıştır.¹

Hukuk benzetmesi: yabancı dilde ifade veren tanığı dinleyen hâkim yalnızca Türkçe bilir; yeminli tercüman o dilin ayrıntılarını hâkimden saklar. Her yeni dil için yeni tercüman gerekir, mahkeme aynı kalır. Benzetmenin sınırı şudur: sürücü her ayrıntıyı aynen dışarı vermez; ortak bir arayüz sunabilmek için bazı aygıt farklarını gizler.

Dosya sisteminden aygıta inen yol

OSTEP, Linux'un dosya sistemi yığınını kabaca şöyle çizer: uygulama POSIX arayüzüyle (open, read, write, close) dosya sistemine seslenir; dosya sistemi genel blok arayüzüne ("blok oku/yaz") konuşur; genel blok katmanı isteği uygun sürücüye yönlendirir; sürücü aygıta özgü isteği verir.¹

Uygulama                                 [kullanıcı alanı]
-- POSIX arayüzü: open, read, write --
Dosya sistemi                            [çekirdek, Bölüm 13.2]
-- genel blok arayüzü: blok oku/yaz --
Genel blok katmanı
-- aygıta özgü arayüz --
Sürücü [SCSI, ATA, ...]
Aygıt (disk)                             [donanım]

Her kat yalnızca bir alttakinin arayüzünü bilir. Şemada ayrıca, özel araçların (dosya sistemi denetleyicisi, disk birleştirme gibi) dosya soyutlamasını atlayıp blokları doğrudan okumasını sağlayan bir ham arayüz (raw interface) de var.¹ Böylece Bölüm 16'daki zincir tamamlanır: ad → inode → blok numarası → sürücü → sektörler.

Sürücü aygıtla nasıl konuşur

Sürücünün işi, 17.1'deki üç yazmacı kullanan bir protokolü yürütmektir. OSTEP'in dört adımlı kanonik protokolü:¹

Durum == MEŞGUL olduğu sürece bekle      // 1. aygıt hazır mı, tekrar tekrar bak
Veriyi VERİ yazmacına yaz                 // 2. aygıta veriyi ver
Komutu KOMUT yazmacına yaz                // 3. aygıt işe başlar
Durum == MEŞGUL olduğu sürece bekle      // 4. bitti mi, tekrar tekrar bak

İşlemcinin veriyi bizzat taşıdığı bu yönteme programlanmış giriş/çıkış (programmed I/O, PIO) denir. Basit ve çalışır; ama bekleme döngüleri ve veri taşıma işlemciyi meşgul eder. Çaresi 17.3'te.

İşlemci aygıt yazmacına nasıl yazar? OSTEP iki yöntem sayar:¹

• Giriş/çıkış komutları (explicit I/O instructions): x86 örneğinde in ve out: değeri bir yazmaca koyarsın, aygıtı adlandıran bir port numarası verirsin. Bu erişim ayrıcalık denetimine bağlıdır (Bölüm 13.2); sıradan bir program keyfine göre aygıtı yönetemez. Her program diski doğrudan yazabilseydi OSTEP'in deyişiyle "kaos" olurdu.
• Belleğe eşlenmiş giriş/çıkış (memory-mapped I/O): donanım, aygıt yazmaçlarını bellek konumları gibi sunar. Yazmaca erişmek için işletim sistemi o adrese yükleme (okuma) ya da saklama (yazma) komutu verir; donanım isteği belleğe değil aygıta yönlendirir. Yeni komut gerektirmemesi hoş yanıdır (Bölüm 5.4'teki adres fikrinin uzantısı).

OSTEP, birinin ötekine belirgin üstünlüğü olmadığını söyler; ikisi de bugün kullanılıyor.¹

Üç sınıf: karakter, blok, ağ

Linux'ta sürücülerin sunduğu aygıtlar üç temel sınıfa ayrılır:⁵

• Karakter aygıtı (character device): byte akışı gibi (dosya gibi) erişilen aygıt; metin konsolu, seri port. Çoğu yalnızca ardışık erişilen bir veri kanalıdır.
• Blok aygıtı (block device): üzerinde dosya sistemi barındırabilen aygıt, örneğin disk; aktarım bloklar halinde yönetilir.
• Ağ arayüzü (network interface): başka bilgisayarlarla paket alışverişi yapan aygıt; tek tek bağlantıları bilmez. Bu sınıflandırmada sıradan bir /dev aygıt dosyası olarak sunulmaz; eth0 olası bir arayüz adıdır, her makinenin zorunlu adı değildir. Paket ayrıntılarını Bölüm 19 açacak.

Sınıflar sert değildir: bir USB aygıtı karakter, blok ya da ağ aygıtı olarak görünebilir.⁵

Bölüm 16'daki izinlerle buluşma: /dev

Karakter ve blok aygıtlarına /dev dizinindeki dosya sistemi girdileriyle ulaşılır.⁵ "Her şey dosyadır" fikri (Bottom-Up CS): ekran yazılan, klavye okunan bir dosya gibi görülebilir; dosya, veri veren ya da alan her şeyin soyutlamasıdır.⁴ Bu dosyalar aygıtın kendisi değil, ona erişim kapısıdır.

ls -l çıktısında c karakter aygıtını, b blok aygıtını belirtir; 16.3'teki izin bilgileri bu girdilerde de görünür. Dosya boyu yerine görülebilen ana ve alt numara (major and minor number), geleneksel olarak sürücüyü ve onun yönettiği aygıtı ayırt eder. Böylece insanın gördüğü ad, çekirdeğin ilgili sürücü işlevlerini bulabildiği erişim kaydına bağlanır.⁶ Komutları çalıştırmayı Bölüm 18'de öğreneceğiz.

Mekanizma ve politika; soyutlamanın bedeli

Linux Device Drivers'ın temel ilkesi: sürücü mekanizma (mechanism) sağlar, politika (policy) değil. Mekanizma "hangi yetenekler sunulacak", politika "bunlar nasıl kullanılacak"tır. Örnek: disket sürücüsü yalnızca disketi sürekli bir blok dizisi gösterir; kimin erişeceğine, dosya sistemi üzerinden mi doğrudan mı erişileceğine üst katmanlar karar verir.⁵ Benzetme: altyapı kamu hizmetini mümkün kılar, kimin yararlanacağı mevzuatındır; yukarıdaki rw-rw---- bir politikadır.

Soyutlamanın bedeli de olabilir. OSTEP'in tarihsel blok arayüzü örneğinde, SCSI'nin ayrıntılı hata bilgisi üst katlara yalnız genel EIO giriş/çıkış hatası olarak aktarılabilir. Ortak arayüz basitlik sağlar ama aygıtın her özelliğini göstermeyebilir.¹ Linux'ta sürücüler çekirdeğe derlenebildiği gibi yüklenebilir modül (loadable kernel module) olarak sonradan da eklenebilir. insmod ve rmmod böyle modül işlemlerinin araçlarıdır; burada yalnız adlarını tanıyoruz, çalıştırmıyoruz.⁵

17.3 Kesme, yoklama, doğrudan bellek erişimi (DMA)

Protokoldeki iki bekleme döngüsünü hatırla. Bölüm 8.1'deki gecikme farkını sayıya çevirelim. Süreler örnek değerdir (belirli bir aygıtın ölçümü değil), işlemci 3 GHz (saniyede 3 milyar çevrim, Bölüm 5.2):

(Süre × 3 × 10⁹, Python ile doğrulandı.) İşlemci bunları bekleme döngüsünde harcarsa, tek bir disk okumasında otuz milyon çevrim çöpe gider. Sorun: işlemci ile aygıtın hızı arasındaki uçurum. İki soruyu ayıralım: sonucu nasıl öğreneceğiz, veriyi kim taşıyacak?

Yoklama: tekrar tekrar sormak

17.2'deki protokolde işletim sistemi, bitip bitmediğini durum yazmacını tekrar tekrar okuyarak anlıyordu. Buna yoklama (polling) denir. Basit ve çalışır, ama OSTEP'in dediği gibi (potansiyel olarak yavaş) aygıtı beklerken çok işlemci zamanı harcar; oysa hazır başka bir sürece geçilebilirdi.¹ Benzetme: duruşma sonucunu öğrenmek için kalemin kapısını beş dakikada bir çalmak.

Kesme: aygıt işlemciyi dürtsün

Çözüm kesmedir (interrupt). İşletim sistemi isteği verir, isteği yapan süreci uyutur ve başka işe geçer (bağlam değişimi, Bölüm 14.2). Aygıt işini bitirince bir donanım kesmesi gönderir; işlemci yaptığı işi bırakıp işletim sisteminin önceden belirlenmiş bir koduna atlar: kesme işleyicisi (interrupt handler, ISR). İşleyici isteği tamamlar (veriyi okur, hata kodunu alır) ve bekleyen süreci uyandırır.¹ Hesaplama ile giriş/çıkış üst üste biner: disk süreç 1'in isteğini işlerken işlemci süreç 2'yi çalıştırır; çalıştırılabilecek başka iş varsa bekleme süresi yararlı hesapla örtüşebilir.

Bottom-Up CS’in sade kesmeli modelinde mekanizma şöyle: tuşa basılınca olayı işletim sistemine iletmek için kesme üretilir. Aygıtlar anakarttaki ayrı bir çipe, kesme denetleyicisine (programmable interrupt controller, PIC) bağlanır; aygıt kesme istediğinde hattın gerilimini değiştirir (Bölüm 3.1), denetleyici bunu işlemciye mesaj olarak iletir. İşletim sistemi, her kesmeyi atlanacak bir kod adresiyle eşleştiren bir kesme tablosu (interrupt descriptor table) hazırlamıştır; işlemci tabloya bakıp işleyiciyi bulur. İşleyiciyi yazmak sürücü yazarının işidir. Kesme her an gelebileceğinden işletim sistemi işleyiciye girerken yazmaçları kaydeder, çıkarken geri yükler; kaybedilen zaman dışında kesme çalışan programa görünmezdir. Çoğu sürücü işi iki aşamaya böler: kesmeyi onaylayıp işi sıraya koyar, işlemciyi hemen eski işine döndürür, ağır işlemeyi sonra yapar.³

Aynı düzenek içeriden de kullanılır (Bottom-Up CS): geçersiz bellek erişimi gibi işlemci istisnaları, sistem çağrısına tuzakla giriş ve sanal bellek kesmenin akrabalarıdır; Bölüm 13.3'teki sistem çağrısı ve Bölüm 15.3'teki sayfa hatası böyledir.³

Kesme her zaman iyi değildir

"Kesme yoklamayı yener" sonucu yanlıştır. OSTEP’in vurgusu: çok hızlı bir aygıtta kısa yoklama daha ekonomik olabilir; iş hemen bitmişse kesmenin ek maliyeti kazancı aşabilir, çünkü başka sürece geçmek, kesmeyi işlemek, geri dönmek pahalıdır. Hız bilinmiyorsa melez yöntem: kısa süre yokla, bitmediyse kesmeye geç. Ağda daha tehlikeli bir durum vardır: her paket bir kesme üretirse işletim sistemi yalnızca kesmeleri işleyip kullanıcı süreçlerine hiç fırsat veremeyen bir canlı kilitlenmeye (livelock) düşebilir; OSTEP'in örneği, yük patlaması yaşayan bir web sunucusudur. Bir eniyileme kesme birleştirme (interrupt coalescing): aygıt kesmeyi göndermeden biraz bekler, bu sırada biten başka istekler tek kesmede toplanır; bedel gecikmedir.¹

DMA: veriyi işlemci taşımasın

Bir sorun daha: PIO'da büyük bir veri bloğu aygıta aktarılırken işlemci veriyi kelime kelime kopyalar. Öğretim hesabı (512 byte sektör ve her kopyada 4 byte varsayımıyla sektör başına 128 kopya): 4096 byte blok = 8 sektör = 8 × 128 = 1024 kopyalama (Python ile doğrulandı). Çözüm doğrudan bellek erişimi (direct memory access, DMA): DMA motoru, aygıtlarla ana bellek arasındaki aktarımı işlemciyi neredeyse hiç karıştırmadan yöneten özel bir aygıttır. İşletim sistemi motora üç şey söyler: verinin bellekte nerede olduğunu, ne kadar kopyalanacağını, hangi aygıta gideceğini; sonra başka işe geçer, aktarım bitince motor kesme gönderir.¹ Bottom-Up CS aynı akışı sürücü açısından anlatır.³ İşlemci 1024 ayrı veri kopyasını kendisi yapmak yerine aktarımı hazırlar ve tamamlanmasını yönetir. Bunun tam komut sayısı aygıta ve sürücüye bağlıdır. Benzetme: sekretere "dosyaları taşı, bitince zili çal" demek.

17.4 Donanım–yazılım ilişkisinin tam tablosu: kat planına dönüş

Bölüm 1.5'te "donanım ile yazılımın sınırı Kat 3 ile 4 arasından geçer" demiş, bunun bir sadeleştirme olduğunu eklemiştik. Sınırın gerçekte nerede kesiştiğini artık görüyoruz: sürücü, yazılımın donanıma dokunduğu yerdir. Ele aldığımız modelde çekirdek kodudur; aygıt arayüzüyle konuşur: yazmaçlar, adresler, bekleme bitleri. Tablo planı giriş/çıkış gözüyle okur:

İki sonuç: giriş/çıkış tek katta yaşamaz; Kat 7 ise onca çeşitliliği dosyalara, bloklara, paketlere çevirir. Bölüm 1.4'ün "arayüz sabit kaldıkça alttaki kat değişebilir" cümlesinin kanıtı: uyumlu ortak arayüzü sağlayan yeni aygıt, üstteki uygulamayı aygıt ayrıntılarından koruyabilir. Bu, bütün donanım değişimlerinin her zaman yalnız sürücüyle çözüleceği garantisi değildir.

Bir giriş olayının yolculuğu

Bölüm 1.7'deki önizlemeyi (index.html'e çift tıklamak) şimdi açabiliriz. Kesmeli girişin sade modeli (her donanım yolu aynı değildir; özellikle USB gibi bağlantılar ek denetleyici katları içerebilir):

1. Kat 0–2, aygıt: Klavyenin devresi tuşu bir sinyale çevirir (OSTEP: USB, klavye ve fare gibi düşük hızlı aygıtlar içindir).¹
2. Kat 3, kesme: Aygıt, kesme denetleyicisi üzerinden işlemciye kesme gönderir; Bottom-Up CS tam olarak bu örneği verir.³
3. Kat 7, sürücü: İşlemci tablodan işleyiciyi bulur; sürücü olayı aygıt yazmaçlarından okur.
4. Kat 7 → 9: İşletim sistemi olayı odaktaki programa (tarayıcıya) iletir; bu dinlemeyi Bölüm 26'da göreceğiz.
5. Kat 9–10: Tarayıcı uygun belge olayını oluşturur; uygulamanın dinlediği olay bir düğme etkinleştirmesine karşılık geliyorsa örneğin cevap işlenir. Her tuşun otomatik olarak click olduğu söylenmiyor.
6. Çıktı, ters yönde: Görüntü piksel renkleri olarak ekran kartına, oradan ekrana gider.¹

Bölüm 1.7'deki "çift tıklama bir sürücü aracılığıyla alınır" cümlesi artık açık: fiziksel girdi, aygıt ve işletim sistemi katlarından geçer; kesme, bu modelde haber verme mekanizmasıdır, giriş verisinin kendisi değildir.

Bu bölümde neler kuruldu

Aygıtlar hız ve maliyet yüzünden kademeli yollara bağlanır ve durum, komut, veri yazmaçlarından oluşan bir arayüzün arkasında gizli bir iç yapı taşır. Aygıtın özgül ayrıntılarını bilen çekirdek kodu sürücüdür; sürücü mekanizma sağlar, politikayı üst katlar koyar. Yavaşlık üç araçla yönetilir: yoklama, kesme, DMA. Terimler sözlükte, Bölüm 17 başlığı altında.

Kaynaklar

1. Remzi H. Arpaci-Dusseau ve Andrea C. Arpaci-Dusseau, Operating Systems: Three Easy Pieces, I/O Devices (bölüm 36, v1.10): kademeli yollar, kanonik aygıt ve protokol, PIO, yoklama, kesme, birleştirme, livelock, DMA, giriş/çıkış komutları, belleğe eşleme, sürücü yığını, EIO, aygıt soyutlaması.
2. OSTEP, Hard Disk Drives (bölüm 37), The Interface: 512 byte'lık sektörler, 4 KB'lık işlemler, yırtık yazma.
3. Ian Wienand, Computer Science from the Bottom Up, Peripherals and buses: kesme, denetleyici, tablo, durum kaydetme, istisna ve tuzak, iki aşamalı işleme, NMI, DMA.
4. Ian Wienand, Computer Science from the Bottom Up, Bölüm 1, Everything is a file!: ekran, klavye, yazıcı, CD-ROM'un dosya soyutlamasıyla görülmesi.
5. Corbet, Rubini, Kroah-Hartman, Linux Device Drivers, 3. baskı, Bölüm 1, An Introduction to Device Drivers: mekanizma ve politika, modüller, karakter/blok/ağ sınıfları, USB örneği.
6. Corbet, Rubini, Kroah-Hartman, Linux Device Drivers, 3. baskı, Bölüm 3, Char Drivers: ana ve alt numara, /dev girdileri, ls -l örneği.