show_page_info.py

  1#!/usr/bin/env drgn
  2# SPDX-License-Identifier: GPL-2.0-only
  3# Copyright (C) 2025 Ye Liu <liuye@kylinos.cn>
  4
  5import argparse
  6import sys
  7from drgn import Object, FaultError, PlatformFlags, cast
  8from drgn.helpers.linux import find_task, follow_page, page_size
  9from drgn.helpers.linux.mm import (
 10    decode_page_flags, page_to_pfn, page_to_phys, page_to_virt, vma_find,
 11    PageSlab, PageCompound, PageHead, PageTail, compound_head, compound_order, compound_nr
 12)
 13from drgn.helpers.linux.cgroup import cgroup_name, cgroup_path
 14
 15DESC = """
 16This is a drgn script to show the page state.
 17For more info on drgn, visit https://github.com/osandov/drgn.
 18"""
 19
 20def format_page_data(page):
 21    """
 22    Format raw page data into a readable hex dump with "RAW:" prefix.
 23
 24    :param page: drgn.Object instance representing the page.
 25    :return: Formatted string of memory contents.
 26    """
 27    try:
 28        address = page.value_()
 29        size = prog.type("struct page").size
 30
 31        if prog.platform.flags & PlatformFlags.IS_64_BIT:
 32            word_size = 8
 33        else:
 34            word_size = 4
 35        num_words = size // word_size
 36
 37        values = []
 38        for i in range(num_words):
 39            word_address = address + i * word_size
 40            word = prog.read_word(word_address)
 41            values.append(f"{word:0{word_size * 2}x}")
 42
 43        lines = [f"RAW: {' '.join(values[i:i + 4])}" for i in range(0, len(values), 4)]
 44
 45        return "\n".join(lines)
 46
 47    except FaultError as e:
 48        return f"Error reading memory: {e}"
 49    except Exception as e:
 50        return f"Unexpected error: {e}"
 51
 52def get_memcg_info(page):
 53    """Retrieve memory cgroup information for a page."""
 54    try:
 55        MEMCG_DATA_OBJEXTS = prog.constant("MEMCG_DATA_OBJEXTS").value_()
 56        MEMCG_DATA_KMEM = prog.constant("MEMCG_DATA_KMEM").value_()
 57        mask = prog.constant('__NR_MEMCG_DATA_FLAGS').value_() - 1
 58        memcg_data = page.memcg_data.read_()
 59        if memcg_data & MEMCG_DATA_OBJEXTS:
 60            slabobj_ext = cast("struct slabobj_ext *", memcg_data & ~mask)
 61            memcg = slabobj_ext.objcg.memcg.value_()
 62        elif memcg_data & MEMCG_DATA_KMEM:
 63            objcg = cast("struct obj_cgroup *", memcg_data & ~mask)
 64            memcg = objcg.memcg.value_()
 65        else:
 66            memcg = cast("struct mem_cgroup *", memcg_data & ~mask)
 67
 68        if memcg.value_() == 0:
 69            return "none", "/sys/fs/cgroup/memory/"
 70        cgrp = memcg.css.cgroup
 71        return cgroup_name(cgrp).decode(), f"/sys/fs/cgroup/memory{cgroup_path(cgrp).decode()}"
 72    except FaultError as e:
 73        return "unknown", f"Error retrieving memcg info: {e}"
 74    except Exception as e:
 75        return "unknown", f"Unexpected error: {e}"
 76
 77def show_page_state(page, addr, mm, pid, task):
 78    """Display detailed information about a page."""
 79    try:
 80        print(f'PID: {pid} Comm: {task.comm.string_().decode()} mm: {hex(mm)}')
 81        try:
 82            print(format_page_data(page))
 83        except FaultError as e:
 84            print(f"Error reading page data: {e}")
 85        fields = {
 86            "Page Address": hex(page.value_()),
 87            "Page Flags": decode_page_flags(page),
 88            "Page Size": prog["PAGE_SIZE"].value_(),
 89            "Page PFN": hex(page_to_pfn(page).value_()),
 90            "Page Physical": hex(page_to_phys(page).value_()),
 91            "Page Virtual": hex(page_to_virt(page).value_()),
 92            "Page Refcount": page._refcount.counter.value_(),
 93            "Page Mapcount": page._mapcount.counter.value_(),
 94            "Page Index": hex(page.__folio_index.value_()),
 95            "Page Memcg Data": hex(page.memcg_data.value_()),
 96        }
 97
 98        memcg_name, memcg_path = get_memcg_info(page)
 99        fields["Memcg Name"] = memcg_name
100        fields["Memcg Path"] = memcg_path
101        fields["Page Mapping"] = hex(page.mapping.value_())
102        fields["Page Anon/File"] = "Anon" if page.mapping.value_() & 0x1 else "File"
103
104        try:
105            vma = vma_find(mm, addr)
106            fields["Page VMA"] = hex(vma.value_())
107            fields["VMA Start"] = hex(vma.vm_start.value_())
108            fields["VMA End"] = hex(vma.vm_end.value_())
109        except FaultError as e:
110            fields["Page VMA"] = "Unavailable"
111            fields["VMA Start"] = "Unavailable"
112            fields["VMA End"] = "Unavailable"
113            print(f"Error retrieving VMA information: {e}")
114
115        # Calculate the maximum field name length for alignment
116        max_field_len = max(len(field) for field in fields)
117
118        # Print aligned fields
119        for field, value in fields.items():
120            print(f"{field}:".ljust(max_field_len + 2) + f"{value}")
121
122        # Additional information about the page
123        if PageSlab(page):
124            print("This page belongs to the slab allocator.")
125
126        if PageCompound(page):
127            print("This page is part of a compound page.")
128            if PageHead(page):
129                print("This page is the head page of a compound page.")
130            if PageTail(page):
131                print("This page is the tail page of a compound page.")
132            print(f"{'Head Page:'.ljust(max_field_len + 2)}{hex(compound_head(page).value_())}")
133            print(f"{'Compound Order:'.ljust(max_field_len + 2)}{compound_order(page).value_()}")
134            print(f"{'Number of Pages:'.ljust(max_field_len + 2)}{compound_nr(page).value_()}")
135        else:
136            print("This page is not part of a compound page.")
137    except FaultError as e:
138        print(f"Error accessing page state: {e}")
139    except Exception as e:
140        print(f"Unexpected error: {e}")
141
142def main():
143    """Main function to parse arguments and display page state."""
144    parser = argparse.ArgumentParser(description=DESC, formatter_class=argparse.RawTextHelpFormatter)
145    parser.add_argument('pid', metavar='PID', type=int, help='Target process ID (PID)')
146    parser.add_argument('vaddr', metavar='VADDR', type=str, help='Target virtual address in hexadecimal format (e.g., 0x7fff1234abcd)')
147    args = parser.parse_args()
148
149    try:
150        vaddr = int(args.vaddr, 16)
151    except ValueError:
152        sys.exit(f"Error: Invalid virtual address format: {args.vaddr}")
153
154    try:
155        task = find_task(args.pid)
156        mm = task.mm
157        page = follow_page(mm, vaddr)
158
159        if page:
160            show_page_state(page, vaddr, mm, args.pid, task)
161        else:
162            sys.exit(f"Address {hex(vaddr)} is not mapped.")
163    except FaultError as e:
164        sys.exit(f"Error accessing task or memory: {e}")
165    except Exception as e:
166        sys.exit(f"Unexpected error: {e}")
167
168if __name__ == "__main__":
169    main()