elf: avoid copying read only sections

[alessandrod]

Only copy read only sections if there's gaps between the sections. If all sections are contiguous in memory, slice them from the original ELF data.

[alessandrod]

This should be the only slightly controversial change. Given the following ELF layout:

[leading data][ro data][trailing data]

• Accessing [trailing data] (1 byte past the last readonly byte), always returns EbpfError::InvalidVirtualAddress.
• When there's gaps between the sections that form [ro data], the data is copied and the gaps, including [leading data] are filled with zeroes.
• When there's no gaps between the sections that form [ro data], the data is borrowed and accessing [leading data] returns EbpfError::InvalidVirtualAddress. This is so that we don't expose bits of the input ELF that are not part of rodata.

So to sum up the difference: owned sections fill the gap until the beginning of rodata with zeros; when borrowing we can't fill, so we return an error.

I'm now going to add a config switch to toggle borrowed ro sections and my question is: if the switch is on, should I also go ahead and return EbpfError::InvalidVirtualAddress when accessing [leading data] with owned sections too?

[jackcmay]

That sounds consistent and also throws a legit error because the program should not be accessing elf data outside of the text or ro sections.

[alessandrod]

Ok this is now implemented behind Config::optimize_rodata.

[Lichtso]

The additional load operation here could be problematic and needs to be benchmarked to estimate the performance impact.

[alessandrod]

Very unscientific comparison:

• elf load diff (old is main, new is this PR)

 running 3 tests
-test bench_load_elf                 ... bench:       2,868 ns/iter (+/- 57)
-test bench_load_elf_with_syscall    ... bench:       2,866 ns/iter (+/- 104)
-test bench_load_elf_without_syscall ... bench:       2,869 ns/iter (+/- 26)
+test bench_load_elf                 ... bench:       2,745 ns/iter (+/- 12)
+test bench_load_elf_with_syscall    ... bench:       2,742 ns/iter (+/- 15)
+test bench_load_elf_without_syscall ... bench:       2,763 ns/iter (+/- 124)

• memory mapping diff

@@ -160,24 +169,24 @@
 test bench_gapped_randomized_access_with_1024_entries  ... bench:           6 ns/iter (+/- 0)
 test bench_mapping_with_1024_entries                   ... bench:           4 ns/iter (+/- 0)
 test bench_prng                                        ... bench:           1 ns/iter (+/- 0)
-test bench_randomized_access_with_0001_entry           ... bench:           6 ns/iter (+/- 0)
+test bench_randomized_access_with_0001_entry           ... bench:           5 ns/iter (+/- 0)
 test bench_randomized_access_with_1024_entries         ... bench:           7 ns/iter (+/- 0)
-test bench_randomized_mapping_access_with_0004_entries ... bench:          20 ns/iter (+/- 0)
+test bench_randomized_mapping_access_with_0004_entries ... bench:          19 ns/iter (+/- 0)
 test bench_randomized_mapping_access_with_0016_entries ... bench:          12 ns/iter (+/- 0)
 test bench_randomized_mapping_access_with_0064_entries ... bench:           8 ns/iter (+/- 0)
 test bench_randomized_mapping_access_with_0256_entries ... bench:           7 ns/iter (+/- 0)
 test bench_randomized_mapping_access_with_1024_entries ... bench:           7 ns/iter (+/- 0)
 test bench_randomized_mapping_with_1024_entries        ... bench:           4 ns/iter (+/- 0)

So pretty much the same

[alessandrod]

...and I just realized that the mapping benches don't exercise the jit. All the other benches are the same so I'm fairly sure there's no regressions, but I'll write some JIT mapping tests.

[alessandrod]

I've added some benches and this is the diff:

 name                                                        main ns/iter  no_ro ns/iter  diff ns/iter  diff %  speedup 
 bench_jit_vs_interpreter_address_translation                269,260       274,264               5,004   1.86%   x 0.98 
 bench_jit_vs_interpreter_address_translation_stack_dynamic  216,047       220,829               4,782   2.21%   x 0.98 
 bench_jit_vs_interpreter_address_translation_stack_fixed    251,375       256,889               5,514   2.19%   x 0.98 

There's a 1-2% diff. Keeping in mind that I'm running on my laptop, and that sometimes - probably because of scheduling - I get diff noise up to ~8% for the same code, I think it's fine.