update kernel to 5.10.198

hc

2024-01-03 2f7c68cb55ecb7331f2381deb497c27155f32faf

 kernel/tools/testing/selftests/bpf/verifier/bounds_mix_sign_unsign.c
..
..
@@ -1,13 +1,14 @@
1
1
 {
2
2
 	"bounds checks mixing signed and unsigned, positive bounds",
3
3
 	.insns = {
4
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
5
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
4
6
 	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
5
7
 	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
6
8
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
7
9
 	BPF_LD_MAP_FD(BPF_REG_1, 0),
8
10
 	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
9
-	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 7),
10
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
11
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 6),
11
12
 	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
12
13
 	BPF_MOV64_IMM(BPF_REG_2, 2),
13
14
 	BPF_JMP_REG(BPF_JGE, BPF_REG_2, BPF_REG_1, 3),
..
..
@@ -17,20 +18,21 @@
17
18
 	BPF_MOV64_IMM(BPF_REG_0, 0),
18
19
 	BPF_EXIT_INSN(),
19
20
 	},
20
-	.fixup_map_hash_8b = { 3 },
21
+	.fixup_map_hash_8b = { 5 },
21
22
 	.errstr = "unbounded min value",
22
23
 	.result = REJECT,
23
24
 },
24
25
 {
25
26
 	"bounds checks mixing signed and unsigned",
26
27
 	.insns = {
28
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
29
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
27
30
 	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
28
31
 	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
29
32
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
30
33
 	BPF_LD_MAP_FD(BPF_REG_1, 0),
31
34
 	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
32
-	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 7),
33
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
35
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 6),
34
36
 	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
35
37
 	BPF_MOV64_IMM(BPF_REG_2, -1),
36
38
 	BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_2, 3),
..
..
@@ -40,20 +42,21 @@
40
42
 	BPF_MOV64_IMM(BPF_REG_0, 0),
41
43
 	BPF_EXIT_INSN(),
42
44
 	},
43
-	.fixup_map_hash_8b = { 3 },
45
+	.fixup_map_hash_8b = { 5 },
44
46
 	.errstr = "unbounded min value",
45
47
 	.result = REJECT,
46
48
 },
47
49
 {
48
50
 	"bounds checks mixing signed and unsigned, variant 2",
49
51
 	.insns = {
52
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
53
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
50
54
 	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
51
55
 	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
52
56
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
53
57
 	BPF_LD_MAP_FD(BPF_REG_1, 0),
54
58
 	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
55
-	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
56
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
59
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 8),
57
60
 	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
58
61
 	BPF_MOV64_IMM(BPF_REG_2, -1),
59
62
 	BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_2, 5),
..
..
@@ -65,20 +68,21 @@
65
68
 	BPF_MOV64_IMM(BPF_REG_0, 0),
66
69
 	BPF_EXIT_INSN(),
67
70
 	},
68
-	.fixup_map_hash_8b = { 3 },
71
+	.fixup_map_hash_8b = { 5 },
69
72
 	.errstr = "unbounded min value",
70
73
 	.result = REJECT,
71
74
 },
72
75
 {
73
76
 	"bounds checks mixing signed and unsigned, variant 3",
74
77
 	.insns = {
78
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
79
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
75
80
 	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
76
81
 	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
77
82
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
78
83
 	BPF_LD_MAP_FD(BPF_REG_1, 0),
79
84
 	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
80
-	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 8),
81
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
85
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 7),
82
86
 	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
83
87
 	BPF_MOV64_IMM(BPF_REG_2, -1),
84
88
 	BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_2, 4),
..
..
@@ -89,20 +93,21 @@
89
93
 	BPF_MOV64_IMM(BPF_REG_0, 0),
90
94
 	BPF_EXIT_INSN(),
91
95
 	},
92
-	.fixup_map_hash_8b = { 3 },
96
+	.fixup_map_hash_8b = { 5 },
93
97
 	.errstr = "unbounded min value",
94
98
 	.result = REJECT,
95
99
 },
96
100
 {
97
101
 	"bounds checks mixing signed and unsigned, variant 4",
98
102
 	.insns = {
103
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
104
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
99
105
 	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
100
106
 	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
101
107
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
102
108
 	BPF_LD_MAP_FD(BPF_REG_1, 0),
103
109
 	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
104
-	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 7),
105
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
110
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 6),
106
111
 	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
107
112
 	BPF_MOV64_IMM(BPF_REG_2, 1),
108
113
 	BPF_ALU64_REG(BPF_AND, BPF_REG_1, BPF_REG_2),
..
..
@@ -112,19 +117,20 @@
112
117
 	BPF_MOV64_IMM(BPF_REG_0, 0),
113
118
 	BPF_EXIT_INSN(),
114
119
 	},
115
-	.fixup_map_hash_8b = { 3 },
120
+	.fixup_map_hash_8b = { 5 },
116
121
 	.result = ACCEPT,
117
122
 },
118
123
 {
119
124
 	"bounds checks mixing signed and unsigned, variant 5",
120
125
 	.insns = {
126
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
127
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
121
128
 	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
122
129
 	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
123
130
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
124
131
 	BPF_LD_MAP_FD(BPF_REG_1, 0),
125
132
 	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
126
-	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
127
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
133
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 8),
128
134
 	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
129
135
 	BPF_MOV64_IMM(BPF_REG_2, -1),
130
136
 	BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_2, 5),
..
..
@@ -135,17 +141,20 @@
135
141
 	BPF_MOV64_IMM(BPF_REG_0, 0),
136
142
 	BPF_EXIT_INSN(),
137
143
 	},
138
-	.fixup_map_hash_8b = { 3 },
144
+	.fixup_map_hash_8b = { 5 },
139
145
 	.errstr = "unbounded min value",
140
146
 	.result = REJECT,
141
147
 },
142
148
 {
143
149
 	"bounds checks mixing signed and unsigned, variant 6",
144
150
 	.insns = {
151
+	BPF_MOV64_REG(BPF_REG_9, BPF_REG_1),
152
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
153
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
154
+	BPF_MOV64_REG(BPF_REG_1, BPF_REG_9),
145
155
 	BPF_MOV64_IMM(BPF_REG_2, 0),
146
156
 	BPF_MOV64_REG(BPF_REG_3, BPF_REG_10),
147
157
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_3, -512),
148
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
149
158
 	BPF_LDX_MEM(BPF_DW, BPF_REG_4, BPF_REG_10, -16),
150
159
 	BPF_MOV64_IMM(BPF_REG_6, -1),
151
160
 	BPF_JMP_REG(BPF_JGT, BPF_REG_4, BPF_REG_6, 5),
..
..
@@ -163,13 +172,14 @@
163
172
 {
164
173
 	"bounds checks mixing signed and unsigned, variant 7",
165
174
 	.insns = {
175
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
176
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
166
177
 	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
167
178
 	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
168
179
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
169
180
 	BPF_LD_MAP_FD(BPF_REG_1, 0),
170
181
 	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
171
-	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 7),
172
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
182
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 6),
173
183
 	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
174
184
 	BPF_MOV64_IMM(BPF_REG_2, 1024 * 1024 * 1024),
175
185
 	BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_2, 3),
..
..
@@ -179,19 +189,20 @@
179
189
 	BPF_MOV64_IMM(BPF_REG_0, 0),
180
190
 	BPF_EXIT_INSN(),
181
191
 	},
182
-	.fixup_map_hash_8b = { 3 },
192
+	.fixup_map_hash_8b = { 5 },
183
193
 	.result = ACCEPT,
184
194
 },
185
195
 {
186
196
 	"bounds checks mixing signed and unsigned, variant 8",
187
197
 	.insns = {
198
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
199
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
188
200
 	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
189
201
 	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
190
202
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
191
203
 	BPF_LD_MAP_FD(BPF_REG_1, 0),
192
204
 	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
193
-	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
194
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
205
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 8),
195
206
 	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
196
207
 	BPF_MOV64_IMM(BPF_REG_2, -1),
197
208
 	BPF_JMP_REG(BPF_JGT, BPF_REG_2, BPF_REG_1, 2),
..
..
@@ -203,20 +214,21 @@
203
214
 	BPF_MOV64_IMM(BPF_REG_0, 0),
204
215
 	BPF_EXIT_INSN(),
205
216
 	},
206
-	.fixup_map_hash_8b = { 3 },
217
+	.fixup_map_hash_8b = { 5 },
207
218
 	.errstr = "unbounded min value",
208
219
 	.result = REJECT,
209
220
 },
210
221
 {
211
222
 	"bounds checks mixing signed and unsigned, variant 9",
212
223
 	.insns = {
224
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
225
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
213
226
 	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
214
227
 	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
215
228
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
216
229
 	BPF_LD_MAP_FD(BPF_REG_1, 0),
217
230
 	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
218
-	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 10),
219
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
231
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
220
232
 	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
221
233
 	BPF_LD_IMM64(BPF_REG_2, -9223372036854775808ULL),
222
234
 	BPF_JMP_REG(BPF_JGT, BPF_REG_2, BPF_REG_1, 2),
..
..
@@ -228,19 +240,20 @@
228
240
 	BPF_MOV64_IMM(BPF_REG_0, 0),
229
241
 	BPF_EXIT_INSN(),
230
242
 	},
231
-	.fixup_map_hash_8b = { 3 },
243
+	.fixup_map_hash_8b = { 5 },
232
244
 	.result = ACCEPT,
233
245
 },
234
246
 {
235
247
 	"bounds checks mixing signed and unsigned, variant 10",
236
248
 	.insns = {
249
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
250
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
237
251
 	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
238
252
 	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
239
253
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
240
254
 	BPF_LD_MAP_FD(BPF_REG_1, 0),
241
255
 	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
242
-	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
243
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
256
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 8),
244
257
 	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
245
258
 	BPF_MOV64_IMM(BPF_REG_2, 0),
246
259
 	BPF_JMP_REG(BPF_JGT, BPF_REG_2, BPF_REG_1, 2),
..
..
@@ -252,20 +265,21 @@
252
265
 	BPF_MOV64_IMM(BPF_REG_0, 0),
253
266
 	BPF_EXIT_INSN(),
254
267
 	},
255
-	.fixup_map_hash_8b = { 3 },
268
+	.fixup_map_hash_8b = { 5 },
256
269
 	.errstr = "unbounded min value",
257
270
 	.result = REJECT,
258
271
 },
259
272
 {
260
273
 	"bounds checks mixing signed and unsigned, variant 11",
261
274
 	.insns = {
275
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
276
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
262
277
 	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
263
278
 	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
264
279
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
265
280
 	BPF_LD_MAP_FD(BPF_REG_1, 0),
266
281
 	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
267
-	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
268
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
282
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 8),
269
283
 	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
270
284
 	BPF_MOV64_IMM(BPF_REG_2, -1),
271
285
 	BPF_JMP_REG(BPF_JGE, BPF_REG_2, BPF_REG_1, 2),
..
..
@@ -278,20 +292,21 @@
278
292
 	BPF_MOV64_IMM(BPF_REG_0, 0),
279
293
 	BPF_EXIT_INSN(),
280
294
 	},
281
-	.fixup_map_hash_8b = { 3 },
295
+	.fixup_map_hash_8b = { 5 },
282
296
 	.errstr = "unbounded min value",
283
297
 	.result = REJECT,
284
298
 },
285
299
 {
286
300
 	"bounds checks mixing signed and unsigned, variant 12",
287
301
 	.insns = {
302
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
303
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
288
304
 	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
289
305
 	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
290
306
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
291
307
 	BPF_LD_MAP_FD(BPF_REG_1, 0),
292
308
 	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
293
-	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
294
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
309
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 8),
295
310
 	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
296
311
 	BPF_MOV64_IMM(BPF_REG_2, -6),
297
312
 	BPF_JMP_REG(BPF_JGE, BPF_REG_2, BPF_REG_1, 2),
..
..
@@ -303,20 +318,21 @@
303
318
 	BPF_MOV64_IMM(BPF_REG_0, 0),
304
319
 	BPF_EXIT_INSN(),
305
320
 	},
306
-	.fixup_map_hash_8b = { 3 },
321
+	.fixup_map_hash_8b = { 5 },
307
322
 	.errstr = "unbounded min value",
308
323
 	.result = REJECT,
309
324
 },
310
325
 {
311
326
 	"bounds checks mixing signed and unsigned, variant 13",
312
327
 	.insns = {
328
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
329
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
313
330
 	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
314
331
 	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
315
332
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
316
333
 	BPF_LD_MAP_FD(BPF_REG_1, 0),
317
334
 	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
318
-	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 6),
319
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
335
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 5),
320
336
 	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
321
337
 	BPF_MOV64_IMM(BPF_REG_2, 2),
322
338
 	BPF_JMP_REG(BPF_JGE, BPF_REG_2, BPF_REG_1, 2),
..
..
@@ -331,7 +347,7 @@
331
347
 	BPF_MOV64_IMM(BPF_REG_0, 0),
332
348
 	BPF_EXIT_INSN(),
333
349
 	},
334
-	.fixup_map_hash_8b = { 3 },
350
+	.fixup_map_hash_8b = { 5 },
335
351
 	.errstr = "unbounded min value",
336
352
 	.result = REJECT,
337
353
 },
..
..
@@ -340,13 +356,14 @@
340
356
 	.insns = {
341
357
 	BPF_LDX_MEM(BPF_W, BPF_REG_9, BPF_REG_1,
342
358
 		    offsetof(struct __sk_buff, mark)),
359
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
360
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
343
361
 	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
344
362
 	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
345
363
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
346
364
 	BPF_LD_MAP_FD(BPF_REG_1, 0),
347
365
 	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
348
-	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 8),
349
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
366
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 7),
350
367
 	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
351
368
 	BPF_MOV64_IMM(BPF_REG_2, -1),
352
369
 	BPF_MOV64_IMM(BPF_REG_8, 2),
..
..
@@ -360,20 +377,21 @@
360
377
 	BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_2, -3),
361
378
 	BPF_JMP_IMM(BPF_JA, 0, 0, -7),
362
379
 	},
363
-	.fixup_map_hash_8b = { 4 },
380
+	.fixup_map_hash_8b = { 6 },
364
381
 	.errstr = "unbounded min value",
365
382
 	.result = REJECT,
366
383
 },
367
384
 {
368
385
 	"bounds checks mixing signed and unsigned, variant 15",
369
386
 	.insns = {
387
+	BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
388
+	BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -16),
370
389
 	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
371
390
 	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
372
391
 	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
373
392
 	BPF_LD_MAP_FD(BPF_REG_1, 0),
374
393
 	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
375
-	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 4),
376
-	BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
394
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3),
377
395
 	BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
378
396
 	BPF_MOV64_IMM(BPF_REG_2, -6),
379
397
 	BPF_JMP_REG(BPF_JGE, BPF_REG_2, BPF_REG_1, 2),
..
..
@@ -387,7 +405,7 @@
387
405
 	BPF_MOV64_IMM(BPF_REG_0, 0),
388
406
 	BPF_EXIT_INSN(),
389
407
 	},
390
-	.fixup_map_hash_8b = { 3 },
408
+	.fixup_map_hash_8b = { 5 },
391
409
 	.errstr = "unbounded min value",
392
410
 	.result = REJECT,
393
411
 },