Array sites, arrays and RAID 6 / RAID 10

In the lab you’ll build all four array shapes, check the capacity maths and watch a rebuild. Open PowerShell in C:\ds8k-lab and start the practice shell with python ds8sim.py, and if this is all new, set it up first using Lesson 1.

Practice shell note: the practice shell is our own teaching tool, not IBM software. Real DS CLI output looks very close to this but isn’t identical. Messages starting with SIM, and the CMUN02014E message in the break lab, come from the practice shell, while the RAID 5 warning and error are the ones IBM shows in its Redbook.

1Start clean and read the array sites

Type these at the dscli> prompt:

simctl reset
lsarraysite -l

You should see this:

dscli> simctl reset
SIM0100I simctl: factory state restored (users and passwords kept; use simctl reset -all to reset them too).
dscli> lsarraysite -l
Date/Time: 24 October 2026 10:50:21 UTC IBM DSCLI Version: 7.10.10.348 DS: IBM.2107-78SV001
arsite DA Pair dkcap (10^9B) diskrpm State      Array diskclass       encrypt
===============================================================================
S1     0       4800.0        65000   Unassigned -     FlashCoreModule supported
S2     0       4800.0        65000   Unassigned -     FlashCoreModule supported
S3     0       4800.0        65000   Unassigned -     FlashCoreModule supported
S4     0       4800.0        65000   Unassigned -     FlashCoreModule supported
S5     2       4800.0        65000   Unassigned -     FlashCoreModule supported
S6     2       4800.0        65000   Unassigned -     FlashCoreModule supported
S7     2       3840.0        65000   Unassigned -     FlashTier2      supported
S8     2       3840.0        65000   Unassigned -     FlashTier2      supported

DA pair 0 has four sites of 4.8 TB FlashCore Modules (S1 to S4). DA pair 2 has two more FCM sites (S5, S6) plus two sites of 3.84 TB FlashTier2 drives (S7, S8), and because the spare rules work per DA pair and per drive size, DA pair 2 needs spares for both sizes.

✅ Checkpoint: You can say which DA pair and drive class each site has.

2Build all four array shapes

You’ll use two RAID 6 and two RAID 10 commands, and you’ll see the same -raidtype produce different shapes.

Type these at the dscli> prompt:

mkarray -raidtype 6 -arsite S1
mkarray -raidtype 6 -arsite S3
mkarray -raidtype 10 -arsite S7
mkarray -raidtype 10 -arsite S4
lsarray -l

You should see this:

dscli> mkarray -raidtype 6 -arsite S1
CMUC00004I mkarray: Array A0 successfully created.
dscli> mkarray -raidtype 6 -arsite S3
CMUC00004I mkarray: Array A1 successfully created.
dscli> mkarray -raidtype 10 -arsite S7
CMUC00004I mkarray: Array A2 successfully created.
dscli> mkarray -raidtype 10 -arsite S4
CMUC00004I mkarray: Array A3 successfully created.
dscli> lsarray -l
Date/Time: 24 October 2026 10:50:21 UTC IBM DSCLI Version: 7.10.10.348 DS: IBM.2107-78SV001
Array State      Data   RAIDtype    arsite Rank DA Pair DDMcap (10^9B) diskclass       encrypt
================================================================================================
A0    Unassigned Normal 6 (5+P+Q+S) S1     -    0       4800.0         FlashCoreModule supported
A1    Unassigned Normal 6 (6+P+Q)   S3     -    0       4800.0         FlashCoreModule supported
A2    Unassigned Normal 10 (3x2+2S) S7     -    2       3840.0         FlashTier2      supported
A3    Unassigned Normal 10 (4x2)    S4     -    0       4800.0         FlashCoreModule supported

Look at the RAIDtype column. A0 on S1 kept a spare (5+P+Q+S), but A1 on S3 didn’t need one (6+P+Q).

A2 on S7 is RAID 10 with two spares, shown as 3x2+2S, which means three drives mirrored to three plus two spares, and A3 on S4 is a full 4x2 mirror with no spare.

In this lab system S1, S2 and the DA pair 2 sites are marked to keep spares, so the arrays on them hold some drives back. On a real DS8000 the system works this out from the order you build the arrays in and the spares that already exist.

Data Normal tells you every member drive is healthy, and State Unassigned tells you no rank is using the array yet.

✅ Checkpoint: lsarray -l shows all four shapes: 5+P+Q+S, 6+P+Q, 3×2+2S and 4×2.

3Work out the usable capacity with a script

Next, let a script read the four arrays you’ve built and work out their usable space. It asks the DS CLI for lsarray -l, picks up each RAIDtype and drive size, and does the sums.

Save it on your laptop as C:\ds8k-lab\raid_calc.py, next to ds8sim.py. It runs on the laptop, not on the DS8000.

A script can’t answer password prompts, so you need to save your password in a password file first. If security.dat and auto.profile are already in your lab folder from an earlier lesson, skip this part (the shell would only tell you the record already exists).

Run this (PowerShell, with your own password both times):

python ds8sim.py -hmc1 10.0.0.1 -user admin -passwd YourPassw0rd managepwfile -action add -name admin -pw YourPassw0rd -pwfile security.dat

You should see this:

CMUC00206I managepwfile: Record 10.0.0.1/admin successfully added to password file security.dat.

Then save these eight lines as auto.profile in the same folder. With banner: off, header: on and format: delim, every list comes back as one header row followed by comma-separated rows, which Python reads easily. Implementation Lesson 2 covers profiles in full.

auto.profile:

hmc1: 10.0.0.1
username: admin
pwfile: security.dat
devid: IBM.2107-78SV001
banner: off
header: on
format: delim
delim: ,

The script:

# raid_calc.py - usable capacity of every array on the DS8000, before formatting
# Runs on your workstation or jump server, not on the DS8000.
# It talks to the DS8000 only through the DS CLI (auto.profile: banner off, header on, format delim).
import csv, re, subprocess
DSCLI = ["python", "ds8sim.py", "-cfg", "auto.profile"]   # at work: ["dscli", "-cfg", "auto.profile"]

def dscli(*args):
    """Run one DS CLI command and return its rows as dictionaries."""
    out = subprocess.run(DSCLI + list(args), capture_output=True, text=True).stdout
    lines = [l for l in out.splitlines() if l and not l.startswith("SaatVedha") and not l.startswith("CMUC")]
    return list(csv.DictReader(lines))

TB, TiB = 10**12, 2**40
DRIVES = 8                                 # one DS8A00 array site = 8 drives
write_ios = {"6": 6, "10": 2}              # back-end I/Os per random host write (theory)

def shape(raidtype):
    """'6 (5+P+Q+S)' -> ('6', data 5, protect 2, spare 1); '10 (3x2+2S)' -> ('10', 3, 3, 2)"""
    level = raidtype.split()[0]
    data = int(re.search(r"\((\d+)", raidtype).group(1))
    s = re.search(r"\+(\d*)S\)", raidtype)
    spare = (int(s.group(1) or 1)) if s else 0
    return level, data, DRIVES - data - spare, spare

print(f"{'Array':<6}{'Site':<5}{'RAIDtype':<14}{'drive':>8}  data prot spare {'usable':>17}  of raw")
total = 0
for a in dscli("lsarray", "-l"):
    level, data, prot, spare = shape(a["RAIDtype"])
    drive_tb = float(a["DDMcap (10^9B)"]) / 1000
    usable = data * drive_tb * TB          # usable = data drives x drive size
    print(f"{a['Array']:<6}{a['arsite']:<5}{a['RAIDtype']:<14}{drive_tb:>5.2f} TB  {data:>4} {prot:>4} {spare:>5}"
          f" {usable/TB:>7.2f} TB {usable/TiB:>6.2f} TiB  {100*data/DRIVES:.1f}%")
    total += usable
print(f"Total usable before formatting: {total/TB:.2f} TB")
print()
for level, ios in write_ios.items():
    print(f"1,000 random host writes on RAID {level:<3} -> about {1000*ios:,} back-end I/Os")

Run this in a second PowerShell window in C:\ds8k-lab:

python raid_calc.py

You should see this:

Array Site RAIDtype         drive  data prot spare            usable  of raw
A0    S1   6 (5+P+Q+S)    4.80 TB     5    2     1   24.00 TB  21.83 TiB  62.5%
A1    S3   6 (6+P+Q)      4.80 TB     6    2     0   28.80 TB  26.19 TiB  75.0%
A2    S7   10 (3x2+2S)    3.84 TB     3    3     2   11.52 TB  10.48 TiB  37.5%
A3    S4   10 (4x2)       4.80 TB     4    4     0   19.20 TB  17.46 TiB  50.0%
Total usable before formatting: 83.52 TB

1,000 random host writes on RAID 6   -> about 6,000 back-end I/Os
1,000 random host writes on RAID 10  -> about 2,000 back-end I/Os

You can see the pattern straight away: A1, a 6+P+Q array, gives 75% of raw, and A3, a 4×2 RAID 10 array, gives 50%. On the same 8 drives of 4.8 TB, RAID 6 gives you 1.5 times the space of RAID 10, 28.80 TB against 19.20 TB.

Spares eat space too: A0 keeps one and drops to 62.5%, and A2 keeps two and drops to 37.5%.

The last two lines show the other side of the deal, where RAID 6 does about three times the back-end work for random writes. In practice the DS8000 cache soaks up a lot of that, so read these as theory rather than a promise.

These numbers also come before rank formatting and metadata, which you’ll meet in Lesson 11. At work you’d run the same script from the jump server with dscli once the arrays are built, and compare its total with the capacity the project paid for.

✅ Checkpoint: Your script shows 75.0% for A1 (6+P+Q) and 50.0% for A3 (4×2).

4Fail a drive and watch the rebuild

simctl drivefail is a practice shell command that fails one drive in a site, and simctl tick moves the shell’s clock forward 10 minutes.

Type these at the dscli> prompt:

simctl drivefail S3
lsarray
simctl tick
lsarray

You should see this:

dscli> simctl drivefail S3
SIM0110I simctl: drive IBM.2107-D04-8SV01/R1-P1-D17 failed. Array A1 is rebuilding onto a spare (about 10 simulated minutes; use simctl tick).
dscli> lsarray
Date/Time: 24 October 2026 10:50:21 UTC IBM DSCLI Version: 7.10.10.348 DS: IBM.2107-78SV001
Array State      Data       RAIDtype    arsite Rank DA Pair DDMcap (10^9B)
==========================================================================
A0    Unassigned Normal     6 (5+P+Q+S) S1     -    0       4800.0
A1    Unassigned Rebuilding 6 (6+P+Q)   S3     -    0       4800.0
A2    Unassigned Normal     10 (3x2+2S) S7     -    2       3840.0
A3    Unassigned Normal     10 (4x2)    S4     -    0       4800.0
dscli> simctl tick
SIM0111I simctl: array A1 rebuild complete; the failed drive was replaced and is now the spare.
SIM0112I simctl: clock advanced 10 minutes.
dscli> lsarray
Date/Time: 24 October 2026 11:00:22 UTC IBM DSCLI Version: 7.10.10.348 DS: IBM.2107-78SV001
Array State      Data   RAIDtype    arsite Rank DA Pair DDMcap (10^9B)
======================================================================
A0    Unassigned Normal 6 (5+P+Q+S) S1     -    0       4800.0
A1    Unassigned Normal 6 (6+P+Q)   S3     -    0       4800.0
A2    Unassigned Normal 10 (3x2+2S) S7     -    2       3840.0
A3    Unassigned Normal 10 (4x2)    S4     -    0       4800.0

A1 had no spare of its own, and yet it rebuilt, because it borrowed a global spare from the DA pair the way the Redbook describes. While Data showed Rebuilding, A1 kept serving I/O, and being RAID 6 it could have taken one more failure.

The shell’s 10 minutes is only for practice. On a real system the rebuild time depends on the drive size, how full the array is and how busy it is.

✅ Checkpoint: A1 goes from Rebuilding back to Normal.

Type quit when you’re done.