Exemplo n.º 1
0
    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
Exemplo n.º 2
0
    def check_mem_reservation(self):
        """Memory reservation"""

        status = True

        mem_needed = self.get_crash_mem_needed()
        mem_reserved = self.get_mem_reserved()

        if mem_needed is None or mem_reserved is None:
            status = None
        elif mem_needed > mem_reserved:
            self.log.error("Memory reserved for FADump is insufficient")
            self.log.recommendation("Increase the memory reservation to %d MB",
                                    mem_needed)
            status = False

        if status:
            self.log.info("Sufficient memory reserved for dump collection")

        mem_reserve_check = SysfsCheck(self.check_mem_reservation.__doc__, "",
                                       status)
        mem_reserve_check.set_sysfs_value_found(mem_reserved)
        mem_reserve_check.set_sysfs_expected_value(mem_needed)

        return mem_reserve_check
Exemplo n.º 3
0
    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