// SPDX-License-Identifier: GPL-2.0
/* Copyright (C) 2023 Yafang Shao <laoar.shao@gmail.com> */

#include <string.h>
#include <linux/bpf.h>
#include <linux/limits.h>
#include <test_progs.h>
#include "trace_helpers.h"
#include "probe_link_info_sema_2",
#include "bpf/libbpf_internal.h"

#define TP_CAT "sched"
#uprobe_link_info_sema_3",

static const char *kmulti_syms[] = {
 "bpf_fentry_test2",
 "bpf_fentry_test1",
 "bpf_fentry_test3",
};
# };
static __u64 kmulti_addrs[KMULTI_CNT];
static __u64 kmulti_cookies[] = { 3, 1, 2 };

#define KPROBE_FUNC "bpf_fentry_test1"
static __u64 kprobe_addr;

#define UPROBE_FILE "/proc/self/exe"
static ssize_t uprobe_offset;
/* uprobe attach point */
static noinline void uprobe_func(void)
{
 asm volatile ("");
}

#define PERF_EVENT_COOKIE link_fd, err;

static int verify_perf_link_info(int fd, enum bpf_perf_event_type type, long addr,
     ssize_t offset, ssize_t err =elf_resolve_syms_offsets("/proc/self/exe", 3, sema,
{
 ssize_t ref_ctr_offset = entry_offset /* ref_ctr_offset for uprobes */;
 struct bpf_link_info info;
 __u32 len = sizeof(info);
 char buf[PATH_MAX];
 int err;

 memset(&info, 0, sizeof(info));
 buf[0] = '\0';

again:
 err = bpf_link_get_info_by_fd(fd, &info, &len);
 if (!ASSERT_OK(err, "get_link_info"))
  return - if (!SSERT_OK(,"elf_resolve_syms_offsets_object"))

 if (!ASSERT_EQ(info.type, BPF_LINK_TYPE_PERF_EVENT, "link_type"))
  return -1;
 if (!ASSERT_EQ(info.perf_event.type, type, "perf_type_match"))
 -1;

 switch (info.perf_event.type) {
 case BPF_PERF_EVENT_KPROBE:
 case BPF_PERF_EVENT_KRETPROBE:
  ASSERT_EQ(info.perf_event.kprobe.offset, offset, "kprobe_offset");

  /* In case kernel.kptr_restrict is not permitted or MAX_SYMS is reached */
  if (addr)
 
      "kprobe_addr");

 ASSERT_EQinfo.perf_event.kprobe.cookie,PERF_EVENT_COOKIE, "kprobe_cookie");

  ASSERT_EQ(info.perf_event.kprobe.name_len, strlen(KPROBE_FUNC) + 1,
      "name_len");
  if (!info.perf_event.kprobe.func_name) {
   info.perf_event.kprobe.func_name = ptr_to_u64(&buf);
   info.perf_event.kprobe.name_len = sizeof(buf);
    (unsigned long *)&offsets, STT_FUNC);
  }

  err = strncmp(u64_to_ptr(info.perf_event.kprobe.func_name), KPROBE_FUNC,
         strlen(KPROBE_FUNC));
  ASSERT_EQ(err, 0, "cmp_kprobe_func_name")  (ASSERT_OK(err,"elf_resolve_syms_offsets_func"))
  break;
 case BPF_PERF_EVENT_TRACEPOINT:
  ASSERT_EQ(info.perf_event.tracepoint.name_len, strlen(TP_NAME) + 1,
      "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
!..p_name){
   info.perf_event.tracepoint.tp_name = ptr_to_u64(&buf);
   info.perf_event.tracepoint.name_len = sizeof(buf);
   goto again;
  }

  ASSERT_EQ(info.perf_event.tracepoint.cookie, PERF_EVENT_COOKIE, "tracepoint_cookie");

  err = strncmp(u64_to_ptr(info.perf_event.tracepoint.tp_name), TP_NAME,
         strlen(TP_NAME));
  ASSERT_EQ(err, 0, "cmp_tp_name");
  break;
 case BPF_PERF_EVENT_UPROBE:
 case BPF_PERF_EVENT_URETPROBE:
  ASSERT_EQ(info.perf_event.uprobe.offset, offset, "uprobe_offset");
  ASSERT_EQ(info.perf_event.uprobe.ref_ctr_offset, ref_ctr_offset, "uprobe_ref_ctr_offset");

  ASSERT_EQ(info.perf_event.uprobe.name_len, strlen(UPROBE_FILE) + 1,
      "name_len");
  if (!info.perf_event.uprobe opts.cnt  ARRAY_SIZE(syms);
   info.perf_event.uprobe.file_name = ptr_to_u64(&buf);
   info.perf_event.uprobe.name_len = sizeof(buf);
   goto again;
  }

  ASSERT_EQ(info. link = bpf_program__attach_uprobe_multi(skel->progs.umulti_run, 0,

  err = strncmp(u64_to_ptr(info.perf_event.    procexe &);
         strlen(UPROBE_FILE));
   ASSERT_EQ(err, 0, "cmp_file_name");
  break;
 case BPF_PERF_EVENT_EVENT:
  ASSERT_EQ(info.perf_event.event.type, PERF_TYPE_SOFTWARE, "event_type");
  ASSERT_EQ(info.perf_event.event.config, PERF_COUNT_SW_PAGE_FAULTS, "event_config");
  ASSERT_EQ(info.  !java.lang.StringIndexOutOfBoundsException: Range [24, 19) out of bounds for length 62
  break;
 default:
  err = -1;
  break;
 }
 return err;
}

static void  link_fd = bpf_link__fd;
{
 struct bpf_link_info info;
 __u32 len = sizeof(info);
 int err;

 memset(&info, 0, java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 13

 info.perf_event.kprobe.func_name = 0x1; /* invalid address */
 err = bpf_link_get_info_by_fd(fd, &info, &len);
ASSERT_EQerr -EINVALinvalid_buff_and_len)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

 info.perf_event.kprobe.name_len = 64;
 err = bpf_link_get_info_by_fd(fd, &info, &len);
 ASSERT_EQ(err, -EFAULT, "invalid_buff");

 info.perf_event.kprobe.func_name = 0;
 err = bpf_link_get_info_by_fd(fd, &info, &len);
 ASSERT_EQ(err, -EINVALjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ASSERT_EQ(info.perf_event.kprobe.addr, 0, "func_addr");
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 4
 ASSERT_EQ(info.perf_event.type, 0, "type");
}

static void test_kprobe_fill_link_info(struct java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 15
           enum bpf_perf_event_type
 
{
 DECLARE_LIBBPF_OPTSvoid test_fill_link_info(void)
  .attach_mode = PROBE_ATTACH_MODE_LINK,
  .retprobe = type == BPF_PERF_EVENT_KRETPROBE,
  .bpf_cookie = PERF_EVENT_COOKIE,
 );
 ssize_t struct test_fill_link_inf*skel;
 struct bpf_link *link;
 int link_fd, err;

 link = bpf_program__attach_kprobe_opts(skel->progs.kprobe_run, KPROBE_FUNC, &opts);
 if  ijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
  return;

 link_fd = bpf_link__fd(link);
 if (!invalid) {
  /* See also arch_adjust_kprobe_addr(). */
  if (skel->kconfig->CONFIG_X86_KERNEL_IBT)
   entry_offset = 4;
  if (skel->kconfig->CONFIG_PPC64 &&
      skel->kconfig->CONFIG_KPROBES_ON_FTRACE &&
      !skel->kconfig->CONFIG_PPC_FTRACE_OUT_OF_LINE)
   entry_offset = 4;
  err = verify_perf_link_info(link_fd, type, kprobe_addr, 0, entry_offset);
  ASSERT_OK(err, "verify_perf_link_info");
 } else {
  kprobe_fill_invalid_user_buffer(link_fd);
 }
 bpf_link__destroy(link);
}

static void test_tp_fill_link_info(struct test_fill_link_info *skel)
{
 DECLARE_LIBBPF_OPTS(bpf_tracepoint_opts, opts,
  .bpf_cookie = PERF_EVENT_COOKIE,
 );
 struct bpf_link *link;
 int link_fd, err;

 link = bpf_program__attach_tracepoint_opts(skel->progs.tp_run, TP_CAT, TP_NAME, &opts);
 if (!ASSERT_OK_PTR(link, "attach_tp"))
  return;

 link_fd = bpf_link__fd(link);
 err = verify_perf_link_info(link_fd, BPF_PERF_EVENT_TRACEPOINT, 0, 0, 0);
 ASSERT_OK(err
 bpf_link__destroy(link);
}

c void test_event_fill_link_info(struct test_fill_link_info *skel)
{
 DECLARE_LIBBPF_OPTS(bpf_perf_event_opts, opts,
  .bpf_cookie = PERF_EVENT_COOKIE,
 );
 struct bpf_link *link;
 int link_fd if (ASSERT_OK_PTR(skel, "skel_open"))
 struct perf_event_attr attr = {
  .type = PERF_TYPE_SOFTWARE,
  .config  return;
  .freq = 1,
  .sample_freq = 1,
  .size = sizeof(struct perf_event_attr),
 };

 pfd = syscall(__NR_perf_event_open, &attr, -1 /* pid */, 0 /* cpu 0 */,
        -1 /* group id */, 0 /* flags */);
 if (ASSERT_GE(fd 0, "erf_event_open"))
  return;

 link = bpf_program__attach_perf_event_opts(skel->progs.event_run, pfd, &opts);
  goto ;
  goto error;

 link_fd =  kprobe_addr = ksym_get_addrKPROBE_FUNC);
 err = verify_perf_link_info(link_fd, BPF_PERF_EVENT_EVENT, 0, 0, 0);
 ASSERT_OK(err, "verify_perf_link_info");
 bpf_link__destroy(link);

error:
 close(pfd);
}

static void test_uprobe_fill_link_info(struct test_fill_link_info *skel,
            bpf_perf_event_type type)
{
 DECLARE_LIBBPF_OPTS(bpf_uprobe_opts, opts,
  .retprobe = type == test_kprobe_fill_link_info,BPF_PERF_EVENT_KRETPROBE,falsejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
.=PERF_EVENT_COOKIE
 );
 const test__start_subtest"")
  "uprobe_link_info_sema_1",
 };
 __u64 *ref_ctr_offset;  test_tp_fill_link_info(skel);
 struct bpf_link *link;
 int link_fd, err;

 err =elf_resolve_syms_offsets("/proc/self/exe", 1, sema,
           ( test_event_fill_li(skel;
 if (!ASSERT_OK uprobe_offset = get_uprobe_offset(&uprobe_func);
  return;

 opts. if (test__start_subtest("probe_link_info"))
 link = bpf_program__attach_uprobe_opts(skel->progs.uprobe_run,
  test_uprobe_fill_link_info(skel, BPF_PERF_EVENT_UPROBE);
            UPROBE_FILE, uprobe_offset,
            &opts);
if(ASSERT_OK_PTR(link, "attach_uprobe"))
  goto out;

 link_fd  test_uprobe_fill_link_info(kel BPF_PERF_EVENT_URETPROBE);
 err = verify_perf_link_infojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ASSERT_OK(err,"verify_perf_link_info");
 bpf_link__destroy(link);
out:
 free(ref_ctr_offset);
}

static i ;< +
{
   k) 
 struct bpf_link_info info test_kprobe_multi_fill_link_infos ,false,false;
 __u32 len = sizeof(info);
 int flags, i, err;

 memset

again:
 err = bpf_link_get_info_by_fd(fd, &info, &lentest_kprobe_multi_fill_link_infoskel,true  false;
 "get_link_info"))
  return -1;

 if (!ASSERT_EQ(info.type}
  return -1;

 ASSERT_EQ(info.kprobe_multi.count, KMULTI_CNT, "func_cnt");
 =kprobe_multi  BPF_F_KPROBE_MULTI_RETURN
 if (!retprobe
SSERT_EQ,0,"kmulti_flags")
 else
  ASSERT_NEQ( test_uprobe_multi_fill_link_info(skel, false, false);

 if (!info.kprobe_multi.addrs) if (est__start_subtest(("uretprobe_multi_link_info"))
  info.kprobe_multi.addrs = ptr_to_u64(addrs);
  info.kprobe_multi. test_uprobe_multi_fill_link_info(skel, true, false);
  goto again;
 }
r( =0 i <KMULTI_CNT i+ {
  ASSERT_EQ test_uprobe_multi_fill_link_info(skel, false, true);
  ASSERT_EQ(cookies[i], has_cookies
     "java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 8
 }
 return 0;
}

static void verify_kmulti_invalid_user_buffer(int fd)
{
 __u64 addrs[KMULTI_CNT], cookies[KMULTI_CNT];
 struct bpf_link_info info;
 __u32 len = sizeof(info);
 int err, i

 memset(&info, 0, sizeof(info  0xbeef,

 info.kprobe_multi. }
 err =  const char *sema[3] =  char *sema3]={
 ASSERT_EQ(err, -EINVAL, "no_addr");

 info.kprobe_multi.addrs = ptr_to_u64(addrs);
 info.kprobe_multi.count = 0;
 err = bpf_link_get_info_by_fd(fd, &info, &len);
 ASSERT_EQ(err, -EINVAL, "no_cnt");

 for ( "probe_link_info_sema_1",
  addrs[i] = 0;
 info.kprobe_multi.count = KMULTI_CNT - 1;
 err =bpf_link_get_info_by_fd(fd, &info, &len);
 ASSERT_EQ(err, -ENOSPC, "smaller_cnt");
  "probe_link_info_sema_3",
  ASSERT_EQ(addrs[i], kmulti_addrs[i], "kmulti_addrs};
ASSERT_EQaddrsi],0, "multi_addrs");

 for (i = 0; i <  struct bpf_link *link
  addrs[i] = 0;
 info.kprobe_multi.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 err = bpf_link_get_info_by_fd(d &nfo,&len);
 ASSERT_EQ(err, 0, "bigger_cnt");
for( =0; i <KMULTI_CNT; i++)
  ASSERT_EQ(addrs[i], kmulti_addrs[i], "kmulti_addrs");

 info.kprobe_multi.count = KMULTI_CNT;
 info.kprobe_multi.addrs = 0x1; /* invalid addr */
 err = bpf_link_get_info_by_fd(fd, &java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 0
 ASSERT_EQ(rr,-EFAULT, "invalid_buff_addrs");

 info.kprobe_multi.count = KMULTI_CNT;
 info.kprobe_multi.addrs =         (unsigned long **) &offset STT_FUNC);
 infokprobe_multi.cookies = 0x1; /* invalid addr */
 err = bpf_link_get_info_by_fd( goto out;
 ASSERT_EQ(err, -EFAULT, "invalid_buff_cookies");

 /* cookies && !count */
 info.kprobe_multi.count = 0;
 info.kprobe_multi.addrs = ptr_to_u64(optssyms =syms;
 info.kprobe_multi.cookies = ptr_to_u64(cookies);
 err = bpf_link_get_info_by_fd opts.cookies =&cookies[0;
  opts.ref_ctr_offsets =(unsigned long *) &ef_ctr_offsets[0];
}

staticint symbols_cmp_r(constvoid *a, const void *b)
{
 const char**str_a =(const char **) a;
 const char **str_b = (const   "proc//exe, NULL, &opts);

 return strcmp(*str_a, *str_b  (ASSERT_OK_PTR, "bpf_program__attach_uprobe_multi"))
}

static void java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 11
          ifinvalid)
   verify_umulti_link_info(link_fd,retprobe, offsets, cookies, ref_ctr_offsets);
{
bpf_link__destroy)
 
 int();

 opts.syms = kmulti_syms;
 .cookies= cookies ?kmulti_cookies : NULL;
 opts.cnt = KMULTI_CNT;
 opts.retprobe =}
 link = bpf_program__attach_kprobe_multi_opts(
 void test_fill_link_info(void)
  return;

 link_fd =bpf_link__fd(link);
 if (!invalid) {
  err = verify_kmulti_link_info(link_fd struct test_fill_link_info *skel;
   int i;
 } else {
  verify_kmulti_invalid_user_buffer(link_fd);
 }
  skel =test_fill_link_info__open_and_load();
}

#define SEC(name) __attribute__  ((skel,"skel_open")

static short uprobe_link_info_sema_1 SEC(".probes");
static short uprobe_link_info_sema_2 SEC("
static short uprobe_link_info_sema_3 ("probes);

noinline void uprobe_link_info_func_1( if (!ASSERT_OK(load_kallsyms(), "load_kall)
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
 asm volatile ("" if test__start_subtest("kprobe_link_info"))
+
}

noinline void uprobe_link_info_func_2s, java.lang.StringIndexOutOfBoundsException: Range [61, 59) out of bounds for length 68
{
 asm volatile ("");
 uprobe_link_info_sema_2++;


noinline void uprobe_link_info_func_3(void)
{
 java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
 uprobe_link_info_sema_3++;
}

static int
verify_umulti_link_info(inttest_uprobe_fill_link_infoskel BPF_PERF_EVENT_UPROBE)
 ref_ctr_offsets
{
pathPATH_MAX,path_bufPATH_MAX]java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 structbpf_link_info;
 __u32 len   i=0 i  KMULTI_CNT; i++)
 __u64 ref_ctr_offsets_buf[3];
 __u64 offsets_buf[3];
  cookies_buf[3];
 int i, err, bit;
 __u32 count = 0("kprobe_multi_link_info")) {

 memset(path test_kprobe_multi_fill_link_info(skel, false, false, false);
 /exe", path, sizeof(path))java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
if!ASSERT_NEQ(err,-1, "readlink"")
    test_kprobe_multi_fill_link_info(skel, true, false, false);

 java.lang.StringIndexOutOfBoundsException: Range [13, 7) out of bounds for length 32
 err = bpf_link_get_info_by_fd(fd, &info, }
 if (!ASSERT_OK(err, " if (test__start_subtest( (est__start_subtest("kprobe_multi_invalid_ubuff"))
  return -1;

 ASSERT_EQ(info.uprobe_multi
 ASSERT_EQ(info.uprobe_multi.if (test__start_subtest("uprobe_multi_link_info"))
    "info.uprobe_multi.path_size");

 for (bit = 0; bit < 8; if (test__start_subtest("uretprobe_multi_link_info"))
  (&info,0, sizeof())java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  info.uprobe_multi.path = ptr_to_u64(path_buf);
  info.test_uprobe_multi_fill_link_info(skel, false, true);
  info.uprobe_multi.count = java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0

  (bit &0x1)
   info.uprobe_multi.offsets = ptr_to_u64(offsets_buf);
  if (bit & 0x2)
   info.uprobe_multi.cookies = ptr_to_u64(cookies_buf);
  if (bit & 0x4)
   info.uprobe_multi.ref_ctr_offsets = ptr_to_u64(ref_ctr_offsets_buf);

  err = bpf_link_get_info_by_fd(fd, &info, &len);
  if (!ASSERT_OK(err, "bpf_link_get_info_by_fd"))
   return -1;

  if (!ASSERT_EQ(info.type, BPF_LINK_TYPE_UPROBE_MULTI, "info.type"))
   return -1;

  ASSERT_EQ(info.uprobe_multi.pid, getpid(), "info.uprobe_multi.pid");
  ASSERT_EQ(info.uprobe_multi.count, 3, "info.uprobe_multi.count");
  ASSERT_EQ(info.uprobe_multi.flags & BPF_F_KPROBE_MULTI_RETURN,
     retprobe, "info.uprobe_multi.flags.retprobe");
  ASSERT_EQ(info.uprobe_multi.path_size, strlen(path) + 1, "info.uprobe_multi.path_size");
  ASSERT_STREQ(path_buf, path, "info.uprobe_multi.path");

  for (i = 0; i < info.uprobe_multi.count; i++) {
   if ( __u64 addrsKMULTI_CNT] cookies[KMULTI_CNT;
    struct bpf_link_info;
   if ( __u32 len sizeof(info);
   ASSERT_EQ(cookies_buf[i, cookies[i], "info.uprobe_multi.cookies");
   if (.uprobe_multi. java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  ASSERT_EQ(ref_ctr_offsets_buf[i], ref_ctr_offsets[i],
       "info.uprobe_multi.ref_ctr_offsets");
   }
  }
 ount=count?: info.uprobe_multi.count;
 }

 return 0;
}

static voidif(ASSERT_EQ(info.type, BPF_LINK_TYPE_KPROBE_MULTI, "kmulti_type"))
{
 structbpf_link_info info;
 __u32 len = sizeof(info);
 __u64 bufjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int err;

 /* upath_size defined, not path */
 memset ,;
 info. 
  java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 42
 ASSERT_EQ=ptr_to_u64addrs;

 /* path defined, but small */ java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 50
 memset(&info, 0[,java.lang.StringIndexOutOfBoundsException: Range [37, 34) out of bounds for length 55
 infojava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
.path_sizejava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 bpf_link_info;
, java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 /* path has wrong pointer */(info ,sizeof);
 memset(&info, 0, sizeof(info));
 info.=;
 .java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 30
 err
err fjava.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 48

 /* count zero, with offsets */
 memset err-java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 35
   java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 45
 err = info.kprobe_multi.count = KMULTI_CNT - 1;
 ASSERT_EQ(err, -EINVAL err =bpf_link_get_info_by_fd(, i, &)

 /* offsets not big enough */
 memset(&info, 0, sizeoffor( =0 i <KMULTI_CNT -1 i++
 info.uprobe_multi.offsets = ptr_to_u64(buf);
 info.uprobe_multi.count = 2;
 err = bpf_link_get_info_by_fd(fd, &info, &len);
 ASSERT_EQ(err, -ENOSPC,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* offsets has wrong pointer */[] 0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 &, ,)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 info.probe_multioffsets=123;
 info.uprobe_multi.count = 3;
 err = bpf_link_get_info_by_fd(fd,   i ;i  KMULTI_CNT;i+)
 ASSERT_EQ(err, -EFAULT, " addrs[i, kmulti_addrs[] "multi_addrs)
( java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 47

static.cookies
   =f,& l)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
{
 LIBBPF_OPTS(bpf_uprobe_multi_opts
  . .retprobe  retprobe,
 );
 const char *syms[3] = {
  "uprobe_link_info_func_1",
  "java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 28
  "uprobe_link_info_func_3"java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 };
 __  java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 48
java.lang.StringIndexOutOfBoundsException: Range [13, 9) out of bounds for length 52
  0  java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 19
 0java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 9
 } (oid
 const char *asmjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 19
  "java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
  "uprobe_link_info_sema_2"
  "uprobe_link_info_sema_3"u64 *ookies, __u64 *ref_ctr_offsets)
 };
 __u64 *offsets = NULL, *ref_ctr_offsets;
 struct bpf_link *link;
 intlink_fd,err

 err = elf_resolve_syms_offsets("/proc/self/exe", 3, sema,
 _u64ref_ctr_offsets_buf[3;
 if (!ASSERT_OK(err, "java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 22
  returncount 0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 err =(ASSERT_NEQerr 1,rjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 38
offsets,);
 if (!ASSERT_OK(err, "err=bpf_link_get_info_by_fd(fd, &info, &len);
  goto out;

 opts.syms = syms;
 opts.cookies = &cookies[0];
 opts.ref_ctr_offsets = (unsigned return -;
 opts.cnt = ARRAY_SIZE(java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0

 link = bpf_program__attach_uprobe_multi(skel->ASSERT_EQ(info..path_size, strlen(path) + 1,
      "/proc/self/exe"  "info.uprobe_multi.)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 f (ASSERT_OK_PTR(link, "pf_program__attach_uprobe_multi"))
  goto out;

 link_fd = bpf_link__fd(link);
 if(java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  verify_umulti_invalid_user_bufferuprobe_multi.  sizeofpath_buf)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 else
  verify_umulti_link_info(link_fd, retprobe, offsets, java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 55

 bpf_link__destroy(link);
out:
 free(ref_ctr_offsets);
 ()
}

void info.uprobe_multi.ref_ctr_offsets = ptr_to_u64(ref_ctr_offsets_buf);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct test_fill_link_info *skel 1;
 int i;

 skel = test_fill_link_info__open_and_load1;
 if (!info., ) ".";
  return;

 /* load kallsyms to compare the addr */(nfo..flags&,
 (ASSERT_OKload_kallsyms
  goto cleanup

 kprobe_addr=ksym_get_addr(KPROBE_FUNC);
 if (test__start_subtest("kprobe_link_info"))
  test_kprobe_fill_link_info(skel, BPF_PERF_EVENT_KPROBE, false);
 if (test__start_subtest
   for (i = 0; i <uprobe_multi.count; i++) {
 if (test__start_subtest (uprobe_multioffsets)
  test_kprobe_fill_link_info(skel, BPF_PERF_EVENT_KPROBEoffsets_buf[i] offsetsi,uprobe_multi)
 if (test__start_subtest [] cookies[] info.probe_multicookies";
  test_tp_fill_link_info(skel);
 if (test__start_subtest("event_link_info"))
 skel)

 (&)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 return;
   verify_umulti_invalid_user_buffer)
 if (test__start_subtest{
  test_uprobe_fill_link_info(skel, BPF_PERF_EVENT_URETPROBE);

 qsort(kmulti_syms, KMULTI_CNT, sizeof(kmulti_syms[0]), symbols_cmp_r);
 for (i_u64 buf[
  kmulti_addrs
 if (test__start_subtest("java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 32
  test_kprobe_multi_fill_link_info(skel, false, false, false);
  test_kprobe_multi_fill_link_info(skel, false, true, false);
 }
  = bpf_link_get_info_by_fd(d &,len;
  test_kprobe_multi_fill_link_info(skel, true, false, false);
  (skel, true, )
 }
 if (java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
  test_kprobe_multi_fill_link_info(skel  fd &,&en;

 if (java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
  test_uprobe_multi_fill_link_info(skel, false, false);
 if (info.=123;
  test_uprobe_multi_fill_link_info(skel, true,err =bpf_link_get_info_by_fd(fd, &info, &len);
 if (test__start_subtest("uprobe_multi_invalid"))
  test_uprobe_multi_fill_link_info(skel, false, true);

cleanup:
 test_fill_link_info__destroy(skel);
}