• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* Copyright 2016 The ChromiumOS Authors
2  * Use of this source code is governed by a BSD-style license that can be
3  * found in the LICENSE file.
4  */
5 
6 #ifndef SYSCALL_FILTER_UNITTEST_MACROS_H
7 #define SYSCALL_FILTER_UNITTEST_MACROS_H
8 
9 #include "bpf.h"
10 
11 /* BPF testing macros. */
12 #define EXPECT_EQ_BLOCK(_block, _code, _k, _jt, _jf)                           \
13 	do {                                                                   \
14 		EXPECT_EQ((_block)->code, _code);                              \
15 		EXPECT_EQ((_block)->k, (unsigned int)(_k));                    \
16 		EXPECT_EQ((_block)->jt, _jt);                                  \
17 		EXPECT_EQ((_block)->jf, _jf);                                  \
18 	} while (0)
19 
20 #define EXPECT_EQ_STMT(_block, _code, _k)                                      \
21 	EXPECT_EQ_BLOCK(_block, _code, _k, 0, 0)
22 
23 #define EXPECT_COMP(_block)                                                    \
24 	do {                                                                   \
25 		EXPECT_EQ((_block)->len, BPF_ARG_COMP_LEN + 1);                \
26 		EXPECT_EQ((_block)->instrs->code, BPF_LD + BPF_W + BPF_ABS);   \
27 	} while (0)
28 
29 #define EXPECT_GT_GE_COMP(_block)                                              \
30 	do {                                                                   \
31 		EXPECT_EQ((_block)->len, BPF_ARG_GT_GE_COMP_LEN + 1);          \
32 		EXPECT_EQ((_block)->instrs->code, BPF_LD + BPF_W + BPF_ABS);   \
33 	} while (0)
34 
35 #define EXPECT_SHORT_GT_GE_COMP(_block)                                        \
36 	do {                                                                   \
37 		EXPECT_EQ((_block)->len, BPF_ARG_SHORT_GT_GE_COMP_LEN + 1);    \
38 		EXPECT_EQ((_block)->instrs->code, BPF_LD + BPF_W + BPF_ABS);   \
39 	} while (0)
40 
41 #define EXPECT_LBL(_block)                                                     \
42 	do {                                                                   \
43 		EXPECT_TRUE((_block)->code == (BPF_JMP + BPF_JA));             \
44 		EXPECT_TRUE((_block)->jt == LABEL_JT);                         \
45 		EXPECT_TRUE((_block)->jf == LABEL_JF);                         \
46 	} while (0)
47 
48 #define EXPECT_ACTUAL_LBL(_block, _id)                                         \
49 	do {                                                                   \
50 		EXPECT_TRUE((_block)->code == (BPF_JMP + BPF_JA));             \
51 		EXPECT_TRUE((_block)->k == (_id));                             \
52 		EXPECT_TRUE((_block)->jt == LABEL_JT);                         \
53 		EXPECT_TRUE((_block)->jf == LABEL_JF);                         \
54 	} while (0)
55 
56 #define EXPECT_JUMP_LBL(_block)                                                \
57 	do {                                                                   \
58 		EXPECT_EQ((_block)->code, BPF_JMP + BPF_JA);                   \
59 		EXPECT_EQ((_block)->jt, JUMP_JT);                              \
60 		EXPECT_EQ((_block)->jf, JUMP_JF);                              \
61 	} while (0)
62 
63 #define EXPECT_GROUP_END(_block)                                               \
64 	do {                                                                   \
65 		EXPECT_EQ((_block)->len, 2U);                                  \
66 		EXPECT_JUMP_LBL(&(_block)->instrs[0]);                         \
67 		EXPECT_LBL(&(_block)->instrs[1]);                              \
68 	} while (0)
69 
70 #define EXPECT_KILL(_block)                                                    \
71 	do {                                                                   \
72 		EXPECT_EQ((_block)->len, 1U);                                  \
73 		EXPECT_EQ_STMT((_block)->instrs, BPF_RET + BPF_K,              \
74 			       SECCOMP_RET_KILL);                              \
75 	} while (0)
76 
77 #define EXPECT_TRAP(_block)                                                    \
78 	do {                                                                   \
79 		EXPECT_EQ((_block)->len, 1U);                                  \
80 		EXPECT_EQ_STMT((_block)->instrs, BPF_RET + BPF_K,              \
81 			       SECCOMP_RET_TRAP);                              \
82 	} while (0)
83 
84 #define EXPECT_LOG(_block)                                                     \
85 	do {                                                                   \
86 		EXPECT_EQ((_block)->len, 1U);                                  \
87 		EXPECT_EQ_STMT((_block)->instrs, BPF_RET + BPF_K,              \
88 			       SECCOMP_RET_LOG);                               \
89 	} while (0)
90 
91 #define EXPECT_ALLOW(_block)                                                   \
92 	do {                                                                   \
93 		EXPECT_EQ((_block)->len, 2U);                                  \
94 		EXPECT_LBL(&(_block)->instrs[0]);                              \
95 		EXPECT_EQ_STMT(&(_block)->instrs[1], BPF_RET + BPF_K,          \
96 			       SECCOMP_RET_ALLOW);                             \
97 	} while (0)
98 
99 #define EXPECT_ARCH_VALIDATION(_filter)                                        \
100 	do {                                                                   \
101 		EXPECT_EQ_STMT(&(_filter)[0], BPF_LD + BPF_W + BPF_ABS,        \
102 			       arch_nr);                                       \
103 		EXPECT_EQ_BLOCK(&(_filter)[1], BPF_JMP + BPF_JEQ + BPF_K,      \
104 				MINIJAIL_ARCH_NR, SKIP, NEXT);                 \
105 		EXPECT_EQ_STMT(&(_filter)[2], BPF_RET + BPF_K,                 \
106 			       SECCOMP_RET_KILL);                              \
107 	} while (0)
108 
109 #define EXPECT_ALLOW_SYSCALL(_filter, _nr)                                     \
110 	do {                                                                   \
111 		EXPECT_EQ_BLOCK(&(_filter)[0], BPF_JMP + BPF_JEQ + BPF_K,      \
112 				(_nr), NEXT, SKIP);                            \
113 		EXPECT_EQ_STMT(&(_filter)[1], BPF_RET + BPF_K,                 \
114 			       SECCOMP_RET_ALLOW);                             \
115 	} while (0)
116 
117 #define EXPECT_ALLOW_SYSCALL_ARGS(_filter, _nr, _id, _jt, _jf)                 \
118 	do {                                                                   \
119 		EXPECT_EQ_BLOCK(&(_filter)[0], BPF_JMP + BPF_JEQ + BPF_K,      \
120 				(_nr), NEXT, SKIP);                            \
121 		EXPECT_EQ_BLOCK(&(_filter)[1], BPF_JMP + BPF_JA, (_id), (_jt), \
122 				(_jf));                                        \
123 	} while (0)
124 
125 #endif // SYSCALL_FILTER_UNITTEST_MACROS_H
126