IAli
Tüm Yazılar
Linux OOM Killer Algoritması ve vm.overcommit_memory Dinamikleri

Linux OOM Killer Algoritması ve vm.overcommit_memory Dinamikleri

Linux oom_badness puanlama hesabı, oom_score_adj koruması, overcommit_memory kipleri ve kritik veritabanı servislerini kurban seçilmekten kurtarma rehberi.

Üretim ortamı sistem yöneticilerinin ve güvenilirlik mühendislerinin (SRE) en sık karşılaştığı kabuslardan biri, sunucudaki ana PostgreSQL veya MySQL veritabanının aniden yok olmasıdır. Sistem loglarına bakıldığında şu satır göze çarpar: Out of memory: Kill process 1420 (mysqld) score 842 or sacrifice child.

Sunucuda kontrolsüzce bellek sızdıran küçük bir Python veya Node.js worker süreci varken, Linux çekirdeği neden yüz binlerce aktif kullanıcıya hizmet veren ana veritabanını kurban seçer? Bu kararın arkasında Linux Out-of-Memory (OOM) Killer alt sisteminin puanlama formülü ve bellek taahhüt (overcommit) politikaları yer alır.

TEXT
Linux Bellek Yetersizliği ve OOM Karar Akışı:

Süreç Bellek İster (malloc/mmap)
              │
              ▼
   Yeterli Fiziksel Bellek / Takas Var mı?
        ├── Evet ──► Bellek Sayfası Eşlenir
        └── Hayır ──► Sayfa Geri Kazanımı (kswapd / Direct Reclaim)
                            │
               Başarısız Oldu mu? (Out of Memory)
                            │
                            ▼
              Çekirdek: select_bad_process()
                            │
              Tüm Süreçler Taranır (oom_badness)
              Puan = RSS + Sayfa Tablosu + oom_score_adj
                            │
                            ▼
              En Yüksek Puana Sahip Sürece SIGKILL (9)

1. Bellek Taahhüdü: vm.overcommit_memory Dinamikleri

Linux çekirdeği varsayılan olarak süreçlere fiziksel RAM ve takas (swap) toplamından çok daha fazla bellek tahsis eder. Bu davranışa iyimser bellek tahsisi (optimistic memory allocation) veya overcommit adı verilir. Gerekçe basittir: Süreçler genellikle malloc() ile ayırdıkları sanal belleğin tamamına hemen yazmazlar. Sayfalar ancak üzerlerine gerçek veri yazıldığında (page fault anında) fiziksel belleğe bağlanır. Bu yapı Linux sanal bellek ve sayfa tabloları hiyerarşisinde yönetilir.

Çekirdeğin bellek taahhüt davranışını vm.overcommit_memory parametresi belirler. Üç farklı kip bulunur:

Mod 0: Sezgisel Aşırı Taahhüt (Heuristic Overcommit - Varsayılan)

Çekirdek bariz şekilde aşırı olan bellek isteklerini reddeder, ancak makul boyuttaki talepleri fiziksel belleği aşsa bile onaylar. Tipik masaüstü ve genel sunucu iş yükleri için tasarlanmıştır.

Mod 1: Koşulsuz Onay Kipi (Always Overcommit)

Çekirdek bellek kontrolünü devre dışı bırakır ve her tahsis isteğini onaylar. Bilimsel hesaplama ve sparse array kullanan özel yazılımlar dışında genel sunucularda kullanılması ani sistem kilitlenmelerine yol açar.

Mod 2: Katı Taahhüt Sınırı (Strict Overcommit - No Overcommit)

Çekirdek toplam taahhüt edilebilir bellek miktarını kesin bir üst sınırla sınırlar. Bu sınır şu formülle hesaplanır:

$$\text{CommitLimit} = \text{Swap} + (\text{RAM} \times \frac{\text{vm.overcommit_ratio}}{100})$$

Örneğin 64 GB RAM ve 8 GB Swap bulunan bir sunucuda vm.overcommit_ratio varsayılan olarak 50 ise:

$$\text{CommitLimit} = 8 \text{ GB} + (64 \text{ GB} \times 0.50) = 40 \text{ GB}$$

Sistemdeki tüm süreçlerin toplam sanal bellek taahhüdü (/proc/meminfo içindeki Committed_AS) bu sınırı aştığı anda malloc() çağrıları ENOMEM hatasıyla başarısız olur. OOM Killer hiç devreye girmeden uygulama seviyesinde hata yakalanır.

2. OOM Puanlama Algoritması: oom_badness() Nasıl Hesaplanır?

Sistemde serbest bellek tükendiğinde ve çekirdeğin bellek geri kazanım döngüleri (kswapd ve doğrudan geri çağırma) sonuç vermediğinde OOM Killer devreye girer. Çekirdek select_bad_process() fonksiyonu üzerinden tüm süreç tablosunu tarar ve her süreç için oom_badness() fonksiyonunu çağırır.

Linux çekirdek kaynak kodunda (mm/oom_kill.c) puan hesabı temel olarak şu faktörlere dayanır:

  1. Temel Puan (Base Points): Sürecin kullandığı Yerleşik Küme Boyutu (Resident Set Size - RSS) ile sayfa tablolarının (pagetables) kapladığı sayfa sayısı toplanır.
  2. Kurban Seçim Mantığı: Çekirdek en az sayıda süreci sonlandırarak en yüksek miktarda fiziksel belleği serbest bırakmayı hedefler. Bu nedenle sistemde en çok RAM kullanan süreç otomatik olarak en yüksek puana ulaşır.
  3. Kök Süreçler ve İmtiyaz: root kullanıcısına ait süreçler eskiden puan indirimi alırdı, ancak modern çekirdeklerde bu kural kaldırılmıştır. Yalnızca PID 1 (init/systemd) ve çekirdek iş parçacıkları (kthreads) OOM hedefi olmaktan muaftır.

Veritabanı felaketinin temel nedeni bu puanlama hiyerarşisinde ortaya çıkar: 64 GB RAM'li bir sunucuda bellek sızdıran küçük bir worker süreci 4 GB RAM tüketip sistemi tüketme noktasına getirdiğinde, 40 GB buffer pool kullanan PostgreSQL MVCC süreci çok daha yüksek bir RSS puanına sahip olduğu için kurban seçilir.

3. oom_score_adj ile Kritik Servisleri Koruma

Linux çekirdeği, süreçlerin OOM puanını dinamik olarak ayarlamak için iki arayüz sunar:

  • /proc/[pid]/oom_score: Çekirdeğin süreç için hesapladığı güncel puan (0 ile 1000 arası).
  • /proc/[pid]/oom_score_adj: Kullanıcının veya yöneticinin dışarıdan müdahale edebildiği puan düzeltme değeri (-1000 ile +1000 arası).

Nihai OOM puanı şu mantıkla hesaplanır:

$$\text{Final Score} = \text{oom_score} + \text{oom_score_adj}$$

Eğer oom_score_adj değeri -1000 yapılırsa, süreç OOM Killer listesinden tamamen çıkarılır ve çekirdek tarafından kurban seçilme riski sıfırlanır.

Systemd Servislerinde oom_score_adj Yapılandırması

PostgreSQL, MySQL veya Redis gibi kritik veritabanlarını OOM Killer saldırılarına karşı korumak için ilgili systemd servis dosyasına (/etc/systemd/system/postgresql.service.d/override.conf) şu direktif eklenmelidir:

INI
[Service]
OOMScoreAdjust=-1000

Buna karşılık, bellek sızdırma potansiyeli yüksek olan arka plan kuyruk işçileri (Celery, Sidekiq veya node worker süreçleri) için puan artırılabilir:

INI
[Service]
OOMScoreAdjust=500

Bu sayede bellek daralması yaşandığında çekirdek doğrudan riskli kuyruk işçilerini kurban seçecek, ana veritabanı motoruna dokunmayacaktır.

4. Gerçek Bir Postmortem: PostgreSQL Neden Öldü?

Üretim ortamında yaşanmış tipik bir vaka üzerinden süreci inceleyelim.

Sistem Özellikleri:

  • 32 GB RAM, 4 GB Takas Alanı
  • PostgreSQL 16: shared_buffers = 8GB, ortalama RSS 10 GB
  • 12 adet Python veri analizi iş parçacığı

Olay Sırası:

  1. Saat 03:14'te bir veri analizi görevi pandas kütüphanesinde hatalı bir birleştirme (merge) yaparak döngü içinde 18 GB bellek tahsis etmeye başladı.
  2. RAM doldu, çekirdek takas alanını kullanmaya başladı ve takas alanı da tükendi.
  3. Çekirdek kswapd üzerinden sayfa temizlemeye çalıştı ancak kirli sayfalar disk I/O darboğazına takıldı.
  4. OOM Killer devreye girdi.
  5. Python süreci o anda 12 GB RSS tüketiyordu (puan: ~375).
  6. PostgreSQL ana süreci ve ona bağlı worker süreçleri toplamda 14 GB paylaşımlı ve yerel bellek tutuyordu (puan: ~437).
  7. OOM Killer en yüksek puana sahip olan PostgreSQL ana sürecine SIGKILL gönderdi. Veritabanı aniden kapandı.

Sistem loglarında görülen kurban kararı:

TEXT
[ 4128.591024] Out of memory: Kill process 1208 (postgres) score 437 or sacrifice child
[ 4128.591845] Killed process 1208 (postgres) total-vm:14892012kB, anon-rss:2104104kB, file-rss:10248100kB

Çözüm: PostgreSQL için OOMScoreAdjust=-900 atanırken, veri analizi servisleri ayrı bir cgroups limitine bağlanarak ana bellek havuzundan izole edildi.

5. Üretim Ortamı İçin Kontrol ve İyileştirme Reçetesi

Sisteminizin OOM direncini artırmak için şu kontrol adımlarını izleyin.

Mevcut süreçlerin OOM puanlarını sıralamak için şu komutu kullanın:

Bash
printf "%-10s %-10s %-25s\n" "PID" "PUAN" "KOMUT"
for pid in /proc/[0-9]*; do
    p=$(basename "$pid")
    if [ -f "$pid/oom_score" ]; then
        score=$(cat "$pid/oom_score" 2>/dev/null)
        cmd=$(tr -d '\0' < "$pid/cmdline" 2>/dev/null | cut -c1-25)
        [ -n "$score" ] && [ "$score" -gt 0 ] && printf "%-10s %-10s %-25s\n" "$p" "$score" "$cmd"
    fi
done | sort -k2 -rn | head -n 10

Veritabanı sunucularında beklenmedik aşırı taahhütleri önlemek için sysctl.conf içine şu değerleri ekleyin:

Bash
# Bellek aşırı taahhüdünü sınırla
vm.overcommit_memory = 2
vm.overcommit_ratio = 80

# Panik durumunda OOM tetiklenirse sistemi yeniden başlatma süresi (opsiyonel)
vm.panic_on_oom = 0

Bu yapılandırma sayesinde bellek tüketimi kontrol altına alınır, kritik süreçlerin oom_score_adj ile korunmasıyla üretim ortamı krizleri önlenmiş olur.

Yazıyı Değerlendir

0 tepki

Fikirlerinizi tek tıkla paylaşarak geri bildirim bırakın.

Bu teknik notu çevrenizle paylaşın

Ali Purtaş

@alipurtas • Hey, This is Ali!

İletişime Geç

Kendi halinde yazılım geliştiren bir öğrenci. Sistemler kuruyor, deniyor, bozuyor ve öğrendiği gerçek çözümleri burada belgeliyor.

Konu Kümesi & Önerilen Yazılar

İç Bağlantılı Mimari
Yorumlar yükleniyor...