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)
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()
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
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 OpTestIPMILockMode(): ## 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 will cover following test steps # 1. It will get the OS level installed on power 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. Load the necessary ipmi modules based on config values # 5. Issue a ipmi lock command through out-of-band authenticated interface # 6. Now BMC IPMI is in locked mode, at this point only white listed # in-band ipmi commands sholud work(No other in-band ipmi command should work) # 7. Execute and test the functionality of whitelisted in-band ipmi # commands in locked mode # 8. At the end of test issue a ipmi unlock command to revert the availablity of all # in-band ipmi commands in unlocked mode. # # @return BMC_CONST.FW_SUCCESS or raise OpTestError # def test_ipmi_lock_mode(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 # loading below ipmi modules based on config option # ipmi_devintf, ipmi_powernv and ipmi_masghandler self.cv_LPAR.lpar_load_module_based_on_config(l_kernel, BMC_CONST.CONFIG_IPMI_DEVICE_INTERFACE, BMC_CONST.IPMI_DEV_INTF) self.cv_LPAR.lpar_load_module_based_on_config(l_kernel, BMC_CONST.CONFIG_IPMI_POWERNV, BMC_CONST.IPMI_POWERNV) self.cv_LPAR.lpar_load_module_based_on_config(l_kernel, BMC_CONST.CONFIG_IPMI_HANDLER, BMC_CONST.IPMI_MSG_HANDLER) # Issue a ipmi lock command through authenticated interface print "Issuing ipmi lock command through authenticated interface" l_res = self.cv_IPMI.ipmitool_execute_command(BMC_CONST.IPMI_LOCK_CMD) l_res = l_res.splitlines() if int(l_res[-1]): l_msg = "IPMI:Lock command failed, There may be two reasons here.\n\ a. check the corresponding parches available in AMI driver code,\n\ b. if patches available then command is failing" print l_msg raise OpTestError(l_msg) print "IPMI:Lock command executed successfully" try: self.run_inband_ipmi_whitelisted_cmds() except: l_msg = "One of white listed in-band ipmi command execution failed" print sys.exc_info() finally: # Issue a ipmi unlock command at the end of test. print "Issuing ipmi unlock command through authenticated interface" self.cv_IPMI.ipmitool_execute_command(BMC_CONST.IPMI_UNLOCK_CMD) ## # @brief This function will execute whitelisted in-band ipmi commands # and test the functionality in locked mode. # # @return BMC_CONST.FW_SUCCESS or raise OpTestError # def run_inband_ipmi_whitelisted_cmds(self): 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") # Test IPMI white listed commands those should be allowed through un-authenticated # in-band interface # 1.[App] Get Device ID print "Testing Get Device ID command" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_DEVICE_ID) if l_res[-1] != "0": l_msg = "IPMI: Get Device ID command failed" raise OpTestError(l_msg) # 2.[App] Get Device GUID print "Testing Get Device GUID" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_DEVICE_GUID) if l_res[-1] != "0": l_msg = "IPMI: Get Device GUID command failed" raise OpTestError(l_msg) # 3.[App] Get System GUID print "Testing Get system GUID" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_SYSTEM_GUID) if l_res[-1] != "0": l_msg = "IPMI: Get System GUID command failed" raise OpTestError(l_msg) # 4.[Storage] Get SEL info print "Testing Get SEL info" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_SEL_INFO) if l_res[-1] != "0": l_msg = "IPMI: Get SEL info command failed" raise OpTestError(l_msg) # 5.[Storage] Get SEL time print "Testing Get SEL time" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_SEL_TIME_RAW) if l_res[-1] != "0": l_msg = "IPMI: Get SEL time command failed" raise OpTestError(l_msg) # 6. [Storage] Reserve SEL print "Testing Reserve SEL" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_RESERVE_SEL) if l_res[-1] != "0": l_msg = "IPMI: Reserve SEL command failed" raise OpTestError(l_msg) # 7. [Storage] Set SEL time (required for RTC) print "Testing Set SEL time" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_SEL_TIME) l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_SET_SEL_TIME + " \'" + l_res[-1] + "\'; echo $?") if l_res[-1] != "0": l_msg = "IPMI: Set SEL time command failed" raise OpTestError(l_msg) self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_SEL_TIME) # 8. [Transport] Get LAN parameters print "Testing Get LAN parameters" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_LAN_PARAMETERS) if l_res[-1] != "0": l_msg = "IPMI: Get LAN parameters command failed" raise OpTestError(l_msg) # 9.[Chassis] Get System Boot Options print "Testing Get System Boot Options" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_SYSTEM_BOOT_OPTIONS) if l_res[-1] != "0": l_msg = "IPMI: Get System Boot Options command failed" raise OpTestError(l_msg) # 10.[Chassis] Set System Boot Options print "Testing Set System Boot Options" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_SET_SYTEM_BOOT_OPTIONS) if l_res[-1] != "0": l_msg = "IPMI: Set System Boot Options command failed" raise OpTestError(l_msg) self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_SYSTEM_BOOT_OPTIONS) # 11. [App] Get BMC Global Enables print "Testing Get BMC Global Enables" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_BMC_GLOBAL_ENABLES_RAW) if l_res[-1] != "0": l_msg = "IPMI: Get BMC Global Enables command failed" raise OpTestError(l_msg) self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_BMC_GLOBAL_ENABLES) # 12. [App] Set BMC Global Enables print "Testing Set BMC Global Enables" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_SET_BMC_GLOBAL_ENABLES_SEL_OFF) if l_res[-1] != "0": l_msg = "IPMI: Set BMC Global Enables sel=off command failed" raise OpTestError(l_msg) self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_BMC_GLOBAL_ENABLES) self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_SET_BMC_GLOBAL_ENABLES_SEL_ON) # 13.[App] Get System Interface Capabilities print "Testing Get System Interface Capabilities" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_SYSTEM_INTERFACE_CAPABILITIES_SSIF) if l_res[-1] != "0": l_msg = "IPMI: Get System Interface Capabilities SSIF command failed" raise OpTestError(l_msg) l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_SYSTEM_INTERFACE_CAPABILITIES_KCS) if l_res[-1] != "0": l_msg = "IPMI: Get System Interface Capabilities KCS command failed" raise OpTestError(l_msg) # 14.[App] Get Message Flags print "Testing Get Message Flags" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_MESSAGE_FLAGS) if l_res[-1] != "0": l_msg = "IPMI: Get Message Flags command failed" raise OpTestError(l_msg) # 15. [App] Get BT Capabilities print "Testing Get BT Capabilities" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_BT_CAPABILITIES) if l_res[-1] != "0": l_msg = "IPMI: Get BT Capabilities command failed" raise OpTestError(l_msg) # 16. [App] Clear Message Flags print "Testing Clear Message Flags" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_CLEAR_MESSAGE_FLAGS) if l_res[-1] != "0": l_msg = "IPMI: Clear Message Flags command failed" raise OpTestError(l_msg) # 17. [OEM] PNOR Access Status print "Testing the PNOR Access Status" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_PNOR_ACCESS_STATUS_DENY) if l_res[-1] != "0": l_msg = "IPMI: PNOR Access Status:deny command failed" raise OpTestError(l_msg) l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_PNOR_ACCESS_STATUS_GRANT) if l_res[-1] != "0": l_msg = "IPMI: PNOR Access Status:grant command failed" raise OpTestError(l_msg) # 18. [Storage] Add SEL Entry print "Testing Add SEL Entry" print "Clearing the SEL list" self.cv_IPMI.ipmi_sdr_clear() l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_ADD_SEL_ENTRY) if l_res[-1] != "0": l_msg = "IPMI: Add SEL Entry command failed" raise OpTestError(l_msg) l_res = self.cv_IPMI.ipmitool_execute_command(BMC_CONST.IPMI_LIST_LAST_SEL_EVENT) print "Checking for Reserved entry creation in SEL" if "Reserved" not in l_res: l_msg = "IPMI: Add SEL Entry command, doesn't create an SEL event" raise OpTestError(l_msg) # 19. [App] Set Power State print "Testing Set Power State" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_SET_ACPI_POWER_STATE) if l_res[-1] != "0": l_msg = "IPMI: Set Power State command failed" raise OpTestError(l_msg) # 20. [App] Set watchdog print "Testing Set watchdog" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_SET_WATCHDOG) if l_res[-1] != "0": l_msg = "IPMI: Set watchdog command failed" raise OpTestError(l_msg) self.cv_IPMI.ipmitool_execute_command(BMC_CONST.IPMI_MC_WATCHDOG_GET) # 21. [Sensor/Event] Get Sensor Type print "Testing Get Sensor Type" l_res = self.cv_IPMI.ipmitool_execute_command(BMC_CONST.IPMI_SDR_GET_WATCHDOG) matchObj = re.search( "Watchdog \((0x\d{1,})\)", l_res) if matchObj: print "Got sensor Id for watchdog: %s" % matchObj.group(1) else: l_msg = "Failed to get sensor id for watchdog sensor" raise OpTestError(l_msg) l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_SENSOR_TYPE_FOR_WATCHDOG + " " + matchObj.group(1) + " ;echo $?") if l_res[-1] != "0": l_msg = "IPMI: Get Sensor Type command failed" raise OpTestError(l_msg) # 22.[Sensor/Event] Get Sensor Reading print "Testing Get Sensor Reading" l_res = self.cv_IPMI.ipmitool_execute_command(BMC_CONST.IPMI_SDR_GET_WATCHDOG) matchObj = re.search( "Watchdog \((0x\d{1,})\)", l_res) if matchObj: print "Got sensor Id for watchdog: %s" % matchObj.group(1) else: l_msg = "Failed to get sensor id for watchdog sensor" raise OpTestError(l_msg) l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_SENSOR_READING + " " + matchObj.group(1) + " ;echo $?") if l_res[-1] != "0": l_msg = "IPMI: Get Sensor Reading command failed" raise OpTestError(l_msg) # 23.[Sensor/Event] Platform Event (0x02) print "Testing Platform Event" self.cv_IPMI.ipmi_sdr_clear() l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_PLATFORM_EVENT) if l_res[-1] != "0": l_msg = "IPMI: Platform Event command failed" raise OpTestError(l_msg) l_res = self.cv_IPMI.ipmitool_execute_command(BMC_CONST.IPMI_LIST_LAST_SEL_EVENT) if "Reserved" not in l_res: l_msg = "IPMI: Platform Event command failed to log SEL event" raise OpTestError(l_msg) # 24. [OEM] PNOR Access Response (0x08) print "Testing PNOR Access Response" self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_PNOR_ACCESS_STATUS_GRANT) l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_PNOR_ACCESS_RESPONSE) if l_res[-1] != "0": l_msg = "IPMI: PNOR Access Response command failed" raise OpTestError(l_msg) self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_PNOR_ACCESS_STATUS_DENY) l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_PNOR_ACCESS_RESPONSE) if l_res[-1] != "0": l_msg = "IPMI: PNOR Access Response command failed" raise OpTestError(l_msg) # 25.[Chassis] Chassis Control print "Testing chassis power on" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_CHASSIS_POWER_ON) if l_res[-1] != "0": l_msg = "IPMI: chassis power on command failed" raise OpTestError(l_msg) # 26.[App] 0x38 Get Channel Authentication Cap print "Testing Get Channel Authentication Capabilities" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_CHANNEL_AUTH_CAP) if l_res[-1] != "0": l_msg = "IPMI: Get Channel Authentication Capabilities command failed" raise OpTestError(l_msg) # 27.[App] Reset Watchdog (0x22) print "Testing reset watchdog" self.cv_IPMI.ipmi_sdr_clear() l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_RESET_WATCHDOG) if l_res[-1] != "0": l_msg = "IPMI: Reset Watchdog command failed" raise OpTestError(l_msg) time.sleep(10) # Reset watchdog should create a SEL event log l_res = self.cv_IPMI.ipmitool_execute_command(BMC_CONST.IPMI_LIST_LAST_SEL_EVENT) if "Watchdog" not in l_res: l_msg = "IPMI: Reset Watchdog command, doesn't create an SEL event" raise OpTestError(l_msg) # 28. [App] Get ACPI Power State (0x06) print "Testing Get ACPI Power State" l_res = self.cv_IPMI.run_lpar_cmd_on_ipmi_console(BMC_CONST.LPAR_GET_ACPI_POWER_STATE) if l_res[-1] != "0": l_msg = "IPMI: Get ACPI Power State command failed" raise OpTestError(l_msg)
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)