LQWiki - User contributions [en]

RAID

2007-03-31T05:18:41Z

Texastwister: /* Combination RAID Levels */ spelling correction

== What is RAID? ==

'''RAID''' stands for "Redundant Array of Independent Disks". It allows multiple physical hard drives to be used as one device. There are many different types or "levels" of RAID for different purposes.

=== Can I use it? ===

RAID capabilities are considered essential for most server-class computers and are widely implemented on servers. But there is no reason that RAID cannot be used on more basic PCs as well. Any computer capable of supporting more than one hard-disk can use RAID.

=== Why Might I Want it? ===
RAID capabilities can provide several benefits:
* Redundancy -- If one disk fails, one or more others have the same data and can prevent data loss until the failed drive is replaced.
* Performance -- Data can be written to more than one drive at a time, improving overall transfer rates.
* Convenience -- The space from several physical disks can be addressed as though it were single device. This can be done without RAID using [[symlink]]s and well designed [[mount point]]s, but may be easier to set up with RAID.

The different RAID levels provide these benefits in different combinations -- A linear RAID (sometime called "concatenation") provides convenience, but no performance or redundancy benefits. RAID 0 offers performance benefits, but no redundancy. RAID 1 offers redundancy but no performance benefit. Most other RAID types offer some combination of both performance and redundancy benefits.

=== What is the Difference Between Software and Hardware RAID? ===
RAID can be implemented either by a dedicated hardware device or through software.

In hardware RAID, the drives are attached to a controller card with a dedicated processor chip. The controller card handles the creation of the RAID and any parity calculations that must be made and presents the storage to the operating system as though each array were a single drive instead of an array of several physical drives. Using hardware RAID, an operating system does not need to know anything about RAID since it simply sees what it believes to be physical disks. True hardware RAID controllers are based on SCSI controllers or SAS (Serial-Attached-SCSI) controllers. While there are a few IDE-based or SATA-based RAID controllers that are true hardware RAID controllers in the conventional sense, in many cases these cards are actually driver-based RAID as explained below.

In software RAID, the creation of the array and all of the calculations involved are handled by software (most often by the OS itself). This does add a small amount of additional overhead to the system CPU, but in most systems it is a negligable amount.

=== What is Driver-based RAID or Fake-RAID? ===
Some "RAID cards", most notably a large number of SATA (serial ATA) RAID controllers are marketed as though they are true hardware RAID controllers -- when in fact they are little more than plain SATA controllers that are shipped with a device driver (usually Windows-only) that implements software RAID at a driver level instead of in the OS kernel. In these devices, the driver passes the tasks of creating the arrays, calculating parity, and etc., to the system CPU -- thus differing little in effect from software RAID as discussed above.

An additional drawback to such cards stems from the fact that most vendors initially provide full RAID functionality only in the Windows versions of their drivers. In Linux, many such cards must be configured as ordinary IDE or SATA controllers and then the OS is used to provide RAID functionality with normal software RAID.

See http://linux-ata.org/faq-sata-raid.html for more information.

== Simple RAID Levels ==

There are only a few basic RAID types although they can be combined together to produce combination types.

Basic RAID types supported by Linux software RAID include Linear, RAID-0, RAID-1, RAID-4, and RAID-5

=== Linear ===
A RAID in Linear mode offers no redundancy benefit and very little performance benefit. It would be used only because it allows the storage space on multiple physical hard drives to be addressed as a single device. As shown below, it fills the first device before writing to the next.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}
|
Physical
Disk 2
{| border=2
<pre>
data4
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
xxxxx
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. The disks do not have to be of the same size. So, if I form a Linear RAID of a 10 GB and two 20 GB disks, the usable size of the array is the full 50 GB.

In the event of a drive failure, only the files stored on the affected drive would be lost. For example, in the illustration above, if disk 2 failed, only data4 and data5 would be lost.

=== RAID-0 ===

RAID-0 is also known as "striping". It spreads data across several hard drives so that the system can be reading from several drives at once, increasing performance. Like Linear RAID, RAID-0 offers no redundancy.

RAID-0 is popular amongst gamers, for whom performance is more important than reduced reliability.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data4
xxxxx
</pre>
|}
|
Physical
Disk 2
{| border=2
<pre>
data2
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data3
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. So, if I form a RAID-0 of three 20 GB disks, the usable size of the array is the full 60 GB.

It is advisable, but not required, to use disks of identical size (the performance benefit to this RAID is reduced if one drive is substantially larger than the rest). In theory the speed of a RAID-0 array is roughly that of the slowest drive times the number of drives, although it will usually be slower in the real world.

In the event of a drive failure, since files can be spread across multiple disks, most or all of the data in the array will probably be lost.

=== RAID-1 ===

RAID-1 is also known as "mirroring". It creates a duplicate copy of data on another hard drive (or several more) so that if one of the drives fails, no data is lost. This RAID level offers good redundancy, but no performance benefit. In fact, while read performance is equivalent to that of a single drive, write performance is a bit lower than when using a single drive.

RAID-1 is most commonly implemented using only two drives, but Linux software RAID supports the use of multiple drive -- each an exact copy of the others.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data1
data2
data3
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is the same as the space available on the smallest of the hard drives being used. So, if I form a RAID-1 of a 10 GB and a 20 GB disk, the usable size of the array is only 10 GB.

Since each disk in the array is an exact copy of the same data, a RAID-1 array can withstand the failure of one or several drives, so long as at least one remains intact.

=== RAID-4 ===

RAID-4 is also known as "striping with dedicated parity". It requires at least three disks to create. One of them is used exclusively for parity data and the rest contain striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data3
data5
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
data4
data6
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
parity1-2
parity3-4
parity5-6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-4 of two 10 GB disks and one 20 GB disk, the usable size of the array is 20 GB.

A RAID-4 can withstand the failure of any single drive without data loss. If the failed drive is the parity drive, the array can continue to function because all of the actual data is still intact on the other drives. If the failed drive is one of the data drives, the array can continue to function by using the parity information and the data on the remaining drive(s) to calculate what data the failed drive should be storing if it were functioning. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

=== RAID-5 ===

RAID-5 is also known as "striping with distributed parity". It requires at least three disks to create. Each of them is used for both parity data and striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
| Physical
Disk 1
{| border=2
<pre>
data1
data3
parity5-6
</pre>
|}

| Physical
Disk 2
{| border=2
<pre>
data2
parity3-4
data5
</pre>
|}
| Physical
Disk 3
{| border=2
<pre>
parity1-2
data4
data6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-5 of three 10 GB disks, the usable size of the array is 20 GB.

A RAID-5 can withstand the failure of any single drive without data loss. When any single drive fails the array can continue to function because all of the actual data is either still intact on the other drives or able to be reconstructed from the remaining data plus the parity information on the other drives. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

== Combination RAID Levels ==
Arrays can be built using other arrays just as they can from drives or partitions. This allows the creation of "nested", "multiple", or "combination" RAID types.

Combining simple RAID types with different strengths can often provide the best of both worlds. For example, RAID 0 offers great performance but no redundancy while RAID 1 offers redundancy but no performance advantage. Combining them into a RAID 0+1 or a RAID 10 offers both -- with even better redundancy that in a basic RAID 1.

Combinations can be formed of any RAID types supported by Linux, but the most common variations are probably:
* RAID 0+1 -- Mirroring of stripe sets
* RAID 10 -- Striping across mirror sets
* RAID 50 -- Striping across RAID 5 sets

=== Naming Conventions ===
Although usage of these conventions is not always consistent, the general rule is that the first digit in the name describes the RAID type first or at the lowest level. The second digit describes the RAID type applied second or at the logically higher level.

For example, a RAID 0+1 (so named to prevent people from assuming that a RAID 01 is the same as a RAID 1) is created by first building two or more stripe sets (identical size and configuration) and then building a mirror from them.

A RAID 10 would be created in the opposite sequence -- building multiple mirrors from paired disks and then creating a strip set across them.

=== RAID 0+1: Mirroring of Stripe sets ===

RAID 0+1 provides better performance than simple RAID 1 along with the redundancy that simple RAID 0 lacks. It requires at least four drives to implement and provides usable space equal to S*N/2 where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID 0+1 of four 10 GB disks, the usable size of the array is 20 GB.

{| border=0
| RAID 0+1 (Mirroring of Stripe sets)
{| border=1
| First Stripe Set
{| border=1
| Disk 1
<pre>
Data1
Data4
xxx</pre>
| Disk 2
<pre>Data2
Data5
xxx</pre>
| Disk 3
<pre>Data3
Data6
xxx</pre>
|}
| Second Stripe Set
{| border=1
| Disk 4
<pre>Data1
Data4
xxx</pre>
| Disk 5
<pre>Data2
Data5
xxx</pre>
| Disk 6
<pre>Data3
Data6
xxx</pre>
|}
|}
|}

A RAID 0+1 can withstand the failure of a single drive (or multiple drives, so long as they are all from the same stripe set).

=== RAID 10: Striping across Mirror sets ===

RAID 10 provides better performance than simple RAID 1 along with the redundancy that simple RAID 0 lacks. It requires at least four drives to implement and provides usable space equal to S*N/2 where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID 10 of four 10 GB disks, the usable size of the array is 20 GB.

RAID 0+1 and RAID 10 are very similar but, by most measures of both performance and redundancy, RAID 10 is considered to be preferable.

{| border=0
| RAID 10 -- Striping across Mirror sets
{| border=1
| Mirror 1
{| border=1
| Disk 1
<pre>
Data1
Data4
</pre>
| Disk 2
<pre>
Data1
Data4
</pre>
|}

| Mirror 2
{| border=1
| Disk 3
<pre>
Data2
Data5
</pre>
| Disk 4
<pre>
Data2
Data5
</pre>
|}

| Mirror 3
{| border=1
| Disk 5
<pre>
Data3
Data6
</pre>
| Disk 6
<pre>
Data3
Data6
</pre>
|}

|}
|}

A RAID 10 can withstand the failure of a single drive (or multiple drives, so long as they are NOT in the same mirror set).

=== RAID 50: Striping across RAID 5 sets===

RAID 50 provides better write performance and improved redundancy over simple RAID 5 along with the redundancy that simple RAID 0 lacks. It requires at least six drives to implement and (assuming all drives are the same size) provides usable space equal to S * (N-1) * R where 'S' is the size of the smallest of the hard drives being used, 'N' is the number of disks in each RAID 5 array, and 'R' is the number of RAID 5 sets used in the stripe set. So, if I form a RAID 50 of six 10 GB disks, the usable size of the array is 40 GB.

{| border=0
| RAID 50 -- Striping across RAID 5 sets
{| border=1
| RAID 5
Set 1
{| border=1
| Disk 1
<pre>
Data1
Data5
Parity 9,11
</pre>
| Disk 2
<pre>
Data3
Parity 5,7
Data9
</pre>
| Disk 3
<pre>
Parity 1,3
Data7
Data11
</pre>
|}
| RAID 5
Set 2
{| border=1
| Disk 4
<pre>
Data2
Data6
Parity 10,12
</pre>
| Disk 5
<pre>
Data4
Parity 6,8
Data10
</pre>
| Disk 6
<pre>
Parity 2,4
Data8
Data12
</pre>
|}
|}

|}

A RAID 50 can withstand the failure of one drive in each RAID 5.

== Configuring Linux Software RAID ==

Linux software RAID can be configured in several different ways. Some installation tools allow for the creation of arrays during the OS install. An older (but still maintained) set of tools known collectively as ''raidtools'' can be used to create or modify an array after the OS install. A newer tool known as mdadm is considered by some to be easier to use.

Post-installation configuration of Linux software RAID consists of several steps:

* Create partitions for use. Configure them as Linux RAID Automounting partitions (hex code "fd")
* Use mdadm to create the array.
* Create the /etc/raidtab file (lsraid -R -p is useful to generate a template raidtab file, but it may require some editing).
* Create a filesystem on the partition
* Mount the partition and/or add the partition to /etc/fstab

=== Partition Drives ===
Partitioning is always a thorny problem. People have trouble with their root and boot file systems running in software RAID configurations, although both are possible. If hardware is managing your RAID, you probably won't be reading this. NB Some so-called RAID controllers are nothing more than a BIOS front for two IDE ports: e.g. [[Promise]] [[FastTrak]]. This is [[Software Raid]], like a [[WinModem]] is a type of modem.

You can use the partition type 'FD' (the hex value) for linux RAID autodetect. If you have the right stuff compiled in or a terribly complicated initrd setup), the arrays should be detected at boot time, then all your configuration is complete and you can refer to the drives as /dev/md*.
This is better than having post boot init scripts to sort out the raid, and allows the root partition to be raided.

=== Create the RAID ===
The raidtools/raidtools2 package seems out of date. Use the concise mdadm tool to build your software managed RAID arrays.

=== Create a filesystem on the RAID ===
Or duplicate one. A common strategy in migrating to RAID is to create matching partitions on the new empty disk, copy the data over, then set up 'degraded' arrays.

mdadm --create /dev/md0 --raid-level=raid1 -n=2 missing /dev/hdg5

where hdg5 is the newly create partition. "MISSING" will be added into the raid array once the configuration of the array is otherwise complete. This allows a lower-risk migration, although backups are essential.

=== Create an <tt>/etc/raidtab</tt> file ===
This is not necessary if you have the kernel autodetecting the arrays at boot time

=== Choose or create a mountpoint ===

=== Modify the <tt>/etc/fstab</tt> file to mount at boot ===

RAID

2007-03-31T04:57:40Z

Texastwister: /* What is the Difference Between Software and Hardware RAID */

== What is RAID? ==

'''RAID''' stands for "Redundant Array of Independent Disks". It allows multiple physical hard drives to be used as one device. There are many different types or "levels" of RAID for different purposes.

=== Can I use it? ===

RAID capabilities are considered essential for most server-class computers and are widely implemented on servers. But there is no reason that RAID cannot be used on more basic PCs as well. Any computer capable of supporting more than one hard-disk can use RAID.

=== Why Might I Want it? ===
RAID capabilities can provide several benefits:
* Redundancy -- If one disk fails, one or more others have the same data and can prevent data loss until the failed drive is replaced.
* Performance -- Data can be written to more than one drive at a time, improving overall transfer rates.
* Convenience -- The space from several physical disks can be addressed as though it were single device. This can be done without RAID using [[symlink]]s and well designed [[mount point]]s, but may be easier to set up with RAID.

The different RAID levels provide these benefits in different combinations -- A linear RAID (sometime called "concatenation") provides convenience, but no performance or redundancy benefits. RAID 0 offers performance benefits, but no redundancy. RAID 1 offers redundancy but no performance benefit. Most other RAID types offer some combination of both performance and redundancy benefits.

=== What is the Difference Between Software and Hardware RAID? ===
RAID can be implemented either by a dedicated hardware device or through software.

In hardware RAID, the drives are attached to a controller card with a dedicated processor chip. The controller card handles the creation of the RAID and any parity calculations that must be made and presents the storage to the operating system as though each array were a single drive instead of an array of several physical drives. Using hardware RAID, an operating system does not need to know anything about RAID since it simply sees what it believes to be physical disks. True hardware RAID controllers are based on SCSI controllers or SAS (Serial-Attached-SCSI) controllers. While there are a few IDE-based or SATA-based RAID controllers that are true hardware RAID controllers in the conventional sense, in many cases these cards are actually driver-based RAID as explained below.

In software RAID, the creation of the array and all of the calculations involved are handled by software (most often by the OS itself). This does add a small amount of additional overhead to the system CPU, but in most systems it is a negligable amount.

=== What is Driver-based RAID or Fake-RAID? ===
Some "RAID cards", most notably a large number of SATA (serial ATA) RAID controllers are marketed as though they are true hardware RAID controllers -- when in fact they are little more than plain SATA controllers that are shipped with a device driver (usually Windows-only) that implements software RAID at a driver level instead of in the OS kernel. In these devices, the driver passes the tasks of creating the arrays, calculating parity, and etc., to the system CPU -- thus differing little in effect from software RAID as discussed above.

An additional drawback to such cards stems from the fact that most vendors initially provide full RAID functionality only in the Windows versions of their drivers. In Linux, many such cards must be configured as ordinary IDE or SATA controllers and then the OS is used to provide RAID functionality with normal software RAID.

See http://linux-ata.org/faq-sata-raid.html for more information.

== Simple RAID Levels ==

There are only a few basic RAID types although they can be combined together to produce combination types.

Basic RAID types supported by Linux software RAID include Linear, RAID-0, RAID-1, RAID-4, and RAID-5

=== Linear ===
A RAID in Linear mode offers no redundancy benefit and very little performance benefit. It would be used only because it allows the storage space on multiple physical hard drives to be addressed as a single device. As shown below, it fills the first device before writing to the next.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}
|
Physical
Disk 2
{| border=2
<pre>
data4
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
xxxxx
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. The disks do not have to be of the same size. So, if I form a Linear RAID of a 10 GB and two 20 GB disks, the usable size of the array is the full 50 GB.

In the event of a drive failure, only the files stored on the affected drive would be lost. For example, in the illustration above, if disk 2 failed, only data4 and data5 would be lost.

=== RAID-0 ===

RAID-0 is also known as "striping". It spreads data across several hard drives so that the system can be reading from several drives at once, increasing performance. Like Linear RAID, RAID-0 offers no redundancy.

RAID-0 is popular amongst gamers, for whom performance is more important than reduced reliability.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data4
xxxxx
</pre>
|}
|
Physical
Disk 2
{| border=2
<pre>
data2
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data3
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. So, if I form a RAID-0 of three 20 GB disks, the usable size of the array is the full 60 GB.

It is advisable, but not required, to use disks of identical size (the performance benefit to this RAID is reduced if one drive is substantially larger than the rest). In theory the speed of a RAID-0 array is roughly that of the slowest drive times the number of drives, although it will usually be slower in the real world.

In the event of a drive failure, since files can be spread across multiple disks, most or all of the data in the array will probably be lost.

=== RAID-1 ===

RAID-1 is also known as "mirroring". It creates a duplicate copy of data on another hard drive (or several more) so that if one of the drives fails, no data is lost. This RAID level offers good redundancy, but no performance benefit. In fact, while read performance is equivalent to that of a single drive, write performance is a bit lower than when using a single drive.

RAID-1 is most commonly implemented using only two drives, but Linux software RAID supports the use of multiple drive -- each an exact copy of the others.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data1
data2
data3
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is the same as the space available on the smallest of the hard drives being used. So, if I form a RAID-1 of a 10 GB and a 20 GB disk, the usable size of the array is only 10 GB.

Since each disk in the array is an exact copy of the same data, a RAID-1 array can withstand the failure of one or several drives, so long as at least one remains intact.

=== RAID-4 ===

RAID-4 is also known as "striping with dedicated parity". It requires at least three disks to create. One of them is used exclusively for parity data and the rest contain striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data3
data5
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
data4
data6
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
parity1-2
parity3-4
parity5-6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-4 of two 10 GB disks and one 20 GB disk, the usable size of the array is 20 GB.

A RAID-4 can withstand the failure of any single drive without data loss. If the failed drive is the parity drive, the array can continue to function because all of the actual data is still intact on the other drives. If the failed drive is one of the data drives, the array can continue to function by using the parity information and the data on the remaining drive(s) to calculate what data the failed drive should be storing if it were functioning. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

=== RAID-5 ===

RAID-5 is also known as "striping with distributed parity". It requires at least three disks to create. Each of them is used for both parity data and striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
| Physical
Disk 1
{| border=2
<pre>
data1
data3
parity5-6
</pre>
|}

| Physical
Disk 2
{| border=2
<pre>
data2
parity3-4
data5
</pre>
|}
| Physical
Disk 3
{| border=2
<pre>
parity1-2
data4
data6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-5 of three 10 GB disks, the usable size of the array is 20 GB.

A RAID-5 can withstand the failure of any single drive without data loss. When any single drive fails the array can continue to function because all of the actual data is either still intact on the other drives or able to be reconstructed from the remaining data plus the parity information on the other drives. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

== Combination RAID Levels ==
Arrays can be built using other arrays just as they can from drives or partitions. This allows the creation of "nested", "multiple", or "combination" RAID types.

Combining simple RAID types with different strengths can often provide the best of both worlds. For example, RAID 0 offers great performance but no redundancy while RAID 1 offers redundancy but no performance advantage. Combining them into a RAID 0+1 or a RAID 10 offers both -- with even better redundancy that in a basic RAID 1.

Combinations can be formed of any RAID types supported by Linux, but the most common variations are probably:
* RAID 0+1 -- Mirroring of strip sets
* RAID 10 -- Striping across mirror sets
* RAID 50 -- Striping across RAID 5 sets

=== Naming Conventions ===
Although usage of these conventions is not always consistent, the general rule is that the first digit in the name describes the RAID type first or at the lowest level. The second digit describes the RAID type applied second or at the logically higher level.

For example, a RAID 0+1 (so named to prevent people from assuming that a RAID 01 is the same as a RAID 1) is created by first building two or more stripe sets (identical size and configuration) and then building a mirror from them.

A RAID 10 would be created in the opposite sequence -- building multiple mirrors from paired disks and then creating a strip set across them.

=== RAID 0+1: Mirroring of Stripe sets ===

RAID 0+1 provides better performance than simple RAID 1 along with the redundancy that simple RAID 0 lacks. It requires at least four drives to implement and provides usable space equal to S*N/2 where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID 0+1 of four 10 GB disks, the usable size of the array is 20 GB.

{| border=0
| RAID 0+1 (Mirroring of Stripe sets)
{| border=1
| First Stripe Set
{| border=1
| Disk 1
<pre>
Data1
Data4
xxx</pre>
| Disk 2
<pre>Data2
Data5
xxx</pre>
| Disk 3
<pre>Data3
Data6
xxx</pre>
|}
| Second Stripe Set
{| border=1
| Disk 4
<pre>Data1
Data4
xxx</pre>
| Disk 5
<pre>Data2
Data5
xxx</pre>
| Disk 6
<pre>Data3
Data6
xxx</pre>
|}
|}
|}

A RAID 0+1 can withstand the failure of a single drive (or multiple drives, so long as they are all from the same stripe set).

=== RAID 10: Striping across Mirror sets ===

RAID 10 provides better performance than simple RAID 1 along with the redundancy that simple RAID 0 lacks. It requires at least four drives to implement and provides usable space equal to S*N/2 where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID 10 of four 10 GB disks, the usable size of the array is 20 GB.

RAID 0+1 and RAID 10 are very similar but, by most measures of both performance and redundancy, RAID 10 is considered to be preferable.

{| border=0
| RAID 10 -- Striping across Mirror sets
{| border=1
| Mirror 1
{| border=1
| Disk 1
<pre>
Data1
Data4
</pre>
| Disk 2
<pre>
Data1
Data4
</pre>
|}

| Mirror 2
{| border=1
| Disk 3
<pre>
Data2
Data5
</pre>
| Disk 4
<pre>
Data2
Data5
</pre>
|}

| Mirror 3
{| border=1
| Disk 5
<pre>
Data3
Data6
</pre>
| Disk 6
<pre>
Data3
Data6
</pre>
|}

|}
|}

A RAID 10 can withstand the failure of a single drive (or multiple drives, so long as they are NOT in the same mirror set).

=== RAID 50: Striping across RAID 5 sets===

RAID 50 provides better write performance and improved redundancy over simple RAID 5 along with the redundancy that simple RAID 0 lacks. It requires at least six drives to implement and (assuming all drives are the same size) provides usable space equal to S * (N-1) * R where 'S' is the size of the smallest of the hard drives being used, 'N' is the number of disks in each RAID 5 array, and 'R' is the number of RAID 5 sets used in the stripe set. So, if I form a RAID 50 of six 10 GB disks, the usable size of the array is 40 GB.

{| border=0
| RAID 50 -- Striping across RAID 5 sets
{| border=1
| RAID 5
Set 1
{| border=1
| Disk 1
<pre>
Data1
Data5
Parity 9,11
</pre>
| Disk 2
<pre>
Data3
Parity 5,7
Data9
</pre>
| Disk 3
<pre>
Parity 1,3
Data7
Data11
</pre>
|}
| RAID 5
Set 2
{| border=1
| Disk 4
<pre>
Data2
Data6
Parity 10,12
</pre>
| Disk 5
<pre>
Data4
Parity 6,8
Data10
</pre>
| Disk 6
<pre>
Parity 2,4
Data8
Data12
</pre>
|}
|}

|}

A RAID 50 can withstand the failure of one drive in each RAID 5.

== Configuring Linux Software RAID ==

Linux software RAID can be configured in several different ways. Some installation tools allow for the creation of arrays during the OS install. An older (but still maintained) set of tools known collectively as ''raidtools'' can be used to create or modify an array after the OS install. A newer tool known as mdadm is considered by some to be easier to use.

Post-installation configuration of Linux software RAID consists of several steps:

* Create partitions for use. Configure them as Linux RAID Automounting partitions (hex code "fd")
* Use mdadm to create the array.
* Create the /etc/raidtab file (lsraid -R -p is useful to generate a template raidtab file, but it may require some editing).
* Create a filesystem on the partition
* Mount the partition and/or add the partition to /etc/fstab

=== Partition Drives ===
Partitioning is always a thorny problem. People have trouble with their root and boot file systems running in software RAID configurations, although both are possible. If hardware is managing your RAID, you probably won't be reading this. NB Some so-called RAID controllers are nothing more than a BIOS front for two IDE ports: e.g. [[Promise]] [[FastTrak]]. This is [[Software Raid]], like a [[WinModem]] is a type of modem.

You can use the partition type 'FD' (the hex value) for linux RAID autodetect. If you have the right stuff compiled in or a terribly complicated initrd setup), the arrays should be detected at boot time, then all your configuration is complete and you can refer to the drives as /dev/md*.
This is better than having post boot init scripts to sort out the raid, and allows the root partition to be raided.

=== Create the RAID ===
The raidtools/raidtools2 package seems out of date. Use the concise mdadm tool to build your software managed RAID arrays.

=== Create a filesystem on the RAID ===
Or duplicate one. A common strategy in migrating to RAID is to create matching partitions on the new empty disk, copy the data over, then set up 'degraded' arrays.

mdadm --create /dev/md0 --raid-level=raid1 -n=2 missing /dev/hdg5

where hdg5 is the newly create partition. "MISSING" will be added into the raid array once the configuration of the array is otherwise complete. This allows a lower-risk migration, although backups are essential.

=== Create an <tt>/etc/raidtab</tt> file ===
This is not necessary if you have the kernel autodetecting the arrays at boot time

=== Choose or create a mountpoint ===

=== Modify the <tt>/etc/fstab</tt> file to mount at boot ===

RAID

2006-01-18T22:23:59Z

Texastwister: /* RAID-0 */ typos

== What is RAID? ==

'''RAID''' stands for "Redundant Array of Independent Disks". It allows multiple physical hard drives to be used as one device. There are many different types or "levels" of RAID for different purposes.

=== Can I use it? ===

RAID capabilities are considered essential for most server-class computers and are widely implemented on servers. But there is no reason that RAID cannot be used on more basic PCs as well. Any computer capable of supporting more than one hard-disk can use RAID.

=== Why Might I Want it? ===
RAID capabilities can provide several benefits:
* Redundancy -- If one disk fails, one or more others have the same data and can prevent data loss until the failed drive is replaced.
* Performance -- Data can be written to more than one drive at a time, improving overall transfer rates.
* Convenience -- The space from several physical disks can be addressed as though it were single device. This can be done without RAID using [[symlink]]s and well designed [[mount point]]s, but may be easier to set up with RAID.

The different RAID levels provide these benefits in different combinations -- A linear RAID (sometime called "concatenation") provides convenience, but no performance or redundancy benefits. RAID 0 offers performance benefits, but no redundancy. RAID 1 offers redundancy but no performance benefit. Most other RAID types offer some combination of both performance and redundancy benefits.

=== What is the Difference Between Software and Hardware RAID ===
RAID can be implemented either by a dedicated hardware device or through software.

In hardware RAID, the drives are attached to a controller card with a dedicated processor chip. The controller card handles the creation of the RAID and any parity calculations that must be made and presents the storage to the operating system as though each array were a single drive instead of an array of several physical drives. Using hardware RAID, an operating system does not need to know anything about RAID since it simply sees what it believes to be physical disks.

In software RAID, the creation of the array and all of the calculations involved are handled by the OS.

== Simple RAID Levels ==

There are only a few basic RAID types although they can be combined together to produce combination types.

Basic RAID types supported by Linux software RAID include Linear, RAID-0, RAID-1, RAID-4, and RAID-5

=== Linear ===
A RAID in Linear mode offers no redundancy benefit and very little performance benefit. It would be used only because it allows the storage space on multiple physical hard drives to be addressed as a single device. As shown below, it fills the first device before writing to the next.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}
|
Physical
Disk 2
{| border=2
<pre>
data4
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
xxxxx
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. The disks do not have to be of the same size. So, if I form a Linear RAID of a 10 GB and two 20 GB disks, the usable size of the array is the full 50 GB.

In the event of a drive failure, only the files stored on the affected drive would be lost. For example, in the illustration above, if disk 2 failed, only data4 and data5 would be lost.

=== RAID-0 ===

RAID-0 is also known as "striping". It spreads data across several hard drives so that the system can be reading from several drives at once, increasing performance. Like Linear RAID, RAID-0 offers no redundancy.

RAID-0 is popular amongst gamers, for whom performance is more important than reduced reliability.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data4
xxxxx
</pre>
|}
|
Physical
Disk 2
{| border=2
<pre>
data2
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data3
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. So, if I form a RAID-0 of three 20 GB disks, the usable size of the array is the full 60 GB.

It is advisable, but not required, to use disks of identical size (the performance benefit to this RAID is reduced if one drive is substantially larger than the rest). In theory the speed of a RAID-0 array is roughly that of the slowest drive times the number of drives, although it will usually be slower in the real world.

In the event of a drive failure, since files can be spread across multiple disks, most or all of the data in the array will probably be lost.

=== RAID-1 ===

RAID-1 is also known as "mirroring". It creates a duplicate copy of data on another hard drive (or several more) so that if one of the drives fails, no data is lost. This RAID level offers good redundancy, but no performance benefit. In fact, while read performance is equivalent to that of a single drive, write performance is a bit lower than when using a single drive.

RAID-1 is most commonly implemented using only two drives, but Linux software RAID supports the use of multiple drive -- each an exact copy of the others.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data1
data2
data3
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is the same as the space available on the smallest of the hard drives being used. So, if I form a RAID-1 of a 10 GB and a 20 GB disk, the usable size of the array is only 10 GB.

Since each disk in the array is an exact copy of the same data, a RAID-1 array can withstand the failure of one or several drives, so long as at least one remains intact.

=== RAID-4 ===

RAID-4 is also known as "striping with dedicated parity". It requires at least three disks to create. One of them is used exclusively for parity data and the rest contain striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data3
data5
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
data4
data6
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
parity1-2
parity3-4
parity5-6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-4 of two 10 GB disks and one 20 GB disk, the usable size of the array is 20 GB.

A RAID-4 can withstand the failure of any single drive without data loss. If the failed drive is the parity drive, the array can continue to function because all of the actual data is still intact on the other drives. If the failed drive is one of the data drives, the array can continue to function by using the parity information and the data on the remaining drive(s) to calculate what data the failed drive should be storing if it were functioning. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

=== RAID-5 ===

RAID-5 is also known as "striping with distributed parity". It requires at least three disks to create. Each of them is used for both parity data and striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
| Physical
Disk 1
{| border=2
<pre>
data1
data3
parity5-6
</pre>
|}

| Physical
Disk 2
{| border=2
<pre>
data2
parity3-4
data5
</pre>
|}
| Physical
Disk 3
{| border=2
<pre>
parity1-2
data4
data6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-5 of three 10 GB disks, the usable size of the array is 20 GB.

A RAID-5 can withstand the failure of any single drive without data loss. When any single drive fails the array can continue to function because all of the actual data is either still intact on the other drives or able to be reconstructed from the remaining data plus the parity information on the other drives. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

== Combination RAID Levels ==
Arrays can be built using other arrays just as they can from drives or partitions. This allows the creation of "nested", "multiple", or "combination" RAID types.

Combining simple RAID types with different strengths can often provide the best of both worlds. For example, RAID 0 offers great performance but no redundancy while RAID 1 offers redundancy but no performance advantage. Combining them into a RAID 0+1 or a RAID 10 offers both -- with even better redundancy that in a basic RAID 1.

Combinations can be formed of any RAID types supported by Linux, but the most common variations are probably:
* RAID 0+1 -- Mirroring of strip sets
* RAID 10 -- Striping across mirror sets
* RAID 50 -- Striping across RAID 5 sets

=== Naming Conventions ===
Although usage of these conventions is not always consistent, the general rule is that the first digit in the name describes the RAID type first or at the lowest level. The second digit describes the RAID type applied second or at the logically higher level.

For example, a RAID 0+1 (so named to prevent people from assuming that a RAID 01 is the same as a RAID 1) is created by first building two or more stripe sets (identical size and configuration) and then building a mirror from them.

A RAID 10 would be created in the opposite sequence -- building multiple mirrors from paired disks and then creating a strip set across them.

=== RAID 0+1: Mirroring of Stripe sets ===

RAID 0+1 provides better performance than simple RAID 1 along with the redundancy that simple RAID 0 lacks. It requires at least four drives to implement and provides usable space equal to S*N/2 where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID 0+1 of four 10 GB disks, the usable size of the array is 20 GB.

{| border=0
| RAID 0+1 (Mirroring of Stripe sets)
{| border=1
| First Stripe Set
{| border=1
| Disk 1
<pre>
Data1
Data4
xxx</pre>
| Disk 2
<pre>Data2
Data5
xxx</pre>
| Disk 3
<pre>Data3
Data6
xxx</pre>
|}
| Second Stripe Set
{| border=1
| Disk 4
<pre>Data1
Data4
xxx</pre>
| Disk 5
<pre>Data2
Data5
xxx</pre>
| Disk 6
<pre>Data3
Data6
xxx</pre>
|}
|}
|}

A RAID 0+1 can withstand the failure of a single drive (or multiple drives, so long as they are all from the same stripe set).

=== RAID 10: Striping across Mirror sets ===

RAID 10 provides better performance than simple RAID 1 along with the redundancy that simple RAID 0 lacks. It requires at least four drives to implement and provides usable space equal to S*N/2 where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID 10 of four 10 GB disks, the usable size of the array is 20 GB.

RAID 0+1 and RAID 10 are very similar but, by most measures of both performance and redundancy, RAID 10 is considered to be preferable.

{| border=0
| RAID 10 -- Striping across Mirror sets
{| border=1
| Mirror 1
{| border=1
| Disk 1
<pre>
Data1
Data4
</pre>
| Disk 2
<pre>
Data1
Data4
</pre>
|}

| Mirror 2
{| border=1
| Disk 3
<pre>
Data2
Data5
</pre>
| Disk 4
<pre>
Data2
Data5
</pre>
|}

| Mirror 3
{| border=1
| Disk 5
<pre>
Data3
Data6
</pre>
| Disk 6
<pre>
Data3
Data6
</pre>
|}

|}
|}

A RAID 10 can withstand the failure of a single drive (or multiple drives, so long as they are NOT in the same mirror set).

=== RAID 50: Striping across RAID 5 sets===

RAID 50 provides better write performance and improved redundancy over simple RAID 5 along with the redundancy that simple RAID 0 lacks. It requires at least six drives to implement and (assuming all drives are the same size) provides usable space equal to S * (N-1) * R where 'S' is the size of the smallest of the hard drives being used, 'N' is the number of disks in each RAID 5 array, and 'R' is the number of RAID 5 sets used in the stripe set. So, if I form a RAID 50 of six 10 GB disks, the usable size of the array is 40 GB.

{| border=0
| RAID 50 -- Striping across RAID 5 sets
{| border=1
| RAID 5
Set 1
{| border=1
| Disk 1
<pre>
Data1
Data5
Parity 9,11
</pre>
| Disk 2
<pre>
Data3
Parity 5,7
Data9
</pre>
| Disk 3
<pre>
Parity 1,3
Data7
Data11
</pre>
|}
| RAID 5
Set 2
{| border=1
| Disk 4
<pre>
Data2
Data6
Parity 10,12
</pre>
| Disk 5
<pre>
Data4
Parity 6,8
Data10
</pre>
| Disk 6
<pre>
Parity 2,4
Data8
Data12
</pre>
|}
|}

|}

A RAID 50 can withstand the failure of one drive in each RAID 5.

== Configuring Linux Software RAID ==

Linux software RAID can be configured in several different ways. Some installation tools allow for the creation of arrays during the OS install. An older (but still maintained) set of tools known collectively as ''raidtools'' can be used to create or modify an array after the OS install. A newer tool known as mdadm is considered by some to be easier to use.

Post-installation configuration of Linux software RAID consists of several steps:

* Create partitions for use. Configure them as Linux RAID Automounting partitions (hex code "fd")
* Use mdadm to create the array.
* Create the /etc/raidtab file (lsraid -R -p is useful to generate a template raidtab file, but it may require some editing).
* Create a filesystem on the partition
* Mount the partition and/or add the partition to /etc/fstab

=== Partition Drives ===
Partitioning is always a thorny problem. People have trouble with their root and boot file systems running in software RAID configurations, although both are possible. If hardware is managing your RAID, you probably won't be reading this. NB Some so-called RAID controllers are nothing more than a BIOS front for two IDE ports: e.g. [[Promise]] [[FastTrak]]. This is [[Software Raid]], like a [[WinModem]] is a type of modem.

You can use the partition type 'FD' (the hex value) for linux RAID autodetect. If you have the right stuff compiled in or a terribly complicated initrd setup), the arrays should be detected at boot time, then all your configuration is complete and you can refer to the drives as /dev/md*.
This is better than having post boot init scripts to sort out the raid, and allows the root partition to be raided.

=== Create the RAID ===
The raidtools/raidtools2 package seems out of date. Use the concise mdadm tool to build your software managed RAID arrays.

=== Create a filesystem on the RAID ===
Or duplicate one. A common strategy in migrating to RAID is to create matching partitions on the new empty disk, copy the data over, then set up 'degraded' arrays.

mdadm --create /dev/md0 --raid-level=raid1 -n=2 missing /dev/hdg5

where hdg5 is the newly create partition. "MISSING" will be added into the raid array once the configuration of the array is otherwise complete. This allows a lower-risk migration, although backups are essential.

=== Create an <tt>/etc/raidtab</tt> file ===
This is not necessary if you have the kernel autodetecting the arrays at boot time

=== Choose or create a mountpoint ===

=== Modify the <tt>/etc/fstab</tt> file to mount at boot ===

MrProject

2005-12-10T07:05:17Z

Texastwister: Planner was removed from Gnome Office

'''MrProject''' is an older name for an open-source project management application that is now known as Imendio Planner or Gnome Planner. Versions prior to 0.11 were known as MrProject and development was coordinated by a software company called Code Factory. With version 0.11, the coordinating role was assumed by European software company Imendio and the application was renamed to Imendio Planner.

MrProject/Planner was once a part of [[GNOME Office]]. It was removed in December 2003, apparently because the pace of development was lagging too far behind that of the other components.

==External links==
*[http://mrproject.codefactory.se/ MrProject homepage]
*[http://www.gnome.org/gnome-office/ Gnome Office homepage]
*[http://developer.imendio.com/wiki/Planner Development Wiki for Imendio Planner]

MrProject

2005-12-10T06:44:25Z

Texastwister: Note namechange from MrProject to Imendio Planner.

'''MrProject''' is an older name for an open-source project management application that is now known as Imendio Planner or Gnome Planner. Versions prior to 0.11 were known as MrProject and development was coordinated by a software company called Code Factory. With version 0.11, the coordinating role was assumed by European software company Imendio and the application was renamed to Imendio Planner. Planner is a part of [[GNOME Office]].

==External links==
*[http://mrproject.codefactory.se/ MrProject homepage]
*[http://www.gnome.org/gnome-office/ Gnome Office homepage]
http://developer.imendio.com/wiki/Planner

Mandriva

2004-04-30T17:57:53Z

Texastwister: Inserted a missing space.

'''Mandrake''' Linux was created in 1998 with the goal of making [[Linux]] easier to use for everyone. At that time, Linux was still a developer's [[operating system]] and sound knowledge of the [[CLI]] was a must.

[http://www.mandrakesoft.com MandrakeSoft] (the company which produces the Mandrake [[distribution]]) saw this as an opportunity to integrate the best graphical [[desktop environment]]s and contribute its own graphical configuration utilities and quickly became popular for setting the standard in ease-of-use and functionality. In order to achieve this they forked from [[Red Hat]], retained the [[RPM]]-based [[package]] management, and evolved from there.

It was one of the first distributions to be optimized for [[i586]] [[processor]]s (and superior). It developed a graphical installation process recognized by many as the best available, with advanced and efficient hardware detection. Mandrake Linux was also the first rpm-based distribution to provide automatic resolution of dependencies, with urpmi, which debuted in version 7.2. urpmi is now capable of updating the entire distribution, installing security updates, and many other features. A graphical interface to urpmi is provided in rpmdrake (and the MandrakeUpdate tool specifically for security updates).

The [[GPL]] (General Public License) governs the development and redistribution of Mandrake Linux and Mandrake Linux is community-driven to a large degree. Non-MandrakeSoft contributors have write access to packages in the main distribution, commit access to Mandrake's own tools in [[CVS]], full bug tracking rights in [http://qa.mandrakesoft.com Mandrake's bugzilla] and the [http://qa.mandrakesoft.com/wiki Mandrake Development wiki]. Over half the packages in the entire distribution (combining "main" and "contrib") are maintained by the community. For non-developers, support is available from the unofficial [http://mandrake.vmlinuz.ca Mandrake community wiki] and the [http://www.mandrakeusers.org Mandrake Users Board].

Although many see Mandrake as only a desktop-oriented distribution (and one of the best [[distribution]]s for the home desktop), a number of features give Mandrake some advantages over other distributions on servers. Successful cases of the use of Mandrake in business settings (in both desktop and server roles) are documented at [http://mandrakebizcases.com/ this site].

Mandrake's most recent version is Mandrakelinux 10.0 Official.

Distributions similar to Mandrake include:

*[[Red Hat]]
*[[SuSE]]
*[[Lorma]]
*[[Libranet]]

==External links==
*[http://www.mandrakelinux.com/en-us/ Official website]
*[http://www.mandrakelinux.com/en-us/concept.php3 Further information]

Remote desktop connection

2004-04-16T05:05:37Z

Texastwister: Clarified XDMCP

There are several techniques which can be used to establish a '''remote desktop connection''' between one computer and another.

[[ssh]] - SSH (secure shell) is one of the best remote login clients and servers, and is supplied with all Linux distributions. SSH can be used for a terminal or console session (a command prompt) like Telnet, but can also be configured to "tunnel" individual X-Windows applications as well. This would allow a user to, for example, log in to a remote system and launch a graphical application and have the application appear on the user's system. In such a scenario, the application would appear but NOT the full desktop.

[[XDMCP|Remote X-Windows with XDMCP]] - XDMCP allows remote login and access to an entire [[GUI]] environment through an X display manager such as Gnome's GDM (so long as the option is enabled).

[[VNC]] - VNC is also designed to forward an entire GUI environment. It is less efficient than X-Windows but the traffic is compressed (for low bandwidth connections), and clients exist for every major [[OS]]. It has a degree of protection for passwords, but the data itself is sent without encryption. It can be made more secure by tunnelling the connection via ssh.

[[Telnet]] - Telnet was one of the earliest attempts at remote administration. It is now considered inherently insecure (it sends everything in clear text) and largely obsolete, but may have some niche uses on trusted networks. Telnet provides only a console session with no capability of forwarding X-Windows applications or GUI environments.

[[rlogin]] - rlogin allows remote logins using the [[BSD]] "r" [[protocol]]. The "r" suite of utilities has been rendered obsolete by SSH, and like Telnet, is considered too insecure for regular use.

[[rdesktop]] - RDesktop is a Linux client that can attach to a Windows Server running Terminal Services or to the built-in Remote Desktop capability of Windows XP Pro. It is ideal for many who prefer to work from a Linux system, but who have an occasional need to access a Windows machine. RDesktop replicates a full Windows desktop in a window within Linux. -- also capabile of showing just one application

[[X11 forwarding with OpenSSH]] -- can forward your whole desktop, or just the application that you want.. X was built with this functionality in mind.

==See also==
*[[Networking]]

Common Tasks

2004-04-16T05:00:40Z

Texastwister:

Desktop Linux is still under heavy development. While we all wish Linux was so intuitive nobody needed instructions, currently that isn't always the case. This section is meant for '''notes and quick guides''' on how to perform common tasks on Linux.

If a section isn't yet written and you are able to write it, please do so!

== General user tasks ==

===Productivity===
* [[Browsing tasks]] - browsing the WWW and downloading safely
* [[Burning a CDROM]] - some pointers on how to write CDs.
* [[Emailing tasks]] - sending and receiving emails, setting up different mail applications
* [[Office tasks]] - word processing, spreadsheet, presentation, image manipulation and other
* [[Scanning]] - use a [[Scanner]] to convert you paper documents or images to an electronic format

===Fun===
* [[Gaming]] - pass some time ''not'' working
* [[Multimedia tasks]] - listen to music, extract CDs, watch videos and DVDs
* [[Talking to friends online]] - how to access common instant messaging networks, see also [[IM]].

===Technical===
* [[Command Line User Interface]] - Techniques for better experience
* [[Connecting to the net]] - using your modem/network connection to get online
* [[GRUB Menu]] - Single Task - Removing old kernel entries from your GRUB Menu boot up selections.
* [http://home.gagme.com/greg/linux/usbcamera.php How to Connect a Digital Camera to Linux (outside link)] - an excellent how-to on connecting digital cameras to Linux.
* [[Installing Software]] - how to find and manage additional software on a running Linux system
* [[Installing Windows fonts]] - installing your Windows fonts so they work with your Linux install.
* [[screenshots|Taking screenshots]] - You want to show somebody your desktop? There are tools that will help you make a [[screenshots | screenshot]] and [[record your desktop]] so that you can send movie-files of how nice your desktop looks.

== Power user tasks ==

* [[Compiling a Kernel]] - here is a guide for compiling a kernel
* [[Configure Storage Devices]] - how to partition a hard drive, add a new hard drive, use software RAID, or use LVM (logical volume management).
* [[Getting help from IRC]] - LinuxQuestions is a great forum, but it isn't the only one. If you know how, the IRC chat networks can also be a useful resource.
* [[GRUB boot menu]] - Configuration Guide.
* [[Installing NVIDIA drivers]] - Information on installing the newer (but closed-source) drivers released by NVIDIA. These drivers are sometimes required to run some games, like Unreal or Quake.
* [[Recover a Terminal Session]] - What to do if your screen's garbaged.
* [[Remote_Desktop_Connection|Access your System Remotely]] - Access your Linux system from another computer (running Linux, or some other OS) or use your Linux box to access another computer (running Linux, or some other OS).

== See Also ==
* [[Distro specific tips & tricks]]

Common Tasks

2004-04-16T04:57:42Z

Texastwister:

Desktop Linux is still under heavy development. While we all wish Linux was so intuitive nobody needed instructions, currently that isn't always the case. This section is meant for '''notes and quick guides''' on how to perform common tasks on Linux.

If a section isn't yet written and you are able to write it, please do so!

== General user tasks ==

===Productivity===
* [[Browsing tasks]] - browsing the WWW and downloading safely
* [[Burning a CDROM]] - some pointers on how to write CDs.
* [[Emailing tasks]] - sending and receiving emails, setting up different mail applications
* [[Office tasks]] - word processing, spreadsheet, presentation, image manipulation and other
* [[Scanning]] - use a [[Scanner]] to convert you paper documents or images to an electronic format

===Fun===
* [[Gaming]] - pass some time ''not'' working
* [[Multimedia tasks]] - listen to music, extract CDs, watch videos and DVDs
* [[Talking to friends online]] - how to access common instant messaging networks, see also [[IM]].

===Technical===
* [[Command Line User Interface]] - Techniques for better experience
* [[Connecting to the net]] - using your modem/network connection to get online
* [[GRUB Menu]] - Single Task - Removing old kernel entries from your GRUB Menu boot up selections.
* [http://home.gagme.com/greg/linux/usbcamera.php How to Connect a Digital Camera to Linux (outside link)] - an excellent how-to on connecting digital cameras to Linux.
* [[Installing Software]] - how to find and manage additional software on a running Linux system
* [[Installing Windows fonts]] - installing your Windows fonts so they work with your Linux install.
* [[screenshots|Taking screenshots]] - You want to show somebody your desktop? There are tools that will help you make a [[screenshots | screenshot]] and [[record your desktop]] so that you can send movie-files of how nice your desktop looks.

== Power user tasks ==

* [[Compiling a Kernel]] - here is a guide for compiling a kernel
* [[Configure Storage Devices]] - how to partition a hard drive, add a new hard drive, use software RAID, or use LVM (logical volume management).
* [[Getting help from IRC]] - LinuxQuestions is a great forum, but it isn't the only one. If you know how, the IRC chat networks can also be a useful resource.
* [[GRUB boot menu]] - Configuration Guide.
* [[Installing NVIDIA drivers]] - Information on installing the newer (but closed-source) drivers released by NVIDIA. These drivers are sometimes required to run some games, like Unreal or Quake.
* [[Recover a Terminal Session]] - What to do if your screen's garbaged.
* [[Remote_Desktop_Connection|Access your System Remotely]]

== See Also ==
* [[Distro specific tips & tricks]]

RAID

2004-03-20T06:30:42Z

Texastwister: Beginning to add info on RAID configuration.

''This article is a [[LinuxQuestions.org_Wiki:stub_articles|stub]] and needs to be finished. [[LinuxQuestions.org_Wiki:plunging_forward|Plunge forward]] and [[LinuxQuestions.org_Wiki:How_to_edit_a_page|help it grow]] !'' 

== What is RAID? ==

'''RAID''' stands for "Redundant Array of Independent Disks". It allows multiple physical hard drives to be used as one device. There are many different types or "levels" of RAID for different purposes.

=== Can I use it? ===

RAID capabilities are considered essential for most server-class computers and are widely implemented on servers. But there is no reason that RAID cannot be used on more basic PCs as well. Any computer capable of supporting more than one hard-disk can use RAID.

=== Why Might I Want it? ===
RAID capabilities can provide several benefits:
* Redundancy -- If one disk fails, one or more others have the same data and can prevent data loss until the failed drive is replaced.
* Performance -- Data can be written to more than one drive at a time, improving overall transfer rates.
* Convenience -- The space from several physical disks can be addressed as though it were single device.

The different RAID levels provide these benefits in different combinations -- A linear RAID (sometime called "concatenation") provides convenience, but no performance or redundancy benefits. RAID 0 offers performance benefits, but no redundancy. RAID 1 offers redundancy but no performance benefit. Most other RAID types offer some combination of both performance and redundancy benefits.

=== What is the Difference Between Software and Hardware RAID ===
RAID can be implemented either by a dedicated hardware device or through software.

In hardware RAID, the drives are attached to a controller card with a dedicated processor chip. The controller card handles the creation of the RAID and any parity calculations that must be made and presents the storage to the operating system as though each array were a single drive instead of an array of several physical drives. Using hardware RAID, an operating system does not need to know anything about RAID since it simply sees what it believes to be physical disks.

In software RAID, the creation of the array and all of the calculations involved are handled by the OS.

== Simple RAID Levels ==

There are only a few basic RAID types although they can be combined together to produce combination types.

Basic RAID types supported by Linux software RAID include Linear, RAID-0, RAID-1, RAID-4, and RAID-5

=== Linear ===
A RAID in Linear mode offers no redundancy benefit and very little performance benefit. It would be used only because it allows the storage space on multiple physical hard drives to be addressed as a single device. As shown below, it fills the first device before writing to the next.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data4
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
xxxxx
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. The disks do not have to be of the same size. So, if I form a Linear RAID of a 10 GB and two 20 GB disks, the usable size of the array is the full 50 GB.

In the event of a drive failure, only the files stored on the affected drive would be lost. For example, in the illustration above, if disk 2 failed, only data4 and data5 would be lost.

=== RAID-0 ===

RAID-0 is also known as "striping". It spreads data across several hard drives so that the system can be reading from several drives at once, increasing performance. Like Linear RAID, RAID-0 offers no redundancy.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data4
xxxxx
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data3
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. So, if I form a RAID-0 of three 20 GB disks, the usable size of the array is the full 60 GB.

It is advisable, but not required, to use disks of identical size (the performance benefit to this RAID is reduced if one drive is substantially larger than the rest).

In the event of a drive failure, since files can be spread across multiple disks, most or all of the data in the array will probably be lost.

=== RAID-1 ===

RAID-1 is also known as "mirroring". It creates a duplicate copy of data on another hard drive (or several more) so that if one of the drives fails, no data is lost. This RAID level offers good redundancy, but no performance benefit. In fact, while read performance is equivalent to that of a single drive, write performance is a bit lower than when using a single drive.

RAID-1 is most commonly implemented using only two drives, but Linux software RAID supports the use of multiple drive -- each an exact copy of the others.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data1
data2
data3
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is the same as the space available on the smallest of the hard drives being used. So, if I form a RAID-1 of a 10 GB and a 20 GB disk, the usable size of the array is only 10 GB.

Since each disk in the array is an exact copy of the same data, a RAID-1 array can withstand the failure of one or several drives, so long as at least one remains intact.

=== RAID-4 ===

RAID-4 is also known as "striping with dedicated parity". It requires at least three disks to create. One of them is used exclusively for parity data and the rest contain striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data3
data5
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
data4
data6
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
parity1-2
parity3-4
parity5-6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-4 of two 10 GB disks and one 20 GB disk, the usable size of the array is 20 GB.

A RAID-4 can withstand the failure of any single drive without data loss. If the failed drive is the parity drive, the array can continue to function because all of the actual data is still intact on the other drives. If the failed drive is one of the data drives, the array can continue to function by using the parity information and the data on the remaining drive(s) to calculate what data the failed drive should be storing if it were functioning. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

=== RAID-5 ===

RAID-5 is also known as "striping with distributed parity". It requires at least three disks to create. Each of them is used for both parity data and striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
| Physical
Disk 1
{| border=2
<pre>
data1
data3
parity5-6
</pre>
|}

| Physical
Disk 2
{| border=2
<pre>
data2
parity3-4
data5
</pre>
|}
| Physical
Disk 3
{| border=2
<pre>
parity1-2
data4
data6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-5 of three 10 GB disks, the usable size of the array is 20 GB.

A RAID-5 can withstand the failure of any single drive without data loss. When any single drive fails the array can continue to function because all of the actual data is either still intact on the other drives or able to be reconstructed from the remaining data plus the parity information on the other drives. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

== Combination RAID Levels ==
Arrays can be built using other arrays just as they can from drives or partitions. This allows the creation of "nested", "multiple", or "combination" RAID types.

Combining simple RAID types with different strengths can often provide the best of both worlds. For example, RAID 0 offers great performance but no redundancy while RAID 1 offers redundancy but no performance advantage. Combining them into a RAID 0+1 or a RAID 10 offers both -- with even better redundancy that in a basic RAID 1.

Combinations can be formed of any RAID types supported by Linux, but the most common variations are probably:
* RAID 0+1 -- Mirroring of strip sets
* RAID 10 -- Striping across mirror sets
* RAID 50 -- Striping across RAID 5 sets

=== Naming Conventions ===
Although usage of these conventions is not always consistent, the general rule is that the first digit in the name describes the RAID type first or at the lowest level. The second digit describes the RAID type applied second or at the logically higher level.

For example, a RAID 0+1 (so named to prevent people from assuming that a RAID 01 is the same as a RAID 1) is created by first building two or more stripe sets (identical size and configuration) and then building a mirror from them.

A RAID 10 would be created in the opposite sequence -- building multiple mirrors from paired disks and then creating a strip set across them.

=== RAID 0+1: Mirroring of Stripe sets ===

RAID 0+1 provides better performance than simple RAID 1 along with the redundancy that simple RAID 0 lacks. It requires at least four drives to implement and provides usable space equal to S*N/2 where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID 0+1 of four 10 GB disks, the usable size of the array is 20 GB.

{| border=0
| RAID 0+1 (Mirroring of Stripe sets)
{| border=1
| First Stripe Set
{| border=1
| Disk 1
<pre>
Data1
Data4
xxx</pre>
| Disk 2
<pre>Data2
Data5
xxx</pre>
| Disk 3
<pre>Data3
Data6
xxx</pre>
|}
| Second Stripe Set
{| border=1
| Disk 4
<pre>Data1
Data4
xxx</pre>
| Disk 5
<pre>Data2
Data5
xxx</pre>
| Disk 6
<pre>Data3
Data6
xxx</pre>
|}
|}
|}

A RAID 0+1 can withstand the failure of a single drive (or multiple drives, so long as they are all from the same stripe set).

=== RAID 10: Striping across Mirror sets ===

RAID 10 provides better performance than simple RAID 1 along with the redundancy that simple RAID 0 lacks. It requires at least four drives to implement and provides usable space equal to S*N/2 where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID 10 of four 10 GB disks, the usable size of the array is 20 GB.

RAID 0+1 and RAID 10 are very similar but, by most measures of both performance and redundancy, RAID 10 is considered to be preferable.

{| border=0
| RAID 10 -- Striping across Mirror sets
{| border=1
| Mirror 1
{| border=1
| Disk 1
<pre>
Data1
Data4
</pre>
| Disk 2
<pre>
Data1
Data4
</pre>
|}

| Mirror 2
{| border=1
| Disk 3
<pre>
Data2
Data5
</pre>
| Disk 4
<pre>
Data2
Data5
</pre>
|}

| Mirror 3
{| border=1
| Disk 5
<pre>
Data3
Data6
</pre>
| Disk 6
<pre>
Data3
Data6
</pre>
|}

|}
|}

A RAID 10 can withstand the failure of a single drive (or multiple drives, so long as they are NOT in the same mirror set).

=== RAID 50: Striping across RAID 5 sets===

RAID 50 provides better write performance and improved redundancy over simple RAID 5 along with the redundancy that simple RAID 0 lacks. It requires at least six drives to implement and (assuming all drives are the same size) provides usable space equal to S * (N-1) * R where 'S' is the size of the smallest of the hard drives being used, 'N' is the number of disks in each RAID 5 array, and 'R' is the number of RAID 5 sets used in the stripe set. So, if I form a RAID 50 of six 10 GB disks, the usable size of the array is 40 GB.

{| border=0
| RAID 50 -- Striping across RAID 5 sets
{| border=1
| RAID 5
Set 1
{| border=1
| Disk 1
<pre>
Data1
Data5
Parity 9,11
</pre>
| Disk 2
<pre>
Data3
Parity 5,7
Data9
</pre>
| Disk 3
<pre>
Parity 1,3
Data7
Data11
</pre>
|}
| RAID 5
Set 2
{| border=1
| Disk 4
<pre>
Data2
Data6
Parity 10,12
</pre>
| Disk 5
<pre>
Data4
Parity 6,8
Data10
</pre>
| Disk 6
<pre>
Parity 2,4
Data8
Data12
</pre>
|}
|}

|}

A RAID 50 can withstand the failure of one drive in each RAID 5.

== Configuring Linux Software RAID ==

Linux software RAID can be configured in several different ways. Some installation tools allow for the creation of arrays during the OS install. An older (but still maintained) set of tools known collectively as ''raidtools'' can be used to create or modify an array after the OS install. A newer tool known as mdadm is considered by some to be easier to use.

Post-installation configuration of Linux software RAID consists of several steps:

* Create partitions for use. Configure them as Linux RAID Automounting partitions (hex code "fd")
* Use mdadm to create the array.
* Create the /etc/raidtab file (lsraid -R -p is useful to generate a template raidtab file, but it may require some editing).
* Create a filesystem on the partition
* Mount the partition and/or add the partition to /etc/fstab

=== Partition Drives ===

=== Create the RAID ===

=== Create a filesystem on the RAID ===

=== Create an <tt>/etc/raidtab</tt> file ===

=== Choose or create a mountpoint ===

=== Modify the <tt>/etc/fstab</tt> file to mount at boot ===

RAID

2004-03-18T22:13:53Z

Texastwister: Added details on RAID 50

''This article is a [[LinuxQuestions.org_Wiki:stub_articles|stub]] and needs to be finished. [[LinuxQuestions.org_Wiki:plunging_forward|Plunge forward]] and [[LinuxQuestions.org_Wiki:How_to_edit_a_page|help it grow]] !'' 

== What is RAID? ==

'''RAID''' stands for "Redundant Array of Independent Disks". It allows multiple physical hard drives to be used as one device. There are many different types or "levels" of RAID for different purposes.

=== Can I use it? ===

RAID capabilities are considered essential for most server-class computers and are widely implemented on servers. But there is no reason that RAID cannot be used on more basic PCs as well. Any computer capable of supporting more than one hard-disk can use RAID.

=== Why Might I Want it? ===
RAID capabilities can provide several benefits:
* Redundancy -- If one disk fails, one or more others have the same data and can prevent data loss until the failed drive is replaced.
* Performance -- Data can be written to more than one drive at a time, improving overall transfer rates.
* Convenience -- The space from several physical disks can be addressed as though it were single device.

The different RAID levels provide these benefits in different combinations -- A linear RAID (sometime called "concatenation") provides convenience, but no performance or redundancy benefits. RAID 0 offers performance benefits, but no redundancy. RAID 1 offers redundancy but no performance benefit. Most other RAID types offer some combination of both performance and redundancy benefits.

=== What is the Difference Between Software and Hardware RAID ===
RAID can be implemented either by a dedicated hardware device or through software.

In hardware RAID, the drives are attached to a controller card with a dedicated processor chip. The controller card handles the creation of the RAID and any parity calculations that must be made and presents the storage to the operating system as though each array were a single drive instead of an array of several physical drives. Using hardware RAID, an operating system does not need to know anything about RAID since it simply sees what it believes to be physical disks.

In software RAID, the creation of the array and all of the calculations involved are handled by the OS.

== Simple RAID Levels ==

There are only a few basic RAID types although they can be combined together to produce combination types.

Basic RAID types supported by Linux software RAID include Linear, RAID-0, RAID-1, RAID-4, and RAID-5

=== Linear ===
A RAID in Linear mode offers no redundancy benefit and very little performance benefit. It would be used only because it allows the storage space on multiple physical hard drives to be addressed as a single device. As shown below, it fills the first device before writing to the next.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data4
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
xxxxx
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. The disks do not have to be of the same size. So, if I form a Linear RAID of a 10 GB and two 20 GB disks, the usable size of the array is the full 50 GB.

In the event of a drive failure, only the files stored on the affected drive would be lost. For example, in the illustration above, if disk 2 failed, only data4 and data5 would be lost.

=== RAID-0 ===

RAID-0 is also known as "striping". It spreads data across several hard drives so that the system can be reading from several drives at once, increasing performance. Like Linear RAID, RAID-0 offers no redundancy.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data4
xxxxx
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data3
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. So, if I form a RAID-0 of three 20 GB disks, the usable size of the array is the full 60 GB.

It is advisable, but not required, to use disks of identical size (the performance benefit to this RAID is reduced if one drive is substantially larger than the rest).

In the event of a drive failure, since files can be spread across multiple disks, most or all of the data in the array will probably be lost.

=== RAID-1 ===

RAID-1 is also known as "mirroring". It creates a duplicate copy of data on another hard drive (or several more) so that if one of the drives fails, no data is lost. This RAID level offers good redundancy, but no performance benefit. In fact, while read performance is equivalent to that of a single drive, write performance is a bit lower than when using a single drive.

RAID-1 is most commonly implemented using only two drives, but Linux software RAID supports the use of multiple drive -- each an exact copy of the others.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data1
data2
data3
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is the same as the space available on the smallest of the hard drives being used. So, if I form a RAID-1 of a 10 GB and a 20 GB disk, the usable size of the array is only 10 GB.

Since each disk in the array is an exact copy of the same data, a RAID-1 array can withstand the failure of one or several drives, so long as at least one remains intact.

=== RAID-4 ===

RAID-4 is also known as "striping with dedicated parity". It requires at least three disks to create. One of them is used exclusively for parity data and the rest contain striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data3
data5
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
data4
data6
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
parity1-2
parity3-4
parity5-6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-4 of two 10 GB disks and one 20 GB disk, the usable size of the array is 20 GB.

A RAID-4 can withstand the failure of any single drive without data loss. If the failed drive is the parity drive, the array can continue to function because all of the actual data is still intact on the other drives. If the failed drive is one of the data drives, the array can continue to function by using the parity information and the data on the remaining drive(s) to calculate what data the failed drive should be storing if it were functioning. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

=== RAID-5 ===

RAID-5 is also known as "striping with distributed parity". It requires at least three disks to create. Each of them is used for both parity data and striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
| Physical
Disk 1
{| border=2
<pre>
data1
data3
parity5-6
</pre>
|}

| Physical
Disk 2
{| border=2
<pre>
data2
parity3-4
data5
</pre>
|}
| Physical
Disk 3
{| border=2
<pre>
parity1-2
data4
data6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-5 of three 10 GB disks, the usable size of the array is 20 GB.

A RAID-5 can withstand the failure of any single drive without data loss. When any single drive fails the array can continue to function because all of the actual data is either still intact on the other drives or able to be reconstructed from the remaining data plus the parity information on the other drives. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

== Combination RAID Levels ==
Arrays can be built using other arrays just as they can from drives or partitions. This allows the creation of "nested", "multiple", or "combination" RAID types.

Combining simple RAID types with different strengths can often provide the best of both worlds. For example, RAID 0 offers great performance but no redundancy while RAID 1 offers redundancy but no performance advantage. Combining them into a RAID 0+1 or a RAID 10 offers both -- with even better redundancy that in a basic RAID 1.

Combinations can be formed of any RAID types supported by Linux, but the most common variations are probably:
* RAID 0+1 -- Mirroring of strip sets
* RAID 10 -- Striping across mirror sets
* RAID 50 -- Striping across RAID 5 sets

=== Naming Conventions ===
Although usage of these conventions is not always consistent, the general rule is that the first digit in the name describes the RAID type first or at the lowest level. The second digit describes the RAID type applied second or at the logically higher level.

For example, a RAID 0+1 (so named to prevent people from assuming that a RAID 01 is the same as a RAID 1) is created by first building two or more stripe sets (identical size and configuration) and then building a mirror from them.

A RAID 10 would be created in the opposite sequence -- building multiple mirrors from paired disks and then creating a strip set across them.

=== RAID 0+1: Mirroring of Stripe sets ===

RAID 0+1 provides better performance than simple RAID 1 along with the redundancy that simple RAID 0 lacks. It requires at least four drives to implement and provides usable space equal to S*N/2 where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID 0+1 of four 10 GB disks, the usable size of the array is 20 GB.

{| border=0
| RAID 0+1 (Mirroring of Stripe sets)
{| border=1
| First Stripe Set
{| border=1
| Disk 1
<pre>
Data1
Data4
xxx</pre>
| Disk 2
<pre>Data2
Data5
xxx</pre>
| Disk 3
<pre>Data3
Data6
xxx</pre>
|}
| Second Stripe Set
{| border=1
| Disk 4
<pre>Data1
Data4
xxx</pre>
| Disk 5
<pre>Data2
Data5
xxx</pre>
| Disk 6
<pre>Data3
Data6
xxx</pre>
|}
|}
|}

A RAID 0+1 can withstand the failure of a single drive (or multiple drives, so long as they are all from the same stripe set).

=== RAID 10: Striping across Mirror sets ===

RAID 10 provides better performance than simple RAID 1 along with the redundancy that simple RAID 0 lacks. It requires at least four drives to implement and provides usable space equal to S*N/2 where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID 10 of four 10 GB disks, the usable size of the array is 20 GB.

RAID 0+1 and RAID 10 are very similar but, by most measures of both performance and redundancy, RAID 10 is considered to be preferable.

{| border=0
| RAID 10 -- Striping across Mirror sets
{| border=1
| Mirror 1
{| border=1
| Disk 1
<pre>
Data1
Data4
</pre>
| Disk 2
<pre>
Data1
Data4
</pre>
|}

| Mirror 2
{| border=1
| Disk 3
<pre>
Data2
Data5
</pre>
| Disk 4
<pre>
Data2
Data5
</pre>
|}

| Mirror 3
{| border=1
| Disk 5
<pre>
Data3
Data6
</pre>
| Disk 6
<pre>
Data3
Data6
</pre>
|}

|}
|}

A RAID 10 can withstand the failure of a single drive (or multiple drives, so long as they are NOT in the same mirror set).

=== RAID 50: Striping across RAID 5 sets===

RAID 50 provides better write performance and improved redundancy over simple RAID 5 along with the redundancy that simple RAID 0 lacks. It requires at least six drives to implement and (assuming all drives are the same size) provides usable space equal to S * (N-1) * R where 'S' is the size of the smallest of the hard drives being used, 'N' is the number of disks in each RAID 5 array, and 'R' is the number of RAID 5 sets used in the stripe set. So, if I form a RAID 50 of six 10 GB disks, the usable size of the array is 40 GB.

{| border=0
| RAID 50 -- Striping across RAID 5 sets
{| border=1
| RAID 5
Set 1
{| border=1
| Disk 1
<pre>
Data1
Data5
Parity 9,11
</pre>
| Disk 2
<pre>
Data3
Parity 5,7
Data9
</pre>
| Disk 3
<pre>
Parity 1,3
Data7
Data11
</pre>
|}
| RAID 5
Set 2
{| border=1
| Disk 4
<pre>
Data2
Data6
Parity 10,12
</pre>
| Disk 5
<pre>
Data4
Parity 6,8
Data10
</pre>
| Disk 6
<pre>
Parity 2,4
Data8
Data12
</pre>
|}
|}

|}

A RAID 50 can withstand the failure of one drive in each RAID 5.

== Configuring Linux Software RAID ==

=== Partition Drives ===

=== Create the RAID ===

=== Create a filesystem on the RAID ===

=== Create an <tt>/etc/raidtab</tt> file ===

=== Choose or create a mountpoint ===

=== Modify the <tt>/etc/fstab</tt> file to mount at boot ===

RAID

2004-03-18T21:44:53Z

Texastwister: Added explanation about RAID 01 and 10.

''This article is a [[LinuxQuestions.org_Wiki:stub_articles|stub]] and needs to be finished. [[LinuxQuestions.org_Wiki:plunging_forward|Plunge forward]] and [[LinuxQuestions.org_Wiki:How_to_edit_a_page|help it grow]] !'' 

== What is RAID? ==

'''RAID''' stands for "Redundant Array of Independent Disks". It allows multiple physical hard drives to be used as one device. There are many different types or "levels" of RAID for different purposes.

=== Can I use it? ===

RAID capabilities are considered essential for most server-class computers and are widely implemented on servers. But there is no reason that RAID cannot be used on more basic PCs as well. Any computer capable of supporting more than one hard-disk can use RAID.

=== Why Might I Want it? ===
RAID capabilities can provide several benefits:
* Redundancy -- If one disk fails, one or more others have the same data and can prevent data loss until the failed drive is replaced.
* Performance -- Data can be written to more than one drive at a time, improving overall transfer rates.
* Convenience -- The space from several physical disks can be addressed as though it were single device.

The different RAID levels provide these benefits in different combinations -- A linear RAID (sometime called "concatenation") provides convenience, but no performance or redundancy benefits. RAID 0 offers performance benefits, but no redundancy. RAID 1 offers redundancy but no performance benefit. Most other RAID types offer some combination of both performance and redundancy benefits.

=== What is the Difference Between Software and Hardware RAID ===
RAID can be implemented either by a dedicated hardware device or through software.

In hardware RAID, the drives are attached to a controller card with a dedicated processor chip. The controller card handles the creation of the RAID and any parity calculations that must be made and presents the storage to the operating system as though each array were a single drive instead of an array of several physical drives. Using hardware RAID, an operating system does not need to know anything about RAID since it simply sees what it believes to be physical disks.

In software RAID, the creation of the array and all of the calculations involved are handled by the OS.

== Simple RAID Levels ==

There are only a few basic RAID types although they can be combined together to produce combination types.

Basic RAID types supported by Linux software RAID include Linear, RAID-0, RAID-1, RAID-4, and RAID-5

=== Linear ===
A RAID in Linear mode offers no redundancy benefit and very little performance benefit. It would be used only because it allows the storage space on multiple physical hard drives to be addressed as a single device. As shown below, it fills the first device before writing to the next.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data4
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
xxxxx
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. The disks do not have to be of the same size. So, if I form a Linear RAID of a 10 GB and two 20 GB disks, the usable size of the array is the full 50 GB.

In the event of a drive failure, only the files stored on the affected drive would be lost. For example, in the illustration above, if disk 2 failed, only data4 and data5 would be lost.

=== RAID-0 ===

RAID-0 is also known as "striping". It spreads data across several hard drives so that the system can be reading from several drives at once, increasing performance. Like Linear RAID, RAID-0 offers no redundancy.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data4
xxxxx
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data3
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. So, if I form a RAID-0 of three 20 GB disks, the usable size of the array is the full 60 GB.

It is advisable, but not required, to use disks of identical size (the performance benefit to this RAID is reduced if one drive is substantially larger than the rest).

In the event of a drive failure, since files can be spread across multiple disks, most or all of the data in the array will probably be lost.

=== RAID-1 ===

RAID-1 is also known as "mirroring". It creates a duplicate copy of data on another hard drive (or several more) so that if one of the drives fails, no data is lost. This RAID level offers good redundancy, but no performance benefit. In fact, while read performance is equivalent to that of a single drive, write performance is a bit lower than when using a single drive.

RAID-1 is most commonly implemented using only two drives, but Linux software RAID supports the use of multiple drive -- each an exact copy of the others.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data1
data2
data3
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is the same as the space available on the smallest of the hard drives being used. So, if I form a RAID-1 of a 10 GB and a 20 GB disk, the usable size of the array is only 10 GB.

Since each disk in the array is an exact copy of the same data, a RAID-1 array can withstand the failure of one or several drives, so long as at least one remains intact.

=== RAID-4 ===

RAID-4 is also known as "striping with dedicated parity". It requires at least three disks to create. One of them is used exclusively for parity data and the rest contain striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data3
data5
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
data4
data6
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
parity1-2
parity3-4
parity5-6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-4 of two 10 GB disks and one 20 GB disk, the usable size of the array is 20 GB.

A RAID-4 can withstand the failure of any single drive without data loss. If the failed drive is the parity drive, the array can continue to function because all of the actual data is still intact on the other drives. If the failed drive is one of the data drives, the array can continue to function by using the parity information and the data on the remaining drive(s) to calculate what data the failed drive should be storing if it were functioning. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

=== RAID-5 ===

RAID-5 is also known as "striping with distributed parity". It requires at least three disks to create. Each of them is used for both parity data and striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
| Physical
Disk 1
{| border=2
<pre>
data1
data3
parity5-6
</pre>
|}

| Physical
Disk 2
{| border=2
<pre>
data2
parity3-4
data5
</pre>
|}
| Physical
Disk 3
{| border=2
<pre>
parity1-2
data4
data6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-5 of three 10 GB disks, the usable size of the array is 20 GB.

A RAID-5 can withstand the failure of any single drive without data loss. When any single drive fails the array can continue to function because all of the actual data is either still intact on the other drives or able to be reconstructed from the remaining data plus the parity information on the other drives. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

== Combination RAID Levels ==
Arrays can be built using other arrays just as they can from drives or partitions. This allows the creation of "nested", "multiple", or "combination" RAID types.

Combining simple RAID types with different strengths can often provide the best of both worlds. For example, RAID 0 offers great performance but no redundancy while RAID 1 offers redundancy but no performance advantage. Combining them into a RAID 0+1 or a RAID 10 offers both -- with even better redundancy that in a basic RAID 1.

Combinations can be formed of any RAID types supported by Linux, but the most common variations are probably:
* RAID 0+1 -- Mirroring of strip sets
* RAID 10 -- Striping across mirror sets
* RAID 50 -- Striping across RAID 5 sets

=== Naming Conventions ===
Although usage of these conventions is not always consistent, the general rule is that the first digit in the name describes the RAID type first or at the lowest level. The second digit describes the RAID type applied second or at the logically higher level.

For example, a RAID 0+1 (so named to prevent people from assuming that a RAID 01 is the same as a RAID 1) is created by first building two or more stripe sets (identical size and configuration) and then building a mirror from them.

A RAID 10 would be created in the opposite sequence -- building multiple mirrors from paired disks and then creating a strip set across them.

=== RAID 0+1 ===

RAID 0+1 provides better performance than simple RAID 1 along with the redundancy that simple RAID 0 lacks. It requires at least four drives to implement and provides usable space equal to S*N/2 where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID 0+1 of four 10 GB disks, the usable size of the array is 20 GB.

{| border=0
| RAID 0+1 (Mirroring of stripe sets)
{| border=1
| First Stripe Set
{| border=1
| Disk 1
<pre>
Data1
Data4
xxx</pre>
| Disk 2
<pre>Data2
Data5
xxx</pre>
| Disk 3
<pre>Data3
Data6
xxx</pre>
|}
| Second Stripe Set
{| border=1
| Disk 4
<pre>Data1
Data4
xxx</pre>
| Disk 5
<pre>Data2
Data5
xxx</pre>
| Disk 6
<pre>Data3
Data6
xxx</pre>
|}
|}
|}

A RAID 0+1 can withstand the failure of a single drive (or multiple drives, so long as they are all from the same stripe set).

=== RAID 10 ===

RAID 10 provides better performance than simple RAID 1 along with the redundancy that simple RAID 0 lacks. It requires at least four drives to implement and provides usable space equal to S*N/2 where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID 10 of four 10 GB disks, the usable size of the array is 20 GB.

RAID 0+1 and RAID 10 are very similar but, by most measures of both performance and redundancy, RAID 10 is considered to be preferable.

{| border=0
| RAID 10 -- Striping across mirror sets
{| border=1
| Mirror 1
{| border=1
| Disk 1
<pre>
Data1
Data4
</pre>
| Disk 2
<pre>
Data1
Data4
</pre>
|}

| Mirror 2
{| border=1
| Disk 3
<pre>
Data2
Data5
</pre>
| Disk 4
<pre>
Data2
Data5
</pre>
|}

| Mirror 3
{| border=1
| Disk 5
<pre>
Data3
Data6
</pre>
| Disk 6
<pre>
Data3
Data6
</pre>
|}

|}
|}

A RAID 10 can withstand the failure of a single drive (or multiple drives, so long as they are NOT in the same mirror set).

=== RAID 50 ===

{| border=0
| RAID 50 -- Striping across RAID 5 sets
{| border=1
| RAID 5
Set 1
{| border=1
| Disk 1
<pre>
Data1
Data5
Parity 9,11
</pre>
| Disk 2
<pre>
Data3
Parity 5,7
Data9
</pre>
| Disk 3
<pre>
Parity 1,3
Data7
Data11
</pre>
|}
| RAID 5
Set 2
{| border=1
| Disk 4
<pre>
Data2
Data6
Parity 10,12
</pre>
| Disk 5
<pre>
Data4
Parity 6,8
Data10
</pre>
| Disk 6
<pre>
Parity 2,4
Data8
Data12
</pre>
|}
|}

|}

== Configuring Linux Software RAID ==

=== Partition Drives ===

=== Create the RAID ===

=== Create a filesystem on the RAID ===

=== Create an <tt>/etc/raidtab</tt> file ===

=== Choose or create a mountpoint ===

=== Modify the <tt>/etc/fstab</tt> file to mount at boot ===

Mandriva

2004-03-18T15:47:35Z

Texastwister: Revised for objectivity.

'''Mandrake''' Linux was created in 1998 with the goal of making [[Linux]] easier to use for everyone. At that time, Linux was still a developer's [[operating system]] and sound knowledge of the CLI was a must. It is a [[RPM]]-based [[distribution]], and while it began as a [[fork]] of [[Red Hat]],now it adds many features of its own, expecially on the user-friendliness side. It was one of the first distributions to be optimized for i586 processors (and superior).

Mandrake most recent version is Mandrake Community 10.0

MandrakeSoft saw this as an opportunity to integrate the best graphical desktop environments and contribute its own graphical configuration utilities and quickly became famous for setting the standard in ease-of-use and functionality.

The [[GPL]] (General Public License) governs the development and redistribution of Mandrake Linux.

Mandrake has now been widely acclaimed for providing all the power and stability of Linux to both individuals and professional users in an easy-to-use and pleasant environment.

Mandrake Linux was also the first rpm-based distribution to provide automatic resolution of dependencies, with urpmi, which debuted in version 7.2. urpmi is now capable of updating the entire distribution, installing security updates, and many other features. A graphical interface to urpmi is provided in rpmdrake (and the MandrakeUpdate tool specifically for security updates).

Mandrake Linux is community-driven to a large degree. Non-Mandrakesoft contributors have write access to packages in the main distribution, commit access to Mandrake's own tools in CVS, full bug tracking rights in [http://qa.mandrakesoft.com Mandrake's bugzilla] and the [http://qa.mandrakesoft.com/wiki Mandrake Development wiki]. Over half the packages in the entire distribution (combining "main" and "contrib") are maintained by the community. For non-developers, support is available from the unofficial [http://mandrake.vmlinuz.ca Mandrake community wiki] and the [http://www.mandrakeusers.org Mandrake Users Board].

Official website: http://www.mandrakelinux.com/en-us/

With a graphical installation process recognized by many as the best available, Mandrake Linux offers the most advanced and efficient hardware detection.

Visit http://www.mandrakelinux.com/en-us/concept.php3 to learn more.

There is debate between some [[Linux]] experts about Mandrake (and other easy-to-use distributions) because the number of [[patch|patches]] that are added to the kernel to achieve up-to-date hardware compatibility can in rare cases create problems of stability and/or security. Therefore, while Mandrake Linux is a good and stable distribution, and one of the best [[distribution]]s for the home desktop, there is still no full consensus if it is fully tailored for other aims. Successful cases of the use of Mandrake in business settings are documented at [http://mandrakebizcases.com/ this site].

Distributions similar to Mandrake include : [[Red Hat]] , [[SuSE]] , [[Lorma]] , [[Libranet]].

Mandriva

2004-03-18T15:37:20Z

Texastwister: Changed "last" to "most recent" -- "Last" could be taken as no more to come... ever.

'''Mandrake''' Linux was created in 1998 with the goal of making [[Linux]] easier to use for everyone. At that time, Linux was still a developer's [[operating system]] and sound knowledge of the CLI was a must. It is a [[RPM]]-based [[distribution]], and while it began as a [[fork]] of [[Red Hat]],now it adds many features of its own, expecially on the user-friendliness side. It was one of the first distributions to be optimized for i586 processors (and superior).

Mandrake most recent version is Mandrake Community 10.0

MandrakeSoft saw this as an opportunity to integrate the best graphical desktop environments and contribute its own graphical configuration utilities and quickly became famous for setting the standard in ease-of-use and functionality.

The [[GPL]] (General Public License) governs the development and redistribution of Mandrake Linux.

Mandrake has now been widely acclaimed for providing all the power and stability of Linux to both individuals and professional users in an easy-to-use and pleasant environment.

Mandrake Linux was also the first rpm-based distribution to provide automatic resolution of dependencies, with urpmi, which debuted in version 7.2. urpmi is now capable of updating the entire distribution, installing security updates, and many other features. A graphical interface to urpmi is provided in rpmdrake (and the MandrakeUpdate tool specifically for security updates).

Mandrake Linux is community-driven to a large degree. Non-Mandrakesoft contributors have write access to packages in the main distribution, commit access to Mandrake's own tools in CVS, full bug tracking rights in [http://qa.mandrakesoft.com Mandrake's bugzilla] and the [http://qa.mandrakesoft.com/wiki Mandrake Development wiki]. Over half the packages in the entire distribution (combining "main" and "contrib") are maintained by the community. For non-developers, support is available from the unofficial [http://mandrake.vmlinuz.ca Mandrake community wiki] and the [http://www.mandrakeusers.org Mandrake Users Board].

Official website: http://www.mandrakelinux.com/en-us/

With a graphical installation process recognized by many as the best available, Mandrake Linux offers the most advanced and efficient hardware detection.

Visit http://www.mandrakelinux.com/en-us/concept.php3 to learn more.

There is debate between some [[Linux]] experts about Mandrake (and other easy-to-use distributions) because the number of [[patch|patches]] that are added to the kernel to achieve up-to-date hardware compatibility can in rare cases create problems of stability and/or security. Therefore, while Mandrake Linux is a good and stable distribution , and probably the [[distribution]] of choice for the home desktop, there is still no full consensus if it is fully tailored for other aims. Anyway [http://mandrakebizcases.com/ this site] reports where and how Mandrake has been used successfully in business.

Distributions similar to Mandrake include : [[Red Hat]] , [[SuSE]] , [[Lorma]] , [[Libranet]].

RAID

2004-03-18T04:59:55Z

Texastwister: Added RAID 50

''This article is a [[LinuxQuestions.org_Wiki:stub_articles|stub]] and needs to be finished. [[LinuxQuestions.org_Wiki:plunging_forward|Plunge forward]] and [[LinuxQuestions.org_Wiki:How_to_edit_a_page|help it grow]] !'' 

== What is RAID? ==

'''RAID''' stands for "Redundant Array of Independent Disks". It allows multiple physical hard drives to be used as one device. There are many different types or "levels" of RAID for different purposes.

=== Can I use it? ===

RAID capabilities are considered essential for most server-class computers and are widely implemented on servers. But there is no reason that RAID cannot be used on more basic PCs as well. Any computer capable of supporting more than one hard-disk can use RAID.

=== Why Might I Want it? ===
RAID capabilities can provide several benefits:
* Redundancy -- If one disk fails, one or more others have the same data and can prevent data loss until the failed drive is replaced.
* Performance -- Data can be written to more than one drive at a time, improving overall transfer rates.
* Convenience -- The space from several physical disks can be addressed as though it were single device.

The different RAID levels provide these benefits in different combinations -- A linear RAID (sometime called "concatenation") provides convenience, but no performance or redundancy benefits. RAID 0 offers performance benefits, but no redundancy. RAID 1 offers redundancy but no performance benefit. Most other RAID types offer some combination of both performance and redundancy benefits.

=== What is the Difference Between Software and Hardware RAID ===
RAID can be implemented either by a dedicated hardware device or through software.

In hardware RAID, the drives are attached to a controller card with a dedicated processor chip. The controller card handles the creation of the RAID and any parity calculations that must be made and presents the storage to the operating system as though each array were a single drive instead of an array of several physical drives. Using hardware RAID, an operating system does not need to know anything about RAID since it simply sees what it believes to be physical disks.

In software RAID, the creation of the array and all of the calculations involved are handled by the OS.

== Simple RAID Levels ==

There are only a few basic RAID types although they can be combined together to produce combination types.

Basic RAID types supported by Linux software RAID include Linear, RAID-0, RAID-1, RAID-4, and RAID-5

=== Linear ===
A RAID in Linear mode offers no redundancy benefit and very little performance benefit. It would be used only because it allows the storage space on multiple physical hard drives to be addressed as a single device. As shown below, it fills the first device before writing to the next.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data4
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
xxxxx
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. The disks do not have to be of the same size. So, if I form a Linear RAID of a 10 GB and two 20 GB disks, the usable size of the array is the full 50 GB.

In the event of a drive failure, only the files stored on the affected drive would be lost. For example, in the illustration above, if disk 2 failed, only data4 and data5 would be lost.

=== RAID-0 ===

RAID-0 is also known as "striping". It spreads data across several hard drives so that the system can be reading from several drives at once, increasing performance. Like Linear RAID, RAID-0 offers no redundancy.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data4
xxxxx
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data3
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. So, if I form a RAID-0 of three 20 GB disks, the usable size of the array is the full 60 GB.

It is advisable, but not required, to use disks of identical size (the performance benefit to this RAID is reduced if one drive is substantially larger than the rest).

In the event of a drive failure, since files can be spread across multiple disks, most or all of the data in the array will probably be lost.

=== RAID-1 ===

RAID-1 is also known as "mirroring". It creates a duplicate copy of data on another hard drive (or several more) so that if one of the drives fails, no data is lost. This RAID level offers good redundancy, but no performance benefit. In fact, while read performance is equivalent to that of a single drive, write performance is a bit lower than when using a single drive.

RAID-1 is most commonly implemented using only two drives, but Linux software RAID supports the use of multiple drive -- each an exact copy of the others.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data1
data2
data3
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is the same as the space available on the smallest of the hard drives being used. So, if I form a RAID-1 of a 10 GB and a 20 GB disk, the usable size of the array is only 10 GB.

Since each disk in the array is an exact copy of the same data, a RAID-1 array can withstand the failure of one or several drives, so long as at least one remains intact.

=== RAID-4 ===

RAID-4 is also known as "striping with dedicated parity". It requires at least three disks to create. One of them is used exclusively for parity data and the rest contain striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data3
data5
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
data4
data6
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
parity1-2
parity3-4
parity5-6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-4 of two 10 GB disks and one 20 GB disk, the usable size of the array is 20 GB.

A RAID-4 can withstand the failure of any single drive without data loss. If the failed drive is the parity drive, the array can continue to function because all of the actual data is still intact on the other drives. If the failed drive is one of the data drives, the array can continue to function by using the parity information and the data on the remaining drive(s) to calculate what data the failed drive should be storing if it were functioning. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

=== RAID-5 ===

RAID-5 is also known as "striping with distributed parity". It requires at least three disks to create. Each of them is used for both parity data and striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
| Physical
Disk 1
{| border=2
<pre>
data1
data3
parity5-6
</pre>
|}

| Physical
Disk 2
{| border=2
<pre>
data2
parity3-4
data5
</pre>
|}
| Physical
Disk 3
{| border=2
<pre>
parity1-2
data4
data6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-5 of three 10 GB disks, the usable size of the array is 20 GB.

A RAID-5 can withstand the failure of any single drive without data loss. When any single drive fails the array can continue to function because all of the actual data is either still intact on the other drives or able to be reconstructed from the remaining data plus the parity information on the other drives. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

== Combination RAID Levels ==
Arrays can be built using other arrays just as they can from drives or partitions. This allows the creation of "nested", "multiple", or "combination" RAID types.

Combining simple RAID types with different strengths can often provide the best of both worlds. For example, RAID 0 offers great performance but no redundancy while RAID 1 offers redundancy but no performance advantage. Combining them into a RAID 0+1 or a RAID 10 offers both -- with even better redundancy that in a basic RAID 1.

Combinations can be formed of any RAID types supported by Linux, but the most common variations are probably:
* RAID 0+1 -- Mirroring of strip sets
* RAID 10 -- Striping across mirror sets
* RAID 50 -- Striping across RAID 5 sets

=== Naming Conventions ===
Although usage of these conventions is not always consistent, the general rule is that the first digit in the name describes the RAID type first or at the lowest level. The second digit describes the RAID type applied second or at the logically higher level.

For example, a RAID 0+1 (so named to prevent people from assuming that a RAID 01 is the same as a RAID 1) is created by first building two or more stripe sets (identical size and configuration) and then building a mirror from them.

A RAID 10 would be created in the opposite sequence -- building multiple mirrors from paired disks and then creating a strip set across them.

=== RAID 0+1 ===
{| border=0
| RAID 0+1 (Mirroring of stripe sets)
{| border=1
| First Stripe Set
{| border=1
| Disk 1
<pre>
Data1
Data4
xxx</pre>
| Disk 2
<pre>Data2
Data5
xxx</pre>
| Disk 3
<pre>Data3
Data6
xxx</pre>
|}
| Second Stripe Set
{| border=1
| Disk 4
<pre>Data1
Data4
xxx</pre>
| Disk 5
<pre>Data2
Data5
xxx</pre>
| Disk 6
<pre>Data3
Data6
xxx</pre>
|}
|}
|}

=== RAID 10 ===

{| border=0
| RAID 10 -- Striping across mirror sets
{| border=1
| Mirror 1
{| border=1
| Disk 1
<pre>
Data1
Data4
</pre>
| Disk 2
<pre>
Data1
Data4
</pre>
|}

| Mirror 2
{| border=1
| Disk 3
<pre>
Data2
Data5
</pre>
| Disk 4
<pre>
Data2
Data5
</pre>
|}

| Mirror 3
{| border=1
| Disk 5
<pre>
Data3
Data6
</pre>
| Disk 6
<pre>
Data3
Data6
</pre>
|}

|}
|}

=== RAID 50 ===

{| border=0
| RAID 50 -- Striping across RAID 5 sets
{| border=1
| RAID 5
Set 1
{| border=1
| Disk 1
<pre>
Data1
Data5
Parity 9,11
</pre>
| Disk 2
<pre>
Data3
Parity 5,7
Data9
</pre>
| Disk 3
<pre>
Parity 1,3
Data7
Data11
</pre>
|}
| RAID 5
Set 2
{| border=1
| Disk 4
<pre>
Data2
Data6
Parity 10,12
</pre>
| Disk 5
<pre>
Data4
Parity 6,8
Data10
</pre>
| Disk 6
<pre>
Parity 2,4
Data8
Data12
</pre>
|}
|}

|}

== Configuring Linux Software RAID ==

=== Partition Drives ===

=== Create the RAID ===

=== Create a filesystem on the RAID ===

=== Create an <tt>/etc/raidtab</tt> file ===

=== Choose or create a mountpoint ===

=== Modify the <tt>/etc/fstab</tt> file to mount at boot ===

RAID

2004-03-18T04:29:52Z

Texastwister: Added RAID 10

''This article is a [[LinuxQuestions.org_Wiki:stub_articles|stub]] and needs to be finished. [[LinuxQuestions.org_Wiki:plunging_forward|Plunge forward]] and [[LinuxQuestions.org_Wiki:How_to_edit_a_page|help it grow]] !'' 

== What is RAID? ==

'''RAID''' stands for "Redundant Array of Independent Disks". It allows multiple physical hard drives to be used as one device. There are many different types or "levels" of RAID for different purposes.

=== Can I use it? ===

RAID capabilities are considered essential for most server-class computers and are widely implemented on servers. But there is no reason that RAID cannot be used on more basic PCs as well. Any computer capable of supporting more than one hard-disk can use RAID.

=== Why Might I Want it? ===
RAID capabilities can provide several benefits:
* Redundancy -- If one disk fails, one or more others have the same data and can prevent data loss until the failed drive is replaced.
* Performance -- Data can be written to more than one drive at a time, improving overall transfer rates.
* Convenience -- The space from several physical disks can be addressed as though it were single device.

The different RAID levels provide these benefits in different combinations -- A linear RAID (sometime called "concatenation") provides convenience, but no performance or redundancy benefits. RAID 0 offers performance benefits, but no redundancy. RAID 1 offers redundancy but no performance benefit. Most other RAID types offer some combination of both performance and redundancy benefits.

=== What is the Difference Between Software and Hardware RAID ===
RAID can be implemented either by a dedicated hardware device or through software.

In hardware RAID, the drives are attached to a controller card with a dedicated processor chip. The controller card handles the creation of the RAID and any parity calculations that must be made and presents the storage to the operating system as though each array were a single drive instead of an array of several physical drives. Using hardware RAID, an operating system does not need to know anything about RAID since it simply sees what it believes to be physical disks.

In software RAID, the creation of the array and all of the calculations involved are handled by the OS.

== Simple RAID Levels ==

There are only a few basic RAID types although they can be combined together to produce combination types.

Basic RAID types supported by Linux software RAID include Linear, RAID-0, RAID-1, RAID-4, and RAID-5

=== Linear ===
A RAID in Linear mode offers no redundancy benefit and very little performance benefit. It would be used only because it allows the storage space on multiple physical hard drives to be addressed as a single device. As shown below, it fills the first device before writing to the next.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data4
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
xxxxx
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. The disks do not have to be of the same size. So, if I form a Linear RAID of a 10 GB and two 20 GB disks, the usable size of the array is the full 50 GB.

In the event of a drive failure, only the files stored on the affected drive would be lost. For example, in the illustration above, if disk 2 failed, only data4 and data5 would be lost.

=== RAID-0 ===

RAID-0 is also known as "striping". It spreads data across several hard drives so that the system can be reading from several drives at once, increasing performance. Like Linear RAID, RAID-0 offers no redundancy.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data4
xxxxx
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data3
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. So, if I form a RAID-0 of three 20 GB disks, the usable size of the array is the full 60 GB.

It is advisable, but not required, to use disks of identical size (the performance benefit to this RAID is reduced if one drive is substantially larger than the rest).

In the event of a drive failure, since files can be spread across multiple disks, most or all of the data in the array will probably be lost.

=== RAID-1 ===

RAID-1 is also known as "mirroring". It creates a duplicate copy of data on another hard drive (or several more) so that if one of the drives fails, no data is lost. This RAID level offers good redundancy, but no performance benefit. In fact, while read performance is equivalent to that of a single drive, write performance is a bit lower than when using a single drive.

RAID-1 is most commonly implemented using only two drives, but Linux software RAID supports the use of multiple drive -- each an exact copy of the others.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data1
data2
data3
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is the same as the space available on the smallest of the hard drives being used. So, if I form a RAID-1 of a 10 GB and a 20 GB disk, the usable size of the array is only 10 GB.

Since each disk in the array is an exact copy of the same data, a RAID-1 array can withstand the failure of one or several drives, so long as at least one remains intact.

=== RAID-4 ===

RAID-4 is also known as "striping with dedicated parity". It requires at least three disks to create. One of them is used exclusively for parity data and the rest contain striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data3
data5
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
data4
data6
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
parity1-2
parity3-4
parity5-6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-4 of two 10 GB disks and one 20 GB disk, the usable size of the array is 20 GB.

A RAID-4 can withstand the failure of any single drive without data loss. If the failed drive is the parity drive, the array can continue to function because all of the actual data is still intact on the other drives. If the failed drive is one of the data drives, the array can continue to function by using the parity information and the data on the remaining drive(s) to calculate what data the failed drive should be storing if it were functioning. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

=== RAID-5 ===

RAID-5 is also known as "striping with distributed parity". It requires at least three disks to create. Each of them is used for both parity data and striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
| Physical
Disk 1
{| border=2
<pre>
data1
data3
parity5-6
</pre>
|}

| Physical
Disk 2
{| border=2
<pre>
data2
parity3-4
data5
</pre>
|}
| Physical
Disk 3
{| border=2
<pre>
parity1-2
data4
data6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-5 of three 10 GB disks, the usable size of the array is 20 GB.

A RAID-5 can withstand the failure of any single drive without data loss. When any single drive fails the array can continue to function because all of the actual data is either still intact on the other drives or able to be reconstructed from the remaining data plus the parity information on the other drives. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

== Combination RAID Levels ==
Arrays can be built using other arrays just as they can from drives or partitions. This allows the creation of "nested", "multiple", or "combination" RAID types.

Combining simple RAID types with different strengths can often provide the best of both worlds. For example, RAID 0 offers great performance but no redundancy while RAID 1 offers redundancy but no performance advantage. Combining them into a RAID 0+1 or a RAID 10 offers both -- with even better redundancy that in a basic RAID 1.

Combinations can be formed of any RAID types supported by Linux, but the most common variations are probably:
* RAID 0+1 -- Mirroring of strip sets
* RAID 10 -- Striping across mirror sets
* RAID 50 -- Striping across RAID 5 sets

=== Naming Conventions ===
Although usage of these conventions is not always consistent, the general rule is that the first digit in the name describes the RAID type first or at the lowest level. The second digit describes the RAID type applied second or at the logically higher level.

For example, a RAID 0+1 (so named to prevent people from assuming that a RAID 01 is the same as a RAID 1) is created by first building two or more stripe sets (identical size and configuration) and then building a mirror from them.

A RAID 10 would be created in the opposite sequence -- building multiple mirrors from paired disks and then creating a strip set across them.

=== RAID 0+1 ===
{| border=0
| RAID 0+1 (Mirroring of stripe sets)
{| border=1
| First Stripe Set
{| border=1
| Disk 1
<pre>
Data1
Data4
xxx</pre>
| Disk 2
<pre>Data2
Data5
xxx</pre>
| Disk 3
<pre>Data3
Data6
xxx</pre>
|}
| Second Stripe Set
{| border=1
| Disk 4
<pre>Data1
Data4
xxx</pre>
| Disk 5
<pre>Data2
Data5
xxx</pre>
| Disk 6
<pre>Data3
Data6
xxx</pre>
|}
|}
|}

=== RAID 10 ===

{| border=0
| RAID 10 -- Striping across mirror sets
{| border=1
| Mirror 1
{| border=1
| Disk 1
<pre>
Data1
Data4
</pre>
| Disk 2
<pre>
Data1
Data4
</pre>
|}

| Mirror 2
{| border=1
| Disk 3
<pre>
Data2
Data5
</pre>
| Disk 4
<pre>
Data2
Data5
</pre>
|}

| Mirror 3
{| border=1
| Disk 5
<pre>
Data3
Data6
</pre>
| Disk 6
<pre>
Data3
Data6
</pre>
|}

|}
|}

=== RAID 50 ===

== Configuring Linux Software RAID ==

=== Partition Drives ===

=== Create the RAID ===

=== Create a filesystem on the RAID ===

=== Create an <tt>/etc/raidtab</tt> file ===

=== Choose or create a mountpoint ===

=== Modify the <tt>/etc/fstab</tt> file to mount at boot ===

RAID

2004-03-18T04:00:36Z

Texastwister: Adding info on combination RAID levels -- added RAID 0+1

''This article is a [[LinuxQuestions.org_Wiki:stub_articles|stub]] and needs to be finished. [[LinuxQuestions.org_Wiki:plunging_forward|Plunge forward]] and [[LinuxQuestions.org_Wiki:How_to_edit_a_page|help it grow]] !'' 

== What is RAID? ==

'''RAID''' stands for "Redundant Array of Independent Disks". It allows multiple physical hard drives to be used as one device. There are many different types or "levels" of RAID for different purposes.

=== Can I use it? ===

RAID capabilities are considered essential for most server-class computers and are widely implemented on servers. But there is no reason that RAID cannot be used on more basic PCs as well. Any computer capable of supporting more than one hard-disk can use RAID.

=== Why Might I Want it? ===
RAID capabilities can provide several benefits:
* Redundancy -- If one disk fails, one or more others have the same data and can prevent data loss until the failed drive is replaced.
* Performance -- Data can be written to more than one drive at a time, improving overall transfer rates.
* Convenience -- The space from several physical disks can be addressed as though it were single device.

The different RAID levels provide these benefits in different combinations -- A linear RAID (sometime called "concatenation") provides convenience, but no performance or redundancy benefits. RAID 0 offers performance benefits, but no redundancy. RAID 1 offers redundancy but no performance benefit. Most other RAID types offer some combination of both performance and redundancy benefits.

=== What is the Difference Between Software and Hardware RAID ===
RAID can be implemented either by a dedicated hardware device or through software.

In hardware RAID, the drives are attached to a controller card with a dedicated processor chip. The controller card handles the creation of the RAID and any parity calculations that must be made and presents the storage to the operating system as though each array were a single drive instead of an array of several physical drives. Using hardware RAID, an operating system does not need to know anything about RAID since it simply sees what it believes to be physical disks.

In software RAID, the creation of the array and all of the calculations involved are handled by the OS.

== Simple RAID Levels ==

There are only a few basic RAID types although they can be combined together to produce combination types.

Basic RAID types supported by Linux software RAID include Linear, RAID-0, RAID-1, RAID-4, and RAID-5

=== Linear ===
A RAID in Linear mode offers no redundancy benefit and very little performance benefit. It would be used only because it allows the storage space on multiple physical hard drives to be addressed as a single device. As shown below, it fills the first device before writing to the next.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data4
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
xxxxx
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. The disks do not have to be of the same size. So, if I form a Linear RAID of a 10 GB and two 20 GB disks, the usable size of the array is the full 50 GB.

In the event of a drive failure, only the files stored on the affected drive would be lost. For example, in the illustration above, if disk 2 failed, only data4 and data5 would be lost.

=== RAID-0 ===

RAID-0 is also known as "striping". It spreads data across several hard drives so that the system can be reading from several drives at once, increasing performance. Like Linear RAID, RAID-0 offers no redundancy.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data4
xxxxx
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
data5
xxxxx
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data3
xxxxx
xxxxx
</pre>
|}

|}

The available space for this type of RAID is the sum of the space available for each of the participating disks. So, if I form a RAID-0 of three 20 GB disks, the usable size of the array is the full 60 GB.

It is advisable, but not required, to use disks of identical size (the performance benefit to this RAID is reduced if one drive is substantially larger than the rest).

In the event of a drive failure, since files can be spread across multiple disks, most or all of the data in the array will probably be lost.

=== RAID-1 ===

RAID-1 is also known as "mirroring". It creates a duplicate copy of data on another hard drive (or several more) so that if one of the drives fails, no data is lost. This RAID level offers good redundancy, but no performance benefit. In fact, while read performance is equivalent to that of a single drive, write performance is a bit lower than when using a single drive.

RAID-1 is most commonly implemented using only two drives, but Linux software RAID supports the use of multiple drive -- each an exact copy of the others.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data1
data2
data3
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
data1
data2
data3
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is the same as the space available on the smallest of the hard drives being used. So, if I form a RAID-1 of a 10 GB and a 20 GB disk, the usable size of the array is only 10 GB.

Since each disk in the array is an exact copy of the same data, a RAID-1 array can withstand the failure of one or several drives, so long as at least one remains intact.

=== RAID-4 ===

RAID-4 is also known as "striping with dedicated parity". It requires at least three disks to create. One of them is used exclusively for parity data and the rest contain striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data3
data5
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
data4
data6
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
parity1-2
parity3-4
parity5-6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-4 of two 10 GB disks and one 20 GB disk, the usable size of the array is 20 GB.

A RAID-4 can withstand the failure of any single drive without data loss. If the failed drive is the parity drive, the array can continue to function because all of the actual data is still intact on the other drives. If the failed drive is one of the data drives, the array can continue to function by using the parity information and the data on the remaining drive(s) to calculate what data the failed drive should be storing if it were functioning. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

=== RAID-5 ===

RAID-5 is also known as "striping with distributed parity". It requires at least three disks to create. Each of them is used for both parity data and striped data.

This RAID level offers both redundancy and performance benefits, but the performance advantage is not as significant as in RAID-0.

{| border=0
|
Physical
Disk 1
{| border=2
<pre>
data1
data3
parity5-6
</pre>
|}

|
Physical
Disk 2
{| border=2
<pre>
data2
parity3-4
data5
</pre>
|}
|
Physical
Disk 3
{| border=2
<pre>
parity1-2
data4
data6
</pre>
|}

|}

It is advisable, but not required, to use disks of identical size. However, the array will only use space equal to the size of the smallest drive in the array.

The available space for this type of RAID is <code> S * (N-1) </code> where 'S' is the size of the smallest of the hard drives being used and 'N' is the number of disks in the array. So, if I form a RAID-5 of three 10 GB disks, the usable size of the array is 20 GB.

A RAID-5 can withstand the failure of any single drive without data loss. When any single drive fails the array can continue to function because all of the actual data is either still intact on the other drives or able to be reconstructed from the remaining data plus the parity information on the other drives. Although the array continues to function, performance is significantly reduced and the data is at risk if a second drive should fail before the first failed drive is replaced.

== Combination RAID Levels ==
Arrays can be built using other arrays just as they can from drives or partitions. This allows the creation of "nested", "multiple", or "combination" RAID types.

Combining simple RAID types with different strengths can often provide the best of both worlds. For example, RAID 0 offers great performance but no redundancy while RAID 1 offers redundancy but no performance advantage. Combining them into a RAID 0+1 or a RAID 10 offers both -- with even better redundancy that in a basic RAID 1.

Combinations can be formed of any RAID types supported by Linux, but the most common variations are probably:
* RAID 0+1 -- Mirroring of strip sets
* RAID 10 -- Striping across mirror sets
* RAID 50 -- Striping across RAID 5 sets

=== Naming Conventions ===
Although usage of these conventions is not always consistent, the general rule is that the first digit in the name describes the RAID type first or at the lowest level. The second digit describes the RAID type applied second or at the logically higher level.

For example, a RAID 0+1 (so named to prevent people from assuming that a RAID 01 is the same as a RAID 1) is created by first building two or more stripe sets (identical size and configuration) and then building a mirror from them.

A RAID 10 would be created in the opposite sequence -- building multiple mirrors from paired disks and then creating a strip set across them.

=== RAID 0+1 ===
{| border 0
| RAID 0+1 (Mirroring of stripe sets)
{| border 0
| First Stripe Set
{| border 0
| Disk 1
<pre>
Data1
Data4
xxx</pre>
| Disk 2
<pre>Data2
Data5
xxx</pre>
| Disk 3
<pre>Data3
Data6
xxx</pre>
|}
| Second Stripe Set
{| border 0
| Disk 4
<pre>Data1
Data4
xxx</pre>
| Disk 5
<pre>Data2
Data5
xxx</pre>
| Disk 6
<pre>Data3
Data6
xxx</pre>
|}
|}
|}

=== RAID 10 ===

=== RAID 50 ===

== Configuring Linux Software RAID ==

=== Partition Drives ===

=== Create the RAID ===

=== Create a filesystem on the RAID ===

=== Create an <tt>/etc/raidtab</tt> file ===

=== Choose or create a mountpoint ===

=== Modify the <tt>/etc/fstab</tt> file to mount at boot ===

RAID

2004-03-17T19:51:37Z

Texastwister: RAID can be for basic PCs, not just servers!

RAID

2004-03-17T19:40:31Z

Texastwister: corrected typo

RAID

2004-03-09T05:41:14Z

Texastwister: Added RAID-5, corrected typos.

RAID

2004-03-09T00:05:28Z

Texastwister: RAID-4 info added

RAID

2004-03-08T23:39:36Z

Texastwister: Add info on RAID 1 (Striping)

RAID

2004-03-08T23:22:25Z

Texastwister:

RAID

2004-03-08T23:04:11Z

Texastwister: Added info on Linear RAID

Use software RAID

2004-03-08T19:23:59Z

Texastwister: moved to "RAID"

#REDIRECT [[RAID]]

User talk:Texastwister

2004-03-06T16:46:55Z

Texastwister:

Talk:Main Page

2004-03-05T20:31:32Z

Texastwister: Using "#" characters

Remote desktop connection

2004-03-05T06:45:25Z

Texastwister: Adding detail, adding rdesktop

[[ssh]] - SSH (secure shell) is one of the best remote login clients and servers. SSH can be used for a terminal or console session (a command prompt) like Telnet, but can also be configured to "tunnel" X-Windows applications as well. This would allow a user to, for example, log in to a remote system and launch a graphical application and have the application appear on the users system. In such a scenario, the application would appear but NOT the full desktop environment (such as Gnome or KDE).

[[VNC]] - VNC is not as secure as ssh, but is easier to use and configure. VNC is designed primarily to forward an entire GUI environment (including Gnome or KDE if they are in use).

[[Telnet]] - Telnet was one of the earliest attempts at remote administration. It is now considered inherently insecure and largely obsolete, but may have some niche uses on trusted networks. Telnet provides only a console session with not capability of forwarding X-Windows applications or GUI environments.

[[rdesktop]] - RDesktop is a Linux client that can attach to a Windows Terminal Server or to the built in Remote Desktop capability of Windows 2000 and Windows XP. It is ideal for many who prefer to work from a Linux system, but who have an occasional need to access a Windows machine. RDesktop replicates the full Windows desktop in a window withing Linux.

RAID

2004-03-04T23:53:12Z

Texastwister: building this article...

User:Texastwister

2004-03-04T07:03:41Z

Texastwister:

== Scott Purcell, the TexasTwister ==

My handle comes from a hobby and 2nd job -- balloon entertainment (see http://www.texastwister.info ). My full-time job is as a technical trainer for one of the world's largest computer companies. I'm a Linux user for about three years (although the first year was just "dabbling"). I've got my family using Linux exclusively for about the past year with only the occasional objection. I currently run Red Hat Linux 9 on two boxes and Fedora Core 1 on my laptop. I've also tried out Lycoris, Lindows, ELX, and others.

I'm excited about the potential for this wiki and look forward to contributing to it significantly.

Scott Purcell, scott(at)texastwister.info

[[User:Texastwister|Texastwister]] 02:03, Mar 4, 2004 (EST)

Talk back to me below:
----

RAID

2004-03-04T06:45:17Z

Texastwister: Created the outline for content to come

Configure Storage Devices

2004-03-04T06:16:29Z

Texastwister: Added Stub notice until topic is more fully fleshed-out

''This article is a [[LinuxQuestions.org_Wiki:stub_articles|stub]] and needs to be finished. [[LinuxQuestions.org_Wiki:plunging_forward|Plunge forward]] and [[LinuxQuestions.org_Wiki:How_to_edit_a_page|help it grow]] !'' 

[[Add a new hard drive]] -- This section will cover the steps necessary to take a new hard drive and prepare it for use in an already-in-use Linux system. It refers back to several of the other topics on this page.

[[Partition a hard drive]] -- During most install processes, partitioning is handled somewhat automatically using tools that are often specific to a particular distribution. This section details how to do it manually from the command line using tools that will exist in almost any Linux distribution.

[[Create a file system]] ("format" a partition) -- This section will describe how to create a file system on a partition. For Windows users, this step is equivalent to "formatting a drive".

[[Use software RAID]] -- RAID (Redundant Array of Independent Disks) allows two or more storage devices to be treated as a single logical device to provide increased performance, increased redundancy, or both. This section describes how to configure Linux software RAID.

[[Use LVM]] -- Normal partitions are of a fixed size and cannot be "grown". When a partition is filled, it can be cumbersome to migrate the data to a larger partition. LVM (Logical Volume Management) allows space to be added to "logical volumes" (equivalent to partitions) on the fly. This section will describe how to configure LVM.

Configure Storage Devices

2004-03-04T06:12:49Z

Texastwister: Resequenced existing sections

[[Add a new hard drive]] -- This section will cover the steps necessary to take a new hard drive and prepare it for use in an already-in-use Linux system. It refers back to several of the other topics on this page.

[[Partition a hard drive]] -- During most install processes, partitioning is handled somewhat automatically using tools that are often specific to a particular distribution. This section details how to do it manually from the command line using tools that will exist in almost any Linux distribution.

[[Create a file system]] ("format" a partition) -- This section will describe how to create a file system on a partition. For Windows users, this step is equivalent to "formatting a drive".

[[Use software RAID]] -- RAID (Redundant Array of Independent Disks) allows two or more storage devices to be treated as a single logical device to provide increased performance, increased redundancy, or both. This section describes how to configure Linux software RAID.

[[Use LVM]] -- Normal partitions are of a fixed size and cannot be "grown". When a partition is filled, it can be cumbersome to migrate the data to a larger partition. LVM (Logical Volume Management) allows space to be added to "logical volumes" (equivalent to partitions) on the fly. This section will describe how to configure LVM.

Configure Storage Devices

2004-03-03T22:42:26Z

Texastwister: Initial page creation

[[Partition a hard drive]] -- During most install processes, partioning is handled somewhat automatically using tools that are often specific to a particular distribution. This section details how to do it manually from the command line using tools that will exist in almost any Linux distribution.

[[Create a file system]] ("format" a partition) -- This section will describe how to create a file system on a partition. For Windows users, this step is equivalent to "formatting a drive".

[[Add a new hard drive]] -- This section will cover the steps necessary to take a new hard drive and prepare it for use in an already-in-use Linux system. It refers back to several of the other topics on this page.

[[Use software RAID]] -- RAID (Redundant Array of Independent Disks) allows two or more storage devices to be treated as a single logical device to provide increased performance, increased redundancy, or both. This section describes how to configure Linux software RAID.

[[Use LVM]] -- Normal partitions are of a fixed size and cannot be "grown". When a partition is filled, it can be cumbersome to migrate the data to a larger partition. LVM (Logical Volume Management) allows space to be added to "logical volumes" (equivalent to partitions) on the fly. This section will describe how to configure LVM.

Common Tasks

2004-03-03T21:18:47Z

Texastwister: Add section on Storage Configuration

Desktop Linux is still under heavy development. While we all wish Linux was so intuitive nobody needed instructions, currently that isn't the case. This section is meant for notes and quick guides on how to perform common tasks on Linux. If a section isn't yet written and you are able to write it, please do so!

* [[Connecting to the net]] - using your modem/network connection to get online
* [[Talking to friends online]] - how to access common instant messaging networks
* [[Getting help from IRC]] - LinuxQuestions is a great forum, but it isn't the only one. If you know how, the IRC chat networks can also be a useful resource.
* [[Installing Software]] - there's an excellent guide to this in the forums, so use this page for random tips and notes on the process
* [[Compiling a Kernel]] - here is a guide for compiling a kernel
* You want to show somebody your desktop? There are tools that will help you [[make a screenshot]] and [[record your desktop]] so that you can send movie-files of how nice your desktop looks.
* [[Recover a Terminal Session]] - What to do if your screen's garbaged.
*[[GRUB boot menu]] - Remove the old kernel entries from your boot up options.
* [[Configure Storage Devices]] - how to partition a hard drive, add a new hard drive, use software RAID, or use LVM (logical volume management).

LQWiki:Section suggestions

2004-03-03T19:07:21Z

Texastwister: Suggesting a STORAGE CONFIGURATION section

Please post any ideas you have for new sections below.

----
How about a section on "Storage configuration". I can contribute material on Linux Software RAID, LVM, and possibly material comparing the various supported file systems.

[[User:Texastwister|Texastwister]] 14:07, Mar 3, 2004 (EST)

----
Perhaps a section on the best way to install gnome from scratch, with a list of dependency etc would be very useful (to me it would have been anyway). Unfortunately I do not have the expertise/time to do this. Anyone who takes up the buck will have my support.

[[User:Geniarse|generic_genus]] 03:33, Mar 2, 2004 (EST)
----

I would love to see a section for "ex-windows power users". For people who know what has to be done and how to do it in windows, but not yet how it is done in Linux. This would 'tasks equivalent' list partner to the software equivalent list available at http://linuxshop.ru/linuxbegin/win-lin-soft-en/table.shtml

The key advantage of a task equivlent list would be ex-windows people would be able to search on key words which they already know to find the linux method of performing the task. Quite a lot of the time I have taken to learn linux was taken up by just finding which keyword to seach on. One complication I've identified so far - we'll need instructions for the CLI, KDE & Gnome, but it would probably complicate things too much to support all the oher desktops etc out there...

An example of a few items to get started:

===================== 
Set File Associations 
=====================

In Windows 
Explorer | Tools | Folder Options | File Types

In Linux 
Configuration | KDE | Components | File Associations

Gnome instructions go here...

===================== 
Clear Browser History 
=====================

Windows IE

Internet Explorer | Tools | Internet Options | General Tab | Clear History

Linux

KDE 
The history is stored in ~/.kde/share/apps/konqueror/konq_history
To Clear Go Konqueror | Setting Configure Conqueror | History Sidebar (9th item down on left side panel) | Clear History

================== 
Kill a crashed App 
==================

In Windows
Ctrl-Alt-Delete

In Linux
Ctrl-Esc bring up a task list, and allows the user to select and kill a process.

Ctrl=Alt-Esc invokes XKill, which changes the cursor to Skull & Crossbones - and allows the user to kill a program by positioning the cursor over the crashed program and clicking to kill it.

----

I apologize for editing your comments (which I definitely don't think should be done as a general rule) but all I did was remove the excessive equal signs and put breaks in where your text indicated you wanted them. No need for pages that would be broken on anything but 1600x1200 or higher.

Quote: 
In Windows 
Explorer | Tools | Folder Options | File Types

In Linux 
Configuration | KDE | Components | File Associations

Impossible, really. That's not how Linux works. You don't 'set file associations in Linux'. Setting that varies from KDE to Gnome to non-IDEs and from file manager to file manager. You set file associations in midnight commander and gentoo and emelfm and and and. If you set file associations at all. bash has no file associations. But something like that could be very useful - it's a good idea. It'd just have to be carefully done and require a lot of qualifying - lots of ifs, ands, and buts. 'There's more than one way to do it' and Linux isn't so much about following a rote set of steps. Even './configure, make, make install' is excessive simplification.

BTW, it's customary to separate and sign comments.

[[User:Digiot|Digiot]] 06:50, Mar 1, 2004 (EST)

----

How about a section on hardware. A place to let other know about what will work or not work. I have been playing with an old Zaurus that I got off ebay aand could have used a couple of pointers on the little things that go with it. I learned at least one thing not to do!

pben

----

Remember, you can sign your name with 4 tildes on an empty line like below:

<nowiki>~~~~</nowiki>

[[User:Skyline|Skyline]] 22:29, Mar 2, 2004 (EST)

----