blob: 1ee049526a17f4c96a263a9c29a939183ae5f4e6 [file] [log] [blame]
#!/usr/bin/env python
Gives a rudimentary analysis of an OOM oops log. Only analyzes the first OOM
message seen in the provided input.
Usage: <oopslog>
cat <oopslog> |
# Copyright 2015 Broadcom Corporation
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License, version 2, as
# published by the Free Software Foundation (the "GPL").
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# General Public License for more details.
# A copy of the GPL is available at
# or
# Authors:
# Gregory Fong <>
from __future__ import print_function
from decode_gfpmask import gen_flags_dict, get_flag_names
import fileinput
import re
import sys
def main():
if len(sys.argv) > 1 and sys.argv[1] == "-h":
d_gfp = gen_flags_dict()
gfp_mask = None
order = None
free_kB = None
min_kB = None
free_cma_kB = None
free_highmem_kB = None
min_highmem_kB = None
free_highmem_cma_kB = None
lowmem_reserve = None
req_input_vars = ['gfp_mask', 'order', 'free_kB', 'min_kB',
# TODO: use actual PAGE_SIZE
PAGE_SIZE = 4096
for line in fileinput.input():
line = line.rstrip()
if gfp_mask is None:
m ="((?<=oom-killer: gfp_mask=)0x\w+),", line)
if (m):
gfp_mask = int(, 16)
if order is None:
m ="(?<=oom-killer: ).*order=(\d+),", line)
if (m):
order = int(
if free_kB is None:
m ="((?<=Normal free:)\d+)kB", line)
if (m):
free_kB = int(
if min_kB is None:
m ="(?<=Normal ).*min:(\d+)kB", line)
if (m):
min_kB = int(
if free_cma_kB is None:
m ="(?<=Normal free:).*((?<=free_cma:)\d+)kB", line)
if (m):
free_cma_kB = int(
if free_highmem_kB is None:
m ="((?<=HighMem free:)\d+)kB", line)
if (m):
free_highmem_kB = int(
if min_highmem_kB is None:
m ="(?<=HighMem ).*min:(\d+)kB", line)
if (m):
min_highmem_kB = int(
if free_highmem_cma_kB is None:
m ="(?<=HighMem free:).*((?<=free_cma:)\d+)kB", line)
if (m):
free_highmem_cma_kB = int(
if lowmem_reserve is None:
m ="(?<=lowmem_reserve\[\]: 0 )(\d+)", line)
if (m):
lowmem_reserve = int(
if any([eval(x) is None for x in req_input_vars]):
print("Error: Missing {} in input log".format(x))
gfp_flag_names = get_flag_names(d_gfp, gfp_mask)
has_cma = (free_cma_kB is not None) or \
(free_highmem_cma_kB is not None)
highmem = '___GFP_HIGHMEM' in gfp_flag_names
lowmem_reserve_kB = lowmem_reserve * PAGE_SIZE_kB
# assume page group by mobility enabled (see include/linux/gfp.h)
unmovable = not any(x in gfp_flag_names for x in
print("gfp_flags: 0x{:x}".format(gfp_mask))
print("Decoded gfp_flags: {}".format(" | ".join(gfp_flag_names)))
my_free_kB_calc = str(free_kB) # for building up calculation
print("Free mem in ZONE_NORMAL: {:d} kB.".format(free_kB))
if free_highmem_kB:
print("Free mem in ZONE_HIGHMEM: {:d} kB.".format(free_highmem_kB))
my_free_kB_calc += " + " + str(free_highmem_kB)
if unmovable and has_cma:
print("Migrate type is MIGRATE_UNMOVABLE, cannot use CMA pages")
print("Portion of ZONE_NORMAL which is CMA: {:d} kB."
free_kB -= free_cma_kB
my_free_kB_calc += " - " + str(free_cma_kB)
if free_highmem_cma_kB:
free_highmem_kB -= free_highmem_cma_kB
my_free_kB_calc += " - " + str(free_highmem_cma_kB)
print("Portion of ZONE_HIGHMEM which is CMA: {:d} kB."
my_free_kB = free_kB + free_highmem_kB
print("Total free: {} = {:d} kB.".format(my_free_kB_calc, my_free_kB))
my_min_kB = min_kB
my_min_kB_calc = str(min_kB)
if highmem and min_highmem_kB:
my_min_kB += min_highmem_kB
my_min_kB_calc += " + " + str(min_highmem_kB)
print("Minimum RAM allowed: {} = {} kB".format(my_min_kB_calc, my_min_kB))
if highmem and lowmem_reserve_kB:
print("__GFP_HIGHMEM was set, must also exclude lowmem_reserve: {} kB"
print("Did we have enough memory?")
had_enough_memory_lhs = my_free_kB - (PAGE_SIZE_kB << order)
calc_lhs = str(my_free_kB) + " - " + str(PAGE_SIZE_kB << order)
calcstr_lhs = "my_free_kB - (PAGE_SIZE_kB << order)"
had_enough_memory_rhs = my_min_kB
calc_rhs = str(my_min_kB)
calcstr_rhs = "my_min_kB"
if highmem:
had_enough_memory_rhs += lowmem_reserve_kB
calc_rhs += " + " + str(lowmem_reserve_kB)
calcstr_rhs += " + lowmem_reserve_kB"
print("Test: {} > {}".format(calcstr_lhs, calcstr_rhs))
print(" {} > {}".format(calc_lhs, calc_rhs))
had_enough_memory = had_enough_memory_lhs > had_enough_memory_rhs
if had_enough_memory:
print("*Yes*, had enough memory at time of OOM.")
print("*No*, not enough memory at time of OOM.")
print("Possible causes of OOM:")
if had_enough_memory:
print("- Allocation order was {}.".format(order),
"Check freelist for that order and higher in the Mem-info.")
if (unmovable and has_cma):
print(" Note that this allocation is NOT allowed to use CMA",
"pages (marked 'C').")
if highmem and free_highmem_kB:
# TODO: check whether this was caused by having enough memory
# in the sum of highmem and lowmem but not in either one
# TODO: more sophisticated analysis of allocation order
# that looks at freelist. Maybe something like
# if > 90% of free pages are in order 0 and order 1 blocks
# and this is a higher-order allocation:
# Report that this might be a core MM bug causing excessive
# fragmentation, please report to STB Linux team
print("- If this took some time to fail, could be a memory leak in a",
"kernel module.")
if (highmem):
print("- lowmem_reserve might be too high. Try tweaking",
if (unmovable and has_cma):
print("- May not have enough lowmem outside of a CMA region.",
"You may need to decrease the size of a region in lowmem.")
if __name__ == "__main__":