It looks ugly in my editor.
Signed-off-by: NeilBrown <neilb@suse.de>
monitor.
8/ mdadm::Grow_reshape() calls ->manage_reshape to oversee the
rest of the reshape.
-
+
9/ mdadm::<format>->manage_reshape(): saves data that will be overwritten by
the kernel to either the backup file or the metadata specific location,
advances sync_max, waits for reshape, ping mdmon, repeat.
kernel-managed-metadata this protection is provided by
->reshape_safe, but that does not protect us in the case
of user-space-managed-metadata.
-
+
10/ mdadm::<format>->manage_reshape(): Once reshape completes changes the raid
level back to the nominal raid level (if necessary)
->set_array_state to record the the reshape is complete.
For container-wide reshape, this happens once for each
member array.
-
-
-
+
+
+
...
[1]: Linux kernel design patterns - part 3, Neil Brown http://lwn.net/Articles/336262/
and FAULTY (a layer over a single device into which errors can be injected).
.SS MD METADATA
-Each device in an array may have some
+Each device in an array may have some
.I metadata
stored in the device. This metadata is sometimes called a
.BR superblock .
A RAID0 array (which has zero redundancy) is also known as a
striped array.
A RAID0 array is configured at creation with a
-.B "Chunk Size"
+.B "Chunk Size"
which must be a power of two (prior to Linux 2.6.31), and at least 4
kibibytes.
stripe that requires some "prereading". For fairness this defaults to
1. Valid values are 0 to stripe_cache_size. Setting this to 0
maximizes sequential-write throughput at the cost of fairness to threads
-doing small or random writes.
+doing small or random writes.
.SS KERNEL PARAMETERS
.B name
is supported.
-The
+The
.B name
option updates the subarray name in the metadata, it may not affect the
device node name or the device node symlink until the subarray is
-re\-assembled. If updating
+re\-assembled. If updating
.B name
would change the UUID of an active subarray this operation is blocked,
and the command will end in an error.
# ARRAY lines specify information about how to identify arrays so
# so that they can be activated
#
-# You can have more than one device line and use wild cards. The first
+# You can have more than one device line and use wild cards. The first
# example includes SCSI the first partition of SCSI disks /dev/sdb,
-# /dev/sdc, /dev/sdd, /dev/sdj, /dev/sdk, and /dev/sdl. The second
+# /dev/sdc, /dev/sdd, /dev/sdj, /dev/sdk, and /dev/sdl. The second
# line looks for array slices on IDE disks.
#
#DEVICE /dev/sd[bcdjkl]1
.B mdadm.conf
with the exception of
.B auto=
-which is supported only if mdadm was built with the
+which is supported only if mdadm was built with the
.B \-DMDASSEMBLE_AUTO
define.
mdadm -S $md0
# now with no superblock
-mdadm -B $md0 -l linear -n5 $dev0 $dev1 $dev2 $dev3 $dev4
+mdadm -B $md0 -l linear -n5 $dev0 $dev1 $dev2 $dev3 $dev4
check linear
testdev $md0 5 $size 64
mdadm -S $md0
# create a simple raid0
-mdadm -CR $md0 -l raid0 -n3 $dev0 $dev1 $dev2
+mdadm -CR $md0 -l raid0 -n3 $dev0 $dev1 $dev2
check raid0
-testdev $md0 3 $mdsize2_l 512
+testdev $md0 3 $mdsize2_l 512
mdadm -S $md0
# now with version-0.90 superblock
-mdadm -CR $md0 -e0.90 -l0 -n4 $dev0 $dev1 $dev2 $dev3
+mdadm -CR $md0 -e0.90 -l0 -n4 $dev0 $dev1 $dev2 $dev3
check raid0
-testdev $md0 4 $mdsize0 512
+testdev $md0 4 $mdsize0 512
mdadm -S $md0
# now with no superblock
-mdadm -B $md0 -l0 -n5 $dev0 $dev1 $dev2 $dev3 $dev4
+mdadm -B $md0 -l0 -n5 $dev0 $dev1 $dev2 $dev3 $dev4
check raid0
testdev $md0 5 $size 512
mdadm -S $md0
# now same again with different chunk size
for chunk in 4 32 256
do
- mdadm -CR $md0 -e0.90 -l raid0 --chunk $chunk -n3 $dev0 $dev1 $dev2
+ mdadm -CR $md0 -e0.90 -l raid0 --chunk $chunk -n3 $dev0 $dev1 $dev2
check raid0
testdev $md0 3 $mdsize0 $chunk
mdadm -S $md0
# now with version-1 superblock
- mdadm -CR $md0 -e1.0 -l0 -c $chunk -n4 $dev0 $dev1 $dev2 $dev3
+ mdadm -CR $md0 -e1.0 -l0 -c $chunk -n4 $dev0 $dev1 $dev2 $dev3
check raid0
testdev $md0 4 $mdsize1 $chunk
mdadm -S $md0
# now with no superblock
- mdadm -B $md0 -l0 -n5 --chun=$chunk $dev0 $dev1 $dev2 $dev3 $dev4
+ mdadm -B $md0 -l0 -n5 --chun=$chunk $dev0 $dev1 $dev2 $dev3 $dev4
check raid0
testdev $md0 5 $size $chunk
mdadm -S $md0
# test version0, version1, and no super
# test resync and recovery.
-mdadm -CR $md0 -l 1 -n2 $dev0 $dev1
+mdadm -CR $md0 -l 1 -n2 $dev0 $dev1
check resync
check raid1
testdev $md0 1 $mdsize1a 64
mdadm -S $md0
# now with version-0.90 superblock, spare
-mdadm -CR $md0 -e0.90 --level=raid1 -n3 -x2 $dev0 missing missing $dev1 $dev2
+mdadm -CR $md0 -e0.90 --level=raid1 -n3 -x2 $dev0 missing missing $dev1 $dev2
check recovery
check raid1
testdev $md0 1 $mdsize0 64
mdadm -S $md0
# now with no superblock
-mdadm -B $md0 -l mirror -n2 $dev0 $dev1
+mdadm -B $md0 -l mirror -n2 $dev0 $dev1
check resync
check raid1
testdev $md0 1 $size 1
mdadm -S $md0
# again, but with no resync
-mdadm -B $md0 -l 1 --assume-clean -n2 $dev0 $dev1
+mdadm -B $md0 -l 1 --assume-clean -n2 $dev0 $dev1
check raid1
check nosync
testdev $md0 1 $size 1
# create a simple raid4 set
-mdadm -CfR $md0 -l 4 -n3 $dev0 $dev1 $dev2
+mdadm -CfR $md0 -l 4 -n3 $dev0 $dev1 $dev2
check resync ; check raid[45]
testdev $md0 2 $mdsize1 512
mdadm -S $md0
# now with version-1 superblock
-mdadm -CR $md0 -e1 --level=raid4 -n4 $dev0 $dev1 $dev2 $dev3
+mdadm -CR $md0 -e1 --level=raid4 -n4 $dev0 $dev1 $dev2 $dev3
check recovery; check raid[45]
testdev $md0 3 $mdsize1 512
mdadm -S $md0
# create a simple raid5 set
-mdadm -CfR $md0 -e 0.90 -l 5 -n3 $dev0 $dev1 $dev2
+mdadm -CfR $md0 -e 0.90 -l 5 -n3 $dev0 $dev1 $dev2
check resync
testdev $md0 2 $mdsize0 512
mdadm -S $md0
# now with version-1 superblock
-mdadm -CR $md0 -e1 --level=raid5 -n4 $dev0 $dev1 $dev2 $dev3
+mdadm -CR $md0 -e1 --level=raid5 -n4 $dev0 $dev1 $dev2 $dev3
check recovery
testdev $md0 3 $mdsize1 512
mdadm -S $md0
for lo in la ra left-symmetric right-symmetric
do
- mdadm -CfR $md0 -l 5 -p $lo -n3 $dev0 $dev1 $dev2
+ mdadm -CfR $md0 -l 5 -p $lo -n3 $dev0 $dev1 $dev2
check resync ; check raid5
testdev $md0 2 $mdsize1 512
mdadm -S $md0
# now with version-1 superblock
- mdadm -CR $md0 -e1 --level=raid5 --layout $lo -n4 $dev0 $dev1 $dev2 $dev3
+ mdadm -CR $md0 -e1 --level=raid5 --layout $lo -n4 $dev0 $dev1 $dev2 $dev3
check recovery ; check raid5
testdev $md0 3 $mdsize1 512
mdadm -S $md0
# create a simple raid6 set
-mdadm -CfR $md0 -e0.90 -l 6 -n4 $dev0 $dev1 $dev2 $dev3
+mdadm -CfR $md0 -e0.90 -l 6 -n4 $dev0 $dev1 $dev2 $dev3
check resync ; check raid6
testdev $md0 2 $mdsize0 512
mdadm -S $md0
# now with version-1 superblock
-mdadm -CR $md0 -e1 --level=raid6 -n5 $dev0 $dev1 $dev2 $dev3 $dev4
+mdadm -CR $md0 -e1 --level=raid6 -n5 $dev0 $dev1 $dev2 $dev3 $dev4
check resync ; check raid6
testdev $md0 3 $mdsize1 512
mdadm -S $md0
mdadm -CR $md0 -l1 -n4 $dev0 $dev1 $dev2 missing
check resync
-mdadm $md0 --fail $dev2
+mdadm $md0 --fail $dev2
check resync
-mdadm $md0 --fail $dev1
+mdadm $md0 --fail $dev1
sleep 1
check nosync
check state U___
-mdadm $md0 --add $dev4 $dev3
+mdadm $md0 --add $dev4 $dev3
check recovery
# there could be two separate recoveries, one for each dev
check wait
check wait
-mdadm $md0 --remove $dev2 $dev1
+mdadm $md0 --remove $dev2 $dev1
check nosync
check state UUU_
mdadm --zero-superblock $dev2
-mdadm $md0 -a $dev2
+mdadm $md0 -a $dev2
check recovery
check wait
check state UUUU
# Add two more, fail and remove one
# wait for sync to complete, fail, remove, re-add
-mdadm -CR $md0 -l5 -n4 $dev0 $dev1 $dev2 $dev3
+mdadm -CR $md0 -l5 -n4 $dev0 $dev1 $dev2 $dev3
check recovery
mdadm $md0 --fail $dev3
sleep 1
check nosync
check state UUU_
-mdadm $md0 --add $dev4 $dev5
+mdadm $md0 --add $dev4 $dev5
check recovery
check wait
-mdadm $md0 --fail $dev0
-mdadm $md0 --remove $dev3 $dev0
+mdadm $md0 --fail $dev0
+mdadm $md0 --remove $dev3 $dev0
check recovery
check state _UUU
-mdadm $md0 -a $dev3
+mdadm $md0 -a $dev3
check recovery
check wait
check state UUUU
# Make a raid1, add a device, then remove it again.
-mdadm -CR $md0 -l1 -n2 -x1 $dev0 $dev1 $dev2
+mdadm -CR $md0 -l1 -n2 -x1 $dev0 $dev1 $dev2
check resync
check wait
check state UU
check wait
check state UUU
-mdadm $md0 --fail $dev0
+mdadm $md0 --fail $dev0
check state _UU
mdadm --grow $md0 -n 2
# same again for version-1
-mdadm -CR $md0 -l1 -n2 -e1.2 -x1 $dev0 $dev1 $dev2
+mdadm -CR $md0 -l1 -n2 -e1.2 -x1 $dev0 $dev1 $dev2
check resync
check wait
check state UU
check wait
check state UUU
-mdadm $md0 --fail $dev0
+mdadm $md0 --fail $dev0
check state _UU
mdadm --grow $md0 -n 2
# create a small raid1 array, make it larger. Then make it smaller
-mdadm -CR $md0 -e 0.90 --level raid1 --raid-disks 3 --size $[size/2] $dev1 $dev2 $dev3
+mdadm -CR $md0 -e 0.90 --level raid1 --raid-disks 3 --size $[size/2] $dev1 $dev2 $dev3
check wait
check state UUU
testdev $md0 1 $[size/2] 1
mdadm -S $md0
# same again with version 1.1 superblock
-mdadm -CR $md0 --level raid1 --metadata=1.1 --raid-disks 3 --size $[size/2] $dev1 $dev2 $dev3
+mdadm -CR $md0 --level raid1 --metadata=1.1 --raid-disks 3 --size $[size/2] $dev1 $dev2 $dev3
check wait
check state UUU
testdev $md0 1 $[size/2] 1
# create a small raid5 array, make it larger. Then make it smaller
-mdadm -CR $md0 -e0.90 --level raid5 --chunk=64 --raid-disks 3 --size $[size/2] $dev1 $dev2 $dev3
+mdadm -CR $md0 -e0.90 --level raid5 --chunk=64 --raid-disks 3 --size $[size/2] $dev1 $dev2 $dev3
check wait
check state UUU
testdev $md0 2 $[size/2] 32
mdadm -S $md0
# same again with version 1.1 superblock
-mdadm -CR $md0 --level raid5 --metadata=1.1 --chunk=128 --raid-disks 4 --size $[size/2] $dev1 $dev2 $dev3 $dev4
+mdadm -CR $md0 --level raid5 --metadata=1.1 --chunk=128 --raid-disks 4 --size $[size/2] $dev1 $dev2 $dev3 $dev4
check wait
check state UUUU
testdev $md0 3 $[size/2] 128
# create a small raid6 array, make it larger. Then make it smaller
-mdadm -CR $md0 -e 0.90 --level raid6 --chunk=64 --raid-disks 4 --size $[size/2] $dev1 $dev2 $dev3 $dev4
+mdadm -CR $md0 -e 0.90 --level raid6 --chunk=64 --raid-disks 4 --size $[size/2] $dev1 $dev2 $dev3 $dev4
check wait
check state UUUU
testdev $md0 2 $[size/2] 32
mdadm -S $md0
# same again with version 1.1 superblock
-mdadm -CR $md0 --level raid6 --metadata=1.1 --chunk=128 --raid-disks 4 --size $[size/2] $dev1 $dev2 $dev3 $dev4
+mdadm -CR $md0 --level raid6 --metadata=1.1 --chunk=128 --raid-disks 4 --size $[size/2] $dev1 $dev2 $dev3 $dev4
check wait
check state UUUU
testdev $md0 2 $[size/2] 128
# uuid, md-minor on command line with wildcard devices
# mdadm.conf file
-mdadm -CR $md2 -l0 -n3 $dev0 $dev1 $dev2
+mdadm -CR $md2 -l0 -n3 $dev0 $dev1 $dev2
check raid0
tst="testdev $md2 3 $mdsize1_l 512"
$tst
uuid=`mdadm -Db $md2 | sed 's/.*UUID=//'`
mdadm -S $md2
-mdadm -A $md2 $dev0 $dev1 $dev2
+mdadm -A $md2 $dev0 $dev1 $dev2
$tst
mdadm -S $md2
-mdadm -A $md2 -u $uuid $devlist
+mdadm -A $md2 -u $uuid $devlist
$tst
mdadm -S $md2
-mdadm --assemble $md2 --name=2 $devlist
+mdadm --assemble $md2 --name=2 $devlist
$tst
mdadm -S $md2
conf=$targetdir/mdadm.conf
-{
+{
echo DEVICE $devlist
echo array $md2 UUID=$uuid
} > $conf
-mdadm -As -c $conf $md2
+mdadm -As -c $conf $md2
$tst
mdadm -S $md2
-{
+{
echo DEVICE $devlist
echo array $md2 name=2
} > $conf
-mdadm -As -c $conf $md2
+mdadm -As -c $conf $md2
$tst
mdadm -S $md2
-{
+{
echo DEVICE $devlist
echo array $md2 devices=$dev0,$dev1,$dev2
} > $conf
-mdadm -As -c $conf $md2
+mdadm -As -c $conf $md2
$tst
echo "DEVICE $devlist" > $conf
mdadm -Db $md2 >> $conf
mdadm -S $md2
-mdadm --assemble --scan --config=$conf $md2
+mdadm --assemble --scan --config=$conf $md2
$tst
mdadm -S $md2
echo " metadata=0.90 devices=$dev0,$dev1,$dev2" >> $conf
-mdadm --assemble --scan --config=$conf $md2
+mdadm --assemble --scan --config=$conf $md2
$tst
mdadm -S $md2
### Now for version 0...
mdadm --zero-superblock $dev0 $dev1 $dev2
-mdadm -CR $md2 -l0 --metadata=0.90 -n3 $dev0 $dev1 $dev2
+mdadm -CR $md2 -l0 --metadata=0.90 -n3 $dev0 $dev1 $dev2
check raid0
tst="testdev $md2 3 $mdsize0 512"
$tst
uuid=`mdadm -Db $md2 | sed 's/.*UUID=//'`
mdadm -S $md2
-mdadm -A $md2 $dev0 $dev1 $dev2
+mdadm -A $md2 $dev0 $dev1 $dev2
$tst
mdadm -S $md2
-mdadm -A $md2 -u $uuid $devlist
+mdadm -A $md2 -u $uuid $devlist
$tst
mdadm -S $md2
-mdadm --assemble $md2 --super-minor=2 $devlist #
+mdadm --assemble $md2 --super-minor=2 $devlist #
$tst
mdadm -S $md2
conf=$targetdir/mdadm.conf
-{
+{
echo DEVICE $devlist
echo array $md2 UUID=$uuid
} > $conf
-mdadm -As -c $conf $md2
+mdadm -As -c $conf $md2
$tst
mdadm -S $md2
-{
+{
echo DEVICE $devlist
echo array $md2 super-minor=2
} > $conf
-mdadm -As -c $conf $md2
+mdadm -As -c $conf $md2
$tst
mdadm -S $md2
-{
+{
echo DEVICE $devlist
echo array $md2 devices=$dev0,$dev1,$dev2
} > $conf
-mdadm -As -c $conf $md2
+mdadm -As -c $conf $md2
$tst
echo "DEVICE $devlist" > $conf
mdadm -Db $md2 >> $conf
mdadm -S $md2
-mdadm --assemble --scan --config=$conf $md2
+mdadm --assemble --scan --config=$conf $md2
$tst
mdadm -S $md2
echo " metadata=1 devices=$dev0,$dev1,$dev2" >> $conf
-mdadm --assemble --scan --config=$conf $md2
+mdadm --assemble --scan --config=$conf $md2
$tst
mdadm -S $md2
# create a raid5 array and assemble it in various ways,
# including with missing devices.
-mdadm -CR -e 0.90 $md1 -l5 -n3 $dev0 $dev1 $dev2
+mdadm -CR -e 0.90 $md1 -l5 -n3 $dev0 $dev1 $dev2
tst="check raid5 ;testdev $md1 2 $mdsize0 512 ; mdadm -S $md1"
uuid=`mdadm -Db $md1 | sed 's/.*UUID=//'`
check wait
eval $tst
-mdadm -A $md1 $dev0 $dev1 $dev2
+mdadm -A $md1 $dev0 $dev1 $dev2
eval $tst
-mdadm -A $md1 -u $uuid $devlist
+mdadm -A $md1 -u $uuid $devlist
eval $tst
-mdadm -A $md1 -m 1 $devlist
+mdadm -A $md1 -m 1 $devlist
eval $tst
conf=$targetdir/mdadm.conf
-{
+{
echo DEVICE $devlist
echo array $md1 UUID=$uuid
} > $conf
-mdadm -As -c $conf $md1
+mdadm -As -c $conf $md1
eval $tst
-{
+{
echo DEVICE $devlist
echo array $md1 super-minor=1
} > $conf
-mdadm -As -c $conf
+mdadm -As -c $conf
eval $tst
-{
+{
echo DEVICE $devlist
echo array $md1 devices=$dev0,$dev1,$dev2
} > $conf
-mdadm -As -c $conf
+mdadm -As -c $conf
echo "DEVICE $devlist" > $conf
mdadm -Db $md1 >> $conf
eval $tst
-mdadm --assemble --scan --config=$conf $md1
+mdadm --assemble --scan --config=$conf $md1
eval $tst
echo " metadata=0.90 devices=$dev0,$dev1,$dev2" >> $conf
-mdadm --assemble --scan --config=$conf $md1
+mdadm --assemble --scan --config=$conf $md1
eval $tst
### Now with a missing device
-mdadm -AR $md1 $dev0 $dev2 #
+mdadm -AR $md1 $dev0 $dev2 #
check state U_U
eval $tst
-mdadm -A $md1 -u $uuid $devlist
+mdadm -A $md1 -u $uuid $devlist
check state U_U
eval $tst
-mdadm -A $md1 -m 1 $devlist
+mdadm -A $md1 -m 1 $devlist
check state U_U
eval $tst
conf=$targetdir/mdadm.conf
-{
+{
echo DEVICE $devlist
echo array $md1 UUID=$uuid
} > $conf
-mdadm -As -c $conf $md1
+mdadm -As -c $conf $md1
check state U_U
eval $tst
-{
+{
echo DEVICE $devlist
echo array $md1 super-minor=1
} > $conf
-mdadm -As -c $conf
+mdadm -As -c $conf
check state U_U
eval $tst
-{
+{
echo DEVICE $devlist
echo array $md1 devices=$dev0,$dev1,$dev2
} > $conf
-mdadm -As -c $conf
+mdadm -As -c $conf
echo "DEVICE $devlist" > $conf
mdadm -Db $md1 >> $conf
check state U_U
eval $tst
-mdadm --assemble --scan --config=$conf $md1
+mdadm --assemble --scan --config=$conf $md1
check state U_U
eval $tst
echo " metadata=0.90 devices=$dev0,$dev1,$dev2" >> $conf
-mdadm --assemble --scan --config=$conf $md1
+mdadm --assemble --scan --config=$conf $md1
check state U_U
eval $tst
# create a raid0, re-assemble with a different super-minor
-mdadm -CR -e 0.90 $md0 -l0 -n3 $dev0 $dev1 $dev2
+mdadm -CR -e 0.90 $md0 -l0 -n3 $dev0 $dev1 $dev2
testdev $md0 3 $mdsize0 512
minor1=`mdadm -E $dev0 | sed -n -e 's/.*Preferred Minor : //p'`
mdadm -S /dev/md0
-mdadm -A $md1 $dev0 $dev1 $dev2
+mdadm -A $md1 $dev0 $dev1 $dev2
minor2=`mdadm -E $dev0 | sed -n -e 's/.*Preferred Minor : //p'`
mdadm -S /dev/md1
-mdadm -A $md1 --update=super-minor $dev0 $dev1 $dev2
+mdadm -A $md1 --update=super-minor $dev0 $dev1 $dev2
minor3=`mdadm -E $dev0 | sed -n -e 's/.*Preferred Minor : //p'`
mdadm -S /dev/md1
# create a raid1 array, let it sync, then re-assemble with a force-sync
-mdadm -CR $md0 -l1 -n2 $dev0 $dev1
+mdadm -CR $md0 -l1 -n2 $dev0 $dev1
check wait
mdadm -S $md0
-mdadm -A $md0 $dev0 $dev1
+mdadm -A $md0 $dev0 $dev1
check nosync
mdadm -S $md0
-mdadm -A $md0 -U resync $dev0 $dev1
+mdadm -A $md0 -U resync $dev0 $dev1
check resync
mdadm -S $md0
-#
+#
# create a raid1 without any bitmap, add the bitmap and then write to
# the device. This should catch the case where the bitmap is created
# but not reloaded correctly, such as the case fixed by
-#
+#
# create a raid1 without any bitmap, add the bitmap and then write to
# the device. This should catch the case where the bitmap is created
# but not reloaded correctly, such as the case fixed by
-#
+#
# create a raid1 with a bitmap file
#
bmf=$targetdir/bitmap
rm -f $bmf
-mdadm --create --run $md0 --level=1 -n2 --delay=1 --bitmap $bmf $dev1 $dev2
+mdadm --create --run $md0 --level=1 -n2 --delay=1 --bitmap $bmf $dev1 $dev2
check wait
testdev $md0 1 $mdsize1a 64
mdadm -S $md0
sleep 4
dirty3=`mdadm -X $bmf | sed -n -e 's/.*Bitmap.* \([0-9]*\) dirty.*/\1/p'`
if [ $dirty3 -lt 400 ]
-then
+then
echo >&2 "ERROR dirty count $dirty3 is too small"
exit 2
fi
#echo $dirty1 $dirty2 $dirty3 $dirty4
if [ $dirty2 -ne 0 -o $dirty4 -ne 0 -o $dirty3 -lt 400 ]
-then
+then
echo bad dirty counts
exit 1
fi
#echo $dirty1 $dirty2 $dirty3 $dirty4
if [ $dirty2 -ne 0 -o $dirty4 -ne 0 -o $dirty3 -lt 400 ]
-then
+then
echo bad dirty counts
exit 1
fi
#echo $dirty1 $dirty2 $dirty3 $dirty4
if [ $dirty2 -ne 0 -o $dirty4 -ne 0 -o $dirty3 -lt 400 ]
-then
+then
echo bad dirty counts
exit 1
fi
-#
+#
# create a raid1 with an internal bitmap
#
-mdadm --create -e0.90 --run $md0 --level=1 -n2 --delay=1 --bitmap internal --bitmap-chunk=4 $dev1 $dev2
+mdadm --create -e0.90 --run $md0 --level=1 -n2 --delay=1 --bitmap internal --bitmap-chunk=4 $dev1 $dev2
check wait
testdev $md0 1 $mdsize0 64
mdadm -S $md0
sleep 4
dirty3=`mdadm -X $dev2 | sed -n -e 's/.*Bitmap.* \([0-9]*\) dirty.*/\1/p'`
if [ $dirty3 -lt 400 ]
-then
+then
echo >&2 "ERROR dirty count $dirty3 is too small"
exit 2
fi
-#
+#
# create a raid1 with an internal bitmap
#
-mdadm --create --run $md0 --metadata=1.0 --level=1 -n2 --delay=1 --bitmap internal --bitmap-chunk=4 $dev1 $dev2
+mdadm --create --run $md0 --metadata=1.0 --level=1 -n2 --delay=1 --bitmap internal --bitmap-chunk=4 $dev1 $dev2
check wait
check bitmap
testdev $md0 1 $mdsize1b 64
sleep 4
dirty3=`mdadm -X $dev2 | sed -n -e 's/.*Bitmap.* \([0-9]*\) dirty.*/\1/p'`
if [ $dirty3 -lt 400 ]
-then
+then
echo >&2 "ERROR dirty count $dirty3 is too small"
exit 2
fi
-#
+#
# create a raid1 with an internal bitmap
#
-mdadm --create --run $md0 --metadata=1.1 --level=1 -n2 --delay=1 --bitmap internal --bitmap-chunk=4 $dev1 $dev2
+mdadm --create --run $md0 --metadata=1.1 --level=1 -n2 --delay=1 --bitmap internal --bitmap-chunk=4 $dev1 $dev2
check wait
check bitmap
testdev $md0 1 $mdsize11 64
sleep 4
dirty3=`mdadm -X $dev2 | sed -n -e 's/.*Bitmap.* \([0-9]*\) dirty.*/\1/p'`
if [ $dirty3 -lt 400 ]
-then
+then
echo >&2 "ERROR dirty count $dirty3 is too small"
exit 2
fi
-#
+#
# create a raid1 with an internal bitmap
#
-mdadm --create --run $md0 --metadata=1.2 --level=1 -n2 --delay=1 --bitmap internal --bitmap-chunk 4 $dev1 $dev2
+mdadm --create --run $md0 --metadata=1.2 --level=1 -n2 --delay=1 --bitmap internal --bitmap-chunk 4 $dev1 $dev2
check wait
check bitmap
testdev $md0 1 $mdsize12 64
sleep 4
dirty3=`mdadm -X $dev2 | sed -n -e 's/.*Bitmap.* \([0-9]*\) dirty.*/\1/p'`
if [ $dirty3 -lt 400 ]
-then
+then
echo >&2 "ERROR dirty count $dirty3 is too small"
exit 2
fi
-#
+#
# create a raid1 with 3 devices and a bitmap file
# make sure resync does right thing.
#
#
bmf=$targetdir/bitmap
rm -f $bmf
-mdadm --create -e0.90 --run $md0 --level=1 -n3 --delay=1 --bitmap $bmf $dev1 $dev2 $dev3
+mdadm --create -e0.90 --run $md0 --level=1 -n3 --delay=1 --bitmap $bmf $dev1 $dev2 $dev3
check wait
testdev $md0 1 $mdsize0 64
mdadm -S $md0
sleep 4
dirty3=`mdadm -X $bmf | sed -n -e 's/.*Bitmap.* \([0-9]*\) dirty.*/\1/p'`
if [ $dirty3 -lt 400 ]
-then
+then
echo >&2 "ERROR dirty count $dirty3 is too small"
exit 2
fi
sleep 0.5
check wait
sleep 1
- for attr in level raid_disks chunk_size layout
+ for attr in level raid_disks chunk_size layout
do
if [ $# -gt 0 ] ; then
val=$1
shift
sleep 0.5
check wait
- for attr in level raid_disks chunk_size layout
+ for attr in level raid_disks chunk_size layout
do
if [ $# -gt 0 ] ; then
val=$1
fi
done
}
-
+
bu=/tmp/md-test-backup
rm -f $bu
# and now assemble fully incrementally.
for i in $dev8 $dev9 $dev10 $dev11 $dev12
-do
+do
mdadm -I $i -c /var/tmp/mdadm.conf
done
check nosync
#[ -f /var/tmp/mdmon.log ] && cat /var/tmp/mdmon.log
-# Now reassemble
+# Now reassemble
# Note that we add the previously missing disks first.
# $dev10 should have a higher seq number than $dev8
for d in $dev8 $dev9 $dev10 $dev11; do
- mdadm -I $d
+ mdadm -I $d
done
mdadm -IRs || true
vol0_level=1
vol0_comp_size=$((5 * 1024))
vol0_chunk=64
-vol0_num_comps=$(( $num_disks - 1 ))
+vol0_num_comps=$(( $num_disks - 1 ))
vol0_offset=0
# After: RAID 0 volume, 1 disks, 64k chunk size
raid5 DONE
raid6/10 needed??
-assemble
+assemble
by devices DONE
by uuid DONE
by superminor DONE
separate file
internal
filename in config file
-
+
examine
--scan
--brief