20.4. RAID1 - spiegelen
Terug | Hoofdstuk 20. GEOM: Modulair schijftransformatie raamwerk | Volgende

## 20.4. RAID1 - spiegelen

RAID1, of spiegelen, is de techniek om dezelfde gegevens naar meer dan één schijf te schrijven. Spiegels worden normaliter gebruikt om tegen gegevensverlies te beschermen indien een schijf kapot gaat. Elke schijf in een spiegel bevat een identieke kopie van de gegevens. Wanneer een individuele schijf het begeeft, blijft de spiegel functioneren, en levert het gegevens van de schijven die nog wel functioneren. De computer blijft draaien en de beheerder heeft tijd om de kapotte schijf te vervangen zonder onderbreking voor de gebruikers.

Twee veelvoorkomende situaties worden in deze voorbeelden getoond. Het eerste is het maken van een spiegel van twee nieuwe schijven en het als vervanging voor een bestaande enkele schijf te gebruiken. Het tweede voorbeeld maakt een spiegel op een enkele nieuwe schijf aan, kopieert de gegevens van de oude schijf er naar toe, en plaatst daarna de oude schijf in de spiegel. Hoewel deze procedure iets moeilijker is, is er maar één nieuwe schijf nodig.

Traditioneel zijn de twee schijven in een spiegel van hetzelfde model en hebben ze dezelfde capaciteit, maar gmirror(8) verplicht dit niet. Spiegels die met ongelijke schijven zijn gemaakt zullen de capaciteit van de kleinste schijf in de spiegel aannemen. Extra schijfruimte op grotere schijven zal ongebruikt blijven. Schijven die later in de spiegel worden geplaatst moeten tenminste evenveel capaciteit hebben als de kleinste schijf die reeds in de spiegel zit.

### Waarschuwing:

De procedures voor het spiegelen die hier getoond worden zijn niet-destructief, maar maak zoals bij elke grote schijfoperatie eerst een volledige back-up.

### 20.4.1. Kwesties met meta-gegevens

Veel schijfsystemen slaan meta-gegevens op aan het einde van elke schijf. Oude meta-gegevens dienen gewist te worden voordat de schijf herbruikt wordt voor een spiegel. De meeste problemen worden veroorzaakt door twee soorten van achtergebleven meta-gegevens: GPT-partitietabellen en oude meta-gegevens van gmirror(8) van een vorige spiegel.

GPT-meta-gegevens kunnen gewist worden met gpart(8). Dit voorbeeld wist zowel de primaire als de back-up GPT-partitietabellen van schijf `ada8`:

    # gpart destroy -F ada8

gmirror(8) kan in één stap een schijf uit een actieve spiegel halen en de meta-gegevens wissen. Hier wordt de voorbeeldschijf `ada8` uit de actieve spiegel `gm4` gehaald:

    # gmirror remove gm4 ada8

Gebruik, als de spiegel niet draait maar er nog oude meta-gegevens van de spiegel op de schijf staan, `gmirror clear` om deze te verwijderen:

    # gmirror clear ada8

gmirror(8) slaat één blok aan meta-gegevens aan het einde van de schijf op. Omdat GPT-partitieschema's ook meta-gegevens aan het einde van de schijf opslaan, wordt het spiegelen van volledige GPT-schijven met gmirror(8) niet aangeraden. Hier wordt MBR-partitionering gebruikt omdat het alleen een partitietabel aan het begin van de schijf opslaat en niet conflicteert met gmirror(8).

### 20.4.2. Een spiegel met twee nieuwe schijven maken

In dit voorbeeld is FreeBSD reeds op een enkele schijf `ada0` geïnstalleerd. Twee nieuwe schijven, `ada1` en `ada2` zijn met het systeem verbonden. Er zal een nieuwe spiegel op deze twee schijven aangemaakt worden die de oude enkele schijf zal vervangen.

gmirror(8) heeft een kernelmodule `geom_mirror.ko` nodig, ingebouwd in de kernel of geladen tijdens het opstarten of draaien. Laadt nu handmatig de kernelmodule:

    # gmirror load

Maak de spiegel aan met de twee nieuwe schijven:

    # gmirror label -v gm0 /dev/ada1 /dev/ada2

`gm0` is een door de gebruiker gekozen apparaatnaam die aan de nieuwe spiegel wordt toegekend. Nadat de spiegel is gestart, zal deze apparaatnaam verschijnen in de map `/dev/mirror/`.

Nu kunnen er met gpart(8) MBR- en bsdlabel-partitietabellen op de spiegel worden aangemaakt. Hier wordt er een traditioneel schema van een gesplitst bestandssysteem getoond, met partities voor `/`, swap, `/var`, `/tmp` en `/usr`. Dit werkt ook voor een enkel bestandssysteem met enkel `/` en een wisselpartitie.

Partities op de spiegel hoeven niet dezelfde grootte te hebben als die op de bestaande schijf, maar moeten groot genoeg zijn om alle gegevens die reeds op `ada0` staan te kunnen bevatten.

    # gpart create -s MBR mirror/gm0
    # gpart add -t freebsd -a 4k mirror/gm0
    # gpart show mirror/gm0
    =>       63  156301423  mirror/gm0  MBR  (74G)
             63         63                    - free -  (31k)
            126  156301299                 1  freebsd  (74G)
      156301425         61                    - free -  (30k)

    # gpart create -s BSD mirror/gm0s1
    # gpart add -t freebsd-ufs  -a 4k -s 2g mirror/gm0s1
    # gpart add -t freebsd-swap -a 4k -s 4g mirror/gm0s1
    # gpart add -t freebsd-ufs  -a 4k -s 2g mirror/gm0s1
    # gpart add -t freebsd-ufs  -a 4k -s 1g mirror/gm0s1
    # gpart add -t freebsd-ufs  -a 4k       mirror/gm0s1
    # gpart show mirror/gm0s1
    =>        0  156301299  mirror/gm0s1  BSD  (74G)
              0          2                      - free -  (1.0k)
              2    4194304                   1  freebsd-ufs  (2.0G)
        4194306    8388608                   2  freebsd-swap  (4.0G)
       12582914    4194304                   4  freebsd-ufs  (2.0G)
       16777218    2097152                   5  freebsd-ufs  (1.0G)
       18874370  137426928                   6  freebsd-ufs  (65G)
      156301298          1                      - free -  (512B)

Maak de spiegel opstartbaar door opstartcode in het MBR en bsdlabel te installeren en de actieve slice in te stellen:

    # gpart bootcode -b /boot/mbr mirror/gm0
    # gpart set -a active -i 1 mirror/gm0
    # gpart bootcode -b /boot/boot mirror/gm0s1

Formatteer de bestandssystemen op de nieuwe spiegel en zet daarbij soft-updates aan.

    # newfs -U /dev/mirror/gm0s1a
    # newfs -U /dev/mirror/gm0s1d
    # newfs -U /dev/mirror/gm0s1e
    # newfs -U /dev/mirror/gm0s1f

Bestandssystemen van de originele schijf (`ada0`) kunnen nu met dump(8) en restore(8) naar de spiegel gekopieerd worden:

    # mount /dev/mirror/gm0s1a /mnt
    # dump -C16 -b64 -0aL -f - / | (cd /mnt && restore -rf -)
    # mount /dev/mirror/gm0s1d /mnt/var
    # mount /dev/mirror/gm0s1e /mnt/tmp
    # mount /dev/mirror/gm0s1f /mnt/usr
    # dump -C16 -b64 -0aL -f - /var | (cd /mnt/var && restore -rf -)
    # dump -C16 -b64 -0aL -f - /tmp | (cd /mnt/tmp && restore -rf -)
    # dump -C16 -b64 -0aL -f - /usr | (cd /mnt/usr && restore -rf -)

`/mnt/etc/fstab` moet bewerkt worden om naar de nieuwe bestandssystemen op de spiegel te wijzen:

    # Device		Mountpoint	FStype	Options	Dump	Pass#
    /dev/mirror/gm0s1a	/		ufs	rw	1	1
    /dev/mirror/gm0s1b	none		swap	sw	0	0
    /dev/mirror/gm0s1d	/var		ufs	rw	2	2
    /dev/mirror/gm0s1e	/tmp		ufs	rw	2	2
    /dev/mirror/gm0s1f	/usr		ufs	rw	2	2

Als de kernelmodule gmirror(8) niet in de kernel is ingebouwd, wordt `/mnt/boot/loader.conf` bewerkt om de module tijdens het opstarten te laden:

    geom_mirror_load="YES"

Herstart het systeem om de nieuwe spiegel te testen en te verifiëren dat alle gegevens zijn gekopieerd. Het BIOS zal de spiegel als twee individuele schijven zien in plaats van als een spiegel. Omdat de schijven identiek zijn, maakt het niet uit vanaf welke schijf wordt opgestart.

Bekijk de sectie Problemen oplossen als er problemen zijn tijdens het opstarten. Door de originele `ada0` uit te schakelen en los te koppelen kan het als offline back-up bewaard worden.

Tijdens het gebruik zal de spiegel zich net zoals de originele enkele schijf gedragen.

### 20.4.3. Een spiegel met een bestaande schijf aanmaken

In dit voorbeeld is FreeBSD reeds geïnstalleerd op een enkele schijf, `ada0`. Een nieuwe schijf, `ada1`, is met het systeem verbonden. Er zal een spiegel van één schijf worden aangemaakt op de nieuwe schijf, het bestaande systeem zal ernaar worden gekopieerd, en daarna zal de oude schijf in de spiegel worden geplaatst. Deze enigszins complexe procedure is nodig omdat gmirror(8) een blok van 512 bytes aan meta-gegevens aan het einde van elke schijf moet plaatsen en de bestaande `ada0` meestal alle ruimte reeds heeft toegewezen.

Laadt de kernelmodule gmirror(8):

    # gmirror load

Controleer de mediagrootte van de originele schijf met diskinfo(8):

    # diskinfo -v ada0 | head -n3
    /dev/ada0
    	512             # sectorsize
    	1000204821504   # mediasize in bytes (931G)

Maak een spiegel aan op de nieuwe schijf. Om er zeker van te zijn dat de capaciteit van de spiegel niet groter is dan die van de originele schijf, wordt gnop(8) gebruikt om een nepschijf van precies dezelfde grootte aan te maken. Deze schijf slaat geen gegevens op, maar wordt alleen gebruikt om de grootte van de spiegel te begrenzen. Wanneer gmirror(8) de spiegel aanmaakt, zal het de capaciteit beperken tot de grootte van `gzero.nop` zelfs als de nieuwe schijf (`ada1`) meer ruimte heeft. Merk op dat de `1000204821504` op de tweede regel gelijk moet zijn aan de mediagrootte van `ada0` zoals hierboven door diskinfo(8) is getoond.

    # geom zero load
    # gnop create -s 1000204821504 gzero
    # gmirror label -v gm0 gzero.nop ada1
    # gmirror forget gm0

`gzero.nop` slaat geen gegevens op, dus ziet de spiegel het niet als verbonden. De spiegel wordt verteld om componenten die niet verbonden zijn te “vergeten”, waarbij referenties naar `gzero.nop` worden verwijderd. Het resultaat is een spiegelapparaat dat slechts één enkele schijf, `ada1`, bevat.

Bekijk de partitietabel van `ada0` nadat `gm0` is aangemaakt.

Deze uitvoer komt van een schijf van 1 TB. Als er wat niet-toegewezen ruimte aanwezig is aan het einde van de schijf, kan de inhoud direct van `ada0` naar de nieuwe spiegel worden gekopieerd.

Als de uitvoer echter toont dat alle ruimte op de schijf is toegewezen zoals in de volgende lijst, is er geen ruimte over voor de 512 bytes aan meta-gegevens van gmirror(8) aan het einde van de schijf.

    # gpart show ada0
    =>        63  1953525105        ada0  MBR  (931G)
              63  1953525105           1  freebsd  [active]  (931G)

In dit geval moet de partitietabel worden bewerkt om de capaciteit op `mirror/gm0` met één sector te verminderen. De procedure hiervoor wordt later uitgelegd.

In beide gevallen dienen de partitietabellen op de primaire schijf eerst gekopieerd te worden. Dit kan gedaan worden met de subcommando's `backup` en `restore` van gpart(8).

    # gpart backup ada0 > table.ada0
    # gpart backup ada0s1 > table.ada0s1

Deze subcommando's maken twee bestanden aan, `table.ada0` en `table.ada0s1`. Dit voorbeeld komt van een schijf van 1 TB af:

    # cat table.ada0
    MBR 4
    1 freebsd         63 1953525105   [active]

    # cat table.ada0s1
    BSD 8
    1  freebsd-ufs          0    4194304
    2 freebsd-swap    4194304   33554432
    4  freebsd-ufs   37748736   50331648
    5  freebsd-ufs   88080384   41943040
    6  freebsd-ufs  130023424  838860800
    7  freebsd-ufs  968884224  984640881

Als de gehele schijf was gebruikt in de uitvoer van gpart(8) `show`, dan moet de capaciteit in deze partitietabellen met één sector verminderd worden. Bewerk de twee bestanden zodat de grootte van zowel de slice als de laatste partitie met één verminderd wordt. Dit zijn de laatste getallen in elke lijst.

    # cat table.ada0
    MBR 4
    1 freebsd         63 1953525104   [active]

    # cat table.ada0s1
    BSD 8
    1  freebsd-ufs          0    4194304
    2 freebsd-swap    4194304   33554432
    4  freebsd-ufs   37748736   50331648
    5  freebsd-ufs   88080384   41943040
    6  freebsd-ufs  130023424  838860800
    7  freebsd-ufs  968884224  984640880

Als er tenminste één sector aan het einde van de schijf niet was toegewezen, kunnen deze twee bestanden ongewijzigd gebruikt worden.

Herstel nu de partitietabel naar `mirror/gm0`.

    # gpart restore mirror/gm0 < table.ada0
    # gpart restore mirror/gm0s1 < table.ada0s1

Controleer de partitietabel met gpart(8) `show`. Dit voorbeeld heeft `gm0s1a` voor `/`, `gm0s1d` voor `/var`, `gm0s1e` voor `/usr`, `gm0s1f` voor `/data1` en `gm0s1g` voor `/data2`.

    # gpart show mirror/gm0
    =>        63  1953525104  mirror/gm0  MBR  (931G)
              63  1953525042           1  freebsd  [active]  (931G)
      1953525105          62              - free -  (31k)

    # gpart show mirror/gm0s1
    =>         0  1953525042  mirror/gm0s1  BSD  (931G)
               0     2097152             1  freebsd-ufs  (1.0G)
         2097152    16777216             2  freebsd-swap  (8.0G)
        18874368    41943040             4  freebsd-ufs  (20G)
        60817408    20971520             5  freebsd-ufs  (10G)
        81788928   629145600             6  freebsd-ufs  (300G)
       710934528  1242590514             7  freebsd-ufs  (592G)
      1953525042          63                - free -  (31k)

Zowel de slice als de laatste partitie dienen wat vrije ruimte aan het einde van elke schijf te hebben.

Maak bestandssystemen aan op deze nieuwe partities. Het aantal partities zal variëren, overeenkomend met de partities op de originele schijf, `ada0`.

    # newfs -U /dev/mirror/gm0s1a
    # newfs -U /dev/mirror/gm0s1d
    # newfs -U /dev/mirror/gm0s1e
    # newfs -U /dev/mirror/gm0s1f
    # newfs -U /dev/mirror/gm0s1g

Maak de spiegel opstartbaar door opstartcode in het MBR en bsdlabel te installeren en de actieve slice in te stellen:

    # gpart bootcode -b /boot/mbr mirror/gm0
    # gpart set -a active -i 1 mirror/gm0
    # gpart bootcode -b /boot/boot mirror/gm0s1

Pas `/etc/fstab` aan zodat het de nieuwe partities op de spiegel gebruikt. Maak eerst een kopie van dit bestand als `/etc/fstab.orig`.

    # cp /etc/fstab /etc/fstab.orig

Wijzig `/etc/fstab` door `/dev/ada0` door `mirror/gm0` te vervangen.

    # Device		Mountpoint	FStype	Options	Dump	Pass#
    /dev/mirror/gm0s1a	/		ufs	rw	1	1
    /dev/mirror/gm0s1b	none		swap	sw	0	0
    /dev/mirror/gm0s1d	/var		ufs	rw	2	2
    /dev/mirror/gm0s1e	/usr		ufs	rw	2	2
    /dev/mirror/gm0s1f	/data1		ufs	rw	2	2
    /dev/mirror/gm0s1g	/data2		ufs	rw	2	2

Als de kernelmodule gmirror(8) niet in de kernel is gebouwd, wijzig dan `/boot/loader.conf` om het te laden:

    geom_mirror_load="YES"

Bestandssystemen van de originele schijf kunnen nu met dump(8) en restore(8) naar de spiegel gekopieerd worden. Merk op dat het maken van een snapshot voor elk bestandssysteem dat met `dump -L` gedumpt is even kan duren.

    # mount /dev/mirror/gm0s1a /mnt
    # dump -C16 -b64 -0aL -f - /    | (cd /mnt && restore -rf -)
    # mount /dev/mirror/gm0s1d /mnt/var
    # mount /dev/mirror/gm0s1e /mnt/usr
    # mount /dev/mirror/gm0s1f /mnt/data1
    # mount /dev/mirror/gm0s1g /mnt/data2
    # dump -C16 -b64 -0aL -f - /usr | (cd /mnt/usr && restore -rf -)
    # dump -C16 -b64 -0aL -f - /var | (cd /mnt/var && restore -rf -)
    # dump -C16 -b64 -0aL -f - /data1 | (cd /mnt/data1 && restore -rf -)
    # dump -C16 -b64 -0aL -f - /data2 | (cd /mnt/data2 && restore -rf -)

Start het systeem opnieuw op vanaf `ada1`. Als alles werkt, zal het systeem opstarten vanaf `mirror/gm0`, wat nu dezelfde gegevens bevat die `ada0` eerder bevatte. Zie de sectie Problemen oplossen als er problemen zijn met het opstarten.

Op dit moment bestaat de spiegel nog steeds alleen uit de enkele schijf `ada1`.

Nadat er succesvol van `mirror/gm0` is opgestart, is de laatste stap het plaatsen van `ada0` in de spiegel.

### Belangrijk:

Als `ada0` in de spiegel wordt geplaatst, zal de vorige inhoud worden overschreven door gegevens in de spiegel. Ben er zeker van dat `mirror/gm0` dezelfde gegevens bevat als `ada0` voordat `ada0` aan de spiegel wordt toegevoegd. Als er iets mis is met de gegevens die door dump(8) en restore(8) gekopieerd zijn, draai dan `/etc/fstab` terug om de bestandssystemen op `ada0` aan te koppelen, start opnieuw op, en probeer de hele procedure nogmaals.

    # gmirror insert gm0 ada0
    GEOM_MIRROR: Device gm0: rebuilding provider ada0

De synchronisatie tussen de twee schijven zal onmiddellijk beginnen. gmirror(8) `status` toont de voortgang.

    # gmirror status
          Name    Status  Components
    mirror/gm0  DEGRADED  ada1 (ACTIVE)
                          ada0 (SYNCHRONIZING, 64%)

Na een tijd zal de synchronisatie voltooid zijn.

    GEOM_MIRROR: Device gm0: rebuilding provider ada0 finished.
    # gmirror status
          Name    Status  Components
    mirror/gm0  COMPLETE  ada1 (ACTIVE)
                          ada0 (ACTIVE)

`mirror/gm0` bestaat nu uit de twee schijven `ada0` en `ada1`, en de inhoud wordt automatisch met elkaar gesynchroniseerd. In het gebruik zal `mirror/gm0` zich net zo gedragen als de originele enkele schijf.

### 20.4.4. Problemen oplossen

#### 20.4.4.1. Problemen met opstarten

##### 20.4.4.1.1. BIOS-instellingen

Mogelijk is het nodig om de BIOS-instellingen te wijzigen om van één van de nieuwe gespiegelde schijven op te starten. Beide spiegelschijven kunnen gebruikt worden voor het opstarten. Als componenten van een spiegel bevatten ze identieke gegevens.

##### 20.4.4.1.2. Opstartproblemen

Als het opstarten met dit bericht stopt, is er iets mis met het spiegelapparaat:

    Mounting from ufs:/dev/mirror/gm0s1a failed with error 19.

    Loader variables:
      vfs.root.mountfrom=ufs:/dev/mirror/gm0s1a
      vfs.root.mountfrom.options=rw

    Manual root filesystem specification:
      <fstype>:<device> [options]
          Mount <device> using filesystem <fstype>
          and with the specified (optional) option list.

        eg. ufs:/dev/da0s1a
            zfs:tank
            cd9660:/dev/acd0 ro
              (which is equivalent to: mount -t cd9660 -o ro /dev/acd0 /)

      ?               List valid disk boot devices
      .               Yield 1 second (for background tasks)
      <empty line>    Abort manual input

    mountroot>

Het vergeten om de module `geom_mirror` in `/boot/loader.conf` te laden kan dit probleem veroorzaken. Start op vanaf een FreeBSD-9 of nieuwere CD of USB-stick en kies `Shell` op de eerste prompt om dit op te lossen. Laadt daarna de spiegelmodule en en koppel het spiegelapparaat aan:

    # gmirror load
    # mount /dev/mirror/gm0s1a /mnt

Voeg een regel om de spiegelmodule te laden toe aan `/mnt/boot/loader.conf`:

    geom_mirror_load="YES"

Sla het bestand op en start opnieuw op.

Andere problemen die `error 19` veroorzaken zijn lastiger om op te lossen. Typ `ufs:/dev/ada0s1a` in op de prompt. Hoewel het systeem van `ada0` zou moeten opstarten, verschijnt er een andere prompt om een shell uit te kiezen omdat `/etc/fstab` onjuist is. Druk op de prompt op de Enter-toets. Draai de wijzigingen tot nu toe terug door `/etc/fstab` terug te draaien, waardoor de bestandssystemen vanaf de originele schijf ( `ada0`) in plaats vanaf de spiegel worden aangekoppeld. Start het systeem opnieuw op en probeer de procedure nogmaals.

    Enter full pathname of shell or RETURN for /bin/sh:
    # cp /etc/fstab.orig /etc/fstab
    # reboot

### 20.4.5. Herstellen van falende schijven

Het mooie aan het spiegelen van schijven is dat een individuele schijf kan falen zonder dat de spiegel gegevens verliest.

`ada0` is één van de twee schijven die de spiegel in het vorige voorbeeld vormen. Als `ada0` faalt zal de spiegel blijven werken en gegevens leveren van de overgebleven werkende schijf, `ada1`.

Om de kapotte schijf te vervangen wordt de computer uitgezet en de kapotte schijf fysiek vervangen door een nieuwe schijf van gelijke of grotere capaciteit. Fabrikanten passen enigszins willekeurige waarden toe om schijven in gigabytes aan te duiden, de enige manier om er echt zeker van te zijn is om de totale hoeveelheid aan sectors aangegeven door `diskinfo -v` te vergelijken. Een schijf met een grotere capaciteit dan in de spiegel zal werken, alhoewel de extra ruimte op de nieuwe schijf niet gebruikt zal worden.

Nadat de computer opnieuw is aangezet, zal de spiegel in een “degraded” toestand met slechts één schijf draaien. De spiegel wordt verteld om schijven die momenteel niet verbonden zijn te vergeten:

    # gmirror forget gm0

Alle oude meta-gegevens zouden van de vervangende schijf gewist moeten zijn. Daarna wordt de schijf, in dit voorbeeld `ada4`, in de spiegel geplaatst:

    # gmirror insert gm0 /dev/ada4

De hersynchronisatie begint wanneer de nieuwe schijf in de spiegel wordt geplaatst. Het kopiëren van gegevens van de spiegel naar een nieuwe schijf kan een tijd duren. De prestaties van de spiegel zullen tijdens het kopiëren sterk verminderd zijn, dus is het het beste om nieuwe schijven in te voegen wanneer de vraag op de computer laag is.

De voortgang kan met `gmirror status` gevolgd worden, wat de schijven die gesynchroniseerd en het percentage van de voltooiing laat zien. Tijdens de hersynchronisatie zal de status `DEGRADED` zijn en veranderen in `COMPLETE` wanneer het proces is voltooid.

Terug | Omhoog | Volgende
20.3. RAID0 - aaneengeschakeld | Begin | 20.5. RAID3 - Striping op byte-niveau met toegewijde pariteit