use super::{DYNAMIC_ENTRY_SIZE, EHDR_SIZE, PHDR_SIZE};
use crate::elf::constants::{
PF_R, PF_W, PF_X, PT_DYNAMIC, PT_GNU_EH_FRAME, PT_GNU_RELRO, PT_GNU_STACK,
PT_INTERP, PT_LOAD, PT_NOTE, PT_PHDR, PT_TLS,
};
use crate::{
dynamic::LinkMode,
elf::Phdr64,
endian::{U32, U64},
layout::{Layout, Sect, max_page_size, sect},
util::{PAGE, align_up, write_pod},
};
pub(super) fn write_phdrs(image: &mut [u8], layout: &Layout, base: u64) {
let mut phdrs: Vec<Phdr64> =
Vec::with_capacity(usize::from(layout.phdr_count()));
phdrs.extend(phdr_phdr(layout, base));
phdrs.extend(interp_phdr(layout));
let page = max_page_size(layout.target);
phdrs.push(rx_load(rx_segment_end(layout), base, page));
phdrs.extend(note_phdr(layout));
phdrs.extend(rw_load(layout, base, page));
phdrs.extend(tls_phdr(layout));
phdrs.extend(dynamic_phdr(layout, base));
phdrs.extend(relro_phdr(layout, base));
phdrs.extend(eh_frame_hdr_phdr(layout, base));
phdrs.push(gnu_stack(layout.stack_size));
let mut off = EHDR_SIZE;
for p in &phdrs {
write_pod(image, off, p);
off += PHDR_SIZE;
}
}
fn new_phdr(
p_type: u32,
flags: u32,
offset: u64,
vaddr: u64,
filesz: u64,
memsz: u64,
align: u64,
) -> Phdr64 {
Phdr64 {
p_type: U32::new(p_type),
p_flags: U32::new(flags),
p_offset: U64::new(offset),
p_vaddr: U64::new(vaddr),
p_paddr: U64::new(vaddr),
p_filesz: U64::new(filesz),
p_memsz: U64::new(memsz),
p_align: U64::new(align),
}
}
fn rw_segment_start(layout: &Layout) -> u64 {
writable_sects()
.map(|s| layout.region(s))
.find(|r| r.size != 0)
.map_or(0, |r| r.offset)
}
fn writable_sects() -> impl Iterator<Item = Sect> {
sect::TABLE
.iter()
.filter(|(_, spec)| sect::writable(spec))
.map(|(s, _)| *s)
}
fn rx_segment_end(layout: &Layout) -> u64 {
let headers = EHDR_SIZE + u64::from(layout.phdr_count()) * PHDR_SIZE;
sect::TABLE
.iter()
.filter(|(_, spec)| !sect::writable(spec))
.map(|(s, _)| layout.region(*s).end())
.fold(headers, u64::max)
}
fn phdr_phdr(layout: &Layout, base: u64) -> Option<Phdr64> {
if layout.mode() != LinkMode::DynExec || !layout.is_pie() {
return None;
}
let size = u64::from(layout.phdr_count()) * PHDR_SIZE;
Some(new_phdr(
PT_PHDR,
PF_R,
EHDR_SIZE,
base.wrapping_add(EHDR_SIZE),
size,
size,
8,
))
}
fn rx_load(rx_end: u64, base: u64, page: u64) -> Phdr64 {
new_phdr(PT_LOAD, PF_R | PF_X, 0, base, rx_end, rx_end, page)
}
fn interp_phdr(layout: &Layout) -> Option<Phdr64> {
let interp = layout.region(Sect::Interp);
layout.has_interp().then(|| {
new_phdr(
PT_INTERP,
PF_R,
interp.offset,
interp.vaddr,
interp.size,
interp.size,
1,
)
})
}
fn note_phdr(layout: &Layout) -> Option<Phdr64> {
let build_id = layout.region(Sect::BuildId);
let note = layout.region(Sect::Note);
let start = [build_id, note]
.into_iter()
.filter(|r| r.size != 0)
.map(|r| r.offset)
.min()?;
let end = build_id.end().max(note.end());
let size = end.saturating_sub(start);
(size != 0).then(|| {
new_phdr(
PT_NOTE,
PF_R,
start,
layout.base().wrapping_add(start),
size,
size,
4,
)
})
}
fn rw_load(layout: &Layout, base: u64, page: u64) -> Option<Phdr64> {
if !writable_sects().any(|s| layout.region(s).size != 0) {
return None;
}
let rw_off = rw_segment_start(layout);
let file_end = writable_sects()
.filter(|s| sect::file_backed(*s))
.map(|s| layout.region(s).end())
.fold(rw_off, u64::max);
let mem_end = writable_sects()
.filter(|s| *s != Sect::Tbss)
.map(|s| layout.region(s).end())
.fold(file_end, u64::max);
let mem_end = relro_extent(layout)
.map_or(mem_end, |(_, end)| mem_end.max(align_up(end, PAGE)));
Some(new_phdr(
PT_LOAD,
PF_R | PF_W,
rw_off,
base.wrapping_add(rw_off),
file_end.wrapping_sub(rw_off),
mem_end.wrapping_sub(rw_off),
page,
))
}
fn tls_phdr(layout: &Layout) -> Option<Phdr64> {
let block = layout.tls_block()?;
Some(new_phdr(
PT_TLS,
PF_R,
block.offset,
block.vaddr,
block.filesz,
block.memsz,
block.align.max(1),
))
}
fn dynamic_phdr(layout: &Layout, base: u64) -> Option<Phdr64> {
let plan = layout.dynamic.as_ref()?;
let dyn_off = plan.regions.dynamic.offset;
let dyn_size =
u64::try_from(plan.dynamic.len()).unwrap_or(0) * DYNAMIC_ENTRY_SIZE;
Some(new_phdr(
PT_DYNAMIC,
PF_R | PF_W,
dyn_off,
base.wrapping_add(dyn_off),
dyn_size,
dyn_size,
8,
))
}
fn relro_phdr(layout: &Layout, base: u64) -> Option<Phdr64> {
let (start, end) = relro_extent(layout)?;
Some(new_phdr(
PT_GNU_RELRO,
PF_R,
start,
base.wrapping_add(start),
end.wrapping_sub(start),
align_up(end, PAGE).wrapping_sub(start),
1,
))
}
fn relro_extent(layout: &Layout) -> Option<(u64, u64)> {
let mut extent: Option<(u64, u64)> = None;
for s in writable_sects().filter(|s| sect::relro(*s)) {
let r = layout.region(s);
if r.size == 0 {
continue;
}
extent = Some(match extent {
None => (r.offset, r.end()),
Some((start, end)) => (start.min(r.offset), end.max(r.end())),
});
}
extent
}
fn eh_frame_hdr_phdr(layout: &Layout, base: u64) -> Option<Phdr64> {
let r = layout.region(Sect::EhFrameHdr);
if r.size == 0 {
return None;
}
Some(new_phdr(
PT_GNU_EH_FRAME,
PF_R,
r.offset,
base.wrapping_add(r.offset),
r.size,
r.size,
4,
))
}
fn gnu_stack(size: u64) -> Phdr64 {
new_phdr(PT_GNU_STACK, PF_R | PF_W, 0, 0, 0, size, 0x10)
}