jmp32.c

  1{
  2	"jset32: BPF_K",
  3	.insns = {
  4	BPF_DIRECT_PKT_R2,
  5	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
  6	/* reg, high bits shouldn't be tested */
  7	BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, -2, 1),
  8	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
  9	BPF_EXIT_INSN(),
 10
 11	BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, 1, 1),
 12	BPF_EXIT_INSN(),
 13	BPF_MOV64_IMM(BPF_REG_0, 2),
 14	BPF_EXIT_INSN(),
 15	},
 16	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
 17	.result = ACCEPT,
 18	.runs = 3,
 19	.retvals = {
 20		{ .retval = 0,
 21		  .data64 = { 1ULL << 63, }
 22		},
 23		{ .retval = 2,
 24		  .data64 = { 1, }
 25		},
 26		{ .retval = 2,
 27		  .data64 = { 1ULL << 63 | 1, }
 28		},
 29	},
 30	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 31},
 32{
 33	"jset32: BPF_X",
 34	.insns = {
 35	BPF_DIRECT_PKT_R2,
 36	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 37	BPF_LD_IMM64(BPF_REG_8, 0x8000000000000000),
 38	BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
 39	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
 40	BPF_EXIT_INSN(),
 41
 42	BPF_LD_IMM64(BPF_REG_8, 0x8000000000000001),
 43	BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
 44	BPF_EXIT_INSN(),
 45	BPF_MOV64_IMM(BPF_REG_0, 2),
 46	BPF_EXIT_INSN(),
 47	},
 48	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
 49	.result = ACCEPT,
 50	.runs = 3,
 51	.retvals = {
 52		{ .retval = 0,
 53		  .data64 = { 1ULL << 63, }
 54		},
 55		{ .retval = 2,
 56		  .data64 = { 1, }
 57		},
 58		{ .retval = 2,
 59		  .data64 = { 1ULL << 63 | 1, }
 60		},
 61	},
 62	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 63},
 64{
 65	"jset32: ignores upper bits",
 66	.insns = {
 67	BPF_MOV64_IMM(BPF_REG_0, 0),
 68	BPF_LD_IMM64(BPF_REG_7, 0x8000000000000000),
 69	BPF_LD_IMM64(BPF_REG_8, 0x8000000000000000),
 70	BPF_JMP_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
 71	BPF_EXIT_INSN(),
 72	BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
 73	BPF_MOV64_IMM(BPF_REG_0, 2),
 74	BPF_EXIT_INSN(),
 75	},
 76	.result = ACCEPT,
 77	.retval = 2,
 78},
 79{
 80	"jset32: min/max deduction",
 81	.insns = {
 82	BPF_RAND_UEXT_R7,
 83	BPF_MOV64_IMM(BPF_REG_0, 0),
 84	BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, 0x10, 1),
 85	BPF_EXIT_INSN(),
 86	BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, 0x10, 1),
 87	/* unpriv: nospec (inserted to prevent "R9 !read_ok") */
 88	BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
 89	BPF_EXIT_INSN(),
 90	},
 91	.result = ACCEPT,
 92},
 93{
 94	"jeq32: BPF_K",
 95	.insns = {
 96	BPF_DIRECT_PKT_R2,
 97	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 98	BPF_JMP32_IMM(BPF_JEQ, BPF_REG_7, -1, 1),
 99	BPF_EXIT_INSN(),
100	BPF_MOV64_IMM(BPF_REG_0, 2),
101	BPF_EXIT_INSN(),
102	},
103	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
104	.result = ACCEPT,
105	.runs = 2,
106	.retvals = {
107		{ .retval = 0,
108		  .data64 = { -2, }
109		},
110		{ .retval = 2,
111		  .data64 = { -1, }
112		},
113	},
114	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
115},
116{
117	"jeq32: BPF_X",
118	.insns = {
119	BPF_DIRECT_PKT_R2,
120	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
121	BPF_LD_IMM64(BPF_REG_8, 0x7000000000000001),
122	BPF_JMP32_REG(BPF_JEQ, BPF_REG_7, BPF_REG_8, 1),
123	BPF_EXIT_INSN(),
124	BPF_MOV64_IMM(BPF_REG_0, 2),
125	BPF_EXIT_INSN(),
126	},
127	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
128	.result = ACCEPT,
129	.runs = 3,
130	.retvals = {
131		{ .retval = 0,
132		  .data64 = { 2, }
133		},
134		{ .retval = 2,
135		  .data64 = { 1, }
136		},
137		{ .retval = 2,
138		  .data64 = { 1ULL << 63 | 1, }
139		},
140	},
141	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
142},
143{
144	"jeq32: min/max deduction",
145	.insns = {
146	BPF_RAND_UEXT_R7,
147	BPF_MOV64_IMM(BPF_REG_0, 0),
148	BPF_JMP32_IMM(BPF_JEQ, BPF_REG_7, 0x10, 1),
149	BPF_EXIT_INSN(),
150	BPF_JMP32_IMM(BPF_JSGE, BPF_REG_7, 0xf, 1),
151	/* unpriv: nospec (inserted to prevent "R9 !read_ok") */
152	BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
153	BPF_EXIT_INSN(),
154	},
155	.result = ACCEPT,
156},
157{
158	"jne32: BPF_K",
159	.insns = {
160	BPF_DIRECT_PKT_R2,
161	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
162	BPF_JMP32_IMM(BPF_JNE, BPF_REG_7, -1, 1),
163	BPF_EXIT_INSN(),
164	BPF_MOV64_IMM(BPF_REG_0, 2),
165	BPF_EXIT_INSN(),
166	},
167	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
168	.result = ACCEPT,
169	.runs = 2,
170	.retvals = {
171		{ .retval = 2,
172		  .data64 = { 1, }
173		},
174		{ .retval = 0,
175		  .data64 = { -1, }
176		},
177	},
178	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
179},
180{
181	"jne32: BPF_X",
182	.insns = {
183	BPF_DIRECT_PKT_R2,
184	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
185	BPF_LD_IMM64(BPF_REG_8, 0x8000000000000001),
186	BPF_JMP32_REG(BPF_JNE, BPF_REG_7, BPF_REG_8, 1),
187	BPF_EXIT_INSN(),
188	BPF_MOV64_IMM(BPF_REG_0, 2),
189	BPF_EXIT_INSN(),
190	},
191	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
192	.result = ACCEPT,
193	.runs = 3,
194	.retvals = {
195		{ .retval = 0,
196		  .data64 = { 1, }
197		},
198		{ .retval = 2,
199		  .data64 = { 2, }
200		},
201		{ .retval = 2,
202		  .data64 = { 1ULL << 63 | 2, }
203		},
204	},
205	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
206},
207{
208	"jne32: min/max deduction",
209	.insns = {
210	BPF_RAND_UEXT_R7,
211	BPF_MOV64_IMM(BPF_REG_0, 0),
212	BPF_JMP32_IMM(BPF_JNE, BPF_REG_7, 0x10, 1),
213	BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 0x10, 1),
214	BPF_EXIT_INSN(),
215	/* unpriv: nospec (inserted to prevent "R9 !read_ok") */
216	BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
217	BPF_EXIT_INSN(),
218	},
219	.result = ACCEPT,
220},
221{
222	"jge32: BPF_K",
223	.insns = {
224	BPF_DIRECT_PKT_R2,
225	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
226	BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, UINT_MAX - 1, 1),
227	BPF_EXIT_INSN(),
228	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
229	BPF_EXIT_INSN(),
230	},
231	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
232	.result = ACCEPT,
233	.runs = 3,
234	.retvals = {
235		{ .retval = 2,
236		  .data64 = { UINT_MAX, }
237		},
238		{ .retval = 2,
239		  .data64 = { UINT_MAX - 1, }
240		},
241		{ .retval = 0,
242		  .data64 = { 0, }
243		},
244	},
245	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
246},
247{
248	"jge32: BPF_X",
249	.insns = {
250	BPF_DIRECT_PKT_R2,
251	BPF_LD_IMM64(BPF_REG_8, UINT_MAX | 1ULL << 32),
252	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
253	BPF_JMP32_REG(BPF_JGE, BPF_REG_7, BPF_REG_8, 1),
254	BPF_EXIT_INSN(),
255	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
256	BPF_EXIT_INSN(),
257	},
258	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
259	.result = ACCEPT,
260	.runs = 3,
261	.retvals = {
262		{ .retval = 2,
263		  .data64 = { UINT_MAX, }
264		},
265		{ .retval = 0,
266		  .data64 = { INT_MAX, }
267		},
268		{ .retval = 0,
269		  .data64 = { (UINT_MAX - 1) | 2ULL << 32, }
270		},
271	},
272	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
273},
274{
275	"jge32: min/max deduction",
276	.insns = {
277	BPF_RAND_UEXT_R7,
278	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
279	BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
280	BPF_JMP32_REG(BPF_JGE, BPF_REG_7, BPF_REG_8, 1),
281	BPF_EXIT_INSN(),
282	BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, 0x7ffffff0, 1),
283	/* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
284	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
285	BPF_EXIT_INSN(),
286	},
287	.result = ACCEPT,
288	.retval = 2,
289	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
290},
291{
292	"jgt32: BPF_K",
293	.insns = {
294	BPF_DIRECT_PKT_R2,
295	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
296	BPF_JMP32_IMM(BPF_JGT, BPF_REG_7, UINT_MAX - 1, 1),
297	BPF_EXIT_INSN(),
298	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
299	BPF_EXIT_INSN(),
300	},
301	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
302	.result = ACCEPT,
303	.runs = 3,
304	.retvals = {
305		{ .retval = 2,
306		  .data64 = { UINT_MAX, }
307		},
308		{ .retval = 0,
309		  .data64 = { UINT_MAX - 1, }
310		},
311		{ .retval = 0,
312		  .data64 = { 0, }
313		},
314	},
315	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
316},
317{
318	"jgt32: BPF_X",
319	.insns = {
320	BPF_DIRECT_PKT_R2,
321	BPF_LD_IMM64(BPF_REG_8, (UINT_MAX - 1) | 1ULL << 32),
322	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
323	BPF_JMP32_REG(BPF_JGT, BPF_REG_7, BPF_REG_8, 1),
324	BPF_EXIT_INSN(),
325	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
326	BPF_EXIT_INSN(),
327	},
328	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
329	.result = ACCEPT,
330	.runs = 3,
331	.retvals = {
332		{ .retval = 2,
333		  .data64 = { UINT_MAX, }
334		},
335		{ .retval = 0,
336		  .data64 = { UINT_MAX - 1, }
337		},
338		{ .retval = 0,
339		  .data64 = { (UINT_MAX - 1) | 2ULL << 32, }
340		},
341	},
342	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
343},
344{
345	"jgt32: min/max deduction",
346	.insns = {
347	BPF_RAND_UEXT_R7,
348	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
349	BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
350	BPF_JMP32_REG(BPF_JGT, BPF_REG_7, BPF_REG_8, 1),
351	BPF_EXIT_INSN(),
352	BPF_JMP_IMM(BPF_JGT, BPF_REG_7, 0x7ffffff0, 1),
353	/* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
354	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
355	BPF_EXIT_INSN(),
356	},
357	.result = ACCEPT,
358	.retval = 2,
359	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
360},
361{
362	"jle32: BPF_K",
363	.insns = {
364	BPF_DIRECT_PKT_R2,
365	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
366	BPF_JMP32_IMM(BPF_JLE, BPF_REG_7, INT_MAX, 1),
367	BPF_EXIT_INSN(),
368	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
369	BPF_EXIT_INSN(),
370	},
371	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
372	.result = ACCEPT,
373	.runs = 3,
374	.retvals = {
375		{ .retval = 2,
376		  .data64 = { INT_MAX - 1, }
377		},
378		{ .retval = 0,
379		  .data64 = { UINT_MAX, }
380		},
381		{ .retval = 2,
382		  .data64 = { INT_MAX, }
383		},
384	},
385	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
386},
387{
388	"jle32: BPF_X",
389	.insns = {
390	BPF_DIRECT_PKT_R2,
391	BPF_LD_IMM64(BPF_REG_8, (INT_MAX - 1) | 2ULL << 32),
392	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
393	BPF_JMP32_REG(BPF_JLE, BPF_REG_7, BPF_REG_8, 1),
394	BPF_EXIT_INSN(),
395	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
396	BPF_EXIT_INSN(),
397	},
398	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
399	.result = ACCEPT,
400	.runs = 3,
401	.retvals = {
402		{ .retval = 0,
403		  .data64 = { INT_MAX | 1ULL << 32, }
404		},
405		{ .retval = 2,
406		  .data64 = { INT_MAX - 2, }
407		},
408		{ .retval = 0,
409		  .data64 = { UINT_MAX, }
410		},
411	},
412	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
413},
414{
415	"jle32: min/max deduction",
416	.insns = {
417	BPF_RAND_UEXT_R7,
418	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
419	BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
420	BPF_JMP32_REG(BPF_JLE, BPF_REG_7, BPF_REG_8, 1),
421	BPF_EXIT_INSN(),
422	BPF_JMP32_IMM(BPF_JLE, BPF_REG_7, 0x7ffffff0, 1),
423	/* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
424	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
425	BPF_EXIT_INSN(),
426	},
427	.result = ACCEPT,
428	.retval = 2,
429	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
430},
431{
432	"jlt32: BPF_K",
433	.insns = {
434	BPF_DIRECT_PKT_R2,
435	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
436	BPF_JMP32_IMM(BPF_JLT, BPF_REG_7, INT_MAX, 1),
437	BPF_EXIT_INSN(),
438	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
439	BPF_EXIT_INSN(),
440	},
441	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
442	.result = ACCEPT,
443	.runs = 3,
444	.retvals = {
445		{ .retval = 0,
446		  .data64 = { INT_MAX, }
447		},
448		{ .retval = 0,
449		  .data64 = { UINT_MAX, }
450		},
451		{ .retval = 2,
452		  .data64 = { INT_MAX - 1, }
453		},
454	},
455	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
456},
457{
458	"jlt32: BPF_X",
459	.insns = {
460	BPF_DIRECT_PKT_R2,
461	BPF_LD_IMM64(BPF_REG_8, INT_MAX | 2ULL << 32),
462	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
463	BPF_JMP32_REG(BPF_JLT, BPF_REG_7, BPF_REG_8, 1),
464	BPF_EXIT_INSN(),
465	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
466	BPF_EXIT_INSN(),
467	},
468	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
469	.result = ACCEPT,
470	.runs = 3,
471	.retvals = {
472		{ .retval = 0,
473		  .data64 = { INT_MAX | 1ULL << 32, }
474		},
475		{ .retval = 0,
476		  .data64 = { UINT_MAX, }
477		},
478		{ .retval = 2,
479		  .data64 = { (INT_MAX - 1) | 3ULL << 32, }
480		},
481	},
482	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
483},
484{
485	"jlt32: min/max deduction",
486	.insns = {
487	BPF_RAND_UEXT_R7,
488	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
489	BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
490	BPF_JMP32_REG(BPF_JLT, BPF_REG_7, BPF_REG_8, 1),
491	BPF_EXIT_INSN(),
492	BPF_JMP_IMM(BPF_JSLT, BPF_REG_7, 0x7ffffff0, 1),
493	/* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
494	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
495	BPF_EXIT_INSN(),
496	},
497	.result = ACCEPT,
498	.retval = 2,
499	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
500},
501{
502	"jsge32: BPF_K",
503	.insns = {
504	BPF_DIRECT_PKT_R2,
505	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
506	BPF_JMP32_IMM(BPF_JSGE, BPF_REG_7, -1, 1),
507	BPF_EXIT_INSN(),
508	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
509	BPF_EXIT_INSN(),
510	},
511	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
512	.result = ACCEPT,
513	.runs = 3,
514	.retvals = {
515		{ .retval = 2,
516		  .data64 = { 0, }
517		},
518		{ .retval = 2,
519		  .data64 = { -1, }
520		},
521		{ .retval = 0,
522		  .data64 = { -2, }
523		},
524	},
525	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
526},
527{
528	"jsge32: BPF_X",
529	.insns = {
530	BPF_DIRECT_PKT_R2,
531	BPF_LD_IMM64(BPF_REG_8, (__u32)-1 | 2ULL << 32),
532	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
533	BPF_JMP32_REG(BPF_JSGE, BPF_REG_7, BPF_REG_8, 1),
534	BPF_EXIT_INSN(),
535	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
536	BPF_EXIT_INSN(),
537	},
538	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
539	.result = ACCEPT,
540	.runs = 3,
541	.retvals = {
542		{ .retval = 2,
543		  .data64 = { -1, }
544		},
545		{ .retval = 2,
546		  .data64 = { 0x7fffffff | 1ULL << 32, }
547		},
548		{ .retval = 0,
549		  .data64 = { -2, }
550		},
551	},
552	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
553},
554{
555	"jsge32: min/max deduction",
556	.insns = {
557	BPF_RAND_UEXT_R7,
558	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
559	BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
560	BPF_JMP32_REG(BPF_JSGE, BPF_REG_7, BPF_REG_8, 1),
561	BPF_EXIT_INSN(),
562	BPF_JMP_IMM(BPF_JSGE, BPF_REG_7, 0x7ffffff0, 1),
563	/* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
564	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
565	BPF_EXIT_INSN(),
566	},
567	.result = ACCEPT,
568	.retval = 2,
569	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
570},
571{
572	"jsgt32: BPF_K",
573	.insns = {
574	BPF_DIRECT_PKT_R2,
575	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
576	BPF_JMP32_IMM(BPF_JSGT, BPF_REG_7, -1, 1),
577	BPF_EXIT_INSN(),
578	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
579	BPF_EXIT_INSN(),
580	},
581	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
582	.result = ACCEPT,
583	.runs = 3,
584	.retvals = {
585		{ .retval = 0,
586		  .data64 = { (__u32)-2, }
587		},
588		{ .retval = 0,
589		  .data64 = { -1, }
590		},
591		{ .retval = 2,
592		  .data64 = { 1, }
593		},
594	},
595	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
596},
597{
598	"jsgt32: BPF_X",
599	.insns = {
600	BPF_DIRECT_PKT_R2,
601	BPF_LD_IMM64(BPF_REG_8, 0x7ffffffe | 1ULL << 32),
602	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
603	BPF_JMP32_REG(BPF_JSGT, BPF_REG_7, BPF_REG_8, 1),
604	BPF_EXIT_INSN(),
605	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
606	BPF_EXIT_INSN(),
607	},
608	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
609	.result = ACCEPT,
610	.runs = 3,
611	.retvals = {
612		{ .retval = 0,
613		  .data64 = { 0x7ffffffe, }
614		},
615		{ .retval = 0,
616		  .data64 = { 0x1ffffffffULL, }
617		},
618		{ .retval = 2,
619		  .data64 = { 0x7fffffff, }
620		},
621	},
622	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
623},
624{
625	"jsgt32: min/max deduction",
626	.insns = {
627	BPF_RAND_SEXT_R7,
628	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
629	BPF_LD_IMM64(BPF_REG_8, (__u32)(-2) | 1ULL << 32),
630	BPF_JMP32_REG(BPF_JSGT, BPF_REG_7, BPF_REG_8, 1),
631	BPF_EXIT_INSN(),
632	BPF_JMP_IMM(BPF_JSGT, BPF_REG_7, -2, 1),
633	/* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
634	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
635	BPF_EXIT_INSN(),
636	},
637	.result = ACCEPT,
638	.retval = 2,
639	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
640},
641{
642	"jsle32: BPF_K",
643	.insns = {
644	BPF_DIRECT_PKT_R2,
645	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
646	BPF_JMP32_IMM(BPF_JSLE, BPF_REG_7, -1, 1),
647	BPF_EXIT_INSN(),
648	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
649	BPF_EXIT_INSN(),
650	},
651	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
652	.result = ACCEPT,
653	.runs = 3,
654	.retvals = {
655		{ .retval = 2,
656		  .data64 = { (__u32)-2, }
657		},
658		{ .retval = 2,
659		  .data64 = { -1, }
660		},
661		{ .retval = 0,
662		  .data64 = { 1, }
663		},
664	},
665	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
666},
667{
668	"jsle32: BPF_X",
669	.insns = {
670	BPF_DIRECT_PKT_R2,
671	BPF_LD_IMM64(BPF_REG_8, 0x7ffffffe | 1ULL << 32),
672	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
673	BPF_JMP32_REG(BPF_JSLE, BPF_REG_7, BPF_REG_8, 1),
674	BPF_EXIT_INSN(),
675	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
676	BPF_EXIT_INSN(),
677	},
678	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
679	.result = ACCEPT,
680	.runs = 3,
681	.retvals = {
682		{ .retval = 2,
683		  .data64 = { 0x7ffffffe, }
684		},
685		{ .retval = 2,
686		  .data64 = { (__u32)-1, }
687		},
688		{ .retval = 0,
689		  .data64 = { 0x7fffffff | 2ULL << 32, }
690		},
691	},
692	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
693},
694{
695	"jsle32: min/max deduction",
696	.insns = {
697	BPF_RAND_UEXT_R7,
698	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
699	BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
700	BPF_JMP32_REG(BPF_JSLE, BPF_REG_7, BPF_REG_8, 1),
701	BPF_EXIT_INSN(),
702	BPF_JMP_IMM(BPF_JSLE, BPF_REG_7, 0x7ffffff0, 1),
703	/* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
704	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
705	BPF_EXIT_INSN(),
706	},
707	.result = ACCEPT,
708	.retval = 2,
709	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
710},
711{
712	"jslt32: BPF_K",
713	.insns = {
714	BPF_DIRECT_PKT_R2,
715	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
716	BPF_JMP32_IMM(BPF_JSLT, BPF_REG_7, -1, 1),
717	BPF_EXIT_INSN(),
718	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
719	BPF_EXIT_INSN(),
720	},
721	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
722	.result = ACCEPT,
723	.runs = 3,
724	.retvals = {
725		{ .retval = 2,
726		  .data64 = { (__u32)-2, }
727		},
728		{ .retval = 0,
729		  .data64 = { -1, }
730		},
731		{ .retval = 0,
732		  .data64 = { 1, }
733		},
734	},
735	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
736},
737{
738	"jslt32: BPF_X",
739	.insns = {
740	BPF_DIRECT_PKT_R2,
741	BPF_LD_IMM64(BPF_REG_8, 0x7fffffff | 1ULL << 32),
742	BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
743	BPF_JMP32_REG(BPF_JSLT, BPF_REG_7, BPF_REG_8, 1),
744	BPF_EXIT_INSN(),
745	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
746	BPF_EXIT_INSN(),
747	},
748	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
749	.result = ACCEPT,
750	.runs = 3,
751	.retvals = {
752		{ .retval = 2,
753		  .data64 = { 0x7ffffffe, }
754		},
755		{ .retval = 2,
756		  .data64 = { 0xffffffff, }
757		},
758		{ .retval = 0,
759		  .data64 = { 0x7fffffff | 2ULL << 32, }
760		},
761	},
762	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
763},
764{
765	"jslt32: min/max deduction",
766	.insns = {
767	BPF_RAND_SEXT_R7,
768	BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
769	BPF_LD_IMM64(BPF_REG_8, (__u32)(-1) | 1ULL << 32),
770	BPF_JMP32_REG(BPF_JSLT, BPF_REG_7, BPF_REG_8, 1),
771	BPF_EXIT_INSN(),
772	BPF_JMP32_IMM(BPF_JSLT, BPF_REG_7, -1, 1),
773	/* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
774	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
775	BPF_EXIT_INSN(),
776	},
777	.result = ACCEPT,
778	.retval = 2,
779	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
780},
781{
782	"jgt32: range bound deduction, reg op imm",
783	.insns = {
784	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
785	BPF_MOV64_REG(BPF_REG_8, BPF_REG_1),
786	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
787	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
788	BPF_LD_MAP_FD(BPF_REG_1, 0),
789	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
790	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
791	BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
792	BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
793	BPF_EMIT_CALL(BPF_FUNC_get_cgroup_classid),
794	BPF_JMP32_IMM(BPF_JGT, BPF_REG_0, 1, 5),
795	BPF_MOV32_REG(BPF_REG_6, BPF_REG_0),
796	BPF_ALU64_IMM(BPF_LSH, BPF_REG_6, 32),
797	BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 32),
798	BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_6),
799	BPF_ST_MEM(BPF_B, BPF_REG_8, 0, 0),
800	BPF_MOV32_IMM(BPF_REG_0, 0),
801	BPF_EXIT_INSN(),
802	},
803	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
804	.fixup_map_hash_48b = { 4 },
805	.result = ACCEPT,
806	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
807},
808{
809	"jgt32: range bound deduction, reg1 op reg2, reg1 unknown",
810	.insns = {
811	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
812	BPF_MOV64_REG(BPF_REG_8, BPF_REG_1),
813	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
814	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
815	BPF_LD_MAP_FD(BPF_REG_1, 0),
816	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
817	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 10),
818	BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
819	BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
820	BPF_EMIT_CALL(BPF_FUNC_get_cgroup_classid),
821	BPF_MOV32_IMM(BPF_REG_2, 1),
822	BPF_JMP32_REG(BPF_JGT, BPF_REG_0, BPF_REG_2, 5),
823	BPF_MOV32_REG(BPF_REG_6, BPF_REG_0),
824	BPF_ALU64_IMM(BPF_LSH, BPF_REG_6, 32),
825	BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 32),
826	BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_6),
827	BPF_ST_MEM(BPF_B, BPF_REG_8, 0, 0),
828	BPF_MOV32_IMM(BPF_REG_0, 0),
829	BPF_EXIT_INSN(),
830	},
831	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
832	.fixup_map_hash_48b = { 4 },
833	.result = ACCEPT,
834	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
835},
836{
837	"jle32: range bound deduction, reg1 op reg2, reg2 unknown",
838	.insns = {
839	BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
840	BPF_MOV64_REG(BPF_REG_8, BPF_REG_1),
841	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
842	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
843	BPF_LD_MAP_FD(BPF_REG_1, 0),
844	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
845	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 10),
846	BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
847	BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
848	BPF_EMIT_CALL(BPF_FUNC_get_cgroup_classid),
849	BPF_MOV32_IMM(BPF_REG_2, 1),
850	BPF_JMP32_REG(BPF_JLE, BPF_REG_2, BPF_REG_0, 5),
851	BPF_MOV32_REG(BPF_REG_6, BPF_REG_0),
852	BPF_ALU64_IMM(BPF_LSH, BPF_REG_6, 32),
853	BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 32),
854	BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_6),
855	BPF_ST_MEM(BPF_B, BPF_REG_8, 0, 0),
856	BPF_MOV32_IMM(BPF_REG_0, 0),
857	BPF_EXIT_INSN(),
858	},
859	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
860	.fixup_map_hash_48b = { 4 },
861	.result = ACCEPT,
862	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
863},
864{
865	"jeq32/jne32: bounds checking",
866	.insns = {
867	BPF_MOV64_IMM(BPF_REG_6, 563),
868	BPF_MOV64_IMM(BPF_REG_2, 0),
869	BPF_ALU64_IMM(BPF_NEG, BPF_REG_2, 0),
870	BPF_ALU64_IMM(BPF_NEG, BPF_REG_2, 0),
871	BPF_ALU32_REG(BPF_OR, BPF_REG_2, BPF_REG_6),
872	BPF_JMP32_IMM(BPF_JNE, BPF_REG_2, 8, 5),
873	BPF_JMP_IMM(BPF_JSGE, BPF_REG_2, 500, 2),
874	BPF_MOV64_IMM(BPF_REG_0, 2),
875	BPF_EXIT_INSN(),
876	BPF_MOV64_REG(BPF_REG_0, BPF_REG_4),
877	BPF_EXIT_INSN(),
878	BPF_MOV64_IMM(BPF_REG_0, 1),
879	BPF_EXIT_INSN(),
880	},
881	.prog_type = BPF_PROG_TYPE_SCHED_CLS,
882	.result = ACCEPT,
883	.retval = 1,
884},