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