def check_capture_kernel_memory_allocation(self): """Memory allocated for capture kernel""" status = None allocated_mem_size = None kexec_crash_size = "/sys/kernel/kexec_crash_size" mem_alloc_capture_kernel = get_file_content(kexec_crash_size) self.log.debug("kexec crash size %s: %s", kexec_crash_size, mem_alloc_capture_kernel) if mem_alloc_capture_kernel is None: self.log.error("Memory allocation to capture kernel failed") status = False else: try: allocated_mem_size = int( mem_alloc_capture_kernel) / 1024 / 1024 status = self.is_capture_kernel_memory_sufficient( allocated_mem_size) except ValueError as value_error: self.log.error("Invalid crash size found %s, error: %s", kexec_crash_size, value_error) status = False kdump_mem = SysfsCheck( self.check_capture_kernel_memory_allocation.__doc__, kexec_crash_size, status) kdump_mem.set_sysfs_value_found(allocated_mem_size) kdump_mem.set_sysfs_expected_value( self.get_required_mem_for_capture_kernel()) return kdump_mem
def check_htx_installation_path(self): """HTX Installation path""" installation_path_exists = True if os.path.isfile(self.installation_path): htx_install_dir = get_file_content(self.installation_path) if (htx_install_dir is None) or \ (not os.path.isdir(htx_install_dir)): self.log.error("Missing HTX installation directory %s", htx_install_dir) installation_path_exists = False else: self.log.error("Unable to locate %s file", self.installation_path) installation_path_exists = False return Check(self.check_htx_installation_path.__doc__, installation_path_exists)
def check_fadump_registered(self): """FADump registration check""" status = True sys_kernel_fadump_registered = "/sys/kernel/fadump_registered" fadump_registered = get_file_content(sys_kernel_fadump_registered) try: if fadump_registered is None or int(fadump_registered) != 1: self.log.error("FADump is not registered") status = False else: self.log.info("FADump is registered") except ValueError as value_error: self.log.debug("Invalid data found in file %s, error: %s", sys_kernel_fadump_registered, value_error) status = False return SysfsCheck(self.check_fadump_registered.__doc__, sys_kernel_fadump_registered, status)
def check_is_kexec_crash_loaded(self): """Capture kernel load status""" status = True kexec_crash_loaded = "/sys/kernel/kexec_crash_loaded" try: kexec_crash_status = int(get_file_content(kexec_crash_loaded)) if kexec_crash_status is None or kexec_crash_status != 1: self.log.error("Capture kernel is unavailable") status = False except ValueError as value_error: self.log.error("Invalid data found in file %s, error: %s", kexec_crash_loaded, value_error) status = False kexec_crash_loaded = SysfsCheck( self.check_is_kexec_crash_loaded.__doc__, kexec_crash_loaded, status) kexec_crash_loaded.set_sysfs_value_found(int(kexec_crash_status)) kexec_crash_loaded.set_sysfs_expected_value(1) return kexec_crash_loaded
def get_mem_reserved(self): """Returns the size of memory reserved by fadump in MB""" fadump_mem_file = "/sys/kernel/fadump_mem_reserved" if os.path.exists(fadump_mem_file): fadump_mem = get_file_content(fadump_mem_file) if fadump_mem is None: self.log.debug("Unable to get fadump mem size from %s", fadump_mem_file) return None else: try: self.log.debug("%s: %s", fadump_mem_file, fadump_mem) return int(fadump_mem) / 1024 / 1024 except Exception: self.log.debug("Invalid value (%s) found in %s file:", fadump_mem, fadump_mem_file) return None fadump_region_file = "/sys/kernel/debug/powerpc/fadump_region" if not os.path.exists(fadump_region_file): debugfs = "/sys/kernel/debug" command = ["mount", "-t", "debugfs", "nodev", debugfs] self.log.debug("Mounting %s", debugfs) if execute_command(command)[0] != 0: self.log.debug("Unable to mount %s", debugfs) return None if not os.path.exists(fadump_region_file): self.log.debug("%s file not found", fadump_region_file) return None fadump_regions = get_file_content(fadump_region_file) if fadump_regions is None: return None fadump_mem = 0 for region in fadump_regions.split('\n'): self.log.debug("Fadump region(%s)", region) region = region.strip() try: if region.startswith("CPU") or region.startswith("HPTE"): region_size = region[region.find(':') + 1:len(region)].strip().split()[1] elif region.startswith("DUMP"): region_list = region.split() if len(region_list) > 6: region_size = region_list[4][:-1] else: region_size = region_list[2] else: self.log.warning("Unknown Fadump region(%s)", region) continue fadump_mem = fadump_mem + int(region_size, 16) except Exception: self.log.debug("Unable to parse %s", fadump_region_file) return None self.log.debug("Fadump mem from (%s): %s bytes", fadump_region_file, fadump_mem) return fadump_mem / 1024 / 1024