elf: Replace tst-p_alignmod1-editX with a python script
Checks
| Context |
Check |
Description |
| dj/TryBot-apply_patch |
success
|
Patch applied to master at the time it was sent
|
| dj/TryBot-32bit |
success
|
Build for i686
|
Commit Message
This avoid the cross-compiling breakage when the test should not run
($(run-built-tests) equal to no).
Checked on x86_64-linux-gnu and i686-linux-gnu as well with a cross
compile to aarch64-linux-gnu and powerpc64-linux-gnu.
---
elf/Makefile | 14 +--
elf/tst-elf-edit.h | 126 -----------------------
elf/tst-p_alignmod1-edit.c | 27 -----
elf/tst-p_alignmod2-edit.c | 27 -----
scripts/tst-elf-edit.py | 206 +++++++++++++++++++++++++++++++++++++
5 files changed, 210 insertions(+), 190 deletions(-)
delete mode 100644 elf/tst-elf-edit.h
delete mode 100644 elf/tst-p_alignmod1-edit.c
delete mode 100644 elf/tst-p_alignmod2-edit.c
create mode 100644 scripts/tst-elf-edit.py
Comments
* Adhemerval Zanella via Libc-alpha:
> diff --git a/scripts/tst-elf-edit.py b/scripts/tst-elf-edit.py
> new file mode 100644
> index 0000000000..1fb9b8e0fe
> --- /dev/null
> +++ b/scripts/tst-elf-edit.py
> @@ -0,0 +1,206 @@
> +class Elf_Ehdr:
> + def __init__(self, e_ident):
> + endian, addr, off = elf_types_fmts(e_ident)
> + self.fmt = '{0}HHI{1}{2}{2}IHHHHHH'.format(endian, addr, off)
> + self.len = struct.calcsize(self.fmt)
> +
> + def read(self, f):
> + buf = f.read(self.len)
> + if not buf:
> + error('{}: header too small'.format(f.name))
I think you need to check len(buf) < self.len.
> +class Elf_Phdr:
> + def __init__(self, e_ident):
> + endian, addr, off = elf_types_fmts(e_ident)
> + self.ei_class = e_ident[EI_CLASS]
> + if self.ei_class == ELFCLASS32:
> + self.fmt = '{0}I{2}{1}{1}IIII'.format(endian, addr, off)
> + else:
> + self.fmt = '{0}II{2}{1}{1}QQQ'.format(endian, addr, off)
> + self.len = struct.calcsize(self.fmt)
> +
> + def read(self, f):
> + buf = f.read(self.len)
> + if not buf:
> + error('{}: program header too small'.format(f.name))
Here as well.
Rest looks okay.
Thanks,
Florian
On 26/01/2022 07:09, Florian Weimer wrote:
> * Adhemerval Zanella via Libc-alpha:
>
>> diff --git a/scripts/tst-elf-edit.py b/scripts/tst-elf-edit.py
>> new file mode 100644
>> index 0000000000..1fb9b8e0fe
>> --- /dev/null
>> +++ b/scripts/tst-elf-edit.py
>> @@ -0,0 +1,206 @@
>
>> +class Elf_Ehdr:
>> + def __init__(self, e_ident):
>> + endian, addr, off = elf_types_fmts(e_ident)
>> + self.fmt = '{0}HHI{1}{2}{2}IHHHHHH'.format(endian, addr, off)
>> + self.len = struct.calcsize(self.fmt)
>> +
>> + def read(self, f):
>> + buf = f.read(self.len)
>> + if not buf:
>> + error('{}: header too small'.format(f.name))
>
> I think you need to check len(buf) < self.len.
Ack.
>
>> +class Elf_Phdr:
>> + def __init__(self, e_ident):
>> + endian, addr, off = elf_types_fmts(e_ident)
>> + self.ei_class = e_ident[EI_CLASS]
>> + if self.ei_class == ELFCLASS32:
>> + self.fmt = '{0}I{2}{1}{1}IIII'.format(endian, addr, off)
>> + else:
>> + self.fmt = '{0}II{2}{1}{1}QQQ'.format(endian, addr, off)
>> + self.len = struct.calcsize(self.fmt)
>> +
>> + def read(self, f):
>> + buf = f.read(self.len)
>> + if not buf:
>> + error('{}: program header too small'.format(f.name))
>
> Here as well.
Ack.
>
> Rest looks okay.
Thanks, I push it upstream with the above fixes installed.
On Wed, Jan 26, 2022 at 4:10 AM Adhemerval Zanella
<adhemerval.zanella@linaro.org> wrote:
>
>
>
> On 26/01/2022 07:09, Florian Weimer wrote:
> > * Adhemerval Zanella via Libc-alpha:
> >
> >> diff --git a/scripts/tst-elf-edit.py b/scripts/tst-elf-edit.py
> >> new file mode 100644
> >> index 0000000000..1fb9b8e0fe
> >> --- /dev/null
> >> +++ b/scripts/tst-elf-edit.py
> >> @@ -0,0 +1,206 @@
> >
> >> +class Elf_Ehdr:
> >> + def __init__(self, e_ident):
> >> + endian, addr, off = elf_types_fmts(e_ident)
> >> + self.fmt = '{0}HHI{1}{2}{2}IHHHHHH'.format(endian, addr, off)
> >> + self.len = struct.calcsize(self.fmt)
> >> +
> >> + def read(self, f):
> >> + buf = f.read(self.len)
> >> + if not buf:
> >> + error('{}: header too small'.format(f.name))
> >
> > I think you need to check len(buf) < self.len.
>
> Ack.
>
> >
> >> +class Elf_Phdr:
> >> + def __init__(self, e_ident):
> >> + endian, addr, off = elf_types_fmts(e_ident)
> >> + self.ei_class = e_ident[EI_CLASS]
> >> + if self.ei_class == ELFCLASS32:
> >> + self.fmt = '{0}I{2}{1}{1}IIII'.format(endian, addr, off)
> >> + else:
> >> + self.fmt = '{0}II{2}{1}{1}QQQ'.format(endian, addr, off)
> >> + self.len = struct.calcsize(self.fmt)
> >> +
> >> + def read(self, f):
> >> + buf = f.read(self.len)
> >> + if not buf:
> >> + error('{}: program header too small'.format(f.name))
> >
> > Here as well.
>
> Ack.
>
> >
> > Rest looks okay.
>
> Thanks, I push it upstream with the above fixes installed.
I got
FAIL: elf/tst-p_align3
[hjl@gnu-tgl-2 build-x86_64-linux]$ cat elf/tst-p_align3.out
/export/build/gnu/tools-build/glibc-cet-gitlab/build-x86_64-linux/elf/tst-p_align3:
error while loading shared libraries:
/export/build/gnu/tools-build/glibc-cet-gitlab/build-x86_64-linux/elf/tst-p_alignmod3.so:
cannot change memory protections
[hjl@gnu-tgl-2 build-x86_64-linux]$
Only p_align should be changed to 0x100. But I saw
@@ -5,24 +5,24 @@ There are 11 program headers, starting a
Program Headers:
Type Offset VirtAddr PhysAddr
FileSiz MemSiz Flg Align
- LOAD 0x000000 0x0000000000000000 0x0000000000000000
0x000d38 0x000d38 R 0x200000
- LOAD 0x200000 0x0000000000200000 0x0000000000200000
0x0004c5 0x0004c5 R E 0x200000
- LOAD 0x400000 0x0000000000400000 0x0000000000400000
0x000340 0x000340 R 0x200000
- LOAD 0x400340 0x0000000000600340 0x0000000000600340
0x1ffcc4 0x1ffcd8 RW 0x200000
- DYNAMIC 0x400360 0x0000000000600360 0x0000000000600360
0x0001e0 0x0001e0 RW 0x8
+ LOAD 0x000000 0x0000000000000000 0x0000000000000000
0x0008c8 0x0008c8 R 0x100
+ LOAD 0x000900 0x0000000000000900 0x0000000000000900
0x000115 0x000115 R E 0x100
+ LOAD 0x000b00 0x0000000000000b00 0x0000000000000b00
0x000098 0x000098 R 0x100
+ LOAD 0x000c18 0x0000000000000c18 0x0000000000000c18
0x000200 0x000208 RW 0x100
+ DYNAMIC 0x000c30 0x0000000000000c30 0x0000000000000c30
0x0001b0 0x0001b0 RW 0x8
NOTE 0x0002a8 0x00000000000002a8 0x00000000000002a8
0x000050 0x000050 R 0x8
NOTE 0x0002f8 0x00000000000002f8 0x00000000000002f8
0x000044 0x000044 R 0x4
GNU_PROPERTY 0x0002a8 0x00000000000002a8 0x00000000000002a8
0x000050 0x000050 R 0x8
- GNU_EH_FRAME 0x400118 0x0000000000400118 0x0000000000400118
0x000074 0x000074 R 0x4
+ GNU_EH_FRAME 0x000b00 0x0000000000000b00 0x0000000000000b00
0x000024 0x000024 R 0x4
GNU_STACK 0x000000 0x0000000000000000 0x0000000000000000
0x000000 0x000000 RW 0x10
- GNU_RELRO 0x400340 0x0000000000600340 0x0000000000600340
0x000cc0 0x000cc0 R 0x1
+ GNU_RELRO 0x000c18 0x0000000000000c18 0x0000000000000c18
0x0001e8 0x0001e8 R 0x1
Section to Segment mapping:
Segment Sections...
- 00 .note.gnu.property .note.gnu.build-id .note.ABI-tag .hash
.gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn
.rela.plt
- 01 .init .plt .plt.got .plt.sec .text .fini
- 02 .rodata .eh_frame_hdr .eh_frame
- 03 .init_array .fini_array .data.rel.ro .dynamic .got .got.plt
.data .bss
+ 00 .note.gnu.property .note.gnu.build-id .note.ABI-tag .hash
.gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn
+ 01 .init .plt .plt.got .text .fini
+ 02 .eh_frame_hdr .eh_frame
+ 03 .init_array .fini_array .data.rel.ro .dynamic .got .got.plt .bss
04 .dynamic
05 .note.gnu.property
06 .note.gnu.build-id .note.ABI-tag
On 26/01/2022 12:35, H.J. Lu wrote:
> On Wed, Jan 26, 2022 at 4:10 AM Adhemerval Zanella
> <adhemerval.zanella@linaro.org> wrote:
>>
>>
>>
>> On 26/01/2022 07:09, Florian Weimer wrote:
>>> * Adhemerval Zanella via Libc-alpha:
>>>
>>>> diff --git a/scripts/tst-elf-edit.py b/scripts/tst-elf-edit.py
>>>> new file mode 100644
>>>> index 0000000000..1fb9b8e0fe
>>>> --- /dev/null
>>>> +++ b/scripts/tst-elf-edit.py
>>>> @@ -0,0 +1,206 @@
>>>
>>>> +class Elf_Ehdr:
>>>> + def __init__(self, e_ident):
>>>> + endian, addr, off = elf_types_fmts(e_ident)
>>>> + self.fmt = '{0}HHI{1}{2}{2}IHHHHHH'.format(endian, addr, off)
>>>> + self.len = struct.calcsize(self.fmt)
>>>> +
>>>> + def read(self, f):
>>>> + buf = f.read(self.len)
>>>> + if not buf:
>>>> + error('{}: header too small'.format(f.name))
>>>
>>> I think you need to check len(buf) < self.len.
>>
>> Ack.
>>
>>>
>>>> +class Elf_Phdr:
>>>> + def __init__(self, e_ident):
>>>> + endian, addr, off = elf_types_fmts(e_ident)
>>>> + self.ei_class = e_ident[EI_CLASS]
>>>> + if self.ei_class == ELFCLASS32:
>>>> + self.fmt = '{0}I{2}{1}{1}IIII'.format(endian, addr, off)
>>>> + else:
>>>> + self.fmt = '{0}II{2}{1}{1}QQQ'.format(endian, addr, off)
>>>> + self.len = struct.calcsize(self.fmt)
>>>> +
>>>> + def read(self, f):
>>>> + buf = f.read(self.len)
>>>> + if not buf:
>>>> + error('{}: program header too small'.format(f.name))
>>>
>>> Here as well.
>>
>> Ack.
>>
>>>
>>> Rest looks okay.
>>
>> Thanks, I push it upstream with the above fixes installed.
>
> I got
>
> FAIL: elf/tst-p_align3
>
> [hjl@gnu-tgl-2 build-x86_64-linux]$ cat elf/tst-p_align3.out
> /export/build/gnu/tools-build/glibc-cet-gitlab/build-x86_64-linux/elf/tst-p_align3:
> error while loading shared libraries:
> /export/build/gnu/tools-build/glibc-cet-gitlab/build-x86_64-linux/elf/tst-p_alignmod3.so:
> cannot change memory protections
> [hjl@gnu-tgl-2 build-x86_64-linux]$
>
> Only p_align should be changed to 0x100. But I saw
I am not sure if this is related because tst-p_align3 and tst-alignmod3.so uses
LDFLAGS instead:
1644 $(objpfx)tst-align3: $(objpfx)tst-alignmod3.so
1645 ifeq (yes,$(have-fpie))
1646 CFLAGS-tst-align3.c += $(PIE-ccflag)
1647 endif
1648 LDFLAGS-tst-align3 += -Wl,-z,max-page-size=0x200000
1649 LDFLAGS-tst-alignmod3.so += -Wl,-z,max-page-size=0x200000
1650 $(objpfx)tst-alignmod3.so: $(libsupport)
And the patch only changed the way tst-p_align1 and tst-p_align2 modules were
changed.
>
> @@ -5,24 +5,24 @@ There are 11 program headers, starting a
>
> Program Headers:
> Type Offset VirtAddr PhysAddr
> FileSiz MemSiz Flg Align
> - LOAD 0x000000 0x0000000000000000 0x0000000000000000
> 0x000d38 0x000d38 R 0x200000
> - LOAD 0x200000 0x0000000000200000 0x0000000000200000
> 0x0004c5 0x0004c5 R E 0x200000
> - LOAD 0x400000 0x0000000000400000 0x0000000000400000
> 0x000340 0x000340 R 0x200000
> - LOAD 0x400340 0x0000000000600340 0x0000000000600340
> 0x1ffcc4 0x1ffcd8 RW 0x200000
> - DYNAMIC 0x400360 0x0000000000600360 0x0000000000600360
> 0x0001e0 0x0001e0 RW 0x8
> + LOAD 0x000000 0x0000000000000000 0x0000000000000000
> 0x0008c8 0x0008c8 R 0x100
> + LOAD 0x000900 0x0000000000000900 0x0000000000000900
> 0x000115 0x000115 R E 0x100
> + LOAD 0x000b00 0x0000000000000b00 0x0000000000000b00
> 0x000098 0x000098 R 0x100
> + LOAD 0x000c18 0x0000000000000c18 0x0000000000000c18
> 0x000200 0x000208 RW 0x100
> + DYNAMIC 0x000c30 0x0000000000000c30 0x0000000000000c30
> 0x0001b0 0x0001b0 RW 0x8
> NOTE 0x0002a8 0x00000000000002a8 0x00000000000002a8
> 0x000050 0x000050 R 0x8
> NOTE 0x0002f8 0x00000000000002f8 0x00000000000002f8
> 0x000044 0x000044 R 0x4
> GNU_PROPERTY 0x0002a8 0x00000000000002a8 0x00000000000002a8
> 0x000050 0x000050 R 0x8
> - GNU_EH_FRAME 0x400118 0x0000000000400118 0x0000000000400118
> 0x000074 0x000074 R 0x4
> + GNU_EH_FRAME 0x000b00 0x0000000000000b00 0x0000000000000b00
> 0x000024 0x000024 R 0x4
> GNU_STACK 0x000000 0x0000000000000000 0x0000000000000000
> 0x000000 0x000000 RW 0x10
> - GNU_RELRO 0x400340 0x0000000000600340 0x0000000000600340
> 0x000cc0 0x000cc0 R 0x1
> + GNU_RELRO 0x000c18 0x0000000000000c18 0x0000000000000c18
> 0x0001e8 0x0001e8 R 0x1
>
> Section to Segment mapping:
> Segment Sections...
> - 00 .note.gnu.property .note.gnu.build-id .note.ABI-tag .hash
> .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn
> .rela.plt
> - 01 .init .plt .plt.got .plt.sec .text .fini
> - 02 .rodata .eh_frame_hdr .eh_frame
> - 03 .init_array .fini_array .data.rel.ro .dynamic .got .got.plt
> .data .bss
> + 00 .note.gnu.property .note.gnu.build-id .note.ABI-tag .hash
> .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn
> + 01 .init .plt .plt.got .text .fini
> + 02 .eh_frame_hdr .eh_frame
> + 03 .init_array .fini_array .data.rel.ro .dynamic .got .got.plt .bss
> 04 .dynamic
> 05 .note.gnu.property
> 06 .note.gnu.build-id .note.ABI-tag
>
On Wed, Jan 26, 2022 at 7:45 AM Adhemerval Zanella
<adhemerval.zanella@linaro.org> wrote:
>
>
>
> On 26/01/2022 12:35, H.J. Lu wrote:
> > On Wed, Jan 26, 2022 at 4:10 AM Adhemerval Zanella
> > <adhemerval.zanella@linaro.org> wrote:
> >>
> >>
> >>
> >> On 26/01/2022 07:09, Florian Weimer wrote:
> >>> * Adhemerval Zanella via Libc-alpha:
> >>>
> >>>> diff --git a/scripts/tst-elf-edit.py b/scripts/tst-elf-edit.py
> >>>> new file mode 100644
> >>>> index 0000000000..1fb9b8e0fe
> >>>> --- /dev/null
> >>>> +++ b/scripts/tst-elf-edit.py
> >>>> @@ -0,0 +1,206 @@
> >>>
> >>>> +class Elf_Ehdr:
> >>>> + def __init__(self, e_ident):
> >>>> + endian, addr, off = elf_types_fmts(e_ident)
> >>>> + self.fmt = '{0}HHI{1}{2}{2}IHHHHHH'.format(endian, addr, off)
> >>>> + self.len = struct.calcsize(self.fmt)
> >>>> +
> >>>> + def read(self, f):
> >>>> + buf = f.read(self.len)
> >>>> + if not buf:
> >>>> + error('{}: header too small'.format(f.name))
> >>>
> >>> I think you need to check len(buf) < self.len.
> >>
> >> Ack.
> >>
> >>>
> >>>> +class Elf_Phdr:
> >>>> + def __init__(self, e_ident):
> >>>> + endian, addr, off = elf_types_fmts(e_ident)
> >>>> + self.ei_class = e_ident[EI_CLASS]
> >>>> + if self.ei_class == ELFCLASS32:
> >>>> + self.fmt = '{0}I{2}{1}{1}IIII'.format(endian, addr, off)
> >>>> + else:
> >>>> + self.fmt = '{0}II{2}{1}{1}QQQ'.format(endian, addr, off)
> >>>> + self.len = struct.calcsize(self.fmt)
> >>>> +
> >>>> + def read(self, f):
> >>>> + buf = f.read(self.len)
> >>>> + if not buf:
> >>>> + error('{}: program header too small'.format(f.name))
> >>>
> >>> Here as well.
> >>
> >> Ack.
> >>
> >>>
> >>> Rest looks okay.
> >>
> >> Thanks, I push it upstream with the above fixes installed.
> >
> > I got
> >
> > FAIL: elf/tst-p_align3
> >
> > [hjl@gnu-tgl-2 build-x86_64-linux]$ cat elf/tst-p_align3.out
> > /export/build/gnu/tools-build/glibc-cet-gitlab/build-x86_64-linux/elf/tst-p_align3:
> > error while loading shared libraries:
> > /export/build/gnu/tools-build/glibc-cet-gitlab/build-x86_64-linux/elf/tst-p_alignmod3.so:
> > cannot change memory protections
> > [hjl@gnu-tgl-2 build-x86_64-linux]$
> >
> > Only p_align should be changed to 0x100. But I saw
>
> I am not sure if this is related because tst-p_align3 and tst-alignmod3.so uses
> LDFLAGS instead:
>
> 1644 $(objpfx)tst-align3: $(objpfx)tst-alignmod3.so
> 1645 ifeq (yes,$(have-fpie))
> 1646 CFLAGS-tst-align3.c += $(PIE-ccflag)
> 1647 endif
> 1648 LDFLAGS-tst-align3 += -Wl,-z,max-page-size=0x200000
> 1649 LDFLAGS-tst-alignmod3.so += -Wl,-z,max-page-size=0x200000
> 1650 $(objpfx)tst-alignmod3.so: $(libsupport)
>
> And the patch only changed the way tst-p_align1 and tst-p_align2 modules were
> changed.
It is tst-p_alignmod3.so, not tst-alignmod3.so.
^^
> >
> > @@ -5,24 +5,24 @@ There are 11 program headers, starting a
> >
> > Program Headers:
> > Type Offset VirtAddr PhysAddr
> > FileSiz MemSiz Flg Align
> > - LOAD 0x000000 0x0000000000000000 0x0000000000000000
> > 0x000d38 0x000d38 R 0x200000
> > - LOAD 0x200000 0x0000000000200000 0x0000000000200000
> > 0x0004c5 0x0004c5 R E 0x200000
> > - LOAD 0x400000 0x0000000000400000 0x0000000000400000
> > 0x000340 0x000340 R 0x200000
> > - LOAD 0x400340 0x0000000000600340 0x0000000000600340
> > 0x1ffcc4 0x1ffcd8 RW 0x200000
> > - DYNAMIC 0x400360 0x0000000000600360 0x0000000000600360
> > 0x0001e0 0x0001e0 RW 0x8
> > + LOAD 0x000000 0x0000000000000000 0x0000000000000000
> > 0x0008c8 0x0008c8 R 0x100
> > + LOAD 0x000900 0x0000000000000900 0x0000000000000900
> > 0x000115 0x000115 R E 0x100
> > + LOAD 0x000b00 0x0000000000000b00 0x0000000000000b00
> > 0x000098 0x000098 R 0x100
> > + LOAD 0x000c18 0x0000000000000c18 0x0000000000000c18
> > 0x000200 0x000208 RW 0x100
> > + DYNAMIC 0x000c30 0x0000000000000c30 0x0000000000000c30
> > 0x0001b0 0x0001b0 RW 0x8
> > NOTE 0x0002a8 0x00000000000002a8 0x00000000000002a8
> > 0x000050 0x000050 R 0x8
> > NOTE 0x0002f8 0x00000000000002f8 0x00000000000002f8
> > 0x000044 0x000044 R 0x4
> > GNU_PROPERTY 0x0002a8 0x00000000000002a8 0x00000000000002a8
> > 0x000050 0x000050 R 0x8
> > - GNU_EH_FRAME 0x400118 0x0000000000400118 0x0000000000400118
> > 0x000074 0x000074 R 0x4
> > + GNU_EH_FRAME 0x000b00 0x0000000000000b00 0x0000000000000b00
> > 0x000024 0x000024 R 0x4
> > GNU_STACK 0x000000 0x0000000000000000 0x0000000000000000
> > 0x000000 0x000000 RW 0x10
> > - GNU_RELRO 0x400340 0x0000000000600340 0x0000000000600340
> > 0x000cc0 0x000cc0 R 0x1
> > + GNU_RELRO 0x000c18 0x0000000000000c18 0x0000000000000c18
> > 0x0001e8 0x0001e8 R 0x1
> >
> > Section to Segment mapping:
> > Segment Sections...
> > - 00 .note.gnu.property .note.gnu.build-id .note.ABI-tag .hash
> > .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn
> > .rela.plt
> > - 01 .init .plt .plt.got .plt.sec .text .fini
> > - 02 .rodata .eh_frame_hdr .eh_frame
> > - 03 .init_array .fini_array .data.rel.ro .dynamic .got .got.plt
> > .data .bss
> > + 00 .note.gnu.property .note.gnu.build-id .note.ABI-tag .hash
> > .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn
> > + 01 .init .plt .plt.got .text .fini
> > + 02 .eh_frame_hdr .eh_frame
> > + 03 .init_array .fini_array .data.rel.ro .dynamic .got .got.plt .bss
> > 04 .dynamic
> > 05 .note.gnu.property
> > 06 .note.gnu.build-id .note.ABI-tag
> >
On 26/01/2022 12:46, H.J. Lu wrote:
> On Wed, Jan 26, 2022 at 7:45 AM Adhemerval Zanella
> <adhemerval.zanella@linaro.org> wrote:
>>
>>
>>
>> On 26/01/2022 12:35, H.J. Lu wrote:
>>> On Wed, Jan 26, 2022 at 4:10 AM Adhemerval Zanella
>>> <adhemerval.zanella@linaro.org> wrote:
>>>>
>>>>
>>>>
>>>> On 26/01/2022 07:09, Florian Weimer wrote:
>>>>> * Adhemerval Zanella via Libc-alpha:
>>>>>
>>>>>> diff --git a/scripts/tst-elf-edit.py b/scripts/tst-elf-edit.py
>>>>>> new file mode 100644
>>>>>> index 0000000000..1fb9b8e0fe
>>>>>> --- /dev/null
>>>>>> +++ b/scripts/tst-elf-edit.py
>>>>>> @@ -0,0 +1,206 @@
>>>>>
>>>>>> +class Elf_Ehdr:
>>>>>> + def __init__(self, e_ident):
>>>>>> + endian, addr, off = elf_types_fmts(e_ident)
>>>>>> + self.fmt = '{0}HHI{1}{2}{2}IHHHHHH'.format(endian, addr, off)
>>>>>> + self.len = struct.calcsize(self.fmt)
>>>>>> +
>>>>>> + def read(self, f):
>>>>>> + buf = f.read(self.len)
>>>>>> + if not buf:
>>>>>> + error('{}: header too small'.format(f.name))
>>>>>
>>>>> I think you need to check len(buf) < self.len.
>>>>
>>>> Ack.
>>>>
>>>>>
>>>>>> +class Elf_Phdr:
>>>>>> + def __init__(self, e_ident):
>>>>>> + endian, addr, off = elf_types_fmts(e_ident)
>>>>>> + self.ei_class = e_ident[EI_CLASS]
>>>>>> + if self.ei_class == ELFCLASS32:
>>>>>> + self.fmt = '{0}I{2}{1}{1}IIII'.format(endian, addr, off)
>>>>>> + else:
>>>>>> + self.fmt = '{0}II{2}{1}{1}QQQ'.format(endian, addr, off)
>>>>>> + self.len = struct.calcsize(self.fmt)
>>>>>> +
>>>>>> + def read(self, f):
>>>>>> + buf = f.read(self.len)
>>>>>> + if not buf:
>>>>>> + error('{}: program header too small'.format(f.name))
>>>>>
>>>>> Here as well.
>>>>
>>>> Ack.
>>>>
>>>>>
>>>>> Rest looks okay.
>>>>
>>>> Thanks, I push it upstream with the above fixes installed.
>>>
>>> I got
>>>
>>> FAIL: elf/tst-p_align3
>>>
>>> [hjl@gnu-tgl-2 build-x86_64-linux]$ cat elf/tst-p_align3.out
>>> /export/build/gnu/tools-build/glibc-cet-gitlab/build-x86_64-linux/elf/tst-p_align3:
>>> error while loading shared libraries:
>>> /export/build/gnu/tools-build/glibc-cet-gitlab/build-x86_64-linux/elf/tst-p_alignmod3.so:
>>> cannot change memory protections
>>> [hjl@gnu-tgl-2 build-x86_64-linux]$
>>>
>>> Only p_align should be changed to 0x100. But I saw
>>
>> I am not sure if this is related because tst-p_align3 and tst-alignmod3.so uses
>> LDFLAGS instead:
>>
>> 1644 $(objpfx)tst-align3: $(objpfx)tst-alignmod3.so
>> 1645 ifeq (yes,$(have-fpie))
>> 1646 CFLAGS-tst-align3.c += $(PIE-ccflag)
>> 1647 endif
>> 1648 LDFLAGS-tst-align3 += -Wl,-z,max-page-size=0x200000
>> 1649 LDFLAGS-tst-alignmod3.so += -Wl,-z,max-page-size=0x200000
>> 1650 $(objpfx)tst-alignmod3.so: $(libsupport)
>>
>> And the patch only changed the way tst-p_align1 and tst-p_align2 modules were
>> changed.
>
> It is tst-p_alignmod3.so, not tst-alignmod3.so.
> ^^
My confusion here. But even though the script in not involved:
2622 LDFLAGS-tst-p_alignmod3.so += -Wl,-z,max-page-size=0x100,-z,common-page-size=0x100
2623
2624 $(objpfx)tst-p_align3: $(objpfx)tst-p_alignmod3.so
2625 $(objpfx)tst-p_align3.out: tst-p_align3.sh $(objpfx)tst-p_align3
2626 $(SHELL) $< $(common-objpfx) '$(test-program-prefix)'; \
2627 $(evaluate-test)
That's why it is puzzling me that it start to fail now.
On Wed, Jan 26, 2022 at 7:54 AM Adhemerval Zanella
<adhemerval.zanella@linaro.org> wrote:
>
>
>
> On 26/01/2022 12:46, H.J. Lu wrote:
> > On Wed, Jan 26, 2022 at 7:45 AM Adhemerval Zanella
> > <adhemerval.zanella@linaro.org> wrote:
> >>
> >>
> >>
> >> On 26/01/2022 12:35, H.J. Lu wrote:
> >>> On Wed, Jan 26, 2022 at 4:10 AM Adhemerval Zanella
> >>> <adhemerval.zanella@linaro.org> wrote:
> >>>>
> >>>>
> >>>>
> >>>> On 26/01/2022 07:09, Florian Weimer wrote:
> >>>>> * Adhemerval Zanella via Libc-alpha:
> >>>>>
> >>>>>> diff --git a/scripts/tst-elf-edit.py b/scripts/tst-elf-edit.py
> >>>>>> new file mode 100644
> >>>>>> index 0000000000..1fb9b8e0fe
> >>>>>> --- /dev/null
> >>>>>> +++ b/scripts/tst-elf-edit.py
> >>>>>> @@ -0,0 +1,206 @@
> >>>>>
> >>>>>> +class Elf_Ehdr:
> >>>>>> + def __init__(self, e_ident):
> >>>>>> + endian, addr, off = elf_types_fmts(e_ident)
> >>>>>> + self.fmt = '{0}HHI{1}{2}{2}IHHHHHH'.format(endian, addr, off)
> >>>>>> + self.len = struct.calcsize(self.fmt)
> >>>>>> +
> >>>>>> + def read(self, f):
> >>>>>> + buf = f.read(self.len)
> >>>>>> + if not buf:
> >>>>>> + error('{}: header too small'.format(f.name))
> >>>>>
> >>>>> I think you need to check len(buf) < self.len.
> >>>>
> >>>> Ack.
> >>>>
> >>>>>
> >>>>>> +class Elf_Phdr:
> >>>>>> + def __init__(self, e_ident):
> >>>>>> + endian, addr, off = elf_types_fmts(e_ident)
> >>>>>> + self.ei_class = e_ident[EI_CLASS]
> >>>>>> + if self.ei_class == ELFCLASS32:
> >>>>>> + self.fmt = '{0}I{2}{1}{1}IIII'.format(endian, addr, off)
> >>>>>> + else:
> >>>>>> + self.fmt = '{0}II{2}{1}{1}QQQ'.format(endian, addr, off)
> >>>>>> + self.len = struct.calcsize(self.fmt)
> >>>>>> +
> >>>>>> + def read(self, f):
> >>>>>> + buf = f.read(self.len)
> >>>>>> + if not buf:
> >>>>>> + error('{}: program header too small'.format(f.name))
> >>>>>
> >>>>> Here as well.
> >>>>
> >>>> Ack.
> >>>>
> >>>>>
> >>>>> Rest looks okay.
> >>>>
> >>>> Thanks, I push it upstream with the above fixes installed.
> >>>
> >>> I got
> >>>
> >>> FAIL: elf/tst-p_align3
> >>>
> >>> [hjl@gnu-tgl-2 build-x86_64-linux]$ cat elf/tst-p_align3.out
> >>> /export/build/gnu/tools-build/glibc-cet-gitlab/build-x86_64-linux/elf/tst-p_align3:
> >>> error while loading shared libraries:
> >>> /export/build/gnu/tools-build/glibc-cet-gitlab/build-x86_64-linux/elf/tst-p_alignmod3.so:
> >>> cannot change memory protections
> >>> [hjl@gnu-tgl-2 build-x86_64-linux]$
> >>>
> >>> Only p_align should be changed to 0x100. But I saw
> >>
> >> I am not sure if this is related because tst-p_align3 and tst-alignmod3.so uses
> >> LDFLAGS instead:
> >>
> >> 1644 $(objpfx)tst-align3: $(objpfx)tst-alignmod3.so
> >> 1645 ifeq (yes,$(have-fpie))
> >> 1646 CFLAGS-tst-align3.c += $(PIE-ccflag)
> >> 1647 endif
> >> 1648 LDFLAGS-tst-align3 += -Wl,-z,max-page-size=0x200000
> >> 1649 LDFLAGS-tst-alignmod3.so += -Wl,-z,max-page-size=0x200000
> >> 1650 $(objpfx)tst-alignmod3.so: $(libsupport)
> >>
> >> And the patch only changed the way tst-p_align1 and tst-p_align2 modules were
> >> changed.
> >
> > It is tst-p_alignmod3.so, not tst-alignmod3.so.
> > ^^
> My confusion here. But even though the script in not involved:
>
> 2622 LDFLAGS-tst-p_alignmod3.so += -Wl,-z,max-page-size=0x100,-z,common-page-size=0x100
> 2623
> 2624 $(objpfx)tst-p_align3: $(objpfx)tst-p_alignmod3.so
> 2625 $(objpfx)tst-p_align3.out: tst-p_align3.sh $(objpfx)tst-p_align3
> 2626 $(SHELL) $< $(common-objpfx) '$(test-program-prefix)'; \
> 2627 $(evaluate-test)
>
> That's why it is puzzling me that it start to fail now.
This test checks the invalid p_align handling. You have to edit the
binary to change p_align to 0x100 which is invalid.
On 26/01/2022 13:11, H.J. Lu wrote:
> On Wed, Jan 26, 2022 at 7:54 AM Adhemerval Zanella
> <adhemerval.zanella@linaro.org> wrote:
>>
>>
>>
>> On 26/01/2022 12:46, H.J. Lu wrote:
>>> On Wed, Jan 26, 2022 at 7:45 AM Adhemerval Zanella
>>> <adhemerval.zanella@linaro.org> wrote:
>>>>
>>>>
>>>>
>>>> On 26/01/2022 12:35, H.J. Lu wrote:
>>>>> On Wed, Jan 26, 2022 at 4:10 AM Adhemerval Zanella
>>>>> <adhemerval.zanella@linaro.org> wrote:
>>>>>>
>>>>>>
>>>>>>
>>>>>> On 26/01/2022 07:09, Florian Weimer wrote:
>>>>>>> * Adhemerval Zanella via Libc-alpha:
>>>>>>>
>>>>>>>> diff --git a/scripts/tst-elf-edit.py b/scripts/tst-elf-edit.py
>>>>>>>> new file mode 100644
>>>>>>>> index 0000000000..1fb9b8e0fe
>>>>>>>> --- /dev/null
>>>>>>>> +++ b/scripts/tst-elf-edit.py
>>>>>>>> @@ -0,0 +1,206 @@
>>>>>>>
>>>>>>>> +class Elf_Ehdr:
>>>>>>>> + def __init__(self, e_ident):
>>>>>>>> + endian, addr, off = elf_types_fmts(e_ident)
>>>>>>>> + self.fmt = '{0}HHI{1}{2}{2}IHHHHHH'.format(endian, addr, off)
>>>>>>>> + self.len = struct.calcsize(self.fmt)
>>>>>>>> +
>>>>>>>> + def read(self, f):
>>>>>>>> + buf = f.read(self.len)
>>>>>>>> + if not buf:
>>>>>>>> + error('{}: header too small'.format(f.name))
>>>>>>>
>>>>>>> I think you need to check len(buf) < self.len.
>>>>>>
>>>>>> Ack.
>>>>>>
>>>>>>>
>>>>>>>> +class Elf_Phdr:
>>>>>>>> + def __init__(self, e_ident):
>>>>>>>> + endian, addr, off = elf_types_fmts(e_ident)
>>>>>>>> + self.ei_class = e_ident[EI_CLASS]
>>>>>>>> + if self.ei_class == ELFCLASS32:
>>>>>>>> + self.fmt = '{0}I{2}{1}{1}IIII'.format(endian, addr, off)
>>>>>>>> + else:
>>>>>>>> + self.fmt = '{0}II{2}{1}{1}QQQ'.format(endian, addr, off)
>>>>>>>> + self.len = struct.calcsize(self.fmt)
>>>>>>>> +
>>>>>>>> + def read(self, f):
>>>>>>>> + buf = f.read(self.len)
>>>>>>>> + if not buf:
>>>>>>>> + error('{}: program header too small'.format(f.name))
>>>>>>>
>>>>>>> Here as well.
>>>>>>
>>>>>> Ack.
>>>>>>
>>>>>>>
>>>>>>> Rest looks okay.
>>>>>>
>>>>>> Thanks, I push it upstream with the above fixes installed.
>>>>>
>>>>> I got
>>>>>
>>>>> FAIL: elf/tst-p_align3
>>>>>
>>>>> [hjl@gnu-tgl-2 build-x86_64-linux]$ cat elf/tst-p_align3.out
>>>>> /export/build/gnu/tools-build/glibc-cet-gitlab/build-x86_64-linux/elf/tst-p_align3:
>>>>> error while loading shared libraries:
>>>>> /export/build/gnu/tools-build/glibc-cet-gitlab/build-x86_64-linux/elf/tst-p_alignmod3.so:
>>>>> cannot change memory protections
>>>>> [hjl@gnu-tgl-2 build-x86_64-linux]$
>>>>>
>>>>> Only p_align should be changed to 0x100. But I saw
>>>>
>>>> I am not sure if this is related because tst-p_align3 and tst-alignmod3.so uses
>>>> LDFLAGS instead:
>>>>
>>>> 1644 $(objpfx)tst-align3: $(objpfx)tst-alignmod3.so
>>>> 1645 ifeq (yes,$(have-fpie))
>>>> 1646 CFLAGS-tst-align3.c += $(PIE-ccflag)
>>>> 1647 endif
>>>> 1648 LDFLAGS-tst-align3 += -Wl,-z,max-page-size=0x200000
>>>> 1649 LDFLAGS-tst-alignmod3.so += -Wl,-z,max-page-size=0x200000
>>>> 1650 $(objpfx)tst-alignmod3.so: $(libsupport)
>>>>
>>>> And the patch only changed the way tst-p_align1 and tst-p_align2 modules were
>>>> changed.
>>>
>>> It is tst-p_alignmod3.so, not tst-alignmod3.so.
>>> ^^
>> My confusion here. But even though the script in not involved:
>>
>> 2622 LDFLAGS-tst-p_alignmod3.so += -Wl,-z,max-page-size=0x100,-z,common-page-size=0x100
>> 2623
>> 2624 $(objpfx)tst-p_align3: $(objpfx)tst-p_alignmod3.so
>> 2625 $(objpfx)tst-p_align3.out: tst-p_align3.sh $(objpfx)tst-p_align3
>> 2626 $(SHELL) $< $(common-objpfx) '$(test-program-prefix)'; \
>> 2627 $(evaluate-test)
>>
>> That's why it is puzzling me that it start to fail now.
>
> This test checks the invalid p_align handling. You have to edit the
> binary to change p_align to 0x100 which is invalid.
>
But it is already done by the LD_FLAGS above (from elf/Makefile). I am
still failing to understand why my patch that only changes tst-p_align1
and tst-p_align2 objects made tst-p_align3 to fail.
Before:
$ readelf -l elf/tst-p_align3
[...]
LOAD 0x0000000000000000 0x0000000000000000 0x0000000000000000
0x00000000000015c0 0x00000000000015c0 R 0x1000
LOAD 0x0000000000002000 0x0000000000002000 0x0000000000002000
0x0000000000001892 0x0000000000001892 R E 0x1000
LOAD 0x0000000000004000 0x0000000000004000 0x0000000000004000
0x0000000000000d58 0x0000000000000d58 R 0x1000
LOAD 0x0000000000005cf8 0x0000000000006cf8 0x0000000000006cf8
0x0000000000000498 0x00000000000004d8 RW 0x1000
[...]
$ readelf -l elf/tst-p_alignmod3.so
[....]
Program Headers:
Type Offset VirtAddr PhysAddr
FileSiz MemSiz Flags Align
LOAD 0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000540 0x0000000000000540 R 0x100
LOAD 0x0000000000000600 0x0000000000000600 0x0000000000000600
0x00000000000001f2 0x00000000000001f2 R E 0x100
LOAD 0x0000000000000800 0x0000000000000800 0x0000000000000800
0x00000000000000d0 0x00000000000000d0 R 0x100
LOAD 0x0000000000000930 0x0000000000000a30 0x0000000000000a30
0x00000000000001f8 0x0000000000000208 RW 0x100
After:
$ readelf -l elf/tst-p_align3
[...]
LOAD 0x0000000000000000 0x0000000000000000 0x0000000000000000
0x00000000000015b8 0x00000000000015b8 R 0x1000
LOAD 0x0000000000002000 0x0000000000002000 0x0000000000002000
0x0000000000001892 0x0000000000001892 R E 0x1000
LOAD 0x0000000000004000 0x0000000000004000 0x0000000000004000
0x0000000000000d50 0x0000000000000d50 R 0x1000
LOAD 0x0000000000005cf8 0x0000000000006cf8 0x0000000000006cf8
0x0000000000000498 0x00000000000004d8 RW 0x1000
$ readelf -l elf/tst-p_alignmod3.so
Elf file type is DYN (Shared object file)
[....]
Program Headers:
Type Offset VirtAddr PhysAddr
FileSiz MemSiz Flags Align
LOAD 0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000540 0x0000000000000540 R 0x100
LOAD 0x0000000000000600 0x0000000000000600 0x0000000000000600
0x00000000000001f2 0x00000000000001f2 R E 0x100
LOAD 0x0000000000000800 0x0000000000000800 0x0000000000000800
0x00000000000000d0 0x00000000000000d0 R 0x100
LOAD 0x0000000000000930 0x0000000000000a30 0x0000000000000a30
0x00000000000001f8 0x0000000000000208 RW 0x100
So PT_LOAD p_align are still strictly the same.
On Wed, Jan 26, 2022 at 9:11 AM Adhemerval Zanella
<adhemerval.zanella@linaro.org> wrote:
>
>
>
> On 26/01/2022 13:11, H.J. Lu wrote:
> > On Wed, Jan 26, 2022 at 7:54 AM Adhemerval Zanella
> > <adhemerval.zanella@linaro.org> wrote:
> >>
> >>
> >>
> >> On 26/01/2022 12:46, H.J. Lu wrote:
> >>> On Wed, Jan 26, 2022 at 7:45 AM Adhemerval Zanella
> >>> <adhemerval.zanella@linaro.org> wrote:
> >>>>
> >>>>
> >>>>
> >>>> On 26/01/2022 12:35, H.J. Lu wrote:
> >>>>> On Wed, Jan 26, 2022 at 4:10 AM Adhemerval Zanella
> >>>>> <adhemerval.zanella@linaro.org> wrote:
> >>>>>>
> >>>>>>
> >>>>>>
> >>>>>> On 26/01/2022 07:09, Florian Weimer wrote:
> >>>>>>> * Adhemerval Zanella via Libc-alpha:
> >>>>>>>
> >>>>>>>> diff --git a/scripts/tst-elf-edit.py b/scripts/tst-elf-edit.py
> >>>>>>>> new file mode 100644
> >>>>>>>> index 0000000000..1fb9b8e0fe
> >>>>>>>> --- /dev/null
> >>>>>>>> +++ b/scripts/tst-elf-edit.py
> >>>>>>>> @@ -0,0 +1,206 @@
> >>>>>>>
> >>>>>>>> +class Elf_Ehdr:
> >>>>>>>> + def __init__(self, e_ident):
> >>>>>>>> + endian, addr, off = elf_types_fmts(e_ident)
> >>>>>>>> + self.fmt = '{0}HHI{1}{2}{2}IHHHHHH'.format(endian, addr, off)
> >>>>>>>> + self.len = struct.calcsize(self.fmt)
> >>>>>>>> +
> >>>>>>>> + def read(self, f):
> >>>>>>>> + buf = f.read(self.len)
> >>>>>>>> + if not buf:
> >>>>>>>> + error('{}: header too small'.format(f.name))
> >>>>>>>
> >>>>>>> I think you need to check len(buf) < self.len.
> >>>>>>
> >>>>>> Ack.
> >>>>>>
> >>>>>>>
> >>>>>>>> +class Elf_Phdr:
> >>>>>>>> + def __init__(self, e_ident):
> >>>>>>>> + endian, addr, off = elf_types_fmts(e_ident)
> >>>>>>>> + self.ei_class = e_ident[EI_CLASS]
> >>>>>>>> + if self.ei_class == ELFCLASS32:
> >>>>>>>> + self.fmt = '{0}I{2}{1}{1}IIII'.format(endian, addr, off)
> >>>>>>>> + else:
> >>>>>>>> + self.fmt = '{0}II{2}{1}{1}QQQ'.format(endian, addr, off)
> >>>>>>>> + self.len = struct.calcsize(self.fmt)
> >>>>>>>> +
> >>>>>>>> + def read(self, f):
> >>>>>>>> + buf = f.read(self.len)
> >>>>>>>> + if not buf:
> >>>>>>>> + error('{}: program header too small'.format(f.name))
> >>>>>>>
> >>>>>>> Here as well.
> >>>>>>
> >>>>>> Ack.
> >>>>>>
> >>>>>>>
> >>>>>>> Rest looks okay.
> >>>>>>
> >>>>>> Thanks, I push it upstream with the above fixes installed.
> >>>>>
> >>>>> I got
> >>>>>
> >>>>> FAIL: elf/tst-p_align3
> >>>>>
> >>>>> [hjl@gnu-tgl-2 build-x86_64-linux]$ cat elf/tst-p_align3.out
> >>>>> /export/build/gnu/tools-build/glibc-cet-gitlab/build-x86_64-linux/elf/tst-p_align3:
> >>>>> error while loading shared libraries:
> >>>>> /export/build/gnu/tools-build/glibc-cet-gitlab/build-x86_64-linux/elf/tst-p_alignmod3.so:
> >>>>> cannot change memory protections
> >>>>> [hjl@gnu-tgl-2 build-x86_64-linux]$
> >>>>>
> >>>>> Only p_align should be changed to 0x100. But I saw
> >>>>
> >>>> I am not sure if this is related because tst-p_align3 and tst-alignmod3.so uses
> >>>> LDFLAGS instead:
> >>>>
> >>>> 1644 $(objpfx)tst-align3: $(objpfx)tst-alignmod3.so
> >>>> 1645 ifeq (yes,$(have-fpie))
> >>>> 1646 CFLAGS-tst-align3.c += $(PIE-ccflag)
> >>>> 1647 endif
> >>>> 1648 LDFLAGS-tst-align3 += -Wl,-z,max-page-size=0x200000
> >>>> 1649 LDFLAGS-tst-alignmod3.so += -Wl,-z,max-page-size=0x200000
> >>>> 1650 $(objpfx)tst-alignmod3.so: $(libsupport)
> >>>>
> >>>> And the patch only changed the way tst-p_align1 and tst-p_align2 modules were
> >>>> changed.
> >>>
> >>> It is tst-p_alignmod3.so, not tst-alignmod3.so.
> >>> ^^
> >> My confusion here. But even though the script in not involved:
> >>
> >> 2622 LDFLAGS-tst-p_alignmod3.so += -Wl,-z,max-page-size=0x100,-z,common-page-size=0x100
> >> 2623
> >> 2624 $(objpfx)tst-p_align3: $(objpfx)tst-p_alignmod3.so
> >> 2625 $(objpfx)tst-p_align3.out: tst-p_align3.sh $(objpfx)tst-p_align3
> >> 2626 $(SHELL) $< $(common-objpfx) '$(test-program-prefix)'; \
> >> 2627 $(evaluate-test)
> >>
> >> That's why it is puzzling me that it start to fail now.
> >
> > This test checks the invalid p_align handling. You have to edit the
> > binary to change p_align to 0x100 which is invalid.
> >
>
> But it is already done by the LD_FLAGS above (from elf/Makefile). I am
> still failing to understand why my patch that only changes tst-p_align1
> and tst-p_align2 objects made tst-p_align3 to fail.
>
> Before:
>
> $ readelf -l elf/tst-p_align3
> [...]
> LOAD 0x0000000000000000 0x0000000000000000 0x0000000000000000
> 0x00000000000015c0 0x00000000000015c0 R 0x1000
> LOAD 0x0000000000002000 0x0000000000002000 0x0000000000002000
> 0x0000000000001892 0x0000000000001892 R E 0x1000
> LOAD 0x0000000000004000 0x0000000000004000 0x0000000000004000
> 0x0000000000000d58 0x0000000000000d58 R 0x1000
> LOAD 0x0000000000005cf8 0x0000000000006cf8 0x0000000000006cf8
> 0x0000000000000498 0x00000000000004d8 RW 0x1000
> [...]
> $ readelf -l elf/tst-p_alignmod3.so
> [....]
> Program Headers:
> Type Offset VirtAddr PhysAddr
> FileSiz MemSiz Flags Align
> LOAD 0x0000000000000000 0x0000000000000000 0x0000000000000000
> 0x0000000000000540 0x0000000000000540 R 0x100
> LOAD 0x0000000000000600 0x0000000000000600 0x0000000000000600
> 0x00000000000001f2 0x00000000000001f2 R E 0x100
> LOAD 0x0000000000000800 0x0000000000000800 0x0000000000000800
> 0x00000000000000d0 0x00000000000000d0 R 0x100
> LOAD 0x0000000000000930 0x0000000000000a30 0x0000000000000a30
>
> 0x00000000000001f8 0x0000000000000208 RW 0x100
> After:
>
> $ readelf -l elf/tst-p_align3
> [...]
> LOAD 0x0000000000000000 0x0000000000000000 0x0000000000000000
> 0x00000000000015b8 0x00000000000015b8 R 0x1000
> LOAD 0x0000000000002000 0x0000000000002000 0x0000000000002000
> 0x0000000000001892 0x0000000000001892 R E 0x1000
> LOAD 0x0000000000004000 0x0000000000004000 0x0000000000004000
> 0x0000000000000d50 0x0000000000000d50 R 0x1000
> LOAD 0x0000000000005cf8 0x0000000000006cf8 0x0000000000006cf8
> 0x0000000000000498 0x00000000000004d8 RW 0x1000
>
> $ readelf -l elf/tst-p_alignmod3.so
> Elf file type is DYN (Shared object file)
> [....]
> Program Headers:
> Type Offset VirtAddr PhysAddr
> FileSiz MemSiz Flags Align
> LOAD 0x0000000000000000 0x0000000000000000 0x0000000000000000
> 0x0000000000000540 0x0000000000000540 R 0x100
> LOAD 0x0000000000000600 0x0000000000000600 0x0000000000000600
> 0x00000000000001f2 0x00000000000001f2 R E 0x100
> LOAD 0x0000000000000800 0x0000000000000800 0x0000000000000800
> 0x00000000000000d0 0x00000000000000d0 R 0x100
> LOAD 0x0000000000000930 0x0000000000000a30 0x0000000000000a30
> 0x00000000000001f8 0x0000000000000208 RW 0x100
>
> So PT_LOAD p_align are still strictly the same.
Never mind. We need to disable GNU_RELRO segment to reliably trigger
.../elf/tst-p_alignmod3.so: ELF load command address/offset not page-aligned
A patch is posted at
https://sourceware.org/pipermail/libc-alpha/2022-January/135733.html
@@ -413,8 +413,6 @@ tests += \
tst-nodelete-opened \
tst-noload \
tst-null-argv \
- tst-p_alignmod1-edit \
- tst-p_alignmod2-edit \
tst-p_align1 \
tst-p_align2 \
tst-p_align3 \
@@ -2607,23 +2605,19 @@ $(objpfx)tst-p_align1: $(objpfx)tst-p_alignmod1.so
# Make a copy of tst-p_alignmod-base.so and lower p_align of the first
# PT_LOAD segment.
-$(objpfx)tst-p_alignmod1.so: $(objpfx)tst-p_alignmod1-edit \
- $(objpfx)tst-p_alignmod-base.so
+$(objpfx)tst-p_alignmod1.so: $(objpfx)tst-p_alignmod-base.so
rm -f $@
cp $(objpfx)tst-p_alignmod-base.so $@
- $(test-wrapper-env) $(run-program-env) $(rtld-prefix) \
- $(objpfx)tst-p_alignmod1-edit $@
+ $(PYTHON) $(..)scripts/tst-elf-edit.py -a half $@
$(objpfx)tst-p_align2: $(objpfx)tst-p_alignmod2.so
# Make a copy of tst-p_alignmod-base.so and update p_align of the first
# PT_LOAD segment.
-$(objpfx)tst-p_alignmod2.so: $(objpfx)tst-p_alignmod2-edit \
- $(objpfx)tst-p_alignmod-base.so
+$(objpfx)tst-p_alignmod2.so: $(objpfx)tst-p_alignmod-base.so
rm -f $@
cp $(objpfx)tst-p_alignmod-base.so $@
- $(test-wrapper-env) $(run-program-env) $(rtld-prefix) \
- $(objpfx)tst-p_alignmod2-edit $@
+ $(PYTHON) $(..)scripts/tst-elf-edit.py -a 1 $@
LDFLAGS-tst-p_alignmod3.so += -Wl,-z,max-page-size=0x100,-z,common-page-size=0x100
deleted file mode 100644
@@ -1,126 +0,0 @@
-/* Update p_align of the first PT_LOAD segment.
- Copyright (C) 2022 Free Software Foundation, Inc.
- This file is part of the GNU C Library.
-
- The GNU C Library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- The GNU C Library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-#include <stdio.h>
-#include <stdbool.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <link.h>
-#include <error.h>
-#include <errno.h>
-#include <sys/stat.h>
-#include <sys/mman.h>
-
-const char *file_name;
-
-static size_t update_p_align (size_t);
-
-int
-main (int argc, char ** argv)
-{
- if (argc != 2)
- {
- printf ("Usage: %s: file\n", argv[0]);
- return 0;
- }
-
- file_name = argv[1];
- struct stat statbuf;
- int errno_saved;
-
- if (stat (file_name, &statbuf) < 0)
- error (1, errno, "%s: not exist", file_name);
-
- ElfW(Ehdr) *ehdr;
-
- if (statbuf.st_size < sizeof (*ehdr))
- error (1, 0, "%s: too small", file_name);
-
- int fd = open (file_name, O_RDWR);
- if (fd < 0)
- error (1, errno, "%s: can't open", file_name);
-
- /* Map in the whole file. */
- void *base = mmap (NULL, statbuf.st_size, PROT_READ | PROT_WRITE,
- MAP_SHARED, fd, 0);
- if (base == MAP_FAILED)
- {
- errno_saved = errno;
- close (fd);
- error (1, errno_saved, "%s: failed to map", file_name);
- }
-
- ehdr = (ElfW(Ehdr) *) base;
- if (ehdr->e_ident[EI_MAG0] != ELFMAG0
- || ehdr->e_ident[EI_MAG1] != ELFMAG1
- || ehdr->e_ident[EI_MAG2] != ELFMAG2
- || ehdr->e_ident[EI_MAG3] != ELFMAG3)
- {
- close (fd);
- error (1, 0, "%s: bad ELF header", file_name);
- }
-
- if (ehdr->e_type != ET_DYN)
- {
- close (fd);
- error (1, 0, "%s: not shared library", file_name);
- }
-
- bool unsupported_class = true;
- switch (ehdr->e_ident[EI_CLASS])
- {
- default:
- break;
-
- case ELFCLASS32:
- unsupported_class = __ELF_NATIVE_CLASS != 32;
- break;
-
- case ELFCLASS64:
- unsupported_class = __ELF_NATIVE_CLASS != 64;
- break;
- }
-
- if (unsupported_class)
- {
- close (fd);
- error (1, 0, "%s: unsupported ELF class: %d",
- file_name, ehdr->e_ident[EI_CLASS]);
- }
-
- size_t phdr_size = sizeof (ElfW(Phdr)) * ehdr->e_phentsize;
- if (statbuf.st_size < (ehdr->e_phoff + phdr_size))
- {
- close (fd);
- error (1, 0, "%s: too small", file_name);
- }
-
- ElfW(Phdr) *phdr = (ElfW(Phdr) *) (base + ehdr->e_phoff);
- for (int i = 0; i < ehdr->e_phnum; i++, phdr++)
- if (phdr->p_type == PT_LOAD)
- {
- /* Update p_align of the first PT_LOAD segment. */
- phdr->p_align = update_p_align (phdr->p_align);
- break;
- }
-
- munmap (base, statbuf.st_size);
- close (fd);
-
- return 0;
-}
deleted file mode 100644
@@ -1,27 +0,0 @@
-/* Reduce p_align of the first PT_LOAD segment by half.
- Copyright (C) 2022 Free Software Foundation, Inc.
- This file is part of the GNU C Library.
-
- The GNU C Library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- The GNU C Library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-#include "tst-elf-edit.h"
-
-/* Reduce p_align by half. */
-
-static size_t
-update_p_align (size_t p_align)
-{
- return p_align >> 1;
-}
deleted file mode 100644
@@ -1,27 +0,0 @@
-/* Set p_align of the first PT_LOAD segment to 1.
- Copyright (C) 2022 Free Software Foundation, Inc.
- This file is part of the GNU C Library.
-
- The GNU C Library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- The GNU C Library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, see
- <https://www.gnu.org/licenses/>. */
-
-#include "tst-elf-edit.h"
-
-/* Set p_align to 1. */
-
-static size_t
-update_p_align (size_t p_align __attribute__ ((unused)))
-{
- return 1;
-}
new file mode 100644
@@ -0,0 +1,206 @@
+#!/usr/bin/python3
+# ELF editor for load align tests.
+# Copyright (C) 2022 Free Software Foundation, Inc.
+# Copyright The GNU Toolchain Authors.
+# This file is part of the GNU C Library.
+#
+# The GNU C Library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# The GNU C Library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with the GNU C Library; if not, see
+# <https://www.gnu.org/licenses/>.
+
+import argparse
+import os
+import sys
+import struct
+
+EI_NIDENT=16
+
+EI_MAG0=0
+ELFMAG0=b'\x7f'
+EI_MAG1=1
+ELFMAG1=b'E'
+EI_MAG2=2
+ELFMAG2=b'L'
+EI_MAG3=3
+ELFMAG3=b'F'
+
+EI_CLASS=4
+ELFCLASSNONE=b'0'
+ELFCLASS32=b'\x01'
+ELFCLASS64=b'\x02'
+
+EI_DATA=5
+ELFDATA2LSB=b'\x01'
+ELFDATA2MSB=b'\x02'
+
+ET_DYN=3
+
+PT_LOAD=1
+
+def elf_types_fmts(e_ident):
+ endian = '<' if e_ident[EI_DATA] == ELFDATA2LSB else '>'
+ addr = 'I' if e_ident[EI_CLASS] == ELFCLASS32 else 'Q'
+ off = 'I' if e_ident[EI_CLASS] == ELFCLASS32 else 'Q'
+ return (endian, addr, off)
+
+class Elf_Ehdr:
+ def __init__(self, e_ident):
+ endian, addr, off = elf_types_fmts(e_ident)
+ self.fmt = '{0}HHI{1}{2}{2}IHHHHHH'.format(endian, addr, off)
+ self.len = struct.calcsize(self.fmt)
+
+ def read(self, f):
+ buf = f.read(self.len)
+ if not buf:
+ error('{}: header too small'.format(f.name))
+ data = struct.unpack(self.fmt, buf)
+ self.e_type = data[0]
+ self.e_machine = data[1]
+ self.e_version = data[2]
+ self.e_entry = data[3]
+ self.e_phoff = data[4]
+ self.e_shoff = data[5]
+ self.e_flags = data[6]
+ self.e_ehsize = data[7]
+ self.e_phentsize= data[8]
+ self.e_phnum = data[9]
+ self.e_shstrndx = data[10]
+
+
+class Elf_Phdr:
+ def __init__(self, e_ident):
+ endian, addr, off = elf_types_fmts(e_ident)
+ self.ei_class = e_ident[EI_CLASS]
+ if self.ei_class == ELFCLASS32:
+ self.fmt = '{0}I{2}{1}{1}IIII'.format(endian, addr, off)
+ else:
+ self.fmt = '{0}II{2}{1}{1}QQQ'.format(endian, addr, off)
+ self.len = struct.calcsize(self.fmt)
+
+ def read(self, f):
+ buf = f.read(self.len)
+ if not buf:
+ error('{}: program header too small'.format(f.name))
+ data = struct.unpack(self.fmt, buf)
+ if self.ei_class == ELFCLASS32:
+ self.p_type = data[0]
+ self.p_offset = data[1]
+ self.p_vaddr = data[2]
+ self.p_paddr = data[3]
+ self.p_filesz = data[4]
+ self.p_memsz = data[5]
+ self.p_flags = data[6]
+ self.p_align = data[7]
+ else:
+ self.p_type = data[0]
+ self.p_flags = data[1]
+ self.p_offset = data[2]
+ self.p_vaddr = data[3]
+ self.p_paddr = data[4]
+ self.p_filesz = data[5]
+ self.p_memsz = data[6]
+ self.p_align = data[7]
+
+ def write(self, f):
+ if self.ei_class == ELFCLASS32:
+ data = struct.pack(self.fmt,
+ self.p_type,
+ self.p_offset,
+ self.p_vaddr,
+ self.p_paddr,
+ self.p_filesz,
+ self.p_memsz,
+ self.p_flags,
+ self.p_align)
+ else:
+ data = struct.pack(self.fmt,
+ self.p_type,
+ self.p_flags,
+ self.p_offset,
+ self.p_vaddr,
+ self.p_paddr,
+ self.p_filesz,
+ self.p_memsz,
+ self.p_align)
+ f.write(data)
+
+
+def error(msg):
+ print(msg, file=sys.stderr)
+ sys.exit(1)
+
+
+def elf_edit_align(phdr, align):
+ if align == 'half':
+ phdr.p_align = phdr.p_align >> 1
+ else:
+ phdr.p_align = int(align)
+
+
+def elf_edit(f, align):
+ ei_nident_fmt = 'c' * EI_NIDENT
+ ei_nident_len = struct.calcsize(ei_nident_fmt)
+
+ data = f.read(ei_nident_len)
+ if not data:
+ error('{}: e_nident too small'.format(f.name))
+ e_ident = struct.unpack(ei_nident_fmt, data)
+
+ if e_ident[EI_MAG0] != ELFMAG0 \
+ or e_ident[EI_MAG1] != ELFMAG1 \
+ or e_ident[EI_MAG2] != ELFMAG2 \
+ or e_ident[EI_MAG3] != ELFMAG3:
+ error('{}: bad ELF header'.format(f.name))
+
+ if e_ident[EI_CLASS] != ELFCLASS32 \
+ and e_ident[EI_CLASS] != ELFCLASS64:
+ error('{}: unsupported ELF class: {}'.format(f.name, e_ident[EI_CLASS]))
+
+ if e_ident[EI_DATA] != ELFDATA2LSB \
+ and e_ident[EI_DATA] != ELFDATA2MSB: \
+ error('{}: unsupported ELF data: {}'.format(f.name, e_ident[EI_DATA]))
+
+ ehdr = Elf_Ehdr(e_ident)
+ ehdr.read(f)
+ if ehdr.e_type != ET_DYN:
+ error('{}: not a shared library'.format(f.name))
+
+ phdr = Elf_Phdr(e_ident)
+ for i in range(0, ehdr.e_phnum):
+ f.seek(ehdr.e_phoff + i * phdr.len)
+ phdr.read(f)
+ if phdr.p_type == PT_LOAD:
+ elf_edit_align(phdr, align)
+ f.seek(ehdr.e_phoff + i * phdr.len)
+ phdr.write(f)
+ break
+
+
+def get_parser():
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument('-a', dest='align', required=True,
+ help='How to set the LOAD alignment')
+ parser.add_argument('output',
+ help='ELF file to edit')
+ return parser
+
+
+def main(argv):
+ parser = get_parser()
+ opts = parser.parse_args(argv)
+ with open(opts.output, 'r+b') as fout:
+ elf_edit(fout, opts.align)
+
+
+if __name__ == '__main__':
+ main(sys.argv[1:])