diff mbox series

[bpf-next] selftests/bpf: Fix test_attach_probe for powerpc uprobes

Message ID 20210301190416.90694-1-jolsa@kernel.org (mailing list archive)
State Superseded
Delegated to: BPF
Headers show
Series [bpf-next] selftests/bpf: Fix test_attach_probe for powerpc uprobes | expand

Checks

Context Check Description
netdev/cover_letter success Link
netdev/fixes_present success Link
netdev/patch_count success Link
netdev/tree_selection success Clearly marked for bpf-next
netdev/subject_prefix success Link
netdev/cc_maintainers warning 4 maintainers not CCed: kpsingh@kernel.org linux-kselftest@vger.kernel.org shuah@kernel.org andrii@kernel.org
netdev/source_inline success Was 0 now: 0
netdev/verify_signedoff success Link
netdev/module_param success Was 0 now: 0
netdev/build_32bit success Errors and warnings before: 0 this patch: 0
netdev/kdoc success Errors and warnings before: 0 this patch: 0
netdev/verify_fixes success Link
netdev/checkpatch warning CHECK: architecture specific defines should be avoided
netdev/build_allmodconfig_warn success Errors and warnings before: 0 this patch: 0
netdev/header_inline success Link
netdev/stable success Stable not CCed

Commit Message

Jiri Olsa March 1, 2021, 7:04 p.m. UTC
When testing uprobes we the test gets GEP (Global Entry Point)
address from kallsyms, but then the function is called locally
so the uprobe is not triggered.

Fixing this by adjusting the address to LEP (Local Entry Point)
for powerpc arch.

Signed-off-by: Jiri Olsa <jolsa@kernel.org>
---
 .../selftests/bpf/prog_tests/attach_probe.c    | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

Comments

Yonghong Song March 1, 2021, 10:58 p.m. UTC | #1
On 3/1/21 11:04 AM, Jiri Olsa wrote:
> When testing uprobes we the test gets GEP (Global Entry Point)
> address from kallsyms, but then the function is called locally
> so the uprobe is not triggered.
> 
> Fixing this by adjusting the address to LEP (Local Entry Point)
> for powerpc arch.
> 
> Signed-off-by: Jiri Olsa <jolsa@kernel.org>
> ---
>   .../selftests/bpf/prog_tests/attach_probe.c    | 18 +++++++++++++++++-
>   1 file changed, 17 insertions(+), 1 deletion(-)
> 
> diff --git a/tools/testing/selftests/bpf/prog_tests/attach_probe.c b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> index a0ee87c8e1ea..c3cfb48d3ed0 100644
> --- a/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> +++ b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> @@ -2,6 +2,22 @@
>   #include <test_progs.h>
>   #include "test_attach_probe.skel.h"
>   
> +#if defined(__powerpc64__)
> +/*
> + * We get the GEP (Global Entry Point) address from kallsyms,
> + * but then the function is called locally, so we need to adjust
> + * the address to get LEP (Local Entry Point).

Any documentation in the kernel about this behavior? This will
help to validate the change without trying with powerpc64 qemu...

> + */
> +#define LEP_OFFSET 8
> +
> +static ssize_t get_offset(ssize_t offset)
> +{
> +	return offset + LEP_OFFSET;
> +}
> +#else
> +#define get_offset(offset) (offset)
> +#endif
> +
>   ssize_t get_base_addr() {
>   	size_t start, offset;
>   	char buf[256];
> @@ -36,7 +52,7 @@ void test_attach_probe(void)
>   	if (CHECK(base_addr < 0, "get_base_addr",
>   		  "failed to find base addr: %zd", base_addr))
>   		return;
> -	uprobe_offset = (size_t)&get_base_addr - base_addr;
> +	uprobe_offset = get_offset((size_t)&get_base_addr - base_addr);
>   
>   	skel = test_attach_probe__open_and_load();
>   	if (CHECK(!skel, "skel_open", "failed to open skeleton\n"))
>
Andrii Nakryiko March 2, 2021, 12:34 a.m. UTC | #2
On Mon, Mar 1, 2021 at 11:11 AM Jiri Olsa <jolsa@kernel.org> wrote:
>
> When testing uprobes we the test gets GEP (Global Entry Point)
> address from kallsyms, but then the function is called locally
> so the uprobe is not triggered.
>
> Fixing this by adjusting the address to LEP (Local Entry Point)
> for powerpc arch.
>
> Signed-off-by: Jiri Olsa <jolsa@kernel.org>
> ---
>  .../selftests/bpf/prog_tests/attach_probe.c    | 18 +++++++++++++++++-
>  1 file changed, 17 insertions(+), 1 deletion(-)
>
> diff --git a/tools/testing/selftests/bpf/prog_tests/attach_probe.c b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> index a0ee87c8e1ea..c3cfb48d3ed0 100644
> --- a/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> +++ b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> @@ -2,6 +2,22 @@
>  #include <test_progs.h>
>  #include "test_attach_probe.skel.h"
>
> +#if defined(__powerpc64__)
> +/*
> + * We get the GEP (Global Entry Point) address from kallsyms,
> + * but then the function is called locally, so we need to adjust
> + * the address to get LEP (Local Entry Point).
> + */
> +#define LEP_OFFSET 8
> +
> +static ssize_t get_offset(ssize_t offset)

if we mark this function __weak global, would it work as is? Would it
get an address of a global entry point? I know nothing about this GEP
vs LEP stuff, interesting :)

> +{
> +       return offset + LEP_OFFSET;
> +}
> +#else
> +#define get_offset(offset) (offset)
> +#endif
> +
>  ssize_t get_base_addr() {
>         size_t start, offset;
>         char buf[256];
> @@ -36,7 +52,7 @@ void test_attach_probe(void)
>         if (CHECK(base_addr < 0, "get_base_addr",
>                   "failed to find base addr: %zd", base_addr))
>                 return;
> -       uprobe_offset = (size_t)&get_base_addr - base_addr;
> +       uprobe_offset = get_offset((size_t)&get_base_addr - base_addr);
>
>         skel = test_attach_probe__open_and_load();
>         if (CHECK(!skel, "skel_open", "failed to open skeleton\n"))
> --
> 2.29.2
>
Jiri Olsa March 2, 2021, 10:35 a.m. UTC | #3
On Mon, Mar 01, 2021 at 02:58:53PM -0800, Yonghong Song wrote:
> 
> 
> On 3/1/21 11:04 AM, Jiri Olsa wrote:
> > When testing uprobes we the test gets GEP (Global Entry Point)
> > address from kallsyms, but then the function is called locally
> > so the uprobe is not triggered.
> > 
> > Fixing this by adjusting the address to LEP (Local Entry Point)
> > for powerpc arch.
> > 
> > Signed-off-by: Jiri Olsa <jolsa@kernel.org>
> > ---
> >   .../selftests/bpf/prog_tests/attach_probe.c    | 18 +++++++++++++++++-
> >   1 file changed, 17 insertions(+), 1 deletion(-)
> > 
> > diff --git a/tools/testing/selftests/bpf/prog_tests/attach_probe.c b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > index a0ee87c8e1ea..c3cfb48d3ed0 100644
> > --- a/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > +++ b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > @@ -2,6 +2,22 @@
> >   #include <test_progs.h>
> >   #include "test_attach_probe.skel.h"
> > +#if defined(__powerpc64__)
> > +/*
> > + * We get the GEP (Global Entry Point) address from kallsyms,
> > + * but then the function is called locally, so we need to adjust
> > + * the address to get LEP (Local Entry Point).
> 
> Any documentation in the kernel about this behavior? This will
> help to validate the change without trying with powerpc64 qemu...

we got similar fix in perf:

7b6ff0bdbf4f perf probe ppc64le: Fixup function entry if using kallsyms lookup

CC-ing few other folks from ppc land for more info

jirka

> 
> > + */
> > +#define LEP_OFFSET 8
> > +
> > +static ssize_t get_offset(ssize_t offset)
> > +{
> > +	return offset + LEP_OFFSET;
> > +}
> > +#else
> > +#define get_offset(offset) (offset)
> > +#endif
> > +
> >   ssize_t get_base_addr() {
> >   	size_t start, offset;
> >   	char buf[256];
> > @@ -36,7 +52,7 @@ void test_attach_probe(void)
> >   	if (CHECK(base_addr < 0, "get_base_addr",
> >   		  "failed to find base addr: %zd", base_addr))
> >   		return;
> > -	uprobe_offset = (size_t)&get_base_addr - base_addr;
> > +	uprobe_offset = get_offset((size_t)&get_base_addr - base_addr);
> >   	skel = test_attach_probe__open_and_load();
> >   	if (CHECK(!skel, "skel_open", "failed to open skeleton\n"))
> > 
>
Jiri Olsa March 2, 2021, 11:14 a.m. UTC | #4
On Mon, Mar 01, 2021 at 04:34:24PM -0800, Andrii Nakryiko wrote:
> On Mon, Mar 1, 2021 at 11:11 AM Jiri Olsa <jolsa@kernel.org> wrote:
> >
> > When testing uprobes we the test gets GEP (Global Entry Point)
> > address from kallsyms, but then the function is called locally
> > so the uprobe is not triggered.
> >
> > Fixing this by adjusting the address to LEP (Local Entry Point)
> > for powerpc arch.
> >
> > Signed-off-by: Jiri Olsa <jolsa@kernel.org>
> > ---
> >  .../selftests/bpf/prog_tests/attach_probe.c    | 18 +++++++++++++++++-
> >  1 file changed, 17 insertions(+), 1 deletion(-)
> >
> > diff --git a/tools/testing/selftests/bpf/prog_tests/attach_probe.c b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > index a0ee87c8e1ea..c3cfb48d3ed0 100644
> > --- a/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > +++ b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > @@ -2,6 +2,22 @@
> >  #include <test_progs.h>
> >  #include "test_attach_probe.skel.h"
> >
> > +#if defined(__powerpc64__)
> > +/*
> > + * We get the GEP (Global Entry Point) address from kallsyms,
> > + * but then the function is called locally, so we need to adjust
> > + * the address to get LEP (Local Entry Point).
> > + */
> > +#define LEP_OFFSET 8
> > +
> > +static ssize_t get_offset(ssize_t offset)
> 
> if we mark this function __weak global, would it work as is? Would it
> get an address of a global entry point? I know nothing about this GEP
> vs LEP stuff, interesting :)

you mean get_base_addr? it's already global

all the calls to get_base_addr within the object are made
to get_base_addr+0x8

00000000100350c0 <test_attach_probe>:
    ...
    100350e0:   59 fd ff 4b     bl      10034e38 <get_base_addr+0x8>
    ...
    100358a8:   91 f5 ff 4b     bl      10034e38 <get_base_addr+0x8>


I'm following perf fix we had for similar issue:
  7b6ff0bdbf4f perf probe ppc64le: Fixup function entry if using kallsyms lookup

I'll get more info on that

jirka

> 
> > +{
> > +       return offset + LEP_OFFSET;
> > +}
> > +#else
> > +#define get_offset(offset) (offset)
> > +#endif
> > +
> >  ssize_t get_base_addr() {
> >         size_t start, offset;
> >         char buf[256];
> > @@ -36,7 +52,7 @@ void test_attach_probe(void)
> >         if (CHECK(base_addr < 0, "get_base_addr",
> >                   "failed to find base addr: %zd", base_addr))
> >                 return;
> > -       uprobe_offset = (size_t)&get_base_addr - base_addr;
> > +       uprobe_offset = get_offset((size_t)&get_base_addr - base_addr);
> >
> >         skel = test_attach_probe__open_and_load();
> >         if (CHECK(!skel, "skel_open", "failed to open skeleton\n"))
> > --
> > 2.29.2
> >
>
Yonghong Song March 2, 2021, 5:19 p.m. UTC | #5
On 3/2/21 3:14 AM, Jiri Olsa wrote:
> On Mon, Mar 01, 2021 at 04:34:24PM -0800, Andrii Nakryiko wrote:
>> On Mon, Mar 1, 2021 at 11:11 AM Jiri Olsa <jolsa@kernel.org> wrote:
>>>
>>> When testing uprobes we the test gets GEP (Global Entry Point)
>>> address from kallsyms, but then the function is called locally
>>> so the uprobe is not triggered.
>>>
>>> Fixing this by adjusting the address to LEP (Local Entry Point)
>>> for powerpc arch.
>>>
>>> Signed-off-by: Jiri Olsa <jolsa@kernel.org>
>>> ---
>>>   .../selftests/bpf/prog_tests/attach_probe.c    | 18 +++++++++++++++++-
>>>   1 file changed, 17 insertions(+), 1 deletion(-)
>>>
>>> diff --git a/tools/testing/selftests/bpf/prog_tests/attach_probe.c b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
>>> index a0ee87c8e1ea..c3cfb48d3ed0 100644
>>> --- a/tools/testing/selftests/bpf/prog_tests/attach_probe.c
>>> +++ b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
>>> @@ -2,6 +2,22 @@
>>>   #include <test_progs.h>
>>>   #include "test_attach_probe.skel.h"
>>>
>>> +#if defined(__powerpc64__)
>>> +/*
>>> + * We get the GEP (Global Entry Point) address from kallsyms,
>>> + * but then the function is called locally, so we need to adjust
>>> + * the address to get LEP (Local Entry Point).
>>> + */
>>> +#define LEP_OFFSET 8
>>> +
>>> +static ssize_t get_offset(ssize_t offset)
>>
>> if we mark this function __weak global, would it work as is? Would it
>> get an address of a global entry point? I know nothing about this GEP
>> vs LEP stuff, interesting :)
> 
> you mean get_base_addr? it's already global
> 
> all the calls to get_base_addr within the object are made
> to get_base_addr+0x8
> 
> 00000000100350c0 <test_attach_probe>:
>      ...
>      100350e0:   59 fd ff 4b     bl      10034e38 <get_base_addr+0x8>
>      ...
>      100358a8:   91 f5 ff 4b     bl      10034e38 <get_base_addr+0x8>
> 
> 
> I'm following perf fix we had for similar issue:
>    7b6ff0bdbf4f perf probe ppc64le: Fixup function entry if using kallsyms lookup
> 
> I'll get more info on that

Thanks. The patch
    7b6ff0bdbf4f perf probe ppc64le: Fixup function entry if using 
kallsyms lookup
talked about offset + 8 for kernel symbols.
I guess uprobe symbol might be in the same situation if using the
same compilation mechanism as kernel. But it would be good
to get confirmation from ppc people.

> 
> jirka
> 
>>
>>> +{
>>> +       return offset + LEP_OFFSET;
>>> +}
>>> +#else
>>> +#define get_offset(offset) (offset)
>>> +#endif
>>> +
>>>   ssize_t get_base_addr() {
>>>          size_t start, offset;
>>>          char buf[256];
>>> @@ -36,7 +52,7 @@ void test_attach_probe(void)
>>>          if (CHECK(base_addr < 0, "get_base_addr",
>>>                    "failed to find base addr: %zd", base_addr))
>>>                  return;
>>> -       uprobe_offset = (size_t)&get_base_addr - base_addr;
>>> +       uprobe_offset = get_offset((size_t)&get_base_addr - base_addr);
>>>
>>>          skel = test_attach_probe__open_and_load();
>>>          if (CHECK(!skel, "skel_open", "failed to open skeleton\n"))
>>> --
>>> 2.29.2
>>>
>>
>
Andrii Nakryiko March 2, 2021, 6:31 p.m. UTC | #6
On Tue, Mar 2, 2021 at 3:14 AM Jiri Olsa <jolsa@redhat.com> wrote:
>
> On Mon, Mar 01, 2021 at 04:34:24PM -0800, Andrii Nakryiko wrote:
> > On Mon, Mar 1, 2021 at 11:11 AM Jiri Olsa <jolsa@kernel.org> wrote:
> > >
> > > When testing uprobes we the test gets GEP (Global Entry Point)
> > > address from kallsyms, but then the function is called locally
> > > so the uprobe is not triggered.
> > >
> > > Fixing this by adjusting the address to LEP (Local Entry Point)
> > > for powerpc arch.
> > >
> > > Signed-off-by: Jiri Olsa <jolsa@kernel.org>
> > > ---
> > >  .../selftests/bpf/prog_tests/attach_probe.c    | 18 +++++++++++++++++-
> > >  1 file changed, 17 insertions(+), 1 deletion(-)
> > >
> > > diff --git a/tools/testing/selftests/bpf/prog_tests/attach_probe.c b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > > index a0ee87c8e1ea..c3cfb48d3ed0 100644
> > > --- a/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > > +++ b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > > @@ -2,6 +2,22 @@
> > >  #include <test_progs.h>
> > >  #include "test_attach_probe.skel.h"
> > >
> > > +#if defined(__powerpc64__)
> > > +/*
> > > + * We get the GEP (Global Entry Point) address from kallsyms,
> > > + * but then the function is called locally, so we need to adjust
> > > + * the address to get LEP (Local Entry Point).
> > > + */
> > > +#define LEP_OFFSET 8
> > > +
> > > +static ssize_t get_offset(ssize_t offset)
> >
> > if we mark this function __weak global, would it work as is? Would it
> > get an address of a global entry point? I know nothing about this GEP
> > vs LEP stuff, interesting :)
>
> you mean get_base_addr? it's already global
>
> all the calls to get_base_addr within the object are made
> to get_base_addr+0x8
>
> 00000000100350c0 <test_attach_probe>:
>     ...
>     100350e0:   59 fd ff 4b     bl      10034e38 <get_base_addr+0x8>
>     ...
>     100358a8:   91 f5 ff 4b     bl      10034e38 <get_base_addr+0x8>
>
>
> I'm following perf fix we had for similar issue:
>   7b6ff0bdbf4f perf probe ppc64le: Fixup function entry if using kallsyms lookup
>
> I'll get more info on that

My thinking was that if you mark the function as __weak, then the
compiler is not allowed to assume that the actual implementation of
that function will come from the same object (because it might be
replaced by the linker later), so it has to be pessimistic and use
global entry, no? Totally theoritizing here, of course.

>
> jirka
>
> >
> > > +{
> > > +       return offset + LEP_OFFSET;
> > > +}
> > > +#else
> > > +#define get_offset(offset) (offset)
> > > +#endif
> > > +
> > >  ssize_t get_base_addr() {
> > >         size_t start, offset;
> > >         char buf[256];
> > > @@ -36,7 +52,7 @@ void test_attach_probe(void)
> > >         if (CHECK(base_addr < 0, "get_base_addr",
> > >                   "failed to find base addr: %zd", base_addr))
> > >                 return;
> > > -       uprobe_offset = (size_t)&get_base_addr - base_addr;
> > > +       uprobe_offset = get_offset((size_t)&get_base_addr - base_addr);
> > >
> > >         skel = test_attach_probe__open_and_load();
> > >         if (CHECK(!skel, "skel_open", "failed to open skeleton\n"))
> > > --
> > > 2.29.2
> > >
> >
>
Jiri Olsa March 2, 2021, 6:58 p.m. UTC | #7
On Tue, Mar 02, 2021 at 10:31:41AM -0800, Andrii Nakryiko wrote:
> On Tue, Mar 2, 2021 at 3:14 AM Jiri Olsa <jolsa@redhat.com> wrote:
> >
> > On Mon, Mar 01, 2021 at 04:34:24PM -0800, Andrii Nakryiko wrote:
> > > On Mon, Mar 1, 2021 at 11:11 AM Jiri Olsa <jolsa@kernel.org> wrote:
> > > >
> > > > When testing uprobes we the test gets GEP (Global Entry Point)
> > > > address from kallsyms, but then the function is called locally
> > > > so the uprobe is not triggered.
> > > >
> > > > Fixing this by adjusting the address to LEP (Local Entry Point)
> > > > for powerpc arch.
> > > >
> > > > Signed-off-by: Jiri Olsa <jolsa@kernel.org>
> > > > ---
> > > >  .../selftests/bpf/prog_tests/attach_probe.c    | 18 +++++++++++++++++-
> > > >  1 file changed, 17 insertions(+), 1 deletion(-)
> > > >
> > > > diff --git a/tools/testing/selftests/bpf/prog_tests/attach_probe.c b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > > > index a0ee87c8e1ea..c3cfb48d3ed0 100644
> > > > --- a/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > > > +++ b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > > > @@ -2,6 +2,22 @@
> > > >  #include <test_progs.h>
> > > >  #include "test_attach_probe.skel.h"
> > > >
> > > > +#if defined(__powerpc64__)
> > > > +/*
> > > > + * We get the GEP (Global Entry Point) address from kallsyms,
> > > > + * but then the function is called locally, so we need to adjust
> > > > + * the address to get LEP (Local Entry Point).
> > > > + */
> > > > +#define LEP_OFFSET 8
> > > > +
> > > > +static ssize_t get_offset(ssize_t offset)
> > >
> > > if we mark this function __weak global, would it work as is? Would it
> > > get an address of a global entry point? I know nothing about this GEP
> > > vs LEP stuff, interesting :)
> >
> > you mean get_base_addr? it's already global
> >
> > all the calls to get_base_addr within the object are made
> > to get_base_addr+0x8
> >
> > 00000000100350c0 <test_attach_probe>:
> >     ...
> >     100350e0:   59 fd ff 4b     bl      10034e38 <get_base_addr+0x8>
> >     ...
> >     100358a8:   91 f5 ff 4b     bl      10034e38 <get_base_addr+0x8>
> >
> >
> > I'm following perf fix we had for similar issue:
> >   7b6ff0bdbf4f perf probe ppc64le: Fixup function entry if using kallsyms lookup
> >
> > I'll get more info on that
> 
> My thinking was that if you mark the function as __weak, then the
> compiler is not allowed to assume that the actual implementation of
> that function will come from the same object (because it might be
> replaced by the linker later), so it has to be pessimistic and use
> global entry, no? Totally theoritizing here, of course.

ah ok.. good idea, but it's still jumping to +8 in my test

    # nm test_progs | grep get_base_addr
    0000000010034e30 W get_base_addr

    100350e0:   59 fd ff 4b     bl      10034e38 <get_base_addr+0x8>

looks like it's linker, because compiler leaves just jump to next instruction

jirka
Naveen N . Rao March 3, 2021, 6:40 a.m. UTC | #8
On 2021/03/02 11:35AM, Jiri Olsa wrote:
> On Mon, Mar 01, 2021 at 02:58:53PM -0800, Yonghong Song wrote:
> > 
> > 
> > On 3/1/21 11:04 AM, Jiri Olsa wrote:
> > > When testing uprobes we the test gets GEP (Global Entry Point)
> > > address from kallsyms, but then the function is called locally
> > > so the uprobe is not triggered.
> > > 
> > > Fixing this by adjusting the address to LEP (Local Entry Point)
> > > for powerpc arch.
> > > 
> > > Signed-off-by: Jiri Olsa <jolsa@kernel.org>
> > > ---
> > >   .../selftests/bpf/prog_tests/attach_probe.c    | 18 +++++++++++++++++-
> > >   1 file changed, 17 insertions(+), 1 deletion(-)
> > > 
> > > diff --git a/tools/testing/selftests/bpf/prog_tests/attach_probe.c b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > > index a0ee87c8e1ea..c3cfb48d3ed0 100644
> > > --- a/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > > +++ b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > > @@ -2,6 +2,22 @@
> > >   #include <test_progs.h>
> > >   #include "test_attach_probe.skel.h"
> > > +#if defined(__powerpc64__)

This needs to be specific to ELF v2 ABI, so you'll need to check 
_CALL_ELF. See commit d5c2e2c17ae1d6 ("perf probe ppc64le: Prefer symbol 
table lookup over DWARF") for an example.

> > > +/*
> > > + * We get the GEP (Global Entry Point) address from kallsyms,
> > > + * but then the function is called locally, so we need to adjust
> > > + * the address to get LEP (Local Entry Point).
> > 
> > Any documentation in the kernel about this behavior? This will
> > help to validate the change without trying with powerpc64 qemu...

I don't think we have documented this in the kernel anywhere, but this 
is specific to the ELF v2 ABI and is described there:
- 2.3.2.1.  Function Prologue: 
  http://cdn.openpowerfoundation.org/wp-content/uploads/resources/leabi/content/dbdoclet.50655240___RefHeading___Toc377640597.html
- 3.4.1.  Symbol Values:
   http://cdn.openpowerfoundation.org/wp-content/uploads/resources/leabi/content/dbdoclet.50655241_95185.html

> 
> we got similar fix in perf:
> 
> 7b6ff0bdbf4f perf probe ppc64le: Fixup function entry if using kallsyms lookup
> 
> CC-ing few other folks from ppc land for more info

Thanks.

> > 
> > > + */
> > > +#define LEP_OFFSET 8
> > > +
> > > +static ssize_t get_offset(ssize_t offset)
> > > +{
> > > +	return offset + LEP_OFFSET;
> > > +}
> > > +#else
> > > +#define get_offset(offset) (offset)
> > > +#endif
> > > +
> > >   ssize_t get_base_addr() {
> > >   	size_t start, offset;
> > >   	char buf[256];
> > > @@ -36,7 +52,7 @@ void test_attach_probe(void)
> > >   	if (CHECK(base_addr < 0, "get_base_addr",
> > >   		  "failed to find base addr: %zd", base_addr))
> > >   		return;
> > > -	uprobe_offset = (size_t)&get_base_addr - base_addr;
> > > +	uprobe_offset = get_offset((size_t)&get_base_addr - base_addr);
> > >   	skel = test_attach_probe__open_and_load();
> > >   	if (CHECK(!skel, "skel_open", "failed to open skeleton\n"))
> > > 

As documented in the links above, the right way to identify local entry 
point (LEP) is by looking at the symbol table. Falling back to using a 
hardcoded offset of 8 is a reasonable workaround if we don't have access 
to the symbol table.

- Naveen
Naveen N . Rao March 3, 2021, 6:42 a.m. UTC | #9
On 2021/03/02 09:19AM, Yonghong Song wrote:
> 
> 
> On 3/2/21 3:14 AM, Jiri Olsa wrote:
> > On Mon, Mar 01, 2021 at 04:34:24PM -0800, Andrii Nakryiko wrote:
> > > On Mon, Mar 1, 2021 at 11:11 AM Jiri Olsa <jolsa@kernel.org> wrote:
> > > > 
> > > > When testing uprobes we the test gets GEP (Global Entry Point)
> > > > address from kallsyms, but then the function is called locally
> > > > so the uprobe is not triggered.
> > > > 
> > > > Fixing this by adjusting the address to LEP (Local Entry Point)
> > > > for powerpc arch.
> > > > 
> > > > Signed-off-by: Jiri Olsa <jolsa@kernel.org>
> > > > ---
> > > >   .../selftests/bpf/prog_tests/attach_probe.c    | 18 +++++++++++++++++-
> > > >   1 file changed, 17 insertions(+), 1 deletion(-)
> > > > 
> > > > diff --git a/tools/testing/selftests/bpf/prog_tests/attach_probe.c b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > > > index a0ee87c8e1ea..c3cfb48d3ed0 100644
> > > > --- a/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > > > +++ b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > > > @@ -2,6 +2,22 @@
> > > >   #include <test_progs.h>
> > > >   #include "test_attach_probe.skel.h"
> > > > 
> > > > +#if defined(__powerpc64__)
> > > > +/*
> > > > + * We get the GEP (Global Entry Point) address from kallsyms,
> > > > + * but then the function is called locally, so we need to adjust
> > > > + * the address to get LEP (Local Entry Point).
> > > > + */
> > > > +#define LEP_OFFSET 8
> > > > +
> > > > +static ssize_t get_offset(ssize_t offset)
> > > 
> > > if we mark this function __weak global, would it work as is? Would it
> > > get an address of a global entry point? I know nothing about this GEP
> > > vs LEP stuff, interesting :)
> > 
> > you mean get_base_addr? it's already global
> > 
> > all the calls to get_base_addr within the object are made
> > to get_base_addr+0x8
> > 
> > 00000000100350c0 <test_attach_probe>:
> >      ...
> >      100350e0:   59 fd ff 4b     bl      10034e38 <get_base_addr+0x8>
> >      ...
> >      100358a8:   91 f5 ff 4b     bl      10034e38 <get_base_addr+0x8>
> > 
> > 
> > I'm following perf fix we had for similar issue:
> >    7b6ff0bdbf4f perf probe ppc64le: Fixup function entry if using kallsyms lookup
> > 
> > I'll get more info on that
> 
> Thanks. The patch
>    7b6ff0bdbf4f perf probe ppc64le: Fixup function entry if using kallsyms
> lookup
> talked about offset + 8 for kernel symbols.
> I guess uprobe symbol might be in the same situation if using the
> same compilation mechanism as kernel. But it would be good
> to get confirmation from ppc people.

Yes, this is part of the ELF V2 ABI, so it applies to both kernel and 
userspace.

- Naveen
Jiri Olsa March 3, 2021, 10:49 p.m. UTC | #10
On Wed, Mar 03, 2021 at 12:10:43PM +0530, Naveen N. Rao wrote:
> On 2021/03/02 11:35AM, Jiri Olsa wrote:
> > On Mon, Mar 01, 2021 at 02:58:53PM -0800, Yonghong Song wrote:
> > > 
> > > 
> > > On 3/1/21 11:04 AM, Jiri Olsa wrote:
> > > > When testing uprobes we the test gets GEP (Global Entry Point)
> > > > address from kallsyms, but then the function is called locally
> > > > so the uprobe is not triggered.
> > > > 
> > > > Fixing this by adjusting the address to LEP (Local Entry Point)
> > > > for powerpc arch.
> > > > 
> > > > Signed-off-by: Jiri Olsa <jolsa@kernel.org>
> > > > ---
> > > >   .../selftests/bpf/prog_tests/attach_probe.c    | 18 +++++++++++++++++-
> > > >   1 file changed, 17 insertions(+), 1 deletion(-)
> > > > 
> > > > diff --git a/tools/testing/selftests/bpf/prog_tests/attach_probe.c b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > > > index a0ee87c8e1ea..c3cfb48d3ed0 100644
> > > > --- a/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > > > +++ b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > > > @@ -2,6 +2,22 @@
> > > >   #include <test_progs.h>
> > > >   #include "test_attach_probe.skel.h"
> > > > +#if defined(__powerpc64__)
> 
> This needs to be specific to ELF v2 ABI, so you'll need to check 
> _CALL_ELF. See commit d5c2e2c17ae1d6 ("perf probe ppc64le: Prefer symbol 
> table lookup over DWARF") for an example.

i see, there's the outer #if _CALL_ELF I missed

> 
> > > > +/*
> > > > + * We get the GEP (Global Entry Point) address from kallsyms,
> > > > + * but then the function is called locally, so we need to adjust
> > > > + * the address to get LEP (Local Entry Point).
> > > 
> > > Any documentation in the kernel about this behavior? This will
> > > help to validate the change without trying with powerpc64 qemu...
> 
> I don't think we have documented this in the kernel anywhere, but this 
> is specific to the ELF v2 ABI and is described there:
> - 2.3.2.1.  Function Prologue: 
>   http://cdn.openpowerfoundation.org/wp-content/uploads/resources/leabi/content/dbdoclet.50655240___RefHeading___Toc377640597.html
> - 3.4.1.  Symbol Values:
>    http://cdn.openpowerfoundation.org/wp-content/uploads/resources/leabi/content/dbdoclet.50655241_95185.html
> 
> > 
> > we got similar fix in perf:
> > 
> > 7b6ff0bdbf4f perf probe ppc64le: Fixup function entry if using kallsyms lookup
> > 
> > CC-ing few other folks from ppc land for more info
> 
> Thanks.
> 
> > > 
> > > > + */
> > > > +#define LEP_OFFSET 8
> > > > +
> > > > +static ssize_t get_offset(ssize_t offset)
> > > > +{
> > > > +	return offset + LEP_OFFSET;
> > > > +}
> > > > +#else
> > > > +#define get_offset(offset) (offset)
> > > > +#endif
> > > > +
> > > >   ssize_t get_base_addr() {
> > > >   	size_t start, offset;
> > > >   	char buf[256];
> > > > @@ -36,7 +52,7 @@ void test_attach_probe(void)
> > > >   	if (CHECK(base_addr < 0, "get_base_addr",
> > > >   		  "failed to find base addr: %zd", base_addr))
> > > >   		return;
> > > > -	uprobe_offset = (size_t)&get_base_addr - base_addr;
> > > > +	uprobe_offset = get_offset((size_t)&get_base_addr - base_addr);
> > > >   	skel = test_attach_probe__open_and_load();
> > > >   	if (CHECK(!skel, "skel_open", "failed to open skeleton\n"))
> > > > 
> 
> As documented in the links above, the right way to identify local entry 
> point (LEP) is by looking at the symbol table. Falling back to using a 
> hardcoded offset of 8 is a reasonable workaround if we don't have access 
> to the symbol table.

thanks for the all the info, I'll send v2 with _CALL_ELF check

jirka
Michael Ellerman March 4, 2021, 12:46 a.m. UTC | #11
"Naveen N. Rao" <naveen.n.rao@linux.vnet.ibm.com> writes:
> On 2021/03/02 11:35AM, Jiri Olsa wrote:
>> On Mon, Mar 01, 2021 at 02:58:53PM -0800, Yonghong Song wrote:
>> > 
>> > 
>> > On 3/1/21 11:04 AM, Jiri Olsa wrote:
>> > > When testing uprobes we the test gets GEP (Global Entry Point)
>> > > address from kallsyms, but then the function is called locally
>> > > so the uprobe is not triggered.
>> > > 
>> > > Fixing this by adjusting the address to LEP (Local Entry Point)
>> > > for powerpc arch.
>> > > 
>> > > Signed-off-by: Jiri Olsa <jolsa@kernel.org>
>> > > ---
>> > >   .../selftests/bpf/prog_tests/attach_probe.c    | 18 +++++++++++++++++-
>> > >   1 file changed, 17 insertions(+), 1 deletion(-)
>> > > 
>> > > diff --git a/tools/testing/selftests/bpf/prog_tests/attach_probe.c b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
>> > > index a0ee87c8e1ea..c3cfb48d3ed0 100644
>> > > --- a/tools/testing/selftests/bpf/prog_tests/attach_probe.c
>> > > +++ b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
>> > > @@ -2,6 +2,22 @@
>> > >   #include <test_progs.h>
>> > >   #include "test_attach_probe.skel.h"
>> > > +#if defined(__powerpc64__)
>
> This needs to be specific to ELF v2 ABI, so you'll need to check 
> _CALL_ELF. See commit d5c2e2c17ae1d6 ("perf probe ppc64le: Prefer symbol 
> table lookup over DWARF") for an example.
>
>> > > +/*
>> > > + * We get the GEP (Global Entry Point) address from kallsyms,
>> > > + * but then the function is called locally, so we need to adjust
>> > > + * the address to get LEP (Local Entry Point).
>> > 
>> > Any documentation in the kernel about this behavior? This will
>> > help to validate the change without trying with powerpc64 qemu...
>
> I don't think we have documented this in the kernel anywhere, but this 
> is specific to the ELF v2 ABI and is described there:
> - 2.3.2.1.  Function Prologue: 
>   http://cdn.openpowerfoundation.org/wp-content/uploads/resources/leabi/content/dbdoclet.50655240___RefHeading___Toc377640597.html
> - 3.4.1.  Symbol Values:
>    http://cdn.openpowerfoundation.org/wp-content/uploads/resources/leabi/content/dbdoclet.50655241_95185.html

There's a comment in ppc_function_entry(), but I don't think we have any
actual "documentation".

static inline unsigned long ppc_function_entry(void *func)
{
#ifdef PPC64_ELF_ABI_v2
	u32 *insn = func;

	/*
	 * A PPC64 ABIv2 function may have a local and a global entry
	 * point. We need to use the local entry point when patching
	 * functions, so identify and step over the global entry point
	 * sequence.
	 *
	 * The global entry point sequence is always of the form:
	 *
	 * addis r2,r12,XXXX
	 * addi  r2,r2,XXXX
	 *
	 * A linker optimisation may convert the addis to lis:
	 *
	 * lis   r2,XXXX
	 * addi  r2,r2,XXXX
	 */
	if ((((*insn & OP_RT_RA_MASK) == ADDIS_R2_R12) ||
	     ((*insn & OP_RT_RA_MASK) == LIS_R2)) &&
	    ((*(insn+1) & OP_RT_RA_MASK) == ADDI_R2_R2))
		return (unsigned long)(insn + 2);
	else
		return (unsigned long)func;


cheers
Naveen N . Rao March 4, 2021, 1:34 a.m. UTC | #12
On 2021/03/04 04:55PM, Jiri Olsa wrote:
> On Thu, Mar 04, 2021 at 11:46:27AM +1100, Michael Ellerman wrote:
> > "Naveen N. Rao" <naveen.n.rao@linux.vnet.ibm.com> writes:
> > > On 2021/03/02 11:35AM, Jiri Olsa wrote:
> > >> On Mon, Mar 01, 2021 at 02:58:53PM -0800, Yonghong Song wrote:
> > >> > 
> > >> > 
> > >> > On 3/1/21 11:04 AM, Jiri Olsa wrote:
> > >> > > When testing uprobes we the test gets GEP (Global Entry Point)
> > >> > > address from kallsyms, but then the function is called locally
> > >> > > so the uprobe is not triggered.
> > >> > > 
> > >> > > Fixing this by adjusting the address to LEP (Local Entry Point)
> > >> > > for powerpc arch.
> > >> > > 
> > >> > > Signed-off-by: Jiri Olsa <jolsa@kernel.org>
> > >> > > ---
> > >> > >   .../selftests/bpf/prog_tests/attach_probe.c    | 18 +++++++++++++++++-
> > >> > >   1 file changed, 17 insertions(+), 1 deletion(-)
> > >> > > 
> > >> > > diff --git a/tools/testing/selftests/bpf/prog_tests/attach_probe.c b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > >> > > index a0ee87c8e1ea..c3cfb48d3ed0 100644
> > >> > > --- a/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > >> > > +++ b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> > >> > > @@ -2,6 +2,22 @@
> > >> > >   #include <test_progs.h>
> > >> > >   #include "test_attach_probe.skel.h"
> > >> > > +#if defined(__powerpc64__)
> > >
> > > This needs to be specific to ELF v2 ABI, so you'll need to check 
> > > _CALL_ELF. See commit d5c2e2c17ae1d6 ("perf probe ppc64le: Prefer symbol 
> > > table lookup over DWARF") for an example.
> > >
> > >> > > +/*
> > >> > > + * We get the GEP (Global Entry Point) address from kallsyms,
> > >> > > + * but then the function is called locally, so we need to adjust
> > >> > > + * the address to get LEP (Local Entry Point).
> > >> > 
> > >> > Any documentation in the kernel about this behavior? This will
> > >> > help to validate the change without trying with powerpc64 qemu...
> > >
> > > I don't think we have documented this in the kernel anywhere, but this 
> > > is specific to the ELF v2 ABI and is described there:
> > > - 2.3.2.1.  Function Prologue: 
> > >   http://cdn.openpowerfoundation.org/wp-content/uploads/resources/leabi/content/dbdoclet.50655240___RefHeading___Toc377640597.html
> > > - 3.4.1.  Symbol Values:
> > >    http://cdn.openpowerfoundation.org/wp-content/uploads/resources/leabi/content/dbdoclet.50655241_95185.html
> > 
> > There's a comment in ppc_function_entry(), but I don't think we have any
> > actual "documentation".
> > 
> > static inline unsigned long ppc_function_entry(void *func)
> > {
> > #ifdef PPC64_ELF_ABI_v2
> > 	u32 *insn = func;
> > 
> > 	/*
> > 	 * A PPC64 ABIv2 function may have a local and a global entry
> > 	 * point. We need to use the local entry point when patching
> > 	 * functions, so identify and step over the global entry point
> > 	 * sequence.
> 
> hm, so I need to do the instructions check below as well

It's a good check, but probably not necessary. In most functions, we 
expect to be able to probe two instructions later without much of a 
change to affect function tracing for userspace. For this reason, we 
just probe at an offset of 8 as a reasonable fallback.

It is definetely good if we can come up with a better approach though.

> 
> > 	 *
> > 	 * The global entry point sequence is always of the form:
> > 	 *
> > 	 * addis r2,r12,XXXX
> > 	 * addi  r2,r2,XXXX
> > 	 *
> > 	 * A linker optimisation may convert the addis to lis:
> > 	 *
> > 	 * lis   r2,XXXX
> > 	 * addi  r2,r2,XXXX
> > 	 */
> > 	if ((((*insn & OP_RT_RA_MASK) == ADDIS_R2_R12) ||
> > 	     ((*insn & OP_RT_RA_MASK) == LIS_R2)) &&
> > 	    ((*(insn+1) & OP_RT_RA_MASK) == ADDI_R2_R2))
> 
> is this check/instructions specific to kernel code?
> 
> In the test prog I see following instructions:
> 
> Dump of assembler code for function get_base_addr:
>    0x0000000010034cb0 <+0>:     lis     r2,4256
>    0x0000000010034cb4 <+4>:     addi    r2,r2,31488
>    ...
> 
> but first instruction does not match the check in kernel code above:
> 
> 	1.insn value:	0x3c4010a0
> 	2.insn value:	0x38427b00
> 
> the used defines are:
> 	#define OP_RT_RA_MASK   0xffff0000UL
> 	#define LIS_R2          0x3c020000UL
> 	#define ADDIS_R2_R12    0x3c4c0000UL
> 	#define ADDI_R2_R2      0x38420000UL

Good catch! That's wrong, and I suspect we haven't noticed since kernel 
almost always ends up using the addis variant. I will send a fix for 
this.

> 
> 
> maybe we could skip the check, and run the test twice: first on
> kallsym address and if the uprobe is not hit we will run it again
> on address + 8

Sure, like I mentioned, I'm fine with any approach. Offset'ing into the 
function by 8 is easy and generally works. Re-trying is fine too. The 
proper approach will requires us to consult the symbol table and check 
st_other field [see commit 0b3c2264ae30ed ("perf symbols: Fix kallsyms 
perf test on ppc64le")]

Thanks,
- Naveen
Jiri Olsa March 4, 2021, 3:55 p.m. UTC | #13
On Thu, Mar 04, 2021 at 11:46:27AM +1100, Michael Ellerman wrote:
> "Naveen N. Rao" <naveen.n.rao@linux.vnet.ibm.com> writes:
> > On 2021/03/02 11:35AM, Jiri Olsa wrote:
> >> On Mon, Mar 01, 2021 at 02:58:53PM -0800, Yonghong Song wrote:
> >> > 
> >> > 
> >> > On 3/1/21 11:04 AM, Jiri Olsa wrote:
> >> > > When testing uprobes we the test gets GEP (Global Entry Point)
> >> > > address from kallsyms, but then the function is called locally
> >> > > so the uprobe is not triggered.
> >> > > 
> >> > > Fixing this by adjusting the address to LEP (Local Entry Point)
> >> > > for powerpc arch.
> >> > > 
> >> > > Signed-off-by: Jiri Olsa <jolsa@kernel.org>
> >> > > ---
> >> > >   .../selftests/bpf/prog_tests/attach_probe.c    | 18 +++++++++++++++++-
> >> > >   1 file changed, 17 insertions(+), 1 deletion(-)
> >> > > 
> >> > > diff --git a/tools/testing/selftests/bpf/prog_tests/attach_probe.c b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> >> > > index a0ee87c8e1ea..c3cfb48d3ed0 100644
> >> > > --- a/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> >> > > +++ b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
> >> > > @@ -2,6 +2,22 @@
> >> > >   #include <test_progs.h>
> >> > >   #include "test_attach_probe.skel.h"
> >> > > +#if defined(__powerpc64__)
> >
> > This needs to be specific to ELF v2 ABI, so you'll need to check 
> > _CALL_ELF. See commit d5c2e2c17ae1d6 ("perf probe ppc64le: Prefer symbol 
> > table lookup over DWARF") for an example.
> >
> >> > > +/*
> >> > > + * We get the GEP (Global Entry Point) address from kallsyms,
> >> > > + * but then the function is called locally, so we need to adjust
> >> > > + * the address to get LEP (Local Entry Point).
> >> > 
> >> > Any documentation in the kernel about this behavior? This will
> >> > help to validate the change without trying with powerpc64 qemu...
> >
> > I don't think we have documented this in the kernel anywhere, but this 
> > is specific to the ELF v2 ABI and is described there:
> > - 2.3.2.1.  Function Prologue: 
> >   http://cdn.openpowerfoundation.org/wp-content/uploads/resources/leabi/content/dbdoclet.50655240___RefHeading___Toc377640597.html
> > - 3.4.1.  Symbol Values:
> >    http://cdn.openpowerfoundation.org/wp-content/uploads/resources/leabi/content/dbdoclet.50655241_95185.html
> 
> There's a comment in ppc_function_entry(), but I don't think we have any
> actual "documentation".
> 
> static inline unsigned long ppc_function_entry(void *func)
> {
> #ifdef PPC64_ELF_ABI_v2
> 	u32 *insn = func;
> 
> 	/*
> 	 * A PPC64 ABIv2 function may have a local and a global entry
> 	 * point. We need to use the local entry point when patching
> 	 * functions, so identify and step over the global entry point
> 	 * sequence.

hm, so I need to do the instructions check below as well

> 	 *
> 	 * The global entry point sequence is always of the form:
> 	 *
> 	 * addis r2,r12,XXXX
> 	 * addi  r2,r2,XXXX
> 	 *
> 	 * A linker optimisation may convert the addis to lis:
> 	 *
> 	 * lis   r2,XXXX
> 	 * addi  r2,r2,XXXX
> 	 */
> 	if ((((*insn & OP_RT_RA_MASK) == ADDIS_R2_R12) ||
> 	     ((*insn & OP_RT_RA_MASK) == LIS_R2)) &&
> 	    ((*(insn+1) & OP_RT_RA_MASK) == ADDI_R2_R2))

is this check/instructions specific to kernel code?

In the test prog I see following instructions:

Dump of assembler code for function get_base_addr:
   0x0000000010034cb0 <+0>:     lis     r2,4256
   0x0000000010034cb4 <+4>:     addi    r2,r2,31488
   ...

but first instruction does not match the check in kernel code above:

	1.insn value:	0x3c4010a0
	2.insn value:	0x38427b00

the used defines are:
	#define OP_RT_RA_MASK   0xffff0000UL
	#define LIS_R2          0x3c020000UL
	#define ADDIS_R2_R12    0x3c4c0000UL
	#define ADDI_R2_R2      0x38420000UL


maybe we could skip the check, and run the test twice: first on
kallsym address and if the uprobe is not hit we will run it again
on address + 8

thanks,
jirka

> 		return (unsigned long)(insn + 2);
> 	else
> 		return (unsigned long)func;
> 
> 
> cheers
>
Jiri Olsa March 5, 2021, 1:38 p.m. UTC | #14
On Thu, Mar 04, 2021 at 07:04:59AM +0530, Naveen N. Rao wrote:

SNIP

> > > static inline unsigned long ppc_function_entry(void *func)
> > > {
> > > #ifdef PPC64_ELF_ABI_v2
> > > 	u32 *insn = func;
> > > 
> > > 	/*
> > > 	 * A PPC64 ABIv2 function may have a local and a global entry
> > > 	 * point. We need to use the local entry point when patching
> > > 	 * functions, so identify and step over the global entry point
> > > 	 * sequence.
> > 
> > hm, so I need to do the instructions check below as well
> 
> It's a good check, but probably not necessary. In most functions, we 
> expect to be able to probe two instructions later without much of a 
> change to affect function tracing for userspace. For this reason, we 
> just probe at an offset of 8 as a reasonable fallback.
> 
> It is definetely good if we can come up with a better approach though.
> 
> > 
> > > 	 *
> > > 	 * The global entry point sequence is always of the form:
> > > 	 *
> > > 	 * addis r2,r12,XXXX
> > > 	 * addi  r2,r2,XXXX
> > > 	 *
> > > 	 * A linker optimisation may convert the addis to lis:
> > > 	 *
> > > 	 * lis   r2,XXXX
> > > 	 * addi  r2,r2,XXXX
> > > 	 */
> > > 	if ((((*insn & OP_RT_RA_MASK) == ADDIS_R2_R12) ||
> > > 	     ((*insn & OP_RT_RA_MASK) == LIS_R2)) &&
> > > 	    ((*(insn+1) & OP_RT_RA_MASK) == ADDI_R2_R2))
> > 
> > is this check/instructions specific to kernel code?
> > 
> > In the test prog I see following instructions:
> > 
> > Dump of assembler code for function get_base_addr:
> >    0x0000000010034cb0 <+0>:     lis     r2,4256
> >    0x0000000010034cb4 <+4>:     addi    r2,r2,31488
> >    ...
> > 
> > but first instruction does not match the check in kernel code above:
> > 
> > 	1.insn value:	0x3c4010a0
> > 	2.insn value:	0x38427b00
> > 
> > the used defines are:
> > 	#define OP_RT_RA_MASK   0xffff0000UL
> > 	#define LIS_R2          0x3c020000UL
> > 	#define ADDIS_R2_R12    0x3c4c0000UL
> > 	#define ADDI_R2_R2      0x38420000UL
> 
> Good catch! That's wrong, and I suspect we haven't noticed since kernel 
> almost always ends up using the addis variant. I will send a fix for 
> this.

the new macro value from your fix works for the test,
so I'll use it in v2, so we don't just blindly go to
+8 offset.. I'll send it out shortly

> 
> > 
> > 
> > maybe we could skip the check, and run the test twice: first on
> > kallsym address and if the uprobe is not hit we will run it again
> > on address + 8
> 
> Sure, like I mentioned, I'm fine with any approach. Offset'ing into the 
> function by 8 is easy and generally works. Re-trying is fine too. The 
> proper approach will requires us to consult the symbol table and check 
> st_other field [see commit 0b3c2264ae30ed ("perf symbols: Fix kallsyms 
> perf test on ppc64le")]

I think we don't want to complicate this test with symbol table
check. I'll propose the fix with the extra instructions check
for now and we can add symbol table check in future if it's not
enough

thanks for all the info,
jirka

> 
> Thanks,
> - Naveen
>
diff mbox series

Patch

diff --git a/tools/testing/selftests/bpf/prog_tests/attach_probe.c b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
index a0ee87c8e1ea..c3cfb48d3ed0 100644
--- a/tools/testing/selftests/bpf/prog_tests/attach_probe.c
+++ b/tools/testing/selftests/bpf/prog_tests/attach_probe.c
@@ -2,6 +2,22 @@ 
 #include <test_progs.h>
 #include "test_attach_probe.skel.h"
 
+#if defined(__powerpc64__)
+/*
+ * We get the GEP (Global Entry Point) address from kallsyms,
+ * but then the function is called locally, so we need to adjust
+ * the address to get LEP (Local Entry Point).
+ */
+#define LEP_OFFSET 8
+
+static ssize_t get_offset(ssize_t offset)
+{
+	return offset + LEP_OFFSET;
+}
+#else
+#define get_offset(offset) (offset)
+#endif
+
 ssize_t get_base_addr() {
 	size_t start, offset;
 	char buf[256];
@@ -36,7 +52,7 @@  void test_attach_probe(void)
 	if (CHECK(base_addr < 0, "get_base_addr",
 		  "failed to find base addr: %zd", base_addr))
 		return;
-	uprobe_offset = (size_t)&get_base_addr - base_addr;
+	uprobe_offset = get_offset((size_t)&get_base_addr - base_addr);
 
 	skel = test_attach_probe__open_and_load();
 	if (CHECK(!skel, "skel_open", "failed to open skeleton\n"))