Skip to contentSkip to conversation

bpf: Tidy up verifier checking

PATCH In review Joanne Koong 2 participants 4 messages Feb 17, 2023

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 bpf: Tidy up verifier checking

This change refactors check_mem_access() to check against the base type of the register, and uses switch case checking instead of if / else if checks. This change also uses the existing clear_called_saved_regs() function for resetting caller saved regs in check_helper_call().

---
 kernel/bpf/verifier.c | 67 +++++++++++++++++++++++++++++--------------
 1 file changed, 46 insertions(+), 21 deletions(-)
kernel/bpf/verifier.c +46 -21
index 272563a0b770..b40165be2943 100644
@@ -5317,7 +5317,8 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 	/* for access checks, reg->off is just part of off */
 	off += reg->off;
 
-	if (reg->type == PTR_TO_MAP_KEY) {
+	switch (base_type(reg->type)) {
+	case PTR_TO_MAP_KEY:
 		if (t == BPF_WRITE) {
 			verbose(env, "write to change key R%d not allowed\n", regno);
 			return -EACCES;
@@ -5329,7 +5330,10 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 			return err;
 		if (value_regno >= 0)
 			mark_reg_unknown(env, regs, value_regno);
-	} else if (reg->type == PTR_TO_MAP_VALUE) {
+
+		break;
+	case PTR_TO_MAP_VALUE:
+	{
 		struct btf_field *kptr_field = NULL;
 
 		if (t == BPF_WRITE && value_regno >= 0 &&
@@ -5369,7 +5373,10 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 				mark_reg_unknown(env, regs, value_regno);
 			}
 		}
-	} else if (base_type(reg->type) == PTR_TO_MEM) {
+		break;
+	}
+	case PTR_TO_MEM:
+	{
 		bool rdonly_mem = type_is_rdonly_mem(reg->type);
 
 		if (type_may_be_null(reg->type)) {
@@ -5394,7 +5401,10 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 					      reg->mem_size, false);
 		if (!err && value_regno >= 0 && (t == BPF_READ || rdonly_mem))
 			mark_reg_unknown(env, regs, value_regno);
-	} else if (reg->type == PTR_TO_CTX) {
+		break;
+	}
+	case PTR_TO_CTX:
+	{
 		enum bpf_reg_type reg_type = SCALAR_VALUE;
 		struct btf *btf = NULL;
 		u32 btf_id = 0;
@@ -5438,8 +5448,9 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 			}
 			regs[value_regno].type = reg_type;
 		}
-
-	} else if (reg->type == PTR_TO_STACK) {
+		break;
+	}
+	case PTR_TO_STACK:
 		/* Basic bounds checks. */
 		err = check_stack_access_within_bounds(env, regno, off, size, ACCESS_DIRECT, t);
 		if (err)
@@ -5456,7 +5467,9 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 		else
 			err = check_stack_write(env, regno, off, size,
 						value_regno, insn_idx);
-	} else if (reg_is_pkt_pointer(reg)) {
+		break;
+	case PTR_TO_PACKET:
+	case PTR_TO_PACKET_META:
 		if (t == BPF_WRITE && !may_access_direct_pkt_data(env, NULL, t)) {
 			verbose(env, "cannot write into packet\n");
 			return -EACCES;
@@ -5470,7 +5483,8 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 		err = check_packet_access(env, regno, off, size, false);
 		if (!err && t == BPF_READ && value_regno >= 0)
 			mark_reg_unknown(env, regs, value_regno);
-	} else if (reg->type == PTR_TO_FLOW_KEYS) {
+		break;
+	case PTR_TO_FLOW_KEYS:
 		if (t == BPF_WRITE && value_regno >= 0 &&
 		    is_pointer_value(env, value_regno)) {
 			verbose(env, "R%d leaks addr into flow keys\n",
@@ -5481,7 +5495,11 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 		err = check_flow_keys_access(env, off, size);
 		if (!err && t == BPF_READ && value_regno >= 0)
 			mark_reg_unknown(env, regs, value_regno);
-	} else if (type_is_sk_pointer(reg->type)) {
+		break;
+	case PTR_TO_SOCKET:
+	case PTR_TO_SOCK_COMMON:
+	case PTR_TO_TCP_SOCK:
+	case PTR_TO_XDP_SOCK:
 		if (t == BPF_WRITE) {
 			verbose(env, "R%d cannot write into %s\n",
 				regno, reg_type_str(env, reg->type));
@@ -5490,18 +5508,18 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 		err = check_sock_access(env, insn_idx, regno, off, size, t);
 		if (!err && value_regno >= 0)
 			mark_reg_unknown(env, regs, value_regno);
-	} else if (reg->type == PTR_TO_TP_BUFFER) {
+		break;
+	case PTR_TO_TP_BUFFER:
 		err = check_tp_buffer_access(env, reg, regno, off, size);
 		if (!err && t == BPF_READ && value_regno >= 0)
 			mark_reg_unknown(env, regs, value_regno);
-	} else if (base_type(reg->type) == PTR_TO_BTF_ID &&
-		   !type_may_be_null(reg->type)) {
-		err = check_ptr_to_btf_access(env, regs, regno, off, size, t,
-					      value_regno);
-	} else if (reg->type == CONST_PTR_TO_MAP) {
+		break;
+	case CONST_PTR_TO_MAP:
 		err = check_ptr_to_map_access(env, regs, regno, off, size, t,
 					      value_regno);
-	} else if (base_type(reg->type) == PTR_TO_BUF) {
+		break;
+	case PTR_TO_BUF:
+	{
 		bool rdonly_mem = type_is_rdonly_mem(reg->type);
 		u32 *max_access;
 
@@ -5521,7 +5539,17 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 
 		if (!err && value_regno >= 0 && (rdonly_mem || t == BPF_READ))
 			mark_reg_unknown(env, regs, value_regno);
-	} else {
+		break;
+	}
+	case PTR_TO_BTF_ID:
+		if (!type_may_be_null(reg->type)) {
+			err = check_ptr_to_btf_access(env, regs, regno, off, size, t,
+						      value_regno);
+			break;
+		} else {
+			fallthrough;
+		}
+	default:
 		verbose(env, "R%d invalid mem access '%s'\n", regno,
 			reg_type_str(env, reg->type));
 		return -EACCES;
@@ -8377,10 +8405,7 @@ static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insn
 		return err;
 
 	/* reset caller saved regs */
-	for (i = 0; i < CALLER_SAVED_REGS; i++) {
-		mark_reg_not_init(env, regs, caller_saved[i]);
-		check_reg_arg(env, caller_saved[i], DST_OP_NO_MARK);
-	}
+	clear_caller_saved_regs(env, regs);
 
 	/* helper call returns 64-bit value. */
 	regs[BPF_REG_0].subreg_def = DEF_NOT_SUBREG;
Signature · 1 line
2.30.2
#1 lore raw
Quoted 25 lines · Joanne Koong

This change refactors check_mem_access() to check against the base type of the register, and uses switch case checking instead of if / else if checks. This change also uses the existing clear_called_saved_regs() function for resetting caller saved regs in check_helper_call().

---
 kernel/bpf/verifier.c | 67 +++++++++++++++++++++++++++++--------------
 1 file changed, 46 insertions(+), 21 deletions(-)
kernel/bpf/verifier.c +2 -1
index 272563a0b770..b40165be2943 100644
@@ -5317,7 +5317,8 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 	/* for access checks, reg->off is just part of off */
 	off += reg->off;
 
-	if (reg->type == PTR_TO_MAP_KEY) {
+	switch (base_type(reg->type)) {
+	case PTR_TO_MAP_KEY:
 		if (t == BPF_WRITE) {
 			verbose(env, "write to change key R%d not allowed\n", regno);
 			return -EACCES;

kernel/bpf/verifier.c static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn · line 5336

Quoted 8 lines
kernel/bpf/verifier.c +4 -1
@@ -5329,7 +5330,10 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 			return err;
 		if (value_regno >= 0)
 			mark_reg_unknown(env, regs, value_regno);
-	} else if (reg->type == PTR_TO_MAP_VALUE) {
+
+		break;
+	case PTR_TO_MAP_VALUE:
+	{

I'm getting failure in this test:
#92/1 jeq_infer_not_null/jeq_infer_not_null_ptr_to_btfid:FAIL

I wonder with this change we execute this case even if there's PTR_MAYBE_NULL set, which we did not do before, so the test won't fail now as expected

Quoted 10 lines
kernel/bpf/verifier.c +2 -1
 		struct btf_field *kptr_field = NULL;
 
 		if (t == BPF_WRITE && value_regno >= 0 &&
@@ -5369,7 +5373,10 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 				mark_reg_unknown(env, regs, value_regno);
 			}
 		}
-	} else if (base_type(reg->type) == PTR_TO_MEM) {
+		break;
+	}

SNIP

Quoted 5 lines
kernel/bpf/verifier.c +0 -1
@@ -5521,7 +5539,17 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 
 		if (!err && value_regno >= 0 && (rdonly_mem || t == BPF_READ))
 			mark_reg_unknown(env, regs, value_regno);
-	} else {

kernel/bpf/verifier.c static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn · line 5551

Quoted 10 lines
kernel/bpf/verifier.c +10 -0
+		break;
+	}
+	case PTR_TO_BTF_ID:
+		if (!type_may_be_null(reg->type)) {
+			err = check_ptr_to_btf_access(env, regs, regno, off, size, t,
+						      value_regno);
+			break;
+		} else {
+			fallthrough;
+		}

nit, no need for the else branch, just use fallthrough directly

kernel/bpf/verifier.c static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insn · line 8407

Quoted 8 lines
kernel/bpf/verifier.c +1 -0
+	default:
 		verbose(env, "R%d invalid mem access '%s'\n", regno,
 			reg_type_str(env, reg->type));
 		return -EACCES;
@@ -8377,10 +8405,7 @@ static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insn
 		return err;
 
 	/* reset caller saved regs */

nit, we could remove the comment as well, the function name says it all

jirka

Quoted 11 lines
kernel/bpf/verifier.c +1 -4
-	for (i = 0; i < CALLER_SAVED_REGS; i++) {
-		mark_reg_not_init(env, regs, caller_saved[i]);
-		check_reg_arg(env, caller_saved[i], DST_OP_NO_MARK);
-	}
+	clear_caller_saved_regs(env, regs);
 
 	/* helper call returns 64-bit value. */
 	regs[BPF_REG_0].subreg_def = DEF_NOT_SUBREG;
Signature · 1 line
2.30.2
#2 lore raw
Quoted 39 lines · Jiri Olsa
Quoted 25 lines · Joanne Koong

This change refactors check_mem_access() to check against the base type of the register, and uses switch case checking instead of if / else if checks. This change also uses the existing clear_called_saved_regs() function for resetting caller saved regs in check_helper_call().

---
 kernel/bpf/verifier.c | 67 +++++++++++++++++++++++++++++--------------
 1 file changed, 46 insertions(+), 21 deletions(-)
kernel/bpf/verifier.c +2 -1
index 272563a0b770..b40165be2943 100644
@@ -5317,7 +5317,8 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
      /* for access checks, reg->off is just part of off */
      off += reg->off;
 
-     if (reg->type == PTR_TO_MAP_KEY) {
+     switch (base_type(reg->type)) {
+     case PTR_TO_MAP_KEY:
              if (t == BPF_WRITE) {
                      verbose(env, "write to change key R%d not allowed\n", regno);
                      return -EACCES;

kernel/bpf/verifier.c static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn · line 5336

Quoted 8 lines
kernel/bpf/verifier.c +4 -1
@@ -5329,7 +5330,10 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
                      return err;
              if (value_regno >= 0)
                      mark_reg_unknown(env, regs, value_regno);
-     } else if (reg->type == PTR_TO_MAP_VALUE) {
+
+             break;
+     case PTR_TO_MAP_VALUE:
+     {

I'm getting failure in this test:
#92/1 jeq_infer_not_null/jeq_infer_not_null_ptr_to_btfid:FAIL

Quoted 2 lines

I wonder with this change we execute this case even if there's PTR_MAYBE_NULL set, which we did not do before, so the test won't fail now as expected

Thanks for reviewing this, I will investigate this test failure!

Quoted 56 lines
Quoted 11 lines
kernel/bpf/verifier.c +2 -1
              struct btf_field *kptr_field = NULL;
 
              if (t == BPF_WRITE && value_regno >= 0 &&
@@ -5369,7 +5373,10 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
                              mark_reg_unknown(env, regs, value_regno);
                      }
              }
-     } else if (base_type(reg->type) == PTR_TO_MEM) {
+             break;
+     }

SNIP

Quoted 5 lines
kernel/bpf/verifier.c +0 -1
@@ -5521,7 +5539,17 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 
              if (!err && value_regno >= 0 && (rdonly_mem || t == BPF_READ))
                      mark_reg_unknown(env, regs, value_regno);
-     } else {

kernel/bpf/verifier.c static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn · line 5551

Quoted 10 lines
kernel/bpf/verifier.c +10 -0
+             break;
+     }
+     case PTR_TO_BTF_ID:
+             if (!type_may_be_null(reg->type)) {
+                     err = check_ptr_to_btf_access(env, regs, regno, off, size, t,
+                                                   value_regno);
+                     break;
+             } else {
+                     fallthrough;
+             }

nit, no need for the else branch, just use fallthrough directly

kernel/bpf/verifier.c static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insn · line 8407

Quoted 8 lines
kernel/bpf/verifier.c +1 -0
+     default:
              verbose(env, "R%d invalid mem access '%s'\n", regno,
                      reg_type_str(env, reg->type));
              return -EACCES;
@@ -8377,10 +8405,7 @@ static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insn
              return err;
 
      /* reset caller saved regs */

nit, we could remove the comment as well, the function name says it all

jirka

Quoted 11 lines
kernel/bpf/verifier.c +1 -5
-     for (i = 0; i < CALLER_SAVED_REGS; i++) {
-             mark_reg_not_init(env, regs, caller_saved[i]);
-             check_reg_arg(env, caller_saved[i], DST_OP_NO_MARK);
-     }
+     clear_caller_saved_regs(env, regs);
 
      /* helper call returns 64-bit value. */
      regs[BPF_REG_0].subreg_def = DEF_NOT_SUBREG;
--

2.30.2

#3 lore raw
Quoted 41 lines · Joanne Koong
Quoted 39 lines · Jiri Olsa
Quoted 25 lines · Joanne Koong

This change refactors check_mem_access() to check against the base type of the register, and uses switch case checking instead of if / else if checks. This change also uses the existing clear_called_saved_regs() function for resetting caller saved regs in check_helper_call().

---
 kernel/bpf/verifier.c | 67 +++++++++++++++++++++++++++++--------------
 1 file changed, 46 insertions(+), 21 deletions(-)
kernel/bpf/verifier.c +2 -1
index 272563a0b770..b40165be2943 100644
@@ -5317,7 +5317,8 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
      /* for access checks, reg->off is just part of off */
      off += reg->off;
 
-     if (reg->type == PTR_TO_MAP_KEY) {
+     switch (base_type(reg->type)) {
+     case PTR_TO_MAP_KEY:
              if (t == BPF_WRITE) {
                      verbose(env, "write to change key R%d not allowed\n", regno);
                      return -EACCES;

kernel/bpf/verifier.c static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn · line 5336

Quoted 8 lines
kernel/bpf/verifier.c +4 -1
@@ -5329,7 +5330,10 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
                      return err;
              if (value_regno >= 0)
                      mark_reg_unknown(env, regs, value_regno);
-     } else if (reg->type == PTR_TO_MAP_VALUE) {
+
+             break;
+     case PTR_TO_MAP_VALUE:
+     {

I'm getting failure in this test:
#92/1 jeq_infer_not_null/jeq_infer_not_null_ptr_to_btfid:FAIL

Quoted 4 lines
Quoted 2 lines

I wonder with this change we execute this case even if there's PTR_MAYBE_NULL set, which we did not do before, so the test won't fail now as expected

Thanks for reviewing this, I will investigate this test failure!

I'm going to abandon this patch, on a closer look I don't think it's accurate. For most of these matches, it needs to be a strict match (eg reg->type should be exactly PTR_TO_MAP_KEY) and any type modifiers should fail (eg PTR_MAYBE_NULL)

Quoted 57 lines
Quoted 57 lines
Quoted 12 lines
kernel/bpf/verifier.c +2 -1
              struct btf_field *kptr_field = NULL;
 
              if (t == BPF_WRITE && value_regno >= 0 &&
@@ -5369,7 +5373,10 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
                              mark_reg_unknown(env, regs, value_regno);
                      }
              }
-     } else if (base_type(reg->type) == PTR_TO_MEM) {
+             break;
+     }

SNIP

Quoted 5 lines
kernel/bpf/verifier.c +0 -1
@@ -5521,7 +5539,17 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
 
              if (!err && value_regno >= 0 && (rdonly_mem || t == BPF_READ))
                      mark_reg_unknown(env, regs, value_regno);
-     } else {

kernel/bpf/verifier.c static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn · line 5551

Quoted 10 lines
kernel/bpf/verifier.c +10 -0
+             break;
+     }
+     case PTR_TO_BTF_ID:
+             if (!type_may_be_null(reg->type)) {
+                     err = check_ptr_to_btf_access(env, regs, regno, off, size, t,
+                                                   value_regno);
+                     break;
+             } else {
+                     fallthrough;
+             }

nit, no need for the else branch, just use fallthrough directly

kernel/bpf/verifier.c static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insn · line 8407

Quoted 8 lines
kernel/bpf/verifier.c +1 -0
+     default:
              verbose(env, "R%d invalid mem access '%s'\n", regno,
                      reg_type_str(env, reg->type));
              return -EACCES;
@@ -8377,10 +8405,7 @@ static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insn
              return err;
 
      /* reset caller saved regs */

nit, we could remove the comment as well, the function name says it all

jirka

Quoted 11 lines
kernel/bpf/verifier.c +1 -5
-     for (i = 0; i < CALLER_SAVED_REGS; i++) {
-             mark_reg_not_init(env, regs, caller_saved[i]);
-             check_reg_arg(env, caller_saved[i], DST_OP_NO_MARK);
-     }
+     clear_caller_saved_regs(env, regs);
 
      /* helper call returns 64-bit value. */
      regs[BPF_REG_0].subreg_def = DEF_NOT_SUBREG;
--

2.30.2