From patchwork Mon Feb 22 15:24:12 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kieran Bingham X-Patchwork-Id: 62589 Delivered-To: patch@linaro.org Received: by 10.112.43.199 with SMTP id y7csp1302872lbl; Mon, 22 Feb 2016 07:24:47 -0800 (PST) X-Received: by 10.66.152.231 with SMTP id vb7mr38930646pab.132.1456154687283; Mon, 22 Feb 2016 07:24:47 -0800 (PST) Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id q77si40331681pfi.164.2016.02.22.07.24.46; Mon, 22 Feb 2016 07:24:47 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dkim=pass header.i=@linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754086AbcBVPYn (ORCPT + 30 others); Mon, 22 Feb 2016 10:24:43 -0500 Received: from mail-wm0-f51.google.com ([74.125.82.51]:35606 "EHLO mail-wm0-f51.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753395AbcBVPYk (ORCPT ); Mon, 22 Feb 2016 10:24:40 -0500 Received: by mail-wm0-f51.google.com with SMTP id c200so176833280wme.0 for ; Mon, 22 Feb 2016 07:24:39 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=CrUAFH/xIC9222SfcEmXWKp/pnio6VX93fooUPeEJGY=; b=hUPb5GsyhpMQwhqNjtKHeW5eVZzmrmNE8mDCNgTd7ORO/8v539c2BE4YEFomxpQDHL cq0LXBkBil0FdSvQ8cgosuxWS78NU4dnow2UivbZkFo44GNF8MUYbYohDixgLEHIgllW A02BAYG5Poz+HbaQ/zNbgm9HSUb6zt+Twc1DQ= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=CrUAFH/xIC9222SfcEmXWKp/pnio6VX93fooUPeEJGY=; b=kIFJbF3qyFV+aWVQevqvuLOaELUMwX6L7QrYlxe3E9aF/n/l5PfJAfdGC/OMPFeRT1 zom7mQFWnkLTw8HGwA1jPC1XluC0SGDy1zSo9hgv/J+CB4OelK6yMOOqCEWQNQKhBgvK JX6OSy0VfI7yZoJydMM33zJab7IRd+CaA+l1euKBAzP9pbJxvUqLNwKc79JCbDY/PXz0 5V7MNdo4QmaaSO98F1MlorjAmrNC9JCmhnjhGTDkoBp5GUEZxCFF31n/OGzVINtkGMH1 lfXXygyY6RvLgAohilXUmUYbi5hZIORA5jp/R0Ue1t0KVLrXB/qNiUyEX68zqjQV4Hkx 9GRA== X-Gm-Message-State: AG10YOS7YJ0Zj3hLCnlJ0bi3mr1nmCapf8wnBTi0IqqX2SgXl11mMgeF7UU5GqaYi/eTWq6R X-Received: by 10.194.113.38 with SMTP id iv6mr28353796wjb.126.1456154678845; Mon, 22 Feb 2016 07:24:38 -0800 (PST) Received: from localhost.localdomain (cpc87017-aztw30-2-0-cust65.18-1.cable.virginm.net. [92.232.232.66]) by smtp.gmail.com with ESMTPSA id w66sm21557528wmd.2.2016.02.22.07.24.38 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 22 Feb 2016 07:24:38 -0800 (PST) From: Kieran Bingham To: jan.kiszka@siemens.com, linux-kernel@vger.kernel.org Cc: lee.jones@linaro.org, peter.griffin@linaro.org, maxime.coquelin@st.com, Kieran Bingham Subject: [PATCH 8/8] scripts/gdb: Add meminfo command Date: Mon, 22 Feb 2016 15:24:12 +0000 Message-Id: <1456154652-29023-9-git-send-email-kieran.bingham@linaro.org> X-Mailer: git-send-email 2.5.0 In-Reply-To: <1456154652-29023-1-git-send-email-kieran.bingham@linaro.org> References: <1456154652-29023-1-git-send-email-kieran.bingham@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Provide an equivalent of /proc/meminfo which should be available from core dumps, or crashed kernels. This should allow a debugger to identify if memory pressures were applicable in the instance of their issue Signed-off-by: Kieran Bingham --- Changes from v1: - Updated to use LX_ macros for constants - Utilise the LX_CONFIG() options for conditional printing - Fixed meminfo command on Jan's target .config - Added missing segments to meminfo command (HUGEPAGE, QUICKLIST) - Adjusted for new list_for_each_entry() function - Fixed up for !CONFIG_SWAP and !CONFIG_MMU targets (Tested STM32) --- scripts/gdb/linux/constants.py.in | 34 ++++++ scripts/gdb/linux/proc.py | 219 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 253 insertions(+) -- 2.5.0 diff --git a/scripts/gdb/linux/constants.py.in b/scripts/gdb/linux/constants.py.in index 57213ad8cf75..66562a8242bd 100644 --- a/scripts/gdb/linux/constants.py.in +++ b/scripts/gdb/linux/constants.py.in @@ -12,8 +12,16 @@ * */ +#include +#include +#include + #include +#include #include +#include +#include + /* We need to stringify expanded macros so that they can be parsed */ @@ -51,3 +59,29 @@ LX_VALUE(MNT_NOATIME) LX_VALUE(MNT_NODIRATIME) LX_VALUE(MNT_RELATIME) +/* asm/page.h */ +LX_GDBPARSED(PAGE_SHIFT) + +/* asm/thread_info.h */ +LX_GDBPARSED(THREAD_SIZE) + +/* linux/vmalloc.h */ +LX_GDBPARSED(VMALLOC_TOTAL) + +/* linux/swap.h */ +LX_GDBPARSED(MAX_SWAPFILES) + + +/* Kernel Configs */ +LX_CONFIG(CONFIG_HIGHMEM) +LX_CONFIG(CONFIG_MEMORY_FAILURE) +LX_CONFIG(CONFIG_TRANSPARENT_HUGEPAGE) +LX_CONFIG(CONFIG_CMA) +LX_CONFIG(CONFIG_MMU) +LX_CONFIG(CONFIG_SWAP) + +#ifndef CONFIG_NR_QUICK +#define CONFIG_NR_QUICK 0 +#endif +LX_VALUE(CONFIG_NR_QUICK) +LX_CONFIG(CONFIG_QUICKLIST) diff --git a/scripts/gdb/linux/proc.py b/scripts/gdb/linux/proc.py index 44804e10493e..95933f66ea3e 100644 --- a/scripts/gdb/linux/proc.py +++ b/scripts/gdb/linux/proc.py @@ -204,3 +204,222 @@ values of that process namespace""" info_opts(MNT_INFO, m_flags))) LxMounts() + + +bdev_type = utils.CachedType("struct block_device") +bdev_ptr_type = bdev_type.get_type().pointer() + + +class LxMeminfo(gdb.Command): + """ Identify the memory usage, statistics, and availability + +Equivalent to cat /proc/meminfo on a running target """ + + def __init__(self): + super(LxMeminfo, self).__init__("lx-meminfo", gdb.COMMAND_DATA) + + def K(self, val): + # Convert from PAGES to KB + return int(val << (constants.LX_PAGE_SHIFT - 10)) + + def page_K(self, remote_value): + # Obtain page value, and Convert from PAGES to KB + val = int(gdb.parse_and_eval(remote_value)) + return self.K(val) + + def gps(self, enum_zone_stat_item): + # Access the Global Page State structure + # I would prefer to read this structure in one go and then index + # from the enum. But we can't determine the enum values with out + # a call to GDB anyway so we may as well take the easy route and + # get the value. + remote_value = "vm_stat[" + enum_zone_stat_item + "].counter" + return int(gdb.parse_and_eval(remote_value)) + + def gps_K(self, enum_zone_stat_item): + return self.K(self.gps(enum_zone_stat_item)) + + def nr_blockdev_pages(self): + bdevs_head = gdb.parse_and_eval("all_bdevs") + pages = 0 + for bdev in lists.list_for_each_entry(bdevs_head, bdev_ptr_type, "bd_list"): + try: + pages += bdev['bd_inode']['i_mapping']['nrpages'] + except: + # Any memory read failures are simply not counted + pass + return pages + + def total_swapcache_pages(self): + pages = 0 + if not constants.LX_CONFIG_SWAP: + return 0 + + for i in range(0, int(constants.LX_MAX_SWAPFILES)): + swap_space = "swapper_spaces[" + str(i) + "].nrpages" + pages += int(gdb.parse_and_eval(swap_space)) + return pages + + def vm_commit_limit(self, totalram_pages): + total_swap_pages = 0 + overcommit = int(gdb.parse_and_eval("sysctl_overcommit_kbytes")) + overcommit_ratio = int(gdb.parse_and_eval("sysctl_overcommit_ratio")) + + if constants.LX_CONFIG_SWAP: + total_swap_pages = int(gdb.parse_and_eval("total_swap_pages")) + + hugetlb_total_pages = 0 # hugetlb_total_pages() + + if overcommit: + allowed = overcommit >> (constants.LX_PAGE_SHIFT - 10) + else: + allowed = ((totalram_pages - hugetlb_total_pages * + overcommit_ratio / 100)) + + allowed += total_swap_pages + return allowed + + def quicklist_total_size(self): + count = 0 + quicklist = utils.gdb_eval_or_none("quicklist") + if quicklist is None: + return 0 + + for cpu in cpus.each_online_cpu(): + ql = cpus.per_cpu(quicklist, cpu) + for q in range(0, constants.LX_CONFIG_NR_QUICK): + # for (q = ql; q < ql + CONFIG_NR_QUICK; q++) + # count += q->nr_pages + count += ql[q]['nr_pages'] + + return count + + # Main lx-meminfo command execution + # See fs/proc/meminfo.c:meminfo_proc_show() + def invoke(self, arg, from_tty): + totalram = int(gdb.parse_and_eval("totalram_pages")) + freeram = self.gps("NR_FREE_PAGES") + reclaimable = self.gps("NR_SLAB_RECLAIMABLE") + unreclaimable = self.gps("NR_SLAB_UNRECLAIMABLE") + slab = reclaimable + unreclaimable + # for_each_zone(zone) + # wmark_low += zone->watermark[WMARK_LOW]; + wmark_low = 0 # Zone parsing is unimplemented + + available = freeram - wmark_low + available += reclaimable - min(reclaimable / 2, wmark_low) + + bufferram = self.nr_blockdev_pages() + total_swapcache_pages = self.total_swapcache_pages() + + file_pages = self.gps("NR_FILE_PAGES") + cached = file_pages - total_swapcache_pages - bufferram + + # LRU Pages + active_pages_anon = self.gps("NR_ACTIVE_ANON") + inactive_pages_anon = self.gps("NR_INACTIVE_ANON") + active_pages_file = self.gps("NR_ACTIVE_FILE") + inactive_pages_file = self.gps("NR_INACTIVE_FILE") + unevictable_pages = self.gps("NR_UNEVICTABLE") + active_pages = active_pages_anon + active_pages_file + inactive_pages = inactive_pages_anon + inactive_pages_file + + kernelstack = int(self.gps("NR_KERNEL_STACK") * + constants.LX_THREAD_SIZE / 1024) + + commitlimit = int(self.vm_commit_limit(totalram)) + committed_as = int(gdb.parse_and_eval("vm_committed_as.count")) + + vmalloc_total = int(constants.LX_VMALLOC_TOTAL >> 10) + + gdb.write( + "MemTotal: {:8d} kB\n".format(self.K(totalram)) + + "MemFree: {:8d} kB\n".format(self.K(freeram)) + + "MemAvailable: {:8d} kB\n".format(self.K(available)) + + "Buffers: {:8d} kB\n".format(self.K(bufferram)) + + "Cached: {:8d} kB\n".format(self.K(cached)) + + "SwapCached: {:8d} kB\n".format(self.K(total_swapcache_pages)) + + "Active: {:8d} kB\n".format(self.K(active_pages)) + + "Inactive: {:8d} kB\n".format(self.K(inactive_pages)) + + "Active(anon): {:8d} kB\n".format(self.K(active_pages_anon)) + + "Inactive(anon): {:8d} kB\n".format(self.K(inactive_pages_anon)) + + "Active(file): {:8d} kB\n".format(self.K(active_pages_file)) + + "Inactive(file): {:8d} kB\n".format(self.K(inactive_pages_file)) + + "Unevictable: {:8d} kB\n".format(self.K(unevictable_pages)) + + "Mlocked: {:8d} kB\n".format(self.gps_K("NR_MLOCK")) + ) + if constants.LX_CONFIG_HIGHMEM: + totalhigh = int(gdb.parse_and_eval("totalhigh_pages")) + freehigh = int(gdb.parse_and_eval("nr_free_highpages()")) + gdb.write( + "HighTotal: {:8d} kB\n".format(self.K(totalhigh)) + + "HighFree: {:8d} kB\n".format(self.K(freehigh)) + + "LowTotal: {:8d} kB\n".format(self.K(totalram-totalhigh)) + + "LowFree: {:8d} kB\n".format(self.K(freeram-freehigh)) + ) + if not constants.LX_CONFIG_MMU: + mmap_pages_allocated = gdb.parse_and_eval("mmap_pages_allocated.counter") + gdb.write( + "MmapCopy: {:8d} kB\n".format(self.K(mmap_pages_allocated)) + + ) + pass + + gdb.write( + "SwapTotal: {:8d} kB\n".format(self.K(0)) + + "SwapFree: {:8d} kB\n".format(self.K(0)) + + "Dirty: {:8d} kB\n".format(self.gps_K("NR_FILE_DIRTY")) + + "Writeback: {:8d} kB\n".format(self.gps_K("NR_WRITEBACK")) + + "AnonPages: {:8d} kB\n".format(self.gps_K("NR_ANON_PAGES")) + + "Mapped: {:8d} kB\n".format(self.gps_K("NR_FILE_MAPPED")) + + "Shmem: {:8d} kB\n".format(self.gps_K("NR_SHMEM")) + + "Slab: {:8d} kB\n".format(self.K(slab)) + + "SReclaimable: {:8d} kB\n".format(self.K(reclaimable)) + + "SUnreclaim: {:8d} kB\n".format(self.K(unreclaimable)) + + "KernelStack: {:8d} kB\n".format(kernelstack) + + "PageTables: {:8d} kB\n".format(self.gps_K("NR_PAGETABLE")) + ) + + if constants.LX_CONFIG_QUICKLIST: + quicklist = self.quicklist_total_size() + gdb.write( + "Quicklists: {:8d} kB\n".format(self.K(quicklist)) + ) + + gdb.write( + "NFS_Unstable: {:8d} kB\n".format(self.gps_K("NR_UNSTABLE_NFS")) + + "Bounce: {:8d} kB\n".format(self.gps_K("NR_BOUNCE")) + + "WritebackTmp: {:8d} kB\n".format(self.gps_K("NR_WRITEBACK_TEMP")) + ) + + gdb.write( + "CommitLimit: {:8d} kB\n".format(self.K(commitlimit)) + + "Committed_AS: {:8d} kB\n".format(self.K(committed_as)) + + "VmallocTotal: {:8d} kB\n".format(vmalloc_total) + ) + + # These are always zero now + gdb.write( + "VmallocUsed: {:8d} kB\n".format(0) + + "VmallocChunk: {:8d} kB\n".format(0) + ) + + if constants.LX_CONFIG_MEMORY_FAILURE: + gdb.write( + "HardwareCorrupted: {:8d} kB\n" + ) + if constants.LX_CONFIG_TRANSPARENT_HUGEPAGE: + huge = self.gps("NR_ANON_TRANSPARENT_HUGEPAGES") + # HPAGE_PMD_NR can not be determined in constants.py + gdb.write( + "AnonHugePages: {:8d} kB ( * HPAGE_PMD_NR )\n" + .format(self.K(huge)) + ) + if constants.LX_CONFIG_CMA: + totalcma_pages = int(gdb.parse_and_eval("totalcma_pages")) + gdb.write( + "CmaTotal: {:8d} kB\n".format(self.K(totalcma_pages)) + + "CmaFree: {:8d} kB\n".format(self.gps_K("NR_FREE_CMA_PAGES")) + ) + +LxMeminfo()