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() 170