bpf: Add BPF_F_ANY_ALIGNMENT.

Often we want to write tests cases that check things like bad context offset accesses. And one way to do this is to use an odd offset on, for example, a 32-bit load. This unfortunately triggers the alignment checks first on platforms that do not set CONFIG_EFFICIENT_UNALIGNED_ACCESS. So the test case see the alignment failure rather than what it was testing for. It is often not completely possible to respect the original intention of the test, or even test the same exact thing, while solving the alignment issue. Another option could have been to check the alignment after the context and other validations are performed by the verifier, but that is a non-trivial change to the verifier.

David Miller committed 7 years ago

Commit e9ee9ef1 parent 88945f48 files · +45 −9Browse files

Unified · Split

8 files

include/uapi/linux/bpf.h +14 −0
kernel/bpf/syscall.c +6 −1
kernel/bpf/verifier.c +2 −0
tools/include/uapi/linux/bpf.h +14 −0
tools/lib/bpf/bpf.c +4 −4
tools/lib/bpf/bpf.h +1 −1
tools/testing/selftests/bpf/test_align.c +2 −2
tools/testing/selftests/bpf/test_verifier.c +2 −1

include/uapi/linux/bpf.h+14−0

@@ -232,6 +232,20 @@ enum bpf_attach_type { · 231 unmodified lines
232	*/	232	*/
233	#define BPF_F_STRICT_ALIGNMENT (1U << 0)	233	#define BPF_F_STRICT_ALIGNMENT (1U << 0)
234		234
		235	/* If BPF_F_ANY_ALIGNMENT is used in BPF_PROF_LOAD command, the
		236	* verifier will allow any alignment whatsoever. On platforms
		237	* with strict alignment requirements for loads ands stores (such
		238	* as sparc and mips) the verifier validates that all loads and
		239	* stores provably follow this requirement. This flag turns that
		240	* checking and enforcement off.
		241	*
		242	* It is mostly used for testing when we want to validate the
		243	* context and memory access aspects of the verifier, but because
		244	* of an unaligned access the alignment check would trigger before
		245	* the one we are interested in.
		246	*/
		247	#define BPF_F_ANY_ALIGNMENT (1U << 1)
		248
235	/* when bpf_ldimm64->src_reg == BPF_PSEUDO_MAP_FD, bpf_ldimm64->imm == fd */	249	/* when bpf_ldimm64->src_reg == BPF_PSEUDO_MAP_FD, bpf_ldimm64->imm == fd */
236	#define BPF_PSEUDO_MAP_FD 1	250	#define BPF_PSEUDO_MAP_FD 1
237		251

kernel/bpf/syscall.c+6−1

 	if (CHECK_ATTR(BPF_PROG_LOAD))
 		return -EINVAL;
-	if (attr->prog_flags & ~BPF_F_STRICT_ALIGNMENT)
+	if (attr->prog_flags & ~(BPF_F_STRICT_ALIGNMENT | BPF_F_ANY_ALIGNMENT))
 		return -EINVAL;
+	if (!IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) &&
+	    (attr->prog_flags & BPF_F_ANY_ALIGNMENT) &&
+	    !capable(CAP_SYS_ADMIN))
+		return -EPERM;
 	/* copy eBPF program license from user space */
 	if (strncpy_from_user(license, u64_to_user_ptr(attr->license),
 			      sizeof(license) - 1) < 0)

kernel/bpf/verifier.c+2−0

@@ -6505,6 +6505,8 @@ int bpf_check(struct bpf_prog *prog, union bpf_attr attr, · 6504 unmodified lines
6505	env->strict_alignment = !!(attr->prog_flags & BPF_F_STRICT_ALIGNMENT);	6505	env->strict_alignment = !!(attr->prog_flags & BPF_F_STRICT_ALIGNMENT);
6506	if (!IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS))	6506	if (!IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS))
6507	env->strict_alignment = true;	6507	env->strict_alignment = true;
		6508	if (attr->prog_flags & BPF_F_ANY_ALIGNMENT)
		6509	env->strict_alignment = false;
6508		6510
6509	ret = replace_map_fd_with_map_ptr(env);	6511	ret = replace_map_fd_with_map_ptr(env);
6510	if (ret < 0)	6512	if (ret < 0)

tools/include/uapi/linux/bpf.h+14−0

@@ -232,6 +232,20 @@ enum bpf_attach_type { · 231 unmodified lines
232	*/	232	*/
233	#define BPF_F_STRICT_ALIGNMENT (1U << 0)	233	#define BPF_F_STRICT_ALIGNMENT (1U << 0)
234		234
		235	/* If BPF_F_ANY_ALIGNMENT is used in BPF_PROF_LOAD command, the
		236	* verifier will allow any alignment whatsoever. On platforms
		237	* with strict alignment requirements for loads ands stores (such
		238	* as sparc and mips) the verifier validates that all loads and
		239	* stores provably follow this requirement. This flag turns that
		240	* checking and enforcement off.
		241	*
		242	* It is mostly used for testing when we want to validate the
		243	* context and memory access aspects of the verifier, but because
		244	* of an unaligned access the alignment check would trigger before
		245	* the one we are interested in.
		246	*/
		247	#define BPF_F_ANY_ALIGNMENT (1U << 1)
		248
235	/* when bpf_ldimm64->src_reg == BPF_PSEUDO_MAP_FD, bpf_ldimm64->imm == fd */	249	/* when bpf_ldimm64->src_reg == BPF_PSEUDO_MAP_FD, bpf_ldimm64->imm == fd */
236	#define BPF_PSEUDO_MAP_FD 1	250	#define BPF_PSEUDO_MAP_FD 1
237		251

tools/lib/bpf/bpf.c+4−4

@@ -279,9 +279,9 @@ int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns, · 278 unmodified lines
279	}	279	}
280		280
281	int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns,	281	int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns,
282	size_t insns_cnt, int strict_alignment,	282	size_t insns_cnt, __u32 prog_flags, const char *license,
283	const char *license, __u32 kern_version,	283	__u32 kern_version, char *log_buf, size_t log_buf_sz,
284	char *log_buf, size_t log_buf_sz, int log_level)	284	int log_level)
285	{	285	{
286	union bpf_attr attr;	286	union bpf_attr attr;
287		287
@@ -295,7 +295,7 @@ int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns, · 7 unmodified lines
295	attr.log_level = log_level;	295	attr.log_level = log_level;
296	log_buf[0] = 0;	296	log_buf[0] = 0;
297	attr.kern_version = kern_version;	297	attr.kern_version = kern_version;
298	attr.prog_flags = strict_alignment ? BPF_F_STRICT_ALIGNMENT : 0;	298	attr.prog_flags = prog_flags;
299		299
300	return sys_bpf(BPF_PROG_LOAD, &attr, sizeof(attr));	300	return sys_bpf(BPF_PROG_LOAD, &attr, sizeof(attr));
301	}	301	}

tools/lib/bpf/bpf.h+1−1

@@ -98,7 +98,7 @@ LIBBPF_API int bpf_load_program(enum bpf_prog_type type, · 97 unmodified lines
98	char *log_buf, size_t log_buf_sz);	98	char *log_buf, size_t log_buf_sz);
99	LIBBPF_API int bpf_verify_program(enum bpf_prog_type type,	99	LIBBPF_API int bpf_verify_program(enum bpf_prog_type type,
100	const struct bpf_insn *insns,	100	const struct bpf_insn *insns,
101	size_t insns_cnt, int strict_alignment,	101	size_t insns_cnt, __u32 prog_flags,
102	const char *license, __u32 kern_version,	102	const char *license, __u32 kern_version,
103	char *log_buf, size_t log_buf_sz,	103	char *log_buf, size_t log_buf_sz,
104	int log_level);	104	int log_level);

tools/testing/selftests/bpf/test_align.c+2−2

@@ -620,8 +620,8 @@ static int do_test_single(struct bpf_align_test *test) · 619 unmodified lines
620		620
621	prog_len = probe_filter_length(prog);	621	prog_len = probe_filter_length(prog);
622	fd_prog = bpf_verify_program(prog_type ? : BPF_PROG_TYPE_SOCKET_FILTER,	622	fd_prog = bpf_verify_program(prog_type ? : BPF_PROG_TYPE_SOCKET_FILTER,
623	prog, prog_len, 1, "GPL", 0,	623	prog, prog_len, BPF_F_STRICT_ALIGNMENT,
624	bpf_vlog, sizeof(bpf_vlog), 2);	624	"GPL", 0, bpf_vlog, sizeof(bpf_vlog), 2);
625	if (fd_prog < 0 && test->result != REJECT) {	625	if (fd_prog < 0 && test->result != REJECT) {
626	printf("Failed to load program.\n");	626	printf("Failed to load program.\n");
627	printf("%s", bpf_vlog);	627	printf("%s", bpf_vlog);

tools/testing/selftests/bpf/test_verifier.c+2−1

@@ -14275,7 +14275,8 @@ static void do_test_single(struct bpf_test *test, bool unpriv, · 14274 unmodified lines
14275	prog_len = probe_filter_length(prog);	14275	prog_len = probe_filter_length(prog);
14276		14276
14277	fd_prog = bpf_verify_program(prog_type, prog, prog_len,	14277	fd_prog = bpf_verify_program(prog_type, prog, prog_len,
14278	test->flags & F_LOAD_WITH_STRICT_ALIGNMENT,	14278	test->flags & F_LOAD_WITH_STRICT_ALIGNMENT ?
		14279	BPF_F_STRICT_ALIGNMENT : 0,
14279	"GPL", 0, bpf_vlog, sizeof(bpf_vlog), 1);	14280	"GPL", 0, bpf_vlog, sizeof(bpf_vlog), 1);
14280		14281
14281	expected_ret = unpriv && test->result_unpriv != UNDEF ?	14282	expected_ret = unpriv && test->result_unpriv != UNDEF ?