1MD(4)                      Kernel Interfaces Manual                      MD(4)
2
3
4

NAME

6       md - Multiple Device driver aka Linux Software RAID
7

SYNOPSIS

9       /dev/mdn
10       /dev/md/n
11       /dev/md/name
12

DESCRIPTION

14       The  md  driver  provides  virtual devices that are created from one or
15       more independent underlying devices.  This array of devices often  con‐
16       tains redundancy and the devices are often disk drives, hence the acro‐
17       nym RAID which stands for a Redundant Array of Independent Disks.
18
19       md supports RAID levels 1 (mirroring), 4  (striped  array  with  parity
20       device),  5  (striped  array  with  distributed  parity information), 6
21       (striped array with distributed dual redundancy  information),  and  10
22       (striped  and  mirrored).   If  some number of underlying devices fails
23       while using one of these levels, the array will continue  to  function;
24       this  number  is one for RAID levels 4 and 5, two for RAID level 6, and
25       all but one (N-1) for RAID level 1, and dependent on configuration  for
26       level 10.
27
28       md also supports a number of pseudo RAID (non-redundant) configurations
29       including RAID0 (striped array), LINEAR (catenated array), MULTIPATH (a
30       set  of  different  interfaces to the same device), and FAULTY (a layer
31       over a single device into which errors can be injected).
32
33
34   MD METADATA
35       Each device in an array may have some metadata stored  in  the  device.
36       This  metadata  is sometimes called a superblock.  The metadata records
37       information about the structure and state of the  array.   This  allows
38       the array to be reliably re-assembled after a shutdown.
39
40       From Linux kernel version 2.6.10, md provides support for two different
41       formats of metadata, and other formats can be  added.   Prior  to  this
42       release, only one format is supported.
43
44       The common format — known as version 0.90 — has a superblock that is 4K
45       long and is written into a 64K aligned block that starts at  least  64K
46       and  less than 128K from the end of the device (i.e. to get the address
47       of the superblock round the size of the device down to  a  multiple  of
48       64K  and  then subtract 64K).  The available size of each device is the
49       amount of space before the super block, so between 64K and 128K is lost
50       when a device in incorporated into an MD array.  This superblock stores
51       multi-byte fields in a processor-dependent  manner,  so  arrays  cannot
52       easily be moved between computers with different processors.
53
54       The new format — known as version 1 — has a superblock that is normally
55       1K long, but can be longer.  It is normally stored between 8K  and  12K
56       from  the end of the device, on a 4K boundary, though variations can be
57       stored at the start of the device (version 1.1) or 4K from the start of
58       the  device  (version 1.2).  This metadata format stores multibyte data
59       in a processor-independent format and supports up to hundreds of compo‐
60       nent devices (version 0.90 only supports 28).
61
62       The metadata contains, among other things:
63
64       LEVEL  The  manner  in  which  the  devices are arranged into the array
65              (LINEAR, RAID0, RAID1, RAID4, RAID5, RAID10, MULTIPATH).
66
67       UUID   a 128 bit Universally  Unique  Identifier  that  identifies  the
68              array that contains this device.
69
70
71       When  a version 0.90 array is being reshaped (e.g. adding extra devices
72       to a RAID5), the version number  is  temporarily  set  to  0.91.   This
73       ensures that if the reshape process is stopped in the middle (e.g. by a
74       system crash) and the machine boots into an older kernel that does  not
75       support  reshaping,  then  the array will not be assembled (which would
76       cause data corruption) but will be left untouched until a  kernel  that
77       can complete the reshape processes is used.
78
79
80   ARRAYS WITHOUT METADATA
81       While it is usually best to create arrays with superblocks so that they
82       can be assembled reliably, there are some circumstances when  an  array
83       without superblocks is preferred.  These include:
84
85       LEGACY ARRAYS
86              Early  versions of the md driver only supported LINEAR and RAID0
87              configurations and did not use a superblock (which is less crit‐
88              ical  with  these  configurations).  While such arrays should be
89              rebuilt with superblocks if possible, md  continues  to  support
90              them.
91
92       FAULTY Being  a  largely transparent layer over a different device, the
93              FAULTY  personality  doesn't  gain  anything   from   having   a
94              superblock.
95
96       MULTIPATH
97              It is often possible to detect devices which are different paths
98              to the same storage directly rather than  having  a  distinctive
99              superblock  written to the device and searched for on all paths.
100              In this case, a MULTIPATH array with no superblock makes sense.
101
102       RAID1  In some configurations it might be desired  to  create  a  RAID1
103              configuration  that  does  not use a superblock, and to maintain
104              the state of the array elsewhere.  While not encouraged for gen‐
105              eral use, it does have special-purpose uses and is supported.
106
107
108   ARRAYS WITH EXTERNAL METADATA
109       From release 2.6.28, the md driver supports arrays with externally man‐
110       aged metadata.  That is, the metadata is not managed by the kernel  but
111       rather  by  a user-space program which is external to the kernel.  This
112       allows support for a variety of metadata formats without cluttering the
113       kernel with lots of details.
114
115       md  is  able to communicate with the user-space program through various
116       sysfs attributes so that it can make appropriate changes to  the  meta‐
117       data - for example to mark a device as faulty.  When necessary, md will
118       wait for the program to acknowledge the event by  writing  to  a  sysfs
119       attribute.   The  manual  page  for mdmon(8) contains more detail about
120       this interaction.
121
122
123   CONTAINERS
124       Many metadata formats use a single block of metadata to describe a num‐
125       ber of different arrays which all use the same set of devices.  In this
126       case it is helpful for the kernel to know about the full set of devices
127       as a whole.  This set is known to md as a container.  A container is an
128       md array with externally managed metadata and with  device  offset  and
129       size  so  that  it  just  covers the metadata part of the devices.  The
130       remainder of each device is available to be incorporated  into  various
131       arrays.
132
133
134   LINEAR
135       A  LINEAR  array  simply catenates the available space on each drive to
136       form one large virtual drive.
137
138       One advantage of this arrangement over the more common  RAID0  arrange‐
139       ment  is  that  the  array  may be reconfigured at a later time with an
140       extra drive, so the array is made bigger without  disturbing  the  data
141       that is on the array.  This can even be done on a live array.
142
143       If  a  chunksize is given with a LINEAR array, the usable space on each
144       device is rounded down to a multiple of this chunksize.
145
146
147   RAID0
148       A RAID0 array (which has zero redundancy) is also known  as  a  striped
149       array.  A RAID0 array is configured at creation with a Chunk Size which
150       must be a power of  two  (prior  to  Linux  2.6.31),  and  at  least  4
151       kibibytes.
152
153       The  RAID0  driver  assigns  the  first chunk of the array to the first
154       device, the second chunk to the second device,  and  so  on  until  all
155       drives have been assigned one chunk.  This collection of chunks forms a
156       stripe.  Further chunks are gathered into stripes in the same way,  and
157       are assigned to the remaining space in the drives.
158
159       If devices in the array are not all the same size, then once the small‐
160       est device has been  exhausted,  the  RAID0  driver  starts  collecting
161       chunks  into smaller stripes that only span the drives which still have
162       remaining space.
163
164
165
166   RAID1
167       A RAID1 array is also known as a mirrored set (though mirrors  tend  to
168       provide reflected images, which RAID1 does not) or a plex.
169
170       Once  initialised,  each  device  in a RAID1 array contains exactly the
171       same data.  Changes are written to all devices in  parallel.   Data  is
172       read  from  any  one  device.   The  driver attempts to distribute read
173       requests across all devices to maximise performance.
174
175       All devices in a RAID1 array should be the same size.  If they are not,
176       then  only the amount of space available on the smallest device is used
177       (any extra space on other devices is wasted).
178
179       Note that the read balancing done by the driver does not make the RAID1
180       performance  profile  be  the  same  as  for  RAID0; a single stream of
181       sequential input will not be accelerated (e.g. a single dd), but multi‐
182       ple  sequential  streams  or  a  random workload will use more than one
183       spindle. In theory, having an N-disk  RAID1  will  allow  N  sequential
184       threads to read from all disks.
185
186       Individual  devices  in a RAID1 can be marked as "write-mostly".  These
187       drives are excluded from the normal read balancing  and  will  only  be
188       read  from  when  there  is  no  other  option.  This can be useful for
189       devices connected over a slow link.
190
191
192   RAID4
193       A RAID4 array is like a RAID0 array with an extra  device  for  storing
194       parity.  This  device  is  the last of the active devices in the array.
195       Unlike RAID0, RAID4 also requires that all stripes span all drives,  so
196       extra space on devices that are larger than the smallest is wasted.
197
198       When  any block in a RAID4 array is modified, the parity block for that
199       stripe (i.e. the block in the parity device at the same  device  offset
200       as  the  stripe)  is also modified so that the parity block always con‐
201       tains the "parity" for the whole stripe.  I.e. its content  is  equiva‐
202       lent  to the result of performing an exclusive-or operation between all
203       the data blocks in the stripe.
204
205       This allows the array to continue to function if one device fails.  The
206       data  that was on that device can be calculated as needed from the par‐
207       ity block and the other data blocks.
208
209
210   RAID5
211       RAID5 is very similar to RAID4.  The  difference  is  that  the  parity
212       blocks  for  each stripe, instead of being on a single device, are dis‐
213       tributed across all devices.  This allows more parallelism  when  writ‐
214       ing,  as  two different block updates will quite possibly affect parity
215       blocks on different devices so there is less contention.
216
217       This also allows more parallelism when reading, as  read  requests  are
218       distributed over all the devices in the array instead of all but one.
219
220
221   RAID6
222       RAID6  is  similar to RAID5, but can handle the loss of any two devices
223       without data loss.  Accordingly, it requires  N+2  drives  to  store  N
224       drives worth of data.
225
226       The  performance for RAID6 is slightly lower but comparable to RAID5 in
227       normal mode and single disk failure mode.  It is very slow in dual disk
228       failure mode, however.
229
230
231   RAID10
232       RAID10  provides  a  combination  of  RAID1 and RAID0, and is sometimes
233       known as RAID1+0.  Every datablock is duplicated some number of  times,
234       and  the resulting collection of datablocks are distributed over multi‐
235       ple drives.
236
237       When configuring a RAID10 array, it is necessary to specify the  number
238       of  replicas  of  each  data block that are required (this will usually
239       be 2) and whether their layout should  be  "near",  "far"  or  "offset"
240       (with "offset" being available since Linux 2.6.18).
241
242       About the RAID10 Layout Examples:
243       The  examples  below visualise the chunk distribution on the underlying
244       devices for the respective layout.
245
246       For simplicity it is assumed that the size of  the  chunks  equals  the
247       size  of  the  blocks of the underlying devices as well as those of the
248       RAID10 device exported by the kernel (for example /dev/md/name).
249       Therefore the chunks / chunk numbers map directly to the  blocks /block
250       addresses of the exported RAID10 device.
251
252       Decimal  numbers (0, 1, 2, ...) are the chunks of the RAID10 and due to
253       the above assumption  also  the  blocks  and  block  addresses  of  the
254       exported RAID10 device.
255       Repeated numbers mean copies of a chunk / block (obviously on different
256       underlying devices).
257       Hexadecimal numbers (0x00, 0x01, 0x02, ...) are the block addresses  of
258       the underlying devices.
259
260
261        "near" Layout
262              When  "near" replicas are chosen, the multiple copies of a given
263              chunk are laid out consecutively ("as close  to  each  other  as
264              possible") across the stripes of the array.
265
266              With  an  even  number of devices, they will likely (unless some
267              misalignment is present) lay at the very same offset on the dif‐
268              ferent devices.
269              This is as the "classic" RAID1+0; that is two groups of mirrored
270              devices (in the example  below  the  groups  Device #1 / #2  and
271              Device #3 / #4  are each a RAID1) both in turn forming a striped
272              RAID0.
273
274              Example with 2 copies  per  chunk  and  an  even  number (4)  of
275              devices:
276
277                    ┌───────────┌───────────┌───────────┌───────────┐
278                    │ Device #1 │ Device #2 │ Device #3 │ Device #4 │
279              ┌─────├───────────├───────────├───────────├───────────┤
280              │0x00 │     0     │     0     │     1     │     1     │
281              │0x01 │     2     │     2     │     3     │     3     │
282              │...  │    ...    │    ...    │    ...    │    ...    │
283              │ :   │     :     │     :     │     :     │     :     │
284              │...  │    ...    │    ...    │    ...    │    ...    │
285              │0x80 │    254    │    254    │    255    │    255    │
286              └─────└───────────└───────────└───────────└───────────┘
287                      \---------v---------/   \---------v---------/
288                              RAID1                   RAID1
289                      \---------------------v---------------------/
290                                          RAID0
291
292              Example  with  2 copies  per  chunk  and  an  odd  number (5) of
293              devices:
294
295                    ┌────────┌────────┌────────┌────────┌────────┐
296                    │ Dev #1 │ Dev #2 │ Dev #3 │ Dev #4 │ Dev #5 │
297              ┌─────├────────├────────├────────├────────├────────┤
298              │0x00 │   0    │   0    │   1    │   1    │   2    │
299              │0x01 │   2    │   3    │   3    │   4    │   4    │
300              │...  │  ...   │  ...   │  ...   │  ...   │  ...   │
301              │ :   │   :    │   :    │   :    │   :    │   :    │
302              │...  │  ...   │  ...   │  ...   │  ...   │  ...   │
303              │0x80 │  317   │  318   │  318   │  319   │  319   │
304              └─────└────────└────────└────────└────────└────────┘
305
306
307
308        "far" Layout
309              When "far" replicas are chosen, the multiple copies of  a  given
310              chunk  are  laid out quite distant ("as far as reasonably possi‐
311              ble") from each other.
312
313              First a complete sequence of all data blocks (that  is  all  the
314              data  one  sees  on the exported RAID10 block device) is striped
315              over the  devices.  Then  another  (though  "shifted")  complete
316              sequence of all data blocks; and so on (in the case of more than
317              2 copies per chunk).
318
319              The "shift" needed to prevent placing copies of the same  chunks
320              on  the  same devices is actually a cyclic permutation with off‐
321              set 1 of each of the  stripes  within  a  complete  sequence  of
322              chunks.
323              The  offset 1  is  relative to the previous complete sequence of
324              chunks, so in case of more than 2 copies per chunk one gets  the
325              following offsets:
326              1. complete sequence of chunks: offset =  0
327              2. complete sequence of chunks: offset =  1
328              3. complete sequence of chunks: offset =  2
329                                     :
330              n. complete sequence of chunks: offset = n-1
331
332              Example  with  2 copies  per  chunk  and  an  even number (4) of
333              devices:
334
335                    ┌───────────┌───────────┌───────────┌───────────┐
336                    │ Device #1 │ Device #2 │ Device #3 │ Device #4 │
337              ┌─────├───────────├───────────├───────────├───────────┤
338              │0x00 │     0     │     1     │     2     │     3     │ \
339              │0x01 │     4     │     5     │     6     │     7     │ > [#]
340              │...  │    ...    │    ...    │    ...    │    ...    │ :
341              │ :   │     :     │     :     │     :     │     :     │ :
342              │...  │    ...    │    ...    │    ...    │    ...    │ :
343              │0x40 │    252    │    253    │    254    │    255    │ /
344              │0x41 │     3     │     0     │     1     │     2     │ \
345              │0x42 │     7     │     4     │     5     │     6     │ > [#]~
346              │...  │    ...    │    ...    │    ...    │    ...    │ :
347              │ :   │     :     │     :     │     :     │     :     │ :
348              │...  │    ...    │    ...    │    ...    │    ...    │ :
349              │0x80 │    255    │    252    │    253    │    254    │ /
350              └─────└───────────└───────────└───────────└───────────┘
351
352              Example with  2 copies  per  chunk  and  an  odd  number (5)  of
353              devices:
354
355                    ┌────────┌────────┌────────┌────────┌────────┐
356                    │ Dev #1 │ Dev #2 │ Dev #3 │ Dev #4 │ Dev #5 │
357              ┌─────├────────├────────├────────├────────├────────┤
358              │0x00 │   0    │   1    │   2    │   3    │   4    │ \
359              │0x01 │   5    │   6    │   7    │   8    │   9    │ > [#]
360              │...  │  ...   │  ...   │  ...   │  ...   │  ...   │ :
361              │ :   │   :    │   :    │   :    │   :    │   :    │ :
362              │...  │  ...   │  ...   │  ...   │  ...   │  ...   │ :
363              │0x40 │  315   │  316   │  317   │  318   │  319   │ /
364              │0x41 │   4    │   0    │   1    │   2    │   3    │ \
365              │0x42 │   9    │   5    │   6    │   7    │   8    │ > [#]~
366              │...  │  ...   │  ...   │  ...   │  ...   │  ...   │ :
367              │ :   │   :    │   :    │   :    │   :    │   :    │ :
368              │...  │  ...   │  ...   │  ...   │  ...   │  ...   │ :
369              │0x80 │  319   │  315   │  316   │  317   │  318   │ /
370              └─────└────────└────────└────────└────────└────────┘
371
372              With  [#] being  the  complete  sequence  of chunks and [#]~ the
373              cyclic permutation with offset 1 thereof (in the  case  of  more
374              than     2     copies     per     chunk     there    would    be
375              ([#]~)~, (([#]~)~)~, ...).
376
377              The advantage of this  layout  is  that  MD  can  easily  spread
378              sequential  reads over the devices, making them similar to RAID0
379              in terms of speed.
380              The cost is more seeking for writes, making  them  substantially
381              slower.
382
383
384       "offset" Layout
385              When  "offset"  replicas  are  chosen, all the copies of a given
386              chunk are striped consecutively ("offset by  the  stripe  length
387              after each other") over the devices.
388
389              Explained  in detail, <number of devices> consecutive chunks are
390              striped over the devices, immediately followed  by  a  "shifted"
391              copy  of  these  chunks (and by further such "shifted" copies in
392              the case of more than 2 copies per chunk).
393              This pattern repeats for all further consecutive chunks  of  the
394              exported  RAID10  device  (in  other  words:  all  further  data
395              blocks).
396
397              The "shift" needed to prevent placing copies of the same  chunks
398              on  the  same devices is actually a cyclic permutation with off‐
399              set 1 of each of the striped copies of <number of devices>  con‐
400              secutive chunks.
401              The offset 1 is relative to the previous striped copy of <number
402              of devices> consecutive chunks, so in case of more than 2 copies
403              per chunk one gets the following offsets:
404              1. <number of devices> consecutive chunks: offset =  0
405              2. <number of devices> consecutive chunks: offset =  1
406              3. <number of devices> consecutive chunks: offset =  2
407                                           :
408              n. <number of devices> consecutive chunks: offset = n-1
409
410              Example  with  2 copies  per  chunk  and  an  even number (4) of
411              devices:
412
413                    ┌───────────┌───────────┌───────────┌───────────┐
414                    │ Device #1 │ Device #2 │ Device #3 │ Device #4 │
415              ┌─────├───────────├───────────├───────────├───────────┤
416              │0x00 │     0     │     1     │     2     │     3     │ ) AA
417              │0x01 │     3     │     0     │     1     │     2     │ ) AA~
418              │0x02 │     4     │     5     │     6     │     7     │ ) AB
419              │0x03 │     7     │     4     │     5     │     6     │ ) AB~
420              │...  │    ...    │    ...    │    ...    │    ...    │ ) ...
421              │ :   │     :     │     :     │     :     │     :     │   :
422              │...  │    ...    │    ...    │    ...    │    ...    │ ) ...
423              │0x79 │    251    │    252    │    253    │    254    │ ) EX
424              │0x80 │    254    │    251    │    252    │    253    │ ) EX~
425              └─────└───────────└───────────└───────────└───────────┘
426
427              Example with  2 copies  per  chunk  and  an  odd  number (5)  of
428              devices:
429
430                    ┌────────┌────────┌────────┌────────┌────────┐
431                    │ Dev #1 │ Dev #2 │ Dev #3 │ Dev #4 │ Dev #5 │
432              ┌─────├────────├────────├────────├────────├────────┤
433              │0x00 │   0    │   1    │   2    │   3    │   4    │ ) AA
434              │0x01 │   4    │   0    │   1    │   2    │   3    │ ) AA~
435              │0x02 │   5    │   6    │   7    │   8    │   9    │ ) AB
436              │0x03 │   9    │   5    │   6    │   7    │   8    │ ) AB~
437              │...  │  ...   │  ...   │  ...   │  ...   │  ...   │ ) ...
438              │ :   │   :    │   :    │   :    │   :    │   :    │   :
439              │...  │  ...   │  ...   │  ...   │  ...   │  ...   │ ) ...
440              │0x79 │  314   │  315   │  316   │  317   │  318   │ ) EX
441              │0x80 │  318   │  314   │  315   │  316   │  317   │ ) EX~
442              └─────└────────└────────└────────└────────└────────┘
443
444              With  AA, AB, ...,  AZ, BA, ...  being  the  sets  of <number of
445              devices> consecutive chunks and AA~, AB~, ..., AZ~, BA~, ... the
446              cyclic  permutations  with offset 1 thereof (in the case of more
447              than 2 copies per chunk there would be (AA~)~, ...  as  well  as
448              ((AA~)~)~, ... and so on).
449
450              This  should  give  similar  read  characteristics to "far" if a
451              suitably large chunk size is used, but without as  much  seeking
452              for writes.
453
454       It  should  be  noted that the number of devices in a RAID10 array need
455       not be a multiple of the number of replica of each data block; however,
456       there must be at least as many devices as replicas.
457
458       If,  for  example,  an  array is created with 5 devices and 2 replicas,
459       then space equivalent to 2.5 of the  devices  will  be  available,  and
460       every block will be stored on two different devices.
461
462       Finally,  it  is  possible  to have an array with both "near" and "far"
463       copies.  If an array is configured with 2 near copies and 2 far copies,
464       then there will be a total of 4 copies of each block, each on a differ‐
465       ent drive.  This is an artifact of the implementation and  is  unlikely
466       to be of real value.
467
468
469   MULTIPATH
470       MULTIPATH  is not really a RAID at all as there is only one real device
471       in a MULTIPATH md array.  However  there  are  multiple  access  points
472       (paths) to this device, and one of these paths might fail, so there are
473       some similarities.
474
475       A MULTIPATH array is  composed  of  a  number  of  logically  different
476       devices,  often  fibre  channel interfaces, that all refer the the same
477       real device. If one of these interfaces fails (e.g. due to cable  prob‐
478       lems),  the  MULTIPATH  driver  will  attempt  to  redirect requests to
479       another interface.
480
481       The MULTIPATH drive is not receiving any ongoing development and should
482       be considered a legacy driver.  The device-mapper based multipath driv‐
483       ers should be preferred for new installations.
484
485
486   FAULTY
487       The FAULTY md module is provided for testing purposes.  A FAULTY  array
488       has  exactly  one  component device and is normally assembled without a
489       superblock, so the md array created provides direct access  to  all  of
490       the data in the component device.
491
492       The  FAULTY module may be requested to simulate faults to allow testing
493       of other md levels or of filesystems.  Faults can be chosen to  trigger
494       on  read requests or write requests, and can be transient (a subsequent
495       read/write at the address will probably succeed) or persistent  (subse‐
496       quent  read/write of the same address will fail).  Further, read faults
497       can be "fixable" meaning that they persist until a write request at the
498       same address.
499
500       Fault  types  can  be requested with a period.  In this case, the fault
501       will recur repeatedly after the given number of requests of  the  rele‐
502       vant type.  For example if persistent read faults have a period of 100,
503       then every 100th read request would generate a fault,  and  the  faulty
504       sector  would be recorded so that subsequent reads on that sector would
505       also fail.
506
507       There is a limit to the number of faulty sectors that  are  remembered.
508       Faults  generated  after  this  limit is exhausted are treated as tran‐
509       sient.
510
511       The list of faulty sectors can be flushed, and the active list of fail‐
512       ure modes can be cleared.
513
514
515   UNCLEAN SHUTDOWN
516       When  changes are made to a RAID1, RAID4, RAID5, RAID6, or RAID10 array
517       there is a possibility of inconsistency for short periods  of  time  as
518       each  update  requires  at  least  two block to be written to different
519       devices, and these writes probably won't happen  at  exactly  the  same
520       time.   Thus  if  a  system with one of these arrays is shutdown in the
521       middle of a write operation (e.g. due to power failure), the array  may
522       not be consistent.
523
524       To  handle  this  situation,  the  md  driver marks an array as "dirty"
525       before writing any data to it, and marks it as "clean" when  the  array
526       is  being  disabled, e.g. at shutdown.  If the md driver finds an array
527       to be dirty at startup, it proceeds to correct any  possibly  inconsis‐
528       tency.   For  RAID1,  this  involves  copying the contents of the first
529       drive onto all other drives.  For RAID4, RAID5 and RAID6 this  involves
530       recalculating  the parity for each stripe and making sure that the par‐
531       ity block has the correct data.  For RAID10 it involves copying one  of
532       the replicas of each block onto all the others.  This process, known as
533       "resynchronising" or "resync" is  performed  in  the  background.   The
534       array can still be used, though possibly with reduced performance.
535
536       If  a  RAID4,  RAID5  or  RAID6 array is degraded (missing at least one
537       drive, two for RAID6) when it is restarted after an  unclean  shutdown,
538       it  cannot recalculate parity, and so it is possible that data might be
539       undetectably corrupted.  The 2.4 md driver does not alert the  operator
540       to  this  condition.   The 2.6 md driver will fail to start an array in
541       this condition without manual intervention, though this  behaviour  can
542       be overridden by a kernel parameter.
543
544
545   RECOVERY
546       If  the  md driver detects a write error on a device in a RAID1, RAID4,
547       RAID5, RAID6, or RAID10 array,  it  immediately  disables  that  device
548       (marking  it  as  faulty)  and  continues  operation  on  the remaining
549       devices.  If there are spare drives, the driver will  start  recreating
550       on  one  of  the  spare drives the data which was on that failed drive,
551       either by copying a working drive in a RAID1 configuration, or by doing
552       calculations  with  the  parity  block  on RAID4, RAID5 or RAID6, or by
553       finding and copying originals for RAID10.
554
555       In kernels prior to about 2.6.15, a read error  would  cause  the  same
556       effect  as  a write error.  In later kernels, a read-error will instead
557       cause md to attempt a recovery by overwriting the bad  block.  i.e.  it
558       will find the correct data from elsewhere, write it over the block that
559       failed, and then try to read it back again.  If either the write or the
560       re-read  fail,  md will treat the error the same way that a write error
561       is treated, and will fail the whole device.
562
563       While this recovery process is happening, the md  driver  will  monitor
564       accesses  to the array and will slow down the rate of recovery if other
565       activity is happening, so that normal access to the array will  not  be
566       unduly  affected.   When  no  other activity is happening, the recovery
567       process proceeds at full speed.  The actual speed targets for  the  two
568       different  situations  can  be  controlled  by  the speed_limit_min and
569       speed_limit_max control files mentioned below.
570
571
572   SCRUBBING AND MISMATCHES
573       As storage devices can develop bad blocks at any time it is valuable to
574       regularly  read  all  blocks  on all devices in an array so as to catch
575       such bad blocks early.  This process is called scrubbing.
576
577       md arrays can be scrubbed by writing either check or repair to the file
578       md/sync_action in the sysfs directory for the device.
579
580       Requesting a scrub will cause md to read every block on every device in
581       the array, and check that  the  data  is  consistent.   For  RAID1  and
582       RAID10,  this means checking that the copies are identical.  For RAID4,
583       RAID5, RAID6 this means checking that the parity block  is  (or  blocks
584       are) correct.
585
586       If  a read error is detected during this process, the normal read-error
587       handling causes correct data to be found from other devices and  to  be
588       written  back to the faulty device.  In many case this will effectively
589       fix the bad block.
590
591       If all blocks read successfully but are found  to  not  be  consistent,
592       then this is regarded as a mismatch.
593
594       If  check  was used, then no action is taken to handle the mismatch, it
595       is simply recorded.  If repair  was  used,  then  a  mismatch  will  be
596       repaired  in  the same way that resync repairs arrays.  For RAID5/RAID6
597       new parity blocks are written.  For RAID1/RAID10, all but one block are
598       overwritten with the content of that one block.
599
600       A  count  of  mismatches is recorded in the sysfs file md/mismatch_cnt.
601       This is set to zero when a scrub starts and is incremented  whenever  a
602       sector  is  found  that is a mismatch.  md normally works in units much
603       larger than a single sector and when it finds a mismatch, it  does  not
604       determine exactly how many actual sectors were affected but simply adds
605       the number of sectors in the IO unit that was used.  So a value of  128
606       could  simply  mean  that  a  single  64KB  check found an error (128 x
607       512bytes = 64KB).
608
609       If an array is created by mdadm with --assume-clean then  a  subsequent
610       check could be expected to find some mismatches.
611
612       On a truly clean RAID5 or RAID6 array, any mismatches should indicate a
613       hardware problem at some level - software  issues  should  never  cause
614       such a mismatch.
615
616       However on RAID1 and RAID10 it is possible for software issues to cause
617       a mismatch to be reported.  This does not  necessarily  mean  that  the
618       data  on  the  array  is corrupted.  It could simply be that the system
619       does not care what is stored on that part of the array - it  is  unused
620       space.
621
622       The  most  likely  cause  for an unexpected mismatch on RAID1 or RAID10
623       occurs if a swap partition or swap file is stored on the array.
624
625       When the swap subsystem wants to write a page of memory out,  it  flags
626       the  page as 'clean' in the memory manager and requests the swap device
627       to write it out.  It is quite possible that the memory will be  changed
628       while  the  write-out is happening.  In that case the 'clean' flag will
629       be found to be clear when the write completes and so the swap subsystem
630       will simply forget that the swapout had been attempted, and will possi‐
631       bly choose a different page to write out.
632
633       If the swap device was on RAID1 (or RAID10), then the data is sent from
634       memory to a device twice (or more depending on the number of devices in
635       the array).  Thus it is possible that the memory gets  changed  between
636       the times it is sent, so different data can be written to the different
637       devices in the array.  This will be detected by check  as  a  mismatch.
638       However it does not reflect any corruption as the block where this mis‐
639       match occurs is being treated by the swap system as  being  empty,  and
640       the data will never be read from that block.
641
642       It  is  conceivable for a similar situation to occur on non-swap files,
643       though it is less likely.
644
645       Thus the mismatch_cnt value can not be  interpreted  very  reliably  on
646       RAID1 or RAID10, especially when the device is used for swap.
647
648
649
650   BITMAP WRITE-INTENT LOGGING
651       From  Linux  2.6.13,  md  supports a bitmap based write-intent log.  If
652       configured, the bitmap is used to record which blocks of the array  may
653       be  out  of  sync.   Before any write request is honoured, md will make
654       sure that the corresponding bit in the log is set.  After a  period  of
655       time with no writes to an area of the array, the corresponding bit will
656       be cleared.
657
658       This bitmap is used for two optimisations.
659
660       Firstly, after an unclean shutdown, the resync process will consult the
661       bitmap and only resync those blocks that correspond to bits in the bit‐
662       map that are set.  This can dramatically reduce resync time.
663
664       Secondly, when a drive fails and is removed from the  array,  md  stops
665       clearing bits in the intent log.  If that same drive is re-added to the
666       array, md will notice and will only recover the sections of  the  drive
667       that  are  covered  by  bits  in the intent log that are set.  This can
668       allow a device to be temporarily removed and reinserted without causing
669       an enormous recovery cost.
670
671       The  intent log can be stored in a file on a separate device, or it can
672       be stored near the superblocks of an array which has superblocks.
673
674       It is possible to add an intent log to an active array,  or  remove  an
675       intent log if one is present.
676
677       In  2.6.13, intent bitmaps are only supported with RAID1.  Other levels
678       with redundancy are supported from 2.6.15.
679
680
681   BAD BLOCK LIST
682       From Linux 3.5 each device in an md array can store a  list  of  known-
683       bad-blocks.   This list is 4K in size and usually positioned at the end
684       of the space between the superblock and the data.
685
686       When a block cannot be read and cannot  be  repaired  by  writing  data
687       recovered from other devices, the address of the block is stored in the
688       bad block list.  Similarly if an attempt to write a  block  fails,  the
689       address  will  be recorded as a bad block.  If attempting to record the
690       bad block fails, the whole device will be marked faulty.
691
692       Attempting to read from a known bad block  will  cause  a  read  error.
693       Attempting  to  write to a known bad block will be ignored if any write
694       errors have been reported by the device.  If there have been  no  write
695       errors then the data will be written to the known bad block and if that
696       succeeds, the address will be removed from the list.
697
698       This allows an array to fail more gracefully - a few blocks on  differ‐
699       ent devices can be faulty without taking the whole array out of action.
700
701       The  list  is particularly useful when recovering to a spare.  If a few
702       blocks cannot be read from the other devices, the bulk of the  recovery
703       can complete and those few bad blocks will be recorded in the bad block
704       list.
705
706
707   WRITE-BEHIND
708       From Linux 2.6.14, md supports WRITE-BEHIND on RAID1 arrays.
709
710       This allows certain devices in the array to be flagged as write-mostly.
711       MD will only read from such devices if there is no other option.
712
713       If  a  write-intent  bitmap  is also provided, write requests to write-
714       mostly devices will be treated as write-behind requests and md will not
715       wait  for  writes  to  those  requests to complete before reporting the
716       write as complete to the filesystem.
717
718       This allows for a RAID1 with WRITE-BEHIND to be  used  to  mirror  data
719       over  a  slow  link  to a remote computer (providing the link isn't too
720       slow).  The extra latency of the remote link will not slow down  normal
721       operations,  but  the remote system will still have a reasonably up-to-
722       date copy of all data.
723
724
725   RESTRIPING
726       Restriping, also known as Reshaping, is the processes  of  re-arranging
727       the  data  stored in each stripe into a new layout.  This might involve
728       changing the number of devices in the array (so the stripes are wider),
729       changing the chunk size (so stripes are deeper or shallower), or chang‐
730       ing the arrangement of data and  parity  (possibly  changing  the  RAID
731       level, e.g. 1 to 5 or 5 to 6).
732
733       As  of  Linux  2.6.35, md can reshape a RAID4, RAID5, or RAID6 array to
734       have a different number of devices (more or fewer) and to have  a  dif‐
735       ferent layout or chunk size.  It can also convert between these differ‐
736       ent RAID levels.  It can also convert between  RAID0  and  RAID10,  and
737       between  RAID0  and  RAID4 or RAID5.  Other possibilities may follow in
738       future kernels.
739
740       During any stripe process there is a 'critical  section'  during  which
741       live  data is being overwritten on disk.  For the operation of increas‐
742       ing the number of drives in a RAID5, this critical section  covers  the
743       first few stripes (the number being the product of the old and new num‐
744       ber of devices).  After this critical section is passed, data  is  only
745       written to areas of the array which no longer hold live data — the live
746       data has already been located away.
747
748       For a reshape which reduces the number of devices, the  'critical  sec‐
749       tion' is at the end of the reshape process.
750
751       md  is  not  able to ensure data preservation if there is a crash (e.g.
752       power failure) during the critical section.  If md is asked to start an
753       array  which  failed  during  a critical section of restriping, it will
754       fail to start the array.
755
756       To deal with this possibility, a user-space program must
757
758       ·   Disable writes to that section of the array (using the sysfs inter‐
759           face),
760
761       ·   take a copy of the data somewhere (i.e. make a backup),
762
763       ·   allow the process to continue and invalidate the backup and restore
764           write access once the critical section is passed, and
765
766       ·   provide for restoring the critical data before restarting the array
767           after a system crash.
768
769       mdadm versions from 2.4 do this for growing a RAID5 array.
770
771       For  operations  that  do not change the size of the array, like simply
772       increasing chunk size, or converting RAID5  to  RAID6  with  one  extra
773       device,  the entire process is the critical section.  In this case, the
774       restripe will need to progress in stages, as a  section  is  suspended,
775       backed up, restriped, and released.
776
777
778   SYSFS INTERFACE
779       Each  block  device  appears  as a directory in sysfs (which is usually
780       mounted at /sys).  For MD devices, this directory will contain a subdi‐
781       rectory  called md which contains various files for providing access to
782       information about the array.
783
784       This  interface  is  documented  more  fully  in  the  file  Documenta‐
785       tion/md.txt  which  is  distributed with the kernel sources.  That file
786       should be consulted for full documentation.  The following are  just  a
787       selection of attribute files that are available.
788
789
790       md/sync_speed_min
791              This  value,  if  set,  overrides  the  system-wide  setting  in
792              /proc/sys/dev/raid/speed_limit_min for this array only.  Writing
793              the value system to this file will cause the system-wide setting
794              to have effect.
795
796
797       md/sync_speed_max
798              This  is  the  partner  of   md/sync_speed_min   and   overrides
799              /proc/sys/dev/raid/speed_limit_max described below.
800
801
802       md/sync_action
803              This  can  be  used  to  monitor and control the resync/recovery
804              process of MD.  In particular, writing "check" here  will  cause
805              the array to read all data block and check that they are consis‐
806              tent (e.g. parity is correct, or all  mirror  replicas  are  the
807              same).  Any discrepancies found are NOT corrected.
808
809              A count of problems found will be stored in md/mismatch_count.
810
811              Alternately,  "repair"  can be written which will cause the same
812              check to be performed, but any errors will be corrected.
813
814              Finally, "idle" can be written to stop the check/repair process.
815
816
817       md/stripe_cache_size
818              This is only available on RAID5 and RAID6.  It records the  size
819              (in  pages  per  device)  of the  stripe cache which is used for
820              synchronising all write operations to the  array  and  all  read
821              operations if the array is degraded.  The default is 256.  Valid
822              values are 17 to 32768.  Increasing  this  number  can  increase
823              performance  in  some situations, at some cost in system memory.
824              Note, setting this value too high can result in an "out of  mem‐
825              ory" condition for the system.
826
827              memory_consumed     =     system_page_size    *    nr_disks    *
828              stripe_cache_size
829
830
831       md/preread_bypass_threshold
832              This is only available on RAID5 and RAID6.  This  variable  sets
833              the  number  of times MD will service a full-stripe-write before
834              servicing a stripe that requires some "prereading".   For  fair‐
835              ness   this   defaults   to   1.    Valid   values   are   0  to
836              stripe_cache_size.  Setting this to 0 maximizes sequential-write
837              throughput  at  the  cost  of fairness to threads doing small or
838              random writes.
839
840
841   KERNEL PARAMETERS
842       The md driver recognised several different kernel parameters.
843
844       raid=noautodetect
845              This will disable the normal detection of md arrays that happens
846              at  boot time.  If a drive is partitioned with MS-DOS style par‐
847              titions, then if any of the 4 main partitions  has  a  partition
848              type  of 0xFD, then that partition will normally be inspected to
849              see if it is part of an MD array, and if  any  full  arrays  are
850              found,  they  are  started.  This kernel parameter disables this
851              behaviour.
852
853
854       raid=partitionable
855
856       raid=part
857              These are available in 2.6 and later kernels only.   They  indi‐
858              cate that autodetected MD arrays should be created as partition‐
859              able arrays, with a different major device number to the  origi‐
860              nal non-partitionable md arrays.  The device number is listed as
861              mdp in /proc/devices.
862
863
864       md_mod.start_ro=1
865
866       /sys/module/md_mod/parameters/start_ro
867              This tells md to start all arrays in read-only mode.  This is  a
868              soft  read-only  that will automatically switch to read-write on
869              the first write request.   However  until  that  write  request,
870              nothing  is  written  to any device by md, and in particular, no
871              resync or recovery operation is started.
872
873
874       md_mod.start_dirty_degraded=1
875
876       /sys/module/md_mod/parameters/start_dirty_degraded
877              As mentioned above, md will not normally start a  RAID4,  RAID5,
878              or  RAID6  that is both dirty and degraded as this situation can
879              imply hidden data  loss.   This  can  be  awkward  if  the  root
880              filesystem is affected.  Using this module parameter allows such
881              arrays to be started at boot time.  It should be understood that
882              there  is  a real (though small) risk of data corruption in this
883              situation.
884
885
886       md=n,dev,dev,...
887
888       md=dn,dev,dev,...
889              This tells the md driver to assemble /dev/md n from  the  listed
890              devices.   It  is only necessary to start the device holding the
891              root filesystem this way.  Other arrays are  best  started  once
892              the system is booted.
893
894              In  2.6  kernels, the d immediately after the = indicates that a
895              partitionable device (e.g.  /dev/md/d0) should be created rather
896              than the original non-partitionable device.
897
898
899       md=n,l,c,i,dev...
900              This  tells  the  md driver to assemble a legacy RAID0 or LINEAR
901              array without a superblock.  n gives the  md  device  number,  l
902              gives the level, 0 for RAID0 or -1 for LINEAR, c gives the chunk
903              size as a base-2 logarithm offset by twelve, so 0  means  4K,  1
904              means 8K.  i is ignored (legacy support).
905
906

FILES

908       /proc/mdstat
909              Contains  information  about  the  status  of  currently running
910              array.
911
912       /proc/sys/dev/raid/speed_limit_min
913              A readable and writable file that reflects  the  current  "goal"
914              rebuild  speed for times when non-rebuild activity is current on
915              an array.  The speed is in Kibibytes per second, and is  a  per-
916              device  rate,  not  a  per-array rate (which means that an array
917              with more disks will shuffle more data for a given speed).   The
918              default is 1000.
919
920
921       /proc/sys/dev/raid/speed_limit_max
922              A  readable  and  writable file that reflects the current "goal"
923              rebuild speed for times when no non-rebuild activity is  current
924              on an array.  The default is 200,000.
925
926

SEE ALSO

928       mdadm(8),
929
930
931
932                                                                         MD(4)
Impressum