class OpTestHeartbeat():
## Initialize this object
# @param i_bmcIP The IP address of the BMC
# @param i_bmcUser The userid to log into the BMC with
# @param i_bmcPasswd The password of the userid to log into the BMC with
# @param i_bmcUserIpmi The userid to issue the BMC IPMI commands with
# @param i_bmcPasswdIpmi The password of BMC IPMI userid
# @param i_ffdcDir Optional param to indicate where to write FFDC
#
# "Only required for inband tests" else Default = None
# @param i_lparIP The IP address of the LPAR
# @param i_lparuser The userid to log into the LPAR
# @param i_lparPasswd The password of the userid to log into the LPAR with
#
def __init__(self, i_bmcIP, i_bmcUser, i_bmcPasswd,
i_bmcUserIpmi, i_bmcPasswdIpmi, i_ffdcDir=None, i_lparip=None,
i_lparuser=None, i_lparPasswd=None):
self.cv_BMC = OpTestBMC(i_bmcIP, i_bmcUser, i_bmcPasswd, i_ffdcDir)
self.cv_IPMI = OpTestIPMI(i_bmcIP, i_bmcUserIpmi, i_bmcPasswdIpmi,
i_ffdcDir)
self.cv_LPAR = OpTestLpar(i_lparip, i_lparuser, i_lparPasswd, i_bmcIP)
self.util = OpTestUtil()
##
# @brief This function will cover following test steps
# 1. It will check for os level and get kernel version
# 2. It will check for existence of ps command
# 3. It will check for kopald service is running
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def test_kopald_service(self):
# Get OS level
l_oslevel = self.cv_LPAR.lpar_get_OS_Level()
# Get kernel version
l_kernel = self.cv_LPAR.lpar_get_kernel_version()
# Checking for ps command
self.cv_LPAR.lpar_check_command("ps")
l_cmd = "ps -ef | grep -i kopald"
print l_cmd
l_res = self.cv_LPAR.lpar_run_command(l_cmd)
print l_res
if (l_res.__contains__('[kopald]')):
return BMC_CONST.FW_SUCCESS
else:
l_msg = "kopald service is not running"
print l_msg
raise OpTestError(l_msg)
class OpTestHMIHandling:
## Initialize this object
# @param i_bmcIP The IP address of the BMC
# @param i_bmcUser The userid to log into the BMC with
# @param i_bmcPasswd The password of the userid to log into the BMC with
# @param i_bmcUserIpmi The userid to issue the BMC IPMI commands with
# @param i_bmcPasswdIpmi The password of BMC IPMI userid
# @param i_ffdcDir Optional param to indicate where to write FFDC
#
# "Only required for inband tests" else Default = None
# @param i_lparIP The IP address of the LPAR
# @param i_lparuser The userid to log into the LPAR
# @param i_lparPasswd The password of the userid to log into the LPAR with
#
def __init__(
self,
i_bmcIP,
i_bmcUser,
i_bmcPasswd,
i_bmcUserIpmi,
i_bmcPasswdIpmi,
i_ffdcDir=None,
i_lparip=None,
i_lparuser=None,
i_lparPasswd=None,
):
self.cv_BMC = OpTestBMC(i_bmcIP, i_bmcUser, i_bmcPasswd, i_ffdcDir)
self.cv_IPMI = OpTestIPMI(
i_bmcIP, i_bmcUserIpmi, i_bmcPasswdIpmi, i_ffdcDir, i_lparip, i_lparuser, i_lparPasswd
)
self.cv_LPAR = OpTestLpar(i_lparip, i_lparuser, i_lparPasswd, i_bmcIP)
self.cv_SYSTEM = OpTestSystem(
i_bmcIP,
i_bmcUser,
i_bmcPasswd,
i_bmcUserIpmi,
i_bmcPasswdIpmi,
i_ffdcDir,
i_lparip,
i_lparuser,
i_lparPasswd,
)
self.util = OpTestUtil()
##
# @brief This is a common function for all the hmi test cases. This will be executed before
# any test case starts. Basically this provides below requirements.
# 1. Validates all required lpar commands
# 2. It will clone skiboot source repository
# 3. Compile the necessary tools xscom-utils and gard utility to test HMI.
# 4. Get the list Of Chips and cores in the form of dictionary.
# Ex: [['00000000', ['4', '5', '6', 'c', 'd', 'e']], ['00000001', ['4', '5', '6', 'c', 'd', 'e']], ['00000010', ['4', '5', '6', 'c', 'd', 'e']]]
# 5. In-order to inject HMI errors on cpu's, cpu should be running,
# so disabling the sleep states 1 and 2 of all CPU's.
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def test_init(self):
# Get OS level
self.cv_LPAR.lpar_get_OS_Level()
# Check whether git and gcc commands are available on lpar
self.cv_LPAR.lpar_check_command("git")
self.cv_LPAR.lpar_check_command("gcc")
# It will clone skiboot source repository
l_dir = "/tmp/skiboot"
self.cv_LPAR.lpar_clone_skiboot_source(l_dir)
# Compile the necessary tools xscom-utils and gard utility
self.cv_LPAR.lpar_compile_xscom_utilities(l_dir)
self.cv_LPAR.lpar_compile_gard_utility(l_dir)
# Getting list of processor chip Id's(executing getscom -l to get chip id's)
l_res = self.cv_LPAR.lpar_run_command("cd %s/external/xscom-utils/; ./getscom -l" % l_dir)
l_res = l_res.splitlines()
l_chips = []
for line in l_res:
matchObj = re.search("(\d{8}).*processor", line)
if matchObj:
l_chips.append(matchObj.group(1))
if not l_chips:
l_msg = "Getscom failed to list processor chip id's"
raise OpTestError(l_msg)
l_chips.sort()
print l_chips # ['00000000', '00000001', '00000010']
# Currently getting the list of active core id's with respect to each chip is by using opal msg log
# TODO: Need to identify best way to get list of cores(If Opal msg log is empty)
l_cmd = "cat /sys/firmware/opal/msglog | grep -i CHIP"
l_res = self.cv_LPAR.lpar_run_command(l_cmd)
l_cores = {}
self.l_dic = []
l_res = l_res.splitlines()
for line in l_res:
matchObj = re.search("Chip (\d{1,2}) Core ([a-z0-9])", line)
if matchObj:
if l_cores.has_key(int(matchObj.group(1))):
(l_cores[int(matchObj.group(1))]).append(matchObj.group(2))
else:
l_cores[int(matchObj.group(1))] = list(matchObj.group(2))
if not l_cores:
l_msg = "Failed in getting core id's information from OPAL msg log"
raise OpTestError(l_msg)
print l_cores # {0: ['4', '5', '6', 'c', 'd', 'e'], 1: ['4', '5', '6', 'c', 'd', 'e'], 10: ['4', '5', '6', 'c', 'd', 'e']}
l_cores = sorted(l_cores.iteritems())
print l_cores
i = 0
for tup in l_cores:
new_list = [l_chips[i], tup[1]]
self.l_dic.append(new_list)
i += 1
print self.l_dic
# self.l_dic is a list of chip id's, core id's . and is of below format
# [['00000000', ['4', '5', '6', 'c', 'd', 'e']], ['00000001', ['4', '5', '6', 'c', 'd', 'e']], ['00000010', ['4', '5', '6', 'c', 'd', 'e']]]
self.l_dir = l_dir
# In-order to inject HMI errors on cpu's, cpu should be running, so disabling the sleep states 1 and 2 of all CPU's
self.cv_LPAR.lpar_run_command(BMC_CONST.GET_CPU_SLEEP_STATE2)
self.cv_LPAR.lpar_run_command(BMC_CONST.GET_CPU_SLEEP_STATE1)
self.cv_LPAR.lpar_run_command(BMC_CONST.GET_CPU_SLEEP_STATE0)
self.cv_LPAR.lpar_run_command(BMC_CONST.DISABLE_CPU_SLEEP_STATE1)
self.cv_LPAR.lpar_run_command(BMC_CONST.DISABLE_CPU_SLEEP_STATE2)
self.cv_LPAR.lpar_run_command(BMC_CONST.GET_CPU_SLEEP_STATE2)
self.cv_LPAR.lpar_run_command(BMC_CONST.GET_CPU_SLEEP_STATE1)
self.cv_LPAR.lpar_run_command(BMC_CONST.GET_CPU_SLEEP_STATE0)
##
# @brief This function is mainly used to clear hardware gard entries.
# It will perform below steps
# 1. Reboot the system(Power off/on)
# 2. Clear any Hardware gard entries
# 3. Again reboot the system, to make use of garded Hardware.
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def clearGardEntries(self):
# Power off and on the system.
self.cv_IPMI.ipmi_power_off()
self.cv_IPMI.ipmi_power_on()
if int(self.cv_SYSTEM.sys_ipl_wait_for_working_state()):
l_msg = "System failed to boot host OS"
raise OpTestError(l_msg)
time.sleep(BMC_CONST.LPAR_BRINGUP_TIME)
# Clearing gard entries after lpar comes up
self.cv_LPAR.lpar_get_OS_Level()
l_con = self.cv_SYSTEM.sys_get_ipmi_console()
self.cv_IPMI.ipmi_lpar_login(l_con)
self.cv_IPMI.ipmi_lpar_set_unique_prompt(l_con)
self.cv_IPMI.run_lpar_cmd_on_ipmi_console("uname -a")
l_dir = "/tmp/skiboot"
self.cv_IPMI.run_lpar_cmd_on_ipmi_console("cd %s/external/gard/;" % l_dir)
l_cmd = "./gard list; echo $?"
self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
l_cmd = "./gard clear all; echo $?"
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
if int(l_res[-1]):
l_msg = "Clearing gard entries through gard tool is failed"
raise OpTestError(l_msg)
l_cmd = "./gard list; echo $?"
self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
# Rebooting the system again to make use of garded hardware
self.cv_IPMI.ipmi_power_off()
self.cv_IPMI.ipmi_power_on()
if int(self.cv_SYSTEM.sys_ipl_wait_for_working_state()):
l_msg = "System failed to boot host OS"
raise OpTestError(l_msg)
time.sleep(BMC_CONST.LPAR_BRINGUP_TIME)
self.cv_LPAR.lpar_get_OS_Level()
self.cv_SYSTEM.sys_ipmi_close_console(l_con)
##
# @brief This function executes HMI test case based on the i_test value, Before test starts
# disabling kdump service to make sure system reboots, after injecting non-recoverable errors.
#
# @param i_test @type int: this is the type of test case want to execute
# BMC_CONST.HMI_PROC_RECV_DONE: Processor recovery done
# BMC_CONST.HMI_PROC_RECV_ERROR_MASKED: proc_recv_error_masked
# BMC_CONST.HMI_MALFUNCTION_ALERT: malfunction_alert
# BMC_CONST.HMI_HYPERVISOR_RESOURCE_ERROR: hypervisor resource error
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def testHMIHandling(self, i_test):
l_test = i_test
self.test_init()
l_con = self.cv_SYSTEM.sys_get_ipmi_console()
self.cv_IPMI.ipmi_lpar_login(l_con)
self.cv_IPMI.ipmi_lpar_set_unique_prompt(l_con)
self.cv_IPMI.run_lpar_cmd_on_ipmi_console("uname -a")
self.cv_IPMI.run_lpar_cmd_on_ipmi_console("cat /etc/os-release")
self.cv_IPMI.run_lpar_cmd_on_ipmi_console("service kdump status")
self.cv_IPMI.run_lpar_cmd_on_ipmi_console("service kdump stop")
self.cv_IPMI.run_lpar_cmd_on_ipmi_console("service kdump status")
self.cv_IPMI.run_lpar_cmd_on_ipmi_console("cd %s/external/xscom-utils/;" % self.l_dir)
self.cv_IPMI.run_lpar_cmd_on_ipmi_console("lscpu")
self.cv_IPMI.run_lpar_cmd_on_ipmi_console("dmesg -D")
if l_test == BMC_CONST.HMI_PROC_RECV_DONE:
self.test_proc_recv_done()
elif l_test == BMC_CONST.HMI_PROC_RECV_ERROR_MASKED:
self.test_proc_recv_error_masked()
elif l_test == BMC_CONST.HMI_MALFUNCTION_ALERT:
self.test_malfunction_allert()
elif l_test == BMC_CONST.HMI_HYPERVISOR_RESOURCE_ERROR:
self.test_hyp_resource_err()
else:
l_msg = "Please provide valid test case"
raise OpTestError(l_msg)
self.cv_SYSTEM.sys_ipmi_close_console(l_con)
return BMC_CONST.FW_SUCCESS
##
# @brief This function is used to test HMI: processor recovery done
# and also this function injecting error on all the cpus one by one and
# verify whether cpu is recovered or not.
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def test_proc_recv_done(self):
for l_pair in self.l_dic:
l_chip = l_pair[0]
for l_core in l_pair[1]:
l_reg = "1%s013100" % l_core
l_cmd = "./putscom -c %s %s 0000000000100000; echo $?" % (l_chip, l_reg)
self.cv_IPMI.run_lpar_cmd_on_ipmi_console("dmesg -C")
time.sleep(10)
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
time.sleep(10)
if l_res[-1] == "0":
print "Injected thread hang recoverable error"
else:
if any("Kernel panic - not syncing" in line for line in l_res):
l_msg = "Processor recovery failed: Kernel got panic"
elif any("Petitboot" in line for line in l_res):
l_msg = "System reached petitboot:Processor recovery failed"
elif any("ISTEP" in line for line in l_res):
l_msg = "System started booting: Processor recovery failed"
else:
l_msg = "Failed to inject thread hang recoverable error"
print l_msg
raise OpTestError(l_msg)
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console("dmesg")
if any("Processor Recovery done" in line for line in l_res) and any(
"Harmless Hypervisor Maintenance interrupt [Recovered]" in line for line in l_res
):
print "Processor recovery done"
else:
l_msg = "HMI handling failed to log message: for proc_recv_done"
raise OpTestError(l_msg)
time.sleep(BMC_CONST.HMI_TEST_CASE_SLEEP_TIME)
return BMC_CONST.FW_SUCCESS
##
# @brief This function is used to test HMI: proc_recv_error_masked
# Processor went through recovery for an error which is actually masked for reporting
# this function also injecting the error on all the cpu's one-by-one.
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def test_proc_recv_error_masked(self):
for l_pair in self.l_dic:
l_chip = l_pair[0]
for l_core in l_pair[1]:
l_reg = "1%s013100" % l_core
l_cmd = "./putscom -c %s %s 0000000000080000; echo $?" % (l_chip, l_reg)
self.cv_IPMI.run_lpar_cmd_on_ipmi_console("dmesg -C")
time.sleep(10)
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
time.sleep(10)
if l_res[-1] == "0":
print "Injected thread hang recoverable error"
else:
if any("Kernel panic - not syncing" in line for line in l_res):
l_msg = "Processor recovery failed: Kernel got panic"
elif any("Petitboot" in line for line in l_res):
l_msg = "System reached petitboot:Processor recovery failed"
elif any("ISTEP" in line for line in l_res):
l_msg = "System started booting: Processor recovery failed"
else:
l_msg = "Failed to inject thread hang recoverable error"
print l_msg
raise OpTestError(l_msg)
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console("dmesg")
if any("Processor Recovery done" in line for line in l_res) and any(
"Harmless Hypervisor Maintenance interrupt [Recovered]" in line for line in l_res
):
print "Processor recovery done"
else:
l_msg = "HMI handling failed to log message"
raise OpTestError(l_msg)
time.sleep(BMC_CONST.HMI_TEST_CASE_SLEEP_TIME)
return BMC_CONST.FW_SUCCESS
##
# @brief This function is used to test hmi malfunction alert:Core checkstop
# A processor core in the system has to be checkstopped (failed recovery).
# Injecting core checkstop on random core of random chip
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def test_malfunction_allert(self):
# Get random pair of chip vs cores
l_pair = random.choice(self.l_dic)
# Get random chip id
l_chip = l_pair[0]
# Get random core number
l_core = random.choice(l_pair[1])
l_reg = "1%s013100" % l_core
l_cmd = "./putscom -c %s %s 1000000000000000" % (l_chip, l_reg)
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
if any("Kernel panic - not syncing" in line for line in l_res):
print "Malfunction alert: kernel got panic"
elif any("login:"******"System booted to host OS without any kernel panic message"
elif any("Petitboot" in line for line in l_res):
print "System reached petitboot without any kernel panic message"
elif any("ISTEP" in line for line in l_res):
print "System started booting without any kernel panic message"
else:
l_msg = "HMI: Malfunction alert failed"
raise OpTestError(l_msg)
return BMC_CONST.FW_SUCCESS
##
# @brief This function is used to test HMI: Hypervisor resource error
# Injecting Hypervisor resource error on random core of random chip
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def test_hyp_resource_err(self):
# Get random pair of chip vs cores
l_pair = random.choice(self.l_dic)
# Get random chip id
l_chip = l_pair[0]
# Get random core number
l_core = random.choice(l_pair[1])
l_reg = "1%s013100" % l_core
l_cmd = "./putscom -c %s %s 0000000000008000" % (l_chip, l_reg)
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
if any("Kernel panic - not syncing" in line for line in l_res) and any(
"Hypervisor Resource error - core check stop" in line for line in l_res
):
print "Hypervisor resource error: kernel got panic"
elif any("login:"******"System booted to host OS without any kernel panic message"
elif any("Petitboot" in line for line in l_res):
print "System reached petitboot without any kernel panic message"
elif any("ISTEP" in line for line in l_res):
print "System started booting without any kernel panic message"
else:
l_msg = "HMI: Hypervisor resource error failed"
raise OpTestError(l_msg)
return BMC_CONST.FW_SUCCESS
class OpTestSensors():
## Initialize this object
# @param i_bmcIP The IP address of the BMC
# @param i_bmcUser The userid to log into the BMC with
# @param i_bmcPasswd The password of the userid to log into the BMC with
# @param i_bmcUserIpmi The userid to issue the BMC IPMI commands with
# @param i_bmcPasswdIpmi The password of BMC IPMI userid
# @param i_ffdcDir Optional param to indicate where to write FFDC
#
# "Only required for inband tests" else Default = None
# @param i_lparIP The IP address of the LPAR
# @param i_lparuser The userid to log into the LPAR
# @param i_lparPasswd The password of the userid to log into the LPAR with
#
def __init__(self, i_bmcIP, i_bmcUser, i_bmcPasswd,
i_bmcUserIpmi, i_bmcPasswdIpmi, i_ffdcDir=None, i_lparip=None,
i_lparuser=None, i_lparPasswd=None):
self.cv_BMC = OpTestBMC(i_bmcIP, i_bmcUser, i_bmcPasswd, i_ffdcDir)
self.cv_IPMI = OpTestIPMI(i_bmcIP, i_bmcUserIpmi, i_bmcPasswdIpmi,
i_ffdcDir)
self.cv_LPAR = OpTestLpar(i_lparip, i_lparuser, i_lparPasswd,i_bmcIP)
self.util = OpTestUtil()
##
# @brief This function will cover following test steps
# 1. It will check for kernel config option CONFIG_SENSORS_IBMPOWERNV
# 2. It will load ibmpowernv driver only on powernv platform
# 3. It will check for sensors command existence and lm_sensors package
# 4. start the lm_sensors service and detect any sensor chips
# using sensors-detect.
# 5. At the end it will test sensors command functionality
# with different options
#
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def test_hwmon_driver(self):
# Get OS level
l_oslevel = self.cv_LPAR.lpar_get_OS_Level()
# Get kernel version
l_kernel = self.cv_LPAR.lpar_get_kernel_version()
# Checking for sensors config option CONFIG_SENSORS_IBMPOWERNV
l_config = "CONFIG_SENSORS_IBMPOWERNV"
l_val = self.cv_LPAR.lpar_check_config(l_kernel, l_config)
if l_val == "y":
print "Driver build into kernel itself"
else:
print "Driver will be built as module"
# Loading ibmpowernv driver only on powernv platform
self.cv_LPAR.lpar_load_ibmpowernv(l_oslevel)
# Checking for sensors command and lm_sensors package
self.cv_LPAR.lpar_check_command("sensors")
l_pkg = self.cv_LPAR.lpar_check_pkg_for_utility(l_oslevel, "sensors")
print "Installed package: %s" % l_pkg
# Restart the lm_sensor service
self.cv_LPAR.lpar_start_lm_sensor_svc(l_oslevel)
# To detect different sensor chips and modules
res = self.cv_LPAR.lpar_run_command("yes | sensors-detect")
print res
# Checking sensors command functionality with different options
output = self.cv_LPAR.lpar_run_command("sensors; echo $?")
response = output.splitlines()
if int(response[-1]):
l_msg = "sensors not working,exiting...."
raise OpTestError(l_msg)
print output
output = self.cv_LPAR.lpar_run_command("sensors -f; echo $?")
response = output.splitlines()
if int(response[-1]):
l_msg = "sensors -f not working,exiting...."
raise OpTestError(l_msg)
print output
output = self.cv_LPAR.lpar_run_command("sensors -A; echo $?")
response = output.splitlines()
if int(response[-1]):
l_msg = "sensors -A not working,exiting...."
raise OpTestError(l_msg)
print output
output = self.cv_LPAR.lpar_run_command("sensors -u; echo $?")
response = output.splitlines()
if int(response[-1]):
l_msg = "sensors -u not working,exiting...."
raise OpTestError(l_msg)
print output
return BMC_CONST.FW_SUCCESS
class OpTestPrdDriver():
## Initialize this object
# @param i_bmcIP The IP address of the BMC
# @param i_bmcUser The userid to log into the BMC with
# @param i_bmcPasswd The password of the userid to log into the BMC with
# @param i_bmcUserIpmi The userid to issue the BMC IPMI commands with
# @param i_bmcPasswdIpmi The password of BMC IPMI userid
# @param i_ffdcDir Optional param to indicate where to write FFDC
#
# "Only required for inband tests" else Default = None
# @param i_lparIP The IP address of the LPAR
# @param i_lparuser The userid to log into the LPAR
# @param i_lparPasswd The password of the userid to log into the LPAR with
#
def __init__(self, i_bmcIP, i_bmcUser, i_bmcPasswd,
i_bmcUserIpmi, i_bmcPasswdIpmi, i_ffdcDir=None, i_lparip=None,
i_lparuser=None, i_lparPasswd=None):
self.cv_BMC = OpTestBMC(i_bmcIP, i_bmcUser, i_bmcPasswd, i_ffdcDir)
self.cv_IPMI = OpTestIPMI(i_bmcIP, i_bmcUserIpmi, i_bmcPasswdIpmi,
i_ffdcDir, i_lparip, i_lparuser, i_lparPasswd)
self.cv_LPAR = OpTestLpar(i_lparip, i_lparuser, i_lparPasswd, i_bmcIP)
self.cv_SYSTEM = OpTestSystem(i_bmcIP, i_bmcUser, i_bmcPasswd,
i_bmcUserIpmi, i_bmcPasswdIpmi, i_ffdcDir, i_lparip,
i_lparuser, i_lparPasswd)
self.util = OpTestUtil()
##
# @brief This function performs below steps
# 1. Initially connecting to lpar and ipmi consoles for execution.
# 2. check for IPOLL mask register value to see whether opal-prd is running or not
# if it is 0-->opal-prd is running-->continue
# else start opal-prd service again
# 3. call test_prd_for_fir() function for each core FIR error and this function
# can be used for any number of errors, like it is a generic function
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def testPrdDriver(self):
self.test_init()
l_con = self.cv_SYSTEM.sys_get_ipmi_console()
self.cv_IPMI.ipmi_lpar_login(l_con)
self.cv_IPMI.ipmi_lpar_set_unique_prompt(l_con)
self.cv_IPMI.run_lpar_cmd_on_ipmi_console("cd %s/external/xscom-utils/;" % BMC_CONST.CLONE_SKIBOOT_DIR)
# check for IPOLL mask register value to check opal-prd is running or not
l_cmd = "./getscom -c 0x0 %s" % BMC_CONST.IPOLL_MASK_REGISTER
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
if l_res[-1] == "0":
print "Opal-prd is running"
else:
self.cv_IPMI.run_lpar_cmd_on_ipmi_console("service opal-prd start")
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
if l_res[-1] == "0":
print "Opal-prd is running"
else:
l_msg = "IPOLL MASK REGISTER is not getting cleared by opal-prd"
raise OpTestError(l_msg)
# test for PBA FIR with different core errors
# 1.PBAFIR_OCI_APAR_ERR-->OCI Address Parity Error
self.test_prd_for_fir(BMC_CONST.PBA_FAULT_ISOLATION_REGISTER,
BMC_CONST.PBA_FAULT_ISOLATION_MASK_REGISTER,
BMC_CONST.PBAFIR_OCI_APAR_ERR)
# 2.PBAFIR_PB_CE_FW-->PB Read Data CE Error for Forwarded Request
self.test_prd_for_fir(BMC_CONST.PBA_FAULT_ISOLATION_REGISTER,
BMC_CONST.PBA_FAULT_ISOLATION_MASK_REGISTER,
BMC_CONST.PBAFIR_PB_CE_FW)
# 3.PBAFIR_PB_RDDATATO_FW-->PB Read Data Timeout for Forwarded Request
self.test_prd_for_fir(BMC_CONST.PBA_FAULT_ISOLATION_REGISTER,
BMC_CONST.PBA_FAULT_ISOLATION_MASK_REGISTER,
BMC_CONST.PBAFIR_PB_RDDATATO_FW)
# 4.PBAFIR_PB_RDADRERR_FW-->PB CRESP Addr Error Received for Forwarded Read Request
self.test_prd_for_fir(BMC_CONST.PBA_FAULT_ISOLATION_REGISTER,
BMC_CONST.PBA_FAULT_ISOLATION_MASK_REGISTER,
BMC_CONST.PBAFIR_PB_RDADRERR_FW)
return BMC_CONST.FW_SUCCESS
##
# @brief This function injects some core FIR errors and verifies whether opal-prd clears the errors.
# and also this function injects errors on random chip.
#
# @param FIR @type str: Local Fault Isolation register
# @param FIMR @type str: Local Fault Isolation mask register
# @param ERROR @type int: Core FIR error, this error will be written to FIR.
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def test_prd_for_fir(self, FIR, FIMR, ERROR):
chip_id = "0x" + self.random_chip
print chip_id
print "OPAL-PRD: Injecting error 0x%x on FIR: %s" % (ERROR, FIR)
# Read Local Fault Isolation register
l_cmd = "./getscom -c %s %s" % (chip_id, FIR)
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
# Reading Local Fault Isolation mask register
l_cmd = "./getscom -c %s %s" % (chip_id, FIMR)
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
print l_res
# Changing the FIMR value to un-masked value.
LEN = 16
l_len = len(l_res[-1])
l_val = hex(int(("0x" + "0"*(LEN - l_len) + l_res[-1]), 16)& (ERROR ^ 0xffffffffffffffff))
# Writing the same value to Local Fault Isolation mask register again
l_cmd = "./putscom -c %s %s %s" % (chip_id, BMC_CONST.PBA_FAULT_ISOLATION_MASK_REGISTER, l_val)
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
# Inject a core error on FIR
l_cmd = "./putscom -c %s %s %s" % (chip_id, FIR, hex(ERROR))
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
time.sleep(30)
# Read Local Fault Isolation register again
l_cmd = "./getscom -c %s %s" % (chip_id, FIR)
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
print l_res
# Check FIR got cleared by opal-prd
if l_res[-1] == "0":
print "Opal-prd handles core hardware error"
else:
l_msg = "Opal-prd not clearing hardware errors in runtime"
print l_msg
raise OpTestError(l_msg)
# Reading the Local Fault Isolation Mask Register again
l_cmd = "./getscom -c %s %s" % (chip_id, FIMR)
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
print l_res
# check for IPOLL mask register value to see opal-prd cleared the value
l_cmd = "./getscom -c %s %s" % (chip_id, BMC_CONST.IPOLL_MASK_REGISTER)
l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(l_cmd)
if l_res[-1] == "0":
print "Opal-prd cleared the IPOLL MASK REGISTER"
return BMC_CONST.FW_SUCCESS
else:
l_msg = "Opal-prd is not clearing the IPOLL MASK REGISTER after injecting core FIR error"
print l_msg
raise OpTestError(l_msg)
##
# @brief This is a common function for all the PRD test cases. This will be executed before
# any test case starts. Basically this provides below requirements.
# 1. Validates all required lpar commands
# 2. It will clone skiboot source repository
# 3. Compile the necessary tools -xscom-utils(getscom and putscom)
# 4. Get the list Of Chips.
# Ex: ['00000000', '00000001', '00000010']
# 5. generate a random chip.
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def test_init(self):
# Get OS level
self.cv_LPAR.lpar_get_OS_Level()
# Check whether git and gcc commands are available on lpar
self.cv_LPAR.lpar_check_command("git")
self.cv_LPAR.lpar_check_command("gcc")
# It will clone skiboot source repository
self.cv_LPAR.lpar_clone_skiboot_source(BMC_CONST.CLONE_SKIBOOT_DIR)
# Compile the necessary tools xscom-utils and gard utility
self.cv_LPAR.lpar_compile_xscom_utilities(BMC_CONST.CLONE_SKIBOOT_DIR)
# Getting list of processor chip Id's(executing getscom -l to get chip id's)
l_res = self.cv_LPAR.lpar_run_command("cd %s/external/xscom-utils/; ./getscom -l" % BMC_CONST.CLONE_SKIBOOT_DIR)
l_res = l_res.splitlines()
l_chips = []
for line in l_res:
matchObj = re.search("(\d{8}).*processor", line)
if matchObj:
l_chips.append(matchObj.group(1))
if not l_chips:
l_msg = "Getscom failed to list processor chip id's"
raise OpTestError(l_msg)
l_chips.sort()
print l_chips # ['00000000', '00000001', '00000010']
self.random_chip = random.choice(l_chips)
# Below will be useful for debug purposes to compare chip information
l_res = self.cv_LPAR.lpar_read_msglog_core()
print l_res
class OpTestOOBIPMI():
## Initialize this object
# @param i_bmcIP The IP address of the BMC
# @param i_bmcUser The userid to log into the BMC with
# @param i_bmcPasswd The password of the userid to log into the BMC with
# @param i_bmcUserIpmi The userid to issue the BMC IPMI commands with
# @param i_bmcPasswdIpmi The password of BMC IPMI userid
# @param i_ffdcDir Optional param to indicate where to write FFDC
#
# "Only required for inband tests" else Default = None
# @param i_lparIP The IP address of the LPAR
# @param i_lparuser The userid to log into the LPAR
# @param i_lparPasswd The password of the userid to log into the LPAR with
#
def __init__(self, i_bmcIP, i_bmcUser, i_bmcPasswd,
i_bmcUserIpmi, i_bmcPasswdIpmi, i_ffdcDir=None, i_lparip=None,
i_lparuser=None, i_lparPasswd=None):
self.cv_BMC = OpTestBMC(i_bmcIP, i_bmcUser, i_bmcPasswd, i_ffdcDir)
self.cv_IPMI = OpTestIPMI(i_bmcIP, i_bmcUserIpmi, i_bmcPasswdIpmi,
i_ffdcDir)
self.cv_LPAR = OpTestLpar(i_lparip, i_lparuser, i_lparPasswd, i_bmcIP)
self.util = OpTestUtil()
##
# @brief It will execute and test all Out-of-band ipmi commands.
# bmc, channel, chassis, dcmi, echo, event, exec, firewall, fru, lan
# mc, pef, power, raw, sdr, sel, sensor, session, user
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_oob_ipmi(self):
print "OOB IPMI: Chassis tests"
self.test_chassis()
print "OOB IPMI: chassis identify tests"
self.test_chassisIdentifytests()
print "OOB IPMI: chassis bootdevice tests"
self.test_chassisBootdev()
print "OOB IPMI: info tests"
self.test_Info()
print "OOB IPMI: sdr tests"
self.test_sdr_list_by_type()
self.test_sdr_elist_by_type()
self.test_sdr_type_list()
self.test_sdr_get_id()
print "OOB IPMI: Fru tests"
self.test_fru_print()
self.test_fru_read()
print "OOB IPMI: MC tests"
self.test_mc()
print "OOB IPMI: Sensor tests"
self.test_sensor_list()
self.test_sensor_byid("Host Status")
self.test_sensor_byid("OS Boot")
self.test_sensor_byid("OCC Active")
print "OOB IPMI: SEL tests"
self.test_sel_info()
self.test_sel_list()
self.test_sel_elist()
l_res = self.test_sel_time_get()
self.test_sel_time_set(l_res[0])
i_num = "3"
self.test_sel_list_first_n_entries(i_num)
self.test_sel_list_last_n_entries(i_num)
self.test_sel_get_functionality()
self.test_sel_clear_functionality()
print "OOB IPMI: Channel Tests"
self.test_channel()
print "OOB IPMI: dcmi tests"
self.test_dcmi()
print "OOB IPMI: echo tests"
self.test_echo()
print "OOB IPMI: event tests"
self.test_event()
print "OOB IPMI: Firewall test"
self.test_firewall()
print "OOB IPMI: Pef tests"
self.test_pef()
print "OOB IPMI: raw command execution tests"
self.test_raw()
print "OOB IPMI: exec tests"
self.test_exec()
##
# @brief It will check basic channel functionalities: info and authentication capabilities.
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_channel(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_CHANNEL_AUTHCAP)
self.run_ipmi_cmd(BMC_CONST.IPMI_CHANNEL_INFO)
##
# @brief It will execute and test the return code of ipmi command.
#
# @param i_cmd @type string:The ipmitool command, for example: chassis power on; echo $?
#
# @return l_res @type list: output of command or raise OpTestError
#
def run_ipmi_cmd(self, i_cmd):
l_cmd = i_cmd
l_res = self.cv_IPMI.ipmitool_execute_command(l_cmd)
print l_res
l_res = l_res.splitlines()
if int(l_res[-1]):
l_msg = "IPMI: command failed %c" % l_cmd
raise OpTestError(l_msg)
return l_res
##
# @brief It will execute and test the ipmi chassis <cmd> commands
# cmd: status, poh, restart_cause, policy list and policy set
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_chassis(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_STATUS)
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_POH)
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_RESTART_CAUSE)
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_POLICY_LIST)
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_POLICY_ALWAYS_OFF)
##
# @brief It will execute and test the ipmi chassis identify commands
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_chassisIdentifytests(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_IDENTIFY)
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_IDENTIFY_5)
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_IDENTIFY)
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_IDENTIFY_FORCE)
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_IDENTIFY)
##
# @brief It will execute and test the functionality of ipmi chassis bootdev <dev>
# dev: none,pxe,cdrom,disk,bios,safe,diag,floppy and none.
#
# @return BMC_CONST.FW_SUCCESS on success or raise OpTestError
#
def test_chassisBootdev(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_BOOTDEV_NONE)
self.verify_bootdev("none")
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_BOOTDEV_PXE)
self.verify_bootdev("pxe")
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_BOOTDEV_CDROM)
self.verify_bootdev("cdrom")
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_BOOTDEV_DISK)
self.verify_bootdev("disk")
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_BOOTDEV_BIOS)
self.verify_bootdev("bios")
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_BOOTDEV_SAFE)
self.verify_bootdev("safe")
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_BOOTDEV_DIAG)
self.verify_bootdev("diag")
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_BOOTDEV_FLOPPY)
self.verify_bootdev("floppy")
self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_BOOTDEV_NONE)
self.verify_bootdev("none")
##
# @brief It will verify whether setting of given bootdevice is honoured or not
# by reading chassis bootparam get 5
#
# @param i_dev @type string: boot device name: Ex safe, disk and cdrom
#
# @return BMC_CONST.FW_SUCCESS on success or raise OpTestError
#
def verify_bootdev(self, i_dev):
l_res = self.run_ipmi_cmd(BMC_CONST.IPMI_CHASSIS_BOOTPARAM_GET_5)
if i_dev == "safe":
l_msg = "Force Boot from default Hard-Drive, request Safe-Mode"
elif i_dev == "disk":
l_msg = "Force Boot from default Hard-Drive"
elif i_dev == "diag":
l_msg = "Force Boot from Diagnostic Partition"
elif i_dev == "bios":
l_msg = "Force Boot into BIOS Setup"
elif i_dev == "pxe":
l_msg = "Force PXE"
elif i_dev == "cdrom":
l_msg = "Force Boot from CD/DVD"
elif i_dev == "none":
l_msg = "No override"
elif i_dev == "floppy":
l_msg = "Force Boot from Floppy/primary removable media"
else:
print "pass proper bootdevice"
for l_line in l_res:
if l_line.__contains__(l_msg):
print "Verifying bootdev is successfull for %s" % i_dev
return BMC_CONST.FW_SUCCESS
else:
l_msg = "Boot device is not set to %s" % i_dev
raise OpTestError(l_msg)
##
# @brief It will execute and test the ipmi <sdr/sel/mc/channel> info related commands.
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_Info(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_CHANNEL_INFO)
self.run_ipmi_cmd(BMC_CONST.IPMI_MC_INFO)
self.run_ipmi_cmd(BMC_CONST.IPMI_SEL_INFO)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_INFO)
##
# @brief It will execute and test the ipmi sdr list <all/fru/event/mcloc/compact/full/generic>
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_sdr_list_by_type(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_LIST)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_LIST_ALL)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_LIST_FRU)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_LIST_EVENT)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_LIST_MCLOC)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_LIST_COMPACT)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_LIST_FULL)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_LIST_GENERIC)
##
# @brief It will execute and test the ipmi sdr elist <all/fru/event/mcloc/compact/full/generic>
# commands
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_sdr_elist_by_type(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_ELIST)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_ELIST_ALL)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_ELIST_FRU)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_ELIST_EVENT)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_ELIST_MCLOC)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_ELIST_COMPACT)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_ELIST_FULL)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_ELIST_GENERIC)
##
# @brief It will execute and test the ipmi sdr type <Temp/fan/Powersupply> commands
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_sdr_type_list(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_TYPE_LIST)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_TYPE_TEMPERATURE)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_TYPE_FAN)
self.run_ipmi_cmd(BMC_CONST.IPMI_SDR_TYPE_POWER_SUPPLY)
##
# @brief It will execute and test the ipmi sdr get <sensor-id> command
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_sdr_get_id(self):
l_cmd = BMC_CONST.IPMI_SDR_GET_WATCHDOG + "; echo $?"
self.run_ipmi_cmd(l_cmd)
##
# @brief It will execute and test the ipmi fru print command.
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_fru_print(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_FRU_PRINT)
##
# @brief It will execute and test the ipmi fru read command.
# then the output file is displayed by hexdump
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_fru_read(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_FRU_READ)
l_res = commands.getstatusoutput("hexdump -C file_fru")
if int(l_res[0]) == 0:
print l_res[1]
else:
l_msg = "Failing to do hexdump for fru file"
print l_msg
raise OpTestError(l_msg)
##
# @brief It will execute and test the ipmi sensor list functionality
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_sensor_list(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_SENSOR_LIST)
##
# @brief It will execute and test the ipmi sensor get <id> functionality
#
# @param i_sensor @type string:sensor id to retrieve the data
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_sensor_byid(self, i_sensor):
l_cmd = "sensor get \"%s\"; echo $?" % i_sensor
self.run_ipmi_cmd(l_cmd)
##
# @brief It will execute and test the management controller(mc) commands functionality
# info-Displays information about the BMC hardware, including device revision,
# firmware revision, IPMI version supported, manufacturer ID, and information
# on additional device support
# watchdog get-Show current Watchdog Timer settings and countdown state.
# watchdog off-Turn off a currently running Watchdog countdown timer.
# watchdog reset-Reset the Watchdog Timer to its most recent state and restart the countdown timer.
# selftest- Check on the basic health of the BMC by executing the
# Get Self Test results command and report the results.
# setenables-Enables or disables the given option
# getenables-Displays a list of the currently enabled options for the BMC.
# getsysinfo-Retrieves system info from bmc for given argument
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_mc(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_MC_INFO)
self.run_ipmi_cmd(BMC_CONST.IPMI_MC_WATCHDOG_GET)
self.run_ipmi_cmd(BMC_CONST.IPMI_MC_SELFTEST)
self.run_ipmi_cmd(BMC_CONST.IPMI_MC_SELFTEST)
self.run_ipmi_cmd(BMC_CONST.IPMI_MC_SETENABLES_OEM_0_OFF)
self.run_ipmi_cmd(BMC_CONST.IPMI_MC_GETENABLES)
self.run_ipmi_cmd(BMC_CONST.IPMI_MC_SETENABLES_OEM_0_ON)
self.run_ipmi_cmd(BMC_CONST.IPMI_MC_GETENABLES)
self.run_ipmi_cmd(BMC_CONST.IPMI_MC_WATCHDOG_OFF)
self.run_ipmi_cmd(BMC_CONST.IPMI_MC_WATCHDOG_RESET)
self.run_ipmi_cmd(BMC_CONST.IPMI_MC_GETSYS_INFO)
##
# @brief It will execute and test the ipmi sel info functionality
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_sel_info(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_SEL_INFO)
##
# @brief It will execute and test ipmi sel list functionality.
# the entire contents of the System Event Log are displayed.
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_sel_list(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_SEL_LIST)
##
# @brief It will execute and test the ipmi sel elist functionality
# If invoked as elist (extended list) it will also use the
# Sensor Data Record entries to display the sensor ID for
# the sensor that caused each event.
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_sel_elist(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_SEL_ELIST)
##
# @brief It will execute and test the ipmi sel time get functionality
# Displays the SEL clock's current time.
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_sel_time_get(self):
l_res = self.run_ipmi_cmd(BMC_CONST.IPMI_SEL_TIME_GET)
return l_res
##
# @brief It will execute and test the ipmi sel set <time string> functionality
# Sets the SEL clock. Future SEL entries will use the time set by this command.
#
# @param i_time @type string: the value to be set as a sel time
# <time string> is of the form "MM/DD/YYYY HH:MM:SS"
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_sel_time_set(self, i_time):
l_cmd = "sel time set \'%s\'; echo $?" % i_time
self.run_ipmi_cmd(l_cmd)
##
# @brief It will execute and test the ipmi sel list first <n entries>
#
# @param i_num @type string:The num of entries of sel to be listed
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_sel_list_first_n_entries(self, i_num):
l_cmd = "sel list first %i; echo $?" % int(i_num)
self.run_ipmi_cmd(l_cmd)
##
# @brief It will execute and test the ipmi sel list last <n entries>
#
# @param i_num @type string:The num of entries of sel to be listed
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_sel_list_last_n_entries(self, i_num):
l_cmd = "sel list last %i; echo $?" % int(i_num)
self.run_ipmi_cmd(l_cmd)
##
# @brief It will execute and test the ipmi sel get <id> functionality
#
# @param i_sel_id @type string: for example 0x05, 0x06..
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_sel_get_byid(self, i_sel_id):
l_cmd = "sel get %s; echo $?" % i_sel_id
self.run_ipmi_cmd(l_cmd)
##
# @brief It will execute and test the ipmi sel clear functionality
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_sel_clear(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_SEL_CLEAR)
##
# @brief It will execute and test the ipmi sel get <id> functionality
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def test_sel_get_functionality(self):
l_res = self.cv_IPMI.ipmitool_execute_command("sel list first 3 | awk '{print $1}'; echo $?")
l_list = l_res.splitlines()
if int(l_list[-1]) == 0:
if l_res.__contains__("SEL has no entries"):
print "There are No sel entries to fetch"
pass
else:
del l_list[-1]
for l in l_list:
l_id = "0x" + l
self.test_sel_get_byid(l_id)
return BMC_CONST.FW_SUCCESS
else:
l_msg = "Not able to get sel entries"
print l_msg
raise OpTestError(l_msg)
##
# @brief It will execute and test the ipmi sel clear functionality
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def test_sel_clear_functionality(self):
self.test_sel_clear()
l_res = self.cv_LPAR.lpar_run_command("ipmitool sel list; echo $?")
l_list = l_res.splitlines()
for l_line in l_list:
if l_line.__contains__("SEL has no entries"):
print "Sel clear function got cleared event entries"
return BMC_CONST.FW_SUCCESS
else:
l_msg = "OOB IPMI: sel clear function failing in clearing entries"
print l_msg
print l_res
raise OpTestError(l_msg)
##
# @brief It will execute and test the dcmi related ipmi commands.
# discover-This command is used to discover supported capabilities in DCMI
# Power reading-Get power related readings from the system.
# get_limit-Get the configured power limits.
# sensors-Prints the available DCMI sensors.
# get_mc_id_string-Get management controller identifier string
# get_temp_reading-Get Temperature Sensor Readings.
# get_conf_param-Get DCMI Configuration Parameters.
# oob_discover-Ping/Pong Message for DCMI Discovery
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_dcmi(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_DCMI_DISCOVER)
self.run_ipmi_cmd(BMC_CONST.IPMI_DCMI_POWER_READING)
self.run_ipmi_cmd(BMC_CONST.IPMI_DCMI_POWER_GET_LIMIT)
self.run_ipmi_cmd(BMC_CONST.IPMI_DCMI_SENSORS)
self.run_ipmi_cmd(BMC_CONST.IPMI_DCMI_GET_MC_ID_STRING)
self.run_ipmi_cmd(BMC_CONST.IPMI_DCMI_GET_TEMP_READING)
self.run_ipmi_cmd(BMC_CONST.IPMI_DCMI_GET_CONF_PARAM)
self.run_ipmi_cmd(BMC_CONST.IPMI_DCMI_OOB_DISCOVER)
##
# @brief It will execute and test the functionality of ipmi echo command.
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_echo(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_ECHO_DONE)
##
# @brief It will execute and test event related commands to test sel functionality.
# Send a pre-defined test event to the System Event Log. The following
# events are included as a means to test the functionality of the System
# Event Log component of the BMC (an entry will be added each time the
# event N command is executed)
# Currently supported values for N are:
# 1 Temperature: Upper Critical: Going High
# 2 Voltage Threshold: Lower Critical: Going Low
# 3 Memory: Correctable ECC
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_event(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_EVENT_1)
self.run_ipmi_cmd(BMC_CONST.IPMI_EVENT_2)
self.run_ipmi_cmd(BMC_CONST.IPMI_EVENT_3)
##
# @brief It will execute and test ipmi exec command.
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_exec(self):
pass
# TODO: need to execute ipmi commands from a file
##
# @brief It will execute and test firmware firewall info command.
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_firewall(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_FIREWALL_INFO)
##
# @brief It will execute and test pef related commands:
# info:This command will query the BMC and print information about the PEF supported features.
# status: This command prints the current PEF status
# policy: This command lists the PEF policy table entries
# list: This command lists the PEF table entries.
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_pef(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_PEF_INFO)
self.run_ipmi_cmd(BMC_CONST.IPMI_PEF_STATUS)
self.run_ipmi_cmd(BMC_CONST.IPMI_PEF_POLICY)
self.run_ipmi_cmd(BMC_CONST.IPMI_PEF_LIST)
##
# @brief This will test raw IPMI commands. For example to query the POH counter with a raw command
#
# @return l_res @type list: output of command or raise OpTestError
#
def test_raw(self):
self.run_ipmi_cmd(BMC_CONST.IPMI_RAW_POH)
class OpTestMtdPnorDriver():
## Initialize this object and also getting the lpar login credentials to use by scp utility
# @param i_bmcIP The IP address of the BMC
# @param i_bmcUser The userid to log into the BMC with
# @param i_bmcPasswd The password of the userid to log into the BMC with
# @param i_bmcUserIpmi The userid to issue the BMC IPMI commands with
# @param i_bmcPasswdIpmi The password of BMC IPMI userid
# @param i_ffdcDir Optional param to indicate where to write FFDC
#
# "Only required for inband tests" else Default = None
# @param i_lparIP The IP address of the LPAR
# @param i_lparuser The userid to log into the LPAR
# @param i_lparPasswd The password of the userid to log into the LPAR with
#
def __init__(self, i_bmcIP, i_bmcUser, i_bmcPasswd,
i_bmcUserIpmi, i_bmcPasswdIpmi, i_ffdcDir=None, i_lparip=None,
i_lparuser=None, i_lparPasswd=None):
self.cv_BMC = OpTestBMC(i_bmcIP, i_bmcUser, i_bmcPasswd, i_ffdcDir)
self.cv_IPMI = OpTestIPMI(i_bmcIP, i_bmcUserIpmi, i_bmcPasswdIpmi,
i_ffdcDir)
self.cv_LPAR = OpTestLpar(i_lparip, i_lparuser, i_lparPasswd, i_bmcIP)
self.util = OpTestUtil()
self.lpar_user = i_lparuser
self.lpar_ip = i_lparip
self.lpar_Passwd = i_lparPasswd
##
# @brief This function has following test steps
# 1. Get lpar information(OS and Kernel information)
# 2. Load the mtd module based on config value
# 3. Check /dev/mtd0 character device file existence on lpar
# 4. Copying the contents of the flash in a file /tmp/pnor
# 5. Getting the /tmp/pnor file into local x86 machine using scp utility
# 6. Remove existing /tmp/ffs directory and
# Clone latest ffs git repository in local x86 working machine
# 7. Compile ffs repository to get fcp utility
# 8. Check existence of fcp utility in ffs repository, after compiling
# 9. Get the PNOR flash contents on an x86 machine using fcp utility
#
# @return BMC_CONST.FW_SUCCESS-success or raise OpTestError-fail
#
def testMtdPnorDriver(self):
# Get OS level
l_oslevel = self.cv_LPAR.lpar_get_OS_Level()
# Get Kernel Version
l_kernel = self.cv_LPAR.lpar_get_kernel_version()
# loading mtd module based on config option
l_config = "CONFIG_MTD_POWERNV_FLASH"
l_module = "mtd"
self.cv_LPAR.lpar_load_module_based_on_config(l_kernel, l_config, l_module)
# Check /dev/mtd0 file existence on lpar
l_cmd = "ls -l /dev/mtd0; echo $?"
l_res = self.cv_LPAR.lpar_run_command(l_cmd)
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
print "/dev/mtd0 character device file exists on lpar"
else:
l_msg = "/dev/mtd0 character device file doesn't exist on lpar"
print l_msg
raise OpTestError(l_msg)
# Copying the contents of the PNOR flash in a file /tmp/pnor
l_file = "/tmp/pnor"
l_cmd = "cat /dev/mtd0 > %s; echo $?" % l_file
l_res = self.cv_LPAR.lpar_run_command(l_cmd)
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
print "Fetched PNOR data from /dev/mtd0 into temp file /tmp/pnor"
else:
l_msg = "Fetching PNOR data is failed from /dev/mtd0 into temp file /tmp/pnor"
print l_msg
raise OpTestError(l_msg)
# Getting the /tmp/pnor file into local x86 machine
l_path = "/tmp/"
self.util.copyFilesToDest(l_path, self.lpar_user, self.lpar_ip, l_file, self.lpar_Passwd, "2", BMC_CONST.SCP_TO_LOCAL)
l_list = commands.getstatusoutput("ls -l %s; echo $?" % l_path)
print l_list
l_workdir = "/tmp/ffs"
# Remove existing /tmp/ffs directory
l_res = commands.getstatusoutput("rm -rf %s" % l_workdir)
print l_res
# Clone latest ffs git repository in local x86 working machine
l_cmd = "git clone https://github.com/open-power/ffs/ %s" % l_workdir
l_res = commands.getstatusoutput(l_cmd)
print l_res
if int(l_res[0]) == 0:
print "Cloning of ffs repository is successfull"
else:
l_msg = "Cloning ffs repository is failed"
print l_msg
raise OpTestError(l_msg)
# Compile ffs repository to get fcp utility
l_cmd = "cd %s/; make" % l_workdir
l_res = commands.getstatusoutput(l_cmd)
print l_res
if int(l_res[0]) == 0:
print "Compiling fcp utility is successfull"
else:
l_msg = "Compiling fcp utility is failed"
print l_msg
raise OpTestError(l_msg)
# Check existence of fcp utility in ffs repository, after compiling.
l_cmd = "test -f %s/fcp/x86/fcp" % l_workdir
l_res = commands.getstatusoutput(l_cmd)
print l_res
if int(l_res[0]) == 0:
print "Compiling fcp utility is successfull"
else:
l_msg = "Compiling fcp utility is failed"
print l_msg
raise OpTestError(l_msg)
# Check the PNOR flash contents on an x86 machine using fcp utility
l_cmd = "%s/fcp/x86/fcp -o 0x0 -L %s" % (l_workdir, l_file)
l_res = commands.getstatusoutput(l_cmd)
print l_res[1]
if int(l_res[0]) == 0:
print "Getting PNOR data successfull using fcp utility"
return BMC_CONST.FW_SUCCESS
else:
l_msg = "Getting the PNOR data using fcp utility failed"
print l_msg
raise OpTestError(l_msg)
class OpTestRTCdriver():
## Initialize this object
# @param i_bmcIP The IP address of the BMC
# @param i_bmcUser The userid to log into the BMC with
# @param i_bmcPasswd The password of the userid to log into the BMC with
# @param i_bmcUserIpmi The userid to issue the BMC IPMI commands with
# @param i_bmcPasswdIpmi The password of BMC IPMI userid
# @param i_ffdcDir Optional param to indicate where to write FFDC
#
# "Only required for inband tests" else Default = None
# @param i_lparIP The IP address of the LPAR
# @param i_lparuser The userid to log into the LPAR
# @param i_lparPasswd The password of the userid to log into the LPAR with
#
def __init__(self, i_bmcIP, i_bmcUser, i_bmcPasswd,
i_bmcUserIpmi, i_bmcPasswdIpmi, i_ffdcDir=None, i_lparip=None,
i_lparuser=None, i_lparPasswd=None):
self.cv_BMC = OpTestBMC(i_bmcIP, i_bmcUser, i_bmcPasswd, i_ffdcDir)
self.cv_IPMI = OpTestIPMI(i_bmcIP, i_bmcUserIpmi, i_bmcPasswdIpmi,
i_ffdcDir)
self.cv_LPAR = OpTestLpar(i_lparip, i_lparuser, i_lparPasswd,i_bmcIP)
self.util = OpTestUtil()
##
# @brief This function will cover following test steps
# 1. Getting lpar information(OS and Kernel info)
# 2. Loading rtc_opal module based on config option
# 3. Testing the rtc driver functions
# Display the current time,
# set the Hardware Clock to a specified time,
# set the Hardware Clock from the System Time, or
# set the System Time from the Hardware Clock
# keep the Hardware clock in UTC or local time format
# Hardware clock compare, predict and adjust functions
# Hardware clock debug and test modes
# Reading the Hardware clock from special file instead of default
# 4. After executing above each function reading the Hardware clock in b/w functions.
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def test_RTC_driver(self):
# Get OS level
l_oslevel = self.cv_LPAR.lpar_get_OS_Level()
# Get Kernel Version
l_kernel = self.cv_LPAR.lpar_get_kernel_version()
# Get hwclock version
l_hwclock = self.cv_LPAR.lpar_run_command("hwclock -V;echo $?")
# loading rtc_opal module based on config option
l_config = "CONFIG_RTC_DRV_OPAL"
l_module = "rtc_opal"
self.cv_LPAR.lpar_load_module_based_on_config(l_kernel, l_config, l_module)
# Get the device files for rtc driver
l_res = self.cv_LPAR.lpar_run_command("ls /dev/ | grep -i --color=never rtc")
l_files = l_res.splitlines()
l_list = []
for name in l_files:
if name.__contains__("rtc"):
l_file = "/dev/" + name
l_list.append(l_file)
else:
continue
print l_list
# Display the time of hwclock from device files
for l_file in l_list:
self.read_hwclock_from_file(l_file)
self.cv_LPAR.lpar_read_hwclock()
time.sleep(5)
self.cv_LPAR.lpar_set_hwclock_time("2015-01-01 10:10:10")
time.sleep(5)
self.cv_LPAR.lpar_read_hwclock()
self.cv_LPAR.lpar_set_hwclock_time("2016-01-01 20:20:20")
self.cv_LPAR.lpar_read_hwclock()
self.set_hwclock_in_utc("2017-01-01 10:10:10")
self.cv_LPAR.lpar_read_hwclock()
self.set_hwclock_in_localtime("2014-01-01 05:05:05")
self.cv_LPAR.lpar_read_hwclock()
self.cv_LPAR.lpar_read_systime()
self.systime_to_hwclock()
self.cv_LPAR.lpar_read_hwclock()
self.systime_to_hwclock_in_utc()
self.cv_LPAR.lpar_read_hwclock()
self.systime_to_hwclock_in_localtime()
self.cv_LPAR.lpar_read_hwclock()
self.hwclock_to_systime()
self.cv_LPAR.lpar_read_hwclock()
self.cv_LPAR.lpar_read_systime()
self.hwclock_in_utc()
self.cv_LPAR.lpar_read_hwclock()
self.hwclock_in_localtime()
self.cv_LPAR.lpar_read_hwclock()
self.hwclock_predict("2015-01-01 10:10:10")
self.cv_LPAR.lpar_read_hwclock()
self.hwclock_debug_mode()
self.cv_LPAR.lpar_read_hwclock()
self.hwclock_test_mode("2018-01-01 10:10:10")
self.cv_LPAR.lpar_read_hwclock()
self.hwclock_adjust()
self.cv_LPAR.lpar_read_hwclock()
self.hwclock_compare()
self.cv_LPAR.lpar_read_hwclock()
##
# @brief This function reads hwclock from special /dev/... file instead of default
#
# @param i_file @type string: special /dev/ file
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def read_hwclock_from_file(self, i_file):
print "Reading the hwclock from special file /dev/ ...: %s" % i_file
l_res = self.cv_LPAR.lpar_run_command("hwclock -r -f %s;echo $?" % i_file)
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "Reading the hwclock from file failed"
print l_msg
raise OpTestError(l_msg)
##
# @brief This function sets hwclock in UTC format
#
# @param i_time @type string: time to set hwclock
# Ex: "2016-01-01 12:12:12"
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def set_hwclock_in_utc(self, i_time):
print "Setting the hwclock in UTC: %s" % i_time
l_res = self.cv_LPAR.lpar_run_command("hwclock --set --date \'%s\' --utc;echo $?" % i_time)
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "Setting the hwclock in UTC failed"
print l_msg
raise OpTestError(l_msg)
##
# @brief This function sets hwclock in local time format
#
# @param i_time @type string: Time to set hwclock
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def set_hwclock_in_localtime(self, i_time):
print "Setting the hwclock in localtime: %s" % i_time
l_res = self.cv_LPAR.lpar_run_command("hwclock --set --date \'%s\' --localtime;echo $?" % i_time)
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "Setting the hwclock in localtime failed"
print l_msg
raise OpTestError(l_msg)
##
# @brief This function sets the time of hwclock from system time
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def systime_to_hwclock(self):
print "Setting the hwclock from system time"
l_res = self.cv_LPAR.lpar_run_command("hwclock --systohc;echo $?")
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "Setting the hwclock from system time failed"
print l_msg
raise OpTestError(l_msg)
##
# @brief This function sets the time of hwclock from system time in UTC format
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def systime_to_hwclock_in_utc(self):
print "Setting the hwclock from system time, in UTC format"
l_res = self.cv_LPAR.lpar_run_command("hwclock --systohc --utc;echo $?")
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "Setting the hwclock from system time in UTC format failed"
print l_msg
raise OpTestError(l_msg)
##
# @brief This function sets the time of hwclock from system time in local time format
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def systime_to_hwclock_in_localtime(self):
print "Setting the hwclock from system time, in localtime format"
l_res = self.cv_LPAR.lpar_run_command("hwclock --systohc --localtime;echo $?")
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "Setting the hwclock from system time in localtime format failed"
print l_msg
raise OpTestError(l_msg)
##
# @brief This function sets the system time from hwclock.
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def hwclock_to_systime(self):
print "Setting the system time from hwclock"
l_res = self.cv_LPAR.lpar_run_command("hwclock --hctosys;echo $?")
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "Setting the system time from hwclock failed"
print l_msg
raise OpTestError(l_msg)
##
# @brief This function keeps hwclock in UTC format.
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def hwclock_in_utc(self):
print "Keeping the hwclock in UTC format"
l_res = self.cv_LPAR.lpar_run_command("hwclock --utc;echo $?")
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "Keeping the hwclock in UTC is failed"
print l_msg
raise OpTestError(l_msg)
##
# @brief This function keeps hwclock in local time format.
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def hwclock_in_localtime(self):
print "Keeping the hwclock in localtime"
l_res = self.cv_LPAR.lpar_run_command("hwclock --localtime;echo $?")
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "Keeping the hwclock in localtime is failed"
print l_msg
raise OpTestError(l_msg)
##
# @brief This function tests hwclock compare functionality for a time of 100 seconds.
# Here checking the return status of timeout as 124, if compare works fine. any
# other return value means compare function failed.
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def hwclock_compare(self):
print "Testing hwclock compare functionality for a time of 100 seconds"
l_res = self.cv_LPAR.lpar_run_command("timeout 100 hwclock --compare; echo $?")
l_res = l_res.splitlines()
print l_res
if int(l_res[-1]) == 124:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "hwclock compare function failed"
print l_msg
raise OpTestError(l_msg)
##
# @brief This function predict RTC reading at time given with --date
#
# @param i_time @type string: time at which predict hwclock reading
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def hwclock_predict(self, i_time):
print "Testing the hwclock predict function to a time: %s" % i_time
l_res = self.cv_LPAR.lpar_run_command("hwclock --predict --date \'%s\';echo $?" % i_time)
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "hwclock predict function failed"
print l_msg
raise OpTestError(l_msg)
##
# @brief This function tests hwclock debug mode.
# In this mode setting hwclock from system time
# and setting system time from hwclock
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def hwclock_debug_mode(self):
print "Testing the hwclock debug mode"
l_res = self.cv_LPAR.lpar_run_command("hwclock --systohc --debug;echo $?")
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
pass
else:
l_msg = "Setting the hwclock from system time in debug mode failed"
print l_msg
raise OpTestError(l_msg)
l_res = self.cv_LPAR.lpar_run_command("hwclock --hctosys --debug;echo $?")
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "Setting the system time from hwclock in debug mode failed"
print l_msg
raise OpTestError(l_msg)
##
# @brief This function tests the hwclock test mode. In this mode setting the hwclock
# time using --set option. Here it just execute but should not set hwclock time.
#
# @param i_time @type string: time to set hwclock in test mode
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def hwclock_test_mode(self, i_time):
print "Testing the hwclock test mode, set time to: %s" % i_time
l_res = self.cv_LPAR.lpar_run_command("hwclock --set --date \'%s\' --test;echo $?" % i_time)
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "hwclock test function failed"
print l_msg
raise OpTestError(l_msg)
##
# @brief This function tests hwclock adjust functionality
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def hwclock_adjust(self):
print "Testing the hwclock adjust function"
l_res = self.cv_LPAR.lpar_run_command("hwclock --adjust;echo $?")
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
l_res = self.cv_LPAR.lpar_run_command("cat /etc/adjtime")
return BMC_CONST.FW_SUCCESS
else:
l_msg = "hwclock adjust function failed"
print l_msg
raise OpTestError(l_msg)
class OpTestSwitchEndianSyscall():
## Initialize this object
# @param i_bmcIP The IP address of the BMC
# @param i_bmcUser The userid to log into the BMC with
# @param i_bmcPasswd The password of the userid to log into the BMC with
# @param i_bmcUserIpmi The userid to issue the BMC IPMI commands with
# @param i_bmcPasswdIpmi The password of BMC IPMI userid
# @param i_ffdcDir Optional param to indicate where to write FFDC
#
# "Only required for inband tests" else Default = None
# @param i_lparIP The IP address of the LPAR
# @param i_lparuser The userid to log into the LPAR
# @param i_lparPasswd The password of the userid to log into the LPAR with
#
def __init__(self, i_bmcIP, i_bmcUser, i_bmcPasswd,
i_bmcUserIpmi, i_bmcPasswdIpmi, i_ffdcDir=None, i_lparip=None,
i_lparuser=None, i_lparPasswd=None):
self.cv_BMC = OpTestBMC(i_bmcIP, i_bmcUser, i_bmcPasswd, i_ffdcDir)
self.cv_IPMI = OpTestIPMI(i_bmcIP, i_bmcUserIpmi, i_bmcPasswdIpmi,
i_ffdcDir)
self.cv_LPAR = OpTestLpar(i_lparip, i_lparuser, i_lparPasswd,i_bmcIP)
self.util = OpTestUtil()
##
# @brief If git and gcc commands are availble on lpar, this function will clone linux
# git repository and check for switch_endian_test directory and make
# the required files. And finally execute bin file switch_endian_test.
#
# @return BMC_CONST.FW_SUCCESS-success or BMC_CONST.FW_FAILED-fail
#
def testSwitchEndianSysCall(self):
# Get OS level
self.cv_LPAR.lpar_get_OS_Level()
# Check whether git and gcc commands are available on lpar
self.cv_LPAR.lpar_check_command("git")
self.cv_LPAR.lpar_check_command("gcc")
# Clone latest linux git repository into l_dir
l_dir = "/tmp/linux"
self.cv_LPAR.lpar_clone_linux_source(l_dir)
# Check for switch_endian test directory.
self.check_dir_exists(l_dir)
# make the required files
self.make_test(l_dir)
# Run the switch_endian sys call test once
l_rc = self.run_once(l_dir)
if int(l_rc) == 1:
print "Switch endian sys call test got succesful"
return BMC_CONST.FW_SUCCESS
else:
print "Switch endian sys call test failed"
return BMC_CONST.FW_FAILED
##
# @brief It will check for existence of switch_endian directory in the cloned repository
#
# @param i_dir @type string: linux source directory
#
# @return 1-success or raise OpTestError
#
def check_dir_exists(self, i_dir):
l_dir = '%s/tools/testing/selftests/powerpc/switch_endian' % i_dir
l_cmd = "test -d %s; echo $?" % l_dir
print l_cmd
l_res = self.cv_LPAR.lpar_run_command(l_cmd)
print l_res
l_res = l_res.replace("\r\n", "")
if int(l_res) == 0:
print "Switch endian test directory exists"
return 1
else:
l_msg = "Switch endian directory is not present"
print l_msg
raise OpTestError(l_msg)
##
# @brief It will prepare for executable bin files using make command
# At the end it will check for bin file switch_endian_test and
# will throw an exception in case of missing bin file after make
#
# @param i_dir @type string: linux source directory
#
# @return 1-success or raise OpTestError
#
def make_test(self, i_dir):
l_cmd = "cd %s/tools/testing/selftests/powerpc/switch_endian;\
make;" % i_dir
print l_cmd
l_res = self.cv_LPAR.lpar_run_command(l_cmd)
l_cmd = "test -f %s/tools/testing/selftests/powerpc/switch_endian/switch_endian_test; echo $?" % i_dir
l_res = self.cv_LPAR.lpar_run_command(l_cmd)
l_res = l_res.replace("\r\n", "")
if int(l_res) == 0:
print "Executable binary switch_endian_test is available"
return 1
else:
l_msg = "Switch_endian_test bin file is not present after make"
print l_msg
raise OpTestError(l_msg)
##
# @brief This function will run executable file switch_endian_test and
# check for switch_endian() sys call functionality
#
# @param i_dir @type string: linux source directory
#
# @return 1-success ; 0-fail
#
def run_once(self, i_dir):
l_cmd = "cd %s/tools/testing/selftests/powerpc/switch_endian/;\
./switch_endian_test" % i_dir
print l_cmd
l_res = self.cv_LPAR.lpar_run_command(l_cmd)
if (l_res.__contains__('success: switch_endian_test')):
return 1
else:
return 0
class OpTestInbandIPMI():
## Initialize this object
# @param i_bmcIP The IP address of the BMC
# @param i_bmcUser The userid to log into the BMC with
# @param i_bmcPasswd The password of the userid to log into the BMC with
# @param i_bmcUserIpmi The userid to issue the BMC IPMI commands with
# @param i_bmcPasswdIpmi The password of BMC IPMI userid
# @param i_ffdcDir Optional param to indicate where to write FFDC
#
# "Only required for inband tests" else Default = None
# @param i_lparIP The IP address of the LPAR
# @param i_lparuser The userid to log into the LPAR
# @param i_lparPasswd The password of the userid to log into the LPAR with
#
def __init__(self, i_bmcIP, i_bmcUser, i_bmcPasswd,
i_bmcUserIpmi, i_bmcPasswdIpmi, i_ffdcDir=None, i_lparip=None,
i_lparuser=None, i_lparPasswd=None):
self.cv_BMC = OpTestBMC(i_bmcIP, i_bmcUser, i_bmcPasswd, i_ffdcDir)
self.cv_IPMI = OpTestIPMI(i_bmcIP, i_bmcUserIpmi, i_bmcPasswdIpmi,
i_ffdcDir)
self.cv_LPAR = OpTestLpar(i_lparip, i_lparuser, i_lparPasswd, i_bmcIP)
self.util = OpTestUtil()
##
# @brief This function will cover following test steps
# 1. It will get the OS level installed on powernv platform
# 2. It will check for kernel version installed on the Open Power Machine
# 3. It will check for ipmitool command existence and ipmitool package
# 4. Checking Inband ipmitool command functionality with different options
# using ipmitool.
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def test_ipmi_inband_functionality(self):
# Get OS level
l_oslevel = self.cv_LPAR.lpar_get_OS_Level()
# Get kernel version
l_kernel = self.cv_LPAR.lpar_get_kernel_version()
# Checking for ipmitool command and lm_sensors package
self.cv_LPAR.lpar_check_command("ipmitool")
l_pkg = self.cv_LPAR.lpar_check_pkg_for_utility(l_oslevel, "ipmitool")
print "Installed package: %s" % l_pkg
# Checking Inband ipmitool command functionality with different options
l_cmd = "ipmitool sdr; echo $?"
output = self.cv_LPAR.lpar_run_command(l_cmd)
response = output.splitlines()
if int(response[-1]):
l_msg = "ipmitool sdr not working,exiting...."
raise OpTestError(l_msg)
l_cmd = "ipmitool sdr elist full; echo $?"
output = self.cv_LPAR.lpar_run_command(l_cmd)
response = output.splitlines()
if int(response[-1]):
l_msg = "ipmitool sdr elist full not working,exiting...."
raise OpTestError(l_msg)
l_cmd = "ipmitool sdr type temperature; echo $?"
l_res = self.cv_LPAR.lpar_run_command(l_cmd)
if l_res.__contains__("Temp"):
print "ipmitool sdr type temperature is working"
else:
l_msg = "ipmitool sdr type temperature is not working"
raise OpTestError(l_msg)
l_cmd = "ipmitool lan print 1; echo $?"
output = self.cv_LPAR.lpar_run_command(l_cmd)
response = output.splitlines()
if int(response[-1]):
l_msg = "ipmitool lan print command is not working,exiting...."
raise OpTestError(l_msg)
l_cmd = "ipmitool fru print; echo $?"
output = self.cv_LPAR.lpar_run_command(l_cmd)
response = output.splitlines()
if int(response[-1]):
l_msg = "ipmitool fru print is not working,exiting...."
raise OpTestError(l_msg)
l_cmd = "ipmitool chassis status | grep \"System Power\""
l_res = self.cv_LPAR.lpar_run_command(l_cmd)
if l_res.__contains__("System Power : on"):
print "ipmitool Chassis status is working"
else:
l_msg = "ipmitool chassis status is not working"
raise OpTestError(l_msg)
l_cmd = "ipmitool chassis identify 1; echo $?"
l_res = self.cv_LPAR.lpar_run_command(l_cmd)
if l_res.__contains__("Chassis identify interval: 1 seconds"):
print "ipmitool Chassis identify interval is working"
else:
l_msg = "ipmitool Chassis identify interval is not working,exiting...."
raise OpTestError(l_msg)
l_cmd = "ipmitool chassis identify force; echo $?"
l_res = self.cv_LPAR.lpar_run_command(l_cmd)
if l_res.__contains__("Chassis identify interval: indefinite"):
print "ipmitool Chassis identify interval is working"
else:
l_msg = "ipmitool Chassis identify interval is not working"
raise OpTestError(l_msg)
l_cmd = "ipmitool sensor list; echo $?"
output = self.cv_LPAR.lpar_run_command(l_cmd)
response = output.splitlines()
if int(response[-1]):
l_msg = "ipmitool sensor list is not working,exiting...."
raise OpTestError(l_msg)
l_cmd = "ipmitool mc info; echo $?"
output = self.cv_LPAR.lpar_run_command(l_cmd)
response = output.splitlines()
if int(response[-1]):
l_msg = "ipmitool mc info is not working,exiting...."
raise OpTestError(l_msg)
l_cmd = "ipmitool mc selftest; echo $?"
l_res = self.cv_LPAR.lpar_run_command(l_cmd)
if l_res.__contains__("Selftest: passed"):
print "ipmitool mc selftest is passed"
else:
l_msg = "ipmitool mc selftest is failing"
raise OpTestError(l_msg)
l_cmd = "ipmitool mc getenables; echo $?"
output = self.cv_LPAR.lpar_run_command(l_cmd)
response = output.splitlines()
if int(response[-1]):
l_msg = "ipmitool mc getenables is not working,exiting...."
raise OpTestError(l_msg)
l_cmd = "ipmitool mc watchdog get; echo $?"
output = self.cv_LPAR.lpar_run_command(l_cmd)
response = output.splitlines()
if int(response[-1]):
l_msg = "ipmitool mc watchdog get is not working,exiting...."
raise OpTestError(l_msg)
l_cmd = "ipmitool sel info; echo $?"
output = self.cv_LPAR.lpar_run_command(l_cmd)
response = output.splitlines()
if int(response[-1]):
l_msg = "ipmitool sel info is not working,exiting...."
raise OpTestError(l_msg)
l_cmd = "ipmitool sel list; echo $?"
output = self.cv_LPAR.lpar_run_command(l_cmd)
response = output.splitlines()
if int(response[-1]):
l_msg = "ipmitool sel list is not working,exiting...."
raise OpTestError(l_msg)
l_cmd = "ipmitool sel list last 3 | grep \"PCI resource configuration\" | awk \'{ print $1 }\'"
output = self.cv_LPAR.lpar_run_command(l_cmd)
response = output.splitlines()
l_cmd = "ipmitool sel get 0x" + response[1] + "; echo $?"
output = self.cv_LPAR.lpar_run_command(l_cmd)
response = output.splitlines()
if int(response[-1]):
l_msg = "ipmitool sel get is not working,exiting...."
raise OpTestError(l_msg)
return BMC_CONST.FW_SUCCESS
class OpTestI2Cdriver():
## Initialize this object
# @param i_bmcIP The IP address of the BMC
# @param i_bmcUser The userid to log into the BMC with
# @param i_bmcPasswd The password of the userid to log into the BMC with
# @param i_bmcUserIpmi The userid to issue the BMC IPMI commands with
# @param i_bmcPasswdIpmi The password of BMC IPMI userid
# @param i_ffdcDir Optional param to indicate where to write FFDC
#
# "Only required for inband tests" else Default = None
# @param i_lparIP The IP address of the LPAR
# @param i_lparuser The userid to log into the LPAR
# @param i_lparPasswd The password of the userid to log into the LPAR with
#
def __init__(self, i_bmcIP, i_bmcUser, i_bmcPasswd,
i_bmcUserIpmi, i_bmcPasswdIpmi, i_ffdcDir=None, i_lparip=None,
i_lparuser=None, i_lparPasswd=None):
self.cv_BMC = OpTestBMC(i_bmcIP, i_bmcUser, i_bmcPasswd, i_ffdcDir)
self.cv_IPMI = OpTestIPMI(i_bmcIP, i_bmcUserIpmi, i_bmcPasswdIpmi,
i_ffdcDir)
self.cv_LPAR = OpTestLpar(i_lparip, i_lparuser, i_lparPasswd, i_bmcIP)
self.util = OpTestUtil()
##
# @brief This function has following test steps
# 1. Getting lpar information(OS and kernel info)
# 2. Checking the required utilites are present on lpar or not
# 3. Loading the necessary modules to test I2C device driver functionalites
# (i2c_dev, i2c_opal and at24)
# 4. Getting the list of i2c buses
# 5. Querying the i2c bus for devices
# 3. Getting the list of i2c buses and eeprom chip addresses
# 4. Accessing the registers visible through the i2cbus using i2cdump utility
# 5. Listing the i2c adapter conetents and i2c bus entries to make sure sysfs entries
# created for each bus.
# 6. Testing i2cget functionality for limited samples
# Avoiding i2cset functionality, it may damage the system.
#
# @return BMC_CONST.FW_SUCCESS-success or raise OpTestError-fail
#
def testI2Cdriver(self):
# Get OS level
self.cv_LPAR.lpar_get_OS_Level()
# make sure install "i2c-tools" package in-order to run the test
# Check whether i2cdump, i2cdetect and hexdump commands are available on lpar
self.cv_LPAR.lpar_check_command("i2cdump")
self.cv_LPAR.lpar_check_command("i2cdetect")
self.cv_LPAR.lpar_check_command("hexdump")
self.cv_LPAR.lpar_check_command("i2cget")
self.cv_LPAR.lpar_check_command("i2cset")
# Get Kernel Version
l_kernel = self.cv_LPAR.lpar_get_kernel_version()
# loading i2c_opal module based on config option
l_config = "CONFIG_I2C_OPAL"
l_module = "i2c_opal"
self.cv_LPAR.lpar_load_module_based_on_config(l_kernel, l_config, l_module)
# loading i2c_dev module based on config option
l_config = "CONFIG_I2C_CHARDEV"
l_module = "i2c_dev"
self.cv_LPAR.lpar_load_module_based_on_config(l_kernel, l_config, l_module)
# loading at24 module based on config option
l_config = "CONFIG_EEPROM_AT24"
l_module = "at24"
self.cv_LPAR.lpar_load_module_based_on_config(l_kernel, l_config, l_module)
# Get information of EEPROM chips
self.cv_LPAR.lpar_get_info_of_eeprom_chips()
# Get list of i2c buses available on lpar,
# l_list=["0","1"....]
# l_list1=["i2c-0","i2c-1","i2c-2"....]
l_list, l_list1 = self.cv_LPAR.lpar_get_list_of_i2c_buses()
# Scanning i2c bus for devices attached to it.
for l_bus in l_list:
self.query_i2c_bus(l_bus)
# Get list of pairs of i2c bus and EEPROM device addresses in the lpar
l_chips = self.cv_LPAR.lpar_get_list_of_eeprom_chips()
for l_args in l_chips:
# Accessing the registers visible through the i2cbus using i2cdump utility
# l_args format: "0 0x51","1 0x53",.....etc
self.i2c_dump(l_args)
# list i2c adapter conetents
l_res = self.cv_LPAR.lpar_run_command("ls -l /sys/class/i2c-adapter; echo $?")
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
pass
else:
l_msg = "listing i2c adapter contents through the sysfs entry failed"
print l_msg
raise OpTestError(l_msg)
# Checking the sysfs entry of each i2c bus
for l_bus in l_list1:
l_res = self.cv_LPAR.lpar_run_command("ls -l /sys/class/i2c-adapter/%s; echo $?" % l_bus)
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
pass
else:
l_msg = "listing i2c bus contents through the sysfs entry failed"
print l_msg
raise OpTestError(l_msg)
# Currently testing only getting the data from a data address, avoiding setting data.
# Only four samples are gathered to check whether reading eeprom data is working or not.
# Setting eeprom data is dangerous and make your system UNBOOTABLE
l_addrs = ["0x00", "0x10", "0x20", "0x30", "0x40", "0x50", "0x60", "0x70", "0x80", "0x90", "0xa0", "0xb0", "0xc0", "0xd0", "0xe0", "0xf0"]
for l_addr in l_addrs:
l_val = self.i2c_get(l_chips[1], l_addr)
# self.i2c_set(l_list2[1], l_addr, "0x50")
return BMC_CONST.FW_SUCCESS
##
# @brief This function query's the i2c bus for devices attached to it.
# i2cdetect is a utility to scan an I2C bus for devices
#
# @param i_bus @type string: i2c bus numer
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def query_i2c_bus(self, i_bus):
print "Querying the i2c bus for devices attached to it"
l_res = self.cv_LPAR.lpar_run_command("i2cdetect -y %i; echo $?" % int(i_bus))
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "Querying the i2cbus for devices failed:%s" % i_bus
print l_msg
raise OpTestError(l_msg)
##
# @brief This i2cdump function takes arguments in pair of a string like "i2cbus address".
# i2cbus indicates the number or name of the I2C bus to be scanned. This number should
# correspond to one of the busses listed by i2cdetect -l. address indicates
# the address to be scanned on that bus, and is an integer between 0x03 and 0x77
# i2cdump is a program to examine registers visible through the I2C bus
#
# @param i_args @type string: this is the argument to i2cdump utility
# args are in the form of "i2c-bus-number eeprom-chip-address"
# Ex: "0 0x51","3 0x52" ....etc
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def i2c_dump(self, i_args):
l_res = self.cv_LPAR.lpar_run_command("i2cdump -f -y %s; echo $?" % i_args)
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "i2cdump failed for the device: %s" % i_args
print l_msg
raise OpTestError(l_msg)
##
# @brief This function i2cget read from I2C/SMBus chip registers
# command usage: i2cget [-f] [-y] i2cbus chip-address [data-address [mode]]
#
# @param i_args @type string: this is the argument to i2cget utility
# args are in the form of "i2c-bus-number eeprom-chip-address"
# Ex: "0 0x51","3 0x52" ....etc
# @param i_addr @type string: this is the data-address on chip, from where data will be read
# Ex: "0x00","0x10","0x20"...
#
# @return l_res @type string: data present on data-address or raise OpTestError
#
def i2c_get(self, i_args, i_addr):
l_res = self.cv_LPAR.lpar_run_command("i2cget -f -y %s %s;echo $?" % (i_args, i_addr))
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return l_res
else:
l_msg = "i2cget: Getting data from address %s failed" % i_addr
print l_msg
raise OpTestError(l_msg)
##
# @brief This function i2cset will be used for setting I2C registers
# command usage: i2cset [-f] [-y] [-m mask] [-r] i2cbus chip-address data-address [value] ... [mode]
#
# @param i_args @type string: this is the argument to i2cset utility
# args are in the form of "i2c-bus-number eeprom-chip-address"
# Ex: "0 0x51","3 0x52" ....etc
# @param i_addr @type string: this is the data-address on chip, where data will be set
# Ex: "0x00","0x10","0x20"...
# @param i_val @type string: this is the value which will be set into data-address i_addr
#
# @return BMC_CONST.FW_SUCCESS or raise OpTestError
#
def i2c_set(self, i_args, i_addr, i_val):
l_res = self.cv_LPAR.lpar_run_command("i2cset -f -y %s %s %s;echo $?" % (i_args, i_addr, i_val))
l_res = l_res.splitlines()
if int(l_res[-1]) == 0:
return BMC_CONST.FW_SUCCESS
else:
l_msg = "i2cset: Setting the data to a address %s failed" % i_addr
print l_msg
raise OpTestError(l_msg)