Page MenuHomeFreeBSD
Differential D13572

net/scapy: Update to upstream release 2.3.3
ClosedPublic
Actions

Authored by sbruno on Dec 21 2017, 3:38 PM.
Tags
None
Referenced Files
Unknown Object (File)
Sat, Apr 12, 10:41 AM
Unknown Object (File)
Mon, Apr 7, 3:33 AM
Unknown Object (File)
Sun, Apr 6, 5:35 AM
Unknown Object (File)
Sat, Mar 29, 1:46 AM
Unknown Object (File)
Mar 11 2025, 8:44 PM
Unknown Object (File)
Mar 10 2025, 8:00 AM
Unknown Object (File)
Mar 3 2025, 6:32 PM
Unknown Object (File)
Mar 3 2025, 4:58 AM
View All Files
Subscribers
mat

Details

Reviewers
skozlov
Commits
rP458040: net/scapy: Update to upstream release 2.3.3
Summary

Update to latest tagged release

Upstream moved to github so we can now track releases there:
https://github.com/secdev/scapy/releases/tag/v2.3.3

Add upstream matplotlib support

Diff Detail

Repository
rP FreeBSD ports repository
Lint
No Lint Coverage
Unit
No Test Coverage
Build Status
Buildable 13720
Build 13940: arc lint + arc unit

Event Timeline

sbruno created this revision.Dec 21 2017, 3:38 PM
Herald added a subscriber: mat. · View Herald TranscriptDec 21 2017, 3:38 PM
Harbormaster completed remote builds in B13719: Diff 36865.Dec 21 2017, 3:38 PM
sbruno edited the summary of this revision. (Show Details)Dec 21 2017, 3:38 PM
sbruno updated this revision to Diff 36866.Dec 21 2017, 3:41 PM

Missed needing to delete the second patch file which is no longer needed

Harbormaster completed remote builds in B13720: Diff 36866.Dec 21 2017, 3:41 PM
mat added inline comments.Dec 21 2017, 3:42 PM
net/scapy/Makefile
15

You should remove the GH_TAGNAME, add a DISTVERSIONPREFIX=v line after the PORTVERSION line, and re-run make makesum.

sbruno updated this revision to Diff 36867.Dec 21 2017, 3:49 PM

Delete GH_TAGNAME and use DISVERSIONPREFIX + PORTREVISION to fetch.

Regen distinfo

Harbormaster completed remote builds in B13721: Diff 36867.Dec 21 2017, 3:49 PM
sbruno marked an inline comment as done.Dec 21 2017, 3:50 PM
skozlov added a reviewer: skozlov.Dec 21 2017, 6:17 PM
skozlov requested changes to this revision.Jan 3 2018, 1:22 PM

Smoke test passed. IMO good to go after Portlint issue is resolved.

net/scapy/Makefile
13

Portlint sees spaces in this line instead of a tab.

This revision now requires changes to proceed.Jan 3 2018, 1:22 PM
sbruno updated this revision to Diff 37490.Jan 4 2018, 2:48 AM

Clean up tab vs space PORTLINT warning.

sbruno marked an inline comment as done.Jan 4 2018, 2:49 AM
skozlov accepted this revision.Jan 4 2018, 11:24 AM
This revision is now accepted and ready to land.Jan 4 2018, 11:24 AM
Closed by commit rP458040: net/scapy: Update to upstream release 2.3.3 (authored by sbruno). · Explain WhyJan 4 2018, 5:50 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathSize
net/
scapy/
12 lines
5 lines
files/

Diff 36866

View Options

net/scapy/Makefile

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linesstatic Elf_Ehdr *get_elf_header(int, const char *, const struct stat *,
Elf_Phdr **phdr); Elf_Phdr **phdr);
static int convert_flags(int); /* Elf flags -> mmap flags */ static int convert_flags(int); /* Elf flags -> mmap flags */
int __getosreldate(void); int __getosreldate(void);
static bool static bool
phdr_in_zero_page(const Elf_Ehdr *hdr) phdr_in_zero_page(const Elf_Ehdr *hdr)
{ {
return (hdr->e_phoff + hdr->e_phnum * sizeof(Elf_Phdr) <= return (hdr->e_phoff + hdr->e_phnum * sizeof(Elf_Phdr) <= page_size);
(size_t)PAGE_SIZE);
} }
/* /*
* Map a shared object into memory. The "fd" argument is a file descriptor, * Map a shared object into memory. The "fd" argument is a file descriptor,
* which must be open on the object and positioned at its beginning. * which must be open on the object and positioned at its beginning.
* The "path" argument is a pathname that is used only for error messages. * The "path" argument is a pathname that is used only for error messages.
* *
* The return value is a pointer to a newly-allocated Obj_Entry structure * The return value is a pointer to a newly-allocated Obj_Entry structure
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Linesmap_object(int fd, const char *path, const struct stat *sb)
switch (phdr->p_type) { switch (phdr->p_type) {
case PT_INTERP: case PT_INTERP:
phinterp = phdr; phinterp = phdr;
break; break;
case PT_LOAD: case PT_LOAD:
segs[++nsegs] = phdr; segs[++nsegs] = phdr;
if ((segs[nsegs]->p_align & (PAGE_SIZE - 1)) != 0) { if ((segs[nsegs]->p_align & (page_size - 1)) != 0) {
kibUnsubmitted
Not Done
Inline Actions

I must admit this changes ABI.

kib: I must admit this changes ABI.
andrewAuthorUnsubmitted
Done
Inline Actions

That is expected. Userspace from <= 13 is not expected to run on a kernel built with 16k PAGE_SIZE. It will be a non-default option that the user has to enable with the understanding it will break the ABI.

I would like to make the alignment 64k here on arm64 for 14+. It should be safe as the linker should already use 64k alignment, however I'd expect to keep 4k for older binaries.

andrew: That is expected. Userspace from <= 13 is not expected to run on a kernel built with 16k…
_rtld_error("%s: PT_LOAD segment %d not page-aligned", _rtld_error("%s: PT_LOAD segment %d not page-aligned",
path, nsegs); path, nsegs);
goto error; goto error;
} }
if ((segs[nsegs]->p_flags & PF_X) == PF_X) { if ((segs[nsegs]->p_flags & PF_X) == PF_X) {
text_end = MAX(text_end, text_end = MAX(text_end,
round_page(segs[nsegs]->p_vaddr + segs[nsegs]->p_memsz)); rtld_round_page(segs[nsegs]->p_vaddr +
segs[nsegs]->p_memsz));
} }
break; break;
case PT_PHDR: case PT_PHDR:
phdr_vaddr = phdr->p_vaddr; phdr_vaddr = phdr->p_vaddr;
phsize = phdr->p_memsz; phsize = phdr->p_memsz;
break; break;
Show All 10 Lines case PT_GNU_STACK:
break; break;
case PT_GNU_RELRO: case PT_GNU_RELRO:
relro_page = phdr->p_vaddr; relro_page = phdr->p_vaddr;
relro_size = phdr->p_memsz; relro_size = phdr->p_memsz;
break; break;
case PT_NOTE: case PT_NOTE:
if (phdr->p_offset > PAGE_SIZE || if (phdr->p_offset > page_size ||
phdr->p_offset + phdr->p_filesz > PAGE_SIZE) { phdr->p_offset + phdr->p_filesz > page_size) {
note_map_len = round_page(phdr->p_offset + note_map_len = rtld_round_page(phdr->p_offset +
phdr->p_filesz) - trunc_page(phdr->p_offset); phdr->p_filesz) - rtld_trunc_page(phdr->p_offset);
note_map = mmap(NULL, note_map_len, PROT_READ, note_map = mmap(NULL, note_map_len, PROT_READ,
MAP_PRIVATE, fd, trunc_page(phdr->p_offset)); MAP_PRIVATE, fd, rtld_trunc_page(phdr->p_offset));
if (note_map == MAP_FAILED) { if (note_map == MAP_FAILED) {
_rtld_error("%s: error mapping PT_NOTE (%d)", path, errno); _rtld_error("%s: error mapping PT_NOTE (%d)", path, errno);
goto error; goto error;
} }
note_start = (Elf_Addr)(note_map + phdr->p_offset - note_start = (Elf_Addr)(note_map + phdr->p_offset -
trunc_page(phdr->p_offset)); rtld_trunc_page(phdr->p_offset));
} else { } else {
note_start = (Elf_Addr)(char *)hdr + phdr->p_offset; note_start = (Elf_Addr)(char *)hdr + phdr->p_offset;
} }
note_end = note_start + phdr->p_filesz; note_end = note_start + phdr->p_filesz;
break; break;
} }
++phdr; ++phdr;
} }
if (phdyn == NULL) { if (phdyn == NULL) {
_rtld_error("%s: object is not dynamically-linked", path); _rtld_error("%s: object is not dynamically-linked", path);
goto error; goto error;
} }
if (nsegs < 0) { if (nsegs < 0) {
_rtld_error("%s: too few PT_LOAD segments", path); _rtld_error("%s: too few PT_LOAD segments", path);
goto error; goto error;
} }
/* /*
* Map the entire address space of the object, to stake out our * Map the entire address space of the object, to stake out our
* contiguous region, and to establish the base address for relocation. * contiguous region, and to establish the base address for relocation.
*/ */
base_vaddr = trunc_page(segs[0]->p_vaddr); base_vaddr = rtld_trunc_page(segs[0]->p_vaddr);
base_vlimit = round_page(segs[nsegs]->p_vaddr + segs[nsegs]->p_memsz); base_vlimit = rtld_round_page(segs[nsegs]->p_vaddr + segs[nsegs]->p_memsz);
mapsize = base_vlimit - base_vaddr; mapsize = base_vlimit - base_vaddr;
base_addr = (caddr_t) base_vaddr; base_addr = (caddr_t) base_vaddr;
base_flags = __getosreldate() >= P_OSREL_MAP_GUARD ? MAP_GUARD : base_flags = __getosreldate() >= P_OSREL_MAP_GUARD ? MAP_GUARD :
MAP_PRIVATE | MAP_ANON | MAP_NOCORE; MAP_PRIVATE | MAP_ANON | MAP_NOCORE;
if (npagesizes > 1 && round_page(segs[0]->p_filesz) >= pagesizes[1]) if (npagesizes > 1 && rtld_round_page(segs[0]->p_filesz) >= pagesizes[1])
base_flags |= MAP_ALIGNED_SUPER; base_flags |= MAP_ALIGNED_SUPER;
if (base_vaddr != 0) if (base_vaddr != 0)
base_flags |= MAP_FIXED | MAP_EXCL; base_flags |= MAP_FIXED | MAP_EXCL;
kibUnsubmitted
Not Done
Inline Actions

This would cause similar ABI issue, since binary built for 4k page with corresponding alignment would be not runnable.

kib: This would cause similar ABI issue, since binary built for 4k page with corresponding alignment…
mapbase = mmap(base_addr, mapsize, PROT_NONE, base_flags, -1, 0); mapbase = mmap(base_addr, mapsize, PROT_NONE, base_flags, -1, 0);
if (mapbase == MAP_FAILED) { if (mapbase == MAP_FAILED) {
_rtld_error("%s: mmap of entire address space failed: %s", _rtld_error("%s: mmap of entire address space failed: %s",
path, rtld_strerror(errno)); path, rtld_strerror(errno));
goto error; goto error;
} }
if (base_addr != NULL && mapbase != base_addr) { if (base_addr != NULL && mapbase != base_addr) {
_rtld_error("%s: mmap returned wrong address: wanted %p, got %p", _rtld_error("%s: mmap returned wrong address: wanted %p, got %p",
path, base_addr, mapbase); path, base_addr, mapbase);
goto error1; goto error1;
} }
for (i = 0; i <= nsegs; i++) { for (i = 0; i <= nsegs; i++) {
/* Overlay the segment onto the proper region. */ /* Overlay the segment onto the proper region. */
data_offset = trunc_page(segs[i]->p_offset); data_offset = rtld_trunc_page(segs[i]->p_offset);
data_vaddr = trunc_page(segs[i]->p_vaddr); data_vaddr = rtld_trunc_page(segs[i]->p_vaddr);
data_vlimit = round_page(segs[i]->p_vaddr + segs[i]->p_filesz); data_vlimit = rtld_round_page(segs[i]->p_vaddr + segs[i]->p_filesz);
data_addr = mapbase + (data_vaddr - base_vaddr); data_addr = mapbase + (data_vaddr - base_vaddr);
data_prot = convert_prot(segs[i]->p_flags); data_prot = convert_prot(segs[i]->p_flags);
data_flags = convert_flags(segs[i]->p_flags) | MAP_FIXED; data_flags = convert_flags(segs[i]->p_flags) | MAP_FIXED;
if (data_vlimit != data_vaddr && if (data_vlimit != data_vaddr &&
mmap(data_addr, data_vlimit - data_vaddr, data_prot, mmap(data_addr, data_vlimit - data_vaddr, data_prot,
data_flags | MAP_PREFAULT_READ, fd, data_offset) == MAP_FAILED) { data_flags | MAP_PREFAULT_READ, fd, data_offset) == MAP_FAILED) {
_rtld_error("%s: mmap of data failed: %s", path, _rtld_error("%s: mmap of data failed: %s", path,
rtld_strerror(errno)); rtld_strerror(errno));
goto error1; goto error1;
} }
/* Do BSS setup */ /* Do BSS setup */
if (segs[i]->p_filesz != segs[i]->p_memsz) { if (segs[i]->p_filesz != segs[i]->p_memsz) {
/* Clear any BSS in the last page of the segment. */ /* Clear any BSS in the last page of the segment. */
clear_vaddr = segs[i]->p_vaddr + segs[i]->p_filesz; clear_vaddr = segs[i]->p_vaddr + segs[i]->p_filesz;
clear_addr = mapbase + (clear_vaddr - base_vaddr); clear_addr = mapbase + (clear_vaddr - base_vaddr);
clear_page = mapbase + (trunc_page(clear_vaddr) - base_vaddr); clear_page = mapbase + (rtld_trunc_page(clear_vaddr) - base_vaddr);
if ((nclear = data_vlimit - clear_vaddr) > 0) { if ((nclear = data_vlimit - clear_vaddr) > 0) {
/* Make sure the end of the segment is writable */ /* Make sure the end of the segment is writable */
if ((data_prot & PROT_WRITE) == 0 && -1 == if ((data_prot & PROT_WRITE) == 0 && -1 ==
mprotect(clear_page, PAGE_SIZE, data_prot|PROT_WRITE)) { mprotect(clear_page, page_size, data_prot|PROT_WRITE)) {
_rtld_error("%s: mprotect failed: %s", path, _rtld_error("%s: mprotect failed: %s", path,
rtld_strerror(errno)); rtld_strerror(errno));
goto error1; goto error1;
} }
memset(clear_addr, 0, nclear); memset(clear_addr, 0, nclear);
/* Reset the data protection back */ /* Reset the data protection back */
if ((data_prot & PROT_WRITE) == 0) if ((data_prot & PROT_WRITE) == 0)
mprotect(clear_page, PAGE_SIZE, data_prot); mprotect(clear_page, page_size, data_prot);
} }
/* Overlay the BSS segment onto the proper region. */ /* Overlay the BSS segment onto the proper region. */
bss_vaddr = data_vlimit; bss_vaddr = data_vlimit;
bss_vlimit = round_page(segs[i]->p_vaddr + segs[i]->p_memsz); bss_vlimit = rtld_round_page(segs[i]->p_vaddr + segs[i]->p_memsz);
bss_addr = mapbase + (bss_vaddr - base_vaddr); bss_addr = mapbase + (bss_vaddr - base_vaddr);
if (bss_vlimit > bss_vaddr) { /* There is something to do */ if (bss_vlimit > bss_vaddr) { /* There is something to do */
if (mmap(bss_addr, bss_vlimit - bss_vaddr, data_prot, if (mmap(bss_addr, bss_vlimit - bss_vaddr, data_prot,
data_flags | MAP_ANON, -1, 0) == MAP_FAILED) { data_flags | MAP_ANON, -1, 0) == MAP_FAILED) {
_rtld_error("%s: mmap of bss failed: %s", path, _rtld_error("%s: mmap of bss failed: %s", path,
rtld_strerror(errno)); rtld_strerror(errno));
goto error1; goto error1;
} }
Show All 39 Linesmap_object(int fd, const char *path, const struct stat *sb)
obj->tlsindex = ++tls_max_index; obj->tlsindex = ++tls_max_index;
obj->tlssize = phtls->p_memsz; obj->tlssize = phtls->p_memsz;
obj->tlsalign = phtls->p_align; obj->tlsalign = phtls->p_align;
obj->tlspoffset = phtls->p_offset; obj->tlspoffset = phtls->p_offset;
obj->tlsinitsize = phtls->p_filesz; obj->tlsinitsize = phtls->p_filesz;
obj->tlsinit = mapbase + phtls->p_vaddr; obj->tlsinit = mapbase + phtls->p_vaddr;
} }
obj->stack_flags = stack_flags; obj->stack_flags = stack_flags;
obj->relro_page = obj->relocbase + trunc_page(relro_page); obj->relro_page = obj->relocbase + rtld_trunc_page(relro_page);
obj->relro_size = trunc_page(relro_page + relro_size) - obj->relro_size = rtld_trunc_page(relro_page + relro_size) -
trunc_page(relro_page); rtld_trunc_page(relro_page);
if (note_start < note_end) if (note_start < note_end)
digest_notes(obj, note_start, note_end); digest_notes(obj, note_start, note_end);
if (note_map != NULL) if (note_map != NULL)
munmap(note_map, note_map_len); munmap(note_map, note_map_len);
munmap(hdr, PAGE_SIZE); munmap(hdr, page_size);
return (obj); return (obj);
error1: error1:
munmap(mapbase, mapsize); munmap(mapbase, mapsize);
error: error:
if (note_map != NULL && note_map != MAP_FAILED) if (note_map != NULL && note_map != MAP_FAILED)
munmap(note_map, note_map_len); munmap(note_map, note_map_len);
if (!phdr_in_zero_page(hdr)) if (!phdr_in_zero_page(hdr))
munmap(phdr, hdr->e_phnum * sizeof(phdr[0])); munmap(phdr, hdr->e_phnum * sizeof(phdr[0]));
munmap(hdr, PAGE_SIZE); munmap(hdr, page_size);
return (NULL); return (NULL);
} }
bool bool
check_elf_headers(const Elf_Ehdr *hdr, const char *path) check_elf_headers(const Elf_Ehdr *hdr, const char *path)
{ {
if (!IS_ELF(*hdr)) { if (!IS_ELF(*hdr)) {
_rtld_error("%s: invalid file format", path); _rtld_error("%s: invalid file format", path);
Show All 33 Linesget_elf_header(int fd, const char *path, const struct stat *sbp,
Elf_Phdr *phdr; Elf_Phdr *phdr;
/* Make sure file has enough data for the ELF header */ /* Make sure file has enough data for the ELF header */
if (sbp != NULL && sbp->st_size < (off_t)sizeof(Elf_Ehdr)) { if (sbp != NULL && sbp->st_size < (off_t)sizeof(Elf_Ehdr)) {
_rtld_error("%s: invalid file format", path); _rtld_error("%s: invalid file format", path);
return (NULL); return (NULL);
} }
hdr = mmap(NULL, PAGE_SIZE, PROT_READ, MAP_PRIVATE | MAP_PREFAULT_READ, hdr = mmap(NULL, page_size, PROT_READ, MAP_PRIVATE | MAP_PREFAULT_READ,
fd, 0); fd, 0);
if (hdr == MAP_FAILED) { if (hdr == MAP_FAILED) {
_rtld_error("%s: read error: %s", path, rtld_strerror(errno)); _rtld_error("%s: read error: %s", path, rtld_strerror(errno));
return (NULL); return (NULL);
} }
/* Make sure the file is valid */ /* Make sure the file is valid */
if (!check_elf_headers(hdr, path)) if (!check_elf_headers(hdr, path))
Show All 15 Lines if (phdr == MAP_FAILED) {
rtld_strerror(errno)); rtld_strerror(errno));
goto error; goto error;
} }
} }
*phdr_p = phdr; *phdr_p = phdr;
return (hdr); return (hdr);
error: error:
munmap(hdr, PAGE_SIZE); munmap(hdr, page_size);
return (NULL); return (NULL);
} }
void void
obj_free(Obj_Entry *obj) obj_free(Obj_Entry *obj)
{ {
Objlist_Entry *elm; Objlist_Entry *elm;
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines
View Options

net/scapy/distinfo

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linesstatic Elf_Ehdr *get_elf_header(int, const char *, const struct stat *,
Elf_Phdr **phdr); Elf_Phdr **phdr);
static int convert_flags(int); /* Elf flags -> mmap flags */ static int convert_flags(int); /* Elf flags -> mmap flags */
int __getosreldate(void); int __getosreldate(void);
static bool static bool
phdr_in_zero_page(const Elf_Ehdr *hdr) phdr_in_zero_page(const Elf_Ehdr *hdr)
{ {
return (hdr->e_phoff + hdr->e_phnum * sizeof(Elf_Phdr) <= return (hdr->e_phoff + hdr->e_phnum * sizeof(Elf_Phdr) <= page_size);
(size_t)PAGE_SIZE);
} }
/* /*
* Map a shared object into memory. The "fd" argument is a file descriptor, * Map a shared object into memory. The "fd" argument is a file descriptor,
* which must be open on the object and positioned at its beginning. * which must be open on the object and positioned at its beginning.
* The "path" argument is a pathname that is used only for error messages. * The "path" argument is a pathname that is used only for error messages.
* *
* The return value is a pointer to a newly-allocated Obj_Entry structure * The return value is a pointer to a newly-allocated Obj_Entry structure
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Linesmap_object(int fd, const char *path, const struct stat *sb)
switch (phdr->p_type) { switch (phdr->p_type) {
case PT_INTERP: case PT_INTERP:
phinterp = phdr; phinterp = phdr;
break; break;
case PT_LOAD: case PT_LOAD:
segs[++nsegs] = phdr; segs[++nsegs] = phdr;
if ((segs[nsegs]->p_align & (PAGE_SIZE - 1)) != 0) { if ((segs[nsegs]->p_align & (page_size - 1)) != 0) {
kibUnsubmitted
Not Done
Inline Actions

I must admit this changes ABI.

kib: I must admit this changes ABI.
andrewAuthorUnsubmitted
Done
Inline Actions

That is expected. Userspace from <= 13 is not expected to run on a kernel built with 16k PAGE_SIZE. It will be a non-default option that the user has to enable with the understanding it will break the ABI.

I would like to make the alignment 64k here on arm64 for 14+. It should be safe as the linker should already use 64k alignment, however I'd expect to keep 4k for older binaries.

andrew: That is expected. Userspace from <= 13 is not expected to run on a kernel built with 16k…
_rtld_error("%s: PT_LOAD segment %d not page-aligned", _rtld_error("%s: PT_LOAD segment %d not page-aligned",
path, nsegs); path, nsegs);
goto error; goto error;
} }
if ((segs[nsegs]->p_flags & PF_X) == PF_X) { if ((segs[nsegs]->p_flags & PF_X) == PF_X) {
text_end = MAX(text_end, text_end = MAX(text_end,
round_page(segs[nsegs]->p_vaddr + segs[nsegs]->p_memsz)); rtld_round_page(segs[nsegs]->p_vaddr +
segs[nsegs]->p_memsz));
} }
break; break;
case PT_PHDR: case PT_PHDR:
phdr_vaddr = phdr->p_vaddr; phdr_vaddr = phdr->p_vaddr;
phsize = phdr->p_memsz; phsize = phdr->p_memsz;
break; break;
Show All 10 Lines case PT_GNU_STACK:
break; break;
case PT_GNU_RELRO: case PT_GNU_RELRO:
relro_page = phdr->p_vaddr; relro_page = phdr->p_vaddr;
relro_size = phdr->p_memsz; relro_size = phdr->p_memsz;
break; break;
case PT_NOTE: case PT_NOTE:
if (phdr->p_offset > PAGE_SIZE || if (phdr->p_offset > page_size ||
phdr->p_offset + phdr->p_filesz > PAGE_SIZE) { phdr->p_offset + phdr->p_filesz > page_size) {
note_map_len = round_page(phdr->p_offset + note_map_len = rtld_round_page(phdr->p_offset +
phdr->p_filesz) - trunc_page(phdr->p_offset); phdr->p_filesz) - rtld_trunc_page(phdr->p_offset);
note_map = mmap(NULL, note_map_len, PROT_READ, note_map = mmap(NULL, note_map_len, PROT_READ,
MAP_PRIVATE, fd, trunc_page(phdr->p_offset)); MAP_PRIVATE, fd, rtld_trunc_page(phdr->p_offset));
if (note_map == MAP_FAILED) { if (note_map == MAP_FAILED) {
_rtld_error("%s: error mapping PT_NOTE (%d)", path, errno); _rtld_error("%s: error mapping PT_NOTE (%d)", path, errno);
goto error; goto error;
} }
note_start = (Elf_Addr)(note_map + phdr->p_offset - note_start = (Elf_Addr)(note_map + phdr->p_offset -
trunc_page(phdr->p_offset)); rtld_trunc_page(phdr->p_offset));
} else { } else {
note_start = (Elf_Addr)(char *)hdr + phdr->p_offset; note_start = (Elf_Addr)(char *)hdr + phdr->p_offset;
} }
note_end = note_start + phdr->p_filesz; note_end = note_start + phdr->p_filesz;
break; break;
} }
++phdr; ++phdr;
} }
if (phdyn == NULL) { if (phdyn == NULL) {
_rtld_error("%s: object is not dynamically-linked", path); _rtld_error("%s: object is not dynamically-linked", path);
goto error; goto error;
} }
if (nsegs < 0) { if (nsegs < 0) {
_rtld_error("%s: too few PT_LOAD segments", path); _rtld_error("%s: too few PT_LOAD segments", path);
goto error; goto error;
} }
/* /*
* Map the entire address space of the object, to stake out our * Map the entire address space of the object, to stake out our
* contiguous region, and to establish the base address for relocation. * contiguous region, and to establish the base address for relocation.
*/ */
base_vaddr = trunc_page(segs[0]->p_vaddr); base_vaddr = rtld_trunc_page(segs[0]->p_vaddr);
base_vlimit = round_page(segs[nsegs]->p_vaddr + segs[nsegs]->p_memsz); base_vlimit = rtld_round_page(segs[nsegs]->p_vaddr + segs[nsegs]->p_memsz);
mapsize = base_vlimit - base_vaddr; mapsize = base_vlimit - base_vaddr;
base_addr = (caddr_t) base_vaddr; base_addr = (caddr_t) base_vaddr;
base_flags = __getosreldate() >= P_OSREL_MAP_GUARD ? MAP_GUARD : base_flags = __getosreldate() >= P_OSREL_MAP_GUARD ? MAP_GUARD :
MAP_PRIVATE | MAP_ANON | MAP_NOCORE; MAP_PRIVATE | MAP_ANON | MAP_NOCORE;
if (npagesizes > 1 && round_page(segs[0]->p_filesz) >= pagesizes[1]) if (npagesizes > 1 && rtld_round_page(segs[0]->p_filesz) >= pagesizes[1])
base_flags |= MAP_ALIGNED_SUPER; base_flags |= MAP_ALIGNED_SUPER;
if (base_vaddr != 0) if (base_vaddr != 0)
base_flags |= MAP_FIXED | MAP_EXCL; base_flags |= MAP_FIXED | MAP_EXCL;
kibUnsubmitted
Not Done
Inline Actions

This would cause similar ABI issue, since binary built for 4k page with corresponding alignment would be not runnable.

kib: This would cause similar ABI issue, since binary built for 4k page with corresponding alignment…
mapbase = mmap(base_addr, mapsize, PROT_NONE, base_flags, -1, 0); mapbase = mmap(base_addr, mapsize, PROT_NONE, base_flags, -1, 0);
if (mapbase == MAP_FAILED) { if (mapbase == MAP_FAILED) {
_rtld_error("%s: mmap of entire address space failed: %s", _rtld_error("%s: mmap of entire address space failed: %s",
path, rtld_strerror(errno)); path, rtld_strerror(errno));
goto error; goto error;
} }
if (base_addr != NULL && mapbase != base_addr) { if (base_addr != NULL && mapbase != base_addr) {
_rtld_error("%s: mmap returned wrong address: wanted %p, got %p", _rtld_error("%s: mmap returned wrong address: wanted %p, got %p",
path, base_addr, mapbase); path, base_addr, mapbase);
goto error1; goto error1;
} }
for (i = 0; i <= nsegs; i++) { for (i = 0; i <= nsegs; i++) {
/* Overlay the segment onto the proper region. */ /* Overlay the segment onto the proper region. */
data_offset = trunc_page(segs[i]->p_offset); data_offset = rtld_trunc_page(segs[i]->p_offset);
data_vaddr = trunc_page(segs[i]->p_vaddr); data_vaddr = rtld_trunc_page(segs[i]->p_vaddr);
data_vlimit = round_page(segs[i]->p_vaddr + segs[i]->p_filesz); data_vlimit = rtld_round_page(segs[i]->p_vaddr + segs[i]->p_filesz);
data_addr = mapbase + (data_vaddr - base_vaddr); data_addr = mapbase + (data_vaddr - base_vaddr);
data_prot = convert_prot(segs[i]->p_flags); data_prot = convert_prot(segs[i]->p_flags);
data_flags = convert_flags(segs[i]->p_flags) | MAP_FIXED; data_flags = convert_flags(segs[i]->p_flags) | MAP_FIXED;
if (data_vlimit != data_vaddr && if (data_vlimit != data_vaddr &&
mmap(data_addr, data_vlimit - data_vaddr, data_prot, mmap(data_addr, data_vlimit - data_vaddr, data_prot,
data_flags | MAP_PREFAULT_READ, fd, data_offset) == MAP_FAILED) { data_flags | MAP_PREFAULT_READ, fd, data_offset) == MAP_FAILED) {
_rtld_error("%s: mmap of data failed: %s", path, _rtld_error("%s: mmap of data failed: %s", path,
rtld_strerror(errno)); rtld_strerror(errno));
goto error1; goto error1;
} }
/* Do BSS setup */ /* Do BSS setup */
if (segs[i]->p_filesz != segs[i]->p_memsz) { if (segs[i]->p_filesz != segs[i]->p_memsz) {
/* Clear any BSS in the last page of the segment. */ /* Clear any BSS in the last page of the segment. */
clear_vaddr = segs[i]->p_vaddr + segs[i]->p_filesz; clear_vaddr = segs[i]->p_vaddr + segs[i]->p_filesz;
clear_addr = mapbase + (clear_vaddr - base_vaddr); clear_addr = mapbase + (clear_vaddr - base_vaddr);
clear_page = mapbase + (trunc_page(clear_vaddr) - base_vaddr); clear_page = mapbase + (rtld_trunc_page(clear_vaddr) - base_vaddr);
if ((nclear = data_vlimit - clear_vaddr) > 0) { if ((nclear = data_vlimit - clear_vaddr) > 0) {
/* Make sure the end of the segment is writable */ /* Make sure the end of the segment is writable */
if ((data_prot & PROT_WRITE) == 0 && -1 == if ((data_prot & PROT_WRITE) == 0 && -1 ==
mprotect(clear_page, PAGE_SIZE, data_prot|PROT_WRITE)) { mprotect(clear_page, page_size, data_prot|PROT_WRITE)) {
_rtld_error("%s: mprotect failed: %s", path, _rtld_error("%s: mprotect failed: %s", path,
rtld_strerror(errno)); rtld_strerror(errno));
goto error1; goto error1;
} }
memset(clear_addr, 0, nclear); memset(clear_addr, 0, nclear);
/* Reset the data protection back */ /* Reset the data protection back */
if ((data_prot & PROT_WRITE) == 0) if ((data_prot & PROT_WRITE) == 0)
mprotect(clear_page, PAGE_SIZE, data_prot); mprotect(clear_page, page_size, data_prot);
} }
/* Overlay the BSS segment onto the proper region. */ /* Overlay the BSS segment onto the proper region. */
bss_vaddr = data_vlimit; bss_vaddr = data_vlimit;
bss_vlimit = round_page(segs[i]->p_vaddr + segs[i]->p_memsz); bss_vlimit = rtld_round_page(segs[i]->p_vaddr + segs[i]->p_memsz);
bss_addr = mapbase + (bss_vaddr - base_vaddr); bss_addr = mapbase + (bss_vaddr - base_vaddr);
if (bss_vlimit > bss_vaddr) { /* There is something to do */ if (bss_vlimit > bss_vaddr) { /* There is something to do */
if (mmap(bss_addr, bss_vlimit - bss_vaddr, data_prot, if (mmap(bss_addr, bss_vlimit - bss_vaddr, data_prot,
data_flags | MAP_ANON, -1, 0) == MAP_FAILED) { data_flags | MAP_ANON, -1, 0) == MAP_FAILED) {
_rtld_error("%s: mmap of bss failed: %s", path, _rtld_error("%s: mmap of bss failed: %s", path,
rtld_strerror(errno)); rtld_strerror(errno));
goto error1; goto error1;
} }
Show All 39 Linesmap_object(int fd, const char *path, const struct stat *sb)
obj->tlsindex = ++tls_max_index; obj->tlsindex = ++tls_max_index;
obj->tlssize = phtls->p_memsz; obj->tlssize = phtls->p_memsz;
obj->tlsalign = phtls->p_align; obj->tlsalign = phtls->p_align;
obj->tlspoffset = phtls->p_offset; obj->tlspoffset = phtls->p_offset;
obj->tlsinitsize = phtls->p_filesz; obj->tlsinitsize = phtls->p_filesz;
obj->tlsinit = mapbase + phtls->p_vaddr; obj->tlsinit = mapbase + phtls->p_vaddr;
} }
obj->stack_flags = stack_flags; obj->stack_flags = stack_flags;
obj->relro_page = obj->relocbase + trunc_page(relro_page); obj->relro_page = obj->relocbase + rtld_trunc_page(relro_page);
obj->relro_size = trunc_page(relro_page + relro_size) - obj->relro_size = rtld_trunc_page(relro_page + relro_size) -
trunc_page(relro_page); rtld_trunc_page(relro_page);
if (note_start < note_end) if (note_start < note_end)
digest_notes(obj, note_start, note_end); digest_notes(obj, note_start, note_end);
if (note_map != NULL) if (note_map != NULL)
munmap(note_map, note_map_len); munmap(note_map, note_map_len);
munmap(hdr, PAGE_SIZE); munmap(hdr, page_size);
return (obj); return (obj);
error1: error1:
munmap(mapbase, mapsize); munmap(mapbase, mapsize);
error: error:
if (note_map != NULL && note_map != MAP_FAILED) if (note_map != NULL && note_map != MAP_FAILED)
munmap(note_map, note_map_len); munmap(note_map, note_map_len);
if (!phdr_in_zero_page(hdr)) if (!phdr_in_zero_page(hdr))
munmap(phdr, hdr->e_phnum * sizeof(phdr[0])); munmap(phdr, hdr->e_phnum * sizeof(phdr[0]));
munmap(hdr, PAGE_SIZE); munmap(hdr, page_size);
return (NULL); return (NULL);
} }
bool bool
check_elf_headers(const Elf_Ehdr *hdr, const char *path) check_elf_headers(const Elf_Ehdr *hdr, const char *path)
{ {
if (!IS_ELF(*hdr)) { if (!IS_ELF(*hdr)) {
_rtld_error("%s: invalid file format", path); _rtld_error("%s: invalid file format", path);
Show All 33 Linesget_elf_header(int fd, const char *path, const struct stat *sbp,
Elf_Phdr *phdr; Elf_Phdr *phdr;
/* Make sure file has enough data for the ELF header */ /* Make sure file has enough data for the ELF header */
if (sbp != NULL && sbp->st_size < (off_t)sizeof(Elf_Ehdr)) { if (sbp != NULL && sbp->st_size < (off_t)sizeof(Elf_Ehdr)) {
_rtld_error("%s: invalid file format", path); _rtld_error("%s: invalid file format", path);
return (NULL); return (NULL);
} }
hdr = mmap(NULL, PAGE_SIZE, PROT_READ, MAP_PRIVATE | MAP_PREFAULT_READ, hdr = mmap(NULL, page_size, PROT_READ, MAP_PRIVATE | MAP_PREFAULT_READ,
fd, 0); fd, 0);
if (hdr == MAP_FAILED) { if (hdr == MAP_FAILED) {
_rtld_error("%s: read error: %s", path, rtld_strerror(errno)); _rtld_error("%s: read error: %s", path, rtld_strerror(errno));
return (NULL); return (NULL);
} }
/* Make sure the file is valid */ /* Make sure the file is valid */
if (!check_elf_headers(hdr, path)) if (!check_elf_headers(hdr, path))
Show All 15 Lines if (phdr == MAP_FAILED) {
rtld_strerror(errno)); rtld_strerror(errno));
goto error; goto error;
} }
} }
*phdr_p = phdr; *phdr_p = phdr;
return (hdr); return (hdr);
error: error:
munmap(hdr, PAGE_SIZE); munmap(hdr, page_size);
return (NULL); return (NULL);
} }
void void
obj_free(Obj_Entry *obj) obj_free(Obj_Entry *obj)
{ {
Objlist_Entry *elm; Objlist_Entry *elm;
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines
View Options

net/scapy/files/patch-scapy__arch__unix.py

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linesstatic Elf_Ehdr *get_elf_header(int, const char *, const struct stat *,
Elf_Phdr **phdr); Elf_Phdr **phdr);
static int convert_flags(int); /* Elf flags -> mmap flags */ static int convert_flags(int); /* Elf flags -> mmap flags */
int __getosreldate(void); int __getosreldate(void);
static bool static bool
phdr_in_zero_page(const Elf_Ehdr *hdr) phdr_in_zero_page(const Elf_Ehdr *hdr)
{ {
return (hdr->e_phoff + hdr->e_phnum * sizeof(Elf_Phdr) <= return (hdr->e_phoff + hdr->e_phnum * sizeof(Elf_Phdr) <= page_size);
(size_t)PAGE_SIZE);
} }
/* /*
* Map a shared object into memory. The "fd" argument is a file descriptor, * Map a shared object into memory. The "fd" argument is a file descriptor,
* which must be open on the object and positioned at its beginning. * which must be open on the object and positioned at its beginning.
* The "path" argument is a pathname that is used only for error messages. * The "path" argument is a pathname that is used only for error messages.
* *
* The return value is a pointer to a newly-allocated Obj_Entry structure * The return value is a pointer to a newly-allocated Obj_Entry structure
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Linesmap_object(int fd, const char *path, const struct stat *sb)
switch (phdr->p_type) { switch (phdr->p_type) {
case PT_INTERP: case PT_INTERP:
phinterp = phdr; phinterp = phdr;
break; break;
case PT_LOAD: case PT_LOAD:
segs[++nsegs] = phdr; segs[++nsegs] = phdr;
if ((segs[nsegs]->p_align & (PAGE_SIZE - 1)) != 0) { if ((segs[nsegs]->p_align & (page_size - 1)) != 0) {
kibUnsubmitted
Not Done
Inline Actions

I must admit this changes ABI.

kib: I must admit this changes ABI.
andrewAuthorUnsubmitted
Done
Inline Actions

That is expected. Userspace from <= 13 is not expected to run on a kernel built with 16k PAGE_SIZE. It will be a non-default option that the user has to enable with the understanding it will break the ABI.

I would like to make the alignment 64k here on arm64 for 14+. It should be safe as the linker should already use 64k alignment, however I'd expect to keep 4k for older binaries.

andrew: That is expected. Userspace from <= 13 is not expected to run on a kernel built with 16k…
_rtld_error("%s: PT_LOAD segment %d not page-aligned", _rtld_error("%s: PT_LOAD segment %d not page-aligned",
path, nsegs); path, nsegs);
goto error; goto error;
} }
if ((segs[nsegs]->p_flags & PF_X) == PF_X) { if ((segs[nsegs]->p_flags & PF_X) == PF_X) {
text_end = MAX(text_end, text_end = MAX(text_end,
round_page(segs[nsegs]->p_vaddr + segs[nsegs]->p_memsz)); rtld_round_page(segs[nsegs]->p_vaddr +
segs[nsegs]->p_memsz));
} }
break; break;
case PT_PHDR: case PT_PHDR:
phdr_vaddr = phdr->p_vaddr; phdr_vaddr = phdr->p_vaddr;
phsize = phdr->p_memsz; phsize = phdr->p_memsz;
break; break;
Show All 10 Lines case PT_GNU_STACK:
break; break;
case PT_GNU_RELRO: case PT_GNU_RELRO:
relro_page = phdr->p_vaddr; relro_page = phdr->p_vaddr;
relro_size = phdr->p_memsz; relro_size = phdr->p_memsz;
break; break;
case PT_NOTE: case PT_NOTE:
if (phdr->p_offset > PAGE_SIZE || if (phdr->p_offset > page_size ||
phdr->p_offset + phdr->p_filesz > PAGE_SIZE) { phdr->p_offset + phdr->p_filesz > page_size) {
note_map_len = round_page(phdr->p_offset + note_map_len = rtld_round_page(phdr->p_offset +
phdr->p_filesz) - trunc_page(phdr->p_offset); phdr->p_filesz) - rtld_trunc_page(phdr->p_offset);
note_map = mmap(NULL, note_map_len, PROT_READ, note_map = mmap(NULL, note_map_len, PROT_READ,
MAP_PRIVATE, fd, trunc_page(phdr->p_offset)); MAP_PRIVATE, fd, rtld_trunc_page(phdr->p_offset));
if (note_map == MAP_FAILED) { if (note_map == MAP_FAILED) {
_rtld_error("%s: error mapping PT_NOTE (%d)", path, errno); _rtld_error("%s: error mapping PT_NOTE (%d)", path, errno);
goto error; goto error;
} }
note_start = (Elf_Addr)(note_map + phdr->p_offset - note_start = (Elf_Addr)(note_map + phdr->p_offset -
trunc_page(phdr->p_offset)); rtld_trunc_page(phdr->p_offset));
} else { } else {
note_start = (Elf_Addr)(char *)hdr + phdr->p_offset; note_start = (Elf_Addr)(char *)hdr + phdr->p_offset;
} }
note_end = note_start + phdr->p_filesz; note_end = note_start + phdr->p_filesz;
break; break;
} }
++phdr; ++phdr;
} }
if (phdyn == NULL) { if (phdyn == NULL) {
_rtld_error("%s: object is not dynamically-linked", path); _rtld_error("%s: object is not dynamically-linked", path);
goto error; goto error;
} }
if (nsegs < 0) { if (nsegs < 0) {
_rtld_error("%s: too few PT_LOAD segments", path); _rtld_error("%s: too few PT_LOAD segments", path);
goto error; goto error;
} }
/* /*
* Map the entire address space of the object, to stake out our * Map the entire address space of the object, to stake out our
* contiguous region, and to establish the base address for relocation. * contiguous region, and to establish the base address for relocation.
*/ */
base_vaddr = trunc_page(segs[0]->p_vaddr); base_vaddr = rtld_trunc_page(segs[0]->p_vaddr);
base_vlimit = round_page(segs[nsegs]->p_vaddr + segs[nsegs]->p_memsz); base_vlimit = rtld_round_page(segs[nsegs]->p_vaddr + segs[nsegs]->p_memsz);
mapsize = base_vlimit - base_vaddr; mapsize = base_vlimit - base_vaddr;
base_addr = (caddr_t) base_vaddr; base_addr = (caddr_t) base_vaddr;
base_flags = __getosreldate() >= P_OSREL_MAP_GUARD ? MAP_GUARD : base_flags = __getosreldate() >= P_OSREL_MAP_GUARD ? MAP_GUARD :
MAP_PRIVATE | MAP_ANON | MAP_NOCORE; MAP_PRIVATE | MAP_ANON | MAP_NOCORE;
if (npagesizes > 1 && round_page(segs[0]->p_filesz) >= pagesizes[1]) if (npagesizes > 1 && rtld_round_page(segs[0]->p_filesz) >= pagesizes[1])
base_flags |= MAP_ALIGNED_SUPER; base_flags |= MAP_ALIGNED_SUPER;
if (base_vaddr != 0) if (base_vaddr != 0)
base_flags |= MAP_FIXED | MAP_EXCL; base_flags |= MAP_FIXED | MAP_EXCL;
kibUnsubmitted
Not Done
Inline Actions

This would cause similar ABI issue, since binary built for 4k page with corresponding alignment would be not runnable.

kib: This would cause similar ABI issue, since binary built for 4k page with corresponding alignment…
mapbase = mmap(base_addr, mapsize, PROT_NONE, base_flags, -1, 0); mapbase = mmap(base_addr, mapsize, PROT_NONE, base_flags, -1, 0);
if (mapbase == MAP_FAILED) { if (mapbase == MAP_FAILED) {
_rtld_error("%s: mmap of entire address space failed: %s", _rtld_error("%s: mmap of entire address space failed: %s",
path, rtld_strerror(errno)); path, rtld_strerror(errno));
goto error; goto error;
} }
if (base_addr != NULL && mapbase != base_addr) { if (base_addr != NULL && mapbase != base_addr) {
_rtld_error("%s: mmap returned wrong address: wanted %p, got %p", _rtld_error("%s: mmap returned wrong address: wanted %p, got %p",
path, base_addr, mapbase); path, base_addr, mapbase);
goto error1; goto error1;
} }
for (i = 0; i <= nsegs; i++) { for (i = 0; i <= nsegs; i++) {
/* Overlay the segment onto the proper region. */ /* Overlay the segment onto the proper region. */
data_offset = trunc_page(segs[i]->p_offset); data_offset = rtld_trunc_page(segs[i]->p_offset);
data_vaddr = trunc_page(segs[i]->p_vaddr); data_vaddr = rtld_trunc_page(segs[i]->p_vaddr);
data_vlimit = round_page(segs[i]->p_vaddr + segs[i]->p_filesz); data_vlimit = rtld_round_page(segs[i]->p_vaddr + segs[i]->p_filesz);
data_addr = mapbase + (data_vaddr - base_vaddr); data_addr = mapbase + (data_vaddr - base_vaddr);
data_prot = convert_prot(segs[i]->p_flags); data_prot = convert_prot(segs[i]->p_flags);
data_flags = convert_flags(segs[i]->p_flags) | MAP_FIXED; data_flags = convert_flags(segs[i]->p_flags) | MAP_FIXED;
if (data_vlimit != data_vaddr && if (data_vlimit != data_vaddr &&
mmap(data_addr, data_vlimit - data_vaddr, data_prot, mmap(data_addr, data_vlimit - data_vaddr, data_prot,
data_flags | MAP_PREFAULT_READ, fd, data_offset) == MAP_FAILED) { data_flags | MAP_PREFAULT_READ, fd, data_offset) == MAP_FAILED) {
_rtld_error("%s: mmap of data failed: %s", path, _rtld_error("%s: mmap of data failed: %s", path,
rtld_strerror(errno)); rtld_strerror(errno));
goto error1; goto error1;
} }
/* Do BSS setup */ /* Do BSS setup */
if (segs[i]->p_filesz != segs[i]->p_memsz) { if (segs[i]->p_filesz != segs[i]->p_memsz) {
/* Clear any BSS in the last page of the segment. */ /* Clear any BSS in the last page of the segment. */
clear_vaddr = segs[i]->p_vaddr + segs[i]->p_filesz; clear_vaddr = segs[i]->p_vaddr + segs[i]->p_filesz;
clear_addr = mapbase + (clear_vaddr - base_vaddr); clear_addr = mapbase + (clear_vaddr - base_vaddr);
clear_page = mapbase + (trunc_page(clear_vaddr) - base_vaddr); clear_page = mapbase + (rtld_trunc_page(clear_vaddr) - base_vaddr);
if ((nclear = data_vlimit - clear_vaddr) > 0) { if ((nclear = data_vlimit - clear_vaddr) > 0) {
/* Make sure the end of the segment is writable */ /* Make sure the end of the segment is writable */
if ((data_prot & PROT_WRITE) == 0 && -1 == if ((data_prot & PROT_WRITE) == 0 && -1 ==
mprotect(clear_page, PAGE_SIZE, data_prot|PROT_WRITE)) { mprotect(clear_page, page_size, data_prot|PROT_WRITE)) {
_rtld_error("%s: mprotect failed: %s", path, _rtld_error("%s: mprotect failed: %s", path,
rtld_strerror(errno)); rtld_strerror(errno));
goto error1; goto error1;
} }
memset(clear_addr, 0, nclear); memset(clear_addr, 0, nclear);
/* Reset the data protection back */ /* Reset the data protection back */
if ((data_prot & PROT_WRITE) == 0) if ((data_prot & PROT_WRITE) == 0)
mprotect(clear_page, PAGE_SIZE, data_prot); mprotect(clear_page, page_size, data_prot);
} }
/* Overlay the BSS segment onto the proper region. */ /* Overlay the BSS segment onto the proper region. */
bss_vaddr = data_vlimit; bss_vaddr = data_vlimit;
bss_vlimit = round_page(segs[i]->p_vaddr + segs[i]->p_memsz); bss_vlimit = rtld_round_page(segs[i]->p_vaddr + segs[i]->p_memsz);
bss_addr = mapbase + (bss_vaddr - base_vaddr); bss_addr = mapbase + (bss_vaddr - base_vaddr);
if (bss_vlimit > bss_vaddr) { /* There is something to do */ if (bss_vlimit > bss_vaddr) { /* There is something to do */
if (mmap(bss_addr, bss_vlimit - bss_vaddr, data_prot, if (mmap(bss_addr, bss_vlimit - bss_vaddr, data_prot,
data_flags | MAP_ANON, -1, 0) == MAP_FAILED) { data_flags | MAP_ANON, -1, 0) == MAP_FAILED) {
_rtld_error("%s: mmap of bss failed: %s", path, _rtld_error("%s: mmap of bss failed: %s", path,
rtld_strerror(errno)); rtld_strerror(errno));
goto error1; goto error1;
} }
Show All 39 Linesmap_object(int fd, const char *path, const struct stat *sb)
obj->tlsindex = ++tls_max_index; obj->tlsindex = ++tls_max_index;
obj->tlssize = phtls->p_memsz; obj->tlssize = phtls->p_memsz;
obj->tlsalign = phtls->p_align; obj->tlsalign = phtls->p_align;
obj->tlspoffset = phtls->p_offset; obj->tlspoffset = phtls->p_offset;
obj->tlsinitsize = phtls->p_filesz; obj->tlsinitsize = phtls->p_filesz;
obj->tlsinit = mapbase + phtls->p_vaddr; obj->tlsinit = mapbase + phtls->p_vaddr;
} }
obj->stack_flags = stack_flags; obj->stack_flags = stack_flags;
obj->relro_page = obj->relocbase + trunc_page(relro_page); obj->relro_page = obj->relocbase + rtld_trunc_page(relro_page);
obj->relro_size = trunc_page(relro_page + relro_size) - obj->relro_size = rtld_trunc_page(relro_page + relro_size) -
trunc_page(relro_page); rtld_trunc_page(relro_page);
if (note_start < note_end) if (note_start < note_end)
digest_notes(obj, note_start, note_end); digest_notes(obj, note_start, note_end);
if (note_map != NULL) if (note_map != NULL)
munmap(note_map, note_map_len); munmap(note_map, note_map_len);
munmap(hdr, PAGE_SIZE); munmap(hdr, page_size);
return (obj); return (obj);
error1: error1:
munmap(mapbase, mapsize); munmap(mapbase, mapsize);
error: error:
if (note_map != NULL && note_map != MAP_FAILED) if (note_map != NULL && note_map != MAP_FAILED)
munmap(note_map, note_map_len); munmap(note_map, note_map_len);
if (!phdr_in_zero_page(hdr)) if (!phdr_in_zero_page(hdr))
munmap(phdr, hdr->e_phnum * sizeof(phdr[0])); munmap(phdr, hdr->e_phnum * sizeof(phdr[0]));
munmap(hdr, PAGE_SIZE); munmap(hdr, page_size);
return (NULL); return (NULL);
} }
bool bool
check_elf_headers(const Elf_Ehdr *hdr, const char *path) check_elf_headers(const Elf_Ehdr *hdr, const char *path)
{ {
if (!IS_ELF(*hdr)) { if (!IS_ELF(*hdr)) {
_rtld_error("%s: invalid file format", path); _rtld_error("%s: invalid file format", path);
Show All 33 Linesget_elf_header(int fd, const char *path, const struct stat *sbp,
Elf_Phdr *phdr; Elf_Phdr *phdr;
/* Make sure file has enough data for the ELF header */ /* Make sure file has enough data for the ELF header */
if (sbp != NULL && sbp->st_size < (off_t)sizeof(Elf_Ehdr)) { if (sbp != NULL && sbp->st_size < (off_t)sizeof(Elf_Ehdr)) {
_rtld_error("%s: invalid file format", path); _rtld_error("%s: invalid file format", path);
return (NULL); return (NULL);
} }
hdr = mmap(NULL, PAGE_SIZE, PROT_READ, MAP_PRIVATE | MAP_PREFAULT_READ, hdr = mmap(NULL, page_size, PROT_READ, MAP_PRIVATE | MAP_PREFAULT_READ,
fd, 0); fd, 0);
if (hdr == MAP_FAILED) { if (hdr == MAP_FAILED) {
_rtld_error("%s: read error: %s", path, rtld_strerror(errno)); _rtld_error("%s: read error: %s", path, rtld_strerror(errno));
return (NULL); return (NULL);
} }
/* Make sure the file is valid */ /* Make sure the file is valid */
if (!check_elf_headers(hdr, path)) if (!check_elf_headers(hdr, path))
Show All 15 Lines if (phdr == MAP_FAILED) {
rtld_strerror(errno)); rtld_strerror(errno));
goto error; goto error;
} }
} }
*phdr_p = phdr; *phdr_p = phdr;
return (hdr); return (hdr);
error: error:
munmap(hdr, PAGE_SIZE); munmap(hdr, page_size);
return (NULL); return (NULL);
} }
void void
obj_free(Obj_Entry *obj) obj_free(Obj_Entry *obj)
{ {
Objlist_Entry *elm; Objlist_Entry *elm;
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines
View Options

net/scapy/files/patch-setup.py

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linesstatic Elf_Ehdr *get_elf_header(int, const char *, const struct stat *,
Elf_Phdr **phdr); Elf_Phdr **phdr);
static int convert_flags(int); /* Elf flags -> mmap flags */ static int convert_flags(int); /* Elf flags -> mmap flags */
int __getosreldate(void); int __getosreldate(void);
static bool static bool
phdr_in_zero_page(const Elf_Ehdr *hdr) phdr_in_zero_page(const Elf_Ehdr *hdr)
{ {
return (hdr->e_phoff + hdr->e_phnum * sizeof(Elf_Phdr) <= return (hdr->e_phoff + hdr->e_phnum * sizeof(Elf_Phdr) <= page_size);
(size_t)PAGE_SIZE);
} }
/* /*
* Map a shared object into memory. The "fd" argument is a file descriptor, * Map a shared object into memory. The "fd" argument is a file descriptor,
* which must be open on the object and positioned at its beginning. * which must be open on the object and positioned at its beginning.
* The "path" argument is a pathname that is used only for error messages. * The "path" argument is a pathname that is used only for error messages.
* *
* The return value is a pointer to a newly-allocated Obj_Entry structure * The return value is a pointer to a newly-allocated Obj_Entry structure
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Linesmap_object(int fd, const char *path, const struct stat *sb)
switch (phdr->p_type) { switch (phdr->p_type) {
case PT_INTERP: case PT_INTERP:
phinterp = phdr; phinterp = phdr;
break; break;
case PT_LOAD: case PT_LOAD:
segs[++nsegs] = phdr; segs[++nsegs] = phdr;
if ((segs[nsegs]->p_align & (PAGE_SIZE - 1)) != 0) { if ((segs[nsegs]->p_align & (page_size - 1)) != 0) {
kibUnsubmitted
Not Done
Inline Actions

I must admit this changes ABI.

kib: I must admit this changes ABI.
andrewAuthorUnsubmitted
Done
Inline Actions

That is expected. Userspace from <= 13 is not expected to run on a kernel built with 16k PAGE_SIZE. It will be a non-default option that the user has to enable with the understanding it will break the ABI.

I would like to make the alignment 64k here on arm64 for 14+. It should be safe as the linker should already use 64k alignment, however I'd expect to keep 4k for older binaries.

andrew: That is expected. Userspace from <= 13 is not expected to run on a kernel built with 16k…
_rtld_error("%s: PT_LOAD segment %d not page-aligned", _rtld_error("%s: PT_LOAD segment %d not page-aligned",
path, nsegs); path, nsegs);
goto error; goto error;
} }
if ((segs[nsegs]->p_flags & PF_X) == PF_X) { if ((segs[nsegs]->p_flags & PF_X) == PF_X) {
text_end = MAX(text_end, text_end = MAX(text_end,
round_page(segs[nsegs]->p_vaddr + segs[nsegs]->p_memsz)); rtld_round_page(segs[nsegs]->p_vaddr +
segs[nsegs]->p_memsz));
} }
break; break;
case PT_PHDR: case PT_PHDR:
phdr_vaddr = phdr->p_vaddr; phdr_vaddr = phdr->p_vaddr;
phsize = phdr->p_memsz; phsize = phdr->p_memsz;
break; break;
Show All 10 Lines case PT_GNU_STACK:
break; break;
case PT_GNU_RELRO: case PT_GNU_RELRO:
relro_page = phdr->p_vaddr; relro_page = phdr->p_vaddr;
relro_size = phdr->p_memsz; relro_size = phdr->p_memsz;
break; break;
case PT_NOTE: case PT_NOTE:
if (phdr->p_offset > PAGE_SIZE || if (phdr->p_offset > page_size ||
phdr->p_offset + phdr->p_filesz > PAGE_SIZE) { phdr->p_offset + phdr->p_filesz > page_size) {
note_map_len = round_page(phdr->p_offset + note_map_len = rtld_round_page(phdr->p_offset +
phdr->p_filesz) - trunc_page(phdr->p_offset); phdr->p_filesz) - rtld_trunc_page(phdr->p_offset);
note_map = mmap(NULL, note_map_len, PROT_READ, note_map = mmap(NULL, note_map_len, PROT_READ,
MAP_PRIVATE, fd, trunc_page(phdr->p_offset)); MAP_PRIVATE, fd, rtld_trunc_page(phdr->p_offset));
if (note_map == MAP_FAILED) { if (note_map == MAP_FAILED) {
_rtld_error("%s: error mapping PT_NOTE (%d)", path, errno); _rtld_error("%s: error mapping PT_NOTE (%d)", path, errno);
goto error; goto error;
} }
note_start = (Elf_Addr)(note_map + phdr->p_offset - note_start = (Elf_Addr)(note_map + phdr->p_offset -
trunc_page(phdr->p_offset)); rtld_trunc_page(phdr->p_offset));
} else { } else {
note_start = (Elf_Addr)(char *)hdr + phdr->p_offset; note_start = (Elf_Addr)(char *)hdr + phdr->p_offset;
} }
note_end = note_start + phdr->p_filesz; note_end = note_start + phdr->p_filesz;
break; break;
} }
++phdr; ++phdr;
} }
if (phdyn == NULL) { if (phdyn == NULL) {
_rtld_error("%s: object is not dynamically-linked", path); _rtld_error("%s: object is not dynamically-linked", path);
goto error; goto error;
} }
if (nsegs < 0) { if (nsegs < 0) {
_rtld_error("%s: too few PT_LOAD segments", path); _rtld_error("%s: too few PT_LOAD segments", path);
goto error; goto error;
} }
/* /*
* Map the entire address space of the object, to stake out our * Map the entire address space of the object, to stake out our
* contiguous region, and to establish the base address for relocation. * contiguous region, and to establish the base address for relocation.
*/ */
base_vaddr = trunc_page(segs[0]->p_vaddr); base_vaddr = rtld_trunc_page(segs[0]->p_vaddr);
base_vlimit = round_page(segs[nsegs]->p_vaddr + segs[nsegs]->p_memsz); base_vlimit = rtld_round_page(segs[nsegs]->p_vaddr + segs[nsegs]->p_memsz);
mapsize = base_vlimit - base_vaddr; mapsize = base_vlimit - base_vaddr;
base_addr = (caddr_t) base_vaddr; base_addr = (caddr_t) base_vaddr;
base_flags = __getosreldate() >= P_OSREL_MAP_GUARD ? MAP_GUARD : base_flags = __getosreldate() >= P_OSREL_MAP_GUARD ? MAP_GUARD :
MAP_PRIVATE | MAP_ANON | MAP_NOCORE; MAP_PRIVATE | MAP_ANON | MAP_NOCORE;
if (npagesizes > 1 && round_page(segs[0]->p_filesz) >= pagesizes[1]) if (npagesizes > 1 && rtld_round_page(segs[0]->p_filesz) >= pagesizes[1])
base_flags |= MAP_ALIGNED_SUPER; base_flags |= MAP_ALIGNED_SUPER;
if (base_vaddr != 0) if (base_vaddr != 0)
base_flags |= MAP_FIXED | MAP_EXCL; base_flags |= MAP_FIXED | MAP_EXCL;
kibUnsubmitted
Not Done
Inline Actions

This would cause similar ABI issue, since binary built for 4k page with corresponding alignment would be not runnable.

kib: This would cause similar ABI issue, since binary built for 4k page with corresponding alignment…
mapbase = mmap(base_addr, mapsize, PROT_NONE, base_flags, -1, 0); mapbase = mmap(base_addr, mapsize, PROT_NONE, base_flags, -1, 0);
if (mapbase == MAP_FAILED) { if (mapbase == MAP_FAILED) {
_rtld_error("%s: mmap of entire address space failed: %s", _rtld_error("%s: mmap of entire address space failed: %s",
path, rtld_strerror(errno)); path, rtld_strerror(errno));
goto error; goto error;
} }
if (base_addr != NULL && mapbase != base_addr) { if (base_addr != NULL && mapbase != base_addr) {
_rtld_error("%s: mmap returned wrong address: wanted %p, got %p", _rtld_error("%s: mmap returned wrong address: wanted %p, got %p",
path, base_addr, mapbase); path, base_addr, mapbase);
goto error1; goto error1;
} }
for (i = 0; i <= nsegs; i++) { for (i = 0; i <= nsegs; i++) {
/* Overlay the segment onto the proper region. */ /* Overlay the segment onto the proper region. */
data_offset = trunc_page(segs[i]->p_offset); data_offset = rtld_trunc_page(segs[i]->p_offset);
data_vaddr = trunc_page(segs[i]->p_vaddr); data_vaddr = rtld_trunc_page(segs[i]->p_vaddr);
data_vlimit = round_page(segs[i]->p_vaddr + segs[i]->p_filesz); data_vlimit = rtld_round_page(segs[i]->p_vaddr + segs[i]->p_filesz);
data_addr = mapbase + (data_vaddr - base_vaddr); data_addr = mapbase + (data_vaddr - base_vaddr);
data_prot = convert_prot(segs[i]->p_flags); data_prot = convert_prot(segs[i]->p_flags);
data_flags = convert_flags(segs[i]->p_flags) | MAP_FIXED; data_flags = convert_flags(segs[i]->p_flags) | MAP_FIXED;
if (data_vlimit != data_vaddr && if (data_vlimit != data_vaddr &&
mmap(data_addr, data_vlimit - data_vaddr, data_prot, mmap(data_addr, data_vlimit - data_vaddr, data_prot,
data_flags | MAP_PREFAULT_READ, fd, data_offset) == MAP_FAILED) { data_flags | MAP_PREFAULT_READ, fd, data_offset) == MAP_FAILED) {
_rtld_error("%s: mmap of data failed: %s", path, _rtld_error("%s: mmap of data failed: %s", path,
rtld_strerror(errno)); rtld_strerror(errno));
goto error1; goto error1;
} }
/* Do BSS setup */ /* Do BSS setup */
if (segs[i]->p_filesz != segs[i]->p_memsz) { if (segs[i]->p_filesz != segs[i]->p_memsz) {
/* Clear any BSS in the last page of the segment. */ /* Clear any BSS in the last page of the segment. */
clear_vaddr = segs[i]->p_vaddr + segs[i]->p_filesz; clear_vaddr = segs[i]->p_vaddr + segs[i]->p_filesz;
clear_addr = mapbase + (clear_vaddr - base_vaddr); clear_addr = mapbase + (clear_vaddr - base_vaddr);
clear_page = mapbase + (trunc_page(clear_vaddr) - base_vaddr); clear_page = mapbase + (rtld_trunc_page(clear_vaddr) - base_vaddr);
if ((nclear = data_vlimit - clear_vaddr) > 0) { if ((nclear = data_vlimit - clear_vaddr) > 0) {
/* Make sure the end of the segment is writable */ /* Make sure the end of the segment is writable */
if ((data_prot & PROT_WRITE) == 0 && -1 == if ((data_prot & PROT_WRITE) == 0 && -1 ==
mprotect(clear_page, PAGE_SIZE, data_prot|PROT_WRITE)) { mprotect(clear_page, page_size, data_prot|PROT_WRITE)) {
_rtld_error("%s: mprotect failed: %s", path, _rtld_error("%s: mprotect failed: %s", path,
rtld_strerror(errno)); rtld_strerror(errno));
goto error1; goto error1;
} }
memset(clear_addr, 0, nclear); memset(clear_addr, 0, nclear);
/* Reset the data protection back */ /* Reset the data protection back */
if ((data_prot & PROT_WRITE) == 0) if ((data_prot & PROT_WRITE) == 0)
mprotect(clear_page, PAGE_SIZE, data_prot); mprotect(clear_page, page_size, data_prot);
} }
/* Overlay the BSS segment onto the proper region. */ /* Overlay the BSS segment onto the proper region. */
bss_vaddr = data_vlimit; bss_vaddr = data_vlimit;
bss_vlimit = round_page(segs[i]->p_vaddr + segs[i]->p_memsz); bss_vlimit = rtld_round_page(segs[i]->p_vaddr + segs[i]->p_memsz);
bss_addr = mapbase + (bss_vaddr - base_vaddr); bss_addr = mapbase + (bss_vaddr - base_vaddr);
if (bss_vlimit > bss_vaddr) { /* There is something to do */ if (bss_vlimit > bss_vaddr) { /* There is something to do */
if (mmap(bss_addr, bss_vlimit - bss_vaddr, data_prot, if (mmap(bss_addr, bss_vlimit - bss_vaddr, data_prot,
data_flags | MAP_ANON, -1, 0) == MAP_FAILED) { data_flags | MAP_ANON, -1, 0) == MAP_FAILED) {
_rtld_error("%s: mmap of bss failed: %s", path, _rtld_error("%s: mmap of bss failed: %s", path,
rtld_strerror(errno)); rtld_strerror(errno));
goto error1; goto error1;
} }
Show All 39 Linesmap_object(int fd, const char *path, const struct stat *sb)
obj->tlsindex = ++tls_max_index; obj->tlsindex = ++tls_max_index;
obj->tlssize = phtls->p_memsz; obj->tlssize = phtls->p_memsz;
obj->tlsalign = phtls->p_align; obj->tlsalign = phtls->p_align;
obj->tlspoffset = phtls->p_offset; obj->tlspoffset = phtls->p_offset;
obj->tlsinitsize = phtls->p_filesz; obj->tlsinitsize = phtls->p_filesz;
obj->tlsinit = mapbase + phtls->p_vaddr; obj->tlsinit = mapbase + phtls->p_vaddr;
} }
obj->stack_flags = stack_flags; obj->stack_flags = stack_flags;
obj->relro_page = obj->relocbase + trunc_page(relro_page); obj->relro_page = obj->relocbase + rtld_trunc_page(relro_page);
obj->relro_size = trunc_page(relro_page + relro_size) - obj->relro_size = rtld_trunc_page(relro_page + relro_size) -
trunc_page(relro_page); rtld_trunc_page(relro_page);
if (note_start < note_end) if (note_start < note_end)
digest_notes(obj, note_start, note_end); digest_notes(obj, note_start, note_end);
if (note_map != NULL) if (note_map != NULL)
munmap(note_map, note_map_len); munmap(note_map, note_map_len);
munmap(hdr, PAGE_SIZE); munmap(hdr, page_size);
return (obj); return (obj);
error1: error1:
munmap(mapbase, mapsize); munmap(mapbase, mapsize);
error: error:
if (note_map != NULL && note_map != MAP_FAILED) if (note_map != NULL && note_map != MAP_FAILED)
munmap(note_map, note_map_len); munmap(note_map, note_map_len);
if (!phdr_in_zero_page(hdr)) if (!phdr_in_zero_page(hdr))
munmap(phdr, hdr->e_phnum * sizeof(phdr[0])); munmap(phdr, hdr->e_phnum * sizeof(phdr[0]));
munmap(hdr, PAGE_SIZE); munmap(hdr, page_size);
return (NULL); return (NULL);
} }
bool bool
check_elf_headers(const Elf_Ehdr *hdr, const char *path) check_elf_headers(const Elf_Ehdr *hdr, const char *path)
{ {
if (!IS_ELF(*hdr)) { if (!IS_ELF(*hdr)) {
_rtld_error("%s: invalid file format", path); _rtld_error("%s: invalid file format", path);
Show All 33 Linesget_elf_header(int fd, const char *path, const struct stat *sbp,
Elf_Phdr *phdr; Elf_Phdr *phdr;
/* Make sure file has enough data for the ELF header */ /* Make sure file has enough data for the ELF header */
if (sbp != NULL && sbp->st_size < (off_t)sizeof(Elf_Ehdr)) { if (sbp != NULL && sbp->st_size < (off_t)sizeof(Elf_Ehdr)) {
_rtld_error("%s: invalid file format", path); _rtld_error("%s: invalid file format", path);
return (NULL); return (NULL);
} }
hdr = mmap(NULL, PAGE_SIZE, PROT_READ, MAP_PRIVATE | MAP_PREFAULT_READ, hdr = mmap(NULL, page_size, PROT_READ, MAP_PRIVATE | MAP_PREFAULT_READ,
fd, 0); fd, 0);
if (hdr == MAP_FAILED) { if (hdr == MAP_FAILED) {
_rtld_error("%s: read error: %s", path, rtld_strerror(errno)); _rtld_error("%s: read error: %s", path, rtld_strerror(errno));
return (NULL); return (NULL);
} }
/* Make sure the file is valid */ /* Make sure the file is valid */
if (!check_elf_headers(hdr, path)) if (!check_elf_headers(hdr, path))
Show All 15 Lines if (phdr == MAP_FAILED) {
rtld_strerror(errno)); rtld_strerror(errno));
goto error; goto error;
} }
} }
*phdr_p = phdr; *phdr_p = phdr;
return (hdr); return (hdr);
error: error:
munmap(hdr, PAGE_SIZE); munmap(hdr, page_size);
return (NULL); return (NULL);
} }
void void
obj_free(Obj_Entry *obj) obj_free(Obj_Entry *obj)
{ {
Objlist_Entry *elm; Objlist_Entry *elm;
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines