---
title: 'Mantıksal Birim Yönetimi'
source: 'https://academia.sh/tr/kurslar/sistem-yonetimi/mantiksal-birim-yonetimi'
course: 'Sistem Yönetimi'
language: tr
updated: '2026-08-17T18:10:06+00:00'
license: 'CC BY-SA 4.0'
---

# Mantıksal Birim Yönetimi

Büyütme iki adımdır ve yirmi bir okumanın yedisi zincirin yanlış halkasını gösteriyor; 512 blok ayrılmış bir anlık görüntü 413. saniyede doluyor ve altmış saniyede bir bakan izleme o ana kadar 256 blokta duran bir sayı görüyor.

Önceki dersin bütün ölçümleri bir bölümün sınırlarının sabit olduğunu varsaydı: aygıta
çizilmiş bir aralık ve içine kurulmuş bir dosya sistemi. Bu varsayım altında dolan bir bölüm
için yapılabilecek tek şey silmekti; komşu bölümdeki boş yer erişilemez kalıyordu.

Bu ders o sabitliği kaldıran katmanı ölçer. Katman, bölümleri bir havuza toplar ve havuzdan
istenen boyutta parçalar keser; kesilen parça çalışırken büyütülebilir ve bir anının kopyası
tutulabilir. Kazanç gerçektir ve iki yeni yanlış tanı kaynağı getirir: zincirin hangi
halkasının büyüdüğü ve bir anın kopyasının ne kadar dayanacağı.

## Üç Katman ve Aralarındaki Birim

Katman üç nesneden oluşur. **Fiziksel birim (physical volume)**, havuza katılmış bir blok
aygıtı ya da bölümdür. **Birim havuzu (volume group)**, bir ya da daha çok fiziksel birimin
tek bir alan olarak sunulmasıdır. **Mantıksal birim (logical volume)**, havuzdan kesilmiş ve
üzerine dosya sistemi kurulabilen parçadır.

Kesme işlemi bayt bayt değil, sabit boyutlu **ayırma birimleriyle (extent)** yapılır. Havuz
oluşturulurken bir ayırma biriminin boyu belirlenir; her mantıksal birim tam sayıda ayırma
birimi tutar ve büyütme de bu birimlerin katlarıyla olur. Bunun iki sonucu vardır: istenen
boyut yukarı yuvarlanır ve bir mantıksal birim, havuzdaki fiziksel birimlerin **birden
çoğuna** yayılabilir.

Yayılma katmanın hem gücü hem sessiz riskidir. Bir mantıksal birim iki fiziksel birime
yayılmışsa, ikisinden birinin arızalanması birimin tamamını kullanılamaz kılar; havuza aygıt
eklemek dayanıklılığı artırmaz, yalnız kapasiteyi artırır. Katmanın kendisi bir yedeklilik
düzeni değildir ve öyle olduğu varsayıldığında tanı en pahalı biçimde yanılır.

Üç katman üç araçla okunur: `pvs` fiziksel birimleri, `vgs` havuzları, `lvs` mantıksal
birimleri listeler. Aşağıdaki döküm `lvs` çıktısının biçimini gösteren bir **örnek dökümdür**;
çalıştırılmamıştır ve bu derste hiçbir sayı iddiası buradan gelmez.

```text
LV        VG      Attr       LSize   Pool Origin Data%  Meta%
veri      havuz-1 -wi-ao----  32.00g
veri-anlik havuz-1 swi-a-s---  2.00g       veri   41.30
gunluk    havuz-1 -wi-ao----   8.00g
```

İkinci satırdaki `Origin` ve `Data%` sütunları bu dersin ikinci ölçümünün konusudur: bir
anlık görüntünün kaynağı ve doluluğu.

## Büyütme İki Adımdır

Bir mantıksal birimi büyütmek dosya sistemini büyütmez. Katman birime yeni ayırma birimleri
ekler; dosya sistemi ise kendi defterlerini eski sınıra göre tutmaya devam eder ve yeni alanı
görmez. İki adım ayrıdır, sıraları bağlayıcıdır ve aralarındaki boşlukta araçlar farklı
sayılar söyler.

- **DP26** — Zincir yedi aşamadan geçer: başlangıç, havuza fiziksel birim eklenmesi, mantıksal
  birimin büyütülmesi, dosya sisteminin büyütülmesi, yazmanın sürmesi, anlık görüntünün
  ayrılması ve anlık görüntünün düşmesi.
- **DP27** — Bütün sayılar bloktur; ayırma birimi bu ölçümde blok katıdır ve yuvarlama
  sayılmaz.
- **DP28** — Sorulan tanı tektir: **şu anda kaç blok daha yazılabilir.** Kâhin, dosya
  sisteminin kapasitesinden kullanılanın düşülmesidir.

```python
"""Buyutme iki adimdir; her arac zincirin farkli bir halkasini gosterir."""
ASAMA = (
    ("0 baslangic",              0, 4096, 4096, 3800),
    ("1 fiziksel birim eklendi", 8192, 4096, 4096, 3800),
    ("2 mantiksal birim buyudu", 4096, 8192, 4096, 3800),
    ("3 dosya sistemi buyudu",   4096, 8192, 8192, 3800),
    ("4 yazma surdu",            4096, 8192, 8192, 6000),
    ("5 anlik goruntu ayrildi",  3584, 8192, 8192, 6000),
    ("6 anlik goruntu dustu",    4096, 8192, 8192, 6000),
)


def okumalar(a):
    """Soru: su anda kac blok daha yazilabilir."""
    _, vg_bos, lv, fs, kullanilan = a
    return {"kahin": fs - kullanilan,
            "vgs": vg_bos + lv - kullanilan,     # havuzdaki bos yer yazilabilir sanilir
            "lvs": lv - kullanilan,              # birim boyutu yazilabilir sanilir
            "df": fs - kullanilan}


print("asama                      vg bos    lv    fs  kullanilan  kahin"
      "    vgs    lvs     df")
for a in ASAMA:
    o = okumalar(a)
    print(f"{a[0]:24s} {a[1]:7d} {a[2]:5d} {a[3]:5d} {a[4]:11d}"
          f" {o['kahin']:6d} {o['vgs']:6d} {o['lvs']:6d} {o['df']:6d}")
print()
print("arac  dogru okuma  yanlis okuma")
toplam = 0
for arac in ("vgs", "lvs", "df"):
    y = sum(okumalar(a)[arac] != okumalar(a)["kahin"] for a in ASAMA)
    toplam += y
    print(f"  {arac:3s} {len(ASAMA) - y:11d}  {y:12d}")
print("yanlis tani:", toplam, "/", len(ASAMA) * 3)
```

```
asama                      vg bos    lv    fs  kullanilan  kahin    vgs    lvs     df
0 baslangic                    0  4096  4096        3800    296    296    296    296
1 fiziksel birim eklendi    8192  4096  4096        3800    296   8488    296    296
2 mantiksal birim buyudu    4096  8192  4096        3800    296   8488   4392    296
3 dosya sistemi buyudu      4096  8192  8192        3800   4392   8488   4392   4392
4 yazma surdu               4096  8192  8192        6000   2192   6288   2192   2192
5 anlik goruntu ayrildi     3584  8192  8192        6000   2192   5776   2192   2192
6 anlik goruntu dustu       4096  8192  8192        6000   2192   6288   2192   2192

arac  dogru okuma  yanlis okuma
  vgs           1             6
  lvs           6             1
  df            7             0
yanlis tani: 7 / 21
```

Üç sayı yan yana. **Kâhin:** ikinci aşamada yazılabilir alan **296 bloktur** — mantıksal
birim ikiye katlanmış olmasına rağmen. **Araç çıktısı:** aynı aşamada `lvs` 4392, `vgs` 8488
blok gösteriyor. **Yanlış tanı:** yirmi bir okumanın **yedisi** yanlış.

Tablo, katmanın getirdiği asıl güçlüğü gösteriyor: aynı soruya üç ayrı katman cevap veriyor ve
yalnız en üstteki doğru. Havuzun boş yeri hiçbir zaman doğrudan yazılabilir alan değildir;
mantıksal birimin boyutu, dosya sistemi büyütülmediği sürece yazılabilir alan değildir.
İkinci aşamada duran bir işlem — büyütme komutu verilmiş, dosya sistemi büyütülmemiş — sistemi
"yer açıldı" sanılan ama açılmamış bir durumda bırakır ve dolan disk arızası **büyütme
yapıldıktan sonra** ortaya çıkar.

Sıralamanın kendisi de bağlayıcıdır. Büyütmede önce mantıksal birim, sonra dosya sistemi
büyütülür; küçültmede sıra terstir ve tersine çevrilmediğinde dosya sistemi kendi sınırının
dışında kalan bloklara işaret etmeye devam eder. Bu iki cümle arasındaki fark, geri
dönülemeyen bir veri kaybıdır.

## Anlık Görüntü Nasıl Dolar

**Anlık görüntü (snapshot)**, bir mantıksal birimin belirli bir andaki hâlini okunabilir
tutan ikinci bir birimdir. Kopyalama işlemin başında yapılmaz; kaynaktaki bir blok ilk kez
üzerine yazıldığında **eski hâli** anlık görüntünün alanına taşınır. Bu yüzden anlık
görüntünün tükettiği yer, kaynağın boyutuyla değil, kaynakta **değişen blok sayısıyla**
orantılıdır.

Ayrılan alan bittiğinde anlık görüntü geçersizleşir ve düşer. Kaynak birim etkilenmez ve
çalışmaya devam eder; kaybolan şey, o anlık görüntüden alınmakta olan yedeğin geçerliliğidir.

- **DP29** — Kaynak mantıksal birim **4096 blok**, anlık görüntüye ayrılan alan **512
  bloktur**. Olağan yük her saniye **sıcak kümedeki 256 bloktan** ikisini yeniler.
- **DP30** — 400. ve 430. saniyeler arasında yedek görevi geniş bir tarama yapar ve her
  saniye **20 bloğa** dokunur; dokunulan bloklar birimin tamamından çekilir.
- **DP31** — İzleme aracı doluluğu `aralik` saniyede bir okur; eşiği aşan ilk okuma uyarıdır.
  Uyarı dolma anından **sonra** geliyorsa ya da hiç gelmiyorsa tanı yanlış sayılır.

```python
"""Anlik goruntu yazarken kopyalar; ayrilan yer dolunca gecersizlesir."""
TOHUM = 20260218
DONEM = 600
BIRIM_BLOK = 4096        # kaynak mantiksal birimin blok sayisi
AYRILAN = 512            # anlik goruntuye ayrilan blok
SICAK = 256              # olagan yukun dokundugu blok kumesi
PATLAMA = (400, 430)     # yedek gorevinin genis tarama yaptigi aralik


def uretec(tohum):
    d = tohum

    def sonraki(n):
        nonlocal d
        d = (d * 1103515245 + 12345) % 2147483648
        return d % n
    return sonraki


def kopyalanan(tohum=TOHUM):
    """Kahin: her saniye sonunda anlik goruntunun tuttugu blok sayisi."""
    r = uretec(tohum)
    goruldu, egri = set(), []
    for t in range(DONEM):
        if PATLAMA[0] <= t < PATLAMA[1]:
            for _ in range(20):
                goruldu.add(r(BIRIM_BLOK))
        else:
            for _ in range(2):
                goruldu.add(r(SICAK))
        egri.append(min(len(goruldu), AYRILAN))
    return egri


def dolma_ani(egri):
    for t, v in enumerate(egri):
        if v >= AYRILAN:
            return t
    return None


def tani(egri, aralik, esik):
    """Arac `aralik` saniyede bir bakar; esigi asan okuma uyari sayilir."""
    dolar = dolma_ani(egri)
    bakislar = [t for t in range(0, DONEM, aralik) if t < dolar]
    uyari = next((t for t in range(0, DONEM, aralik)
                  if egri[t] / AYRILAN >= esik), None)
    zamaninda = uyari is not None and uyari < dolar
    return {"son_okuma": egri[bakislar[-1]] if bakislar else 0,
            "uyari": uyari, "yanlis": not zamaninda}


E = kopyalanan()
D = dolma_ani(E)
print("kahin: anlik goruntu", D, "saniyede doluyor |", AYRILAN, "blok ayrildi")
print("egri:", [(t, E[t]) for t in (0, 60, 180, 300, 360, 400, 410, 420)])
print()
print("aralik  esik  dolmadan onceki son okuma  ilk uyari  yanlis tani")
yanlis = 0
for aralik in (10, 30, 60, 120, 300):
    for esik in (0.70, 0.90):
        s = tani(E, aralik, esik)
        yanlis += s["yanlis"]
        print(f"{aralik:6d}  {esik:.2f}  {s['son_okuma']:25d}"
              f"  {str(s['uyari']):>9s}  {str(s['yanlis']):>11s}")
print("yanlis tani:", yanlis, "/ 10")
print()
for tohum in (TOHUM, 20260219):
    e2 = kopyalanan(tohum)
    y = sum(tani(e2, a, s)["yanlis"] for a in (10, 30, 60, 120, 300)
            for s in (0.70, 0.90))
    print(f"tohum {tohum}: dolma ani {dolma_ani(e2)}  t=360 okumasi {e2[360]}"
          f"  yanlis tani {y} / 10")
```

```
kahin: anlik goruntu 413 saniyede doluyor | 512 blok ayrildi
egri: [(0, 2), (60, 122), (180, 256), (300, 256), (360, 256), (400, 276), (410, 466), (420, 512)]

aralik  esik  dolmadan onceki son okuma  ilk uyari  yanlis tani
    10  0.70                        466        410        False
    10  0.90                        466        410        False
    30  0.70                        256        420         True
    30  0.90                        256        420         True
    60  0.70                        256        420         True
    60  0.90                        256        420         True
   120  0.70                        256        480         True
   120  0.90                        256        480         True
   300  0.70                        256       None         True
   300  0.90                        256       None         True
yanlis tani: 8 / 10

tohum 20260218: dolma ani 413  t=360 okumasi 256  yanlis tani 8 / 10
tohum 20260219: dolma ani 413  t=360 okumasi 256  yanlis tani 8 / 10
```

Üç sayı yan yana. **Kâhin:** anlık görüntü **413. saniyede** doluyor. **Araç çıktısı:** altmış
saniyede bir bakan izleme, dolmadan önceki son okumasında **256 blok** görüyor — ayrılan alanın
tam yarısı. **Yanlış tanı:** on örnekleme ve eşik birleşiminin **sekizi** uyarıyı zamanında
üretemiyor.

Eğri bunun nedenini gösteriyor. İlk üç yüz saniyede doluluk 256'da duruyor, çünkü olağan yük
hep aynı sıcak kümeye dokunuyor ve o küme bir kez kopyalandıktan sonra yeni kopya
gerektirmiyor. Sayı üç yüz saniye boyunca kıpırdamıyor ve bakan kişiye **kararlı** görünüyor.
Sonra yedek görevi geniş tarama yapıyor ve doluluk on üç saniyede 256'dan 512'ye çıkıyor.
Eşiği düşürmek bu sorunu çözmüyor: tabloda 0,70 ile 0,90 eşikleri aynı sonucu veriyor, çünkü
sorun eşiğin yüksekliği değil, **iki bakış arasındaki mesafedir**. Süreç yönetimi konusundaki
örnekleme ölçümüyle aynı yapı burada da işliyor.

İkinci tohumda dolma anı da yanlış tanı sayısı da değişmiyor. Bunun nedeni yapısaldır: sıcak
küme her tohum altında doyar ve patlamanın genişliği tohumdan bağımsızdır. Sonuç kurguya değil,
yazarken kopyalamanın kendi davranışına bağlı.

Buradan çıkan tasarım kuralı şudur: anlık görüntüye ayrılacak alan, kaynağın boyutuna göre
değil, anlık görüntünün **yaşayacağı süre boyunca değişecek blok sayısına** göre seçilir. Uzun
süre tutulan bir anlık görüntü, kaynağın tamamı kadar yer isteyebilir.

Uygulamada üç önlem bu ölçümden doğrudan çıkıyor. Birincisi, anlık görüntünün **ömrünü
kısaltmaktır**: yedek alındıktan hemen sonra kaldırılan bir görüntü, hiçbir eşik aşılmadan
biter. İkincisi, doluluğu **olayla birlikte** okumaktır — yedek görevi başlarken ve biterken
alınan iki okuma, altmış saniyelik düzenli örneklemeden daha çok şey söyler. Üçüncüsü, anlık
görüntünün **çalışırken büyütülebilmesidir**: ayrılan alan tükenmeden önce havuzdan yeni
ayırma birimleri eklenebilir, ama tükendikten sonra eklenemez. Üçünün ortak yanı, kararı
örnekleme aralığına bırakmamaktır.

Bir de yanlış anlaşılan bir nokta vardır. Anlık görüntü bir yedek değildir; kaynağıyla aynı
fiziksel birimlerde durur ve kaynağın altındaki aygıt arızalandığında ikisi birlikte kaybolur.
Sağladığı şey **tutarlı bir okuma anıdır** — yedeği alan sürecin, veri değişmeye devam ederken
sabit bir görüntüden okumasını mümkün kılar. Yedeklemenin kendisi bu kursun dışındadır ve
başka bir yerde ölçülmüştür.

## Küçültme ve Silme

Bu katmanın komutları arasında geri alınamaz olanlar açık uçlu değildir; adları bellidir. Bir
mantıksal birimi silen komut, o birimin ayırma birimlerini havuza geri verir ve içindeki
dosya sistemi bir daha kurulamaz. Bir mantıksal birimi küçülten komut, dosya sistemi önceden
küçültülmemişse dosya sisteminin son bloklarını havuza geri verir; dosya sistemi o blokları
kullanıyorsa veri kaybı sessiz ve kesin olur. Bu ders o iki komutu **çalıştırılabilir tam
biçimde vermez**.

Güvenli sınama yolu üç adımdır. Birincisi **kuru çalışmadur**: birim yönetimi araçları,
değişikliği uygulamadan sonucu bildiren bir seçenek taşır ve o seçeneğin çıktısı okunmadan
gerçek komut verilmez. İkincisi **anlık görüntüdür**: değişiklikten önce alınan bir anlık
görüntü, kaynak bozulduğunda geri dönüşü mümkün kılar — yeter ki ayrılan alanı dolmadan
kullanılsın. Üçüncüsü **ayrı bir havuzda denemedir**: geri döngü aygıtlarından kurulmuş küçük
bir havuz, bütün zinciri gerçek veriden uzakta çalıştırmayı sağlar.

## Özet

- Katman üç nesneden oluşur: havuza katılmış fiziksel birimler, onları tek alan olarak sunan
  birim havuzu ve havuzdan sabit boyutlu ayırma birimleriyle kesilen mantıksal birimler.
  Havuza aygıt eklemek kapasiteyi artırır, dayanıklılığı artırmaz.
- Büyütme iki adımdır ve araçlar arasındaki boşluk ölçülebilir: yedi aşamada yirmi bir okumanın
  yedisi yanlış; `vgs` altı kez, `lvs` bir kez yanılıyor, `df` hiç yanılmıyor.
- Mantıksal birim büyütülüp dosya sistemi büyütülmediğinde yazılabilir alan 296 blokta kalıyor
  ama `lvs` 4392, `vgs` 8488 gösteriyor.
- Anlık görüntü kaynağın boyutuyla değil, değişen blok sayısıyla dolar: 512 bloklu bir görüntü
  413. saniyede doluyor ve altmış saniyede bir bakan izleme o ana kadar 256 blokta duran bir
  sayı görüyor. On örnekleme ve eşik birleşiminin sekizi uyarıyı zamanında üretemiyor.
- Eşiği düşürmek bu kaçırmayı düzeltmiyor; ayıran şey iki bakış arasındaki mesafedir. Birim
  silme ve küçültme komutları geri alınamaz ve bu ders onları tam biçimde vermez.

## Sonraki Adım

Bu ders depolamayı yalnız veri tutan bir katman olarak ele aldı. Oysa aynı blok aygıtının bir
bölümü hiç dosya tutmaz: bellek baskısı altında sayfaların atıldığı alandır. Sonraki ders o
alanı ölçer ve bir soruyu yanıtlar — takas kullanımı hangi göstergede ne kadar geç görünür.
Ölçüm iki yönlü çıkacak: bazı göstergeler baskıyı geç haber veriyor, bazıları baskı geçtikten
sonra da haber vermeye devam ediyor.
