1. 28 Apr, 2022 7 commits
  2. 27 Apr, 2022 28 commits
  3. 26 Apr, 2022 5 commits
    • Alexei Starovoitov's avatar
      Merge branch 'Teach libbpf to "fix up" BPF verifier log' · d54d06a4
      Alexei Starovoitov authored
      Andrii Nakryiko says:
      
      ====================
      
      This patch set teaches libbpf to enhance BPF verifier log with human-readable
      and relevant information about failed CO-RE relocation. Patch #9 is the main
      one with the new logic. See relevant commit messages for some more details.
      
      All the other patches are either fixing various bugs detected
      while working on this feature, most prominently a bug with libbpf not handling
      CO-RE relocations for SEC("?...") programs, or are refactoring libbpf
      internals to allow for easier reuse of CO-RE relo lookup and formatting logic.
      ====================
      Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
      d54d06a4
    • Andrii Nakryiko's avatar
      selftests/bpf: Add libbpf's log fixup logic selftests · ea4128eb
      Andrii Nakryiko authored
      Add tests validating that libbpf is indeed patching up BPF verifier log
      with CO-RE relocation details. Also test partial and full truncation
      scenarios.
      
      This test might be a bit fragile due to changing BPF verifier log
      format. If that proves to be frequently breaking, we can simplify tests
      or remove the truncation subtests. But for now it seems useful to test
      it in those conditions that are otherwise rarely occuring in practice.
      
      Also test CO-RE relo failure in a subprog as that excercises subprogram CO-RE
      relocation mapping logic which doesn't work out of the box without extra
      relo storage previously done only for gen_loader case.
      Signed-off-by: default avatarAndrii Nakryiko <andrii@kernel.org>
      Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
      Link: https://lore.kernel.org/bpf/20220426004511.2691730-11-andrii@kernel.org
      ea4128eb
    • Andrii Nakryiko's avatar
      libbpf: Fix up verifier log for unguarded failed CO-RE relos · 9fdc4273
      Andrii Nakryiko authored
      Teach libbpf to post-process BPF verifier log on BPF program load
      failure and detect known error patterns to provide user with more
      context.
      
      Currently there is one such common situation: an "unguarded" failed BPF
      CO-RE relocation. While failing CO-RE relocation is expected, it is
      expected to be property guarded in BPF code such that BPF verifier
      always eliminates BPF instructions corresponding to such failed CO-RE
      relos as dead code. In cases when user failed to take such precautions,
      BPF verifier provides the best log it can:
      
        123: (85) call unknown#195896080
        invalid func unknown#195896080
      
      Such incomprehensible log error is due to libbpf "poisoning" BPF
      instruction that corresponds to failed CO-RE relocation by replacing it
      with invalid `call 0xbad2310` instruction (195896080 == 0xbad2310 reads
      "bad relo" if you squint hard enough).
      
      Luckily, libbpf has all the necessary information to look up CO-RE
      relocation that failed and provide more human-readable description of
      what's going on:
      
        5: <invalid CO-RE relocation>
        failed to resolve CO-RE relocation <byte_off> [6] struct task_struct___bad.fake_field_subprog (0:2 @ offset 8)
      
      This hopefully makes it much easier to understand what's wrong with
      user's BPF program without googling magic constants.
      
      This BPF verifier log fixup is setup to be extensible and is going to be
      used for at least one other upcoming feature of libbpf in follow up patches.
      Libbpf is parsing lines of BPF verifier log starting from the very end.
      Currently it processes up to 10 lines of code looking for familiar
      patterns. This avoids wasting lots of CPU processing huge verifier logs
      (especially for log_level=2 verbosity level). Actual verification error
      should normally be found in last few lines, so this should work
      reliably.
      
      If libbpf needs to expand log beyond available log_buf_size, it
      truncates the end of the verifier log. Given verifier log normally ends
      with something like:
      
        processed 2 insns (limit 1000000) max_states_per_insn 0 total_states 0 peak_states 0 mark_read 0
      
      ... truncating this on program load error isn't too bad (end user can
      always increase log size, if it needs to get complete log).
      Signed-off-by: default avatarAndrii Nakryiko <andrii@kernel.org>
      Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
      Link: https://lore.kernel.org/bpf/20220426004511.2691730-10-andrii@kernel.org
      9fdc4273
    • Andrii Nakryiko's avatar
      libbpf: Simplify bpf_core_parse_spec() signature · 14032f26
      Andrii Nakryiko authored
      Simplify bpf_core_parse_spec() signature to take struct bpf_core_relo as
      an input instead of requiring callers to decompose them into type_id,
      relo, spec_str, etc. This makes using and reusing this helper easier.
      Signed-off-by: default avatarAndrii Nakryiko <andrii@kernel.org>
      Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
      Link: https://lore.kernel.org/bpf/20220426004511.2691730-9-andrii@kernel.org
      14032f26
    • Andrii Nakryiko's avatar
      libbpf: Refactor CO-RE relo human description formatting routine · b58af63a
      Andrii Nakryiko authored
      Refactor how CO-RE relocation is formatted. Now it dumps human-readable
      representation, currently used by libbpf in either debug or error
      message output during CO-RE relocation resolution process, into provided
      buffer. This approach allows for better reuse of this functionality
      outside of CO-RE relocation resolution, which we'll use in next patch
      for providing better error message for BPF verifier rejecting BPF
      program due to unguarded failed CO-RE relocation.
      
      It also gets rid of annoying "stitching" of libbpf_print() calls, which
      was the only place where we did this.
      Signed-off-by: default avatarAndrii Nakryiko <andrii@kernel.org>
      Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
      Link: https://lore.kernel.org/bpf/20220426004511.2691730-8-andrii@kernel.org
      b58af63a