1 /* 2 * Testsuite for BPF interpreter and BPF JIT compiler 3 * 4 * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of version 2 of the GNU General Public 8 * License as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License for more details. 14 */ 15 16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 17 18 #include <linux/init.h> 19 #include <linux/module.h> 20 #include <linux/filter.h> 21 #include <linux/skbuff.h> 22 #include <linux/netdevice.h> 23 #include <linux/if_vlan.h> 24 25 /* General test specific settings */ 26 #define MAX_SUBTESTS 3 27 #define MAX_TESTRUNS 10000 28 #define MAX_DATA 128 29 #define MAX_INSNS 512 30 #define MAX_K 0xffffFFFF 31 32 /* Few constants used to init test 'skb' */ 33 #define SKB_TYPE 3 34 #define SKB_MARK 0x1234aaaa 35 #define SKB_HASH 0x1234aaab 36 #define SKB_QUEUE_MAP 123 37 #define SKB_VLAN_TCI 0xffff 38 #define SKB_DEV_IFINDEX 577 39 #define SKB_DEV_TYPE 588 40 41 /* Redefine REGs to make tests less verbose */ 42 #define R0 BPF_REG_0 43 #define R1 BPF_REG_1 44 #define R2 BPF_REG_2 45 #define R3 BPF_REG_3 46 #define R4 BPF_REG_4 47 #define R5 BPF_REG_5 48 #define R6 BPF_REG_6 49 #define R7 BPF_REG_7 50 #define R8 BPF_REG_8 51 #define R9 BPF_REG_9 52 #define R10 BPF_REG_10 53 54 /* Flags that can be passed to test cases */ 55 #define FLAG_NO_DATA BIT(0) 56 #define FLAG_EXPECTED_FAIL BIT(1) 57 58 enum { 59 CLASSIC = BIT(6), /* Old BPF instructions only. */ 60 INTERNAL = BIT(7), /* Extended instruction set. */ 61 }; 62 63 #define TEST_TYPE_MASK (CLASSIC | INTERNAL) 64 65 struct bpf_test { 66 const char *descr; 67 union { 68 struct sock_filter insns[MAX_INSNS]; 69 struct sock_filter_int insns_int[MAX_INSNS]; 70 } u; 71 __u8 aux; 72 __u8 data[MAX_DATA]; 73 struct { 74 int data_size; 75 __u32 result; 76 } test[MAX_SUBTESTS]; 77 }; 78 79 static struct bpf_test tests[] = { 80 { 81 "TAX", 82 .u.insns = { 83 BPF_STMT(BPF_LD | BPF_IMM, 1), 84 BPF_STMT(BPF_MISC | BPF_TAX, 0), 85 BPF_STMT(BPF_LD | BPF_IMM, 2), 86 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 87 BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */ 88 BPF_STMT(BPF_MISC | BPF_TAX, 0), 89 BPF_STMT(BPF_LD | BPF_LEN, 0), 90 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 91 BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */ 92 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1), 93 BPF_STMT(BPF_RET | BPF_A, 0) 94 }, 95 CLASSIC, 96 { 10, 20, 30, 40, 50 }, 97 { { 2, 10 }, { 3, 20 }, { 4, 30 } }, 98 }, 99 { 100 "TXA", 101 .u.insns = { 102 BPF_STMT(BPF_LDX | BPF_LEN, 0), 103 BPF_STMT(BPF_MISC | BPF_TXA, 0), 104 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 105 BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */ 106 }, 107 CLASSIC, 108 { 10, 20, 30, 40, 50 }, 109 { { 1, 2 }, { 3, 6 }, { 4, 8 } }, 110 }, 111 { 112 "ADD_SUB_MUL_K", 113 .u.insns = { 114 BPF_STMT(BPF_LD | BPF_IMM, 1), 115 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2), 116 BPF_STMT(BPF_LDX | BPF_IMM, 3), 117 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 118 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff), 119 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3), 120 BPF_STMT(BPF_RET | BPF_A, 0) 121 }, 122 CLASSIC | FLAG_NO_DATA, 123 { }, 124 { { 0, 0xfffffffd } } 125 }, 126 { 127 "DIV_KX", 128 .u.insns = { 129 BPF_STMT(BPF_LD | BPF_IMM, 8), 130 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2), 131 BPF_STMT(BPF_MISC | BPF_TAX, 0), 132 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 133 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0), 134 BPF_STMT(BPF_MISC | BPF_TAX, 0), 135 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 136 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000), 137 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 138 BPF_STMT(BPF_RET | BPF_A, 0) 139 }, 140 CLASSIC | FLAG_NO_DATA, 141 { }, 142 { { 0, 0x40000001 } } 143 }, 144 { 145 "AND_OR_LSH_K", 146 .u.insns = { 147 BPF_STMT(BPF_LD | BPF_IMM, 0xff), 148 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0), 149 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27), 150 BPF_STMT(BPF_MISC | BPF_TAX, 0), 151 BPF_STMT(BPF_LD | BPF_IMM, 0xf), 152 BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0), 153 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 154 BPF_STMT(BPF_RET | BPF_A, 0) 155 }, 156 CLASSIC | FLAG_NO_DATA, 157 { }, 158 { { 0, 0x800000ff }, { 1, 0x800000ff } }, 159 }, 160 { 161 "LD_IMM_0", 162 .u.insns = { 163 BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */ 164 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0), 165 BPF_STMT(BPF_RET | BPF_K, 0), 166 BPF_STMT(BPF_RET | BPF_K, 1), 167 }, 168 CLASSIC, 169 { }, 170 { { 1, 1 } }, 171 }, 172 { 173 "LD_IND", 174 .u.insns = { 175 BPF_STMT(BPF_LDX | BPF_LEN, 0), 176 BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K), 177 BPF_STMT(BPF_RET | BPF_K, 1) 178 }, 179 CLASSIC, 180 { }, 181 { { 1, 0 }, { 10, 0 }, { 60, 0 } }, 182 }, 183 { 184 "LD_ABS", 185 .u.insns = { 186 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000), 187 BPF_STMT(BPF_RET | BPF_K, 1) 188 }, 189 CLASSIC, 190 { }, 191 { { 1, 0 }, { 10, 0 }, { 60, 0 } }, 192 }, 193 { 194 "LD_ABS_LL", 195 .u.insns = { 196 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF), 197 BPF_STMT(BPF_MISC | BPF_TAX, 0), 198 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1), 199 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 200 BPF_STMT(BPF_RET | BPF_A, 0) 201 }, 202 CLASSIC, 203 { 1, 2, 3 }, 204 { { 1, 0 }, { 2, 3 } }, 205 }, 206 { 207 "LD_IND_LL", 208 .u.insns = { 209 BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1), 210 BPF_STMT(BPF_LDX | BPF_LEN, 0), 211 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 212 BPF_STMT(BPF_MISC | BPF_TAX, 0), 213 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0), 214 BPF_STMT(BPF_RET | BPF_A, 0) 215 }, 216 CLASSIC, 217 { 1, 2, 3, 0xff }, 218 { { 1, 1 }, { 3, 3 }, { 4, 0xff } }, 219 }, 220 { 221 "LD_ABS_NET", 222 .u.insns = { 223 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF), 224 BPF_STMT(BPF_MISC | BPF_TAX, 0), 225 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1), 226 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 227 BPF_STMT(BPF_RET | BPF_A, 0) 228 }, 229 CLASSIC, 230 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 }, 231 { { 15, 0 }, { 16, 3 } }, 232 }, 233 { 234 "LD_IND_NET", 235 .u.insns = { 236 BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15), 237 BPF_STMT(BPF_LDX | BPF_LEN, 0), 238 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 239 BPF_STMT(BPF_MISC | BPF_TAX, 0), 240 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0), 241 BPF_STMT(BPF_RET | BPF_A, 0) 242 }, 243 CLASSIC, 244 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 }, 245 { { 14, 0 }, { 15, 1 }, { 17, 3 } }, 246 }, 247 { 248 "LD_PKTTYPE", 249 .u.insns = { 250 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 251 SKF_AD_OFF + SKF_AD_PKTTYPE), 252 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 253 BPF_STMT(BPF_RET | BPF_K, 1), 254 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 255 SKF_AD_OFF + SKF_AD_PKTTYPE), 256 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 257 BPF_STMT(BPF_RET | BPF_K, 1), 258 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 259 SKF_AD_OFF + SKF_AD_PKTTYPE), 260 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 261 BPF_STMT(BPF_RET | BPF_K, 1), 262 BPF_STMT(BPF_RET | BPF_A, 0) 263 }, 264 CLASSIC, 265 { }, 266 { { 1, 3 }, { 10, 3 } }, 267 }, 268 { 269 "LD_MARK", 270 .u.insns = { 271 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 272 SKF_AD_OFF + SKF_AD_MARK), 273 BPF_STMT(BPF_RET | BPF_A, 0) 274 }, 275 CLASSIC, 276 { }, 277 { { 1, SKB_MARK}, { 10, SKB_MARK} }, 278 }, 279 { 280 "LD_RXHASH", 281 .u.insns = { 282 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 283 SKF_AD_OFF + SKF_AD_RXHASH), 284 BPF_STMT(BPF_RET | BPF_A, 0) 285 }, 286 CLASSIC, 287 { }, 288 { { 1, SKB_HASH}, { 10, SKB_HASH} }, 289 }, 290 { 291 "LD_QUEUE", 292 .u.insns = { 293 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 294 SKF_AD_OFF + SKF_AD_QUEUE), 295 BPF_STMT(BPF_RET | BPF_A, 0) 296 }, 297 CLASSIC, 298 { }, 299 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } }, 300 }, 301 { 302 "LD_PROTOCOL", 303 .u.insns = { 304 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1), 305 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0), 306 BPF_STMT(BPF_RET | BPF_K, 0), 307 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 308 SKF_AD_OFF + SKF_AD_PROTOCOL), 309 BPF_STMT(BPF_MISC | BPF_TAX, 0), 310 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 311 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0), 312 BPF_STMT(BPF_RET | BPF_K, 0), 313 BPF_STMT(BPF_MISC | BPF_TXA, 0), 314 BPF_STMT(BPF_RET | BPF_A, 0) 315 }, 316 CLASSIC, 317 { 10, 20, 30 }, 318 { { 10, ETH_P_IP }, { 100, ETH_P_IP } }, 319 }, 320 { 321 "LD_VLAN_TAG", 322 .u.insns = { 323 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 324 SKF_AD_OFF + SKF_AD_VLAN_TAG), 325 BPF_STMT(BPF_RET | BPF_A, 0) 326 }, 327 CLASSIC, 328 { }, 329 { 330 { 1, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT }, 331 { 10, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT } 332 }, 333 }, 334 { 335 "LD_VLAN_TAG_PRESENT", 336 .u.insns = { 337 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 338 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT), 339 BPF_STMT(BPF_RET | BPF_A, 0) 340 }, 341 CLASSIC, 342 { }, 343 { 344 { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }, 345 { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) } 346 }, 347 }, 348 { 349 "LD_IFINDEX", 350 .u.insns = { 351 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 352 SKF_AD_OFF + SKF_AD_IFINDEX), 353 BPF_STMT(BPF_RET | BPF_A, 0) 354 }, 355 CLASSIC, 356 { }, 357 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } }, 358 }, 359 { 360 "LD_HATYPE", 361 .u.insns = { 362 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 363 SKF_AD_OFF + SKF_AD_HATYPE), 364 BPF_STMT(BPF_RET | BPF_A, 0) 365 }, 366 CLASSIC, 367 { }, 368 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } }, 369 }, 370 { 371 "LD_CPU", 372 .u.insns = { 373 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 374 SKF_AD_OFF + SKF_AD_CPU), 375 BPF_STMT(BPF_MISC | BPF_TAX, 0), 376 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 377 SKF_AD_OFF + SKF_AD_CPU), 378 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 379 BPF_STMT(BPF_RET | BPF_A, 0) 380 }, 381 CLASSIC, 382 { }, 383 { { 1, 0 }, { 10, 0 } }, 384 }, 385 { 386 "LD_NLATTR", 387 .u.insns = { 388 BPF_STMT(BPF_LDX | BPF_IMM, 1), 389 BPF_STMT(BPF_MISC | BPF_TXA, 0), 390 BPF_STMT(BPF_LDX | BPF_IMM, 3), 391 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 392 SKF_AD_OFF + SKF_AD_NLATTR), 393 BPF_STMT(BPF_RET | BPF_A, 0) 394 }, 395 CLASSIC, 396 { 0xff, 4, 0, 2, 0, 4, 0, 3, 0 }, 397 { { 4, 0 }, { 20, 5 } }, 398 }, 399 { 400 "LD_NLATTR_NEST", 401 .u.insns = { 402 BPF_STMT(BPF_LD | BPF_IMM, 1), 403 BPF_STMT(BPF_LDX | BPF_IMM, 3), 404 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 405 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 406 BPF_STMT(BPF_LD | BPF_IMM, 1), 407 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 408 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 409 BPF_STMT(BPF_LD | BPF_IMM, 1), 410 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 411 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 412 BPF_STMT(BPF_LD | BPF_IMM, 1), 413 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 414 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 415 BPF_STMT(BPF_LD | BPF_IMM, 1), 416 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 417 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 418 BPF_STMT(BPF_LD | BPF_IMM, 1), 419 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 420 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 421 BPF_STMT(BPF_LD | BPF_IMM, 1), 422 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 423 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 424 BPF_STMT(BPF_LD | BPF_IMM, 1), 425 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 426 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 427 BPF_STMT(BPF_RET | BPF_A, 0) 428 }, 429 CLASSIC, 430 { 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 }, 431 { { 4, 0 }, { 20, 9 } }, 432 }, 433 { 434 "LD_PAYLOAD_OFF", 435 .u.insns = { 436 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 437 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 438 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 439 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 440 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 441 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 442 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 443 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 444 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 445 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 446 BPF_STMT(BPF_RET | BPF_A, 0) 447 }, 448 CLASSIC, 449 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800), 450 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request, 451 * id 9737, seq 1, length 64 452 */ 453 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 454 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 455 0x08, 0x00, 456 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40, 457 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 }, 458 { { 30, 0 }, { 100, 42 } }, 459 }, 460 { 461 "LD_ANC_XOR", 462 .u.insns = { 463 BPF_STMT(BPF_LD | BPF_IMM, 10), 464 BPF_STMT(BPF_LDX | BPF_IMM, 300), 465 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 466 SKF_AD_OFF + SKF_AD_ALU_XOR_X), 467 BPF_STMT(BPF_RET | BPF_A, 0) 468 }, 469 CLASSIC, 470 { }, 471 { { 4, 10 ^ 300 }, { 20, 10 ^ 300 } }, 472 }, 473 { 474 "SPILL_FILL", 475 .u.insns = { 476 BPF_STMT(BPF_LDX | BPF_LEN, 0), 477 BPF_STMT(BPF_LD | BPF_IMM, 2), 478 BPF_STMT(BPF_ALU | BPF_RSH, 1), 479 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 480 BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */ 481 BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000), 482 BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */ 483 BPF_STMT(BPF_STX, 15), /* M3 = len */ 484 BPF_STMT(BPF_LDX | BPF_MEM, 1), 485 BPF_STMT(BPF_LD | BPF_MEM, 2), 486 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 487 BPF_STMT(BPF_LDX | BPF_MEM, 15), 488 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 489 BPF_STMT(BPF_RET | BPF_A, 0) 490 }, 491 CLASSIC, 492 { }, 493 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } } 494 }, 495 { 496 "JEQ", 497 .u.insns = { 498 BPF_STMT(BPF_LDX | BPF_LEN, 0), 499 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 500 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1), 501 BPF_STMT(BPF_RET | BPF_K, 1), 502 BPF_STMT(BPF_RET | BPF_K, MAX_K) 503 }, 504 CLASSIC, 505 { 3, 3, 3, 3, 3 }, 506 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } }, 507 }, 508 { 509 "JGT", 510 .u.insns = { 511 BPF_STMT(BPF_LDX | BPF_LEN, 0), 512 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 513 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1), 514 BPF_STMT(BPF_RET | BPF_K, 1), 515 BPF_STMT(BPF_RET | BPF_K, MAX_K) 516 }, 517 CLASSIC, 518 { 4, 4, 4, 3, 3 }, 519 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } }, 520 }, 521 { 522 "JGE", 523 .u.insns = { 524 BPF_STMT(BPF_LDX | BPF_LEN, 0), 525 BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K), 526 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0), 527 BPF_STMT(BPF_RET | BPF_K, 10), 528 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0), 529 BPF_STMT(BPF_RET | BPF_K, 20), 530 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0), 531 BPF_STMT(BPF_RET | BPF_K, 30), 532 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0), 533 BPF_STMT(BPF_RET | BPF_K, 40), 534 BPF_STMT(BPF_RET | BPF_K, MAX_K) 535 }, 536 CLASSIC, 537 { 1, 2, 3, 4, 5 }, 538 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } }, 539 }, 540 { 541 "JSET", 542 .u.insns = { 543 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 544 BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1), 545 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 546 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 547 BPF_STMT(BPF_LDX | BPF_LEN, 0), 548 BPF_STMT(BPF_MISC | BPF_TXA, 0), 549 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4), 550 BPF_STMT(BPF_MISC | BPF_TAX, 0), 551 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0), 552 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1), 553 BPF_STMT(BPF_RET | BPF_K, 10), 554 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1), 555 BPF_STMT(BPF_RET | BPF_K, 20), 556 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 557 BPF_STMT(BPF_RET | BPF_K, 30), 558 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 559 BPF_STMT(BPF_RET | BPF_K, 30), 560 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 561 BPF_STMT(BPF_RET | BPF_K, 30), 562 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 563 BPF_STMT(BPF_RET | BPF_K, 30), 564 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 565 BPF_STMT(BPF_RET | BPF_K, 30), 566 BPF_STMT(BPF_RET | BPF_K, MAX_K) 567 }, 568 CLASSIC, 569 { 0, 0xAA, 0x55, 1 }, 570 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } }, 571 }, 572 { 573 "tcpdump port 22", 574 .u.insns = { 575 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12), 576 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */ 577 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20), 578 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0), 579 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0), 580 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17), 581 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54), 582 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0), 583 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56), 584 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13), 585 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */ 586 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23), 587 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0), 588 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0), 589 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8), 590 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20), 591 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0), 592 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14), 593 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14), 594 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0), 595 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16), 596 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1), 597 BPF_STMT(BPF_RET | BPF_K, 0xffff), 598 BPF_STMT(BPF_RET | BPF_K, 0), 599 }, 600 CLASSIC, 601 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800) 602 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.], 603 * seq 1305692979:1305693027, ack 3650467037, win 65535, 604 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48 605 */ 606 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6, 607 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76, 608 0x08, 0x00, 609 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5, 610 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */ 611 0x0a, 0x01, 0x01, 0x95, /* ip src */ 612 0x0a, 0x01, 0x02, 0x0a, /* ip dst */ 613 0xc2, 0x24, 614 0x00, 0x16 /* dst port */ }, 615 { { 10, 0 }, { 30, 0 }, { 100, 65535 } }, 616 }, 617 { 618 "tcpdump complex", 619 .u.insns = { 620 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] - 621 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and 622 * (len > 115 or len < 30000000000)' -d 623 */ 624 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12), 625 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0), 626 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29), 627 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23), 628 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27), 629 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20), 630 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0), 631 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14), 632 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14), 633 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0), 634 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16), 635 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20), 636 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16), 637 BPF_STMT(BPF_ST, 1), 638 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14), 639 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf), 640 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2), 641 BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */ 642 BPF_STMT(BPF_LD | BPF_MEM, 1), 643 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 644 BPF_STMT(BPF_ST, 5), 645 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14), 646 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26), 647 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0), 648 BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2), 649 BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */ 650 BPF_STMT(BPF_LD | BPF_MEM, 5), 651 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0), 652 BPF_STMT(BPF_LD | BPF_LEN, 0), 653 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0), 654 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0), 655 BPF_STMT(BPF_RET | BPF_K, 0xffff), 656 BPF_STMT(BPF_RET | BPF_K, 0), 657 }, 658 CLASSIC, 659 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6, 660 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76, 661 0x08, 0x00, 662 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5, 663 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */ 664 0x0a, 0x01, 0x01, 0x95, /* ip src */ 665 0x0a, 0x01, 0x02, 0x0a, /* ip dst */ 666 0xc2, 0x24, 667 0x00, 0x16 /* dst port */ }, 668 { { 10, 0 }, { 30, 0 }, { 100, 65535 } }, 669 }, 670 { 671 "RET_A", 672 .u.insns = { 673 /* check that unitialized X and A contain zeros */ 674 BPF_STMT(BPF_MISC | BPF_TXA, 0), 675 BPF_STMT(BPF_RET | BPF_A, 0) 676 }, 677 CLASSIC, 678 { }, 679 { {1, 0}, {2, 0} }, 680 }, 681 { 682 "INT: ADD trivial", 683 .u.insns_int = { 684 BPF_ALU64_IMM(BPF_MOV, R1, 1), 685 BPF_ALU64_IMM(BPF_ADD, R1, 2), 686 BPF_ALU64_IMM(BPF_MOV, R2, 3), 687 BPF_ALU64_REG(BPF_SUB, R1, R2), 688 BPF_ALU64_IMM(BPF_ADD, R1, -1), 689 BPF_ALU64_IMM(BPF_MUL, R1, 3), 690 BPF_ALU64_REG(BPF_MOV, R0, R1), 691 BPF_EXIT_INSN(), 692 }, 693 INTERNAL, 694 { }, 695 { { 0, 0xfffffffd } } 696 }, 697 { 698 "INT: MUL_X", 699 .u.insns_int = { 700 BPF_ALU64_IMM(BPF_MOV, R0, -1), 701 BPF_ALU64_IMM(BPF_MOV, R1, -1), 702 BPF_ALU64_IMM(BPF_MOV, R2, 3), 703 BPF_ALU64_REG(BPF_MUL, R1, R2), 704 BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1), 705 BPF_EXIT_INSN(), 706 BPF_ALU64_IMM(BPF_MOV, R0, 1), 707 BPF_EXIT_INSN(), 708 }, 709 INTERNAL, 710 { }, 711 { { 0, 1 } } 712 }, 713 { 714 "INT: MUL_X2", 715 .u.insns_int = { 716 BPF_ALU32_IMM(BPF_MOV, R0, -1), 717 BPF_ALU32_IMM(BPF_MOV, R1, -1), 718 BPF_ALU32_IMM(BPF_MOV, R2, 3), 719 BPF_ALU64_REG(BPF_MUL, R1, R2), 720 BPF_ALU64_IMM(BPF_RSH, R1, 8), 721 BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1), 722 BPF_EXIT_INSN(), 723 BPF_ALU32_IMM(BPF_MOV, R0, 1), 724 BPF_EXIT_INSN(), 725 }, 726 INTERNAL, 727 { }, 728 { { 0, 1 } } 729 }, 730 { 731 "INT: MUL32_X", 732 .u.insns_int = { 733 BPF_ALU32_IMM(BPF_MOV, R0, -1), 734 BPF_ALU64_IMM(BPF_MOV, R1, -1), 735 BPF_ALU32_IMM(BPF_MOV, R2, 3), 736 BPF_ALU32_REG(BPF_MUL, R1, R2), 737 BPF_ALU64_IMM(BPF_RSH, R1, 8), 738 BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1), 739 BPF_EXIT_INSN(), 740 BPF_ALU32_IMM(BPF_MOV, R0, 1), 741 BPF_EXIT_INSN(), 742 }, 743 INTERNAL, 744 { }, 745 { { 0, 1 } } 746 }, 747 { 748 /* Have to test all register combinations, since 749 * JITing of different registers will produce 750 * different asm code. 751 */ 752 "INT: ADD 64-bit", 753 .u.insns_int = { 754 BPF_ALU64_IMM(BPF_MOV, R0, 0), 755 BPF_ALU64_IMM(BPF_MOV, R1, 1), 756 BPF_ALU64_IMM(BPF_MOV, R2, 2), 757 BPF_ALU64_IMM(BPF_MOV, R3, 3), 758 BPF_ALU64_IMM(BPF_MOV, R4, 4), 759 BPF_ALU64_IMM(BPF_MOV, R5, 5), 760 BPF_ALU64_IMM(BPF_MOV, R6, 6), 761 BPF_ALU64_IMM(BPF_MOV, R7, 7), 762 BPF_ALU64_IMM(BPF_MOV, R8, 8), 763 BPF_ALU64_IMM(BPF_MOV, R9, 9), 764 BPF_ALU64_IMM(BPF_ADD, R0, 20), 765 BPF_ALU64_IMM(BPF_ADD, R1, 20), 766 BPF_ALU64_IMM(BPF_ADD, R2, 20), 767 BPF_ALU64_IMM(BPF_ADD, R3, 20), 768 BPF_ALU64_IMM(BPF_ADD, R4, 20), 769 BPF_ALU64_IMM(BPF_ADD, R5, 20), 770 BPF_ALU64_IMM(BPF_ADD, R6, 20), 771 BPF_ALU64_IMM(BPF_ADD, R7, 20), 772 BPF_ALU64_IMM(BPF_ADD, R8, 20), 773 BPF_ALU64_IMM(BPF_ADD, R9, 20), 774 BPF_ALU64_IMM(BPF_SUB, R0, 10), 775 BPF_ALU64_IMM(BPF_SUB, R1, 10), 776 BPF_ALU64_IMM(BPF_SUB, R2, 10), 777 BPF_ALU64_IMM(BPF_SUB, R3, 10), 778 BPF_ALU64_IMM(BPF_SUB, R4, 10), 779 BPF_ALU64_IMM(BPF_SUB, R5, 10), 780 BPF_ALU64_IMM(BPF_SUB, R6, 10), 781 BPF_ALU64_IMM(BPF_SUB, R7, 10), 782 BPF_ALU64_IMM(BPF_SUB, R8, 10), 783 BPF_ALU64_IMM(BPF_SUB, R9, 10), 784 BPF_ALU64_REG(BPF_ADD, R0, R0), 785 BPF_ALU64_REG(BPF_ADD, R0, R1), 786 BPF_ALU64_REG(BPF_ADD, R0, R2), 787 BPF_ALU64_REG(BPF_ADD, R0, R3), 788 BPF_ALU64_REG(BPF_ADD, R0, R4), 789 BPF_ALU64_REG(BPF_ADD, R0, R5), 790 BPF_ALU64_REG(BPF_ADD, R0, R6), 791 BPF_ALU64_REG(BPF_ADD, R0, R7), 792 BPF_ALU64_REG(BPF_ADD, R0, R8), 793 BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */ 794 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1), 795 BPF_EXIT_INSN(), 796 BPF_ALU64_REG(BPF_ADD, R1, R0), 797 BPF_ALU64_REG(BPF_ADD, R1, R1), 798 BPF_ALU64_REG(BPF_ADD, R1, R2), 799 BPF_ALU64_REG(BPF_ADD, R1, R3), 800 BPF_ALU64_REG(BPF_ADD, R1, R4), 801 BPF_ALU64_REG(BPF_ADD, R1, R5), 802 BPF_ALU64_REG(BPF_ADD, R1, R6), 803 BPF_ALU64_REG(BPF_ADD, R1, R7), 804 BPF_ALU64_REG(BPF_ADD, R1, R8), 805 BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */ 806 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1), 807 BPF_EXIT_INSN(), 808 BPF_ALU64_REG(BPF_ADD, R2, R0), 809 BPF_ALU64_REG(BPF_ADD, R2, R1), 810 BPF_ALU64_REG(BPF_ADD, R2, R2), 811 BPF_ALU64_REG(BPF_ADD, R2, R3), 812 BPF_ALU64_REG(BPF_ADD, R2, R4), 813 BPF_ALU64_REG(BPF_ADD, R2, R5), 814 BPF_ALU64_REG(BPF_ADD, R2, R6), 815 BPF_ALU64_REG(BPF_ADD, R2, R7), 816 BPF_ALU64_REG(BPF_ADD, R2, R8), 817 BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */ 818 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1), 819 BPF_EXIT_INSN(), 820 BPF_ALU64_REG(BPF_ADD, R3, R0), 821 BPF_ALU64_REG(BPF_ADD, R3, R1), 822 BPF_ALU64_REG(BPF_ADD, R3, R2), 823 BPF_ALU64_REG(BPF_ADD, R3, R3), 824 BPF_ALU64_REG(BPF_ADD, R3, R4), 825 BPF_ALU64_REG(BPF_ADD, R3, R5), 826 BPF_ALU64_REG(BPF_ADD, R3, R6), 827 BPF_ALU64_REG(BPF_ADD, R3, R7), 828 BPF_ALU64_REG(BPF_ADD, R3, R8), 829 BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */ 830 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1), 831 BPF_EXIT_INSN(), 832 BPF_ALU64_REG(BPF_ADD, R4, R0), 833 BPF_ALU64_REG(BPF_ADD, R4, R1), 834 BPF_ALU64_REG(BPF_ADD, R4, R2), 835 BPF_ALU64_REG(BPF_ADD, R4, R3), 836 BPF_ALU64_REG(BPF_ADD, R4, R4), 837 BPF_ALU64_REG(BPF_ADD, R4, R5), 838 BPF_ALU64_REG(BPF_ADD, R4, R6), 839 BPF_ALU64_REG(BPF_ADD, R4, R7), 840 BPF_ALU64_REG(BPF_ADD, R4, R8), 841 BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */ 842 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1), 843 BPF_EXIT_INSN(), 844 BPF_ALU64_REG(BPF_ADD, R5, R0), 845 BPF_ALU64_REG(BPF_ADD, R5, R1), 846 BPF_ALU64_REG(BPF_ADD, R5, R2), 847 BPF_ALU64_REG(BPF_ADD, R5, R3), 848 BPF_ALU64_REG(BPF_ADD, R5, R4), 849 BPF_ALU64_REG(BPF_ADD, R5, R5), 850 BPF_ALU64_REG(BPF_ADD, R5, R6), 851 BPF_ALU64_REG(BPF_ADD, R5, R7), 852 BPF_ALU64_REG(BPF_ADD, R5, R8), 853 BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */ 854 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1), 855 BPF_EXIT_INSN(), 856 BPF_ALU64_REG(BPF_ADD, R6, R0), 857 BPF_ALU64_REG(BPF_ADD, R6, R1), 858 BPF_ALU64_REG(BPF_ADD, R6, R2), 859 BPF_ALU64_REG(BPF_ADD, R6, R3), 860 BPF_ALU64_REG(BPF_ADD, R6, R4), 861 BPF_ALU64_REG(BPF_ADD, R6, R5), 862 BPF_ALU64_REG(BPF_ADD, R6, R6), 863 BPF_ALU64_REG(BPF_ADD, R6, R7), 864 BPF_ALU64_REG(BPF_ADD, R6, R8), 865 BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */ 866 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1), 867 BPF_EXIT_INSN(), 868 BPF_ALU64_REG(BPF_ADD, R7, R0), 869 BPF_ALU64_REG(BPF_ADD, R7, R1), 870 BPF_ALU64_REG(BPF_ADD, R7, R2), 871 BPF_ALU64_REG(BPF_ADD, R7, R3), 872 BPF_ALU64_REG(BPF_ADD, R7, R4), 873 BPF_ALU64_REG(BPF_ADD, R7, R5), 874 BPF_ALU64_REG(BPF_ADD, R7, R6), 875 BPF_ALU64_REG(BPF_ADD, R7, R7), 876 BPF_ALU64_REG(BPF_ADD, R7, R8), 877 BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */ 878 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1), 879 BPF_EXIT_INSN(), 880 BPF_ALU64_REG(BPF_ADD, R8, R0), 881 BPF_ALU64_REG(BPF_ADD, R8, R1), 882 BPF_ALU64_REG(BPF_ADD, R8, R2), 883 BPF_ALU64_REG(BPF_ADD, R8, R3), 884 BPF_ALU64_REG(BPF_ADD, R8, R4), 885 BPF_ALU64_REG(BPF_ADD, R8, R5), 886 BPF_ALU64_REG(BPF_ADD, R8, R6), 887 BPF_ALU64_REG(BPF_ADD, R8, R7), 888 BPF_ALU64_REG(BPF_ADD, R8, R8), 889 BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */ 890 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1), 891 BPF_EXIT_INSN(), 892 BPF_ALU64_REG(BPF_ADD, R9, R0), 893 BPF_ALU64_REG(BPF_ADD, R9, R1), 894 BPF_ALU64_REG(BPF_ADD, R9, R2), 895 BPF_ALU64_REG(BPF_ADD, R9, R3), 896 BPF_ALU64_REG(BPF_ADD, R9, R4), 897 BPF_ALU64_REG(BPF_ADD, R9, R5), 898 BPF_ALU64_REG(BPF_ADD, R9, R6), 899 BPF_ALU64_REG(BPF_ADD, R9, R7), 900 BPF_ALU64_REG(BPF_ADD, R9, R8), 901 BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */ 902 BPF_ALU64_REG(BPF_MOV, R0, R9), 903 BPF_EXIT_INSN(), 904 }, 905 INTERNAL, 906 { }, 907 { { 0, 2957380 } } 908 }, 909 { 910 "INT: ADD 32-bit", 911 .u.insns_int = { 912 BPF_ALU32_IMM(BPF_MOV, R0, 20), 913 BPF_ALU32_IMM(BPF_MOV, R1, 1), 914 BPF_ALU32_IMM(BPF_MOV, R2, 2), 915 BPF_ALU32_IMM(BPF_MOV, R3, 3), 916 BPF_ALU32_IMM(BPF_MOV, R4, 4), 917 BPF_ALU32_IMM(BPF_MOV, R5, 5), 918 BPF_ALU32_IMM(BPF_MOV, R6, 6), 919 BPF_ALU32_IMM(BPF_MOV, R7, 7), 920 BPF_ALU32_IMM(BPF_MOV, R8, 8), 921 BPF_ALU32_IMM(BPF_MOV, R9, 9), 922 BPF_ALU64_IMM(BPF_ADD, R1, 10), 923 BPF_ALU64_IMM(BPF_ADD, R2, 10), 924 BPF_ALU64_IMM(BPF_ADD, R3, 10), 925 BPF_ALU64_IMM(BPF_ADD, R4, 10), 926 BPF_ALU64_IMM(BPF_ADD, R5, 10), 927 BPF_ALU64_IMM(BPF_ADD, R6, 10), 928 BPF_ALU64_IMM(BPF_ADD, R7, 10), 929 BPF_ALU64_IMM(BPF_ADD, R8, 10), 930 BPF_ALU64_IMM(BPF_ADD, R9, 10), 931 BPF_ALU32_REG(BPF_ADD, R0, R1), 932 BPF_ALU32_REG(BPF_ADD, R0, R2), 933 BPF_ALU32_REG(BPF_ADD, R0, R3), 934 BPF_ALU32_REG(BPF_ADD, R0, R4), 935 BPF_ALU32_REG(BPF_ADD, R0, R5), 936 BPF_ALU32_REG(BPF_ADD, R0, R6), 937 BPF_ALU32_REG(BPF_ADD, R0, R7), 938 BPF_ALU32_REG(BPF_ADD, R0, R8), 939 BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */ 940 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1), 941 BPF_EXIT_INSN(), 942 BPF_ALU32_REG(BPF_ADD, R1, R0), 943 BPF_ALU32_REG(BPF_ADD, R1, R1), 944 BPF_ALU32_REG(BPF_ADD, R1, R2), 945 BPF_ALU32_REG(BPF_ADD, R1, R3), 946 BPF_ALU32_REG(BPF_ADD, R1, R4), 947 BPF_ALU32_REG(BPF_ADD, R1, R5), 948 BPF_ALU32_REG(BPF_ADD, R1, R6), 949 BPF_ALU32_REG(BPF_ADD, R1, R7), 950 BPF_ALU32_REG(BPF_ADD, R1, R8), 951 BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */ 952 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1), 953 BPF_EXIT_INSN(), 954 BPF_ALU32_REG(BPF_ADD, R2, R0), 955 BPF_ALU32_REG(BPF_ADD, R2, R1), 956 BPF_ALU32_REG(BPF_ADD, R2, R2), 957 BPF_ALU32_REG(BPF_ADD, R2, R3), 958 BPF_ALU32_REG(BPF_ADD, R2, R4), 959 BPF_ALU32_REG(BPF_ADD, R2, R5), 960 BPF_ALU32_REG(BPF_ADD, R2, R6), 961 BPF_ALU32_REG(BPF_ADD, R2, R7), 962 BPF_ALU32_REG(BPF_ADD, R2, R8), 963 BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */ 964 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1), 965 BPF_EXIT_INSN(), 966 BPF_ALU32_REG(BPF_ADD, R3, R0), 967 BPF_ALU32_REG(BPF_ADD, R3, R1), 968 BPF_ALU32_REG(BPF_ADD, R3, R2), 969 BPF_ALU32_REG(BPF_ADD, R3, R3), 970 BPF_ALU32_REG(BPF_ADD, R3, R4), 971 BPF_ALU32_REG(BPF_ADD, R3, R5), 972 BPF_ALU32_REG(BPF_ADD, R3, R6), 973 BPF_ALU32_REG(BPF_ADD, R3, R7), 974 BPF_ALU32_REG(BPF_ADD, R3, R8), 975 BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */ 976 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1), 977 BPF_EXIT_INSN(), 978 BPF_ALU32_REG(BPF_ADD, R4, R0), 979 BPF_ALU32_REG(BPF_ADD, R4, R1), 980 BPF_ALU32_REG(BPF_ADD, R4, R2), 981 BPF_ALU32_REG(BPF_ADD, R4, R3), 982 BPF_ALU32_REG(BPF_ADD, R4, R4), 983 BPF_ALU32_REG(BPF_ADD, R4, R5), 984 BPF_ALU32_REG(BPF_ADD, R4, R6), 985 BPF_ALU32_REG(BPF_ADD, R4, R7), 986 BPF_ALU32_REG(BPF_ADD, R4, R8), 987 BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */ 988 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1), 989 BPF_EXIT_INSN(), 990 BPF_ALU32_REG(BPF_ADD, R5, R0), 991 BPF_ALU32_REG(BPF_ADD, R5, R1), 992 BPF_ALU32_REG(BPF_ADD, R5, R2), 993 BPF_ALU32_REG(BPF_ADD, R5, R3), 994 BPF_ALU32_REG(BPF_ADD, R5, R4), 995 BPF_ALU32_REG(BPF_ADD, R5, R5), 996 BPF_ALU32_REG(BPF_ADD, R5, R6), 997 BPF_ALU32_REG(BPF_ADD, R5, R7), 998 BPF_ALU32_REG(BPF_ADD, R5, R8), 999 BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */ 1000 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1), 1001 BPF_EXIT_INSN(), 1002 BPF_ALU32_REG(BPF_ADD, R6, R0), 1003 BPF_ALU32_REG(BPF_ADD, R6, R1), 1004 BPF_ALU32_REG(BPF_ADD, R6, R2), 1005 BPF_ALU32_REG(BPF_ADD, R6, R3), 1006 BPF_ALU32_REG(BPF_ADD, R6, R4), 1007 BPF_ALU32_REG(BPF_ADD, R6, R5), 1008 BPF_ALU32_REG(BPF_ADD, R6, R6), 1009 BPF_ALU32_REG(BPF_ADD, R6, R7), 1010 BPF_ALU32_REG(BPF_ADD, R6, R8), 1011 BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */ 1012 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1), 1013 BPF_EXIT_INSN(), 1014 BPF_ALU32_REG(BPF_ADD, R7, R0), 1015 BPF_ALU32_REG(BPF_ADD, R7, R1), 1016 BPF_ALU32_REG(BPF_ADD, R7, R2), 1017 BPF_ALU32_REG(BPF_ADD, R7, R3), 1018 BPF_ALU32_REG(BPF_ADD, R7, R4), 1019 BPF_ALU32_REG(BPF_ADD, R7, R5), 1020 BPF_ALU32_REG(BPF_ADD, R7, R6), 1021 BPF_ALU32_REG(BPF_ADD, R7, R7), 1022 BPF_ALU32_REG(BPF_ADD, R7, R8), 1023 BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */ 1024 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1), 1025 BPF_EXIT_INSN(), 1026 BPF_ALU32_REG(BPF_ADD, R8, R0), 1027 BPF_ALU32_REG(BPF_ADD, R8, R1), 1028 BPF_ALU32_REG(BPF_ADD, R8, R2), 1029 BPF_ALU32_REG(BPF_ADD, R8, R3), 1030 BPF_ALU32_REG(BPF_ADD, R8, R4), 1031 BPF_ALU32_REG(BPF_ADD, R8, R5), 1032 BPF_ALU32_REG(BPF_ADD, R8, R6), 1033 BPF_ALU32_REG(BPF_ADD, R8, R7), 1034 BPF_ALU32_REG(BPF_ADD, R8, R8), 1035 BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */ 1036 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1), 1037 BPF_EXIT_INSN(), 1038 BPF_ALU32_REG(BPF_ADD, R9, R0), 1039 BPF_ALU32_REG(BPF_ADD, R9, R1), 1040 BPF_ALU32_REG(BPF_ADD, R9, R2), 1041 BPF_ALU32_REG(BPF_ADD, R9, R3), 1042 BPF_ALU32_REG(BPF_ADD, R9, R4), 1043 BPF_ALU32_REG(BPF_ADD, R9, R5), 1044 BPF_ALU32_REG(BPF_ADD, R9, R6), 1045 BPF_ALU32_REG(BPF_ADD, R9, R7), 1046 BPF_ALU32_REG(BPF_ADD, R9, R8), 1047 BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */ 1048 BPF_ALU32_REG(BPF_MOV, R0, R9), 1049 BPF_EXIT_INSN(), 1050 }, 1051 INTERNAL, 1052 { }, 1053 { { 0, 2957380 } } 1054 }, 1055 { /* Mainly checking JIT here. */ 1056 "INT: SUB", 1057 .u.insns_int = { 1058 BPF_ALU64_IMM(BPF_MOV, R0, 0), 1059 BPF_ALU64_IMM(BPF_MOV, R1, 1), 1060 BPF_ALU64_IMM(BPF_MOV, R2, 2), 1061 BPF_ALU64_IMM(BPF_MOV, R3, 3), 1062 BPF_ALU64_IMM(BPF_MOV, R4, 4), 1063 BPF_ALU64_IMM(BPF_MOV, R5, 5), 1064 BPF_ALU64_IMM(BPF_MOV, R6, 6), 1065 BPF_ALU64_IMM(BPF_MOV, R7, 7), 1066 BPF_ALU64_IMM(BPF_MOV, R8, 8), 1067 BPF_ALU64_IMM(BPF_MOV, R9, 9), 1068 BPF_ALU64_REG(BPF_SUB, R0, R0), 1069 BPF_ALU64_REG(BPF_SUB, R0, R1), 1070 BPF_ALU64_REG(BPF_SUB, R0, R2), 1071 BPF_ALU64_REG(BPF_SUB, R0, R3), 1072 BPF_ALU64_REG(BPF_SUB, R0, R4), 1073 BPF_ALU64_REG(BPF_SUB, R0, R5), 1074 BPF_ALU64_REG(BPF_SUB, R0, R6), 1075 BPF_ALU64_REG(BPF_SUB, R0, R7), 1076 BPF_ALU64_REG(BPF_SUB, R0, R8), 1077 BPF_ALU64_REG(BPF_SUB, R0, R9), 1078 BPF_ALU64_IMM(BPF_SUB, R0, 10), 1079 BPF_JMP_IMM(BPF_JEQ, R0, -55, 1), 1080 BPF_EXIT_INSN(), 1081 BPF_ALU64_REG(BPF_SUB, R1, R0), 1082 BPF_ALU64_REG(BPF_SUB, R1, R2), 1083 BPF_ALU64_REG(BPF_SUB, R1, R3), 1084 BPF_ALU64_REG(BPF_SUB, R1, R4), 1085 BPF_ALU64_REG(BPF_SUB, R1, R5), 1086 BPF_ALU64_REG(BPF_SUB, R1, R6), 1087 BPF_ALU64_REG(BPF_SUB, R1, R7), 1088 BPF_ALU64_REG(BPF_SUB, R1, R8), 1089 BPF_ALU64_REG(BPF_SUB, R1, R9), 1090 BPF_ALU64_IMM(BPF_SUB, R1, 10), 1091 BPF_ALU64_REG(BPF_SUB, R2, R0), 1092 BPF_ALU64_REG(BPF_SUB, R2, R1), 1093 BPF_ALU64_REG(BPF_SUB, R2, R3), 1094 BPF_ALU64_REG(BPF_SUB, R2, R4), 1095 BPF_ALU64_REG(BPF_SUB, R2, R5), 1096 BPF_ALU64_REG(BPF_SUB, R2, R6), 1097 BPF_ALU64_REG(BPF_SUB, R2, R7), 1098 BPF_ALU64_REG(BPF_SUB, R2, R8), 1099 BPF_ALU64_REG(BPF_SUB, R2, R9), 1100 BPF_ALU64_IMM(BPF_SUB, R2, 10), 1101 BPF_ALU64_REG(BPF_SUB, R3, R0), 1102 BPF_ALU64_REG(BPF_SUB, R3, R1), 1103 BPF_ALU64_REG(BPF_SUB, R3, R2), 1104 BPF_ALU64_REG(BPF_SUB, R3, R4), 1105 BPF_ALU64_REG(BPF_SUB, R3, R5), 1106 BPF_ALU64_REG(BPF_SUB, R3, R6), 1107 BPF_ALU64_REG(BPF_SUB, R3, R7), 1108 BPF_ALU64_REG(BPF_SUB, R3, R8), 1109 BPF_ALU64_REG(BPF_SUB, R3, R9), 1110 BPF_ALU64_IMM(BPF_SUB, R3, 10), 1111 BPF_ALU64_REG(BPF_SUB, R4, R0), 1112 BPF_ALU64_REG(BPF_SUB, R4, R1), 1113 BPF_ALU64_REG(BPF_SUB, R4, R2), 1114 BPF_ALU64_REG(BPF_SUB, R4, R3), 1115 BPF_ALU64_REG(BPF_SUB, R4, R5), 1116 BPF_ALU64_REG(BPF_SUB, R4, R6), 1117 BPF_ALU64_REG(BPF_SUB, R4, R7), 1118 BPF_ALU64_REG(BPF_SUB, R4, R8), 1119 BPF_ALU64_REG(BPF_SUB, R4, R9), 1120 BPF_ALU64_IMM(BPF_SUB, R4, 10), 1121 BPF_ALU64_REG(BPF_SUB, R5, R0), 1122 BPF_ALU64_REG(BPF_SUB, R5, R1), 1123 BPF_ALU64_REG(BPF_SUB, R5, R2), 1124 BPF_ALU64_REG(BPF_SUB, R5, R3), 1125 BPF_ALU64_REG(BPF_SUB, R5, R4), 1126 BPF_ALU64_REG(BPF_SUB, R5, R6), 1127 BPF_ALU64_REG(BPF_SUB, R5, R7), 1128 BPF_ALU64_REG(BPF_SUB, R5, R8), 1129 BPF_ALU64_REG(BPF_SUB, R5, R9), 1130 BPF_ALU64_IMM(BPF_SUB, R5, 10), 1131 BPF_ALU64_REG(BPF_SUB, R6, R0), 1132 BPF_ALU64_REG(BPF_SUB, R6, R1), 1133 BPF_ALU64_REG(BPF_SUB, R6, R2), 1134 BPF_ALU64_REG(BPF_SUB, R6, R3), 1135 BPF_ALU64_REG(BPF_SUB, R6, R4), 1136 BPF_ALU64_REG(BPF_SUB, R6, R5), 1137 BPF_ALU64_REG(BPF_SUB, R6, R7), 1138 BPF_ALU64_REG(BPF_SUB, R6, R8), 1139 BPF_ALU64_REG(BPF_SUB, R6, R9), 1140 BPF_ALU64_IMM(BPF_SUB, R6, 10), 1141 BPF_ALU64_REG(BPF_SUB, R7, R0), 1142 BPF_ALU64_REG(BPF_SUB, R7, R1), 1143 BPF_ALU64_REG(BPF_SUB, R7, R2), 1144 BPF_ALU64_REG(BPF_SUB, R7, R3), 1145 BPF_ALU64_REG(BPF_SUB, R7, R4), 1146 BPF_ALU64_REG(BPF_SUB, R7, R5), 1147 BPF_ALU64_REG(BPF_SUB, R7, R6), 1148 BPF_ALU64_REG(BPF_SUB, R7, R8), 1149 BPF_ALU64_REG(BPF_SUB, R7, R9), 1150 BPF_ALU64_IMM(BPF_SUB, R7, 10), 1151 BPF_ALU64_REG(BPF_SUB, R8, R0), 1152 BPF_ALU64_REG(BPF_SUB, R8, R1), 1153 BPF_ALU64_REG(BPF_SUB, R8, R2), 1154 BPF_ALU64_REG(BPF_SUB, R8, R3), 1155 BPF_ALU64_REG(BPF_SUB, R8, R4), 1156 BPF_ALU64_REG(BPF_SUB, R8, R5), 1157 BPF_ALU64_REG(BPF_SUB, R8, R6), 1158 BPF_ALU64_REG(BPF_SUB, R8, R7), 1159 BPF_ALU64_REG(BPF_SUB, R8, R9), 1160 BPF_ALU64_IMM(BPF_SUB, R8, 10), 1161 BPF_ALU64_REG(BPF_SUB, R9, R0), 1162 BPF_ALU64_REG(BPF_SUB, R9, R1), 1163 BPF_ALU64_REG(BPF_SUB, R9, R2), 1164 BPF_ALU64_REG(BPF_SUB, R9, R3), 1165 BPF_ALU64_REG(BPF_SUB, R9, R4), 1166 BPF_ALU64_REG(BPF_SUB, R9, R5), 1167 BPF_ALU64_REG(BPF_SUB, R9, R6), 1168 BPF_ALU64_REG(BPF_SUB, R9, R7), 1169 BPF_ALU64_REG(BPF_SUB, R9, R8), 1170 BPF_ALU64_IMM(BPF_SUB, R9, 10), 1171 BPF_ALU64_IMM(BPF_SUB, R0, 10), 1172 BPF_ALU64_IMM(BPF_NEG, R0, 0), 1173 BPF_ALU64_REG(BPF_SUB, R0, R1), 1174 BPF_ALU64_REG(BPF_SUB, R0, R2), 1175 BPF_ALU64_REG(BPF_SUB, R0, R3), 1176 BPF_ALU64_REG(BPF_SUB, R0, R4), 1177 BPF_ALU64_REG(BPF_SUB, R0, R5), 1178 BPF_ALU64_REG(BPF_SUB, R0, R6), 1179 BPF_ALU64_REG(BPF_SUB, R0, R7), 1180 BPF_ALU64_REG(BPF_SUB, R0, R8), 1181 BPF_ALU64_REG(BPF_SUB, R0, R9), 1182 BPF_EXIT_INSN(), 1183 }, 1184 INTERNAL, 1185 { }, 1186 { { 0, 11 } } 1187 }, 1188 { /* Mainly checking JIT here. */ 1189 "INT: XOR", 1190 .u.insns_int = { 1191 BPF_ALU64_REG(BPF_SUB, R0, R0), 1192 BPF_ALU64_REG(BPF_XOR, R1, R1), 1193 BPF_JMP_REG(BPF_JEQ, R0, R1, 1), 1194 BPF_EXIT_INSN(), 1195 BPF_ALU64_IMM(BPF_MOV, R0, 10), 1196 BPF_ALU64_IMM(BPF_MOV, R1, -1), 1197 BPF_ALU64_REG(BPF_SUB, R1, R1), 1198 BPF_ALU64_REG(BPF_XOR, R2, R2), 1199 BPF_JMP_REG(BPF_JEQ, R1, R2, 1), 1200 BPF_EXIT_INSN(), 1201 BPF_ALU64_REG(BPF_SUB, R2, R2), 1202 BPF_ALU64_REG(BPF_XOR, R3, R3), 1203 BPF_ALU64_IMM(BPF_MOV, R0, 10), 1204 BPF_ALU64_IMM(BPF_MOV, R1, -1), 1205 BPF_JMP_REG(BPF_JEQ, R2, R3, 1), 1206 BPF_EXIT_INSN(), 1207 BPF_ALU64_REG(BPF_SUB, R3, R3), 1208 BPF_ALU64_REG(BPF_XOR, R4, R4), 1209 BPF_ALU64_IMM(BPF_MOV, R2, 1), 1210 BPF_ALU64_IMM(BPF_MOV, R5, -1), 1211 BPF_JMP_REG(BPF_JEQ, R3, R4, 1), 1212 BPF_EXIT_INSN(), 1213 BPF_ALU64_REG(BPF_SUB, R4, R4), 1214 BPF_ALU64_REG(BPF_XOR, R5, R5), 1215 BPF_ALU64_IMM(BPF_MOV, R3, 1), 1216 BPF_ALU64_IMM(BPF_MOV, R7, -1), 1217 BPF_JMP_REG(BPF_JEQ, R5, R4, 1), 1218 BPF_EXIT_INSN(), 1219 BPF_ALU64_IMM(BPF_MOV, R5, 1), 1220 BPF_ALU64_REG(BPF_SUB, R5, R5), 1221 BPF_ALU64_REG(BPF_XOR, R6, R6), 1222 BPF_ALU64_IMM(BPF_MOV, R1, 1), 1223 BPF_ALU64_IMM(BPF_MOV, R8, -1), 1224 BPF_JMP_REG(BPF_JEQ, R5, R6, 1), 1225 BPF_EXIT_INSN(), 1226 BPF_ALU64_REG(BPF_SUB, R6, R6), 1227 BPF_ALU64_REG(BPF_XOR, R7, R7), 1228 BPF_JMP_REG(BPF_JEQ, R7, R6, 1), 1229 BPF_EXIT_INSN(), 1230 BPF_ALU64_REG(BPF_SUB, R7, R7), 1231 BPF_ALU64_REG(BPF_XOR, R8, R8), 1232 BPF_JMP_REG(BPF_JEQ, R7, R8, 1), 1233 BPF_EXIT_INSN(), 1234 BPF_ALU64_REG(BPF_SUB, R8, R8), 1235 BPF_ALU64_REG(BPF_XOR, R9, R9), 1236 BPF_JMP_REG(BPF_JEQ, R9, R8, 1), 1237 BPF_EXIT_INSN(), 1238 BPF_ALU64_REG(BPF_SUB, R9, R9), 1239 BPF_ALU64_REG(BPF_XOR, R0, R0), 1240 BPF_JMP_REG(BPF_JEQ, R9, R0, 1), 1241 BPF_EXIT_INSN(), 1242 BPF_ALU64_REG(BPF_SUB, R1, R1), 1243 BPF_ALU64_REG(BPF_XOR, R0, R0), 1244 BPF_JMP_REG(BPF_JEQ, R9, R0, 2), 1245 BPF_ALU64_IMM(BPF_MOV, R0, 0), 1246 BPF_EXIT_INSN(), 1247 BPF_ALU64_IMM(BPF_MOV, R0, 1), 1248 BPF_EXIT_INSN(), 1249 }, 1250 INTERNAL, 1251 { }, 1252 { { 0, 1 } } 1253 }, 1254 { /* Mainly checking JIT here. */ 1255 "INT: MUL", 1256 .u.insns_int = { 1257 BPF_ALU64_IMM(BPF_MOV, R0, 11), 1258 BPF_ALU64_IMM(BPF_MOV, R1, 1), 1259 BPF_ALU64_IMM(BPF_MOV, R2, 2), 1260 BPF_ALU64_IMM(BPF_MOV, R3, 3), 1261 BPF_ALU64_IMM(BPF_MOV, R4, 4), 1262 BPF_ALU64_IMM(BPF_MOV, R5, 5), 1263 BPF_ALU64_IMM(BPF_MOV, R6, 6), 1264 BPF_ALU64_IMM(BPF_MOV, R7, 7), 1265 BPF_ALU64_IMM(BPF_MOV, R8, 8), 1266 BPF_ALU64_IMM(BPF_MOV, R9, 9), 1267 BPF_ALU64_REG(BPF_MUL, R0, R0), 1268 BPF_ALU64_REG(BPF_MUL, R0, R1), 1269 BPF_ALU64_REG(BPF_MUL, R0, R2), 1270 BPF_ALU64_REG(BPF_MUL, R0, R3), 1271 BPF_ALU64_REG(BPF_MUL, R0, R4), 1272 BPF_ALU64_REG(BPF_MUL, R0, R5), 1273 BPF_ALU64_REG(BPF_MUL, R0, R6), 1274 BPF_ALU64_REG(BPF_MUL, R0, R7), 1275 BPF_ALU64_REG(BPF_MUL, R0, R8), 1276 BPF_ALU64_REG(BPF_MUL, R0, R9), 1277 BPF_ALU64_IMM(BPF_MUL, R0, 10), 1278 BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1), 1279 BPF_EXIT_INSN(), 1280 BPF_ALU64_REG(BPF_MUL, R1, R0), 1281 BPF_ALU64_REG(BPF_MUL, R1, R2), 1282 BPF_ALU64_REG(BPF_MUL, R1, R3), 1283 BPF_ALU64_REG(BPF_MUL, R1, R4), 1284 BPF_ALU64_REG(BPF_MUL, R1, R5), 1285 BPF_ALU64_REG(BPF_MUL, R1, R6), 1286 BPF_ALU64_REG(BPF_MUL, R1, R7), 1287 BPF_ALU64_REG(BPF_MUL, R1, R8), 1288 BPF_ALU64_REG(BPF_MUL, R1, R9), 1289 BPF_ALU64_IMM(BPF_MUL, R1, 10), 1290 BPF_ALU64_REG(BPF_MOV, R2, R1), 1291 BPF_ALU64_IMM(BPF_RSH, R2, 32), 1292 BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1), 1293 BPF_EXIT_INSN(), 1294 BPF_ALU64_IMM(BPF_LSH, R1, 32), 1295 BPF_ALU64_IMM(BPF_ARSH, R1, 32), 1296 BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1), 1297 BPF_EXIT_INSN(), 1298 BPF_ALU64_REG(BPF_MUL, R2, R0), 1299 BPF_ALU64_REG(BPF_MUL, R2, R1), 1300 BPF_ALU64_REG(BPF_MUL, R2, R3), 1301 BPF_ALU64_REG(BPF_MUL, R2, R4), 1302 BPF_ALU64_REG(BPF_MUL, R2, R5), 1303 BPF_ALU64_REG(BPF_MUL, R2, R6), 1304 BPF_ALU64_REG(BPF_MUL, R2, R7), 1305 BPF_ALU64_REG(BPF_MUL, R2, R8), 1306 BPF_ALU64_REG(BPF_MUL, R2, R9), 1307 BPF_ALU64_IMM(BPF_MUL, R2, 10), 1308 BPF_ALU64_IMM(BPF_RSH, R2, 32), 1309 BPF_ALU64_REG(BPF_MOV, R0, R2), 1310 BPF_EXIT_INSN(), 1311 }, 1312 INTERNAL, 1313 { }, 1314 { { 0, 0x35d97ef2 } } 1315 }, 1316 { 1317 "INT: ALU MIX", 1318 .u.insns_int = { 1319 BPF_ALU64_IMM(BPF_MOV, R0, 11), 1320 BPF_ALU64_IMM(BPF_ADD, R0, -1), 1321 BPF_ALU64_IMM(BPF_MOV, R2, 2), 1322 BPF_ALU64_IMM(BPF_XOR, R2, 3), 1323 BPF_ALU64_REG(BPF_DIV, R0, R2), 1324 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1), 1325 BPF_EXIT_INSN(), 1326 BPF_ALU64_IMM(BPF_MOD, R0, 3), 1327 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1), 1328 BPF_EXIT_INSN(), 1329 BPF_ALU64_IMM(BPF_MOV, R0, -1), 1330 BPF_EXIT_INSN(), 1331 }, 1332 INTERNAL, 1333 { }, 1334 { { 0, -1 } } 1335 }, 1336 { 1337 "INT: DIV + ABS", 1338 .u.insns_int = { 1339 BPF_ALU64_REG(BPF_MOV, R6, R1), 1340 BPF_LD_ABS(BPF_B, 3), 1341 BPF_ALU64_IMM(BPF_MOV, R2, 2), 1342 BPF_ALU32_REG(BPF_DIV, R0, R2), 1343 BPF_ALU64_REG(BPF_MOV, R8, R0), 1344 BPF_LD_ABS(BPF_B, 4), 1345 BPF_ALU64_REG(BPF_ADD, R8, R0), 1346 BPF_LD_IND(BPF_B, R8, -70), 1347 BPF_EXIT_INSN(), 1348 }, 1349 INTERNAL, 1350 { 10, 20, 30, 40, 50 }, 1351 { { 4, 0 }, { 5, 10 } } 1352 }, 1353 { 1354 "INT: DIV by zero", 1355 .u.insns_int = { 1356 BPF_ALU64_REG(BPF_MOV, R6, R1), 1357 BPF_ALU64_IMM(BPF_MOV, R7, 0), 1358 BPF_LD_ABS(BPF_B, 3), 1359 BPF_ALU32_REG(BPF_DIV, R0, R7), 1360 BPF_EXIT_INSN(), 1361 }, 1362 INTERNAL, 1363 { 10, 20, 30, 40, 50 }, 1364 { { 3, 0 }, { 4, 0 } } 1365 }, 1366 { 1367 "check: missing ret", 1368 .u.insns = { 1369 BPF_STMT(BPF_LD | BPF_IMM, 1), 1370 }, 1371 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 1372 { }, 1373 { } 1374 }, 1375 { 1376 "check: div_k_0", 1377 .u.insns = { 1378 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0), 1379 BPF_STMT(BPF_RET | BPF_K, 0) 1380 }, 1381 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 1382 { }, 1383 { } 1384 }, 1385 { 1386 "check: unknown insn", 1387 .u.insns = { 1388 /* seccomp insn, rejected in socket filter */ 1389 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0), 1390 BPF_STMT(BPF_RET | BPF_K, 0) 1391 }, 1392 CLASSIC | FLAG_EXPECTED_FAIL, 1393 { }, 1394 { } 1395 }, 1396 { 1397 "check: out of range spill/fill", 1398 .u.insns = { 1399 BPF_STMT(BPF_STX, 16), 1400 BPF_STMT(BPF_RET | BPF_K, 0) 1401 }, 1402 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 1403 { }, 1404 { } 1405 }, 1406 { 1407 "JUMPS + HOLES", 1408 .u.insns = { 1409 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1410 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15), 1411 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1412 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1413 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1414 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1415 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1416 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1417 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1418 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1419 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1420 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1421 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1422 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1423 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1424 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4), 1425 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1426 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2), 1427 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1428 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15), 1429 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14), 1430 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1431 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1432 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1433 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1434 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1435 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1436 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1437 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1438 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1439 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1440 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1441 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1442 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1443 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3), 1444 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2), 1445 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1446 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15), 1447 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14), 1448 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1449 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1450 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1451 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1452 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1453 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1454 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1455 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1456 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1457 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1458 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1459 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1460 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1461 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3), 1462 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2), 1463 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1464 BPF_STMT(BPF_RET | BPF_A, 0), 1465 BPF_STMT(BPF_RET | BPF_A, 0), 1466 }, 1467 CLASSIC, 1468 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8, 1469 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4, 1470 0x08, 0x00, 1471 0x45, 0x00, 0x00, 0x28, 0x00, 0x00, 1472 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */ 1473 0xc0, 0xa8, 0x33, 0x01, 1474 0xc0, 0xa8, 0x33, 0x02, 1475 0xbb, 0xb6, 1476 0xa9, 0xfa, 1477 0x00, 0x14, 0x00, 0x00, 1478 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 1479 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 1480 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 1481 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 1482 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 1483 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 1484 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 1485 0xcc, 0xcc, 0xcc, 0xcc }, 1486 { { 88, 0x001b } } 1487 }, 1488 { 1489 "check: RET X", 1490 .u.insns = { 1491 BPF_STMT(BPF_RET | BPF_X, 0), 1492 }, 1493 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 1494 { }, 1495 { }, 1496 }, 1497 { 1498 "check: LDX + RET X", 1499 .u.insns = { 1500 BPF_STMT(BPF_LDX | BPF_IMM, 42), 1501 BPF_STMT(BPF_RET | BPF_X, 0), 1502 }, 1503 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 1504 { }, 1505 { }, 1506 }, 1507 { /* Mainly checking JIT here. */ 1508 "M[]: alt STX + LDX", 1509 .u.insns = { 1510 BPF_STMT(BPF_LDX | BPF_IMM, 100), 1511 BPF_STMT(BPF_STX, 0), 1512 BPF_STMT(BPF_LDX | BPF_MEM, 0), 1513 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1514 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1515 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1516 BPF_STMT(BPF_STX, 1), 1517 BPF_STMT(BPF_LDX | BPF_MEM, 1), 1518 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1519 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1520 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1521 BPF_STMT(BPF_STX, 2), 1522 BPF_STMT(BPF_LDX | BPF_MEM, 2), 1523 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1524 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1525 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1526 BPF_STMT(BPF_STX, 3), 1527 BPF_STMT(BPF_LDX | BPF_MEM, 3), 1528 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1529 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1530 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1531 BPF_STMT(BPF_STX, 4), 1532 BPF_STMT(BPF_LDX | BPF_MEM, 4), 1533 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1534 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1535 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1536 BPF_STMT(BPF_STX, 5), 1537 BPF_STMT(BPF_LDX | BPF_MEM, 5), 1538 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1539 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1540 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1541 BPF_STMT(BPF_STX, 6), 1542 BPF_STMT(BPF_LDX | BPF_MEM, 6), 1543 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1544 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1545 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1546 BPF_STMT(BPF_STX, 7), 1547 BPF_STMT(BPF_LDX | BPF_MEM, 7), 1548 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1549 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1550 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1551 BPF_STMT(BPF_STX, 8), 1552 BPF_STMT(BPF_LDX | BPF_MEM, 8), 1553 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1554 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1555 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1556 BPF_STMT(BPF_STX, 9), 1557 BPF_STMT(BPF_LDX | BPF_MEM, 9), 1558 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1559 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1560 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1561 BPF_STMT(BPF_STX, 10), 1562 BPF_STMT(BPF_LDX | BPF_MEM, 10), 1563 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1564 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1565 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1566 BPF_STMT(BPF_STX, 11), 1567 BPF_STMT(BPF_LDX | BPF_MEM, 11), 1568 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1569 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1570 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1571 BPF_STMT(BPF_STX, 12), 1572 BPF_STMT(BPF_LDX | BPF_MEM, 12), 1573 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1574 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1575 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1576 BPF_STMT(BPF_STX, 13), 1577 BPF_STMT(BPF_LDX | BPF_MEM, 13), 1578 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1579 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1580 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1581 BPF_STMT(BPF_STX, 14), 1582 BPF_STMT(BPF_LDX | BPF_MEM, 14), 1583 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1584 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1585 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1586 BPF_STMT(BPF_STX, 15), 1587 BPF_STMT(BPF_LDX | BPF_MEM, 15), 1588 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1589 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1590 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1591 BPF_STMT(BPF_RET | BPF_A, 0), 1592 }, 1593 CLASSIC | FLAG_NO_DATA, 1594 { }, 1595 { { 0, 116 } }, 1596 }, 1597 { /* Mainly checking JIT here. */ 1598 "M[]: full STX + full LDX", 1599 .u.insns = { 1600 BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb), 1601 BPF_STMT(BPF_STX, 0), 1602 BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae), 1603 BPF_STMT(BPF_STX, 1), 1604 BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf), 1605 BPF_STMT(BPF_STX, 2), 1606 BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc), 1607 BPF_STMT(BPF_STX, 3), 1608 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb), 1609 BPF_STMT(BPF_STX, 4), 1610 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda), 1611 BPF_STMT(BPF_STX, 5), 1612 BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb), 1613 BPF_STMT(BPF_STX, 6), 1614 BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade), 1615 BPF_STMT(BPF_STX, 7), 1616 BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec), 1617 BPF_STMT(BPF_STX, 8), 1618 BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc), 1619 BPF_STMT(BPF_STX, 9), 1620 BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac), 1621 BPF_STMT(BPF_STX, 10), 1622 BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea), 1623 BPF_STMT(BPF_STX, 11), 1624 BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb), 1625 BPF_STMT(BPF_STX, 12), 1626 BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf), 1627 BPF_STMT(BPF_STX, 13), 1628 BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde), 1629 BPF_STMT(BPF_STX, 14), 1630 BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad), 1631 BPF_STMT(BPF_STX, 15), 1632 BPF_STMT(BPF_LDX | BPF_MEM, 0), 1633 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1634 BPF_STMT(BPF_LDX | BPF_MEM, 1), 1635 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1636 BPF_STMT(BPF_LDX | BPF_MEM, 2), 1637 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1638 BPF_STMT(BPF_LDX | BPF_MEM, 3), 1639 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1640 BPF_STMT(BPF_LDX | BPF_MEM, 4), 1641 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1642 BPF_STMT(BPF_LDX | BPF_MEM, 5), 1643 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1644 BPF_STMT(BPF_LDX | BPF_MEM, 6), 1645 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1646 BPF_STMT(BPF_LDX | BPF_MEM, 7), 1647 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1648 BPF_STMT(BPF_LDX | BPF_MEM, 8), 1649 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1650 BPF_STMT(BPF_LDX | BPF_MEM, 9), 1651 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1652 BPF_STMT(BPF_LDX | BPF_MEM, 10), 1653 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1654 BPF_STMT(BPF_LDX | BPF_MEM, 11), 1655 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1656 BPF_STMT(BPF_LDX | BPF_MEM, 12), 1657 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1658 BPF_STMT(BPF_LDX | BPF_MEM, 13), 1659 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1660 BPF_STMT(BPF_LDX | BPF_MEM, 14), 1661 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1662 BPF_STMT(BPF_LDX | BPF_MEM, 15), 1663 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1664 BPF_STMT(BPF_RET | BPF_A, 0), 1665 }, 1666 CLASSIC | FLAG_NO_DATA, 1667 { }, 1668 { { 0, 0x2a5a5e5 } }, 1669 }, 1670 { 1671 "check: SKF_AD_MAX", 1672 .u.insns = { 1673 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1674 SKF_AD_OFF + SKF_AD_MAX), 1675 BPF_STMT(BPF_RET | BPF_A, 0), 1676 }, 1677 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 1678 { }, 1679 { }, 1680 }, 1681 { /* Passes checker but fails during runtime. */ 1682 "LD [SKF_AD_OFF-1]", 1683 .u.insns = { 1684 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1685 SKF_AD_OFF - 1), 1686 BPF_STMT(BPF_RET | BPF_K, 1), 1687 }, 1688 CLASSIC, 1689 { }, 1690 { { 1, 0 } }, 1691 }, 1692 }; 1693 1694 static struct net_device dev; 1695 1696 static struct sk_buff *populate_skb(char *buf, int size) 1697 { 1698 struct sk_buff *skb; 1699 1700 if (size >= MAX_DATA) 1701 return NULL; 1702 1703 skb = alloc_skb(MAX_DATA, GFP_KERNEL); 1704 if (!skb) 1705 return NULL; 1706 1707 memcpy(__skb_put(skb, size), buf, size); 1708 1709 /* Initialize a fake skb with test pattern. */ 1710 skb_reset_mac_header(skb); 1711 skb->protocol = htons(ETH_P_IP); 1712 skb->pkt_type = SKB_TYPE; 1713 skb->mark = SKB_MARK; 1714 skb->hash = SKB_HASH; 1715 skb->queue_mapping = SKB_QUEUE_MAP; 1716 skb->vlan_tci = SKB_VLAN_TCI; 1717 skb->dev = &dev; 1718 skb->dev->ifindex = SKB_DEV_IFINDEX; 1719 skb->dev->type = SKB_DEV_TYPE; 1720 skb_set_network_header(skb, min(size, ETH_HLEN)); 1721 1722 return skb; 1723 } 1724 1725 static void *generate_test_data(struct bpf_test *test, int sub) 1726 { 1727 if (test->aux & FLAG_NO_DATA) 1728 return NULL; 1729 1730 /* Test case expects an skb, so populate one. Various 1731 * subtests generate skbs of different sizes based on 1732 * the same data. 1733 */ 1734 return populate_skb(test->data, test->test[sub].data_size); 1735 } 1736 1737 static void release_test_data(const struct bpf_test *test, void *data) 1738 { 1739 if (test->aux & FLAG_NO_DATA) 1740 return; 1741 1742 kfree_skb(data); 1743 } 1744 1745 static int probe_filter_length(struct sock_filter *fp) 1746 { 1747 int len = 0; 1748 1749 for (len = MAX_INSNS - 1; len > 0; --len) 1750 if (fp[len].code != 0 || fp[len].k != 0) 1751 break; 1752 1753 return len + 1; 1754 } 1755 1756 static struct sk_filter *generate_filter(int which, int *err) 1757 { 1758 struct sk_filter *fp; 1759 struct sock_fprog_kern fprog; 1760 unsigned int flen = probe_filter_length(tests[which].u.insns); 1761 __u8 test_type = tests[which].aux & TEST_TYPE_MASK; 1762 1763 switch (test_type) { 1764 case CLASSIC: 1765 fprog.filter = tests[which].u.insns; 1766 fprog.len = flen; 1767 1768 *err = sk_unattached_filter_create(&fp, &fprog); 1769 if (tests[which].aux & FLAG_EXPECTED_FAIL) { 1770 if (*err == -EINVAL) { 1771 pr_cont("PASS\n"); 1772 /* Verifier rejected filter as expected. */ 1773 *err = 0; 1774 return NULL; 1775 } else { 1776 pr_cont("UNEXPECTED_PASS\n"); 1777 /* Verifier didn't reject the test that's 1778 * bad enough, just return! 1779 */ 1780 *err = -EINVAL; 1781 return NULL; 1782 } 1783 } 1784 /* We don't expect to fail. */ 1785 if (*err) { 1786 pr_cont("FAIL to attach err=%d len=%d\n", 1787 *err, fprog.len); 1788 return NULL; 1789 } 1790 break; 1791 1792 case INTERNAL: 1793 fp = kzalloc(sk_filter_size(flen), GFP_KERNEL); 1794 if (fp == NULL) { 1795 pr_cont("UNEXPECTED_FAIL no memory left\n"); 1796 *err = -ENOMEM; 1797 return NULL; 1798 } 1799 1800 fp->len = flen; 1801 memcpy(fp->insnsi, tests[which].u.insns_int, 1802 fp->len * sizeof(struct sock_filter_int)); 1803 1804 sk_filter_select_runtime(fp); 1805 break; 1806 } 1807 1808 *err = 0; 1809 return fp; 1810 } 1811 1812 static void release_filter(struct sk_filter *fp, int which) 1813 { 1814 __u8 test_type = tests[which].aux & TEST_TYPE_MASK; 1815 1816 switch (test_type) { 1817 case CLASSIC: 1818 sk_unattached_filter_destroy(fp); 1819 break; 1820 case INTERNAL: 1821 sk_filter_free(fp); 1822 break; 1823 } 1824 } 1825 1826 static int __run_one(const struct sk_filter *fp, const void *data, 1827 int runs, u64 *duration) 1828 { 1829 u64 start, finish; 1830 int ret, i; 1831 1832 start = ktime_to_us(ktime_get()); 1833 1834 for (i = 0; i < runs; i++) 1835 ret = SK_RUN_FILTER(fp, data); 1836 1837 finish = ktime_to_us(ktime_get()); 1838 1839 *duration = (finish - start) * 1000ULL; 1840 do_div(*duration, runs); 1841 1842 return ret; 1843 } 1844 1845 static int run_one(const struct sk_filter *fp, struct bpf_test *test) 1846 { 1847 int err_cnt = 0, i, runs = MAX_TESTRUNS; 1848 1849 for (i = 0; i < MAX_SUBTESTS; i++) { 1850 void *data; 1851 u64 duration; 1852 u32 ret; 1853 1854 if (test->test[i].data_size == 0 && 1855 test->test[i].result == 0) 1856 break; 1857 1858 data = generate_test_data(test, i); 1859 ret = __run_one(fp, data, runs, &duration); 1860 release_test_data(test, data); 1861 1862 if (ret == test->test[i].result) { 1863 pr_cont("%lld ", duration); 1864 } else { 1865 pr_cont("ret %d != %d ", ret, 1866 test->test[i].result); 1867 err_cnt++; 1868 } 1869 } 1870 1871 return err_cnt; 1872 } 1873 1874 static __init int test_bpf(void) 1875 { 1876 int i, err_cnt = 0, pass_cnt = 0; 1877 1878 for (i = 0; i < ARRAY_SIZE(tests); i++) { 1879 struct sk_filter *fp; 1880 int err; 1881 1882 pr_info("#%d %s ", i, tests[i].descr); 1883 1884 fp = generate_filter(i, &err); 1885 if (fp == NULL) { 1886 if (err == 0) { 1887 pass_cnt++; 1888 continue; 1889 } 1890 1891 return err; 1892 } 1893 err = run_one(fp, &tests[i]); 1894 release_filter(fp, i); 1895 1896 if (err) { 1897 pr_cont("FAIL (%d times)\n", err); 1898 err_cnt++; 1899 } else { 1900 pr_cont("PASS\n"); 1901 pass_cnt++; 1902 } 1903 } 1904 1905 pr_info("Summary: %d PASSED, %d FAILED\n", pass_cnt, err_cnt); 1906 return err_cnt ? -EINVAL : 0; 1907 } 1908 1909 static int __init test_bpf_init(void) 1910 { 1911 return test_bpf(); 1912 } 1913 1914 static void __exit test_bpf_exit(void) 1915 { 1916 } 1917 1918 module_init(test_bpf_init); 1919 module_exit(test_bpf_exit); 1920 1921 MODULE_LICENSE("GPL"); 1922