HPFE Gen3, flash drives and FlashCore Modules

FCM pools catch new admins out in two ways: someone tries to create a normal (fully allocated) volume, or someone fills the pool with data that won’t compress. You’ll do both.

1Break it: create a standard volume in an FCM pool

An application team asks for a “normal, fully allocated” 100 GiB LUN. Start the shell (the lab setup is still there) and try it without -sam ese.

Run this:

mkfbvol -extpool P0 -cap 100 -name std_vol 2001

You’ll get this error:

CMUN02031E mkfbvol: P0: Only thin provisioned ESE volumes (-sam ese) can be created in an extent pool with FlashCore Module ranks.

Why: FCMs always compress and always store data thin, and you can’t turn that off, so a fully allocated volume would promise physical space the system can’t know about in advance. This wording is a practice shell message; a real DS8000 refuses as well, in its own words.

Fix: create the volume as ESE (thin) and tell the team the host still sees the full 100 GiB.

Run this:

mkfbvol -extpool P0 -cap 100 -sam ese -name std_vol 2001

You should see this:

CMUC00025I mkfbvol: FB volume 2001 successfully created.

If a team does need standard (fully allocated) volumes, put them in a pool built on industry-standard flash, such as array sites S7 and S8.

✅ Checkpoint: Volume 2001 exists as a thin (ESE) volume.

2Break it: fill an FCM pool with data that won’t compress

The shell always compresses at 4.5:1, so this one needs a model. Save it as fcm_space.py on your laptop, in the lab folder next to ds8sim.py; it’s a planning model that runs there and not on the DS8000, and you give it the physical TB of the pool and, for each kind of data, the TB written and its compression ratio.

# fcm_space.py - SaatVedha FlashCore Module physical space check (a teaching model, not an IBM tool)
# A planning tool: it runs on your laptop or jump server, not on the DS8000.
# With --check it starts from a real pool, read through the DS CLI with lsextpool -l
# (auto.profile: banner off, header on, format delim), and adds the data you plan to write.
# FCMs compress every write in hardware. What fills the pool is the PHYSICAL space after compression.
# Usage: python fcm_space.py <physical TB in the pool> <TB written>:<ratio> [<TB written>:<ratio> ...]
#        python fcm_space.py --check <pool ID> [<TiB to write>:<ratio> ...]
#   ratio = how well that data compresses, for example 3 for 3:1, 1 for data that does not compress
import csv, subprocess, sys
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))

THRESHOLD = 85   # % physical capacity; IBM's default alert threshold for the pool
MIB_PER_TIB = 1024 * 1024

if len(sys.argv) < 3:
    print("Usage: python fcm_space.py <physical TB> <TB written>:<ratio> [...]")
    print("       python fcm_space.py --check <pool ID> [<TiB to write>:<ratio> ...]")
    sys.exit(1)

unit, written, used, items = "TB", 0.0, 0.0, sys.argv[2:]
if sys.argv[1] == "--check":
    unit, pid = "TiB", sys.argv[2].upper()
    pool = [p for p in dscli("lsextpool", "-l") if p["ID"] == pid]
    if not pool:
        print(f"Pool {pid} not found. Check the ID with lsextpool.")
        sys.exit(2)
    p = pool[0]
    phys = float(p["totalPhysicalCap(MiB/cyl)"]) / MIB_PER_TIB
    written = float(p["usedLogicalCap(MiB/cyl)"]) / MIB_PER_TIB
    used = float(p["usedPhysicalCap(MiB/cyl)"]) / MIB_PER_TIB
    items = sys.argv[3:]
    print(f"Pool {pid} ({p['Name']}) from lsextpool -l: {phys:.1f} TiB physical")
    if used:
        print(f"  {written:7.1f} TiB in the pool now at {written / used:.1f}:1 -> {used:7.1f} TiB physical")
else:
    phys = float(sys.argv[1])

for item in items:
    tb, ratio = (float(x) for x in item.split(":"))
    written += tb
    used += tb / ratio
    print(f"  {tb:7.1f} {unit} written at {ratio:.1f}:1 -> {tb / ratio:7.1f} {unit} physical")
if not used:
    print(f"Used physical     : 0.0 {unit} of {phys:.1f} {unit}. The pool is empty.")
    sys.exit(0)
pct = 100 * used / phys
print(f"Written (logical) : {written:.1f} {unit}")
print(f"Used physical     : {used:.1f} {unit} of {phys:.1f} {unit} ({pct:.0f} %)")
print(f"Overall ratio     : {written / used:.2f}:1")
if pct >= 100:
    print("Status            : PHYSICAL CAPACITY FULL. New writes to this pool fail.")
elif pct >= THRESHOLD:
    print(f"Status            : ABOVE THRESHOLD ({THRESHOLD} %). Act now: add capacity or move data.")
else:
    print(f"Status            : OK, below the {THRESHOLD} % threshold.")

Say a pool has 100 TB of physical flash and holds 150 TB of databases that compress 3:1.

Run this (PowerShell):

python fcm_space.py 100 150:3

You should see this:

    150.0 TB written at 3.0:1 ->    50.0 TB physical
Written (logical) : 150.0 TB
Used physical     : 50.0 TB of 100.0 TB (50 %)
Overall ratio     : 3.00:1
Status            : OK, below the 85 % threshold.

It’s half full. Now the backup team lands 80 TB of encrypted backups in the same pool, and since encrypted data looks random it compresses at about 1:1.

Run this:

python fcm_space.py 100 150:3 80:1

You’ll get this:

    150.0 TB written at 3.0:1 ->    50.0 TB physical
     80.0 TB written at 1.0:1 ->    80.0 TB physical
Written (logical) : 230.0 TB
Used physical     : 130.0 TB of 100.0 TB (130 %)
Overall ratio     : 1.77:1
Status            : PHYSICAL CAPACITY FULL. New writes to this pool fail.

Why: the hosts were only using 230 TB of logical space and their thin volumes may still show lots left, but the 80 TB of backups took 80 TB of physical flash. The real pool would have crossed the 85% alert after only part of the backup run (try python fcm_space.py 100 150:3 40:1 to see it at 90%) and then hit Pool Physical Capacity Full.

Fix: keep data that’s already encrypted or compressed off FCM pools, or size the pool at 1:1 for that data. Moving the backups to their own pool on industry-standard flash works, and so does adding physical capacity:

Run this:

python fcm_space.py 200 150:3 80:1

You should see this:

    150.0 TB written at 3.0:1 ->    50.0 TB physical
     80.0 TB written at 1.0:1 ->    80.0 TB physical
Written (logical) : 230.0 TB
Used physical     : 130.0 TB of 200.0 TB (65 %)
Overall ratio     : 1.77:1
Status            : OK, below the 85 % threshold.

The model works from numbers you type, and its --check part starts from a real pool instead, reading lsextpool -l through the DS CLI and adding what you plan to write on top. Type quit in the shell if it’s still open.

A script can’t answer password prompts, so save your password in a password file first. If security.dat is already in your lab folder from an earlier lesson, skip this command (the shell would tell you the record already exists).

Run this (PowerShell):

python ds8sim.py -hmc1 10.0.0.1 -user admin -passwd YOURPASSWORD managepwfile -action add -name admin -pw YOURPASSWORD -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. banner: off, header: on and format: delim make every list come back as one header row plus comma-separated rows, which Python reads easily. Implementation Lesson 2 explains 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: ,

Run this (PowerShell):

python fcm_space.py --check P0
python fcm_space.py --check P0 20:1

You should see this:

Pool P0 (fcm_pool) from lsextpool -l: 21.6 TiB physical
      0.5 TiB in the pool now at 4.5:1 ->     0.1 TiB physical
Written (logical) : 0.5 TiB
Used physical     : 0.1 TiB of 21.6 TiB (1 %)
Overall ratio     : 4.47:1
Status            : OK, below the 85 % threshold.
Pool P0 (fcm_pool) from lsextpool -l: 21.6 TiB physical
      0.5 TiB in the pool now at 4.5:1 ->     0.1 TiB physical
     20.0 TiB written at 1.0:1 ->    20.0 TiB physical
Written (logical) : 20.5 TiB
Used physical     : 20.1 TiB of 21.6 TiB (93 %)
Overall ratio     : 1.02:1
Status            : ABOVE THRESHOLD (85 %). Act now: add capacity or move data.

Pool P0 holds the 500 GiB you wrote in the lab, about 0.1 TiB of flash at 4.5:1. Plan 20 TiB of encrypted backups at 1:1 on top of that and the same pool jumps to 93 %, past the alert threshold. The script shows TiB here because the DS CLI reports the pool in MiB.

At work, a scheduler on the jump server runs --check for every FCM pool each morning and mails out the pools that are over the threshold.

✅ Checkpoint: You can explain why the overall ratio fell from 3:1 to 1.77:1 and what that did to the pool, and --check shows pool P0 at 93 % with 20 TiB of backups added.