def env():
"""Verify LNVM variables and construct exported variables"""
if cij.ssh.env():
cij.err("cij.lnvm.env: invalid SSH environment")
return 1
lnvm = cij.env_to_dict(PREFIX, REQUIRED)
nvme = cij.env_to_dict("NVME", ["DEV_NAME"])
if "BGN" not in lnvm.keys():
cij.err("cij.lnvm.env: invalid LNVM_BGN")
return 1
if "END" not in lnvm.keys():
cij.err("cij.lnvm.env: invalid LNVM_END")
return 1
if "DEV_TYPE" not in lnvm.keys():
cij.err("cij.lnvm.env: invalid LNVM_DEV_TYPE")
return 1
lnvm["DEV_NAME"] = "%sb%03de%03d" % (nvme["DEV_NAME"], int(lnvm["BGN"]), int(lnvm["END"]))
lnvm["DEV_PATH"] = "/dev/%s" % lnvm["DEV_NAME"]
cij.env_export(PREFIX, EXPORTED, lnvm)
return 0
def get_meta(offset, length, output):
"""Get chunk meta of NVMe device"""
if env():
cij.err("cij.nvme.meta: Invalid NVMe ENV.")
return 1
nvme = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)
max_size = 0x40000
with open(output, "wb") as fout:
for off in range(offset, length, max_size):
size = min(length - off, max_size)
cmd = [
"nvme get-log", nvme["DEV_PATH"], "-i 0xca",
"-o 0x%x" % off,
"-l 0x%x" % size, "-b"
]
status, stdout, _ = cij.ssh.command(cmd, shell=True)
if status:
cij.err("cij.nvme.meta: Error get chunk meta")
return 1
fout.write(stdout)
return 0
def comp_meta(file_bef, file_aft, mode="pfail"):
"""Compare chunk meta, mode=[pfail, power, reboot]"""
if env():
cij.err("cij.nvme.comp_meta: Invalid NVMe ENV.")
return 1
nvme = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)
num_chk = int(nvme["LNVM_TOTAL_CHUNKS"])
meta_bef = cij.bin.Buffer(types=get_descriptor_table(nvme['SPEC_VERSION']),
length=num_chk)
meta_aft = cij.bin.Buffer(types=get_descriptor_table(nvme['SPEC_VERSION']),
length=num_chk)
meta_bef.read(file_bef)
meta_aft.read(file_aft)
for chk in range(num_chk):
ignore = ["WL", "RSV0"]
# PFAIL: BEFORE IS OPEN CHUNK, WRITE POINTER IS NOT SURE, IGNORE
if mode == "pfail" and meta_bef[chk].CS == 4:
ignore.append("WP")
# COMPARE CHUNK META
if meta_bef.compare(meta_aft, chk, ignore=ignore):
cij.warn("META_BUFF_BEF[%s]:" % chk)
meta_bef.dump(chk)
cij.warn("META_BUFF_AFT[%s]:" % chk)
meta_aft.dump(chk)
cij.err("Error compare, CHUNK: %s" % chk)
return 1
return 0
def recover():
"""Recover LNVM device"""
if env():
cij.err("cij.lnvm.create: Invalid LNVM ENV")
return 1
nvme = cij.env_to_dict("NVME", ["DEV_NAME"])
lnvm = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)
cij.emph("lnvm.recover: LNVM_DEV_NAME: %s" % lnvm["DEV_NAME"])
cmd = ["nvme lnvm create -d %s -n %s -t %s -b %s -e %s" % (
nvme["DEV_NAME"], lnvm["DEV_NAME"], lnvm["DEV_TYPE"], lnvm["BGN"], lnvm["END"])]
rcode, _, _ = cij.ssh.command(cmd, shell=True)
if rcode:
cij.err("cij.lnvm.recover: FAILED")
return 1
return 0
def cmd(command):
"""Send IPMI 'command' via ipmitool"""
env()
ipmi = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)
command = "ipmitool -U %s -P %s -H %s -p %s %s" % (
ipmi["USER"], ipmi["PASS"], ipmi["HOST"], ipmi["PORT"], command)
cij.info("ipmi.command: %s" % command)
return cij.util.execute(command, shell=True, echo=True)
def fmt(lbaf=3):
"""Do format for NVMe device"""
if env():
cij.err("cij.nvme.exists: Invalid NVMe ENV.")
return 1
nvme = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)
cmd = ["nvme", "format", nvme["DEV_PATH"], "-l", str(lbaf)]
rcode, _, _ = cij.ssh.command(cmd, shell=True)
return rcode
def exists():
"""Verify that the ENV defined NVMe device exists"""
if env():
cij.err("cij.nvm.exists: Invalid NVMe ENV.")
return 1
nvm = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)
cmd = ['[[ -b "%s" ]]' % nvm["DEV_PATH"]]
rcode, _, _ = cij.ssh.command(cmd, shell=True, echo=False)
return rcode
def exists():
"""Verify that the ENV defined BLOCK device exists"""
if env():
cij.err("cij.block.exists: invalid BLOCK environment")
return 1
block = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)
cmd = ['[[ -b "%s" ]]' % block["DEV_PATH"]]
rcode, _, _ = cij.ssh.command(cmd, shell=True, echo=False)
return rcode
def env():
"""Verify BLOCK variables and construct exported variables"""
if cij.ssh.env():
cij.err("cij.block.env: invalid SSH environment")
return 1
block = cij.env_to_dict(PREFIX, REQUIRED)
block["DEV_PATH"] = "/dev/%s" % block["DEV_NAME"]
cij.env_export(PREFIX, EXPORTED, block)
return 0
def envs():
"""
Return variables defined by modules required by test
"""
variables = {}
for req in REQS:
prefix = req.upper()
variables[prefix] = cij.env_to_dict(
prefix,
getattr(cij, req).REQUIRED + getattr(cij, req).EXPORTED)
return variables
def exists():
"""Verify that the ENV defined NVMe device exists"""
if env():
cij.err("cij.nvme.exists: Invalid NVMe ENV.")
return 1
nvme = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)
cmd = ["[[", "-b", nvme["DEV_PATH"], "]]"]
rcode, _, _ = cij.ssh.command(cmd, shell=True, echo=False)
if rcode:
return False
return True
def env():
"""Verify IPMI environment"""
ipmi = cij.env_to_dict(PREFIX, REQUIRED)
if ipmi is None:
ipmi["USER"] = "******"
ipmi["PASS"] = "******"
ipmi["HOST"] = "localhost"
ipmi["PORT"] = "623"
cij.info("ipmi.env: USER: %s, PASS: %s, HOST: %s, PORT: %s" %
(ipmi["USER"], ipmi["PASS"], ipmi["HOST"], ipmi["PORT"]))
cij.env_export(PREFIX, EXPORTED, ipmi)
return 0
def env():
"""Verify PCI variables and construct exported variables"""
if cij.ssh.env():
cij.err("cij.pci.env: invalid SSH environment")
return 1
pci = cij.env_to_dict(PREFIX, REQUIRED)
pci["BUS_PATH"] = "/sys/bus/pci"
pci["DEV_PATH"] = os.sep.join(
[pci["BUS_PATH"], "devices", pci["DEV_NAME"]])
cij.env_export(PREFIX, EXPORTED, pci)
return 0
def env():
"""Verify NVME variables and construct exported variables"""
if cij.ssh.env():
cij.err("cij.nvm.env: invalid SSH environment")
return 1
nvm = cij.env_to_dict(PREFIX, REQUIRED)
if "nvme" in nvm["DEV_NAME"]:
nvm["DEV_PATH"] = "/dev/%s" % nvm["DEV_NAME"]
else:
nvm["DEV_PATH"] = "traddr:%s" % nvm["DEV_NAME"]
cij.env_export(PREFIX, EXPORTED, nvm)
return 0
def remove():
"""Remove LNVM device"""
if env():
cij.err("cij.lnvm.create: Invalid LNVM ENV")
return 1
lnvm = cij.env_to_dict(PREFIX, EXPORTED + REQUIRED)
cij.emph("lnvm.remove: LNVM_DEV_NAME: %s" % lnvm["DEV_NAME"])
cmd = ["nvme lnvm remove -n %s" % (lnvm["DEV_NAME"])]
rcode, _, _ = cij.ssh.command(cmd, shell=True)
if rcode:
cij.err("cij.lnvm.remove: FAILED")
return 1
return 0
def env():
"""Verify BOARD variables and construct exported variables"""
if cij.ssh.env():
cij.err("board.env: invalid SSH environment")
return 1
board = cij.env_to_dict(PREFIX, REQUIRED) # Verify REQUIRED variables
if board is None:
cij.err("board.env: invalid BOARD environment")
return 1
board["CLASS"] = "_".join([board[r] for r in REQUIRED[:-1]])
board["IDENT"] = "-".join([board["CLASS"], board["ALIAS"]])
cij.env_export(PREFIX, EXPORTED, board) # Export EXPORTED variables
return 0
def __init__(self):
if cij.ssh.env():
raise RuntimeError("cij.liblight: invalid SSH environment")
cij.nvme.env()
nvme = cij.env_to_dict("NVME", ["DEV_NAME", "SPEC_VERSION"])
self.envs = dict()
self.envs["DEV_PATH"] = os.path.join("/dev", nvme["DEV_NAME"])
self.envs["CHUNK_META_STRUCT"] = get_descriptor_table(
nvme["SPEC_VERSION"])
self.envs["CHUNK_META_SIZEOF"] = get_sizeof_descriptor_table(
nvme["SPEC_VERSION"])
cmd = ["nvme", "lnvm", "id-ns", self.envs["DEV_PATH"], "--raw-binary"]
status, stdout, _ = cij.ssh.command(cmd, shell=True)
if status:
raise RuntimeError("cij.liblight: lnvm id-ns fail")
buff = cij.bin.Buffer(types=Geometry, length=1)
buff.memcopy(stdout)
geometry = buff[0]
self.envs["MJR"] = geometry.MJR
self.envs["NUM_GRP"] = geometry.NUM_GRP
self.envs["NUM_PU"] = geometry.NUM_PU
self.envs["NUM_CHK"] = geometry.NUM_CHK
self.envs["CLBA"] = geometry.CLBA
self.envs[
"CHUNKS"] = geometry.NUM_GRP * geometry.NUM_PU * geometry.NUM_CHK
cmd = ["nvme", "id-ns", self.envs["DEV_PATH"], "--raw-binary"]
status, stdout, _ = cij.ssh.command(cmd, shell=True)
if status:
raise RuntimeError("cij.liblight: nvme id-ns fail")
buff = cij.bin.Buffer(types=IdentifyNDS, length=1)
buff.memcopy(stdout)
identify = buff[0]
self.envs["NBYTES"] = 2**identify.LBAF[identify.FLBAS].LBADS
self.envs["NBYTES_OOB"] = identify.LBAF[identify.FLBAS].MS
self.envs["FLBAS"] = identify.FLBAS
def env():
"""Verify SSH variables and construct exported variables"""
ssh = cij.env_to_dict(PREFIX, REQUIRED)
if "KEY" in ssh:
ssh["KEY"] = cij.util.expand_path(ssh["KEY"])
if cij.ENV.get("SSH_PORT") is None:
cij.ENV["SSH_PORT"] = "22"
cij.warn("cij.ssh.env: SSH_PORT was not set, assigned: %r" % (
cij.ENV.get("SSH_PORT")
))
if cij.ENV.get("SSH_CMD_TIME") is None:
cij.ENV["SSH_CMD_TIME"] = "1"
cij.warn("cij.ssh.env: SSH_CMD_TIME was not set, assigned: %r" % (
cij.ENV.get("SSH_CMD_TIME")
))
return 0
def env():
"""Verify NVME variables and construct exported variables"""
if cij.ssh.env():
cij.err("cij.nvme.env: invalid SSH environment")
return 1
nvme = cij.env_to_dict(PREFIX, REQUIRED)
nvme["DEV_PATH"] = os.path.join("/dev", nvme["DEV_NAME"])
# get version, chunks, luns and chs
try:
sysfs = os.path.join("/sys/class/block", nvme["DEV_NAME"], "lightnvm")
nvme["LNVM_VERSION"] = cat_file(os.path.join(sysfs, "version"))
if nvme["LNVM_VERSION"] == "2.0":
luns = "punits"
chs = "groups"
elif nvme["LNVM_VERSION"] == "1.2":
luns = "num_luns"
chs = "num_channels"
else:
raise RuntimeError("cij.nvme.env: invalid lnvm version: %s" %
nvme["LNVM_VERSION"])
nvme["LNVM_NUM_CHUNKS"] = cat_file(os.path.join(sysfs, "chunks"))
nvme["LNVM_NUM_LUNS"] = cat_file(os.path.join(sysfs, luns))
nvme["LNVM_NUM_CHS"] = cat_file(os.path.join(sysfs, chs))
nvme["LNVM_TOTAL_LUNS"] = str(
int(nvme["LNVM_NUM_LUNS"]) * int(nvme["LNVM_NUM_CHS"]))
nvme["LNVM_TOTAL_CHUNKS"] = str(
int(nvme["LNVM_TOTAL_LUNS"]) * int(nvme["LNVM_NUM_CHUNKS"]))
# get spec version by identify namespace data struct
if nvme["LNVM_VERSION"] == "2.0":
cmd = ["nvme", "id-ctrl", nvme["DEV_PATH"], "--raw-binary"]
status, stdout, _ = cij.ssh.command(cmd, shell=True)
if status:
raise RuntimeError("cij.nvme.env: nvme id-ctrl fail")
buff = cij.bin.Buffer(types=IdentifyCDS, length=1)
buff.memcopy(stdout)
if buff[0].VS[1023] == 0x5a:
nvme["SPEC_VERSION"] = "Denali"
else:
nvme["SPEC_VERSION"] = "Spec20"
else:
nvme["SPEC_VERSION"] = "Spec12"
# get chunk meta information
nvme["LNVM_CHUNK_META_LENGTH"] = str(
get_sizeof_descriptor_table(nvme["SPEC_VERSION"]))
nvme["LNVM_CHUNK_META_SIZE"] = str(
int(nvme["LNVM_CHUNK_META_LENGTH"]) *
int(nvme["LNVM_TOTAL_CHUNKS"]))
except StandardError:
traceback.print_exc()
return 1
cij.env_export(PREFIX, EXPORTED, nvme)
return 0