mdadm(8)                                                 mdadm(8)



NNAAMMEE
       mdadm - manage MD devices _a_k_a Linux Software Raid.


SSYYNNOOPPSSIISS
       mmddaaddmm _[_m_o_d_e_] _<_r_a_i_d_d_e_v_i_c_e_> _[_o_p_t_i_o_n_s_] _<_s_u_b_d_e_v_i_c_e_s_>


DDEESSCCRRIIPPTTIIOONN
       RAID  devices are virtual devices created from two or more
       real block devices. This allows  multiple  devices  (typi-
       cally  disk  drives or partitions there-of) to be combined
       into a single  device  to  hold  (for  example)  a  single
       filesystem.   Some  RAID levels included redundancy and so
       can survive some degree of device failure.

       Linux Software RAID devices are implemented through the md
       (Multiple Devices) device driver.

       Currently, Linux supports LLIINNEEAARR md devices, RRAAIIDD00 (strip-
       ing), RRAAIIDD11 (mirroring), RRAAIIDD44 and RRAAIIDD55..

       Recent kernels (2002) also support a mode known as  MMUULLTTII--
       PPAATTHH.  mmddaaddmm does not support MULTIPATH as yet.

       mmddaaddmm is a program that can be used to create, manage, and
       monitor MD devices.  As such it provides a similar set  of
       functionality  to the rraaiiddttoooollss packages.  The key differ-
       ences between mmddaaddmm and rraaiiddttoooollss are:

       +o   mmddaaddmm is a single program and not a collection of pro-
           grams.

       +o   mmddaaddmm  can perform (almost) all of its functions with-
           out having a configuration  file.   Also  mdadm  helps
           with management of the configuration file.

       +o   mmddaaddmm   can  provide  information  about  your  arrays
           (through Detail and Examine) that rraaiiddttoooollss cannot.

       +o   rraaiiddttoooollss can manage  MULTIPATH  devices  which  mmddaaddmm
           cannot yet manage.


MMOODDEESS
       mdadm has 7 major modes of operation:

       AAsssseemmbbllee
              Assemble  the  parts  of a previously created array
              into an active array. Components can be  explicitly
              given  or  can  be searched for.  mmddaaddmm checks that
              the components do form a bona fide array, and  can,
              on  request, fiddle superblock information so as to
              assemble a faulty array.


       BBuuiilldd  Build   a   legacy   array    without    per-device
              superblocks.


       CCrreeaattee Create a new array with per-device superblocks.


       DDeettaaiill Display  the details of a given md device.  Details
              include the RAID  level,  the  number  of  devices,
              which ones are faulty (if any), and the array UUID.


       EExxaammiinnee
              Examine a device to see if it  is  part  of  an  md
              array,  and  print  out  the details of that array.
              This mode can also be used to examine a large  num-
              ber  of  devices  and to print out a summary of the
              arrays  found  in  a  format   suitable   for   the
              mmddaaddmm..ccoonnff configuration file.


       FFoollllooww oorr MMoonniittoorr
              Monitor one or more md devices and act on any state
              changes.


       MMaannaaggee This  is  for  odd  bits  an  pieces  like  hotadd,
              hotremove, setfaulty, stop, readonly, readwrite.


OOPPTTIIOONNSS
       Available options are:


       --AA, ----aasssseemmbbllee
              Assemble an existing array.


       --BB, ----bbuuiilldd
              Build a legacy array without superblocks.


       --CC, ----ccrreeaattee
              Create a new array.


       --DD, ----ddeettaaiill
              Print detail of one or more md devices.


       --EE, ----eexxaammiinnee
              Print content of md superblock on device(s).


       --FF, ----ffoollllooww, ----mmoonniittoorr
              Select MMoonniittoorr mode.


       --hh, ----hheellpp
              Display  help  message or, after above option, mode
              specific help message.


       --VV, ----vveerrssiioonn
              Print version information for mdadm.


       --vv, ----vveerrbboossee
              Be more verbose about what is happening.


       --bb, ----bbrriieeff
              Be less verbose.  This is used  with  ----ddeettaaiill  and
              ----eexxaammiinnee.


FFoorr ccrreeaattee oorr bbuuiilldd::
       --cc, ----cchhuunnkk==
              Specify  chunk  size  of kibibytes.  The default is
              64.


       ----rroouunnddiinngg==
              Specify rounding factor for linear  array  (==chunk
              size)


       --ll, ----lleevveell==
              Set  raid  level.   Options  are: linear, raid0, 0,
              stripe, raid1,  1,  mirror,  raid5,  4,  raid5,  5.
              Obviously  some  of these are synonymous.  Only the
              first 4 are valid when Building.


       --pp, ----ppaarriittyy==
              Set   raid5   parity   algorithm.   Options    are:
              {left,right}-{,a}symmetric,  la,  ra,  ls, rs.  The
              default is left-symmetric.


       ----llaayyoouutt==
              same as --parity


       --nn, ----rraaiidd--ddiisskkss==
              number of active devices in array.


       --xx, ----ssppaarree--ddiisskkss==
              number of spare (eXtra)  disks  in  initial  array.
              Spares can be added and removed later.


       --zz, ----ssiizzee==
              Amount  (in  Kibibytes)  of  space to use from each
              drive in RAID1/4/5.  This must be a multiple of the
              chunk  size, and must leave about 128Kb of space at
              the end of the drive for the RAID  superblock.   If
              this  is  not specified (as it normally is not) the
              smallest drive (or partition) sets the size, though
              if  there is a variance among the drives of greater
              than 1%, a warning is issued.


FFoorr aasssseemmbbllee::
       --uu, ----uuuuiidd==
              uuid of array to assemble. Devices which don't have
              this uuid are excluded


       --mm, ----ssuuppeerr--mmiinnoorr==
              Minor  number of device that array was created for.
              Devices which don't  have  this  minor  number  are
              excluded.  If you create an array as /dev/md1, then
              all superblock will contain  the  minor  number  1,
              even if the array is later assembled as /dev/md2.


       --cc, ----ccoonnffiigg==
              config file.  Default is //eettcc//mmddaaddmm..ccoonnff.


       --ss, ----ssccaann
              scan config file for missing information


       --ff, ----ffoorrccee
              Assemble  the array even if some superblocks appear
              out-of-date


       --RR, ----rruunn
              Attempt to start the array  even  if  fewer  drives
              were  given  than are needed for a full array. Nor-
              mally if not all drives are found and ----ssccaann is not
              used,  then  the  array  will  be assembled but not
              started.  With ----rruunn an attempt  will  be  made  to
              start it anyway.


GGeenneerraall mmaannaaggeemmeenntt
       --aa, ----aadddd
              hotadd listed devices.


       --rr, ----rreemmoovvee
              remove  listed  devices.   The  must not be active.
              i.e. they should be failed or spare devices.


       --ff, ----ffaaiill
              mark listed devices as faulty.


       ----sseett--ffaauullttyy
              same as --fail.


       --RR, ----rruunn
              start a partially built array.


       --SS, ----ssttoopp
              deactivate array, releasing all resources.


       --oo, ----rreeaaddoonnllyy
              mark array as readonly.


       --ww, ----rreeaaddwwrriittee
              mark array as readwrite.



AASSSSEEMMBBLLYY MMOODDEE
       Usage: mmddaaddmm ----aasssseemmbbllee _d_e_v_i_c_e _o_p_t_i_o_n_s_._._.

       Usage: mmddaaddmm ----aasssseemmbbllee ----ssccaann _o_p_t_i_o_n_s_._._.


       This usage assembles one or more  raid  arrays  from  pre-
       existing  components.  For each array, mdadm needs to know
       the md device, the identity of the array, and a number  of
       sub devices. These can be found in a number of ways.

       The  md  device  is either given before ----ssccaann or is found
       from the config file. In  the  latter  case,  multiple  md
       devices can be started with a single mdadm command.

       The identity can be given with the ----uuuuiidd option, with the
       ----ssuuppeerr--mmiinnoorr option, can be found in in the config  file,
       or  will be taken from the super block on the first subde-
       vice listed on the command line.

       Devices can be given on the  ----aasssseemmbbllee  command  line  or
       from  the  config  file.  Only  devices  which  have an md
       superblock which contains the right identity will be  con-
       sidered for any device.

       The  config  file  is  only  used if explicitly named with
       ----ccoonnffiigg or requested with ----ssccaann..   In  the  later  case,
       //eettcc//mmddaaddmm..ccoonnff is used.

       If  ----ssccaann is not given, then the config file will only be
       used to find the identity of md arrays.

       Normally the array will be started after it is  assembled.
       However  is  ----ssccaann  is  not given and insufficient drives
       were lists to start a complete (non-degraded) array,  then
       the  array is not started (to guard against usage errors).
       To insist that the array be started in this case  (as  may
       work for RAID1 or RAID5), give the ----rruunn flag.



BBUUIILLDD MMOODDEE
       Usage:  mmddaaddmm  ----bbuuiilldd  _d_e_v_i_c_e ----cchhuunnkk==_X ----lleevveell==_Y ----rraaiidd--
                   ddiisskkss==_Z _d_e_v_i_c_e_s


       This usage is similar to ----ccrreeaattee.  The difference is that
       it creates a legacy array without a superblock. With these
       arrays there is no difference between  initially  creating
       the  array  and  subsequently assembling the array, except
       that hopefully there is useful data there  in  the  second
       case.

       The  level  may  only  be 0, raid0, or linear. All devices
       must be listed and the array will  be  started  once  com-
       plete.


CCRREEAATTEE MMOODDEE
       Usage: mmddaaddmm ----ccrreeaattee _d_e_v_i_c_e ----cchhuunnkk==_X ----lleevveell==_Y
                   ----rraaiidd--ddiisskkss==_Z _d_e_v_i_c_e_s


       This  usage will initialise a new md array, associate some
       devices with it, and activate the array.

       As devices are added, they are checked to see if they con-
       tain  raid superblocks or filesystems. They are also check
       to see if the variance in device size exceeds 1%.

       If any discrepancy is found, the array will not  automati-
       cally  be run, though the presence of a ----rruunn can override
       this caution.


       The General Management options that are valid with  --cre-
       ate are:

       ----rruunn  insist  of  running  the array even if some devices
              look like they might be in use.


       ----rreeaaddoonnllyy
              start the array readonly - not supported yet.


DDEETTAAIILL MMOODDEE
       Usage: mmddaaddmm ----ddeettaaiill [----bbrriieeff] _d_e_v_i_c_e _._._.


       This usage sill print out the details of the  given  array
       including a list of component devices.  To determine names
       for the devices, mmddaaddmm searches //ddeevv for device files with
       the right major and minor numbers.

       With  ----bbrriieeff  mmddaaddmm  prints a single line that identifies
       the level, number of disks, and UUID of the  array.   This
       line is suitable for inclusion in //eettcc//mmddaaddmm..ccoonnff.


EEXXAAMMIINNEE MMOODDEE
       Usage: mmddaaddmm ----eexxaammiinnee [----ssccaann] [----bbrriieeff] _d_e_v_i_c_e _._._.

       This  usage will examine some block devices to see if that
       have a valid RAID superblock on them.  The information  in
       each valid raid superblock will be printed.

       If  ----ssccaann  is  used, the no devices should be listed, and
       the complete set of devices identified in  the  configura-
       tion  file  are  checked.  ----ssccaann implies ----bbrriieeff but this
       implication can be countered by specifying ----vveerrbboossee.

       With ----bbrriieeff mmddaaddmm will output an  config  file  entry  of
       each  distinct array that was found.  This entry will list
       the UUID, the raid level, and a  list  of  the  individual
       devices  on  which  a superblock for that array was found.
       This output will by syntactically suitable  for  inclusion
       in the configuration file, but should NNOOTT be used blindly.
       Often the array description that you want in the  configu-
       ration file is much less specific than that given by mmddaaddmm
       --BBss.  For example, you normally do not want  to  list  the
       devices, particularly if they are SCSI devices.



FFIILLEESS
   //pprroocc//mmddssttaatt
       If  you're  using the //pprroocc filesystem, //pprroocc//mmddssttaatt gives
       you informations about md devices status.   This  file  is
       not currently used by mmddaaddmm.


   //eettcc//mmddaaddmm..ccoonnff
       The  config file lists which devices may be scanned to see
       if they contain MD  super  block,  and  gives  identifying
       information  (e.g.  UUID)  about  known  MD  arrays.   See
       mmddaaddmm..ccoonnff(5) for more details.



TTOODDOO
       Finish and document Follow mode.


SSEEEE AALLSSOO
       For information on the various levels of RAID, check out:


              http://ostenfeld.dk/~jakob/Software-RAID.HOWTO/

       for new releases of the RAID driver check out:


              ftp://ftp.kernel.org/pub/linux/kernel/peo-
              ple/mingo/raid-patches

       or

              http://www.cse.unsw.edu.au/~neilb/patches/linux-
              stable/

       mmddaaddmm..ccoonnff(5), mmdd(4).

       _r_a_i_d_t_a_b(5), _r_a_i_d_0_r_u_n(8), _r_a_i_d_s_t_o_p(8), _m_k_r_a_i_d(8)



                                                         mdadm(8)
