<!DOCTYPE linuxdoctr system
[ <!ENTITY CurrentVer "0.90.6">
  <!ENTITY mdstat "<TT>/proc/mdstat</TT>">
  <!ENTITY ftpkernel "<TT>ftp://ftp.fi.kernel.org/pub/linux</TT>">
  <!ENTITY fstab "<TT>/etc/fstab</TT>">
  <!ENTITY raidtab "<TT>/etc/raidtab</TT>">

  <!ENTITY tCurrentVer "1.0">
]
>

<!-- This is the Linux Software-RAID HOWTO, SGML source -->
<!-- by Jakob 懴tergaard, jakob@ostenfeld.dk -->

<ARTICLE>

<TITLE>The Software-RAID HOWTO
<AUTHOR>Jakob &Oslash;stergaard
        (<htmlurl
        url="mailto:jakob@ostenfeld.dk"
        name="jakob@ostenfeld.dk">)
<DATE>v. &CurrentVer; 31st of October 1999
<trans>笠井 宗
	(<htmlurl
	url="mailto:kasai@heart-pot.co.jp"
	name="kasai@heart-pot.co.jp">)
<tdate>v.&tCurrentVer; 04 December 1999

<ABSTRACT>
<!-- 
This HOWTO describes how to use Software RAID under Linux. You must be
using the RAID patches available from <htmlurl
name="ftp://ftp.fi.kernel.org/pub/linux/daemons/raid/alpha"
url="ftp://ftp.fi.kernel.org/pub/linux/daemons/raid/alpha">. The HOWTO
can be found at <htmlurl
name="http://ostenfeld.dk/~jakob/Software-RAID.HOWTO/"
url="http://ostenfeld.dk/~jakob/Software-RAID.HOWTO/">.
-->
この HOWTO では、Linux で Software RAID を使う方法について記述します。まずは <htmlurl url="ftp://ftp.fi.kernel.org/pub/linux/daemons/raid/alpha" name="ftp://ftp.fi.kernel.org/pub/linux/daemons/raid/alpha"> から入手可能な RAIDパッチを入手する必要があります。HOWTO の原文は <htmlurl url="http://ostenfeld.dk/~jakob/Software-RAID.HOWTO/" name="http://ostenfeld.dk/~jakob/Software-RAID.HOWTO/"> にあります。

</ABSTRACT>

<TOC>

<SECT>
<!--
Introduction
-->
イントロダクション
<P>
<!--
This howto is written by Jakob &Oslash;stergaard based on a large
number of emails between the author and Ingo Molnar (<htmlurl
url="mailto:mingo@chiara.csoma.elte.hu"
name="mingo@chiara.csoma.elte.hu">) −− one of the RAID developers −−,
the linux-raid mailing list (<htmlurl
url="mailto:linux-raid@vger.rutgers.edu"
name="linux-raid@vger.rutgers.edu">) and various other people.
-->
<!-- SGML の規格上、コメント中に −−(の半角)を記述することはできないので、上記原文内の−−は全角に変更してあります。またこれより下でも同様の処理を行なっています（早川）-->

この howto は Jakob OEstergaard によるものです。著者と Ingo Molnar (<htmlurl
url="mailto:mingo@chiara.csoma.elte.hu"
name="mingo@chiara.csoma.elte.hu">) -- RAID 開発者のうちの 1 人 --、
Linux-RAID メーリングリスト(<htmlurl
url="mailto:linux-raid@vger.rutgers.edu"
name="linux-raid@vger.rutgers.edu">) と他の人々との間で交わされた多くの電子メールに基づくものです。
<P>
<!--
The reason this HOWTO was written even though a Software-RAID HOWTO
already exists is, that the old HOWTO describes the old-style Software
RAID found in the stock kernels. This HOWTO describes the use of the
new-style RAID that has been developed more recently. The new-style
RAID has a lot of features not present in old-style RAID.
-->
Software-RAID HOWTO がすでに存在するにもかかわらず、この HOWTO が書かれたのにはわけがあります。それは古い HOWTO では、普通のカーネルに既にある旧式の Software RAID についてしか書かれていないからです。この HOWTO は、より最近開発された新しいスタイルの RAID の使い方について記述してあります。新しいスタイルの RAID には旧式の RAID にはない、多くの機能があります。
<P>
<!--
The standard 2.2.X kernels does not have direct support for the
new-style RAID described in this HOWTO.  Therefore these patches are
needed.  The RAID support in standard 2.2.X kernels is buggy and lacks
several important features present in the new-style RAID software.
-->
標準の 2.2.X カーネルは、この HOWTO で記述される新しい RAID を直接サポートしていませんから、パッチが必要になります。標準の 2.2.X カーネルでの RAID サポートはバグが多く、新しいスタイルの RAID ソフトウェアにある重要ないくつかの機能が欠けています。
<P>
<!--
As of this writing, it seems likely that when the 2.4 kernel comes out
(hopefully around christmas 1999), it will have the new-style RAID
built in. But until then, the stable kernels must be patched manually.
-->
この執筆時点では 2.4 のカーネルが出る時には（希望的観測によると 今年 1999 年のクリスマス頃）、新しいスタイルの RAID が組み込まれそうです。しかしそれまでは、安定版カーネルに手でパッチを当てる必要があります。
<P>
<!-- 0.90.6 で追加
You might want to use the <TT>-ac</TT> kernel releases done by Alan Cox.
<EM>Some</EM> of those contain the new-style RAID, and that will save
you from patching the kernel yourself.
-->
Alan Cox の手による <TT>-ac</TT> カーネルを使いたいかもしれませんね。
それらの内、<EM>いくつかは</EM>新しいRAIDが含まれています。それなら、カーネルにパッチを当てる手間がはぶけます。
<P>
<!--
Some of the information in this HOWTO may seem trivial, if you know
RAID all ready. Just skip those parts.
-->
あなたが既に RAID について知っているなら、この HOWTO の情報にはつまらないものもあるかもしれませんが、そういう所は読み飛ばしてしまってください。
<P>

<SECT1>
<!--
Disclaimer
-->
Disclaimer／放棄声明
<P>
<!--
The mandatory disclaimer:
-->
無保証−
<P>
<!--
Although RAID seems stable for me, and stable for many other people,
it may not work for you.  If you loose all your data, your job, get
hit by a truck, whatever, it's not my fault, nor the developers'.  Be
aware, that you use the RAID software and this information at
your own risk!  There is no guarantee whatsoever, that any of the
software, or this information, is in anyway correct, nor suited for
any use whatsoever. Back up all your data before experimenting with
this. Better safe than sorry.
-->
RAID は私には安定しているように見えますし、他の多くの人々にとっても安定しているようですが、うまく動作しないかもしれません。あなたが全てのデータを失い、仕事を失い、トラックにはねられるような事になったとしても、それは私や開発者の責任ではありません。RAID ソフトウェアやこの情報は、あなた自身の責任（at your own risk）で利用してください。ソフトウェアにもこの情報にも一切の保証はありません。実験の前に、全てのあなたのデータをバックアップするように！転ばぬ先の杖です。
<P>
<!--
That said, I must also say that I haven't had a single stability
problem with Software RAID, I use it on quite a few machines with no
problems what so ever, and I haven't seen other people having problems
with random crashes or instability.
-->
断っておきますが、私自身は Software RAID の安定性に関する問題にあったことは一度もありません。ごく少数のマシンでしか私は使っていませんが、何の問題も起きていませんし、不可思議なクラッシュがおきたり、不安定だという人も見たことがありません。
<P>

<SECT1>
<!--
Requirements
-->
必要条件
<P>
<!--
This HOWTO assumes you are using a late 2.2.x or 2.0.x kernel with a
matching raid0145 patch, and the 0.90 version of the raidtools. Both
can be found at <HTMLURL
name="ftp://ftp.fi.kernel.org/pub/linux/daemons/raid/alpha"
url="ftp://ftp.fi.kernel.org/pub/linux/daemons/raid/alpha">. The RAID
patch, the raidtools package, and the kernel should all match as close
as possible. At times it can be necessary to use older kernels if raid
patches are not available for the latest kernel.
-->
この HOWTO では、最近の 2.2.x か 2.0.x カーネルに対応した raid0145 パッチを当てたものと、raidtools のバージョン 0.90 を使っていると仮定します。どちらも <htmlurl url="ftp://ftp.fi.kernel.org/pub/linux/daemons/raid/alpha" name="ftp://ftp.fi.kernel.org/pub/linux/daemons/raid/alpha"> で見つけられます。RAID パッチ、raidtools パッケージ、カーネルは、きちんと対応しているバージョンを使ってください。RAID パッチが最新のカーネルに利用できないならば、古いカーネルを使うように。
<P>
（訳注：日本国内からは <htmlurl url="ftp://ftp.jp.kernel.org/pub/linux/daemons/raid/alpha/" name="ftp://ftp.jp.kernel.org/pub/linux/daemons/raid/alpha/"> が利用できます。翻訳時点での最新版は、以下の通りです）
<verb>
RAID パッチ
  raid0145-19990824-2.0.37.gz
  raid0145-19990824-2.2.11.gz

raidtools
  raidtools-19990824-0.90.tar.gz
</verb>
<P>
<SECT>
<!--
Why RAID ?
-->
なぜ RAID なのか？
<P>
<!--
There can be many good reasons for using RAID. A few are; the ability
to combine several physical disks into one larger ``virtual'' device,
performance improvements, and redundancy.
-->
RAID を使うと良いことがたくさんあります。例えば、複数のディスクをより大きく「仮想的な」デバイスに結合する能力、パフォーマンス向上、そして冗長性です。
<P>

<SECT1>
<!--
Technicalities
-->
専門的事項
<P>
<!--
Linux RAID can work on most block devices. It doesn't matter whether
you use IDE or SCSI devices, or a mixture. Some people have also used
the Network Block Device (NBD) with more or less success.
-->
Linux RAID は、ほとんどのブロック型デバイス上で動作します。使用するハードディスクが IDE、SCSI、もしくは両者が混在していようと、それは重要な事ではありません。ネットワーク越し (Network Block Device - NBD) でうまくいったという報告さえあります。
<P>
<!--
Be sure that the bus(ses) to the drives are fast enough. You shouldn't
have 14 UW-SCSI drives on one UW bus, if each drive can give 10 MB/s
and the bus can only sustain 40 MB/s.
Also, you should only have one device per IDE bus. Running disks as
master/slave is horrible for performance. IDE is really bad at
accessing more that one drive per bus.  Of Course, all newer
motherboards have two IDE busses, so you can set up two disks in
RAID without buying more controllers.
-->
ドライブに対するバスの速度は充分に速い必要があります。各ドライブが 10 MB/s の能力があり、バス幅が 40 MB/s しかないような場合は、UW(UltraWide) バス 1 本に 14 台の UW-SCSI ドライブを接続するようなことはしない方がよいでしょう。また IDE バスなら、1 本のバスにデバイスは 1 台だけにするべきです。IDE ディスクをマスター／スレーブ構成にするのはパフォーマンスが悪くなります。IDE では1 台以上のドライブがあるバスに対するアクセスは良くありません。最近のマザーボードは、普通は 2 本の IDE バスを持っていますから、よけいなコントローラを買うことなしに 2 台のディスクで RAID を構成することができます。
<P>
<!--
The RAID layer has absolutely nothing to do with the filesystem
layer. You can put any filesystem on a RAID device, just like any
other block device.
-->
RAID レイヤは、ファイルシステムのレイヤとはまったく関係ありません。通常のブロックデバイスと同様に、RAID デバイスの上にはどんなファイルシステムでも構築できます。
<P>

<SECT1>
<!--
Terms
-->
用語
<P>
<!--
The word ``RAID'' means ``Linux Software RAID''. This HOWTO does not
treat any aspects of Hardware RAID.
-->
「RAID」という語は「Linux Software RAID」を意味するものとします。この HOWTO では Hardware RAID については扱いません。
<P>
<!--
When describing setups, it is useful to refer to the number of disks
and their sizes. At all times the letter <BF>N</BF> is used to denote
the number of active disks in the array (not counting
spare-disks). The letter <BF>S</BF> is the size of the smallest drive
in the array, unless otherwise mentioned. The letter <BF>P</BF> is
used as the performance of one disk in the array, in MB/s. When used,
we assume that the disks are equally fast, which may not always be true.
-->
装置構成について記述する場合には、ディスクの数とサイズの表記を決めておくと便利です。文字 <bf>N</bf> は、ディスクアレイ（予備ディスクを含まない）の中で、アクティブなディスクの数を示すものとします。文字 <bf>S</bf> は特に断らない限り、ディスクアレイの中で最も小さいドライブのサイズとします。文字 <bf>P</bf> はディスクアレイの中の1台のディスクのパフォーマンスを表し、単位は MB/s とします。この<bf>P</bf> を使う場合には、すべてのディスクが同等の性能だと仮定してますが、それは常に正しいとは言えないかもしれません。
<P>
<!--
Note that the words ``device'' and ``disk'' are supposed to mean about
the same thing.  Usually the devices that are used to build a RAID
device are partitions on disks, not necessarily entire disks.  But
combining several partitions on one disk usually does not make sense,
so the words devices and disks just mean ``partitions on different
disks''.
-->
「デバイス」と「ディスク」がほぼ同じ意味で使われている点に注意してください。通常、RAID デバイスを構築するために使われるデバイスはディスクのパーティションであり、必ずしもディスク全体である必要はありません。ですが 1 台のディスクの上でいくつかのパーティションを結合して RAID にしても意味をなさないので、デバイスとディスクは単に「異なるディスク上のパーティション」を意味するものとします。
<P>

<SECT1>
<!--
The RAID levels
-->
RAID レベル
<P>
<!--
Here's a short description of what is supported in the Linux RAID
patches. Some of this information is absolutely basic RAID info, but
I've added a few notices about what's special in the Linux
implementation of the levels.  Just skip this section if you know
RAID. Then come back when you are having problems   :)
-->
Linux RAID パッチでサポートされることを簡単に書いておきます。非常に基礎的な RAID の情報ですが、Linux における RAID レベルの実装で特別なものについては、多少記述してあります。RAID をよく知っている人はこのセクションをスキップしてください。なにか問題があったら戻ってくればいいのです :)
<P>
<!--
The current RAID patches for Linux supports the following
levels:
-->
現在の Linux 用 RAID パッチがサポートするのは以下の各レベルです−
<ITEMIZE>
<!--
<ITEM><BF>Linear mode</BF>
-->
<item><bf>リニアモード</bf>
<ITEMIZE>
<!--
<ITEM>Two or more disks are combined into one physical device. The disks
are ``appended'' to each other, so writing to the RAID device will fill
up disk 0 first, then disk 1 and so on. The disks does not have to be
of the same size. In fact, size doesn't matter at all here   :)
<ITEM>There is no redundancy in this level. If one disk crashes you will
most probably loose all your data.  You can however be lucky to
recover some data, since the filesystem will just be missing one large
consecutive chunk of data.
<ITEM>The read and write performance will not increase for single
reads/writes. But if several users use the device, you may be lucky
that one user effectively is using the first disk, and the other user
is accessing files which happen to reside on the second disk. If that
happens, you will see a performance gain.
-->
<item>複数のディスクが、1 台の物理的なデバイスに結合されるモードです。ディスクはお互いに「追加される」ので、RAID デバイスに書きこむと、最初にディスク 0 に、一杯になったら次にディスク 1 に、また一杯になったらディスク 2 に、と書き込まれることになります。各ディスクは同じサイズである必要はありません。サイズはここでは重要ではないのです :)

<item>このレベルには冗長性はありません。1 台のディスクがクラッシュすると、おそらく全てのデータを失う可能性があります。ですがファイルシステムからデータの大きなかたまりが抜け落ちるわけですから、運良く残った部分から若干のデータを回復できることも可能性としてはあります。

<item>読み書きのパフォーマンスは単独の read/write では向上しませんが、複数のユーザーがデバイスを使う場合、あなたが第 1 のディスクにアクセスしている瞬間に、他の誰かが第 2 のディスクにアクセスしているということが起こり得ます。そのような場合、パフォーマンスは向上します。
</ITEMIZE>
<ITEM><BF>RAID-0</BF>
<ITEMIZE>
<!--
<ITEM>Also called ``stripe'' mode. Like linear mode, except that reads and
writes are done in parallel to the devices. The devices should have
approximately the same size. Since all access is done in parallel, the
devices fill up equally. If one device is much larger than the other
devices, that extra space is still utilized in the RAID device, but
you will be accessing this larger disk alone, during writes in the
high end of your RAID device. This of course hurts performance.
<ITEM>Like linear, there's no redundancy in this level either. Unlike
linear mode, you will not be able to rescue any data if a drive
fails. If you remove a drive from a RAID-0 set, the RAID device will
not just miss one consecutive block of data, it will be filled with
small holes all over the device. e2fsck will probably not be able to
recover much from such a device.
<ITEM>The read and write performance will increase, because reads and
writes are done in parallel on the devices. This is usually the main
reason for running RAID-0. If the busses to the disks are fast enough,
you can get very close to N*P MB/sec.
-->
<item>「ストライプ」モードとも呼ばれます。リニアモードと似ていますが、読み書きが複数のデバイスに並列に行われるところが違います。各々のデバイスはほぼ同じサイズである必要があります。全てのアクセスが並列に実行されるので、複数のデバイスは全て同じように使われます。1 つのデバイスが他より飛び抜けて大きい場合、その特別のスペースは RAID デバイスとして使われますが、デバイスの終わりの方にアクセスするときには、このより大きいディスクだけにアクセスすることになり、当然パフォーマンスは悪化します。

<item>リニアモードと同様、このレベルにも冗長性はありません。リニアモードと違うのは、1 台のドライブが故障した場合でもあっても、一切のデータを救うことができないということです。RAID-0 からドライブを取り外すとすると RAID デバイスのある部分の連続的なブロックが欠落するというわけではなく、デバイスの至る所が小さい穴だらけになるといった感じでしょうか。多分 e2fsck はそのようなデバイスからほとんど何も回復することはできないでしょう。

<item>読み書きのパフォーマンスは向上します、読み書きはデバイス上で並列に実行されるからです。これが、通常 RAID-0 を走らせることの主な理由です。バスが充分に速ければ、パフォーマンスは N * P MB/s に近くなります。

</ITEMIZE>
<ITEM><BF>RAID-1</BF>
<ITEMIZE>
<!--
<ITEM>This is the first mode which actually has redundancy. RAID-1 can be
used on two or more disks with zero or more spare-disks. This mode maintains
an exact mirror of the information on one disk on the other
disk(s). Of Course, the disks must be of equal size. If one disk is
larger than another, your RAID device will be the size of the
smallest disk.
<ITEM>If up to N-1 disks are removed (or crashes), all data are still intact. If
there are spare disks available, and if the system (eg. SCSI drivers
or IDE chipset etc.) survived the crash, reconstruction of the mirror
will immediately begin on one of the spare disks, after detection of
the drive fault.
<ITEM>Read performance will usually scale close to to N*P, while write performance is
the same as on one device, or perhaps even less.  Reads can be done in
parallel, but when writing, the CPU must transfer N times as much data
to the disks as it usually would (remember, N identical copies of
all data must be sent to the disks).
-->
<item>これは実際に冗長性を持つ最初のモードです。RAID-1 は 2 台以上のディスクがあれば利用できます。予備のディスクを用意しておくこともできます。このモードは、1 台のディスクを他のディスクで正確にミラーするわけです。もちろん各ディスクは同じサイズでなければなりません。1 台のディスクが他より大きいとしても、RAID デバイスは最も小さいディスクと同じサイズになってしまいます。

<item>N-1 台までのディスクが取り外されても(または故障しても)、データはまだすべて完全です。利用できる予備ディスクがあり、システム（SCSI ドライバーや IDE チップセットなど）が生き残っている場合、ドライブ故障の発見後、直ちにミラーの再構築が予備ディスクのうちの 1 台で始まります。

<item>読み込みのパフォーマンスは N * P に近い値になりますが、書きこみはデバイスが 1 台の場合と同等以下になります。読み込みは並列動作できますが、書きこみでは CPU が N 回データを送らなければならないからです（N 個のデータの同一のコピーが各ディスクに送られなければならないのです）。

</ITEMIZE>
<ITEM><BF>RAID-4</BF>
<ITEMIZE>
<!--
<ITEM>This RAID level is not used very often. It can be used on three
or more disks. Instead of completely mirroring the information, it
keeps parity information on one drive, and writes data to the other
disks in a RAID-0 like way.  Because one disks is reserved for parity
information, the size of the array will be (N-1)*S, where S is the
size of the smallest drive in the array. As in RAID-1, the disks should either
be of equal size, or you will just have to accept that the S in the
(N-1)*S formula above will be the size of the smallest drive in the
array.
<ITEM>If one drive fails, the parity
information can be used to reconstruct all data.  If two drives fail,
all data is lost.
<ITEM>The reason this level is not more frequently used, is because
the parity information is kept on one drive. This information must be
updated <EM>every</EM> time one of the other disks are written
to. Thus, the parity disk will become a bottleneck, if it is not a lot
faster than the other disks.  However, if you just happen to have a
lot of slow disks and a very fast one, this RAID level can be very useful.
-->
<item>この RAID レベルは、あまり使われません。3 台以上のディスクがあれば使うことができます。情報を完全にミラーする代わりに、1 台のドライブにパリティ情報を保って、他のディスクには RAID-0 のような方法でデータを書くわけです。1 台のディスクがパリティ情報のために予約されるため、アレイのサイズは (N - 1) * S となります。S は最も小さいもののサイズです。RAID-1 の場合のように、ディスクのサイズは同等であるべきです。さもないと上の (N - 1) * S の公式に従い、アレイで最も小さいドライブのサイズである S によって足を引っ張られることになります。

<item>1 台のドライブが故障しただけならパリティ情報が使われ、全てのデータを再現できます。2 台のドライブが故障すると、全てのデータが失われます。

<item>このレベルがあまり使われないのは、パリティ情報が 1 台のドライブに集中してしまうからです。他のディスクのうちの 1 台に書きこみが起こるたびに、この情報は更新されなければならないのです。つまりパリティディスクが他より充分速くないと、ボトルネックになってしまいます。たまたま多くの遅いディスクと非常に速いディスクを持っているようなら、この RAID レベルは役に立つかもしれません。

</ITEMIZE>
<ITEM><BF>RAID-5</BF>
<ITEMIZE>
<!--
<ITEM>This is perhaps the most useful RAID mode when one wishes to combine
a larger number of physical disks, and still maintain some
redundancy. RAID-5 can be used on three or more disks, with zero or
more spare-disks. The resulting RAID-5 device size will be (N-1)*S,
just like RAID-4. The big difference between RAID-5 and -4 is, that
the parity information is distributed evenly among the participating
drives, avoiding the bottleneck problem in RAID-4.
<ITEM>If one of the disks fail, all data are still intact, thanks to the
parity information. If spare disks are available, reconstruction will
begin immediately after the device failure.  If two disks fail
simultaneously, all data are lost. RAID-5 can survive one disk
failure, but not two or more.
<ITEM>Both read and write performance usually increase, but it's hard to
predict how much.
-->
<item>より多くの物理ディスクを結合してさらに冗長性を持たせたいとき、これはおそらく最も役に立つ RAID モードです。RAID-5 は 3 台以上のディスクで使うことができます。予備のディスクを用意しておくこともできます。結果として RAID-5 デバイスサイズは RAID-4 と同様に (N - 1) * S となります。RAID-5 と RAID-4 の間の大きな違いは、パリティ情報が各ドライブに均一に分散されるということです。ですから RAID-4 のボトルネック問題を回避することができます。

<item>1 台のディスクが故障してもパリティ情報のおかげで、全てのデータは完全です。予備ディスクが利用できるなら、デバイス故障の直後に再構築が始まります。2 台のディスクが同時に故障してしまうと全てのデータが消失します。RAID-5 は 1 台のディスク故障を乗り切ることができますが 2 台以上は無理です。

<item>通常、読み書き両方ともにパフォーマンスは向上しますが、どの程度かを予測することは困難です。
</ITEMIZE>
</ITEMIZE>

<SECT2>
<!--
Spare disks
-->
予備ディスク
<P>
<!--
Spare disks are disks that do not take part in the RAID set until one
of the active disks fail.  When a device failure is detected, that
device is marked as ``bad'' and reconstruction is immediately started
on the first spare-disk available.
-->
予備ディスクは、アクティブなディスクのうちの 1 台が故障するまで RAID に参加しないディスクです。デバイス故障が発見されるとそのデバイスは「不良」とマークされ、利用できる最初の予備ディスクの上で直ちに再構築が始まります。
<P>
<!--
Thus, spare disks add a nice extra safety to especially RAID-5 systems
that perhaps are hard to get to (physically). One can allow the system
to run for some time, with a faulty device, since all redundancy is
preserved by means of the spare disk.
-->
つまり RAID-5 に予備ディスクを装備すると、安全性が格段に向上することになります。1 台のディスクが故障したとしても予備ディスクによって冗長性が維持されていれば、そのまま動作し続けることになってもしばらくの間なら許容できるでしょう。
<P>
<!--
You cannot be sure that your system will survive a disk crash. The
RAID layer should handle device failures just fine, but SCSI drivers
could be broken on error handling, or the IDE chipset could lock up,
or a lot of other things could happen.
-->
ただしシステムがディスククラッシュを確実に乗り切るという保証はありません。RAID レイヤはデバイス故障をうまく処理しなければなりませんが、SCSI ドライバがエラー発生時に飛んでしまったり、IDE チップセットが固まってしまったり、他にも似たようなことがいろいろ起こる可能性があります。

<P>
<SECT1>
<!--
Swapping on RAID
-->
RAIDでのスワッピング
<P>
<!--
There's no reason to use RAID for swap performance reasons. The kernel
itself can stripe swapping on several devices, if you just give them
the same priority in the fstab file.
-->
swap の パフォーマンス向上のために RAID を使う必要はありません。fstab ファイルにおいて複数のスワップパーティションに同じ優先度を与えると、カーネル自身がスワップをストライプにすることができるからです。

<!-- 初出の swap はあえてカタカナにせずに 英単語のままにしてあります(早川) -->
<P>
<!--
A nice fstab looks like:
-->
そのための fstab の記述は−

<VERB>
/dev/sda2       swap           swap    defaults,pri=1   0 0
/dev/sdb2       swap           swap    defaults,pri=1   0 0
/dev/sdc2       swap           swap    defaults,pri=1   0 0
/dev/sdd2       swap           swap    defaults,pri=1   0 0
/dev/sde2       swap           swap    defaults,pri=1   0 0
/dev/sdf2       swap           swap    defaults,pri=1   0 0
/dev/sdg2       swap           swap    defaults,pri=1   0 0
</VERB>
<!--
This setup lets the machine swap in parallel on seven SCSI devices. No
need for RAID, since this has been a kernel feature for a long time.
-->
これはスワップを 7 台の SCSI デバイスで並列にする設定です。RAID の必要はありません。これはもう長い間カーネルの機能としてあるものですから。
<P>
<!--
Another reason to use RAID for swap is high availability.  If you set
up a system to boot on eg. a RAID-1 device, the system should be able
to survive a disk crash. But if the system has been swapping on the
now faulty device, you will for sure be going down.  Swapping on the
RAID-1 device would solve this problem. 
-->
スワップに RAID を使うもう一つの理由は、高い可用性です。ブートのために例えば RAID-1 デバイスにシステムをセットアップすれば、システムはディスク・クラッシュを乗り切ることができます。しかしスワップが不良デバイスだとしたら、まず間違いなくまずいことになります。RAID-1 デバイスをスワップにすればこの問題を解決してくれます。
<P>
<!--
With the newer RAID patches, swapping on RAID should now be
safe. Previously swap on RAID was unsafe because of possible (and
likely) deadlock situations, but this should be fixed now.
-->
最新の RAID パッチでは RAID 上でのスワッピングは安全なはずです。以前はデッドロックの可能性があったため、RAID 上でのスワップは安全とは言えませんでしたが、現在では修正されたはずです。
<P>
<!--
You can set up RAID in a swap file on a filesystem on your RAID
device, or you can set up a RAID device as a swap partition, as you
see fit.  As usual, the RAID device is just a block device.
-->
RAID デバイス上のファイルシステムで、スワップ・ファイルの中で RAID を構成することができます。あるいは RAID デバイスをスワップパーティションとして構成することもできます。例によって、RAID デバイスは単なるブロックデバイスなのですから。
<P>

<SECT>
<!--
Hardware issues
-->
ハードウェアの問題
<P>
<!--
This section will mention some of the hardware concerns involved when
running software RAID.
-->
このセクションでは、ソフトウェア RAID を走らせる場合のハードウェアに関して述べていきます。
<P>
<SECT1>
<!--
IDE Configuration
-->
IDE 構成
<P>
<!--
It is indeed possible to run RAID over IDE disks. And excellent
performance can be achieved too. In fact, today's price on IDE drives
and controllers does make IDE something to be considered, when setting
up new RAID systems.
-->
IDE ディスク上に RAID を走らせることは、非常に現実的なことです。優れた性能も得られます。実際、新たに RAID システムを構成する場合に、IDE ドライブとコントローラの今日の価格には一考の価値があります。
<ITEMIZE>
<!--
<ITEM><BF>Physical stability:</BF> IDE drives has traditionally
been of lower mechanical quality than SCSI drives. Even today, the
warranty on IDE drives is typically one year, whereas it is often
three to five years on SCSI drives.  Although it is not fair to say,
that IDE drives are per definition poorly made, one should be aware
that IDE drives of <EM>some</EM> brand <EM>may</EM> fail more often
that similar SCSI drives. However, other brands use the exact same
mechanical setup for both SCSI and IDE drives. It all boils down to:
All disks fail, sooner or later, and one should be prepared for that.
</ITEM>
<ITEM><BF>Data integrity:</BF> Earlier, IDE had no way of assuring
that the data sent onto the IDE bus would be the same as the data
actually written to the disk. This was due to total lack of parity,
checksums, etc.  With the Ultra-DMA standard, IDE drives now do a
checksum on the data they receive, and thus it becomes highly unlikely
that data get corrupted.
</ITEM>
<ITEM><BF>Performance:</BF> I'm not going to write thoroughly about
IDE performance here. The really short story is:
<ITEMIZE>
<ITEM>IDE drives are fast (12 MB/s and beyond)</ITEM>
<ITEM>IDE has more CPU overhead than SCSI (but who cares?)</ITEM>
<ITEM>Only use <BF>one</BF> IDE drive per IDE bus, slave disks spoil
performance</ITEM>
</ITEMIZE>
</ITEM>
<ITEM><BF>Fault survival:</BF> The IDE driver usually survives a failing
IDE device. The RAID layer will mark the disk as failed, and if you
are running RAID levels 1 or above, the machine should work just fine
until you can take it down for maintenance.</ITEM>
-->
<item><bf>物理的安定性−</bf> IDE ドライブは、伝統的に SCSI ドライブより品質が低いようでした。今日でさえ IDE ドライブの保証期間は概ね一年であるのに、SCSI ドライブについては 3 〜 5 年です。こういうことを言うのはフェアではないんですが、IDE ドライブは作りがお粗末で、あるブランドの IDE ドライブは SCSI ドライブより故障しやすいようです。しかし他のブランドでは、SCSI も IDE も完全に同一のメカニズムを使っています。要するに−遅かれ早かれディスクはすべて壊れます、それについては覚悟しておかなければなりません。

<item><bf>データ完全性−</bf> 以前は、IDE ではバスに送られるデータが実際にディスクに書かれたデータと、同じものであるだろうことを保証する方法がありませんでした。パリティやチェックサムなどが欠落していたのです。Ultra-DMA では、IDE ドライブが受けるデータにはチェックサムが付くので、データが壊れることはまずないでしょう。

<item><bf>性能−</bf> IDE の性能についてここで徹底的に書くつもりはありません。簡単に書くと−
<itemize>
<item>IDE ドライブは速い（12 MB/s 以上）
<item>IDE は SCSI より CPU オーバーヘッドが多い（だれがそんな事を気にする？）
<item>IDE バス 1 本あたり <bf>1台</bf>の IDE ドライブとすること。スレーブディスクは性能を台無しにします。
</itemize>

<item><bf>障害時に生き続ける−</bf> 通常 IDE ドライバは、故障した IDE デバイスがあっても死んでしまうことはありません。RAID レイヤはディスクを故障とマークして、RAID レベル 1 以上を利用しているのであれば、メンテナンスのために停止するまでマシンはきちんと動き続けるはずです。
</ITEMIZE>
<P>
<!--
It is <BF>very</BF> important, that you only use <BF>one</BF> IDE disk
per IDE bus. Not only would two disks ruin the performance, but the
failure of a disk often guarantees the failure of the bus, and
therefore the failure of all disks on that bus.  In a fault-tolerant
RAID setup (RAID levels 1,4,5), the failure of one disk can be
handled, but the failure of two disks (the two disks on the bus that
fails due to the failure of the one disk) will render the array
unusable. Also, when the master drive on a bus fails, the slave or the
IDE controller may get awfully confused. One bus, one drive, that's
the rule.
-->
IDE バス 1 本につき IDE ディスク <bf>1 台だけ</bf>にすることは、<bf>非常に</bf>重要です。2 台のディスクをつなぐと性能を台無しにするだけでなく、1 台のディスクが故障すると、バス自体が故障したようになり、結局 2 台とも故障したのと同じ事になります。故障に強い RAID 構成（RAID レベル1,4,5）では、1 台のディスクの故障は救えますが、2 台のディスクが故障（1 台のディスクの故障のためにバス上の 2 台のディスクが使えない）すると、RAID アレイ全体が使えなくなります。また、バス上のマスター・ドライブが故障すると、スレーブまたは IDE コントローラが混乱するかもしれません。1 本のバスには 1 台のドライブ。これがルールです。
<P>
<!--
There are cheap PCI IDE controllers out there. You often get two or
four busses for around $80. Considering the much lower price of IDE
disks versus SCSI disks, I'd say an IDE disk array could be a really
nice solution if one can live with the relatively low (around 8
probably) disks one can attach to a typical system (unless of course,
you have a lot of PCI slots for those IDE controllers).
-->
PCI IDE コントローラには安いヤツがあります。80 ドルも出せば 2 本か 4 本の IDE バスが手に入ります。SCSI ディスクに対し IDE ディスクは非常に安価ですので、典型的なシステムに付けることができる(多くても) 8 台程度のディスクで良いなら、IDE ディスクアレイは本当に素晴らしい解だと言えるでしょう（もちろん IDE コントローラのための PCI スロットの空が必要です）。
<P>

<SECT1>
<!--
Hot Swap
-->
ホットスワップ
<P>
<!--
This has been a hot topic on the linux-kernel list for some
time. Although hot swapping of drives is supported to some extent, it
is still not something one can do easily.
-->
これはしばらくの間 Linux カーネル・リストのホットな話題でした。ドライブのホットスワップはある程度までサポートされていますが、まだ簡単なことではありません。
<P>
<SECT2>
<!--
Hot-swapping IDE drives
-->
IDE ドライブのホットスワップ
<P>
<!--
<BF>Don't !</BF> IDE doesn't handle hot swapping at all.  Sure, it may
work for you, if your IDE driver is compiled as a module (only
possible in the 2.2 series of the kernel), and you re-load it after
you've replaced the drive.  But you may just as well end up with a
fried IDE controller, and you'll be looking at a lot more down-time
than just the time it would have taken to replace the drive on a
downed system.
-->
IDE は基本的にホットスワップ<bf>できません</bf>。IDE ドライバがモジュール（2.2 シリーズのカーネルで可能）としてコンパイルされていて、ドライブの交換後に再ロードすればうまく動くかもしれません。しかし IDE コントローラが揚げ物になるかもしれませんので、素直に電源を切ってドライブを取り替えた方がダウンタイムは短くて済むでしょう。
<P>
<!--
The main problem, except for the electrical issues that can destroy
your hardware, is that the IDE bus must be re-scanned after disks are
swapped. The current IDE driver can't do that.  If the new disk is
100% identical to the old one (wrt. geometry etc.), it <EM>may</EM>
work even without re-scanning the bus, but really, you're walking the
bleeding edge here.
-->
ハードウェアを破壊するかもしれないという電気的な問題を除くと、主な問題はディスクが交換されたあとに IDE バスを再スキャンしなければならないということです。現在の IDE ドライバではできません。新しいディスクが古いものと 100% 同じ(ジオメトリなど)ならバスを再スキャンせずに動く<em>かも</em>しれませんが、まぁやめた方がいいでしょう。
<P>
<SECT2>
<!--
Hot-swapping SCSI drives
-->
SCSI ドライブのホットスワップ
<P>
<!--
Normal SCSI hardware is not hot-swappable either. It <BF>may</BF>
however work. If your SCSI driver supports re-scanning the bus, and
removing and appending devices, you may be able to hot-swap
devices. However, on a normal SCSI bus you probably shouldn't unplug
devices while your system is still powered up. But then again, it may
just work (and you may end up with fried hardware).
-->
普通の SCSI ハードウェアもホットスワップには対応してません。しかしうまく動作する<bf>かも</bf>しれません。SCSI ドライバがバスの再スキャン、デバイスの取り外し、追加をサポートしていれば、ホットスワップできるかもしれません。しかし普通の SCSI バスではシステムに火が入っている間、多分デバイスを引っこ抜いてはいけないはずですが、うまく動作する可能性もあります（しかしハードウェアがこんがり焼き上がって終わってしまうかもしれません）。
<P>
<!--
The SCSI layer <BF>should</BF> survive if a disk dies, but not all
SCSI drivers handle this yet. If your SCSI driver dies when a disk
goes down, your system will go with it, and hot-plug isn't really
interesting then.
-->
ディスクが死んでも SCSI レイヤ は生き残る<bf>はず</bf>ですが、まだ全ての SCSI ドライバがこの状況に対応しているわけではありません。1 台のディスクがおかしくなっただけで SCSI ドライバが死ぬことになると、システム全体が道連れになります、そんなんじゃホットプラグに興味はありません。
<P>
<SECT2>
<!--
Hot-swapping with SCA
-->
SCA によるホットスワップ
<P>
<!--
With SCA, it should be possible to hot-plug devices. However, I don't
have the hardware to try this out, and I haven't heard from anyone
who's tried, so I can't really give any recipe on how to do this.
-->
SCA を使えばホットプラグデバイスになるでしょう。しかし、私にはこれを試用するためのハードウェアがないですし、他に使っているという話も聞かなかったので、これについて述べることはできません。
<P>
<!--
If you want to play with this, you should know about SCSI and RAID
internals anyway. So I'm not going to write something here that I
can't verify works, instead I can give a few clues:
-->
これで遊びたいのであれば、SCSI と RAID の内部構造についての知識が必要です。実際にやってみることができないのでここで書くわけにはいきませんが、その代わりに 2、3 の手がかりを与えることができます−
<ITEMIZE>
<!--
<ITEM>Grep for <BF>remove-single-device</BF> in
<BF>linux/drivers/scsi/scsi.c</BF></ITEM>
<ITEM>Take a look at <BF>raidhotremove</BF> and <BF>raidhotadd</BF>
-->
<item>linux/drivers/scsi/scsi.c の <bf>remove-single-device</bf> を grep
<item><bf>raidhotremove</bf> と <bf>raidhotadd</bf> に注目してください
</ITEMIZE>
<P>
<!--
Not all SCSI drivers support appending and removing devices. In the
2.2 series of the kernel, at least the Adaptec 2940 and Symbios
NCR53c8xx drivers seem to support this, others may and may not. I'd
appreciate if anyone has additional facts here...
-->
全ての SCSI ドライバがデバイスの追加と削除をサポートするというわけではありません。カーネルの 2.2 シリーズでは、少なくとも Adaptec 2940 と Symbios NCR53c8xx ドライバがこれをサポートするようです。これについて補足してくれる人がいれば感謝します．．．
<P>

<SECT>
<!--
RAID setup
-->
RAID セットアップ
<P>
<SECT1>
<!--
General setup
-->
一般的なセットアップ
<P>
<!--
This is what you need for any of the RAID levels:
-->
次のものは、どの RAID レベルでも必要とするものです−
<ITEMIZE>
<!--
<ITEM>A kernel. Preferably a stable 2.2.X kernel, or the latest 2.0.X.
<ITEM>The RAID patches.  There usually is a patch available
   for the recent kernels.
<ITEM>The RAID tools.
<ITEM>Patience, Pizza, and your favorite caffeinated beverage.
-->
<item>カーネル。安定版の 2.2.X または最新の 2.0.X. がいいでしょう。
<item>RAID パッチ。最近のカーネルに利用できるパッチが、大抵の場合あります。
<item>RAID tools
<item>忍耐、ピザ、お気に入りのカフェイン飲料
</ITEMIZE>
<P>
<!--
All this software can be found at &ftpkernel; The RAID
tools and patches are in the <TT>daemons/raid/alpha</TT>
subdirectory. The kernels are found in the <TT>kernel</TT>
subdirectory.
-->
これら全てのソフトウェアは &ftpkernel; で見つけられます。RAID tools とパッチは <tt>daemons/raid/alpha</tt> サブディレクトリにあります。カーネルは <tt>kernel</tt> サブディレクトリで見つけられます。
<P>
<!--
Patch the kernel, configure it to include RAID support for the level
you want to use.  Compile it and install it.
-->
カーネルにパッチを当て、使いたいレベルの RAID サポートを含めるように構成します。そしてコンパイルし、インストールを行ないます。
<P>
<!--
Then unpack, configure, compile and install the RAID tools.
-->
次に、RAID tools を展開して設定し、コンパイル、インストールを行ないます。（訳注：configure, make, make install だけで私の場合は OK でした）
<P>
<!--
Ok, so far so good.  If you reboot now, you should have a file called
&mdstat;.  Remember it, that file is your friend. See
what it contains, by doing a <TT>cat </TT>&mdstat;. It should
tell you that you have the right RAID personality (eg. RAID mode)
registered, and that no RAID devices are currently active.
-->
この時点でリブートすると &mdstat; というファイルが確認できるはずです。そのファイルはあなたの「お友達」だということを憶えておいてください。<tt>cat </tt>&mdstat; を実行して内容を確認してみると、登録されている RAID の特性がわかります（例えば RAID モード）。まだ RAID デバイスは存在しないはずです。
<P>
<!--
Create the partitions you want to include in your RAID set.
-->
RAID に含めたいパーティションをつくります。
<P>
<!--
Now, let's go mode-specific.
-->
ここから先はモードに特化した内容になります。
<P>

<SECT1>
<!--
Linear mode
-->
リニアモード
<P>
<!--
Ok, so you have two or more partitions which are not necessarily the
same size (but of course can be), which you want to append to
each other.
-->
では、まず少なくとも 2 つのパーティションを用意します。それぞれは同じ大きさである必要はありません（ただ、できれば同じに）。それらをお互いにくっつけたいわけです。
<P>
<!--
Set up the &raidtab; file to describe your
setup. I set up a raidtab for two disks in linear mode, and the file
looked like this:
-->
&raidtab; ファイルを設定します。私は raidtab にリニアモードで 2 台のディスクで動作させるための設定を行ないました。内容は以下の通りです−
<P>
<VERB>
raiddev /dev/md0
        raid-level      linear
        nr-raid-disks   2
        persistent-superblock 1
        device          /dev/sdb6
        raid-disk       0
        device          /dev/sdc5
        raid-disk       1
</VERB>
<!--
Spare-disks are not supported here.  If a disk dies, the array dies
with it. There's no information to put on a spare disk.
-->
予備ディスクはここではサポートされません。ディスクが死んだら、アレイも道連れになります。予備ディスクに置く情報はありません。
<P>
<!--
Ok, let's create the array. Run the command
-->
では、アレイを作りましょう。コマンドを打ち込みます。
<VERB>
  mkraid /dev/md0
</VERB>
<P>
<!--
This will initialize your array, write the persistent superblocks, and
start the array.
-->
これでアレイを初期化して persistent superblock を書き、アレイを始動します。
<P>
<!--
Have a look in &mdstat;. You should see that the array is running.
-->
&mdstat; を見てください。アレイが走っている様子が分かります。
<P>
<!--
Now, you can create a filesystem, just like you would on any other
device, mount it, include it in your fstab and so on.
-->
これでファイルシステムを作成することができます。マウントや fstab に記述など、他のデバイスと同様の事ができます。
<P>

<SECT1>RAID-0
<P>
<!--
You have two or more devices, of approximately the same size, and you 
want to combine their storage capacity and also combine their
performance by accessing them in parallel.
-->
ほぼ同じサイズの 2 台以上のデバイスを用意します。それらの容量の結合や、並列にアクセスすることによって性能向上も図るわけです。
<P>
<!--
Set up the &raidtab; file to describe your configuration. An
example raidtab looks like:
-->
&raidtab; ファイルを設定します。以下はその一例です−
<VERB>
raiddev /dev/md0
        raid-level      0
        nr-raid-disks   2
        persistent-superblock 1
        chunk-size     4
        device          /dev/sdb6
        raid-disk       0
        device          /dev/sdc5
        raid-disk       1
</VERB>
<!--
Like in Linear mode, spare disks are not supported here either. RAID-0
has no redundancy, so when a disk dies, the array goes with it.
-->
リニアモードと同様に、予備ディスクはサポートされません。RAID-0 には冗長性がないので、ディスクが死ぬとアレイも道連れになります。
<P>
<!--
Again, you just run 
-->
アレイを初期化するために以下のコマンドを打ち込みます。
<VERB>
  mkraid /dev/md0
</VERB>
<!--
to initialize the array. This should initialize the superblocks and
start the raid device.  Have a look in &mdstat; to see what's
going on. You should see that your device is now running.
-->
スーパーブロックを初期化し、RAID デバイスを始動するわけです。何が起こっているのかは &mdstat; を見てください。デバイスが動いていることが分かるはずです。
<P>
<!--
/dev/md0 is now ready to be formatted, mounted, used and abused.
-->
これで /dev/md0 をフォーマットやマウント、ぐちゃぐちゃ乱用する事もできるようになりました。
<P>

<SECT1>RAID-1
<P>
<!--
You have two devices of approximately same size, and you want the two
to be mirrors of each other. Eventually you have more devices, which
you want to keep as stand-by spare-disks, that will automatically
become a part of the mirror if one of the active devices break.
-->
ほぼ同じサイズの 2 台のデバイスを用意します、お互いにミラーしたいわけです。できればもう 1 台デバイスを用意しましょう。それを待機用の予備ディスクとします。予備ディスクはアクティブなデバイスが壊れた時に、自動的にミラーを補ってくれます。
<P>
<!--
Set up the &raidtab; file like this:
-->
&raidtab; ファイルを設定します−
<VERB>
raiddev /dev/md0
        raid-level      1
        nr-raid-disks   2
        nr-spare-disks  0
        chunk-size     4
        persistent-superblock 1
        device          /dev/sdb6
        raid-disk       0
        device          /dev/sdc5
        raid-disk       1
</VERB>
<!--
If you have spare disks, you can add them to the end of the device
specification like
-->
予備ディスクがある場合、次のような指定を行ないデバイスを追加することができます。<VERB>
        device          /dev/sdd5
        spare-disk      0
</VERB>
<!--
Remember to set the nr-spare-disks entry correspondingly.
-->
この場合は nr-spare-disks エントリを 1 に設定するのを忘れないように。
<P>
<!--
Ok, now we're all set to start initializing the RAID. The mirror must
be constructed, eg. the contents (however unimportant now, since the
device is still not formatted) of the two devices must be
synchronized.
-->
さて、RAID を初期化する用意が整いました。ミラーは 2 台のデバイスの内容まで含めて同期するように構築しなければなりません（デバイスはまだフォーマットされてないので、大した問題ではないんですが）。
<P>
<!--
Issue the
-->
ミラーの初期化を開始するコマンドを打ち込みます。
<VERB>
  mkraid /dev/md0
</VERB>
<!--
command to begin the mirror initialization.
-->

<P>
<!--
Check out the &mdstat; file. It should tell you that the /dev/md0
device has been started, that the mirror is being reconstructed, and
an ETA of the completion of the reconstruction.
-->
&mdstat; ファイルをチェックしましょう。/dev/md0 デバイスのミラーの再構築が始まった事を示しており、構築作業の終了予定時刻を知ることができます。
<P>
<!--
Reconstruction is done using idle I/O bandwidth. So, your system
should still be fairly responsive, although your disk LEDs should be
glowing nicely.
-->
再構築はアイドル中の I/O バンド幅を使ってなされますから、システムは以前とあまり変わらず機敏に動作し続けるはずです。ディスク LED もかなり光っているはずですが。
<P>
<!--
The reconstruction process is transparent, so you can actually use the
device even though the mirror is currently under reconstruction.
-->
再構築プロセスは透過的なので、ミラーが再構築中だとしてもデバイスを使うことができます。
<P>
<!--
Try formatting the device, while the reconstruction is running. It
will work.  Also you can mount it and use it while reconstruction is
running. Of Course, if the wrong disk breaks while the reconstruction
is running, you're out of luck.
-->
再構築の進行中にデバイスをフォーマットしてみてください。ちゃんと動作するはずです。また、再構築の進行中であってもマウントして使うことができます。もちろん再構築中にディスクが壊れたりしたら、そりゃあ運が悪いとしか言いようがありませんが。
<P>

<SECT1>RAID-4
<P>
<!--
<BF>Note!</BF> I haven't tested this setup myself. The setup below is
my best guess, not something I have actually had up running.
-->
<bf>注意！</bf> 私自身はこの設定ではテストしてません。以下の設定はあくまで予想であり、実際に走らせたことはありません。
<P>
<!--
You have three or more devices of roughly the same size, one device is
significantly faster than the other devices, and you want to combine
them all into one larger device, still maintaining some redundancy
information.
Eventually you have a number of devices you wish to use as
spare-disks.
-->
3 台以上のほぼ同じサイズのデバイスを用意します。1 つだけが飛び抜けて速いのがいいですね。これらを結合して 1 つの大きなデバイスとし、冗長性も持たせたいわけです。
<P>
<!--
Set up the /etc/raidtab file like this:
-->
/etc/raidtab ファイルを設定します−
<VERB>
raiddev /dev/md0
        raid-level      4
        nr-raid-disks   4
        nr-spare-disks  0
	persistent-superblock 1
        chunk-size      32
        device          /dev/sdb1
        raid-disk       0
        device          /dev/sdc1
        raid-disk       1
        device          /dev/sdd1
        raid-disk       2
        device          /dev/sde1
        raid-disk       3
</VERB>
<!--
If we had any spare disks, they would be inserted in a similar way,
following the raid-disk specifications;
-->
予備ディスクがあれば同様に入れてください。以下のように−
<VERB>
        device         /dev/sdf1
        spare-disk     0
</VERB>
<!--
as usual.
-->
<P>
<!--
Your array can be initialized with the
-->
これでアレイの初期化ができます。いつも通り、次のコマンドを打ち込んでください。
<VERB>
   mkraid /dev/md0
</VERB>
<!--
command as usual.
-->
<P>
<!--
You should see the section on special options for mke2fs before
formatting the device.
-->
デバイスをフォーマットする前に <ref id="mke2fs" name="mke2fs のためのオプション"> セクションを見てください。
<P>
<SECT1>RAID-5
<P>
<!--
You have three or more devices of roughly the same size, you want to
combine them into a larger device, but still to maintain a degree of
redundancy for data safety. Eventually you have a number of devices to
use as spare-disks, that will not take part in the array before
another device fails.
-->
3 台以上のほぼ同じサイズのデバイスを用意します。これらを結合し、冗長性も併せ持った状態で使うわけです。予備ディスクもあった方がいいでしょう。このディスクは他のデバイスが故障するまでは使われません。
<P>
<!--
If you use N devices where the smallest has size S, the size of the
entire array will be (N-1)*S. This ``missing'' space is used for
parity (redundancy) information.  Thus, if any disk fails, all data
stay intact. But if two disks fail, all data is lost.
-->
N 台のデバイスを使うとして、最も小さいもののサイズを S とすると、アレイのサイズは （N - 1) * S となります。この「失われた」スペースが、パリティ（冗長性）情報のために使われるわけです。どのディスクが故障しても全てのデータは完全なままです。しかし 2 台のディスクが故障してしまったら、全てのデータが消失することになります。
<P>
<!--
Set up the /etc/raidtab file like this:
-->
/etc/raidtab ファイルを設定します−
<VERB>
raiddev /dev/md0
        raid-level      5
        nr-raid-disks   7
        nr-spare-disks  0
	persistent-superblock 1
        parity-algorithm        left-symmetric
        chunk-size      32
        device          /dev/sda3
        raid-disk       0
        device          /dev/sdb1
        raid-disk       1
        device          /dev/sdc1
        raid-disk       2
        device          /dev/sdd1
        raid-disk       3
        device          /dev/sde1
        raid-disk       4
        device          /dev/sdf1
        raid-disk       5
        device          /dev/sdg1
        raid-disk       6
</VERB>
<!--
If we had any spare disks, they would be inserted in a similar way,
following the raid-disk specifications;
-->
予備ディスクがある場合は同様に−
<VERB>
        device         /dev/sdh1
        spare-disk     0
</VERB>
<!--
And so on.
-->
などとするわけです。
<P>
<!--
A chunk size of 32 KB is a good default for many general purpose
filesystems of this size. The array on which the above raidtab is
used, is a 7 times 6 GB = 36 GB (remember the (n-1)*s = (7-1)*6 = 36)
device. It holds an ext2 filesystem with a 4 KB block size.  You could
go higher with both array chunk-size and filesystem block-size if your
filesystem is either much larger, or just holds very large files.
-->
chunk-size の 32 KB という値は、このサイズの普通のファイルシステムのためのデフォルトとしては適切な値でしょう。上記の raidtab で設定されたアレイのサイズは 6 × 6 GB = 36 GB となります（つまり (N - 1) * S = (7 - 1) * 6 = 36 ってことです）。ファイルシステムは ext2 でブロック・サイズは 4 KB としました。ファイルシステムが非常に大きいか、非常に大きいファイルを収容するなら、アレイの chunk-size とファイルシステムのブロックサイズの両方を変えてみると良いでしょう。
<P>
<!--
Ok, enough talking. You set up the raidtab, so let's see if it
works. Run the 
-->
さぁ、おしゃべりは充分でしょう。raidtab を設定しましたから、動かして見ましょう。以下のコマンドを打ち込みます。
<VERB>
  mkraid /dev/md0
</VERB>
<!--
command, and see what happens.  Hopefully your disks start working
like mad, as they begin the reconstruction of your array. Have a look
in &mdstat; to see what's going on.
-->
何が起こるか見てください。うまくいけばアレイの再構築を開始するため、ディスクは猛烈に動き始めます。何が起こっているのかは &mdstat; を見てください。
<P>
<!--
If the device was successfully created, the reconstruction process has
now begun.  Your array is not consistent until this reconstruction
phase has completed. However, the array is fully functional (except
for the handling of device failures of course), and you can format it
and use it even while it is reconstructing.
-->
デバイスの作成がうまくいけば、再構築プロセスの始まりです。再構築のこのフェーズでは、アレイはまだ完全とはいえませんが、完全に機能してくれます。フォーマットもできますし、普通に使うことができます（もちろんデバイスが故障したらいけません）。
<P>
<!--
See the section on special options for mke2fs before formatting the
array.
-->
デバイスをフォーマットする前に <ref id="mke2fs" name="mke2fs のためのオプション"> セクションを見てください。
<P>
<!--
Ok, now when you have your RAID device running, you can always stop it
or re-start it using the
-->
RAID デバイスが動作していれば、停止や再開をするのに以下のコマンドを使うことができます。
<VERB>
  raidstop /dev/md0
</VERB>
<!--
or
-->
あるいは
<VERB>
  raidstart /dev/md0
</VERB>
<!--
commands.
-->
<P>
<!--
Instead of putting these into init-files and rebooting a zillion times
to make that work, read on, and get autodetection running.
-->
これらを初期設定ファイルに入れて何回もリブートするよりも、もうちょっと先に読み進んで、自動検出機能を使った方がいいでしょう。
<P>

<SECT1>The Persistent Superblock
<P>
<!--
Back in ``The Good Old Days'' (TM), the raidtools would read your
&raidtab; file, and then initialize the array.  However, this would
require that the filesystem on which &raidtab; resided was
mounted. This is unfortunate if you want to boot on a RAID.
-->
古き良き時代「Good Old Days」(TM)では、raidtools は &raidtab; を読み込んでアレイを初期化していました。しかしこれは &raidtab; ファイルが存在するファイルシステムがマウントされていることが前提となります。RAID からブートしたいなどという場合は、これはよろしくないでしょう。
<P>
<!--
Also, the old approach led to complications when mounting filesystems
on RAID devices. They could not be put in the &fstab; file as usual,
but would have to be mounted from the init-scripts.
-->
更に RAID デバイス上のファイルシステムをマウントするときの、古いアプローチは少々複雑でした。通常のように &fstab; に書いておけば良いのではなく、初期化スクリプトでマウントしなければならなかったのです。
<P>
<!--
The persistent superblocks solve these problems. When an array is
initialized with the <TT>persistent-superblock</TT> option in the
&raidtab; file, a special superblock is written in the beginning of
all disks participating in the array. This allows the kernel to read
the configuration of RAID devices directly from the disks involved,
instead of reading from some configuration file that may not be
available at all times.
-->
persistent superblock はこれらの問題を解決してくれます。&raidtab; 中の <tt>persistent-superblock</tt> オプション付きでアレイを初期化すると、特別なスーパーブロックがアレイに参加している全てのディスクの先頭部分に書きこまれます。これによりカーネルは、RAIDデバイスの構成を直接ディスクから読めるようになります。普通の構成ファイルだったらいつでも読めるわけじゃありません。
<P>
<!--
You should however still maintain a consistent &raidtab; file, since
you may need this file for later reconstruction of the array.
-->
でも &raidtab; ファイルはそのままにしておきましょう。後でアレイを再構築する際に必要になるかもしれません。
<P>
<!--
The persistent superblock is mandatory if you want auto-detection of
your RAID devices upon system boot. This is described in the
<BF>Autodetection</BF> section.
-->
システムのブート時に RAID デバイスを自動検出したければ、persistent superblock は必須です。これについては<bf>自動検出</bf>セクションで述べることにします。

（訳注：persistent という単語は辞書で引くと、頑固な、持続性がある、不断の、と言った意味を持つ形容詞です。うまい訳語が思いつきませんでしたので、英語表記のままにしてあります）
<P>

<SECT1>
<!--
Chunk sizes
-->
Chunk サイズ
<P>
<!--
The chunk-size deserves an explanation.  You can never write
completely parallel to a set of disks. If you had two disks and wanted
to write a byte, you would have to write four bits on each disk,
actually, every second bit would go to disk 0 and the others to disk
1. Hardware just doesn't support that.  Instead, we choose some
chunk-size, which we define as the smallest ``atomic'' mass of data
that can be written to the devices.  A write of 16 KB with a chunk
size of 4 KB, will cause the first and the third 4 KB chunks to be
written to the first disk, and the second and fourth chunks to be
written to the second disk, in the RAID-0 case with two disks.  Thus,
for large writes, you may see lower overhead by having fairly large
chunks, whereas arrays that are primarily holding small files may
benefit more from a smaller chunk size.
-->
chunk-sizeについて説明することは価値があるでしょう。複数のディスクに対して、完全に同時に書きこむことはできません。2 台のディスクがあり 1 バイトのデータを書きたいとすると、それぞれのディスクに 4 ビットずつ書く必要があります。実際には偶数番目のビットはディスク 0 へ、奇数番目はディスク 1 へと書く必要がありますが、ハードウェアはそんなことをサポートしてはくれません。その代わりに Chunk サイズを設定します。これはデバイスに書き込むことができる最小の「アトミックな」データ量として定義されます。（訳注：Chunk = 「かたまり」とでも訳せば良いでしょうか）ディスク 2 台の RAID-0 のケースで、4 KB の Chunk サイズ による 16 KB の書込を想定すると、1 番目と 3 番目の Chunk は最初のディスクへ、2 番目と 4 番目の Chunk は第二のディスクに書き込まれることになります。このように大量の書き込みに対しては、かなり大きい Chunk を指定することによってオーバーヘッドを減らせるかもしれませんが、小さいファイルの多いアレイでは Chunk サイズを小さくした方が良いかもしれません。
<P>
<!--
Chunk sizes can be specified for all RAID levels except the Linear
mode.
-->
Chunk サイズはリニアモードを除く全ての RAID レベルで指定することができます。
<P>
<!--
For optimal performance, you should experiment with the value, as well
as with the block-size of the filesystem you put on the array.
-->
最適のパフォーマンスを求めるなら、アレイ上のファイルシステムのブロックサイズと同様に、いろんな値での実験が必要となるでしょう。
<P>
<!--
The argument to the chunk-size option in &raidtab; specifies the
chunk-size in kilobytes. So ``4'' means ``4 KB''.
-->
&raidtab; 中の chunk-size オプションに対する引数は、キロバイト単位の chunk サイズを指定します。「4」は「4 KB」を意味することになります。
<P>
<SECT2>RAID-0
<P>
<!--
Data is written ``almost'' in parallel to the disks in the
array. Actually, <TT>chunk-size</TT> bytes are written to each disk,
serially.
-->
データはアレイ中のディスクに「ほとんど」並列に書き込まれます。実際には <tt>chunk-size</tt> バイトのデータが順次、各ディスクに書かれるわけです。
<P>
<!--
If you specify a 4 KB chunk size, and write 16 KB to an array of three
disks, the RAID system will write 4 KB to disks 0, 1 and 2, in
parallel, then the remaining 4 KB to disk 0.
-->
4 KB の Chunk サイズを指定して 3 台のディスクに 16 KB を書く場合、RAID-0 システムではディスク 0, 1, 2 に 4 KB を、残りの 4 KB をディスク 0 に書くことになります。
<P>
<!--
A 32 KB chunk-size is a reasonable starting point for most arrays. But
the optimal value depends very much on the number of drives involved,
the content of the file system you put on it, and many other factors.
Experiment with it, to get the best performance.
-->
32 KB の chunk-size は大部分のアレイで適切な値でしょうが、最適の値はドライブの数やファイルシステムの内容、その他の色々な要因に非常に依存します。最高のパフォーマンスを得るためには実験をして模索する必要があるでしょう。
<P>
<SECT2>RAID-1
<P>
<!--
For writes, the chunk-size doesn't affect the array, since all data
must be written to all disks no matter what.  For reads however, the
chunk-size specifies how much data to read serially from the
participating disks.  Since all active disks in the array
contain the same information, reads can be done in a parallel RAID-0
like manner.
-->
書き込みについては chunk-size はアレイに影響しません。全てのデータはとにかく全てのディスクに書かれなければならないからです。しかし読み込みの場合、chunk-size でアレイのディスクから連続的にどれくらいのデータを読むかを指定します。アレイ中の全てのアクティブなディスクが同じ情報を持つので、RAID-0 のように並列に読み込めるわけです。
<P>
<SECT2>RAID-4
<P>
<!--
When a write is done on a RAID-4 array, the parity information must be
updated on the parity disk as well. The chunk-size is the size of the
parity blocks. If one byte is written to a RAID-4 array, then
<TT>chunk-size</TT> bytes will be read from the N-1 disks, the parity
information will be calculated, and <TT>chunk-size</TT> bytes written
to the parity disk.
-->
RAID-4 アレイへの書き込み時には、パリティディスク上でパリティ情報も更新されなければなりません。chunk-size はパリティブロックのサイズとなります。RAID-4 アレイに 1 バイトを書き込もうとすると、N-1 台のディスクから <tt>chunk-size</tt> バイトのデータを読み込みパリティ情報を計算し、<tt>chunk-size</tt> バイトのデータがパリティディスクに書かれることになります。
<P>
<!--
The chunk-size affects read performance in the same way as in RAID-0,
since reads from RAID-4 are done in the same way.
-->
RAID-0 の場合と同様、chunk-size は読み込み性能に影響します。RAID-4 からの読み込み方はほぼ同じだからです。
<P>
<SECT2>RAID-5
<P>
<!--
On RAID-5 the chunk-size has exactly the same meaning as in
RAID-4.
-->
RAID-5 では、chunk-size は RAID-4 の場合と完全に同じ意味を持ちます。
<P>
<!--
A reasonable chunk-size for RAID-5 is 128 KB, but as always, you may
want to experiment with this.
-->
RAID-5 のための合理的な chunk-size は 128 KB ですが、いつものように実験して模索したいかもしれませんね。
<P>
<!--
Also see the section on special options for mke2fs.  This affects
RAID-5 performance.
-->
また <ref id="mke2fs" name="mke2fs のためのオプション"> セクションも見てください。これは RAID-5 の性能に影響を及ぼします。
<P>

<SECT1>
<!--
Options for mke2fs
-->
mke2fsのためのオプション<label id="mke2fs">
<P>
<!--
There is a special option available when formatting RAID-4 or -5
devices with mke2fs. The <TT>-R stride=nn</TT> option will allow
mke2fs to better place different ext2 specific data-structures in an
intelligent way on the RAID device.
-->
mke2fs で RAID-4 や raid-5 のデバイスをフォーマットする時に利用できる、特別なオプションがあります。<tt>-R stride=nn</tt> オプションによって、mke2fs は RAID デバイス上に ext2 の特殊なデータ構造をうまく置くことができます。
<P>
<!--
If the chunk-size is 32 KB, it means, that 32 KB of consecutive data
will reside on one disk. If we want to build an ext2 filesystem with 4
KB block-size, we realize that there will be eight filesystem blocks
in one array chunk. We can pass this information on the mke2fs
utility, when creating the filesystem:
-->
chunk-sizeが 32 KB なら、その 32 KB の連続したデータは 1 台のディスクの上に置かれます。4 KB のブロックサイズで ext2 ファイルシステムを構築したいならば、1 つのアレイの Chunkの中に 8 つのファイルシステムブロックがあると理解できます。ファイルシステムを作成する時に mke2fs ユーティリティにこの情報を渡すことができます。
<VERB>
  mke2fs -b 4096 -R stride=8 /dev/md0
</VERB>
<P>
<!--
RAID-{4,5} performance is severely influenced by this option. I am
unsure how the stride option will affect other RAID levels. If anyone
has information on this, please send it in my direction.
-->
RAID-{4,5}のパフォーマンスはこのオプションに非常に影響されます。stride オプションが他の RAID レベルの場合にどのような影響を及ぼすかの確信がありません。誰かこれに関する情報があれば私まで送ってください。
<P>
<!--
The ext2fs blocksize <IT>severely</IT> influences the performance of
the filesystem. You should always use 4KB block size on any filesystem
larger than a few hundred megabytes, unless you store a very large
number of very small files on it.
-->
ext2fs のブロックサイズは、ファイルシステムのパフォーマンスに<tt>非常に</tt>影響します。数百メガバイト以上のどんなファイルシステム上でも、ブロックサイズは 4 KB にすべきです。小さいファイルをたくさん置くなら別ですが
<P>

<SECT1>
<!--
Autodetection
-->
自動検出
<P>
<!--
Autodetection allows the RAID devices to be automatically recognized
by the kernel at boot-time, right after the ordinary partition
detection is done. 
-->
自動検出は、カーネルがブート時に普通のパーティションの検出後、RAIDデバイスを自動的に検出できるようにします。
<P>
<!--
This requires several things:
-->
これには必要なものがいくつかあります。
<ENUM>
<!--
<ITEM>You need autodetection support in the kernel. Check this
<ITEM>You must have created the RAID devices using persistent-superblock
<ITEM>The partition-types of the devices used in the RAID must be set to
   <BF>0xFD</BF>  (use fdisk and set the type to ``fd'')
-->
<item>カーネルに自動検出サポートが必要ですので、これをチェックします。
<item>persistent-superblock を使って RAID デバイスを作成します。
<item>RAID で使われるデバイスのパーティションタイプを、<bf>0xFD</bf>（fdiskを使ってタイプを「fd」にする）にセットします。
</ENUM>
<P>
<!--
NOTE: Be sure that your RAID is NOT RUNNING before changing the
partition types.  Use <TT>raidstop /dev/md0</TT> to stop the device.
-->
NOTE: パーティションタイプを変える前に、RAID が動いていないことを確認してください。デバイスを止めるには <tt>raidstop /dev/md0</tt> を使ってください。
<P>
<!--
If you set up 1, 2 and 3 from above, autodetection should be set
up. Try rebooting.  When the system comes up, cat'ing &mdstat;
should tell you that your RAID is running.
-->
上記 1, 2, 3 を設定すれば自動検出の設定は終わりです。リブートしてみてください。システムが立ち上がるとき、cat &mdstat; で RAID が走っている様子がわかります。
<P>
<!--
During boot, you could see messages similar to these:
-->
ブートの間、このような感じのメッセージが表示されます−
<VERB>
 Oct 22 00:51:59 malthe kernel: SCSI device sdg: hdwr sector= 512
  bytes. Sectors= 12657717 [6180 MB] [6.2 GB]
 Oct 22 00:51:59 malthe kernel: Partition check:
 Oct 22 00:51:59 malthe kernel:  sda: sda1 sda2 sda3 sda4
 Oct 22 00:51:59 malthe kernel:  sdb: sdb1 sdb2
 Oct 22 00:51:59 malthe kernel:  sdc: sdc1 sdc2
 Oct 22 00:51:59 malthe kernel:  sdd: sdd1 sdd2
 Oct 22 00:51:59 malthe kernel:  sde: sde1 sde2
 Oct 22 00:51:59 malthe kernel:  sdf: sdf1 sdf2
 Oct 22 00:51:59 malthe kernel:  sdg: sdg1 sdg2
 Oct 22 00:51:59 malthe kernel: autodetecting RAID arrays
 Oct 22 00:51:59 malthe kernel: (read) sdb1's sb offset: 6199872
 Oct 22 00:51:59 malthe kernel: bind<sdb1,1>
 Oct 22 00:51:59 malthe kernel: (read) sdc1's sb offset: 6199872
 Oct 22 00:51:59 malthe kernel: bind<sdc1,2>
 Oct 22 00:51:59 malthe kernel: (read) sdd1's sb offset: 6199872
 Oct 22 00:51:59 malthe kernel: bind<sdd1,3>
 Oct 22 00:51:59 malthe kernel: (read) sde1's sb offset: 6199872
 Oct 22 00:51:59 malthe kernel: bind<sde1,4>
 Oct 22 00:51:59 malthe kernel: (read) sdf1's sb offset: 6205376
 Oct 22 00:51:59 malthe kernel: bind<sdf1,5>
 Oct 22 00:51:59 malthe kernel: (read) sdg1's sb offset: 6205376
 Oct 22 00:51:59 malthe kernel: bind<sdg1,6>
 Oct 22 00:51:59 malthe kernel: autorunning md0
 Oct 22 00:51:59 malthe kernel: running: <sdg1><sdf1><sde1><sdd1><sdc1><sdb1>
 Oct 22 00:51:59 malthe kernel: now!
 Oct 22 00:51:59 malthe kernel: md: md0: raid array is not clean --
  starting background reconstruction 
</VERB>
<!--
This is output from the autodetection of a RAID-5 array that was not
cleanly shut down (eg. the machine crashed).  Reconstruction is
automatically initiated.  Mounting this device is perfectly safe,
since reconstruction is transparent and all data are consistent (it's
only the parity information that is inconsistent - but that isn't
needed until a device fails).
-->
これは正常にシャットダウンされなかった（例えばマシンがクラッシュした）RAID-5 アレイの自動検出時に出力されたものです。再構築は自動的に始まります。このデバイスをこの状態のままマウントしても完全に安全です。というのも再構築は透過的で、全てのデータが一貫 (consistent) しているからです（一貫性がないのはパリティ情報だけですが、デバイスが故障するまでは必要ありません）。
<P>
<!--
Autostarted devices are also automatically stopped at shutdown.  Don't
worry about init scripts.  Just use the /dev/md devices as any other
/dev/sd or /dev/hd devices.
-->
自動始動したデバイスはシャットダウン時にも自動停止します。初期化スクリプトについて心配する必要はありません。/dev/md デバイスは /dev/sd や /dev/hd デバイスと同じように使えます。
<P>
<!--
Yes, it really is that easy.
-->
簡単ですね。
<P>
<!--
You may want to look in your init-scripts for any raidstart/raidstop
commands. These are often found in the standard RedHat init
scripts. They are used for old-style RAID, and has no use in new-style
RAID with autodetection. Just remove the lines, and everything will be
just fine.
-->
raidstart/raidstop コマンドの使い方を知るために初期化スクリプトを覗いてみるのもいいでしょう。これらは標準的な RedHat の初期化スクリプトには、たいてい含まれています。これらが使われるのは旧式な RAID のためなので、自動検出付きの新しい RAID には用をなしません。その行は削ってしまいましょう、それですべてうまくいきます。
<P>

<SECT1>
<!--
Booting on RAID
-->
RAID でブート
<P>
<!-- 0.90.6 で変更
There are several ways to set up a system that mounts it's root
filesystem on a RAID device.  At the moment, only the graphical
install of RedHat Linux 6.1 allows direct installation to a RAID
device.  So most likely you're in for a little tweaking if you want
this, but it is indeed possible.
-->
RAID デバイス上のルートファイルシステムにシステムをセットアップするにはいくつかの方法があります。
今のところ、RedHat Linux 6.1 のグラフィカル・インストールだけが、RAID デバイスへの直接インストールを提供しているにすぎません。
ですから、やりたければ少しひねる必要がありますが、ちゃんと可能なことです。
<P>
<!-- 0.90.6 で変更
The latest official lilo distribution (Version 21) doesn't handle RAID
devices, and thus the kernel cannot be loaded at boot-time from a RAID
device. If you use this version, your <TT>/boot</TT> filesystem will
have to reside on a non-RAID device.  A way to ensure that your system
boots no matter what is, to create similar <TT>/boot</TT> partitions
on all drives in your RAID, that way the BIOS can always load data
from eg. the first drive available.  This requires that you do not
boot with a failed disk in your system.
-->
最新の公式な lilo ディストリビューション(バージョン 21 )では RAID デバイスを扱いません、ですからブート時にカーネルを RAID デバイスからロードすることはできません。このバージョンを使っている場合は <tt>/boot</tt> ファイルシステムは RAID でないデバイスの上に置かなければならないことになります。システムが確実にブートする方法は RAID デバイス中のすべてのドライブ上に同じように <tt>/boot</tt> パーティションを作り、BIOS が利用できる(例えば一番目の)ドライブから常にデータをロードするように設定することです。そのためにはシステム中の故障したディスクからブートしようとしてはいけません。
<P>
<!-- 0.90.6 で追加
With redhat 6.1 a patch to lilo 21 has become available that can
handle <TT>/boot</TT> on RAID-1. Note that it doesn't work for any
other level, RAID-1 (mirroring) is the only supported RAID level. This
patch (<TT>lilo.raid1</TT>) can be found in <TT>
dist/redhat-6.1/SRPMS/SRPMS/lilo-0.21-10.src.rpm</TT> on any redhat
mirror. The patched version of LILO will accept <TT>boot=/dev/md0</TT>
in <TT>lilo.conf</TT> and will make each disk in the mirror bootable.
-->
redhat 6.1 では、RAID-1 で <TT>/boot</TT> を扱うことができる lilo 21 へのパッチが利用できるようになりました。
他のレベルでは働きません、注意してください。RAID-1 (ミラーリング) だけがサポートされる RAID レベルです。
このパッチ (<TT>lilo.raid1</TT>) は、redhat のどのミラーでも <TT>dist/redhat-6.1/SRPMS/SRPMS/lilo-0.21-10.src.rpm</TT> で見つかるでしょう。
このパッチを適用された LILO は、 <TT>lilo.conf</TT> の中で <TT>boot=/dev/md0</TT> という命令を受け付けるようになり、ミラーを構成するどちらのディスクからでもブートできるようにしてくれます。
<P>
<!--
Another way of ensuring that your system can always boot is, to create
a boot floppy when all the setup is done. If the disk on which the
<TT>/boot</TT> filesystem resides dies, you can always boot from the
floppy.
-->
システムが確実にブートすることができるもう一つの方法は、全てのセットアップが終了した時点でブート・フロッピーを作ることです。<tt>/boot</tt> ファイルシステムを載せたディスクが死んでも、いつでもフロッピーからブートすることができます。
<P>

<SECT1>
<!--
Root filesystem on RAID
-->
RAID 上のルートファイルシステム
<P>
<!--
In order to have a system booting on RAID, the root filesystem (/)
must be mounted on a RAID device. Two methods for achieving this is
supplied bellow. Because none of the current distributions (that I
know of at least) support installing on a RAID device, the methods
assume that you install on a normal partition, and then - when the
installation is complete - move the contents of your non-RAID root
filesystem onto a new RAID device.
-->
システムを RAID 上でブートするには、ルートファイルシステム（ / ）が RAID デバイス上でマウントされなければなりません。これを実現する 2 つの方法を以下に示します。現在のディストリビューション（少なくとも私が知っている）は RAID デバイス上にインストールすることをサポートしていませんから、方法としては普通の(RAID ではない)パーティションにインストールを行ない、インストールが終了した後に RAID でないルートファイルシステムの内容を新しい RAID デバイスに移動します。
<P>
<SECT2>
<!--
Method 1
-->
方法 1
<P>
<!--
This method assumes you have a spare disk you can install the system
on, which is not part of the RAID you will be configuring.
-->
この方法では、これから構成しようとしている RAID とは別に予備のディスクを用意し、その上にシステムをインストールします。
<P>
<ITEMIZE>
<!--
<ITEM>First, install a normal system on your extra disk.</ITEM>
<ITEM>Get the kernel you plan on running, get the raid-patches and the
tools, and make your system boot with this new RAID-aware
kernel. Make sure that RAID-support is <BF>in</BF> the kernel, and is
not loaded as modules.</ITEM>
<ITEM>Ok, now you should configure and create the RAID you plan to use
for the root filesystem. This is standard procedure, as described
elsewhere in this document.</ITEM>
<ITEM>Just to make sure everything's fine, try rebooting the system to
see if the new RAID comes up on boot. It should.</ITEM>
<ITEM>Put a filesystem on the new array (using
<TT>mke2fs</TT>), and mount it under /mnt/newroot</ITEM>
<ITEM>Now, copy the contents of your current root-filesystem (the
spare disk) to the new root-filesystem (the array). There are lots of
ways to do this, one of them is
<VERB>
 cd /
 find . -xdev | cpio -pm /mnt/newroot
</VERB></ITEM>
<ITEM>You should modify the <TT>/mnt/newroot/etc/fstab</TT> file to
 use the correct device (the <TT>/dev/md?</TT> root device) for the
 root filesystem.</ITEM>
<ITEM>Now, unmount the current <TT>/boot</TT> filesystem, and mount
 the boot device on <TT>/mnt/newroot/boot</TT> instead. This is
 required for LILO to run successfully in the next step.</ITEM>
<ITEM>Update <TT>/mnt/newroot/etc/lilo.conf</TT> to point to the right
 devices. The boot device must still be a regular disk (non-RAID
 device), but the root device should point to your new RAID. When
 done, run <VERB> lilo -r /mnt/newroot</VERB>This LILO run should
 complete 
 with no errors.</ITEM>
 <ITEM>Reboot the system, and watch everything come up as expected  :)
 </ITEM>
-->
<item>最初は、普通のシステムを予備ディスク上にインストールします。
<item>カーネル、パッチ、raidtools を用意し、新しい RAID 対応カーネルでシステムをブートします。RAID サポートはモジュールとしてロードするのでなく、カーネルに組み込みます。
<item>次に、ルートファイルシステムとして使う予定の RAID を設定、構築を行ないます。これはこの文書のどこかに記述してあるように、ごく普通の方法で行ないます。
<item>RAID がブート時にきちんと動作することを確認するためにシステムをリブートしてみます。動くはずです。
<item>新しいアレイにファイルシステムを作り（<tt>mke2fs</tt> を使う）、/mnt/newroot にマウントします。
<item>新しいルートファイルシステム（アレイ）に、現在のルートファイルシステム（予備ディスク）の内容をコピーします。いろいろ方法はありますが、たとえば、このようにします。
<VERB>
 cd /
 find . -xdev | cpio -pm /mnt/newroot
</VERB>
<item>ルートファイルシステムとして正しいデバイスを使うために <tt>/mnt/newroot/etc/fstab</tt> ファイルを修正します（<tt>/dev/md?</tt> をルートデバイスにします）。
<item>現在の <tt>/boot</tt> ファイルシステムをアンマウントして、その代わりにブートデバイスを <tt>/mnt/newroot/boot</tt> にマウントします。これは次のステップで LILO をうまく走らせるために必要です。
<item>正しいデバイスを指すように <tt>/mnt/newroot/etc/lilo.conf</tt> を修正します。ブートデバイスはまだ普通のディスク（RAID でないデバイス）でなければなりませんが、ルートデバイスは新しい RAID を示している必要があります。その作業が終わったら、<VERB> lilo -r /mnt/newroot</VERB> を実行します。LILO はエラーなしで完了しなければなりません。
<item>システムを再起動します、すべてが予定通り立ち上がるのを確認してください :)
</ITEMIZE>
<P>
<!--
If you're doing this with IDE disks, be sure to tell your BIOS that
all disks are ``auto-detect'' types, so that the BIOS will allow your
machine to boot even when a disk is missing.
-->
この作業を IDE ディスクでしているならば、BIOS で全てのディスクを「auto-detect」タイプに設定してください。そうすれば BIOS がディスクの 1台を見つけられないような時でもマシンはブートすることができるでしょう。
<P>
<SECT2>
<!--
Method 2
-->
方法 2
<P>
<!--
This method requires that you use a raidtools/patch that includes the
failed-disk directive. This will be the tools/patch for all kernels
from 2.2.10 and later.
-->
この方法は、failed-disk 命令の使える raidtools とパッチを使う必要があります。これは 2.2.10 以降のすべてのカーネルのための raidtools とパッチとなるでしょう。
<P>
<!--
You can <BF>only</BF> use this method on RAID levels 1 and above.  The
idea is to install a system on a disk which is purposely marked as
failed in the RAID, then copy the system to the RAID which will be
running in degraded mode, and finally making the RAID use the
no-longer needed ``install-disk'', zapping the old installation but
making the RAID run in non-degraded mode.
-->
この方法は RAID レベル 1 以上<bf>のみ</bf>で使用することができます。意図的に故障とマークされたディスク上にシステムをインストールし、それからデグレードモードで走ることになる RAID にコピーし、最後に不要になった「インストールディスク」の古いシステムを消去して RAID を構築し、非デグレードモードで動作させます。

（訳注：デグレードモード "degraded mode" というのは、冗長性のある RAID の一部が故障しているが、データの完全性は保たれている状態のことです）
<P>
<ITEMIZE>
<!--
<ITEM>First, install a normal system on one disk (that will later
become part of your RAID). It is important that this disk (or
partition) is not the smallest one. If it is, it will not be possible
to add it to the RAID later on!</ITEM>
<ITEM>Then, get the kernel, the patches, the tools etc. etc. You know
the drill. Make your system boot with a new kernel that has the RAID
support you need, compiled into the kernel.</ITEM>
<ITEM>Now, set up the RAID with your current root-device as the
<TT>failed-disk</TT> in the <TT>raidtab</TT> file. Don't put the
<TT>failed-disk</TT> as the first disk in the <TT>raidtab</TT>, that will give
you problems with starting the RAID. Create the RAID, and put a
filesystem on it.</ITEM>
<ITEM>Try rebooting and see if the RAID comes up as it should</ITEM>
<ITEM>Copy the system files, and reconfigure the system to use the
RAID as root-device, as described in the previous section.</ITEM>
<ITEM>When your system successfully boots from the RAID, you can
modify the <TT>raidtab</TT> file to include the previously
<TT>failed-disk</TT> as a normal <TT>raid-disk</TT>. Now,
<TT>raidhotadd</TT> the disk to your RAID.</ITEM>
<ITEM>You should now have a system that can boot from a non-degraded
RAID.</ITEM> 
-->
<item>最初は、普通のシステムを 1 台のディスク（後で RAID に組み込まれます）上にインストールします。このディスク（またはパーティション）が最も小さいものでないことが重要です。さもないと後で RAID に加えることができなくなります！
<item>カーネル、パッチ、raidtools などを入手してきましょう。必要な RAID サポートを組み込んだ新しいカーネルで、システムがブートするようにします。
<item><tt>raidtab</tt> ファイルのルートデバイスを <tt>failed-disk</tt> として RAID をセットアップします。<tt>raidtab</tt> には <tt>failed-disk</tt> を最初のディスクとして置いてはいけません。RAID を始動する時に問題になります。RAID を構築し、ファイルシステムを作ります。
<item>リブートしてみて、予定通り RAID が立ち上がることを確認します。
<item>前のセクションにおいて記述されてるのと同様のやり方で、システムファイルをコピーして、ルートデバイスとして RAID を使うようにシステムを再設定します。
<item>システムが RAID からうまくブートしたら、<tt>raidtab</tt> ファイルを修正し、<tt>failed-disk</tt> とされていたディスクを普通の RAID ディスクとします。次に raidhotadd コマンドでそのディスクを RAID に組み込みます。
<item>デグレードモードじゃない（まともな）RAID からブートすることができるシステムができているはずです。
</ITEMIZE>
<P>

<SECT1>
<!--
Making the system boot on RAID
-->
RAID でブートするシステムを作る
<P>
<!--
For the kernel to be able to mount the root filesystem, all support
for the device on which the root filesystem resides, must be present
in the kernel. Therefore, in order to mount the root filesystem on a
RAID device, the kernel <EM>must</EM> have RAID support.
-->
ルートファイルシステムをマウントすることができるカーネルのために、ルートファイルシステムが置かれるデバイスの全てのサポートはカーネルに組み込まれていなければなりません。したがって、RAID デバイス上でルートファイルシステムをマウントするためには、カーネルに RAID サポートが組み込まれて<em>いなければ</em>なりません。
<P>
<!--
The normal way of ensuring that the kernel can see the RAID device is
to simply compile a kernel with all necessary RAID support compiled
in. Make sure that you compile the RAID support <EM>into</EM> the
kernel, and <EM>not</EM> as loadable modules. The kernel cannot load a 
module (from the root filesystem) before the root filesystem is
mounted.
-->
カーネルから RAID デバイスが見えることを確認する普通の方法は、単に全ての必要な RAID サポートを組み込んでカーネルをコンパイルすることです。RAID サポートをローダブルモジュール<em>ではなく</em>、カーネル<em>に</em>組みこんでいることを確認してください。カーネルはモジュールのロードを(ルートファイルシステムから)ルートファイルシステムがマウントされる前に行なうことはできません。
<P>
<!--
However, since RedHat-6.0 ships with a kernel that has new-style RAID
support as modules, I here describe how one can use the standard
RedHat-6.0 kernel and still have the system boot on RAID.
-->
しかし RedHat 6.0 からはモジュールとして新しい RAID サポートを持つカーネルが含まれていますから、ここではどのように標準の RedHat 6.0 カーネルで RAID 上からシステムをブートさせるかについて記述します。
<P>
<SECT2>
<!--
Booting with RAID as module
-->
モジュールを使用して RAID でブート
<P>
<!--
You will have to instruct LILO to use a RAM-disk in order to achieve
this. Use the <TT>mkinitrd</TT> command to create a ramdisk containing 
all kernel modules needed to mount the root partition. This can be
done as:
-->
ブートさせるためには、LILO に RAM ディスクを使うように指示する必要があります。「ルートパーティションをマウントするのに必要な全てのカーネルモジュールを含んでいる RAM ディスクをつくれ」という <tt>mkinitrd</tt> コマンドを使います。

このようにします。

<VERB>
 mkinitrd --with=&lt;module&gt; &lt;ramdisk name&gt; &lt;kernel&gt;
</VERB>
<!--
For example:
-->
具体的には、このようになります。
<VERB>
 mkinitrd --with=raid5 raid-ramdisk 2.2.5-22
</VERB>
<P>
<!--
This will ensure that the specified RAID module is present at
boot-time, for the kernel to use when mounting the root device.
-->
これにより、カーネルがルートデバイスをマウントするために必要な RAID モジュールがブート時に存在することが保証されます。
<P>

<SECT1>
<!--
Pitfalls
-->
落し穴
<P>
<!--
Never NEVER <BF>never</BF> re-partition disks that are part of a running
RAID. If you must alter the partition table on a disk which is a part
of a RAID, stop the array first, then repartition.
-->
決して、決して、<bf>決して</bf>、稼働している RAID の一部であるディスクのパーティションの切り直しをしてはいけません。RAID の一部であるディスク上のパーティションテーブルを変更する必要があるのなら、最初にアレイを止めます。その後にパーティションを切り直すのです。
<P>
<!--
It is easy to put too many disks on a bus. A normal Fast-Wide SCSI bus
can sustain 10 MB/s which is less than many disks can do alone
today. Putting six such disks on the bus will of course not give you
the expected performance boost.
-->
非常に多くのディスクをバス上に付けることは簡単です。普通の Fast-Wide SCSI バスは 10 MB/s をサポートできますが、これは今日ではほとんどのディスク単独での性能よりも少ない値です。そんなバスにディスクを 6 台置いても期待したパフォーマンスは出ません。
<P>
<!--
More SCSI controllers will only give you extra performance, if the
SCSI busses are nearly maxed out by the disks on them.  You will not
see a performance improvement from using two 2940s with two old SCSI
disks, instead of just running the two disks on one controller.
-->
SCSI バスがバス上のディスクの能力でほとんど満杯になるようなら、SCSI コントローラを複数にすることが、性能向上の唯一の方法となります。2 台の古い SCSI ディスク（1台のコントローラ上で 2台のディスクを走らせることでなくて）で、2 枚の 2940 を使っても性能向上は見られません。
<P>
<!--
If you forget the persistent-superblock option, your array may not
start up willingly after it has been stopped.  Just re-create the
array with the option set correctly in the raidtab.
-->
persistent-superblock オプションを忘れた場合、停止させた後はうまく起動しなくなるかもしれません。raidtab でオプションを正しくセットしなおして、アレイを再構成してください。
<P>
<!--
If a RAID-5 fails to reconstruct after a disk was removed and
re-inserted, this may be because of the ordering of the devices in the
raidtab. Try moving the first ``device ...'' and ``raid-disk ...''
pair to the bottom of the array description in the raidtab file.
-->
RAID-5 でディスクが外され、再挿入後に再構築が失敗する場合、それは raidtab の中のデバイスの順序のためかもしれません。最初の「device...」と「raid-disk...」のペアを raidtab ファイルの中のアレイに関する記述の下の方へ動かしてみてください。
<P>

<SECT>
<!--
Testing
-->
テスト
<P>
<!--
If you plan to use RAID to get fault-tolerance, you may also want to
test your setup, to see if it really works.  Now, how does one
simulate a disk failure ?
-->
フォールトトレランスを得るために RAID を使う予定があり、またそれが本当に動作するかどうかを調べるために設定をテストしたいかもしれませんね。では、どのようにディスク故障をシミュレーションしたらよいでしょうか？
<P>
<!--
The short story is, that you can't, except perhaps for putting a fire
axe thru the drive you want to ``simulate'' the fault on.  You can
never know what will happen if a drive dies. It may electrically take
the bus it's attached to with it, rendering all drives on that bus
inaccessible. I've never heard of that happening though. The drive may
also just report a read/write fault to the SCSI/IDE layer, which in
turn makes the RAID layer handle this situation gracefully.  This is
fortunately the way things often go.
-->
はっきり言って、正常動作しているディスクで故障をシミュレーションするのは無理な話です。ドライブが死んだら何が起こるかを知ることはできません。電気的にバスを乗っ取って、バス上の全てのドライブをアクセス不能にするかもしれません。私はこれまでそういうことが起こったことは聞いたことがありません。ドライブは SCSI/IDE レイヤに読込み・書込みのエラーを報告するかもしれません。そうしてくれれば RAID レイヤは状況を素直に扱うことができるのです。ま、だいたいは期待通りに動いてくれると思います。
<P>
<SECT1>
<!--
Simulating a drive failure
-->
ドライブの故障をシミュレーションする
<P>
<!--
If you want to simulate a drive failure, then plug out the drive. You
should do this with the <BF>power off</BF>.  If you are interested in
testing whether your data can survive with a disk less than the usual
number, there is no point in being a hot-plug cowboy here. Take the
system down, unplug the disk, and boot it up again.
-->
ドライブ故障をシミュレーションしたいのなら、ドライブを外すことです。その場合は必ず<bf>電源を落としてからにして</bf>ください。ディスク数を減らしてデータが生き残るかどうかについて調べたいならば、システムを停止してディスクを抜き、再起動すれば良いのです。
<P>
<!--
Look in the syslog, and look at &mdstat; to see how the RAID is
doing.  Did it work ?
-->
syslog と &mdstat; で RAID がどうなっているかを見ます。うまく動いていますか？
<P>
<!--
Remember, that you <BF>must</BF> be running RAID-{1,4,5} for your
array to be able to survive a disk failure.  Linear- or RAID-0 will
fail completely when a device is missing.
-->
ディスク故障を乗り切るには、RAID-{1,4,5} を走らせて<bf>いなければなりません。</bf>デバイスが見つからないとき、リニアモードと RAID-0 は完全に破綻します。
<P>
<!--
When you've re-connected the disk again (with the power off, of
course, remember), you can add the ``new'' device to the RAID again,
with the <TT>raidhotadd</TT> command.
-->
ディスクを再接続（もちろん電源が落ちている状態で接続するのを忘れずに）した場合は、<tt>raidhotadd</tt> 命令で再び「新しい」デバイスを RAID に加えることができます。
<P>
<SECT1>
<!--
Simulating data corruption
-->
データの破壊をシミュレーションする
<P>
<!--
RAID (be it hardware- or software-), assumes that if a write to a disk
doesn't return an error, then the write was successful. Therefore, if
your disk corrupts data without returning an error, your data
<EM>will</EM> become corrupted.  This is of course very unlikely to
happen, but it is possible, and it would result in a corrupt
filesystem.
-->
RAID（ハードでもソフトでも）では、書き込み時にエラーが返らないと成功とみなされます。したがって、ディスクがエラーを返すことなくデータが壊れたら、結局、データは破壊されるわけです。もちろんこれは起こりそうにないことですが、皆無ではありません。そして結果としてファイルシステムをも破壊することになるのです。
<P>
<!--
RAID cannot and is not supposed to guard against data corruption on
the media. Therefore, it doesn't make any sense either, to purposely
corrupt data (using <TT>dd</TT> for example) on a disk to see how the
RAID system will handle that.  It is most likely (unless you corrupt
the RAID superblock) that the RAID layer will never find out about the
corruption, but your filesystem on the RAID device will be corrupted.
-->
RAID はメディア上のデータ破壊に対する保護は想定していません。したがって RAID システムがどうするのかを見ようとして、ディスクに故意に不正なデータを書き込む（例えば <tt>dd</tt> を使って）ようなことは意味のないことです。RAID レイヤは破壊を検出しないでしょうが（RAID のスーパーブロックを破壊しない限り）、RAID デバイス上のファイルシステムは破壊されます。
<P>
<!--
This is the way things are supposed to work.  RAID is not a guarantee
for data integrity, it just allows you to keep your data if a disk
dies (that is, with RAID levels above or equal one, of course).
-->
これは当然のことです。RAID はデータの完全性に対する保証ではありません。ディスクが死んだ時にデータを守ってくれるものです（もちろん RAID レベル 1 以上）。
<P>

<SECT>
<!--
Reconstruction
-->
再構築
<P>
<!--
If you've read the rest of this HOWTO, you should already have a pretty
good idea about what reconstruction of a degraded RAID involves. I'll
summarize: 
-->
この HOWTO を読み進んできたなら、デグレード RAID の再構築について、すでにかなりよいアイデアがあるはずです。簡単にまとめると−
<ITEMIZE>
<!--
<ITEM>Power down the system
<ITEM>Replace the failed disk
<ITEM>Power up the system once again.
<ITEM>Use <TT>raidhotadd /dev/mdX /dev/sdX</TT> to re-insert the disk
in the array
<ITEM>Have coffee while you watch the automatic reconstruction running
-->
<item>システムの電源を落とす
<item>壊れたディスクを交換する
<item>システムの電源を再投入する
<item>アレイにディスクを元通りに挿入するために <tt>raidhotadd /dev/mdX /dev/sdX</tt> コマンドを使用する
<item>自動再構築を見てる間はコーヒーでもどうぞ
</ITEMIZE>
<!--
And that's it.
-->
ということになりましょうか。
<P>
<!--
Well, it usually is, unless you're unlucky and you RAID has been
rendered unusable because more disks than the ones redundant
failed. This can actually happen if a number of disks reside on the
same bus, and one disk takes the bus with it as it crashes. The other
disks, however fine, will be unreachable to the RAID layer, because
the bus is down, and they will be marked as faulty.  On a RAID-5 where
you can spare one disk, loosing two or more disks can be fatal.
-->
さて、冗長分よりも多くのディスクが故障したことにより RAID が使えなくなるという事態は、普通に起こりうることです。たくさんのディスクが同じバスにつながっていると、実際に起こることがあります。1台のディスククラッシュがバスに影響を及ぼすのです。他のディスクが正常な状態でもバスがダウンしているので RAID レイヤに到達できず、故障とマークされるのです。1台のディスクを冗長とする RAID-5 の上で 2台以上のディスク故障は致命的です。
<P>
<!--
The following section is the explanation that Martin Bene gave to me,
and describes a possible recovery from the scary scenario outlined
above. It involves using the <TT>failed-disk</TT> directive in your
&raidtab;, so this will only work on kernels 2.2.10 and later.
-->
以下のセクションは Martin Bene が私に説明してくれたことであって、前述の恐ろしいシナリオからの回復方法を記述します。それには &raidtab; に failed-disk の記述をする必要がありますので、カーネル 2.2.10 以降でないと動作しません。
<P>
<SECT1>
<!--
Recovery from a multiple disk failure
-->
複数ディスクの故障からの回復
<P>
<!--
The scenario is:
-->
シナリオは、以下の通りです。
<ITEMIZE>
<!--
<ITEM>A controller dies and takes two disks offline at the same time,
<ITEM>All disks on one scsi bus can no longer be reached if a disk dies,
<ITEM>A cable comes loose...
-->
<item>コントローラが死んで、同時に 2 台のディスクがオフラインになる
<item>1 台のディスクが死ぬと、scsi バス上のすべてのディスクが認識されなくなる
<item>ケーブルがはずれる．．．
</ITEMIZE>
<!--
In short: quite often you get a <EM>temporary</EM> failure of several
disks at once; afterwards the RAID superblocks are out of sync and you
can no longer init your RAID array.
-->
要するに− たびたび起こる複数ディスクの<em>一時的な</em>故障によって RAID スーパーブロックの sync がうまくいかなくなり、もはや RAID アレイを初期化できなくなった状態です。
<P>
<!--
One thing left: rewrite the RAID superblocks by <TT>mkraid −−force</TT>
-->
残された道は、<tt>mkraid --force</tt> によって RAID スーパーブロックを書き直すことです。
<P>
<!--
To get this to work, you'll need to have an up to date &raidtab; - if
it doesn't <BF>EXACTLY</BF> match devices and ordering of the original
disks this won't work.
-->
これがうまく動作するためには最新の &raidtab; が必要で、オリジナルと<bf>ぴったりマッチ</bf>するデバイスと順序を守らないとうまくいきません。
<P>
<!--
Look at the sylog produced by trying to start the array, you'll see the
event count for each superblock; usually it's best to leave out the disk
with the lowest event count, i.e the oldest one.
-->
アレイを始動しようとした時の syslog を見ると、各スーパーブロックのイベントカウントが見られます。通常、最も低いイベントカウントのディスク（つまり最も古いもの）を除いておくのがベストです。
<P>
<!--
If you <TT>mkraid</TT> without <TT>failed-disk</TT>, the recovery
thread will kick in immediately and start rebuilding the parity blocks
- not necessarily what you want at that moment.
-->
<tt>failed-disk</tt> なしに <tt>mkraid</tt> するとリカバリスレッドがすぐに起動し、パリティブロックの再構築が始まります。−いま必要なものじゃないですね。
<P>
<!--
With <TT>failed-disk</TT> you can specify exactly which disks you want
to be active and perhaps try different combinations for best
results. BTW, only mount the filesystem read-only while trying this
out... This has been successfully used by at least two guys I've been in
contact with.
-->
<tt>failed-disk</tt> ありなら、正確にどのディスクをアクティブにしたいかについて指定することができ、おそらく最善の結果のために異なる組み合わせを試してみることができます。この手順を試す間は、ファイルシステムはリードオンリーでマウントするようにすべきです。この方法で、私の知っている少なくとも 2 人はうまくいきました。
<P>

<SECT>
<!--
Performance
-->
パフォーマンス
<P>
<!--
This section contains a number of benchmarks from a real-world system
using software RAID.
-->
このセクションでは Software RAID を使っている現実のシステムから、たくさんのベンチマークを並べてみました。
<P>
<!--
Benchmarks are done with the <TT>bonnie</TT> program, and at all times
on files twice- or more the size of the physical RAM in the machine.
-->
ベンチマークは <tt>かわいい</tt> プログラムで、マシンの物理メモリの 2 倍以上のサイズのファイルを使います。
<P>
<!--
The benchmarks here <EM>only</EM> measures input and output bandwidth
on one large single file.  This is a nice thing to know, if it's
maximum I/O throughput for large reads/writes one is interested in.
However, such numbers tell us little about what the performance would
be if the array was used for a news spool, a web-server, etc. etc.
Always keep in mind, that benchmarks numbers are the result of running
a ``synthetic'' program. Few real-world programs do what
<TT>bonnie</TT> does, and although these I/O numbers are nice to look
at, they are not ultimate real-world-appliance performance
indicators. Not even close.
-->
ベンチマークは 1 つの大きなファイルの入出力バンド幅を計測する<em>だけ</em>です。大規模な read/write における最大の I/O スループットに興味があるならば、知っている価値のある素晴らしいものです。しかしそのような数字はアレイがニューススプール、ウェブサーバ、その他、実用された場合にどの程度のパフォーマンスが出るだろうかについては、まったく役に立たないものです。ベンチマークの数字は「人工的な」プログラムを実行した結果であるということに留意すべきです。現実のほとんどのプログラムと同じような動きをするものではないため、これらの数字は見るのには良いけれども、現実の世界では道具として使えるものではありません。
<P>
<!--
For now, I only have results from my own machine. The setup is:
-->
今のところ、私自身のマシンの結果だけです。構成は−
<ITEMIZE>
<!--
<ITEM>Dual Pentium Pro 150 MHz</ITEM>
<ITEM>256 MB RAM (60 MHz EDO)</ITEM>
<ITEM>Three IBM UltraStar 9ES 4.5 GB, SCSI U2W</ITEM>
<ITEM>Adaptec 2940U2W</ITEM>
<ITEM>One IBM UltraStar 9ES 4.5 GB, SCSI UW</ITEM>
<ITEM>Adaptec 2940 UW</ITEM>
<ITEM>Kernel 2.2.7 with RAID patches</ITEM>
-->
<ITEM>デュアル Pentium Pro 150 MHz</ITEM>
<ITEM>256 MB RAM (60 MHz EDO)</ITEM>
<ITEM>IBM UltraStar 9ES 4.5 GB(SCSI U2W) × 3</ITEM>
<ITEM>Adaptec 2940U2W</ITEM>
<ITEM>IBM UltraStar 9ES 4.5 GB(SCSI UW) × 1</ITEM>
<ITEM>Adaptec 2940 UW</ITEM>
<ITEM>Kernel 2.2.7 ＋ RAID パッチ</ITEM>
</ITEMIZE>
<P>
<!--
The three U2W disks hang off the U2W controller, and the UW disk off
the UW controller.
-->
3台の U2W ディスクは U2W コントローラにぶら下がり、UW ディスクは UW コントローラにぶら下がっています。
<P>
<!--
It seems to be impossible to push much more than 30 MB/s thru the SCSI
busses on this system, using RAID or not. My guess is, that because
the system is fairly old, the memory bandwidth sucks, and thus limits
what can be sent thru the SCSI controllers.
-->
このシステム上では RAID 使用の如何にかかわらず、30 MB/s 以上を SCSI バスに強引に通すことは不可能なようです。私の推測によると、システムがかなり古いのでメモリバンド幅が SCSI コントローラの能力を制限しているようです。
<P>
<SECT1>RAID-0
<P>
<!--
<BF>Read</BF> is <BF>Sequential block input</BF>, and <BF>Write</BF>
is <BF>Sequential block output</BF>. File size was 1GB in all
tests. The tests where done in single-user mode. The SCSI driver was
configured not to use tagged command queuing.
-->
<bf>Read</bf> は<bf>連続したブロックの入力</bf>であり、<bf>Write</bf> は<bf>連続したブロックの出力</bf>です。ファイルサイズは全てのテストで 1 GB でした。テストはシングルユーザーモードで行いました。SCSI ドライバは TCQ（Tagged Command Queueing）を使わない設定にしました。
<!--
<P>
<TABLE>
<TABULAR CA="|l|l|l|l|">
 Chunk size | Block size | Read KB/s | Write  KB/s @@
 4k  | 1k | 19712 | 18035 @
 4k  | 4k | 34048 | 27061 @
 8k  | 1k | 19301 | 18091 @
 8k  | 4k | 33920 | 27118 @
 16k | 1k | 19330 | 18179 @
 16k | 2k | 28161 | 23682 @
 16k | 4k | 33990 | 27229 @
 32k | 1k | 19251 | 18194 @
 32k | 4k | 34071 | 26976
</TABULAR>
</TABLE>
-->
<verb>
|Chunk size  |  Block size  |  Read KB/s  |  Write KB/s  |
|            |              |             |              |
|4k          |  1k          |  19712      |  18035       |
|4k          |  4k          |  34048      |  27061       |
|8k          |  1k          |  19301      |  18091       |
|8k          |  4k          |  33920      |  27118       |
|16k         |  1k          |  19330      |  18179       |
|16k         |  2k          |  28161      |  23682       |
|16k         |  4k          |  33990      |  27229       |
|32k         |  1k          |  19251      |  18194       |
|32k         |  4k          |  34071      |  26976       |
</verb>

<P>
<!--
From this it seems that the RAID chunk-size doesn't make that much
of a difference. However, the ext2fs block-size should be as large as
possible, which is 4KB (eg. the page size) on IA-32.
-->
上記より、RAID chunk-size を変えても性能に大きな差は出ないようです。しかし ext2fs ブロックサイズは可能な限り大きい方が良いようです。IA-32 では 4 KB です（例えばページサイズなど）。
<P>
<SECT1>
<!--
RAID-0 with TCQ
-->
TCQ による RAID-0
<P>
<!--
This time, the SCSI driver was configured to use tagged command
queuing, with a queue depth of 8. Otherwise, everything's the same as
before.
-->
今度は SCSI ドライバを、TCQ（Tagged Command Queueing）を使うように設定し、キューの深さを 8 としてます。それ以外は前と同じです。
<!--
<P>
<TABLE>
<TABULAR CA="|l|l|l|l|">
 Chunk size | Block size | Read KB/s | Write  KB/s @@
 32k | 4k | 33617 | 27215 
</TABULAR>
</TABLE>
-->
<verb>
|Chunk size  |  Block size  |  Read KB/s  |  Write KB/s  |
|            |              |             |              |
|32k         |  4k          |  33617      |  27215       |
</verb>

<P>
<!--
No more tests where done. TCQ seemed to slightly increase write
performance, but there really wasn't much of a difference at all.
-->
これ以上のテストはしてません。TCQ によって書込性能がわずかに向上しますが、全体としては大した違いはないと言えるでしょう。
<P>
<SECT1>RAID-5
<P>
<!--
The array was configured to run in RAID-5 mode, and similar tests
where done.
-->
アレイを RAID-5 モードで構成し、同様なテストを行ないました。
<!--
<P>
<TABLE>
<TABULAR CA="|l|l|l|l|">
 Chunk size | Block size | Read KB/s | Write  KB/s @@
 8k | 1k | 11090 | 6874 @
 8k | 4k | 13474 | 12229 @
 32k | 1k | 11442 | 8291 @
 32k | 2k | 16089 | 10926 @
 32k | 4k | 18724 | 12627
</TABULAR>
</TABLE>
-->
<verb>
|Chunk size  |  Block size  |  Read KB/s  |  Write KB/s  |
|            |              |             |              |
|8k          |  1k          |  11090      |  6874        |
|8k          |  4k          |  13474      |  12229       |
|32k         |  1k          |  11442      |  8291        |
|32k         |  2k          |  16089      |  10926       |
|32k         |  4k          |  18724      |  12627       |
</verb>
<P>
<!--
Now, both the chunk-size and the block-size seems to actually make a
difference.
-->
chunk-size とブロックサイズの両方が実際の差を作るようです。
<P>
<SECT1>RAID-10
<P>
<!--
RAID-10 is ``mirrored stripes'', or, a RAID-1 array of two RAID-0
arrays. The chunk-size is the chunk sizes of both the RAID-1 array and
the two RAID-0 arrays. I did not do test where those chunk-sizes
differ, although that should be a perfectly valid setup.
-->
RAID-10 は「ミラー化ストライプ」、あるいは 2 つの RAID-0 アレイの RAID-1 アレイです。chunk-size は RAID-1 アレイと 2 つの RAID-0 アレイの chunk-size です。非常に意味のある設定だと思いますが、chunk-size を変えた場合にどうなるかというテストはしませんでした。
<!--
<P>
<TABLE>
<TABULAR CA="|l|l|l|l|">
 Chunk size | Block size | Read KB/s | Write  KB/s @@
 32k | 1k | 13753 | 11580 @ 
 32k | 4k | 23432 | 22249
</TABULAR>
</TABLE>
-->
<verb>
|Chunk size  |  Block size  |  Read KB/s  |  Write KB/s  |
|            |              |             |              |
|32k         |  1k          |  13753      |  11580       |
|32k         |  4k          |  23432      |  22249       |
</verb>
<P>
<!--
No more tests where done. The file size was 900MB, because the four
partitions involved where 500 MB each, which doesn't give room for a
1G file in this setup (RAID-1 on two 1000MB arrays).
-->
これ以上のテストはしていません。ファイルサイズは 900 MB でした。実は 4 つのパーティションはそれぞれ 500 MB で、この設定（2つの 1000 MB のアレイの RAID-1）では 1 G のファイルのためのスペースがなかったものですから。
<P>

<SECT>
<!--
Credits
-->
クレジット
<P>
<!--
The following people contributed to the creation of this
documentation:
-->
以下の人々が、この文書の作成に貢献してくださいました。
<ITEMIZE>
<ITEM>Ingo Molnar
<ITEM>Jim Warren
<ITEM>Louis Mandelstam
<ITEM>Allan Noah
<ITEM>Yasunori Taniike
<ITEM>Martin Bene
<ITEM>The Linux-RAID mailing list people
<!--
<ITEM>The ones I forgot,  sorry   :)
-->
<ITEM>忘れちゃった方は、ごめんなさい :)
</ITEMIZE>
<P>
<!--
Please submit corrections, suggestions etc. to the author. It's the
only way this HOWTO can improve.
-->
訂正、提案、等ありましたら著者まで送ってください。それが、この HOWTO を改善できる唯一の方法です。
<P>
訳注：
以下の人々が、日本語訳について指摘、アドバイスを下さいました。特に、早川さんには当初、JF への中継役をかって出てくださいました。ありがとうございました。
<ITEMIZE>
<ITEM>早川仁＠Asahiネット
<ITEM>武井伸光
</ITEMIZE>

</ARTICLE>
