propagate nullness information for reg to reg comparisons
Status from this message: This series was applied to bpf/bpf-next.git (master)
Get series with b4
b4 am [email protected]Versions newest first · linked by author and title
- v3 Latest2 patches 0 repliesApplied 2/2
- v22 patches 0 repliesSuperseded
- v12 patches 8 repliesSuperseded
Changes in v3 from the cover letter
- verifier tests are updated with correct error message for unprivileged mode (pointer comparisons are forbidden in unprivileged mode).
Patches in v3 All 2 applied
| # | Subject and files | Size | Replies | Applied |
|---|---|---|---|---|
| 1/2 | bpf: propagate nullness information for reg to reg comparisonskernel/ | +33 | 0 replies | Applied |
| 2/2 | selftests/bpf: check nullness propagation for reg to reg comparisonstools/ | +174 | 0 replies | Applied |
Reviews trailers per patch
All 2 patches have a Reviewed-by or Acked-by.
| Patch | Yonghong Song |
|---|---|
| 1/2 | A-b |
| 2/2 | A-b |
Trailers given in replies are filled; those carried in the patches from earlier versions are outlined with dashes.
Cover letter [PATCH bpf-next v3 0/2] propagate nullness information for reg to reg comparisons
This patchset adds ability to propagates nullness information for branches of register to register equality compare instructions. The following rules are used:
- suppose register A maybe null
- suppose register B is not null
- for JNE A, B, ... - A is not null in the false branch
- for JEQ A, B, ... - A is not null in the true branch
E.g. for program like below:
r6 = skb->sk; r7 = sk_fullsock(r6); r0 = sk_fullsock(r6); if (r0 == 0) return 0; (a) if (r0 != r7) return 0; (b) *r7->type; (c) return 0;
It is safe to dereference r7 at point (c), because of (a) and (b).
The utility of this change came up while working on BPF CLang backend issue [1]. Specifically, while debugging issue with selftest test_sk_lookup.c. This test has the following structure:
int access_ctx_sk(struct bpf_sk_lookup *ctx __CTX__)
{
struct bpf_sock *sk1 = NULL, *sk2 = NULL;
...
sk1 = bpf_map_lookup_elem(&redir_map, &KEY_SERVER_A);
if (!sk1) // (a)
goto out;
...
if (ctx->sk != sk1) // (b)
goto out;
...
if (ctx->sk->family != AF_INET || // (c)
ctx->sk->type != SOCK_STREAM ||
ctx->sk->state != BPF_TCP_LISTEN)
goto out;
...
}- at (a) sk1 is checked to be not null;
- at (b) ctx->sk is verified to be equal to sk1;
- at (c) ctx->sk is accessed w/o nullness check.
Currently Global Value Numbering pass considers expressions sk1 and ctx->sk to be identical at point (c) and replaces ctx->sk with sk1 (not expressions themselves but corresponding SSA values). Since sk1 is known to be not null after (b) verifier allows execution of the program.
However, such optimization is not guaranteed to happen. When it does not happen verifier reports an error.
Changelog:
v2 -> v3:
- verifier tests are updated with correct error message for unprivileged mode (pointer comparisons are forbidden in unprivileged mode).
v1 -> v2:
- after investigation described in [2] as suggested by John, Daniel and Shung-Hsi, function type_is_pointer is removed, calls to this function are replaced by __is_pointer_value(false, src_reg).
RFC -> v1:
- newly added if block in check_cond_jmp_op is moved down to keep make_ptr_not_null_reg actions together;
- tests rewritten to have a single r0 = 0; exit; block.
[1] https://reviews.llvm.org/D131633#3722231
[2] https://lore.kernel.org/bpf/[email protected]/
[RFC] https://lore.kernel.org/bpf/[email protected]/
[v1] https://lore.kernel.org/bpf/[email protected]/
[v2] https://lore.kernel.org/bpf/[email protected]/
Eduard Zingerman (2):
bpf: propagate nullness information for reg to reg comparisons selftests/bpf: check nullness propagation for reg to reg comparisons
kernel/bpf/verifier.c | 35 +++- .../bpf/verifier/jeq_infer_not_null.c | 174 ++++++++++++++++++ 2 files changed, 207 insertions(+), 2 deletions(-) create mode 100644 tools/testing/selftests/bpf/verifier/jeq_infer_not_null.c
Signature · 1 line
2.34.1