Tag Archives: Linux SW-Raid

Upgrade of a server host from Opensuse Leap 15.1 to 15.2 – II – smartd configuration, 3ware controllers, mdadm RAID

Posted on by

During the upgrade of one of my server systems from Opensuse Leap 15.1 to 15.2 I noticed that the smartd-daemon did not start successfully. Logs revealed that the upgrade itself was NOT the cause of this failure; it is nevertheless a good occasion to briefly point out how one can configure the smartd-daemon to keep an overview over the evolution of disk properties on a Leap 15.X system – even when the disks are an integral part of one or more Raid-arrays. “Overview” is also a reason why I use “rsyslog” in addition to a pure systemd journal log to track the SMART data.

A problem with a 3ware based Raid array

The main cause of the smartd-failure on the upgraded server was an active line with the command “DEVICESCAN” in Opensuse’s version of the configuration file “/etc/smartd.conf”. As the command’s name indicates, the system is scanned for disks to monitor. Unfortunately, smartd did not find any SMART enabled devices on my server. 

Feb 05 17:01:55 MySRV smartd[14056]: Drive: DEVICESCAN, implied '-a' Directive on line 32 of file /etc/smartd.conf
Feb 05 17:01:55 MySRV smartd[14056]: Configuration file /etc/smartd.conf was parsed, found DEVICESCAN, scanning devices
Feb 05 17:01:55 MySRV smartd[14056]: Unable to monitor any SMART enabled devices. Try debug (-d) option. Exiting...
...

Well, this finding was correct. All internal disks of the server were members of Raid arrays on elderly 3ware controllers. 3ware controllers are supported by the Linux kernel – in my case via a module “3w_9xxx”. During the installation an Opensuse Leap system the driver module was automatically added to the configurations of GRUB, the initramfs and the list of modules loaded by the eventually booted kernel. Upgrades have respected the configuration so far.

But with hardware RAID controllers the attached individual disks are NOT directly accessible to standard “smartd” directives or a standard plain “smartctl” command. You need to a special options. The HW-RAID-array is seen by the Linux system and smartd as a block device – without an inner structure. And the block device corresponding to the HW-controlled RAID-array has no SMART capabilities – which is, of course, very reasonable. Thus DEVICESCAN fails.

I wondered a bit why I had not seen the problem on the same system with Leap 15.1. Actually, this was my fault: Looking into a backup I saw in the last logs of the host during its time with Leap 15.1 that the problem had existed already before the upgrade – and was caused by an old, original “smartd.conf”-file from SuSE with which I had accidentally overwritten my own version of “smartd.conf”. Stupid me! But the really concerning thing was that I should have noticed the consequences in some logs. But, since I became a almost full-time employee I have been too lazy to work regularly with specific filter-options of systemd’s command “journalctl” – so I missed the relevant messages within the flood of messages in the journal. Time to reactivate rsyslog to get specific information into specific files – see below.

Anyway … It is reasonable that the failure of a standard DEVICESCAN should lead to a failure of the smartd service. The attentive admin thus gets a clear hint that his intention to watch disk health variables is not working as expected – even if the “smartd.conf” should contain other valid lines. The comments in “/etc/smartd.conf” clearly say: 

# The word DEVICESCAN will cause any remaining lines in this configuration file to be ignored: 
# it tells smartd to scan for all ATA and SCSI devices. DEVICESCAN may be followed by any of the
# Directives listed below, which will be applied to all devices that are found.
#  
# Most users should comment out DEVICESCAN and explicitly list the devices that they wish to monitor.

I changed the line breaks a bit to stress the last statement. The obvious
and trivial solution in my case was to comment out the DEVICESCAN-line and activate some explicit statements for the individual disks in the 3ware array. To make things a bit more interesting, let us look at a different system MySYS which uses a combination of 3ware controlled hard-disk arrays and mdadm controlled SSD-arrays.

Off-topic:
The server host discussed above does not require a particular high disk throughput. Storage capacity in TB is more important. Actually, I would never buy a 3ware or LSI controller again for a semi-professional Linux machine. Too much money for a too low performance. With Linux you are certainly better off with mdadm and SW-RAID on a modern multi-core-processor. The general impact on an i7 or i9 on the overall performance is negligible in my experience. Especially, when you have a lot of fast RAM. In addition mdadm gives you much (!) more flexibility. You can, for example, build a set of multiple RAID-arrays working in parallel with one and the same stack of disks/SSDs by assigning different partitions to different distinct arrays – which may even be of a different type. But this is another story …

Entries for disks attached to 3ware controllers and SSDs in mdadm-Raid-arrays in the “/etc/smartd.conf” file

In the system MySRV I use a configuration

  • of multiple mdadm RAID-arrays consisting of assigned SSD-partitions of a stack of 4 SSDs
  • and 4 conventional hard-disks attached to a 3ware controller, forming a RAID 10-array.

In addition the host contains a further stand alone SSD.

For disks attached to a 3ware-controller we need a special form of the directives in the “smartd.conf”-file. Actually, some examples for such directives are given in a 3ware-related commentary section of “/etc/smartd.conf”. You may find something directly suitable for your purposes there.

What about devices which are members of mdadm-controlled SW-Raid arrays? Well, the nice thing is that in contrast to HW-controlled Raid-disks the SMART-daemon can access SSDs (or hard disks) on a mdadm-controlled SW-Raid-array directly! Without any special options! Actually, folks familiar with “mdadm” would have expected this for very basic reasons … But this is yet another story … We just accept the fact as one example ofthe power of Linux.

Thus, for my special system MySYS I just disabled the line with “Devicescan” and inserted the following lines into “/etc/smartd.conf”: 

...
DEFAULT -d removable -s (S/../../7/03)
...
#DEVICESCAN
...
# Monitor SSDs contributing to different mdadm based SSD-Raid-arrays via (vertical) stacks of partitions 
/dev/sda -d sat -a -o off
/dev/sdb -d sat -a -o off
/dev/sdc -d sat -a -o off
/dev/sdd -d sat -a -o off

# Monitor additional stand alone SSD 
/dev/sde -d sat -a -o off

# Monitor HDs attached to 3ware controller with a Raid 10 configuration 
/dev/twa0 -d 3ware,0 -F samsung -a -o off
/dev/twa0 -d 3ware,1 -F samsung -a -o off
/dev/twa0 -d 3ware,2 -F samsung -a -o off
/dev/twa0 -d 3ware,3 -F samsung -a -o off
...

Disclaimer: Never copy the statements and later discussed smartctl-commands above without a thorough study of the literature and documentation on smart, smartctl and smartd. Check the preconditions of applying the directives and commands carefully with respect to your actual HW-/SW-configuration and the type of SSDs and hard disks used there! You have to find out about the correct settings for your system-configuration on your own.
Warning: The effects of the “-a” option and especially of the planned automatic disk tests initiated via the “DEFAULT”-statement may be different for SCSI or SATA-disks. Some options may even lead to data loss on older Samsung disks. I will not take any responsibility
for any problems caused by applying the settings displayed above to YOUR systems. Get advice of a professional regarding RAID-configurations and smartctl ahead of any experiments.

Having this said, the expert sees that I plan short self tests of the disks on every Sunday at 3 AM. Such tests will temporarily reduce the performance of the affected disks and as a consequence also of the various RAID-configurations the disk or any of its partitions might be a part of. At least on my system such a test will, however, not render the defined RAID-arrays unusable.

I could test this for a SATA-device and mdadm e.g. by using a suitable smartctl-command as

smartctl -t short /dev/sdc

and watching the continuing operation of a related RAID-array by

mdadm -D /dev/mdxxx

The corresponding smartcl-command for a 3ware RAID-disk would e.g. be

smartctl -t short /dev/twa0 -d 3ware,3 -F samsung.

As said above: Be careful with such tests on productive systems.

By the way: Only for the 3ware disks you may get an information about the starting of the test in a smartd related log-file (see below). If no errors are found, the logs will NOT show any special message.

At least on an Opensuse system the other settings and options for the various disks are discussed and explained in the commentary sections of the file: 

#   -d TYPE Set the device type: ata, scsi, marvell, removable, 3ware,N, hpt,L/M/N
#   -o VAL  Enable/disable automatic offline tests (on/off)
#   -H      Monitor SMART Health Status, report if failed
#   -l TYPE Monitor SMART log.  Type is one of: error, selftest
#   -f      Monitor for failure of any 'Usage' Attributes
#   -p      Report changes in 'Prefailure' Normalized Attributes
#   -u      Report changes in 'Usage' Normalized Attributes
#   -t      Equivalent to -p and -u Directives
#   -a      Default: equivalent to -H -f -t -l error -l selftest -C 197 -U 198
#   -F TYPE Use firmware bug workaround. Type is one of: none, samsung

and 

# Monitor 4 ATA disks connected to a 3ware 6/7/8000 controller which uses
# the 3w-xxxx driver. Start long self-tests Sundays between 1-2, 2-3, 3-4, 
# and 4-5 am.
# NOTE: starting with the Linux 2.6 kernel series, the /dev/sdX interface
# is DEPRECATED.  Use the /dev/tweN character device interface instead.
# For example /dev/twe0, /dev/twe1, and so on.
#/dev/sdc -d 3ware,0 -a -s L/../../7/01
#/dev/sdc -d 3ware,1 -a -s L/../../7/02
#/dev/sdc -d 3ware,2 -a -s L/../../7/03
#/dev/sdc -d 3ware,3 -a -s L/../../7/04

On my system (with one a 3ware controller and mdadm Raid-arrays) the smartd daemon started without any problems afterwards.

Configure rsyslog to write smartd-information into a distinct separate log-file

Old fashioned as I am, I use rsyslog aside systemd’s journal-logging. rsyslog can easily be configured to write log entries for selected daemons/processes into predefined separate log-files. Such files can directly be opened as they are plain text-files. Let us configure rsyslog for the smartd daemon:

  • Step 1: We create an empty file “/var/log/smartd.log” (as root) on the host in question by the command

    “touch /var/log(smartd.conf”

  • Step 2: Change rights by “chmod 640 /var/log/smartd.log”
  • Step 3: Add the following line to the file “/etc/rsyslog.conf” (close to the end)

    :programname, isequal, “smartd” /var/log/smartd.log

  • Step 4: Restart the rsyslog-daemon by “systemctl restart rsyslog”

You
surely have noticed that this is for local logging. But it is easy to adapt the settings to logging on remote systems.

What do smartd-logs look like?

Depending on your hardware you may get specific messages for your devices at the start of the smartd-daemon. Depending on the execution of scheduled self-tests you may get some messages about starting such test. After some time you should (hopefully) see successful messages regarding short or long self-tests – depending on your settings. In my case: 

2021-02-11T14:29:43.511950+01:00 MySYS smartd[1723]: Device: /dev/sda [SAT], previous self-test completed without error
...
2021-02-11T14:29:44.026256+01:00 MySYS smartd[1723]: Device: /dev/twa0 [3ware_disk_00], previous self-test completed without error
...

In addition that you will get continuous information about changes of variables describing the health-status of your disks. In my case only the variation of the temperature due to changing airflow is shown: 

...
2021-02-11T14:59:43.340341+01:00 MySYS smartd[1723]: Device: /dev/sda [SAT], SMART Usage Attribute: 190 Airflow_Temperature_Cel changed from 76 to 78
2021-02-11T14:59:43.350339+01:00 MySYS smartd[1723]: Device: /dev/sdb [SAT], SMART Usage Attribute: 190 Airflow_Temperature_Cel changed from 77 to 78
2021-02-11T14:59:43.353660+01:00 MySYS smartd[1723]: Device: /dev/sdc [SAT], SMART Usage Attribute: 190 Airflow_Temperature_Cel changed from 77 to 79
2021-02-11T14:59:43.357007+01:00 MySYS smartd[1723]: Device: /dev/sdd [SAT], SMART Usage Attribute: 190 Airflow_Temperature_Cel changed from 77 to 79
2021-02-11T14:59:43.360136+01:00 MySYS smartd[1723]: Device: /dev/sde [SAT], SMART Usage Attribute: 190 Airflow_Temperature_Cel changed from 77 to 78
...

Conclusion

If for some reason the “smartd”-daemon and the related service does not start on a Linux host with Opensuse Leap 15.2 it is easy to get it running again. Even, when your disk devices are members of RAID arrays. The configuration file “/etc/smartd.log” contains a lot of hints how to set up reasonable directives regarding various HW-RAID-controllers supported by the kernel. A really good thing is that we do not need any special commands or options regarding disk devices whose partitions are members of mdamd-controlled SW-RAID arrays.

Links

https://linux.die.net/man/5/smartd.conf
https://linux.die.net/man/8/smartd

https://www.linux.com/topic/desktop/monitor-sata-and-ssd-health-smart/
https://linuxconfig.org/introduction-to-the-systemd-journal
https://www.debugpoint.com/2020/12/systemd-journalctl/

Performance of Linux md raid-10 arrays – negative impact of the intel_pstate CPU governor for HWP?

Posted on by

Last November I performed some tests with “fio” on Raid arrays with SSDs (4 Samsung EVO 850). The test system ran on Opensuse Leap 42.1 with a Linux kernel of version 4.1. It had an onboard Intel Sunrise Point controller and an i7 6700k CPU.

For md-raid arrays of type Raid10, i.e. for Linux SW Raid10 arrays created via the mdadm command, I was quite pleased with the results. Both for N2 and F2 layouts and especially for situations where the Read/Write load was created by several jobs running in parallel. Depending on the size of the data packets you may, e.g., well reach a Random Read [RR] performance between 1.0 Gbyte/sec and 1.5 GByte/sec for packet sizes ≥ 512 KB and %gt; 1024k, respectively. Even for one job only the RR-performance for such packet sizes lay between 790 MByte/sec and 950 Mbyte/sec – i.e. well beyond the performance of a single SSD.

Significant drop in md-raid performance on Opensuse Leap 42.2 with kernel 4.4

Then I upgraded to Opensuse Leap 42.2 with kernel 4.4. Same system, same HW, same controller, same CPU, same SSDs and raid-10 setup.
I repeated some of my raid-array tests. Unfortunately, I then experienced a significant drop in performance – up to 25% depending on the packet size. With absolute differences in the range of 60 MByte/sec to over 200 Mbyte/sec, again depending on the chosen data packet sizes.

In addition I saw irregular ups and downs in the performance (large spread) for repeated tests with the same fio parameters. Up to some days ago I never found a convincing reason for this strange performance variation behavior of the md-Raid arrays for different kernels and OS versions.

Impact of the CPU governor ?!

Three days ago I read several articles about CPU governors. On my system the “intel_pstate” driver is relevant for CPU power saving. It offers exactly two active governor modes: “powersave” and “performance” (see e.g.: https://www.kernel.org/doc/html/latest/admin-guide/pm/intel_pstate.html).

The chosen CPU governor standard for Opensuse Leap 42.2 is “powersave”.

Just for fun I repeated some simple tests for the raid array again – one time with “powersave” active on all CPU cores/threads and a second time with “performance” active on all cores/threads. The discrepancy was striking:

Test setup

HW: CPU i7 6700K, Asus Z170 Extreme 7 with Intel Sunrise Point-H Sata3 controller

Raid-Array: md-raid-10, Layout: N2, Chunk Size: 32k, bitmap: none

SSDs: 4 Samsung Evo 850

Fio parameters:

size=500m
directory=/mnt2
direct=1
ioengine=sync
bs=512k
; bs=1024k
iodepth=1
numjobs=1
[read]
rw=randread
[write]
stonewall
rw=randwrite

Test results:

Fio test case 1 – bs=512k, Random Read [RR] / Random Write [RW]:

Leap 42.1, Kernel 4.1:
RR: 780 MByte/sec – RW: 754 MByte/sec,
RR Spread around 35 Mbyte/sec

Leap 42.2, Kernel 4.4, CPU governor powersave :
RR: 669 MByte/sec – RW: 605 MByte/sec,
RR Spread around 50 Mbyte/sec

Leap 42.2, Kernel 4.4, CPU governor: performance :
RR: 780 MByte/sec – RW: 750 MByte/sec,

RR Spread around 35 Mbyte/sec

Fio test case 2 – bs=1024k, Random Read [RR] / Random Write [RW]:

Leap 42.1, Kernel 4.1:
RR: 860 MByte/sec – RW: 800 MByte/sec
RR Spread around 30 Mbyte/sec

Leap 42.2, Kernel 4.4, CPU governor: powersave :
RR: 735 MByte/sec – RW: 660 MByte/sec
RR Spread > 50 Mbyte/sec

Leap 42.2, Kernel 4.4, CPU governor: performance :
RR: 877 MByte/sec – RW: 792 MByte/sec
RR Spread around 25 Mbyte/sec

Interpretation

The differences are so significant that one begins to worry. The data seem to indicate two points:

  • It seems that a high CPU frequency is required for optimum performance of md-raid arrays with SSDs.
  • It seems that the Leap 42.1 with kernel 4.1 reacts differently to load requests from fio test runs – with resulting CPU frequencies closer to the maximum – than Leap 42.2 with kernel 4.4 in powersave mode. This could be a matter of different CPU governors or major changes in drivers …

With md-raid arrays active, the CPU governor should react very directly to a high I/O load and a related short increase of CPU consumption. However, the md-raid-modules seem to be so well programmed that the rise in CPU load is on average below any thresholds for the “powersave”-governor to react adequately. At least on Leap 42.2 with kernel 4.4 – for whatever reasons. Maybe the time structure of I/O and CPU load is not analyzed precisely enough or there is in general no reaction to I/O. Or there is a bug in the related version of intel_pstate …

Anyway, I never saw a rise of the CPU frequency above 2300 Mhz during the tests on Leap 42.2 – but short spikes to half of the maximum frequency are quite normal on a desktop system with some applications active. Never, however, was the top level of 4200 Mhz reached. I tested also with 2000 MB to be read/written in total – then we talk already of time intervals around 3 to 4 secs for the I/O load to occur.

Questions

When reading a bit more, I got the impression, that the admins possibilities to influence the behavior of the “intel_pstate” governors are very limited. So, some questions arise directly:

  1. What is the major difference between OS Leap 42.1 with kernel 4.1 compared to Opensuse 42.2 with kernel 4.4? Does Leap 41.1 use the same CPU governor as Leap 42.2?
  2. Is the use of Intel’s standard governor mode “powersave” in general a bad choice on systems with a md-raid for SSDs?
  3. Are there any kernel or intel-pstate parameters that would change the md-raid-performance to the better again?

If somebody knows the answers, please contact me. The whole topic is also discussed here: https://bugzilla.kernel.org/show_bug.cgi?id=191881. At least I hope so …

Addendum, 19.06.2017:
Answer to question 1 – I checked which CPU governor runs on Opensuse Leap 42.1:
It is indeed the good old (ACPI-based) “ondemand” governor – and not the “new” intel_pstate based “powersave” governor for Intel’s HWP. So, the findings
described above raise some questions regarding the behavior of the “intel_pstate based “powersave” governor vs. comparable older CPU_FREQ solutions like the “ondemand” governor: The intel_pstate “powersave” governor does not seem to support md-raid as well as the old “ondemand” governor did!

I do not want to speculate too much. It is hard to measure details of the CPU frequency changes on small timescales, and it is difficult to separate the cpu consumption of fio and the md-modules (which probably work multithreaded). But it might be that the “ondemand” governor provides on average higher CPU frequencies to the involved processes over the timescale of a fio run.

Anyway, I would recommend all system admins who use SSD-Raid-arrays under the control of mdadm to check and test for a possible performance dependency of their Raid installation on CPU governors!

 

SSD Raid Arrays unter Linux – VII – problematische Aspekte von Raid-5-Arrays

Posted on by

In früheren Artikeln dieser Serie

SSD Raid Arrays unter Linux – III – SW- Raid vs. Intel-iRST-Raid – Performance?
SSD Raid Arrays unter Linux – V – SW-Raid vs. iRST-Raid – Boot-Unterstützung?
SSD Raid Arrays unter Linux – VI – SW-Raid vs. iRST-Raid – Flexibilität?

hatte ich am Beispiel des Intel Z170 RST Controllers ausgeführt, dass es auf einem reinen Linux-System für Raid-Setups nicht notwendig ist, iRST-Technologie zu benutzen. Man betreibt den Intel-Onboard-Controller besser als einfachen SATA3-Controller und nicht als iRST-Raid-Controller. Die (SSD)-Raid-Arrays baut man sich dann lieber mit Hilfe von mdadm als Linux-SW-Raid-Arrays. Man gewinnt dadurch an Flexibilität, hat keine Performance-Nachteile und kann sogar – wenn nötig – eine Linux-OS vom Array booten.

Bei Einsatz eines SW-Raid-Arrays für SSDs ist unter Linux allerdings ein wenig Umsicht angebracht. U.a. stellt sich die Frage nach der Wahl der Raid-Variante. In meinem Fall für vier SSDs. Da liegen als grundsätzliche Alternativen etwa Raid-10- oder Raid-5-Arrays nahe.

In diesem Beitrag möchte ich zwei Argumente dafür anführen, dass die Wahl eines Raid-5-Arrays nicht unbedingt die beste Entscheidung ist – und zwar

  • trotz des größeren nutzbaren Netto-Platzes auf dem SSD-Raid-Array
  • und trotz der im sequentiellen Read-Bereich für große Datenpakete besseren Performance.

Die Argumentation hat mit der Resynchronisation des Raid-Arrays nach einem Plattenausfall, der relativ schlechten Performance von Random-Write-Prozessen für kleine Datenpakete und der Nichtausführbarkeit des “fstrim”-Befehls zu tun (Stand Nov. 2016).

Nachtrag 14.06.2017:
Von all diesen Punkten ist der letzte derjenige, der sich am einfachsten überprüfen lässt. Zum zweiten Punkt werde ich bei Gelegenheit Daten nachliefern. Bzgl. des ersten Punktes bin ich mir inzwischen nicht mehr sicher, ob ich wirklich alle Einflussfaktoren verstanden habe. Ich habe den Artikel heute abgeändert; er spiegelt nun meine aktuelle Einschätzung wieder.

Was sprach im HDD-Zeitalter gegen Raid-5- oder Raid-6-Arrays?

Raid-5-Arrays stellten schon zu HDD-Zeiten ein Problem dar. Zu nennen war/ist hier aus meiner Sicht an erster Stelle der erhebliche Zeitbedarf zur Rekonstruktion eines degraded Raid-5- oder Raid-6-Arrays.

Ein degradiertes Array kann z.B. aufgrund des Ausfall einer Platte wegen echten HD-Defekten oder aber wegen einer losen SATA-Verbindung (ist mir schon passiert!) zu Stande kommen. Eine Degradierung kann aber durch einen ernsten Fehlers des Linux-Systems ausgelöst werden. Ja, letzteres kommt ab und zu auch mal unter Linux vor! Probleme gibt es u.U. auch dann, wenn Inhalte von Schreib-Caches bei einer Systemstörung nicht rechtzeitig auf alle Platten geschrieben werden konnten. Die Raid-SW muss nach einer Systemstörung mit Reboot u.U. eine Rekonstruktion betroffener Arrays vorschlagen, um wieder auf die sichere Seite zu kommen.

Überlebenswichtige Paritätsinformation muss dann wieder hergestellt werden; fehlerhafte Informationen auf der betroffenen Platte sind neu zu synchronisieren.

Statt Rekonstruktion spricht man oft auch von einer “Resynchronisierung” oder “Rebuild” eines Raid-Arrays. Ich verwende diese Ausrücke nachfolgend synonym.

Extrem lange Resynchronisationszeiten für Raid-Arrays mit mehreren Terrabyte an Kapazität gab es vor allem dann, wenn man die Zeitanteile für Rekonstruktionsaufgaben im Raid-
Controller oder aber in der Linux-SW zugunsten der produktiven Performance operativer Prozesse (also für den laufenden Alltagsbetrieb) reduzieren musste. Die Rekonstruktion eines Raid-5-Arrays konnte dann schon mal etliche Stunden in Anspruch nehmen. In dieser Zeit lebte man immer mit der Gefahr weiterer Ausfälle.

Resynchronisation von SW-Raid-Arrays mit SSDs

Nun sind SSDs ja sehr viel rascher als konventionelle HDDs. Aus diesem Grund sagten einige Systemadministratoren in Internet-Foren sogar eine Renaissance für Raid-5-Arrays voraus. Der Optimismus ist in der Praxis tatsächlich nachvollziehbar: Setzt man die Priorität für eine Raid-5-Resynchronisierung auf Mittelwerte, so liegen die Zeiten für ein 1TB-Array deutlich unter einer Stunde. Das ist aus meiner Sicht OK. Hinzu kommt bei Raid-5 ja die bessere Netto-Plattenplatzkapazität für Nutzdaten im Vergleich zu einem Raid-10-System.

Welche Faktoren beeinflussen die Resynchronisation eines Raid-5-Arrays?

Es erscheint klar, dass nach einem Verlust von Redundanz ggf. zwei Dinge notwendig sind:

  • Wiederherstellen von Information auf der ausgefallenen Platte/Partition bei einem Timeout oder auf einer Ersatz-Platte/Partition nach Totalausfall.
  • Erneutes Herstellen der Redundanz durch Berechnung und Schreiben valider Parity-Informationen.

Verkompliziert wird der Rekonstruktionsvorgang, wenn das Raid-5 Array im degradierten Zustand aktiv weiter betrieben wird oder betrieben werden muss. Zudem stellt sich die Frage, was die Ursache des Redundanzverlustes war und ob die ausgefallene Platte (oder Partition) aufgrund eines Defekts ersetzt werden muss – oder aber, ob die ursprünglich vorhandene Platte aus irgendwelchen Gründen nur einen vorübergehenden Timeout hatte, und weiterverwendet werden kann. Ein solcher Timeout kann z.B. durch ein locker sitzendes SATA-Kabel verursacht worden sein. Letzteres ist mir tatsächlich passiert (s.u.)!

Fall 1: Notwendiger Ersatz einer Platte/Partition nach einem Defekt
Dieser Fall ist logisch am einfachsten zu überblicken. Daten und Paritity-Informationen müssen dann auf der neuen Platte/Partition vollständig neu geschrieben werden.

Dazu muss der gesamte (!) Datenvorrat sukzessive von den verbliebenen Platten ausgelesen werden, über die noch vorhandenen Parity-Daten ist die verlorengegangene Information über Berechnungen zu rekonstruieren, der fehlende Datenanteil ist auf die neue Platte/Partition zuschreiben, Redundanz ist durch Berechnen und Schreiben neuer Parity-Information auf die neue Platte/Partition herzustellen. Das ist ein aufwändiger Vorgang, der die alten, noch funktionierenden Platten des Arrays enorm stresst, CPU kostet und vor allem viele Schreibvorgänge auf der neuen Platte/Partiton nach sich zieht.

Der ganze Prozess ist deshalb zwangsläufig langsam – es ist klar, dass ein weiterer Betrieb des degradierten Arrays nur mit schlechter Performance möglich sein wird. Die Wahrscheinlichkeit, dass eine weitere Platte im Rekonstruktionsprozess ausfällt, ist wegen der vielen Zugriffe nicht vernachlässigbar. Das Schreiben neuer Daten während eines weitergeführten Betriebs muss zudem in den Datentransfers zur neuen Platte und bei zugehörigen Paritätsberechnungen berücksichtigt werden. Das ist ein Grund dafür, die Array-Rekonstruktion möglichst ohne operative Belastung durchzuführen.

Fall 2: Die alte Platte/Partition kann weiter verwendet werden
Tja, da wird es dann komplizierter. Nehmen wir mal an, wir machen dem Array die ausgefallene Partition wieder zugänglich. In der Zwischenzeit lief/läuft aber der operative Betrieb auf dem Array weiter. Ein paar entscheidende Frage sind dann:

Woher soll das System eigentlich wissen, welche Parity-Information seit dem Ausfall noch verlässlich ist? Welche Sektoren und Blöcke
waren vom Ausfall betroffen? Welche Informaiton wurde neu hinzugefügt? Wo hat das zwischenzeitliche Überschreiben von Daten die ursprüngliche Parity-Information verändert?

Für die betroffenen Blöcke muss die Daten- und Parity-Information ja in jedem Fall neu berechnet und die nunmehr ungültige Information auf der wieder eingehängten Platte ersetzen!

Das Schreiben neuer Information kann aber irgendwo im Filesystem und damit auf der Platte erfolgt sein! Kennt das System die betroffenen Sektoren und Datenblöcke nicht, muss es deshalb im Rekonstruktionsprozess zur Sicherheit alle Daten des degradierten Arrays mit den veralteten Informationen auf der wieder eingegliederten Platte vergleichen und ggf. korrigieren!

Es wird klar: Man braucht für solche Situationen eine Art “Logging” der Adressen modifizierter Datenbereiche.

Bitmaps!
Linux SW-Raid (mittels mdadm) sieht für diesen Zweck das Schreiben sog. “Bitmaps” als Option für Raid-Arrays mit Datenredundanz vor. Genauere Informationen erhält man hier: https://raid.wiki.kernel.org/ index.php/ Write-intent_bitmap.

Ich zitiere den wichtigsten Punkt:

“When an array has a write-intent bitmap, a spindle (a device, often a hard drive) can be removed and re-added, then only blocks changes since the removal (as recorded in the bitmap) will be resynced. Therefore a write-intent bitmap reduces rebuild/recovery (md sync) time if:
  – the machine crashes (unclean shutdown)
  -one spindle is disconnected, then reconnected.
If one spindle fails and has to be replaced, a bitmap makes no difference.”

Für das Anschalten einer “Bitmap” und damit des gewünschten “Loggings” steht eine mdadm-Befehlsoption zur Verfügung (s. für die mdadm-Praxis einen späteren Artikel).

Haben Bitmaps auch Nachteile?
Leider muss ich die Frage mit Ja beantworten. Im Artikel
SSD Raid Arrays unter Linux – III – SW- Raid vs. Intel-iRST-Raid – Performance?
hatte ich ja verschiedene Performancedaten zum Vergleich eines reinen (über mdadm angelegten) Linux-SW-Raid-10-Arrays mit einem iRST-Raid-10-Array präsentiert. Dabei wurden erhebliche Unterschiede in der Performance von mdadm-SW-Arrays festgestellt, die mit unterschiedlichen Parametern angelegt wurden:

Die festgestellte, um bis zu 30% schlechtere sequentielle Write-Performance gehörte zu Linux-SW-Arrays, bei denen im operativen Betrieb eine Bitmap mit geschrieben wurde!

Bitmaps kosten also Schreib-Performance – manchmal in signifikanter Weise. Wie hoch die Einbußen genau sind, hängt jedoch auch davon ab, ob man die Bitmap-Daten auf das Array selbst oder auf eine Partition einer separaten Platte außerhalb des Arrays schreibt. Wir werden auf entsprechende Effekte und Zahlen in späteren Artikeln zurückkommen.

Raid-5 mit einem Onboard-Sata3-Controller – Intel Z170 Sunrise Point – und iRST-Technologie

Wie sieht es mit der Rekonstruktion eines Raid-5-Arrays nun eigentlich im schlimmsten Fall aus? Ich schildere hierzu mal eines meiner Erlebnisse:

In meiner grenzenlosen Naivität begann ich bei der Einrichtung meines SSD-Testsystem zunächst damit, unter Einsatz von iRST ein “Raid 5”-Array aufzubauen. Die SSDs hingen dabei am “Sunrise Point”-Controller im Z170-Chipsatz des Mainboards. Nun ist ja bekannt, dass eine gerade Anzahl von Platten und Raid-5 nicht sonderlich gut zueinander passen. Für einen ersten Anlauf mit einem Raid-5-Array sprachen aus meiner Sicht aber folgende Punkte:

  • Bessere Nutzung der (relativ teuren) Plattenkapazität als mit Raid-10.
  • Optimierung vieler (Fake-)
    Raid-Controller auf die Nutzung von Raid-5.
  • Schlechte Erfahrungen mit Raid-10 auf 3ware-Controllern bei Random I/O.

Meine vier 500 GB-SSDs [Samsung EVO 850] wurden also zu einem Linux-SW-Raid-Array zusammengeschaltet; dabei wurden ca. 460 GB pro Platte effektiv genutzt. Zum Aufsetzen nutzte ich die UEFI-BIOS-Bordmittel für den Intel-Controller (iRST). Die resultierende Performance war wirklich überzeugend:

Ein Read-Durchsatz im sequentiellen Bereich um die 1.45 GB/sec und hohe sequentielle Schreibraten im Bereich von 1.1 GB/sec ließen mich zunächst nicht an meinem Vorgehen zweifeln. Hinzu kam – im Vergleich zu Raid 10 – die relativ hohe verfügbare Plattenkapazität (> 1,36 GB bei 4 EVO 850 500GB SSDs).

Das Betriebssystem hatte ich im ersten Anlauf dummerweise auch auf dem Raid-Array selbst installiert. Das kostet, wie bereits in einem früheren Artikel festgestellt, ca. 10% an Performance. Ich habe die Entscheidung für Raid-5 dann aber aus einem anderen Grund als vordergründigen Performance-Einbußen bereut.

Resynchronisation des Raid-5-Systems nach Ausfall einer Platte

Es geschah nämlich etwas, dass normalerweise nicht passieren sollte. Ich hatte ein SATA-Verbindungskabel nicht richtig gesteckt. Als das PC-Gehäuse dann mal bewegt wurde, löste sich das Kabel aus der SSD – mit dem Effekt, dass das Array in einen “degraded” Zustand überging. Kein Problem, dachte ich. Genau für solche Situationen hat man ja ein RAID-System. Ich ließ das Array danach wieder aufbauen – der Resynchronisierungsprozess wurde mit der entsprechenden iRST-Funktionalität des Controllers im BIOS aufgesetzt; die eigentliche Ausführung erfolgte dann im neu gestarteten Linux-System unter Kontrolle der “md-raid”-Module des Kernels. Insgesamt nahm das nicht so viel Zeit in Anspruch wie aufgrund vieler Internet-Artikel befürchtet. Ich habe die Zeit nicht gemessen, aber es dauerte, wie gesagt, sicher deutlich weniger als 1 Stunde.

Was mich dann allerdings schockte, war ein Blick auf den SSD-Zustand mit Hilfe des Kommandos smartctl. Ist Smart im BIOS aktiviert, so ist eine Zustandsüberprüfung einzelner SSDs (zumindest auf meinem ASRock-Board) sowohl bei Einsatz eines nativen Linux-SW-Raids als auch bei Einsatz von iRST-Raid-Containern möglich. Die durch den Ausfall betroffene SSD lief bei mir als Device “/dev/sdd”. Die übrigen Devices des Raid-5-Arrays unter /dev/sda, /dev/sdb, /devsdc. Unter den vielen ausgewiesenen Smart-Daten stelle ich nachfolgend nur die Anzahl der “Total_LBAs_written” nach dem Resynchronisationsprozess dar:

Total_LBAs_Written
sda : 604127952
sdb : 846533123
sdc : 603302987
sdd: 3763859973 !!!

Vor dem Resynchronisationsprozess befand sich der Wert für “/dev/sdd” dagegen auf dem Niveau von “/dev/sdc” – also < 603302987 !!

Dass der Basiswert auf “/dev/sdb” so hoch war, lag übrigens daran, dass auf diesem Device noch andere Tests zur Performance einer einzelnen SDD durchgeführt worden waren.
Nach vielen, vielen weiteren Testläufen und ca. 12 (!) immer neuen initialen Raid-10-Synchronisationen über 100 GB, 200 GB oder 400 GB umfassende (Raid-10-) Arrays sieht das heute (Nov. 2016) so aus:

Total_LBAs_Written
sda: 979783261
sdb: 1211867704
sdc: 995650995
sdd: 4121599736

Es ist offensichtlich, dass die eine Resynchronisations-Aktion für die Wiederherstellung des ehemaligen Raid-5(!)-Arrays über die gesamte Platte “/dev/sdd” hinweg geschrieben hat (Daten- und Paritätsinformationen). Gleichzeitig ging der Parameter “Wear_Leveling_Count” der vom Ausfall betroffenen Platte um 1 Prozentpunkt nach unten. Die Belastung der (vorher ausgefallenen) Platte durch den einen Raid-5-
Resynchronisationsprozess ist also substanziell gewesen!

Wie lässt sich der extreme Befund zur Schreibbelastung erklären?

Im Artikel
SSD Raid Arrays unter Linux – III – SW- Raid vs. Intel-iRST-Raid – Performance?
hatten wir eine relativ gute Schreib-Performance des iRST-imsm-Raid-Arrays festgestellt. Eine spätere Überprüfung brachte dann die Ursache zu Tage:

Die iRST-BIOS-Funktionen legen die imsm-Raid-Container grundsätzlich ohne “Bitmap” an!

Nächste Frage: Welche Auswirkungen hat denn das Fehlen einer Bitmap auf eine Resynchronisation? Eine Antwort finden wir in folgendem Artikel:
https://raid.wiki.kernel.org/ index.php/ Replacing_a_ failed_drive

Dort wird erläutert, dass man im Falle von Timeouts versuchen kann und sollte, die ausgefallene Platte/Partition einem Raid-Array wieder zur Verfügung zu stellen. Ich zitiere aus dem Abschnitt “So you have no redundancy!”:

“Before attempting to replace a failed drive, you should ALWAYS attempt to restore redundancy before replacing a drive. If the array is redundant, a replace will just copy the dodgy drive, only stressing the old drives if it can’t read the dodgy drive. If the array is not redundant, then adding a new drive will stress the entire array as it has to recreate the new drive from the remaining old drives. This is true even for a mirror.”

Und:

“If you have set up a bitmap on your array, then even if you plan to replace the failed drive it is worth doing a re-add. With a bitmap, the raid will know which sectors need writing, and will recover the array for you. You can then consider doing a replace of the faulty drive.
mdmad /dev/mdN –re-add /dev/sdX1
mdadm /dev/mdN –add /dev/sdY1 –replace /dev/sdX1 –with /dev/sdY1
If possible, do not mount the partitions on the raid (or do it read-only) while the rebuild takes place, to avoid undue stress on the array.
If you do not have a bitmap then don’t re-add the old drive unless it was a (now fixed!) timeout problem and you don’t intend replacing the drive. Without a bitmap, then the raid will treat it like a new drive and do a total rebuild.“

Aha! Der letzte Satz erklärt mein Erlebnis und bedeutet gleichzeitig:

Wenn schon Raid-5, dann bitte mit Bitmap!

Es ist eigentlich bemerkenswert, dass Intel für iRST-Raid-5-Arrays nicht automatisch die Anlage von Bitmaps vorsieht. Intel weiß wohl, dass die Schreibraten dann nicht mehr so werbewirksam wären!

Wie ist das Schreiben für eine Raid-5-Rekonstruktion – ohne Bitmap – im Vergleich zu einer normalen Plattenbelastung zu werten?

Zum Vergleich: Eine in einem anderen System seit 2 Jahren als Betriebssystemplatte mit virtuellen Maschinen im Dauereinsatz, aber nicht in einem Raid-Verbund befindliche Samsung EVO 840 Pro weist heute einen Wert von

Total_LBAs_Written
sdx: 7968906003

auf. Das ist also immer noch weniger als das Doppelte dessen, was mich eine einzige (!) Resync-Aktion einer Raid-5-SSD gekostet hat!

Wie oft muss man eigentlich mit einem Resync-Prozess rechnen?

Der oben genannte Artikel wiesen ja darauf hin, dass Crashes und unsaubere Shutdowns einen Rebuild-Vorgang für ein Array auslösen können. Machen wir uns nichts vor: Zumindest auf Linux-Desktop-Systemen kommt sowas öfter vor, als man sich das wünscht. Erst vor kurzem hatte ich mal einen Hänger des KDE-Plasma-Desktops auf meinem Testsystem. Das System war danach nicht mehr bedienbar. Ich befürchtete schon das
Schlimmste; der Filesystemzustand war zum Absturzzeitpunkt zwar fehlerhaft, der Plattenzustand über das Raid-Array hinweg aber noch konsistent. Das Filesystem-Fehler konnte nach einem Reboot ohne ein Raid-Rebuild korrigiert werden.

Aber dafür gibt es nun leider überhaupt keine Garantie – schon gar nicht im Falle eines Absturzes während eines intensiven Datentransfers (lesend und schreibend) zu dem Raid-5-Array. Ein inkonsistenter Zustand der Platten im Raid-System nach einem ernsthaften Systemfehler ist aus meiner Sicht dann eher wahrscheinlich. Und anschließend würde – bei fehlender Bitmap – vermutlich das gesamte Raid-5-System resynchronisiert werden.

Wie schaut es mit Raid-10 aus?

Ich habe für Tests in den letzten Monaten mehrfach Raid-10-Arrays angelegt und auch rekonstruiert. Die Wiederherstellung eines Raid-10-Arrays nach einem Timeout einer Platte erwies sich hinsichtlich der durchgeführten Schreiboperationen regelmäßig als relativ harmlos. Die Resynchronisation eines degradierten Raid-10-Array wird zudem erheblich (!) schneller als die eines gleich großen Raid-5-Arrays abgeschlossen.

Ein Grund liegt auf der Hand – im Falle von Raid-10 ist keine Paritätsinformation zu berechnen oder zu schreiben. Ich vermute ferner, dass im Zuge der Rekonstruktion nach einem Timeout möglicherweise nicht alle Daten, sondern lediglich abweichende, bereits genutzte und während des Timeouts geänderte Blöcke durch Schreibvorgänge abgeglichen werden. Das Prüfen auf Identität von Datenblöcken auf zwei Laufwerken lässt sich bei reiner Spiegelung ja relativ einfach und vor allem schnell durchführen.

Reichweite des TRIM-Befehls?

Ein wichtiger weiterer Punkt, der im Zusammenhang mit SSDs zu beachten ist, ist das Thema der sog. “Write Amplification” (s. https://en.wikipedia.org/ wiki/ Write_amplification). Ein Flash-Speicher muss vor einem Neubeschreiben erst gelöscht werden; das führt u.U. zu Verschiebungen von Speicherinhalten und mehrfachen Schreiboperationen. Das reduziert potentiell sowohl die Performance als auch die Lebenszeit von SSDs.

Neben den reinen Nutzdaten müssen im Normalbetrieb auf allen Platten eines Raid 5/6-Verbunds Paritätsinformationen geschrieben werden. Write Amplification (durch Verlagerung von Blöcken auf SSDs) trägt also gerade im Fall von Paritäts-Raids zusätzlich zu einer stärkeren Abnutzung der SSDs bei – gerade in kleineren Arrays (< 8 disks). Theoretisch ist aber die Anzahl der insgesamt durchzuführenden Schreiboperationen auch bei Raid-10 nicht kleiner als bei Raid-5. Insofern erscheint mir das Thema der Write Amplification als solches allein noch kein Argument für oder gegen Raid-5 oder Raid-10 zu sein.

Eine Konsequenz zur Aufrechterhaltung der Performance und zur Vermeidung von Zeitverlust durch Löschungen besetzter Blöcke bzw. durch das Suchen nach freien Blöcken auf der Platte ist aber, dass die Information über freie Knoten mit dahinterliegenden direkt beschreibbaren Speicherelementen regelmäßig upgedated werden muss. Das Filesystem muss den SSD-Controller – gemeint ist hier der Controller auf der SSD und nicht der Fake-Raid-Controller – über freigewordene, ungenutzte Speicherelemente informieren. [Der SSD-Controller muss mit den im Rahmen des (S)ATA-Protokolls übertragenen Information natürlich auch was anfangen können; letzteres ist heute praktisch bei allen Marken-SSDs der Fall.]

Unter Linux erledigt das der “fstrim“-Befehl für gemountete Partitionen: einerseits erfolgt dadurch die Weitergabe der Information zu freien Knoten; andererseits werden dann von den SSD-Controllern sog. “discard”-Operationen für logisch freigegebene Speicherelemente durchführt. Fortschrittliche Controllers sehen zudem regelmäßige Lösch- und Speicher-Reorganisationsverfahren auf den SSDs vor (SSD garbadge collection).

Nun können Betriebssystem und Raid-(Controlling)-SW in intelligenter Weise dazu beizutragen, um “Write Amplification” zu reduzieren. Hierfür sind meist Zwischenpufferungen von Operationen nötig. Siehe hierzu die interessanten Diskussionen unter

http://www.webhostingtalk.com/ showthread.php?t=1457939

http://cesg.tamu.edu/ wp-content/ uploads/2012/02/ hotstorage13.pdf

Aber:
Das Thema der Speicher-Freigabe und -Reorganisation bleibt unabhängig von der Anzahl der Schreiboperationen für SSD-Raid-Arrays bestehen. Somit stellt sich für die Auswahl eines bestimmten Raid-Verfahrens für SSDs auch die Frage, ob der “fstrim”-Befehl für die verschiedenen Raid-Varianten eigentlich durch die potentiell betroffenen Layer

Linux-Filesystem (z.B. ext4) – Logical Volume einer LVM-Gruppe – Array über Raid-Partitionen – Partitionen verschiedener SSDs

zu den Controllern der beteiligten SSDs durchgereicht wird.

Leider ist das gerade für Raid-5- oder Raid-6-Arrays nicht der Fall – weder im Falle von mdadm-SW-Raid-Arrays noch im Falle des Einsatzes von iRST-Technologie und imsm-Raid-Containern. Ich erhalte bei entsprechenden Versuchen regelmäßig Meldungen, dass die zugrundeliegende Infrastruktur den fstrim-Befehl nicht unterstützen würde.

Auf meinen Test-Systemen konnte ich dagegen feststellen, dass der “fstrim”-Befehl an logische LVM-Volumes auf Raid-0-, Raid-1– und Raid-10-Arrays anstandslos durchgereicht wird – zumindest für ext4-Filesysteme. (Andere Filesysteme wie BTRFS habe ich nicht getestet; generell herrscht ja die begründete Meinung vor, dass EXT4 dem Verhalten von SSDs am besten entgegenkommt). Das gilt für reines SW-Raid unter mdadm wie auch für den Einsatz von iRST/imsm-Containern. (Diese Aussagen kann ich genau genommen im Moment nur für Opensuse-Leap 42.1/42.2 (Kernel 4.4) und ein Debian Jessie-Test-Systeme mit Kernel 4.7 treffen.)

D.h.: Potentielle Einschränkungen der Performance sind zumindest bei ext4-Filesystemen auf Raid-5-Arrays vorprogrammiert, wenn nicht der Plattencontroller selbst die Garbage Collection und Speicherreorganisation übernimmt. Tatsächlich konnte ich für ext4-Partitionen nach Durchführung von Tests, bei denen mehr als 40 % eines Filesystems beschrieben wurden, regelmäßig Performanceverbesserungen nach Absetzen eines fstrim-Befehls feststellen. Zwar keine weltbewegenden Änderungen, aber doch im 10% – 20%-Bereich. Einschränkungen der Performance tauchen mit dem Auffüllen einer Partition also mit hoher Wahrscheinlichkeit auf.

Nun wird und wurde von SSD-Herstellern und Kommentatoren im Internet oft angeführt, dass gerade größere SSDs, die für den professionellen Einsatz gedacht sind, selbst für eine regelmäßige Garbage Collection sorgen. Ich habe sowohl EVO 840 Pros und EVO 850 Pros mit 500GB Kapazität auf verschiedenen Systemen im Einsatz und setze ab und zu den fstrim-Befehl für eingerichtete Partitionen manuell ab. Die benötigten Zeiten zur Speicherreorganisation dauern für meine Gefühl relativ lange und betreffen manchmal etliche zig GB. Dabei werden offenbar auch echte Operationen auf den Disks durchgeführt. Das spricht aus meiner Sicht zumindest nicht für eine hohe Frequenz der automatischen Garbage Collection durch die SSD-Controller von Samsung. Das mag bei anderen SSDs jedoch anders sein.

Aus meiner Sicht ist es daher empfehlenswert, vor dem produktiven Einsatz sicherzustellen, dass der fstrim-Befehl im angestrebten Raid-Verbund funktioniert.

Warnung von Red Hat vor dem Einsatz von SW-Raid-5 mit SSDs

Wie eine Recherche im Internet ergab, warnt(e) Red Hat vor dem Einsatz u.a. von Raid-5 für SSDs; s.

https://access.redhat.com/ documentation/ en-US/Red_Hat_ Enterprise_Linux/ 6/html/ Storage_Administration_Guide/ ch-ssd.html

https://access.redhat.com/ documentation/ en-US/ Red_Hat_Enterprise_Linux/ 7/html/ Storage_Administration_Guide/ ch-ssd.html

Zitat:

Red Hat also warns that software RAID levels 1, 4, 5, and 6 are not recommended for use on SSDs. During the initialization stage of these RAID levels, some RAID management utilities (such as mdadm) write to all of the blocks on the storage device to ensure that checksums operate properly. This will cause the performance of the SSD to degrade quickly.

Schlechte Schreibperformance von Raid-5 bei kleinen Datenpaketen?

Das anderes Argument gegen Raid-5 war die meist schlechte Performance für Random I/O-Bereich und dies vor allem bei einer kleinen Größe der stückweise zu schreibenden Datenpakete. Write-Caches einiger echter HW-Raid-Controller haben hier geholfen; der Einsatz eines Schreibpuffers ist aber – wie oben erläutert – auch mit Risiken verbunden; Batteriepuffer waren für dedizierte HW-Raid-Controller daher meist obligatorisch.

Eine vergleichsweise schlechte Performance attestieren viele Admins Raid-5-Arrays auch heute noch – selbst bei Einsatz von SSDs. Ich bin hier etwas vorsichtiger. Weder Raid-10 noch Raid-5 sind bei kleinen Datenpaketgrößen besonders schnell. Die Performance hängt aber auch stark von anderen Faktoren ab; u.a. von Raid-Array-Parametern, wie der Chunk Size, aber auch dem Lastprofil.

Um das Thema Performance Raid-5 vs. Raid-10 von SW-Raids unter Linux kümmere ich mich deshalb genauer in einem der kommenden Artikel. Bzgl. konkreter Zahlen muss ich den Leser deshalb noch vertrösten.

Fazit

Legt man die obigen Erfahrungen zugrunde, so läuft die Entscheidung zwischen Raid-10 und Raid-5 im Normalbetrieb auf

  • eine Abwägung von Performance-Vor- und -Nachteilen,
  • eine Bewertung des effektiv verfügbaren Plattenplatzes
  • und eine Bewertung des SSD-Verschleißes, der im Fall der Resynchronisation eines Degraded Raid-5-Arrays auftritt,

hinaus.

Man sollte ein Raid-5-Array aus meiner Sicht jedenfalls nicht ohne eine Bitmap betreiben. Das führt aber wieder zu zusätzlichen Schreibprozessen. Selbst wenn man die auf eine Platte außerhalb des Raid-Arrays verlagert, muss man den Overhead und den resultierenden Durchsatz testen. Diese separate Platte muss hinreichend schnell ansprechbar sein und sollte nicht die native und hohe Schreibperformance eines Raid-5-Arrays ohne Bitmap beeinträchtigen. Sequentielle Schreibraten von > 1GB/sec sind auf einem Raid-5-Array mit Consumer-SSDs durchaus möglich; auch wenn die Menge der Bitmap-Daten im Vergleich zur Menge der Realdaten relativ klein sein sollte – die Schreibrate dafür muss zum Gesamtdurchsatz passen. Man würde vermuten, dass das besonders bei kleinen Datenpaketen problematisch wird.

Hinzu kommen potentielle Performance-Einbußen durch ein fehlendes Weiterreichen des fstrim-Befehls an Filesysteme auf Raid-5-Arrays. Das relativiert die Performance-Vorteile beim Lesen, die ein Raid-5-System gegenüber einem Raid-10-System für sequentielles Schreiben aufweist, etwas. Zudem gilt:

Wer aus irgendwelchen Gründen eine verbesserte Lese-Performance unter Raid 10 anstrebt, kann auch mal das Far-Layout oder ein Near/Far-Layout des Raid10-Arrays ausprobieren. Das Far-Layout geht allerdings zu Lasten der Schreibperformance – und dies besonderes für Random I/O. Aber Raid-5 ist gerade für häufigen Random I/O kleinerer zu schreibender Datenmengen noch weniger performant.

Insgesamt erschien/erscheint mir das Aufsetzen eines Raid-5-Arrays doch ein
ziemlicher Balanceakt zu sein. Ich befasse mich in den kommenden Artikeln daher zuerst mit Raid-10-Arrays.

Ausblick

Im nächsten Beitrag
SSD Raid Arrays unter Linux – VIII – Setup von Raid-10-Arrays mit mdadm
gehe ich endlich ein wenig mehr auf praktische Schritte ein. Diskutiert wird dort die Anlage und Parametrierung eines SW-Raid-10-Arrays mit Hilfe von mdadm.

Interessante Links

https://www.thomas-krenn.com/ de/wiki/ ATA_Trim

https://wiki.debian.org/ SSDOptimization

http://cesg.tamu.edu/ wp-content/ uploads/2012/02/ hotstorage13.pdf

https://en.wikipedia.org/ wiki/Write_amplification

http://www.webhostingtalk.com/ showthread.php?t=1457939

http://serverfault.com/questions/ 513909/ what-are-the-main-points-to-avoid-raid5-with-ssd

https://lowendtalk.com/ discussion/ 10000/ don-t-build-ssd-in-raid5

https://www.reddit.com/ r/sysadmin/ comments/ 3m9req/ how_would_you_configure_ an_mdadm_raid_5_w_ssds/? st=ivpbg325&sh=a09d50fd

http://researchweb.watson.ibm.com/ haifa/ conferences/ systor2011/ present/ session5_talk2_systor2011.pdf

http://superuser.com/ questions/ 461506/ intel-matrix-storage-manager-vs-linux-software-raid

Bzgl. der grundsätzlichen Einstellung von LVMs und des Absetzens von TRIM-Anweisungen im Kontext von LVM-Operationen siehe etwa:
http://blog.neutrino.es/ 2013/ howto-properly-activate-trim-for-your-ssd-on-linux-fstrim-lvm-and-dmcrypt/

Near/Far-Layout füe Linux SW-Raid-10
http://www.ilsistemista.net/ index.php/ linux-a-unix/ 35-linux-software-raid-10-layouts-performance-near-far-and-offset-benchmark-analysis.html?start=1

Bitmaps
http://www.tutorialspoint.com/ unix_commands/ mdadm.htm

 

SSD Raid Arrays unter Linux – VI – SW-Raid vs. iRST-Raid – Flexibilität?

Posted on by

Wer für ein Desktop-System oder einen kleinen Server ein Raid-Array aufbauen will, kann dafür (nach einer Risiko-Analyse) ggf. den Onboard-SATA3-Controller des Mainboard-Chipsatzes nutzen. Auf Intel-Chipsätzen findet man dann Controller vor, die das Einrichten von Arrays mit Hilfe der iRST-Technologie erlauben. Darauf bin ich im früheren Beitrag

SSD Raid Arrays unter Linux – III – SW- Raid vs. Intel-iRST-Raid – Performance?

dieser Blog-Post-Serie bereits genauer eingegangen. Zusammen mit einem weiteren Artikel

SSD Raid Arrays unter Linux – V – SW-Raid vs. iRST-Raid – Bootunterstützung?

hatte ich dann erläutert, dass wir unter einem aktuellen Linux-Betriebssystem auch gut ohne Intels iRST-Technologie für die Konfiguration von Raid-Arrays auskommen können.

Der Einsatz von iRST ist auf einem reinen Linux-System weder aus Performance-Gründe noch aus Gründen einer hinreichenden Boot-Unterstützung erforderlich. iRST ändert ferner nichts am Faktum, das z.B. eine Z170-Sunrise-Point-Controller von Intel letztlich als kostengünstiger Fake-Raid-Controller betrieben wird.

In diesem Artikel möchte ich einen weiteren Aspekt gegen den Einsatz von iRST unter Linux ins Spiel bringen – nämlich eine begrenzte Flexibilität. Daneben gibt es aus meiner Sicht noch ein paar weitere erwähnenswerte Nachteile.

CLI vs. “komfortable” BIOS-Funktionen?

Linux-SW-Raids werden in der Regel mit Hilfe von mdadm-Kommandos über die Command Line eingerichtet, iRST-Arrays dagegen über EFI-BIOS-Funktionen oder aber eben auch über “mdadm”. Siehe: https://www.intel.com/content/dam/www/public/us/en/documents/white-papers/rst-linux-paper.pdf.

Einige Betriebsysteme bieten für die Einrichtung von Arrays auch grafische Hilfsfunktionen an – unter Opensuse etwa dem YaST-Partitioner. Die Status-Überwachung beider Arrays erfolgt im laufenden Betrieb mit Hilfe von mdadm (mit bestimmten Optionen) und einen Blick ins Verzeichnis “/proc/mdstat”; für imsm-Metadatencontainer gibt es auch das CLI-Kommando “mdmon”. Aber wer unbedingt grafisch arbeiten muss, der findet eine (begrenzte) mdadm-Unterstützung im Tool “webmin”.

Manch einer mag ja das Anlegen und ggf. die Rekonstruktion von Raid-Arrays über BIOS-Funktionalitäten für bequem halten. Ich sehe das nur begrenzt so. Ein Linux-Admin wird sich durch den Einsatz der Kommandozeile nicht abschrecken lassen. Zumal mdadm ein feingranulareres Arbeiten ermöglicht. Einen kleinen “Kurs” zu mdadm bietet übrigens die Seite https://www.tecmint.com/understanding-raid-setup-in-linux/.

Zudem hilft einem im laufenden Betrieb das BIOS gar nichts. Ferner ist eine Raid-Rekonstruktion über BIOS-Funktionen typischerweise langsamer als über ein laufendes Betriebssystem. Hier kommt das zum Tragen, was ich bereits im Artikel

herausgearbeitet hatte: Im Schadensfall (degradiertes Raid-Array) benötigt man zur Reparatur und zur laufenden Überwachung ein funktionierendes OS auf einer separaten Platte! Der Rückgriff auf BIOS-Funktionalitäten ist dann überflüssig. Das gilt für imsm-Raid-Arrays wie für mdadm-Raid-Arrays!

mdadm bietet für Linux-SW-Raid-Arrays mehr Möglichkeiten als iRST für imsm-Container

Bei Einsatz von iRST und imsm-Containern geht einem im Vergleich zu den Konfigurationsmöglichkeiten von nativen SW-Raid-Arrays über “mdadm” viel Flexibilität verloren. Das sollte man in der Praxis nicht unterschätzen:

So
lässt iRST nur genau 2 Raid-Arrays (Volumes) per Container zu – und der zweite anzulegende Verband kann dann in seiner Kapazität nicht mehr begrenzt werden. Er wird vielmehr den gesamten verbliebenen Platz der bereits einander zugeordneten Container Platten beanspruchen. Das ist eine massive Einschränkung.

“mdadm” unter Linux erlaubt dagegen die Erstellung beliebig vieler, in ihrer Größe definierbarer SW-Raid-Arrays über Partitionen gleicher oder unterschiedlicher SSDs hinweg. Dabei werden dann auch solche exotischen, aber performancesteigernden Dinge wie etwa ein Raid 10 über Partitionen von nur 2 SSDs möglich! Typ und Kapazität eines jeden einzelnen Arrays dürfen dabei im Rahmen der Größe der genutzten Rohpartitionen frei festgelegt werden.

Alle gängigen Typen an Raid-Konfigurationen werden dabei unterstützt. Gerade für Raid-10-Konfigurationen gibt es jedoch im Detail eine Vielzahl von verschiedenen Layout-Möglichkeiten für das Array, die es unter iRST nicht gibt. Diese Optionen erlauben einem eine weitere Optimierung für spezielle Einsatzszenarien. Siehe hierzu etwa:
http://www.ilsistemista.net/index.php/linux-a-unix/35-linux-software-raid-10-layouts-performance-near-far-and-offset-benchmark-analysis.html?start=1
Ich selbst komme darauf aber in einem weiteren Artikel zurück.

Potentielle Folgen von iRST-Einschränkungen bzgl. der Volume-Größe

Die fehlende Freiheit bzgl. der Größenbegrenzung des zweiten imsm-Volumes hat unter iRST bei bestimmten Raid Levels, besonders aber im Fall von großen Raid-5- oder Raid-6-Arrays erhebliche Auswirkungen für evtl. Wiederherstellungsverfahren:

Legt man zwangsweise ein zweites imsm-Volume mit großer Kapazität an, so wird das iRST-Raid-Volume bei irgendwelchen Problemen mit darauf aufgesetzten Filesystemen immer als Ganzes einer Resynchronisation unterworfen. Das passiert z.B. nach unsauberen Shutdowns, bei denen Filesysteme des Raid-Verbandes nicht mehr abschließend mit Caches synchronisiert werden konnten. Fällt gar eine Platte aus, wird der gesamte Container mit beiden Arrays rekonstruiert.

Das kostet bei allen Raid-Formen erhebliche Zeit – vor allem aber für Raid 5/6-Arrays. Die SSD-Geschwindigkeit hilft hier zwar, aber bei großen Arrays mit > 1 TB Kapazität zehrt das im Falle von Raid 5 trotzdem an den Nerven. Zudem wird im Falle von RAID 5 dabei der Verschleiß der eingebundenen SSDs erheblich beschleunigt. Mehr dazu im nächsten Beitrag.

Flexible Größenänderung angelegter Arrays?

Die Größe eines definierten iRST-Raid-Volumes kann im Nachhinein nach meiner Erfahrung weder durch Partitionsausweitung noch durch das Hinzufügen von weiteren Partitionen verändert werden. Bei einem reinen SW-Raid-Array unter Linux ist beides aber über ein paar Zwischenschritte möglich (s. hierzu die mdadm-Literatur; u.a. https://raid.wiki.kernel.org/index.php/Growing und https://www.howtoforge.com/how-to-resize-raid-partitions-shrink-and-grow-software-raid).

Für einen imsm-Container ist mir das bislang mit Linux-Bordmitteln dagegen nicht gelungen. So war es mir u.a. nicht möglich, auf Platten, die bereits einem iRTS-Verband im “imsm”-Format zugeordnet waren, neue Partitionen anzulegen, die ich einem bereits definierten imsm-Raid-5-Volume hätte zuordnen können.

Flexibilität bei Ausfall des Controllers?

Gerade beim Aufbau eines Server-Systems muss man sich fragen: Was geschieht eigentlich, wenn der Controller selbst ausfällt? Ein solcher Ausfall kann, muss aber nicht zum Austausch des gesamten Mainboards führen. Das ist in der Regel immer noch sehr viel billiger
als ein HW_Raid-Controller. Eine Frage ist aber: Kann man in der Zwischenzeit die Raid-Platten zur Not auch an ein anderes Linux-System anschließen und die wichtigsten Daten auf andere System transferieren? Unter der Voraussetzung, dass das Array überhaupt noch lauffähig ist?

Nun, da bin ich im Fall von imsm-Containern unsicher. Im schlimmsten Fall benötigt man ein neues Mainboard-Board mit iRST-Funktionalität, um wieder an die Daten des Arrays zu kommen. Andererseits unterstützt mdadm ja auch imsm-Container … Ich weiß es schlicht nicht – und habe ein solches Ausfallszenario mit iRST/imsm-Containern bislang nicht getestet. Was man aber mit Sicherheit sagen kann, ist Folgendes :

Im Falle eines Linux-SW-Raid-Arrays kann man ein funktionstüchtiges Array auch auf einem anderen Linux-System zum Laufen bringen, wenn die Platten denn physikalisch an einen dortigen Controller angeschlossen werden können. Man hängt die SSD-Platten an den dortigen SATA-Controller,l bootet, aktiviert die md-Raid Module und nutzt ein Plattenverwaltungssystem seiner Wahl – und schon hat man – ggf. nach einer Rekonstruktion des Arrays – wieder Zugriff auf seine Daten.

Zwischenfazit

Ich finde, allein die mangelnde Flexibilität von iRST bei der Definition mehrerer Raid-Arrays mit selbst festgelegter Größe ist ein guter Grund, auf den Einsatz von iRST unter Linux zu verzichten.

Weitere Gründe, die gegen den Einsatz des iRST auf reinen Linux-Systemen sprechen, findet ihr übrigens hier:
http://superuser.com/questions/461506/intel-matrix-storage-manager-vs-linux-software-raid
Siehe dort auch die interessante Diskussion des Themas.

Verbleiben eigentlich noch Gründe für den Einsatz des iRST?

Mir fallen dazu nur noch folgende Punkte ein:

  • Die Restaurierung bzw. Resynchronisation eines defekten Raid-Verbunds mit einer Ersatz-SSD lässt sich zur Not auch unabhängig vom Betriebssystem – nämlich über BIOS-Funktionen – durchführen. Dies ist im Besonderen dann zu bedenken, wenn man das Betriebssystem selbst auf einem Raid-Array bzw. imsm-Volume und/oder die EFI-Boot-Partition in einem imsm-Container installiert hat.
  • Auf Dual-Boot-Systemen (mit Windows) bringt das Intel-spezifische “imsm”-Format Vorteile. Der Raid-Verbund selbst und entsprechend formatierte Partitionen können dann auch direkt unter MS Windows angesprochen werden.

Der letzte Punkt kann auf Dual-Boot-Systemen tatsächlich einige Bedeutung haben. Die eigentliche Frage ist hier jedoch: Braucht man zwingend eine Dual-Boot-System für den Einsatz von MS Windows? Nun, das wird meist wohl von Kundenwünschen abhängen. Für mich selbst gilt jedenfalls:

Wenn man als Linuxer schon in die Untiefen von MS Windows-Systemen abtauschen muss, dann über Virtualisierung. Etwa über VMware (wenn man unbedingt eine wenig 3D-Effekte unter MS Win sehen will), Virtualbox oder KVM. Und bzgl. Performance des Zugriffs auf virtualisierte “Platten” (bzw. entsprechende Container-Files) gilt dann:

Man kann das virtualisierte Windows ja gerade auf einer Partition eines Linux-SW-Raid-Arrays zum Laufen bringen, wenn man die Disk-Perfromance in die Höhe treiben muss. Das klappt nach meiner Erfahrung sehr gut! Ein Win 7-System, das unter VMware läuft, weist einen Leistungsindex mit 7.9 Punkten von 7.9 möglichen Punkten für seine virtualisierte Platte aus. Diese “Platte” besteht aus einem “vdmk”-Container-File, das auf einer ext4-Partition eines Linux-SW-Raid-Arrays mit SSDs untergebracht wurde. Die ext4-“Partition” wurde dabei auf einem LVM-Volume angelegt. Einen noch besseren Durchsatz würde ich für einen direkten Durchgriff auf eine NTFS-Partition auf dem Array erwarten.

Ausblick

Unsere Artikelserie zu SSD-Raid-Arrays hat bislang ergeben, dass wir uns für kleinere
Linux-Systeme auf SW-Raid (unter mdadm) konzentrieren sollten. Will man einen Onboard-Controller von Intel benutzen, so kann und sollte man auf den Einsatz von iRST gut verzichten.

Eine weitere wichtige Frage ist nun: Welche Raid-Variante ist für SSD-Arrays sinnvoll? Nach meiner Einschätzung ist das vor allem eine Frage des Geldbeutels. Überraschenderweise spricht das ggf. gegen den Einsatz von Raid-5- oder Raid-6-Arrays. Das ist Gegenstand des nächsten Artikels dieser Serie:

SSD Raid Arrays unter Linux – VII – problematische Aspekte von Raid-5-Arrays

 

SSD Raid Arrays unter Linux – IV – OS und Daten auf demselben Raid-Array ?

Posted on by

Im letzten Beitrag dieser Serie zu SSD-Raid-Arrays unter Linux

SSD Raid Arrays unter Linux – III – SW- Raid vs. Intel-RST-Raid – Performance?

hatte ich mich mit der Frage auseinandergesetzt, ob ein SSD-Raid-Array an einem Intel-Raid-Controller typischer aktueller Mainboards als iRST-Array oder nicht besser gleich als natives Linux-SW-Raid-Array erstellt werden sollte.

iRST bedeutet Intel Rapid Storage Technologie; wir hatten diese Technologie im letzten Artikel genauer beleuchtet. Aus Performance-Tests für sequentielle Read- oder Write-Zugriffe haben sich dabei keine Anhaltspunkte ergeben, die zwingend für den Einsatz der iRST-Technologie sprechen würden:

Ein natives Linux-SW-Raids mit dem gleichen Onboard-Controller im AHCI-Modus (!) liefert eine vergleichbare oder höhere Performance!

Nun könnte man aber noch Sorgen bzgl. der Boot-Unterstützung haben. Einige Leute werden ja mit dem Gedanken spielen, das Linux-Betriebssystem [OS] selbst auf dem zu konfigurierenden Raid-Array zu installieren.

Ich möchte diesen Wunsch nachfolgend zunächst kritisch hinterfragen, da die Platzierung des OS auf einem ggf. hoch belasteten Raid-Array zumindest einen zusätzlichen Komplexitätsgrad erzeugt. Im nächsten Blog-Beitrag sehe ich mir dann die Boot-Unterstützung genauer an.

Motive für die Installation des Betriebssystem auf einem Raid-Array?

Typische Motive für die Installation des Betriebssystems auf einer Partition des SSD-Raid-Arrays könnten sein:

Verbesserung der Ausfallsicherheit und potentieller Performance-Gewinn

Raid-10- oder Raid-5-Arrays können ja die Lese- und Schreibperformance eines Raid-Verbundes deutlich über die einer einzelnen SSD hinaustreiben! Bei angeblich guter Sicherheit gegenüber dem Ausfall einer einzelnen der beteiligten Platten! Warum das nicht nur für Datenzugriffe von Spezialanwendungen sondern gleich auch für normale operationale Lese- und Schreibzugriffe das Betriebssystems mit nutzen?

Aus meiner Sicht gilt jedoch :

Es gibt mehr gute Gründe gegen die Installation des OS auf einem Raid-Array für die Daten von Anwendungen als dafür. Auf gewöhnlichen Systemen empfiehlt sich eher eine Installation des OS auf einer separaten SSD. Auf Hochperformance-Systemen würde ich das OS zumindest auf einem anderen Array als einem High-Performance-Array für datenintensive Anwendungen anlegen.

Ich führe dafür nachfolgend ein paar Argumente an. Als Voraussetzung nehme ich ein Einsatz-Szenario an, in dem vor allem Datenzugriffe spezieller Anwendungen durch ein Raid-10- oder ein Raid-5-Array beschleunigt werden sollen. Das Raid-Array mit den zugehörigen Daten sei dabei einer regelmäßig hohen Belastung ausgesetzt. Wir nennen es nachfolgend “Last-Array”.

Das ist zwar eine spezielles Szenario; einige der angeführten Argumente sind jedoch auch in anderen Szenarien valide. Das gewählte Szenario zeigt zumindest auf, dass man über die Sinnhaftigkeit einer OS-Installation auf einem für Last ausgelegten Raid-Array nachdenken sollte.

Verbesserung der Ausfallsicherheit?

Aus meiner Sicht gilt ganz grundsätzlich:

Keine einzige Raid-Variante entbindet von regelmäßigen Backups!

Das liegt auf der Hand und ist für Zweifler so oft im Internet begründet worden, dass ich hier auf weitere Ausführungen verzichte.

Zu berücksichtigen ist ferner, dass die Wahrscheinlichkeit, dass gleich belastete SSDs in einem Raid-1/10/5-Verbund etwa gleichzeitig ausfallen werden, ziemlich hoch ist. Auf einem Raid-1, einem Raid-10- oder Raid-5-System darf genau nur eine Platte ausfallen. (Dass es bei Raid-10
Situationen gibt, in denen auch das noch verkraftbar ist, ändert nichts am Grundargument.) Da die Platten in solchen Raid-Verbünden einem in etwa gleichen Verschleiß ausgesetzt sind, wird auch ihr Lebensende etwa zum gleichen Zeitpunkt eintreffen – ggf. stirbt die zweite Platte noch während eines langwierigen Rekonstruktionsvorgangs. Bei einem nicht mehr rekonstruierbaren Raid-System muss man dann aber aber in jedem Fall auf Backups zurückgreifen können.

Ein Szenario mit dem OS auf einer separaten SSD oder einem separaten SSD-Array plus Backups ist demgegenüber also nicht unsicherer. Es reduziert aber die Komplexität und beinhaltet auch eine Lastentkopplung.

Komplexitätsreduktion und Lastentkopplung

Liegen das OS und das Root-Verzeichnis auf einer vom Last-Array separaten SSD bzw. auf einem separaten SSD-Array, so werden die Ausfallmöglichkeiten des Last-Arrays von denen der OS-SSD entkoppelt.

Zudem kommt es zu einer Entkopplung der Last und damit des Verschleißes: Ein hoher Verschleiß der SSDs des Last-Arrays für High-Performance-Anwendungen schlägt sich nicht 1 zu 1 auf die SSD oder das separate SSD-Array des OS nieder. Und ggf. vice versa.

Zudem werden die Strukturen einfacher und flexibler, auch wenn das zunächst nicht den Anschein hat: Nicht ohne Grund mountet man von Haus aus Datenpartitionen oder spezielle Anwendungspartitionen auf bestimmte Zweige des Verzeichnisbaums. Das ermöglicht separate Backups und im Fall von System-Upgrades bleibt die Datenhaltung völlig außen vor. Man denke etwa an Datenbank-Daten, imap-Daten, die Partitionen virtualisierter Systeme etc., die man ggf. auf dem Last-Array platziert hat.

Fällt das Last-Array aus oder degradiert, ist nicht das OS betroffen. Fällt dagegen die SSD des OS aus, kann man das Array sofort wieder auf das Rootverzeichnis eines OS auf einer Ersatz-SSD mounten.

Die Rekonstruktion eines Raid-Arrays erfordert ein laufendes Betriebssystem – eine schnelle Rekonstruktion ein OS auf einer separaten Platte!

Es ergibt sich ein weiterer Punkt, über den man nachdenken sollte:

Hat das Raid-System einen Schaden oder fällt es gar ganz aus, will man trotzdem zeitnah booten können. Die Rekonstruktion eines (SW-) Arrays und das Monitoring dieses Prozesses setzen meist ein laufendes Linux-System voraus. Es ist also durchaus sinnvoll, das OS auf einer separaten SSD oder einem separaten (kleinen) Raid-Array zu halten.

Das Betriebssystem selbst ist bei vernünftiger Partitionierung relativ klein; bei Ausfall der OS-Platte oder -Partition ist es auf einer separaten Ersatzplatte sehr viel schneller rekonstruiert als ein großes Raid-System insgesamt.

Die Rekonstruktion eines defekten degraded Raid-Arrays aus einem auf dem Raid selbst liegenden OS heraus dauert ggf. sehr lange: Eine von Haus aus schlechte Restaurierungs-Performance von z.B. Raid-5-Arrays würde durch den laufenden OS-Betrieb im beschädigten Raid-Verbund noch einmal verschlechtert. Laufende Schreibprozesse aus dem Betriebssystem interferieren mit der Array-Rekonstruktion und können über die heranzuziehenden Paritätsalgorithmen auch nur langsam an das (noch) beschädigte Raid-Array übertragen werden.

Performancegewinn für das Betriebssystem durch RAID?

Linux puffert den normalen Festplattenzugriff so gut, dass man aus meiner Sicht nicht zwingend ein SSD-Array für eine hinreichend gute Basisperformance des Linux-Systems benötigt. Das sieht für spezielle Anwendungen oder etwa einen hochbelasteten Fileservice ggf. anders aus. Für das Kern-OS und seine Platteninteraktionen selbst genügt eine einzelne SSD bei möglichst großem RAM jedoch völlig. Das gilt umso mehr, als gerade bei kleineren Datenpaketen die Raid-Performance je nach Parametrierung sich nur wenig von der perfromance einer SSD abheben mag. Ich werde auf diesen interessanten Punkt in späteren Artikeln zurückkommen.

Beeinträchtigung der Performance eines Last-Raid-Arrays durch ein dort installiertes OS?

Nach meiner bisherigen Erfahrung gilt:

Würde man das OS auf einer Partition eines vorgesehenen (Daten-) Raid-Arrays installieren, so hätte das spürbaren (!) Einfluss auf die Gesamt-Performance dieses Last-Array und dessen Latenz. Random I/O-Prozesse des OS interferieren dann mit denen der Anwendungsprozesse, die man ja eigentlich mit Hilfe des Raid-Systems performanter machen will. Ich habe im Mittel etwa 10% an Performance-Einbußen durch Tests von Arrays mit aktivem OS nachvollziehen können. Für Datenbankanwendungen wie Fileservices, die verschieden konfigurierte Last-Arrays nutzten.

Man sollte das auf seinen eigenen Systemen in jedem Falle überprüfen.

Separates Raid-System für das OS?

Die Frage, ob das OS auf einem (separaten) Raid-System liegen soll, hängt letztlich auch von der Anzahl erstellbarer Raid-Arrays (bzw. im Fall des iRST von der Anzahl separat erstellbarer Container) und damit vom Geldbeutel ab. Ich sehe für eine Installation des OS auf einem Raid-Array, das primär für performanten Daten-I/O bestimmter High-Performance-Anwendungen gedacht ist, keinen überzeugenden Grund. (Es sei denn, man möchte aus irgendwelchen Eitelkeiten heraus extrem schnelle Bootzeiten produzieren.)

Will man das OS aber aus Gründen einer verbesserten Ausfallsicherheit auf einem SSD-Array anlegen, dann bitte auf einem separaten Array (bzw. beim iRST: auf einem Volume eines separaten Containers); dieses Array sollte nicht auch gleichzeitig die Daten geplanter Hochperformance-Anwendungen beherbergen.

Unbestritten ist: Ein separates Raid-10-System mit ggf. hochwertigen Enterprise SSDs ist ein guter Ort für das OS eines Hochperformance-Systems – wenn man denn das dafür nötige Kleingeld hat.

Rücksichtnahme auf Lastprofile!

Ein Raid-System für ein OS erfordert aus Performancegründen ggf. eine andere Parametrierung als ein Last-Array für die Daten von Anwendungen mit einer ganz bestimmten Zugriffs-Charakteristik. Ein Lastprofil, das laufend durch kurze einzelne aufeinander folgende I/O-Spikes für kurze Datenblöcke (< 64KB) gekennzeichnet ist (OS oder bestimmte DB-Anwendungen), ist anders zu bewerten als ein Lastprofil, bei dem viele Jobs parallel große Datenpakete (> 1 MB) auf und von einem Raid-System befördern müssen (Fileserver) oder gar ein Profil, auf dem große Videodateien (> n x 10MB) sequentiell verarbeitet werden.

Entsprechend unterschiedlich sollten zugehörige Raid-Systeme konfiguriert werden. Ich komme darauf in weiteren Artikeln zurück. Auch dieser Punkt spricht für die Trennung des Last-Arrays von Arrays für das OS.

Lösungsansatz: Wie gehe ich persönlich vor?

Sieht man einmal von puren Performance ab, so ist aus den obigen Gründen in vielen Fällen ein Vorgehen sinnvoll, bei dem das OS samt Root-Filesystem auf einer vom Raid-Verband unabhängigen SSD liegt und das Last-Array auf ein Spezialverzeichnis gemountet wird. Zudem ist für eine hinreichende RAM-Ausstattung des Systems zu sorgen. Zu finanzieren ist ferner eine Ersatz-SSD.

Für dieses Vorgehen gilt:

  • Es reduziert Komplexität im Bootvorgang.
  • Es kann durch Einsatz einer weiteren Ersatz-SSD, die mit einer boot- udn laufenden OS-Installation versehen wird, gegen Ausfälle der OS-SSD abgesichert werden. Die Ersatz-SSD kann gegen Verschleiß weitgehend geschont werden; sie muss erst im Notfall mit einem aktuellen OS-Abbild aus einer Sicherung, die z.B. täglich auf konventionellen Medien (HDD) hinterlegt wurde, versehen werden. Ein solcher Transfer dauert heutzutage nur wenige Minuten. Tipp am Rande: Die Identifikation der OS-Platten im Boot-Loader in diesem Szenario eher konventionell, also neutral und nicht über eindeutige Device-IDs, vornehmen.
  • Eine
    eintretende Degradierung des Last-Arrays durch einen SSD-Ausfall betrifft nicht die Operabilität anderer Systembestandteile. Mit einem “degraded SSD-Spezial-Array” kann man sich dann kontrolliert von einem immer noch funktionierenden separaten OS aus befassen.
  • Die SSD für das OS sollte aber Enterprise-Qualität haben und seitens des Herstellers gegen schnellen Verschleiß gewappnet sein.

Käme es auf Geld nicht an, würde ich auf manchen Systemen dem OS und der Root-Partition ein eigenes Raid-10-Array spendieren.

Ausblick

OK – man hat schon gemerkt: Ich halte nicht viel davon, das OS auf einem Raid-Array für die Daten von Hoch-Performance-Anwendungen unterzubringen. Aber manch einer hat entweder so viel Geld, dass er sich ein separates, dediziertes SSD-Raid-Array für das Betriebssystem leisten kann. Oder manch einer ist aus anderen Gründen gzwungen, das OS im einzigen vorhandenen SSD-Raid-Array zu installieren (z.B. auf einem Laptop). dann stellt sich die Frage:

Wird das Booten eines OS in einem Linux-SW-Raid-Array überhaupt unterstützt? Oder ist man hier beim Einsatz von Mainboards mit Intel Chipsatz auf iRST angewiesen?

Darum dreht sich der nächste Artikel dieser Serie:
SSD Raid Arrays unter Linux – V – SW-Raid vs. iRST-Raid – Bootunterstützung?