Create a software RAID 1 with one device

diskmdadmraid

I have a single disk that I want to create a mirror of; let's call this disk sda. I have just bought another identically-sized disk, which we can call sdb. sda and sdb have one partition called sda1 and sdb1 respectively.

When creating a raid, I don't want to wipe my sda clean and start again, I just want it to start mirroring with sdb. My train of thought was to do:

mdadm --create --verbose /dev/md0 --level=mirror --raid-devices=1 /dev/sda1

… to create the array without sdb disk, then run something like (I'm thinking the following command out loud, because I am not sure how to achieve this step)

mdadm /dev/md0 --add /dev/sdb1

_{Note sdb1 is assumed to be formatted similarly to sda1}

Is this possible?

Best Answer

The simple answer to the question in the title is "Yes". But what you really want to do is the next step, which is getting the existing data mirrored.

It's possible to convert the existing disk, but it's risky, as mentioned, due the the metadata location. Much better to create an empty (broken) mirror with the new disk and copy the existing data onto it. Then, if it doesn't work, you just boot back to the un-mirrored original.

First, initialize /dev/sdb1 as the new /dev/md0 with a missing drive and initialize the filesystem (I'm assuming ext3, but the choice is yours)

mdadm --create --verbose /dev/md0 --level=mirror --raid-devices=2 /dev/sdb1 missing
mkfs -text3 /dev/md0

Now, /dev/sda1 is most likely your root file system (/) so for safety you should do the next step from a live CD, rescue disk or other bootable system which can access both /dev/sda1 and /dev/md0 although I have successfully done this by dropping to single user mode.

Copy the entire contents of the filesystem on /dev/sda1 to /dev/md0. For example:

mount /dev/sda1 /mnt/a       # only do this if /dev/sda1 isn't mounted as root
mount /dev/md0 /mnt/b
cd /mnt/a                    # or "cd /" if it's the root filesystem
cp -dpRxv . /mnt/b

Edit /etc/fstab or otherwise ensure that on the next boot, /dev/md0 is mounted instead of /dev/sda1. Your system is probably set to boot from /dev/sda1 and the boot parameters probably specify this as the root device, so when rebooting you should manually change this so that the root is /dev/md0 (assuming /dev/sda1 was root). After reboot, check that/dev/md0 is now mounted (df) and that it is running as a degraded mirror (cat /proc/mdstat). Add /dev/sda1 to the array:

mdadm /dev/md0 --add /dev/sda1

Since the rebuild will overwrite /dev/sda1, which metadata version you use is irrelevant. As always when making major changes, take a full backup (if possible) or at least ensure that anything which can't be recreated is safe.

You will need to regenerate your boot config to use /dev/md0 as root (if /dev/sda1 was root) and probably need to regenerate mdadm.conf to ensure /dev/md0 is always started.

Related Solutions

Create a 2 TB RAID-1 array out of one 2 TB disk and two 1 TB disks while preserving 1 TB of data

As for overwriting each disk with random data, it's redundant. Since you're going to build a new encrypted RAID, the resync will overwrite everything anyway.

As for the method of overwriting, /dev/urandom is horribly slow, people who try to use it for wiping terabytes usually cancel halfway through because it just takes way too long. Encrypting the device with a random key and then wiping that with /dev/zero is faster, and shred -n 1 is much faster still. So if you must have random data on your disk, I recommend you use those methods instead.

Now to your RAID, I'd do the following: (in this example loop2 is the 2TB disk)

Add the new 1TB disk partition to the RAID-1. Wait until the sync is finished. This way, your 1TB of data spans three disks.

$ mdadm /dev/md99 --grow --raid-devices=3 --add /dev/loop1p1
mdadm: added /dev/loop1p1
raid_disks for /dev/md99 set to 3
$ cat /proc/mdstat
md99 : active raid1 loop1p1[2] loop2p1[1] loop0p1[0]
      100224 blocks super 1.2 [3/3] [UUU]

remove the 2TB disk from the RAID-1 array. Your 1TB is still preserved redundantly on the two 1TB disks.

$ mdadm /dev/md99 --fail /dev/loop2p1
mdadm: set /dev/loop2p1 faulty in /dev/md99
$ mdadm /dev/md99 --remove /dev/loop2p1
mdadm: hot removed /dev/loop2p1 from /dev/md99
$ mdadm /dev/md99 --grow --raid-devices=2
raid_disks for /dev/md99 set to 2
$ cat /proc/mdstat
md99 : active raid1 loop1p1[2] loop0p1[0]
      100224 blocks super 1.2 [2/2] [UU]

wipe the 2TB disk
```
$ shred -n 1 /dev/loop2
```
repartition the disk to 2TB. Note that you will need a boot partition if you have no other boot device, as you can not boot from encrypted devices.
```
$ parted /dev/loop2
```

create a new RAID-1 array using that partition, and missing for the 2nd device. The 2nd device will be added later on. Also, the size will be limited for now, to be grown later, as we're not sure of the size of the 2x1TB disks at this point. (If you are sure, feel free to use a different size here, but you won't be able to add the 2x1TB later if you make it too large).

$ mdadm /dev/md42 --create --level=1 --raid-devices=2 --size=1000G /dev/loop2p1 missing
mdadm: largest drive (/dev/loop2p1) exceeds size (102400K) by more than 1%
Continue creating array? yes
mdadm: Defaulting to version 1.2 metadata
mdadm: array /dev/md42 started.
$ cat /proc/mdstat
md42 : active raid1 loop2p1[0]
      102400 blocks super 1.2 [2/1] [U_]

md99 : active raid1 loop1p1[2] loop0p1[0]
      100224 blocks super 1.2 [2/2] [UU]

encrypt it, mkfs, copy data (use your preferred cipher and settings, LVM, filesystem, copy methods, ...)

$ cryptsetup luksFormat /dev/md42
$ cryptsetup luksOpen /dev/md42 luksmd42
$ mkfs.ext4 /dev/mapper/luksmd42
$ mount /dev/md99 /mnt/old
$ mount /dev/md42 /mnt/new
$ rsync -aAHSX /mnt/old/. /mnt/neW/.
$ umount /mnt/old /mnt/new

Now your data is redundant on the old RAID 1 (unencrypted), and the new non-redundant RAID 1 (encrypted). But at this point you have to break redundancy in order to add the 2x1TB disks to the new RAID 1.
```
$ mdadm --stop /dev/md99
mdadm: stopped /dev/md99
```
At this point you could also wipe the 2x1TB disks if you like to waste your time. It's not necessary as the RAID-1 will sync the random data from the 2TB disk over to the 1TB disks.
```
$ shred -n 1 /dev/loop0 &
$ shred -n 1 /dev/loop1 &
$ wait # for shred
$ parted /dev/loop0
$ parted /dev/loop1
```

Combine 2x1TB using mdadm, either linear or 0, depending on your preference.

$ mdadm /dev/md43 --create --level=0 --raid-devices=2 /dev/loop0p1 /dev/loop1p1
$ cat /proc/mdstat
md43 : active raid0 loop1p1[1] loop0p1[0]
      199680 blocks super 1.2 512k chunks

md42 : active raid1 loop2p1[0]
      102400 blocks super 1.2 [2/1] [U_]

Add it to the RAID 1 and grow the RAID 1 at the same time.

 $ mdadm /dev/md42 --add /dev/md43
 mdadm: added /dev/md43
 $ mdadm /dev/md42 --grow --size=max
 mdadm: component size of /dev/md42 has been set to 199616K
 $ cat /proc/mdstat
 md43 : active raid0 loop1p1[1] loop0p1[0]
       199680 blocks super 1.2 512k chunks

 md42 : active raid1 md43[2] loop2p1[0]
       199616 blocks super 1.2 [2/2] [UU]

Grow the cryptsetup and filesystem also.

 $ cryptsetup resize luksmd42
 $ resize2fs /dev/mapper/luksmd42
 resize2fs 1.42.7 (21-Jan-2013)
 Resizing the filesystem on /dev/mapper/luksmd42 to 197568 (1k) blocks.
 The filesystem on /dev/mapper/luksmd42 is now 197568 blocks long.

Aaand you're done.

Edit:

Here's an example /etc/mdadm.conf to go with this setup (use mdadm --detail --scan to get a starting point):

ARRAY /dev/md43 metadata=1.2 UUID=b9f590d7:9984dad4:cb75131b:63bca165
ARRAY /dev/md42 metadata=1.2 UUID=3a70188d:9ecacda7:ac715e16:9402fc55

In particular:

no DEVICE lines (if you must have them, make sure it includes md* devices)
order of ARRAY lines is important - the RAID0 array must be built first, which happens if it's listed first in the file.

Ubuntu – mdadm – RAID5 array size vs. actual disk size mismatch

fdisk is the wrong tool for disks >2TB. Use parted or gdisk instead.

It appears that /dev/sdc1 and /dev/sdd1 are 2TB partitions, so that's what limits your array size. For the other disks, they have GPT so I assume they are 3TB already, but you should check.

Basically you have to stop the array, enlarge each partition to 3TB (without changing the starting offset), then start it again and follow it up with a grow:

mdadm --grow /dev/md0 --size=max

If you can't stop the array, you'll have to fail each 2TB partition individually, repartition and re-add it. This might go faster if you add a write-intent bitmap first.

mdadm --grow /dev/md0 --bitmap=internal

Then for each disk individually,

mdadm /dev/md0 --fail /dev/disk1 # check mdstat for [UUUU] first
mdadm /dev/md0 --remove /dev/disk1
parted /dev/disk -- mklabel gpt mkpart primary 1mib -1mib
mdadm /dev/md0 --re-add /dev/disk1
mdadm --wait /dev/md0 # must wait for sync

Once that's done you can remove the bitmap again (keeping it may harm performance).

mdadm --grow /dev/md0 --bitmap=none
mdadm --grow /dev/md0 --size=max

Finally do your resize2fs or whatever.

Best Answer

Related Solutions

Create a 2 TB RAID-1 array out of one 2 TB disk and two 1 TB disks while preserving 1 TB of data

Ubuntu – mdadm – RAID5 array size vs. actual disk size mismatch

Related Question