IAli
Tüm Yazılar
PID ve Mount İsim Alanları ile Yalıtılmış Süreç Ortamı Tasarımı

PID ve Mount İsim Alanları ile Yalıtılmış Süreç Ortamı Tasarımı

C dilinde clone ve unshare sistem çağrılarıyla Docker olmadan sıfırdan mini konteyner inşası, pivot_root kullanımı ve PID 1 zombi süreç temizliği mimarisi.

Docker, Podman veya containerd gibi modern konteyner motorları sihirli sanal makineler değildir. Konteyner kavramı, Linux çekirdeğinin sunduğu isim alanları (namespaces) ve kontrol grupları (cgroups) soyutlamalarının bir araya getirilmesinden ibarettir.

Reddit r/systems ve r/kernel topluluklarında sıkça sorulan "Kendi mini konteynerimizi sıfırdan C ile nasıl yazarız?" sorusu, Linux süreç izolasyonunun kalbine uzanır. Bu rehberde PID ve Mount isim alanlarını kullanarak, harici hiçbir bağımlılık olmadan saf sistem çağrılarıyla izole bir çalışma ortamının nasıl inşa edildiğini adım adım inceliyoruz.

TEXT
PID İsim Alanı Hiyerarşisi ve Çift Kimlik Modeli:

Ana Sistem (Root PID İsim Alanı):
+───────────────────────────────────────────────────────────────+
| PID 1 (systemd) ──► PID 1420 (mini-container) ──► PID 1421 (sh) |
+───────────────────────────────────────────────────────────────+
                              │                            │
                              ▼ Eşleme                     ▼ Eşleme
İzole Konteyner (Çocuk PID İsim Alanı):
                              +────────────────────────────+
                              | PID 1 (mini-container)     |
                              |   └──► PID 2 (sh)          |
                              +────────────────────────────+

1. Linux İsim Alanları ve PID İzolasyonu

Bir süreç fork() çağrısı yaptığında çocuk süreç ebeveynin tüm isim alanlarını miras alır. Ancak Linux 2.6.24 ile tanıtılan CLONE_NEWPID bayrağı kullanıldığında, çekirdek çocuk süreç için yepyeni bir süreç kimliği (PID) tablosu tahsis eder:

  1. Yeni isim alanında ilk doğan çocuk süreç içeride PID 1 numarasını alır.
  2. Ana sistemde (root namespace) ise bu sürecin normal bir PID numarası (örneğin 1420) olmaya devam eder.
  3. İçerideki süreç ps veya kill komutu çalıştırdığında sadece kendi ağacındaki süreçleri görebilir, dışarıdaki ana işletim sistemi süreçlerine erişemez.

PID 1 Olmanın Ağır Sorumlulukları

Bir süreç PID 1 olduğunda iki kritik sorumluluğu üstlenir:

  • Zombi Süreç Temizliği (Reaping): İçerideki çocuk süreçler öldüğünde, onları yaratan ara süreçler bekleme (wait()) yapmadan çıkarsa bu ölü süreçler zombi (defunct) olarak PID 1'e evlatlık verilir (orphan adoption). PID 1 sürekli waitpid(-1, ...) döngüsü çalıştırarak bu zombileri bellekten temizlemek zorundadır. Aksi halde süreç tablosu dolar.
  • Sinyal Yönetimi: Linux çekirdeği PID 1 sürecine varsayılan sinyal işleyicilerini (default signal handlers) otomatik olarak uygulamaz. Eğer SIGTERM veya SIGINT için açıkça bir sinyal işleyici yazmazsanız süreç bu sinyalleri görmezden gelir.

2. Mount İsim Alanı ve pivot_root Güvenliği

Sadece PID isim alanı oluşturmak yeterli değildir. Süreç içeride /proc dosya sistemini okuduğunda hala ana makinenin donanım ve süreç bilgilerini görür. Sürecin dosya sistemini de tamamen izole etmek gerekir.

Geleneksel chroot() sistem çağrısı tam bir güvenlik sağlamaz. Root yetkisine sahip bir süreç chroot() zindanından göreceli dosya yolları (..) ve yeni dosya tanımlayıcıları ile kolayca kaçabilir.

Bunun yerine üretim seviyesinde pivot_root() kullanılır:

  1. unshare(CLONE_NEWNS) çağrısı ile mount isim alanı ayrılır.
  2. mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, NULL) ile tüm bağlama noktaları özel (private) yapılır. Böylece içerideki mount işlemleri ana sisteme sızmaz.
  3. pivot_root(new_root, put_old) çağrılır. Mevcut kök dizin (/) geçici bir dizine taşınır (old_root), hazırlanan yeni rootfs dizini ise sistemin gerçek kök dizini haline gelir.
  4. umount2("/old_root", MNT_DETACH) ile eski ana makine kök dizini bellekten sökülür. Artık sürecin ana dosya sistemine geri dönmesi mümkün değildir.
  5. Son olarak /proc dizinine yeni, izole procfs bağlanır: mount("proc", "/proc", "proc", 0, NULL).

3. C ile Sıfırdan Mini Konteyner İmplementasyonu

Aşağıdaki C programı, Docker olmadan izole bir ortam ayağa kaldırır. Cgroups v2 Tek Hiyerarşi ile birleştirildiğinde tam bir konteyner çalışma zamanı oluşturur.

C
#define _GNU_SOURCE
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/mount.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <signal.h>

#define STACK_SIZE (1024 * 1024)
static char child_stack[STACK_SIZE];

static int pivot_root_syscall(const char *new_root, const char *put_old) {
    return syscall(SYS_pivot_root, new_root, put_old);
}

static int container_child(void *arg) {
    char *rootfs = (char *)arg;
    char old_root[512];
    snprintf(old_root, sizeof(old_root), "%s/old_root", rootfs);

    /* 1. Mount yayilimini engelle */
    if (mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, NULL) == -1) {
        perror("mount private");
        return 1;
    }

    /* 2. Yeni rootfs alanini bind mount yap */
    if (mount(rootfs, rootfs, "bind", MS_BIND | MS_REC, NULL) == -1) {
        perror("mount bind rootfs");
        return 1;
    }

    /* 3. pivot_root ile kok dizini degistir */
    if (pivot_root_syscall(rootfs, old_root) == -1) {
        perror("pivot_root");
        return 1;
    }

    if (chdir("/") == -1) {
        perror("chdir");
        return 1;
    }

    /* 4. Eski koku sok */
    if (umount2("/old_root", MNT_DETACH) == -1) {
        perror("umount old_root");
        return 1;
    }

    /* 5. Izole /proc bagla */
    if (mount("proc", "/proc", "proc", 0, NULL) == -1) {
        perror("mount proc");
        return 1;
    }

    printf("[Konteyner] Izole PID 1 baslatildi. Gercek PID: %d\n", getpid());

    /* 6. Bir kabuk baslat */
    char *argv[] = {"/bin/sh", NULL};
    char *envp[] = {"PATH=/bin:/usr/bin:/sbin", NULL};
    execve(argv[0], argv, envp);

    perror("execve");
    return 1;
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "Kullanim: %s <rootfs_yolu>\n", argv[0]);
        return 1;
    }

    printf("[Ana Makine] Mini konteyner hazirlaniyor...\n");

    /* CLONE_NEWPID ve CLONE_NEWNS ile cocuk surec klonla */
    int flags = CLONE_NEWPID | CLONE_NEWNS | SIGCHLD;
    pid_t pid = clone(container_child, child_stack + STACK_SIZE, flags, argv[1]);

    if (pid == -1) {
        perror("clone");
        return 1;
    }

    /* Zombi temizligi ve cocuk surecin bitmesini bekle */
    waitpid(pid, NULL, 0);
    printf("[Ana Makine] Konteyner kapandi.\n");
    return 0;
}

4. Test Ortamının Hazırlanması ve Çalıştırma

Bu kodu test etmek için basit bir rootfs (örneğin Alpine Linux mini rootfs) gerekir:

Bash
mkdir -p /tmp/myrootfs/old_root
cd /tmp/myrootfs
curl -sL https://dl-cdn.alpinelinux.org/alpine/v3.20/releases/x86_64/alpine-minirootfs-3.20.0-x86_64.tar.gz | tar -xz
mkdir -p /tmp/myrootfs/old_root

Programı derleyin ve root yetkisiyle çalıştırın:

Bash
gcc -Wall -O2 mini_container.c -o mini_container
sudo ./mini_container /tmp/myrootfs

Konteyner içine girdiğinizde ps aux komutunu çalıştırın:

TEXT
PID   USER     TIME  COMMAND
    1 root      0:00 /bin/sh
    2 root      0:00 ps aux

Ana makinedeki yüzlerce süreç yerine yalnızca kabuk sürecinizi (PID 1) ve ps komutunu görürsünüz. Bu süreç Linux OOM Killer tarafından kurban seçilse dahi tüm isim alanı güvenle sonlandırılır.

5. Üretim İçin Güvenlik Uyarıları

Sıfırdan isim alanı tasarlarken şu güvenlik kurallarına dikkat edilmelidir:

  1. User Namespaces Olmadan Root Tehlikelidir: Yalnızca PID ve Mount izole etmek, içerideki root kullanıcısının ana makinedeki root ayrıcalıklarına sahip olmasını engellemez. Tam yalıtım için CLONE_NEWUSER ile UID/GID eşlemesi yapılmalıdır.
  2. Mount Bayrakları Sertleştirilmelidir: Yeni bağlanan /proc, /sys ve /dev dizinleri MS_NODEV | MS_NOSUID | MS_NOEXEC bayraklarıyla bağlanarak cihaz dosyası yaratma ve yetki yükseltme saldırıları önlenmelidir.
  3. Zombi Süreçleri Dinleyin: Çok süreçli uygulamalarda PID 1 görevi gören sürecin SIGCHLD sinyalini yakalayıp waitpid() ile temizlik yapması zorunludur.

Bu mimari temeller, Docker ve Kubernetes arkasındaki soyutlama perdesini kaldırarak Linux çekirdeğinin süreç izolasyonunu somut bir gerçekliğe dönüştürür.

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...