1use kh_runtime::GuestPageSize;
4
5#[derive(Debug, Clone, PartialEq, Eq)]
7#[allow(clippy::struct_excessive_bools)]
8pub struct MachOSummary {
9 pub path: String,
11 pub fat: bool,
13 pub file_slice_offset: u64,
18 pub cpu: String,
20 pub file_type: String,
22 pub file_type_raw: u32,
24 pub flags: u32,
26 pub ncmds: u32,
28 pub sizeofcmds: u32,
30 pub entry: Option<u64>,
32 pub old_style_entry: bool,
34 pub uuid: Option<String>,
36 pub minos: Option<String>,
38 pub platform: Option<String>,
40 pub is_64: bool,
42 pub little_endian: bool,
44}
45
46#[derive(Debug, Clone, PartialEq, Eq)]
48pub struct SegmentInfo {
49 pub name: String,
51 pub vmaddr: u64,
53 pub vmsize: u64,
55 pub fileoff: u64,
57 pub filesize: u64,
59 pub maxprot: u32,
61 pub initprot: u32,
63 pub sections: Vec<SectionInfo>,
65}
66
67#[derive(Debug, Clone, PartialEq, Eq)]
69pub struct SectionInfo {
70 pub name: String,
72 pub segname: String,
74 pub addr: u64,
76 pub size: u64,
78 pub offset: u32,
80 pub align: u32,
82 pub flags: u32,
84}
85
86#[derive(Debug, Clone, Copy, PartialEq, Eq)]
88pub enum DylibKind {
89 Load,
91 Weak,
93 Reexport,
95 Lazy,
97 Upward,
99 Id,
101}
102
103impl DylibKind {
104 #[must_use]
106 pub const fn as_str(self) -> &'static str {
107 match self {
108 Self::Load => "load",
109 Self::Weak => "weak",
110 Self::Reexport => "reexport",
111 Self::Lazy => "lazy",
112 Self::Upward => "upward",
113 Self::Id => "id",
114 }
115 }
116}
117
118#[derive(Debug, Clone, PartialEq, Eq)]
120pub struct DylibDep {
121 pub kind: DylibKind,
123 pub name: String,
125}
126
127#[derive(Debug, Clone, PartialEq, Eq)]
129pub struct LoadCommandInfo {
130 pub index: u32,
132 pub name: String,
134 pub cmdsize: u32,
136 pub detail: Option<String>,
138}
139
140#[derive(Debug, Clone, PartialEq, Eq)]
142pub struct MachOImage {
143 pub summary: MachOSummary,
145 pub segments: Vec<SegmentInfo>,
147 pub dylibs: Vec<DylibDep>,
149 pub load_commands: Vec<LoadCommandInfo>,
151 pub rpaths: Vec<String>,
153}
154
155impl MachOImage {
156 #[must_use]
158 pub fn summary(&self) -> &MachOSummary {
159 &self.summary
160 }
161
162 #[must_use]
164 pub fn dylibs_matching(&self, find: Option<&str>) -> Vec<&DylibDep> {
165 self.dylibs
166 .iter()
167 .filter(|dep| find.is_none_or(|needle| dep.name.contains(needle)))
168 .collect()
169 }
170
171 #[must_use]
173 pub fn plan(&self, guest: GuestPageSize) -> ImagePlan {
174 ImagePlan::from_image(self, guest)
175 }
176}
177
178#[derive(Debug, Clone, PartialEq, Eq)]
180pub struct PlannedMapping {
181 pub name: String,
183 pub vmaddr: u64,
185 pub vmsize: u64,
187 pub fileoff: u64,
189 pub filesize: u64,
191 pub guest_aligned_addr: u64,
193 pub guest_aligned_end: u64,
195 pub initprot: u32,
197 pub maxprot: u32,
199 pub vmaddr_guest_aligned: bool,
201 pub vmsize_guest_aligned: bool,
203}
204
205#[derive(Debug, Clone, PartialEq, Eq)]
207pub struct ImagePlan {
208 pub guest_page_size: u32,
210 pub preferred_base: u64,
212 pub entry: Option<u64>,
214 pub mappings: Vec<PlannedMapping>,
216 pub fully_guest_aligned: bool,
218}
219
220impl ImagePlan {
221 #[inline]
223 #[must_use]
224 pub const fn empty() -> Self {
225 Self {
226 guest_page_size: 0,
227 preferred_base: 0,
228 entry: None,
229 mappings: Vec::new(),
230 fully_guest_aligned: true,
231 }
232 }
233
234 #[must_use]
236 pub fn from_image(image: &MachOImage, guest: GuestPageSize) -> Self {
237 use kh_runtime::PageLayout;
238
239 let guest_page = guest.bytes();
240 let mut preferred_base = u64::MAX;
241 let mut mappings = Vec::with_capacity(image.segments.len());
242 let mut fully_aligned = true;
243
244 for seg in &image.segments {
245 let aligned_addr = PageLayout::align_down(seg.vmaddr, guest_page).unwrap_or(seg.vmaddr);
246 let end = seg.vmaddr.saturating_add(seg.vmsize);
247 let aligned_end = PageLayout::align_up(end, guest_page).unwrap_or(end);
248
249 let vmaddr_ok = guest_page != 0 && seg.vmaddr.is_multiple_of(u64::from(guest_page));
250 let vmsize_ok = guest_page != 0
251 && (seg.vmsize == 0 || seg.vmsize.is_multiple_of(u64::from(guest_page)));
252 if !vmaddr_ok || !vmsize_ok {
253 fully_aligned = false;
254 }
255
256 let is_pagezero = seg.name == "__PAGEZERO" || (seg.initprot == 0 && seg.fileoff == 0);
258 if seg.vmsize > 0 && !is_pagezero && seg.vmaddr < preferred_base {
259 preferred_base = seg.vmaddr;
260 }
261
262 mappings.push(PlannedMapping {
263 name: seg.name.clone(),
264 vmaddr: seg.vmaddr,
265 vmsize: seg.vmsize,
266 fileoff: seg.fileoff.saturating_add(image.summary.file_slice_offset),
268 filesize: seg.filesize,
269 guest_aligned_addr: aligned_addr,
270 guest_aligned_end: aligned_end,
271 initprot: seg.initprot,
272 maxprot: seg.maxprot,
273 vmaddr_guest_aligned: vmaddr_ok,
274 vmsize_guest_aligned: vmsize_ok,
275 });
276 }
277
278 if preferred_base == u64::MAX {
279 preferred_base = 0;
280 }
281
282 Self {
283 guest_page_size: guest_page,
284 preferred_base,
285 entry: image.summary.entry,
286 mappings,
287 fully_guest_aligned: fully_aligned,
288 }
289 }
290
291 #[must_use]
293 pub fn segment_count(&self) -> usize {
294 self.mappings.len()
295 }
296}