History

scripts/gdb: implement x86_page_ops in mm.py

Implement all member functions of x86_page_ops strictly following the logic of aarch64_page_ops. This includes full support for SPARSEMEM and standard page translation functions. This fixes compatibility with 'lx-' commands on x86_64, preventing AttributeErrors when using lx-pfn_to_page and others.

Seongjun Hong committed 9 months ago

Commit 55f8b451 parent 5ed4b6b2 files · +173 −2Browse files

Unified · Split

2 files
  1. scripts/gdb/linux/constants.py.in +1 −1
  2. scripts/gdb/linux/mm.py +172 −1
scripts/gdb/linux/constants.py.in+1−1
@@ -150,8 +150,8 @@ LX_CONFIG(CONFIG_ARM64_64K_PAGES) · 149 unmodified lines
150if IS_BUILTIN(CONFIG_ARM64):150if IS_BUILTIN(CONFIG_ARM64):
151 LX_VALUE(CONFIG_ARM64_PA_BITS)151 LX_VALUE(CONFIG_ARM64_PA_BITS)
152 LX_VALUE(CONFIG_ARM64_VA_BITS)152 LX_VALUE(CONFIG_ARM64_VA_BITS)
153 LX_VALUE(CONFIG_PAGE_SHIFT)
154 LX_VALUE(CONFIG_ARCH_FORCE_MAX_ORDER)153 LX_VALUE(CONFIG_ARCH_FORCE_MAX_ORDER)
154LX_VALUE(CONFIG_PAGE_SHIFT)
155LX_CONFIG(CONFIG_SPARSEMEM)155LX_CONFIG(CONFIG_SPARSEMEM)
156LX_CONFIG(CONFIG_SPARSEMEM_EXTREME)156LX_CONFIG(CONFIG_SPARSEMEM_EXTREME)
157LX_CONFIG(CONFIG_SPARSEMEM_VMEMMAP)157LX_CONFIG(CONFIG_SPARSEMEM_VMEMMAP)
scripts/gdb/linux/mm.py+172−1
@@ -26,8 +26,179 @@ class page_ops(): · 25 unmodified lines
26 raise gdb.GdbError('Only support CONFIG_SPARSEMEM_VMEMMAP now')26 raise gdb.GdbError('Only support CONFIG_SPARSEMEM_VMEMMAP now')
27 if constants.LX_CONFIG_ARM64 and utils.is_target_arch('aarch64'):27 if constants.LX_CONFIG_ARM64 and utils.is_target_arch('aarch64'):
28 self.ops = aarch64_page_ops()28 self.ops = aarch64_page_ops()
29 elif utils.is_target_arch('x86_64') or utils.is_target_arch('x86-64'):
30 self.ops = x86_page_ops()
29 else:31 else:
30 raise gdb.GdbError('Only support aarch64 now')32 raise gdb.GdbError('Only support aarch64 and x86_64 now')
33
34class x86_page_ops():
35 def __init__(self):
36 self.struct_page_size = utils.get_page_type().sizeof
37 self.PAGE_SHIFT = constants.LX_CONFIG_PAGE_SHIFT
38 self.PAGE_SIZE = 1 << self.PAGE_SHIFT
39 self.PAGE_MASK = (~(self.PAGE_SIZE - 1)) & ((1 << 64) - 1)
40
41 self.PAGE_OFFSET = int(gdb.parse_and_eval("page_offset_base"))
42 self.VMEMMAP_START = int(gdb.parse_and_eval("vmemmap_base"))
43 self.PHYS_BASE = int(gdb.parse_and_eval("phys_base"))
44 self.START_KERNEL_map = 0xffffffff80000000
45
46 self.KERNEL_START = gdb.parse_and_eval("_text")
47 self.KERNEL_END = gdb.parse_and_eval("_end")
48
49 self.VMALLOC_START = int(gdb.parse_and_eval("vmalloc_base"))
50 if self.VMALLOC_START == 0xffffc90000000000:
51 self.VMALLOC_END = self.VMALLOC_START + (32 * 1024 * 1024 * 1024 * 1024) - 1
52 elif self.VMALLOC_START == 0xffa0000000000000:
53 self.VMALLOC_END = self.VMALLOC_START + (12800 * 1024 * 1024 * 1024 * 1024) - 1
54 else:
55 self.VMALLOC_END = self.VMALLOC_START + (12800 * 1024 * 1024 * 1024 * 1024) - 1
56
57 self.MAX_PHYSMEM_BITS = 46
58 self.SECTION_SIZE_BITS = 27
59 self.MAX_ORDER = 10
60
61 self.SECTIONS_SHIFT = self.MAX_PHYSMEM_BITS - self.SECTION_SIZE_BITS
62 self.NR_MEM_SECTIONS = 1 << self.SECTIONS_SHIFT
63 self.PFN_SECTION_SHIFT = self.SECTION_SIZE_BITS - self.PAGE_SHIFT
64 self.PAGES_PER_SECTION = 1 << self.PFN_SECTION_SHIFT
65 self.PAGE_SECTION_MASK = (~(self.PAGES_PER_SECTION - 1)) & ((1 << 64) - 1)
66
67 if constants.LX_CONFIG_SPARSEMEM_EXTREME:
68 self.SECTIONS_PER_ROOT = self.PAGE_SIZE // gdb.lookup_type("struct mem_section").sizeof
69 else:
70 self.SECTIONS_PER_ROOT = 1
71
72 self.NR_SECTION_ROOTS = DIV_ROUND_UP(self.NR_MEM_SECTIONS, self.SECTIONS_PER_ROOT)
73 self.SECTION_ROOT_MASK = self.SECTIONS_PER_ROOT - 1
74
75 try:
76 self.SECTION_HAS_MEM_MAP = 1 << int(gdb.parse_and_eval('SECTION_HAS_MEM_MAP_BIT'))
77 self.SECTION_IS_EARLY = 1 << int(gdb.parse_and_eval('SECTION_IS_EARLY_BIT'))
78 except:
79 self.SECTION_HAS_MEM_MAP = 1 << 0
80 self.SECTION_IS_EARLY = 1 << 3
81
82 self.SUBSECTION_SHIFT = 21
83 self.PAGES_PER_SUBSECTION = 1 << (self.SUBSECTION_SHIFT - self.PAGE_SHIFT)
84
85 if constants.LX_CONFIG_NUMA and constants.LX_CONFIG_NODES_SHIFT:
86 self.NODE_SHIFT = constants.LX_CONFIG_NODES_SHIFT
87 else:
88 self.NODE_SHIFT = 0
89
90 self.MAX_NUMNODES = 1 << self.NODE_SHIFT
91
92 self.vmemmap = gdb.Value(self.VMEMMAP_START).cast(utils.get_page_type().pointer())
93
94 def kasan_reset_tag(self, addr):
95 return addr
96
97 def SECTION_NR_TO_ROOT(self, sec):
98 return sec // self.SECTIONS_PER_ROOT
99
100 def __nr_to_section(self, nr):
101 root = self.SECTION_NR_TO_ROOT(nr)
102 mem_section = gdb.parse_and_eval("mem_section")
103 return mem_section[root][nr & self.SECTION_ROOT_MASK]
104
105 def pfn_to_section_nr(self, pfn):
106 return pfn >> self.PFN_SECTION_SHIFT
107
108 def section_nr_to_pfn(self, sec):
109 return sec << self.PFN_SECTION_SHIFT
110
111 def __pfn_to_section(self, pfn):
112 return self.__nr_to_section(self.pfn_to_section_nr(pfn))
113
114 def pfn_to_section(self, pfn):
115 return self.__pfn_to_section(pfn)
116
117 def subsection_map_index(self, pfn):
118 return (pfn & ~(self.PAGE_SECTION_MASK)) // self.PAGES_PER_SUBSECTION
119
120 def pfn_section_valid(self, ms, pfn):
121 if constants.LX_CONFIG_SPARSEMEM_VMEMMAP:
122 idx = self.subsection_map_index(pfn)
123 return test_bit(idx, ms['usage']['subsection_map'])
124 else:
125 return True
126
127 def valid_section(self, mem_section):
128 if mem_section != None and (mem_section['section_mem_map'] & self.SECTION_HAS_MEM_MAP):
129 return True
130 return False
131
132 def early_section(self, mem_section):
133 if mem_section != None and (mem_section['section_mem_map'] & self.SECTION_IS_EARLY):
134 return True
135 return False
136
137 def pfn_valid(self, pfn):
138 ms = None
139 if self.PHYS_PFN(self.PFN_PHYS(pfn)) != pfn:
140 return False
141 if self.pfn_to_section_nr(pfn) >= self.NR_MEM_SECTIONS:
142 return False
143 ms = self.__pfn_to_section(pfn)
144
145 if not self.valid_section(ms):
146 return False
147 return self.early_section(ms) or self.pfn_section_valid(ms, pfn)
148
149 def PFN_PHYS(self, pfn):
150 return pfn << self.PAGE_SHIFT
151
152 def PHYS_PFN(self, phys):
153 return phys >> self.PAGE_SHIFT
154
155 def __phys_to_virt(self, pa):
156 return pa + self.PAGE_OFFSET
157
158 def __virt_to_phys(self, va):
159 if va >= self.START_KERNEL_map:
160 return va - self.START_KERNEL_map + self.PHYS_BASE
161 else:
162 return va - self.PAGE_OFFSET
163
164 def virt_to_phys(self, va):
165 return self.__virt_to_phys(va)
166
167 def virt_to_page(self, va):
168 return self.pfn_to_page(self.virt_to_pfn(va))
169
170 def __pa(self, va):
171 return self.__virt_to_phys(va)
172
173 def __va(self, pa):
174 return self.__phys_to_virt(pa)
175
176 def pfn_to_kaddr(self, pfn):
177 return self.__va(pfn << self.PAGE_SHIFT)
178
179 def virt_to_pfn(self, va):
180 return self.PHYS_PFN(self.__virt_to_phys(va))
181
182 def sym_to_pfn(self, x):
183 return self.PHYS_PFN(self.__virt_to_phys(x))
184
185 def page_to_pfn(self, page):
186 return int(page.cast(utils.get_page_type().pointer()) - self.vmemmap)
187
188 def pfn_to_page(self, pfn):
189 return self.vmemmap + pfn
190
191 def page_to_phys(self, page):
192 return self.PFN_PHYS(self.page_to_pfn(page))
193
194 def page_to_virt(self, page):
195 return self.__va(self.page_to_phys(page))
196
197 def page_address(self, page):
198 return self.page_to_virt(page)
199
200 def folio_address(self, folio):
201 return self.page_address(folio['page'].address)
31 202
32class aarch64_page_ops():203class aarch64_page_ops():
33 def __init__(self):204 def __init__(self):