diff mbox series

elf: Replace tst-p_alignmod1-editX with a python script

Message ID 20220125170523.952874-1-adhemerval.zanella@linaro.org
State Committed
Headers show
Series elf: Replace tst-p_alignmod1-editX with a python script | expand

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

Adhemerval Zanella Jan. 25, 2022, 5:05 p.m. UTC
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

Florian Weimer Jan. 26, 2022, 10:09 a.m. UTC | #1
* 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
Adhemerval Zanella Jan. 26, 2022, 12:10 p.m. UTC | #2
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.
H.J. Lu Jan. 26, 2022, 3:35 p.m. UTC | #3
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
Adhemerval Zanella Jan. 26, 2022, 3:45 p.m. UTC | #4
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
>
H.J. Lu Jan. 26, 2022, 3:46 p.m. UTC | #5
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
> >
Adhemerval Zanella Jan. 26, 2022, 3:54 p.m. UTC | #6
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.
H.J. Lu Jan. 26, 2022, 4:11 p.m. UTC | #7
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.
Adhemerval Zanella Jan. 26, 2022, 5:11 p.m. UTC | #8
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.
H.J. Lu Jan. 26, 2022, 9:43 p.m. UTC | #9
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
diff mbox series

Patch

diff --git a/elf/Makefile b/elf/Makefile
index 41e0f2e8c4..daafb5cf12 100644
--- a/elf/Makefile
+++ b/elf/Makefile
@@ -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
 
diff --git a/elf/tst-elf-edit.h b/elf/tst-elf-edit.h
deleted file mode 100644
index b764e78933..0000000000
--- a/elf/tst-elf-edit.h
+++ /dev/null
@@ -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;
-}
diff --git a/elf/tst-p_alignmod1-edit.c b/elf/tst-p_alignmod1-edit.c
deleted file mode 100644
index 06d9c636fd..0000000000
--- a/elf/tst-p_alignmod1-edit.c
+++ /dev/null
@@ -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;
-}
diff --git a/elf/tst-p_alignmod2-edit.c b/elf/tst-p_alignmod2-edit.c
deleted file mode 100644
index 4c2ae65b4e..0000000000
--- a/elf/tst-p_alignmod2-edit.c
+++ /dev/null
@@ -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;
-}
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 @@ 
+#!/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:])