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 #define MAX_SUBTESTS 3 26 #define MAX_DATA 128 27 #define MAX_INSNS 512 28 #define MAX_K 0xffffFFFF 29 30 /* define few constants used to init test 'skb' */ 31 #define SKB_TYPE 3 32 #define SKB_MARK 0x1234aaaa 33 #define SKB_HASH 0x1234aaab 34 #define SKB_QUEUE_MAP 123 35 #define SKB_VLAN_TCI 0xffff 36 #define SKB_DEV_IFINDEX 577 37 #define SKB_DEV_TYPE 588 38 39 /* redefine REGs to make tests less verbose */ 40 #define R0 BPF_REG_0 41 #define R1 BPF_REG_1 42 #define R2 BPF_REG_2 43 #define R3 BPF_REG_3 44 #define R4 BPF_REG_4 45 #define R5 BPF_REG_5 46 #define R6 BPF_REG_6 47 #define R7 BPF_REG_7 48 #define R8 BPF_REG_8 49 #define R9 BPF_REG_9 50 #define R10 BPF_REG_10 51 52 struct bpf_test { 53 const char *descr; 54 union { 55 struct sock_filter insns[MAX_INSNS]; 56 struct sock_filter_int insns_int[MAX_INSNS]; 57 }; 58 enum { 59 NO_DATA, 60 EXPECTED_FAIL, 61 SKB, 62 SKB_INT 63 } data_type; 64 __u8 data[MAX_DATA]; 65 struct { 66 int data_size; 67 __u32 result; 68 } test[MAX_SUBTESTS]; 69 }; 70 71 static struct bpf_test tests[] = { 72 { 73 "TAX", 74 .insns = { 75 BPF_STMT(BPF_LD | BPF_IMM, 1), 76 BPF_STMT(BPF_MISC | BPF_TAX, 0), 77 BPF_STMT(BPF_LD | BPF_IMM, 2), 78 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 79 BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */ 80 BPF_STMT(BPF_MISC | BPF_TAX, 0), 81 BPF_STMT(BPF_LD | BPF_LEN, 0), 82 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 83 BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */ 84 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1), 85 BPF_STMT(BPF_RET | BPF_A, 0) 86 }, 87 SKB, 88 { 10, 20, 30, 40, 50 }, 89 { { 2, 10 }, { 3, 20 }, { 4, 30 } }, 90 }, 91 { 92 "TXA", 93 .insns = { 94 BPF_STMT(BPF_LDX | BPF_LEN, 0), 95 BPF_STMT(BPF_MISC | BPF_TXA, 0), 96 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 97 BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */ 98 }, 99 SKB, 100 { 10, 20, 30, 40, 50 }, 101 { { 1, 2 }, { 3, 6 }, { 4, 8 } }, 102 }, 103 { 104 "ADD_SUB_MUL_K", 105 .insns = { 106 BPF_STMT(BPF_LD | BPF_IMM, 1), 107 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2), 108 BPF_STMT(BPF_LDX | BPF_IMM, 3), 109 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 110 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff), 111 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3), 112 BPF_STMT(BPF_RET | BPF_A, 0) 113 }, 114 0, 115 { }, 116 { { 0, 0xfffffffd } } 117 }, 118 { 119 "DIV_KX", 120 .insns = { 121 BPF_STMT(BPF_LD | BPF_IMM, 8), 122 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2), 123 BPF_STMT(BPF_MISC | BPF_TAX, 0), 124 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 125 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0), 126 BPF_STMT(BPF_MISC | BPF_TAX, 0), 127 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 128 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000), 129 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 130 BPF_STMT(BPF_RET | BPF_A, 0) 131 }, 132 0, 133 { }, 134 { { 0, 0x40000001 } } 135 }, 136 { 137 "AND_OR_LSH_K", 138 .insns = { 139 BPF_STMT(BPF_LD | BPF_IMM, 0xff), 140 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0), 141 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27), 142 BPF_STMT(BPF_MISC | BPF_TAX, 0), 143 BPF_STMT(BPF_LD | BPF_IMM, 0xf), 144 BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0), 145 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 146 BPF_STMT(BPF_RET | BPF_A, 0) 147 }, 148 0, 149 { }, 150 { { 0, 0x800000ff }, { 1, 0x800000ff } }, 151 }, 152 { 153 "LD_IND", 154 .insns = { 155 BPF_STMT(BPF_LDX | BPF_LEN, 0), 156 BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K), 157 BPF_STMT(BPF_RET | BPF_K, 1) 158 }, 159 SKB, 160 { }, 161 { { 1, 0 }, { 10, 0 }, { 60, 0 } }, 162 }, 163 { 164 "LD_ABS", 165 .insns = { 166 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000), 167 BPF_STMT(BPF_RET | BPF_K, 1) 168 }, 169 SKB, 170 { }, 171 { { 1, 0 }, { 10, 0 }, { 60, 0 } }, 172 }, 173 { 174 "LD_ABS_LL", 175 .insns = { 176 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF), 177 BPF_STMT(BPF_MISC | BPF_TAX, 0), 178 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1), 179 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 180 BPF_STMT(BPF_RET | BPF_A, 0) 181 }, 182 SKB, 183 { 1, 2, 3 }, 184 { { 1, 0 }, { 2, 3 } }, 185 }, 186 { 187 "LD_IND_LL", 188 .insns = { 189 BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1), 190 BPF_STMT(BPF_LDX | BPF_LEN, 0), 191 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 192 BPF_STMT(BPF_MISC | BPF_TAX, 0), 193 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0), 194 BPF_STMT(BPF_RET | BPF_A, 0) 195 }, 196 SKB, 197 { 1, 2, 3, 0xff }, 198 { { 1, 1 }, { 3, 3 }, { 4, 0xff } }, 199 }, 200 { 201 "LD_ABS_NET", 202 .insns = { 203 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF), 204 BPF_STMT(BPF_MISC | BPF_TAX, 0), 205 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1), 206 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 207 BPF_STMT(BPF_RET | BPF_A, 0) 208 }, 209 SKB, 210 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 }, 211 { { 15, 0 }, { 16, 3 } }, 212 }, 213 { 214 "LD_IND_NET", 215 .insns = { 216 BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15), 217 BPF_STMT(BPF_LDX | BPF_LEN, 0), 218 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 219 BPF_STMT(BPF_MISC | BPF_TAX, 0), 220 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0), 221 BPF_STMT(BPF_RET | BPF_A, 0) 222 }, 223 SKB, 224 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 }, 225 { { 14, 0 }, { 15, 1 }, { 17, 3 } }, 226 }, 227 { 228 "LD_PKTTYPE", 229 .insns = { 230 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 231 SKF_AD_OFF + SKF_AD_PKTTYPE), 232 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 233 BPF_STMT(BPF_RET | BPF_K, 1), 234 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 235 SKF_AD_OFF + SKF_AD_PKTTYPE), 236 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 237 BPF_STMT(BPF_RET | BPF_K, 1), 238 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 239 SKF_AD_OFF + SKF_AD_PKTTYPE), 240 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 241 BPF_STMT(BPF_RET | BPF_K, 1), 242 BPF_STMT(BPF_RET | BPF_A, 0) 243 }, 244 SKB, 245 { }, 246 { { 1, 3 }, { 10, 3 } }, 247 }, 248 { 249 "LD_MARK", 250 .insns = { 251 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 252 SKF_AD_OFF + SKF_AD_MARK), 253 BPF_STMT(BPF_RET | BPF_A, 0) 254 }, 255 SKB, 256 { }, 257 { { 1, SKB_MARK}, { 10, SKB_MARK} }, 258 }, 259 { 260 "LD_RXHASH", 261 .insns = { 262 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 263 SKF_AD_OFF + SKF_AD_RXHASH), 264 BPF_STMT(BPF_RET | BPF_A, 0) 265 }, 266 SKB, 267 { }, 268 { { 1, SKB_HASH}, { 10, SKB_HASH} }, 269 }, 270 { 271 "LD_QUEUE", 272 .insns = { 273 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 274 SKF_AD_OFF + SKF_AD_QUEUE), 275 BPF_STMT(BPF_RET | BPF_A, 0) 276 }, 277 SKB, 278 { }, 279 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } }, 280 }, 281 { 282 "LD_PROTOCOL", 283 .insns = { 284 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1), 285 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0), 286 BPF_STMT(BPF_RET | BPF_K, 0), 287 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 288 SKF_AD_OFF + SKF_AD_PROTOCOL), 289 BPF_STMT(BPF_MISC | BPF_TAX, 0), 290 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 291 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0), 292 BPF_STMT(BPF_RET | BPF_K, 0), 293 BPF_STMT(BPF_MISC | BPF_TXA, 0), 294 BPF_STMT(BPF_RET | BPF_A, 0) 295 }, 296 SKB, 297 { 10, 20, 30 }, 298 { { 10, ETH_P_IP }, { 100, ETH_P_IP } }, 299 }, 300 { 301 "LD_VLAN_TAG", 302 .insns = { 303 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 304 SKF_AD_OFF + SKF_AD_VLAN_TAG), 305 BPF_STMT(BPF_RET | BPF_A, 0) 306 }, 307 SKB, 308 { }, 309 { 310 { 1, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT }, 311 { 10, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT } 312 }, 313 }, 314 { 315 "LD_VLAN_TAG_PRESENT", 316 .insns = { 317 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 318 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT), 319 BPF_STMT(BPF_RET | BPF_A, 0) 320 }, 321 SKB, 322 { }, 323 { 324 { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }, 325 { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) } 326 }, 327 }, 328 { 329 "LD_IFINDEX", 330 .insns = { 331 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 332 SKF_AD_OFF + SKF_AD_IFINDEX), 333 BPF_STMT(BPF_RET | BPF_A, 0) 334 }, 335 SKB, 336 { }, 337 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } }, 338 }, 339 { 340 "LD_HATYPE", 341 .insns = { 342 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 343 SKF_AD_OFF + SKF_AD_HATYPE), 344 BPF_STMT(BPF_RET | BPF_A, 0) 345 }, 346 SKB, 347 { }, 348 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } }, 349 }, 350 { 351 "LD_CPU", 352 .insns = { 353 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 354 SKF_AD_OFF + SKF_AD_CPU), 355 BPF_STMT(BPF_MISC | BPF_TAX, 0), 356 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 357 SKF_AD_OFF + SKF_AD_CPU), 358 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 359 BPF_STMT(BPF_RET | BPF_A, 0) 360 }, 361 SKB, 362 { }, 363 { { 1, 0 }, { 10, 0 } }, 364 }, 365 { 366 "LD_NLATTR", 367 .insns = { 368 BPF_STMT(BPF_LDX | BPF_IMM, 1), 369 BPF_STMT(BPF_MISC | BPF_TXA, 0), 370 BPF_STMT(BPF_LDX | BPF_IMM, 3), 371 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 372 SKF_AD_OFF + SKF_AD_NLATTR), 373 BPF_STMT(BPF_RET | BPF_A, 0) 374 }, 375 SKB, 376 { 0xff, 4, 0, 2, 0, 4, 0, 3, 0 }, 377 { { 4, 0 }, { 20, 5 } }, 378 }, 379 { 380 "LD_NLATTR_NEST", 381 .insns = { 382 BPF_STMT(BPF_LD | BPF_IMM, 1), 383 BPF_STMT(BPF_LDX | BPF_IMM, 3), 384 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 385 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 386 BPF_STMT(BPF_LD | BPF_IMM, 1), 387 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 388 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 389 BPF_STMT(BPF_LD | BPF_IMM, 1), 390 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 391 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 392 BPF_STMT(BPF_LD | BPF_IMM, 1), 393 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 394 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 395 BPF_STMT(BPF_LD | BPF_IMM, 1), 396 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 397 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 398 BPF_STMT(BPF_LD | BPF_IMM, 1), 399 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 400 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 401 BPF_STMT(BPF_LD | BPF_IMM, 1), 402 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 403 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 404 BPF_STMT(BPF_LD | BPF_IMM, 1), 405 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 406 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 407 BPF_STMT(BPF_RET | BPF_A, 0) 408 }, 409 SKB, 410 { 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 }, 411 { { 4, 0 }, { 20, 9 } }, 412 }, 413 { 414 "LD_PAYLOAD_OFF", 415 .insns = { 416 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 417 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 418 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 419 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 420 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 421 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 422 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 423 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 424 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 425 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 426 BPF_STMT(BPF_RET | BPF_A, 0) 427 }, 428 SKB, 429 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800), 430 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request, 431 * id 9737, seq 1, length 64 432 */ 433 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 434 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 435 0x08, 0x00, 436 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40, 437 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 }, 438 { { 30, 0 }, { 100, 42 } }, 439 }, 440 { 441 "LD_ANC_XOR", 442 .insns = { 443 BPF_STMT(BPF_LD | BPF_IMM, 10), 444 BPF_STMT(BPF_LDX | BPF_IMM, 300), 445 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 446 SKF_AD_OFF + SKF_AD_ALU_XOR_X), 447 BPF_STMT(BPF_RET | BPF_A, 0) 448 }, 449 SKB, 450 { }, 451 { { 4, 10 ^ 300 }, { 20, 10 ^ 300 } }, 452 }, 453 { 454 "SPILL_FILL", 455 .insns = { 456 BPF_STMT(BPF_LDX | BPF_LEN, 0), 457 BPF_STMT(BPF_LD | BPF_IMM, 2), 458 BPF_STMT(BPF_ALU | BPF_RSH, 1), 459 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 460 BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */ 461 BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000), 462 BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */ 463 BPF_STMT(BPF_STX, 15), /* M3 = len */ 464 BPF_STMT(BPF_LDX | BPF_MEM, 1), 465 BPF_STMT(BPF_LD | BPF_MEM, 2), 466 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 467 BPF_STMT(BPF_LDX | BPF_MEM, 15), 468 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 469 BPF_STMT(BPF_RET | BPF_A, 0) 470 }, 471 SKB, 472 { }, 473 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } } 474 }, 475 { 476 "JEQ", 477 .insns = { 478 BPF_STMT(BPF_LDX | BPF_LEN, 0), 479 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 480 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1), 481 BPF_STMT(BPF_RET | BPF_K, 1), 482 BPF_STMT(BPF_RET | BPF_K, MAX_K) 483 }, 484 SKB, 485 { 3, 3, 3, 3, 3 }, 486 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } }, 487 }, 488 { 489 "JGT", 490 .insns = { 491 BPF_STMT(BPF_LDX | BPF_LEN, 0), 492 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 493 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1), 494 BPF_STMT(BPF_RET | BPF_K, 1), 495 BPF_STMT(BPF_RET | BPF_K, MAX_K) 496 }, 497 SKB, 498 { 4, 4, 4, 3, 3 }, 499 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } }, 500 }, 501 { 502 "JGE", 503 .insns = { 504 BPF_STMT(BPF_LDX | BPF_LEN, 0), 505 BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K), 506 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0), 507 BPF_STMT(BPF_RET | BPF_K, 10), 508 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0), 509 BPF_STMT(BPF_RET | BPF_K, 20), 510 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0), 511 BPF_STMT(BPF_RET | BPF_K, 30), 512 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0), 513 BPF_STMT(BPF_RET | BPF_K, 40), 514 BPF_STMT(BPF_RET | BPF_K, MAX_K) 515 }, 516 SKB, 517 { 1, 2, 3, 4, 5 }, 518 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } }, 519 }, 520 { 521 "JSET", 522 .insns = { 523 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 524 BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1), 525 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 526 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 527 BPF_STMT(BPF_LDX | BPF_LEN, 0), 528 BPF_STMT(BPF_MISC | BPF_TXA, 0), 529 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4), 530 BPF_STMT(BPF_MISC | BPF_TAX, 0), 531 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0), 532 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1), 533 BPF_STMT(BPF_RET | BPF_K, 10), 534 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1), 535 BPF_STMT(BPF_RET | BPF_K, 20), 536 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 537 BPF_STMT(BPF_RET | BPF_K, 30), 538 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 539 BPF_STMT(BPF_RET | BPF_K, 30), 540 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 541 BPF_STMT(BPF_RET | BPF_K, 30), 542 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 543 BPF_STMT(BPF_RET | BPF_K, 30), 544 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 545 BPF_STMT(BPF_RET | BPF_K, 30), 546 BPF_STMT(BPF_RET | BPF_K, MAX_K) 547 }, 548 SKB, 549 { 0, 0xAA, 0x55, 1 }, 550 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } }, 551 }, 552 { 553 "tcpdump port 22", 554 .insns = { 555 { 0x28, 0, 0, 0x0000000c }, 556 { 0x15, 0, 8, 0x000086dd }, 557 { 0x30, 0, 0, 0x00000014 }, 558 { 0x15, 2, 0, 0x00000084 }, 559 { 0x15, 1, 0, 0x00000006 }, 560 { 0x15, 0, 17, 0x00000011 }, 561 { 0x28, 0, 0, 0x00000036 }, 562 { 0x15, 14, 0, 0x00000016 }, 563 { 0x28, 0, 0, 0x00000038 }, 564 { 0x15, 12, 13, 0x00000016 }, 565 { 0x15, 0, 12, 0x00000800 }, 566 { 0x30, 0, 0, 0x00000017 }, 567 { 0x15, 2, 0, 0x00000084 }, 568 { 0x15, 1, 0, 0x00000006 }, 569 { 0x15, 0, 8, 0x00000011 }, 570 { 0x28, 0, 0, 0x00000014 }, 571 { 0x45, 6, 0, 0x00001fff }, 572 { 0xb1, 0, 0, 0x0000000e }, 573 { 0x48, 0, 0, 0x0000000e }, 574 { 0x15, 2, 0, 0x00000016 }, 575 { 0x48, 0, 0, 0x00000010 }, 576 { 0x15, 0, 1, 0x00000016 }, 577 { 0x06, 0, 0, 0x0000ffff }, 578 { 0x06, 0, 0, 0x00000000 }, 579 }, 580 SKB, 581 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800) 582 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.], 583 * seq 1305692979:1305693027, ack 3650467037, win 65535, 584 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48 585 */ 586 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6, 587 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76, 588 0x08, 0x00, 589 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5, 590 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */ 591 0x0a, 0x01, 0x01, 0x95, /* ip src */ 592 0x0a, 0x01, 0x02, 0x0a, /* ip dst */ 593 0xc2, 0x24, 594 0x00, 0x16 /* dst port */ }, 595 { { 10, 0 }, { 30, 0 }, { 100, 65535 } }, 596 }, 597 { 598 "tcpdump complex", 599 .insns = { 600 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] - 601 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and 602 * (len > 115 or len < 30000000000)' -d 603 */ 604 { 0x28, 0, 0, 0x0000000c }, 605 { 0x15, 30, 0, 0x000086dd }, 606 { 0x15, 0, 29, 0x00000800 }, 607 { 0x30, 0, 0, 0x00000017 }, 608 { 0x15, 0, 27, 0x00000006 }, 609 { 0x28, 0, 0, 0x00000014 }, 610 { 0x45, 25, 0, 0x00001fff }, 611 { 0xb1, 0, 0, 0x0000000e }, 612 { 0x48, 0, 0, 0x0000000e }, 613 { 0x15, 2, 0, 0x00000016 }, 614 { 0x48, 0, 0, 0x00000010 }, 615 { 0x15, 0, 20, 0x00000016 }, 616 { 0x28, 0, 0, 0x00000010 }, 617 { 0x02, 0, 0, 0x00000001 }, 618 { 0x30, 0, 0, 0x0000000e }, 619 { 0x54, 0, 0, 0x0000000f }, 620 { 0x64, 0, 0, 0x00000002 }, 621 { 0x07, 0, 0, 0x00000005 }, 622 { 0x60, 0, 0, 0x00000001 }, 623 { 0x1c, 0, 0, 0x00000000 }, 624 { 0x02, 0, 0, 0x00000005 }, 625 { 0xb1, 0, 0, 0x0000000e }, 626 { 0x50, 0, 0, 0x0000001a }, 627 { 0x54, 0, 0, 0x000000f0 }, 628 { 0x74, 0, 0, 0x00000002 }, 629 { 0x07, 0, 0, 0x00000009 }, 630 { 0x60, 0, 0, 0x00000005 }, 631 { 0x1d, 4, 0, 0x00000000 }, 632 { 0x80, 0, 0, 0x00000000 }, 633 { 0x25, 1, 0, 0x00000073 }, 634 { 0x35, 1, 0, 0xfc23ac00 }, 635 { 0x06, 0, 0, 0x0000ffff }, 636 { 0x06, 0, 0, 0x00000000 }, 637 }, 638 SKB, 639 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6, 640 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76, 641 0x08, 0x00, 642 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5, 643 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */ 644 0x0a, 0x01, 0x01, 0x95, /* ip src */ 645 0x0a, 0x01, 0x02, 0x0a, /* ip dst */ 646 0xc2, 0x24, 647 0x00, 0x16 /* dst port */ }, 648 { { 10, 0 }, { 30, 0 }, { 100, 65535 } }, 649 }, 650 { 651 "RET_A", 652 .insns = { 653 /* check that unitialized X and A contain zeros */ 654 BPF_STMT(BPF_MISC | BPF_TXA, 0), 655 BPF_STMT(BPF_RET | BPF_A, 0) 656 }, 657 SKB, 658 {}, 659 { {1, 0}, {2, 0} }, 660 }, 661 { 662 "INT: ADD trivial", 663 .insns_int = { 664 BPF_ALU64_IMM(BPF_MOV, R1, 1), 665 BPF_ALU64_IMM(BPF_ADD, R1, 2), 666 BPF_ALU64_IMM(BPF_MOV, R2, 3), 667 BPF_ALU64_REG(BPF_SUB, R1, R2), 668 BPF_ALU64_IMM(BPF_ADD, R1, -1), 669 BPF_ALU64_IMM(BPF_MUL, R1, 3), 670 BPF_ALU64_REG(BPF_MOV, R0, R1), 671 BPF_EXIT_INSN(), 672 }, 673 SKB_INT, 674 { }, 675 { { 0, 0xfffffffd } } 676 }, 677 { 678 "INT: MUL_X", 679 .insns_int = { 680 BPF_ALU64_IMM(BPF_MOV, R0, -1), 681 BPF_ALU64_IMM(BPF_MOV, R1, -1), 682 BPF_ALU64_IMM(BPF_MOV, R2, 3), 683 BPF_ALU64_REG(BPF_MUL, R1, R2), 684 BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1), 685 BPF_EXIT_INSN(), 686 BPF_ALU64_IMM(BPF_MOV, R0, 1), 687 BPF_EXIT_INSN(), 688 }, 689 SKB_INT, 690 { }, 691 { { 0, 1 } } 692 }, 693 { 694 "INT: MUL_X2", 695 .insns_int = { 696 BPF_ALU32_IMM(BPF_MOV, R0, -1), 697 BPF_ALU32_IMM(BPF_MOV, R1, -1), 698 BPF_ALU32_IMM(BPF_MOV, R2, 3), 699 BPF_ALU64_REG(BPF_MUL, R1, R2), 700 BPF_ALU64_IMM(BPF_RSH, R1, 8), 701 BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1), 702 BPF_EXIT_INSN(), 703 BPF_ALU32_IMM(BPF_MOV, R0, 1), 704 BPF_EXIT_INSN(), 705 }, 706 SKB_INT, 707 { }, 708 { { 0, 1 } } 709 }, 710 { 711 "INT: MUL32_X", 712 .insns_int = { 713 BPF_ALU32_IMM(BPF_MOV, R0, -1), 714 BPF_ALU64_IMM(BPF_MOV, R1, -1), 715 BPF_ALU32_IMM(BPF_MOV, R2, 3), 716 BPF_ALU32_REG(BPF_MUL, R1, R2), 717 BPF_ALU64_IMM(BPF_RSH, R1, 8), 718 BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1), 719 BPF_EXIT_INSN(), 720 BPF_ALU32_IMM(BPF_MOV, R0, 1), 721 BPF_EXIT_INSN(), 722 }, 723 SKB_INT, 724 { }, 725 { { 0, 1 } } 726 }, 727 { 728 /* Have to test all register combinations, since 729 * JITing of different registers will produce 730 * different asm code. 731 */ 732 "INT: ADD 64-bit", 733 .insns_int = { 734 BPF_ALU64_IMM(BPF_MOV, R0, 0), 735 BPF_ALU64_IMM(BPF_MOV, R1, 1), 736 BPF_ALU64_IMM(BPF_MOV, R2, 2), 737 BPF_ALU64_IMM(BPF_MOV, R3, 3), 738 BPF_ALU64_IMM(BPF_MOV, R4, 4), 739 BPF_ALU64_IMM(BPF_MOV, R5, 5), 740 BPF_ALU64_IMM(BPF_MOV, R6, 6), 741 BPF_ALU64_IMM(BPF_MOV, R7, 7), 742 BPF_ALU64_IMM(BPF_MOV, R8, 8), 743 BPF_ALU64_IMM(BPF_MOV, R9, 9), 744 BPF_ALU64_IMM(BPF_ADD, R0, 20), 745 BPF_ALU64_IMM(BPF_ADD, R1, 20), 746 BPF_ALU64_IMM(BPF_ADD, R2, 20), 747 BPF_ALU64_IMM(BPF_ADD, R3, 20), 748 BPF_ALU64_IMM(BPF_ADD, R4, 20), 749 BPF_ALU64_IMM(BPF_ADD, R5, 20), 750 BPF_ALU64_IMM(BPF_ADD, R6, 20), 751 BPF_ALU64_IMM(BPF_ADD, R7, 20), 752 BPF_ALU64_IMM(BPF_ADD, R8, 20), 753 BPF_ALU64_IMM(BPF_ADD, R9, 20), 754 BPF_ALU64_IMM(BPF_SUB, R0, 10), 755 BPF_ALU64_IMM(BPF_SUB, R1, 10), 756 BPF_ALU64_IMM(BPF_SUB, R2, 10), 757 BPF_ALU64_IMM(BPF_SUB, R3, 10), 758 BPF_ALU64_IMM(BPF_SUB, R4, 10), 759 BPF_ALU64_IMM(BPF_SUB, R5, 10), 760 BPF_ALU64_IMM(BPF_SUB, R6, 10), 761 BPF_ALU64_IMM(BPF_SUB, R7, 10), 762 BPF_ALU64_IMM(BPF_SUB, R8, 10), 763 BPF_ALU64_IMM(BPF_SUB, R9, 10), 764 BPF_ALU64_REG(BPF_ADD, R0, R0), 765 BPF_ALU64_REG(BPF_ADD, R0, R1), 766 BPF_ALU64_REG(BPF_ADD, R0, R2), 767 BPF_ALU64_REG(BPF_ADD, R0, R3), 768 BPF_ALU64_REG(BPF_ADD, R0, R4), 769 BPF_ALU64_REG(BPF_ADD, R0, R5), 770 BPF_ALU64_REG(BPF_ADD, R0, R6), 771 BPF_ALU64_REG(BPF_ADD, R0, R7), 772 BPF_ALU64_REG(BPF_ADD, R0, R8), 773 BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */ 774 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1), 775 BPF_EXIT_INSN(), 776 BPF_ALU64_REG(BPF_ADD, R1, R0), 777 BPF_ALU64_REG(BPF_ADD, R1, R1), 778 BPF_ALU64_REG(BPF_ADD, R1, R2), 779 BPF_ALU64_REG(BPF_ADD, R1, R3), 780 BPF_ALU64_REG(BPF_ADD, R1, R4), 781 BPF_ALU64_REG(BPF_ADD, R1, R5), 782 BPF_ALU64_REG(BPF_ADD, R1, R6), 783 BPF_ALU64_REG(BPF_ADD, R1, R7), 784 BPF_ALU64_REG(BPF_ADD, R1, R8), 785 BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */ 786 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1), 787 BPF_EXIT_INSN(), 788 BPF_ALU64_REG(BPF_ADD, R2, R0), 789 BPF_ALU64_REG(BPF_ADD, R2, R1), 790 BPF_ALU64_REG(BPF_ADD, R2, R2), 791 BPF_ALU64_REG(BPF_ADD, R2, R3), 792 BPF_ALU64_REG(BPF_ADD, R2, R4), 793 BPF_ALU64_REG(BPF_ADD, R2, R5), 794 BPF_ALU64_REG(BPF_ADD, R2, R6), 795 BPF_ALU64_REG(BPF_ADD, R2, R7), 796 BPF_ALU64_REG(BPF_ADD, R2, R8), 797 BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */ 798 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1), 799 BPF_EXIT_INSN(), 800 BPF_ALU64_REG(BPF_ADD, R3, R0), 801 BPF_ALU64_REG(BPF_ADD, R3, R1), 802 BPF_ALU64_REG(BPF_ADD, R3, R2), 803 BPF_ALU64_REG(BPF_ADD, R3, R3), 804 BPF_ALU64_REG(BPF_ADD, R3, R4), 805 BPF_ALU64_REG(BPF_ADD, R3, R5), 806 BPF_ALU64_REG(BPF_ADD, R3, R6), 807 BPF_ALU64_REG(BPF_ADD, R3, R7), 808 BPF_ALU64_REG(BPF_ADD, R3, R8), 809 BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */ 810 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1), 811 BPF_EXIT_INSN(), 812 BPF_ALU64_REG(BPF_ADD, R4, R0), 813 BPF_ALU64_REG(BPF_ADD, R4, R1), 814 BPF_ALU64_REG(BPF_ADD, R4, R2), 815 BPF_ALU64_REG(BPF_ADD, R4, R3), 816 BPF_ALU64_REG(BPF_ADD, R4, R4), 817 BPF_ALU64_REG(BPF_ADD, R4, R5), 818 BPF_ALU64_REG(BPF_ADD, R4, R6), 819 BPF_ALU64_REG(BPF_ADD, R4, R7), 820 BPF_ALU64_REG(BPF_ADD, R4, R8), 821 BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */ 822 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1), 823 BPF_EXIT_INSN(), 824 BPF_ALU64_REG(BPF_ADD, R5, R0), 825 BPF_ALU64_REG(BPF_ADD, R5, R1), 826 BPF_ALU64_REG(BPF_ADD, R5, R2), 827 BPF_ALU64_REG(BPF_ADD, R5, R3), 828 BPF_ALU64_REG(BPF_ADD, R5, R4), 829 BPF_ALU64_REG(BPF_ADD, R5, R5), 830 BPF_ALU64_REG(BPF_ADD, R5, R6), 831 BPF_ALU64_REG(BPF_ADD, R5, R7), 832 BPF_ALU64_REG(BPF_ADD, R5, R8), 833 BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */ 834 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1), 835 BPF_EXIT_INSN(), 836 BPF_ALU64_REG(BPF_ADD, R6, R0), 837 BPF_ALU64_REG(BPF_ADD, R6, R1), 838 BPF_ALU64_REG(BPF_ADD, R6, R2), 839 BPF_ALU64_REG(BPF_ADD, R6, R3), 840 BPF_ALU64_REG(BPF_ADD, R6, R4), 841 BPF_ALU64_REG(BPF_ADD, R6, R5), 842 BPF_ALU64_REG(BPF_ADD, R6, R6), 843 BPF_ALU64_REG(BPF_ADD, R6, R7), 844 BPF_ALU64_REG(BPF_ADD, R6, R8), 845 BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */ 846 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1), 847 BPF_EXIT_INSN(), 848 BPF_ALU64_REG(BPF_ADD, R7, R0), 849 BPF_ALU64_REG(BPF_ADD, R7, R1), 850 BPF_ALU64_REG(BPF_ADD, R7, R2), 851 BPF_ALU64_REG(BPF_ADD, R7, R3), 852 BPF_ALU64_REG(BPF_ADD, R7, R4), 853 BPF_ALU64_REG(BPF_ADD, R7, R5), 854 BPF_ALU64_REG(BPF_ADD, R7, R6), 855 BPF_ALU64_REG(BPF_ADD, R7, R7), 856 BPF_ALU64_REG(BPF_ADD, R7, R8), 857 BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */ 858 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1), 859 BPF_EXIT_INSN(), 860 BPF_ALU64_REG(BPF_ADD, R8, R0), 861 BPF_ALU64_REG(BPF_ADD, R8, R1), 862 BPF_ALU64_REG(BPF_ADD, R8, R2), 863 BPF_ALU64_REG(BPF_ADD, R8, R3), 864 BPF_ALU64_REG(BPF_ADD, R8, R4), 865 BPF_ALU64_REG(BPF_ADD, R8, R5), 866 BPF_ALU64_REG(BPF_ADD, R8, R6), 867 BPF_ALU64_REG(BPF_ADD, R8, R7), 868 BPF_ALU64_REG(BPF_ADD, R8, R8), 869 BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */ 870 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1), 871 BPF_EXIT_INSN(), 872 BPF_ALU64_REG(BPF_ADD, R9, R0), 873 BPF_ALU64_REG(BPF_ADD, R9, R1), 874 BPF_ALU64_REG(BPF_ADD, R9, R2), 875 BPF_ALU64_REG(BPF_ADD, R9, R3), 876 BPF_ALU64_REG(BPF_ADD, R9, R4), 877 BPF_ALU64_REG(BPF_ADD, R9, R5), 878 BPF_ALU64_REG(BPF_ADD, R9, R6), 879 BPF_ALU64_REG(BPF_ADD, R9, R7), 880 BPF_ALU64_REG(BPF_ADD, R9, R8), 881 BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */ 882 BPF_ALU64_REG(BPF_MOV, R0, R9), 883 BPF_EXIT_INSN(), 884 }, 885 SKB_INT, 886 { }, 887 { { 0, 2957380 } } 888 }, 889 { 890 "INT: ADD 32-bit", 891 .insns_int = { 892 BPF_ALU32_IMM(BPF_MOV, R0, 20), 893 BPF_ALU32_IMM(BPF_MOV, R1, 1), 894 BPF_ALU32_IMM(BPF_MOV, R2, 2), 895 BPF_ALU32_IMM(BPF_MOV, R3, 3), 896 BPF_ALU32_IMM(BPF_MOV, R4, 4), 897 BPF_ALU32_IMM(BPF_MOV, R5, 5), 898 BPF_ALU32_IMM(BPF_MOV, R6, 6), 899 BPF_ALU32_IMM(BPF_MOV, R7, 7), 900 BPF_ALU32_IMM(BPF_MOV, R8, 8), 901 BPF_ALU32_IMM(BPF_MOV, R9, 9), 902 BPF_ALU64_IMM(BPF_ADD, R1, 10), 903 BPF_ALU64_IMM(BPF_ADD, R2, 10), 904 BPF_ALU64_IMM(BPF_ADD, R3, 10), 905 BPF_ALU64_IMM(BPF_ADD, R4, 10), 906 BPF_ALU64_IMM(BPF_ADD, R5, 10), 907 BPF_ALU64_IMM(BPF_ADD, R6, 10), 908 BPF_ALU64_IMM(BPF_ADD, R7, 10), 909 BPF_ALU64_IMM(BPF_ADD, R8, 10), 910 BPF_ALU64_IMM(BPF_ADD, R9, 10), 911 BPF_ALU32_REG(BPF_ADD, R0, R1), 912 BPF_ALU32_REG(BPF_ADD, R0, R2), 913 BPF_ALU32_REG(BPF_ADD, R0, R3), 914 BPF_ALU32_REG(BPF_ADD, R0, R4), 915 BPF_ALU32_REG(BPF_ADD, R0, R5), 916 BPF_ALU32_REG(BPF_ADD, R0, R6), 917 BPF_ALU32_REG(BPF_ADD, R0, R7), 918 BPF_ALU32_REG(BPF_ADD, R0, R8), 919 BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */ 920 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1), 921 BPF_EXIT_INSN(), 922 BPF_ALU32_REG(BPF_ADD, R1, R0), 923 BPF_ALU32_REG(BPF_ADD, R1, R1), 924 BPF_ALU32_REG(BPF_ADD, R1, R2), 925 BPF_ALU32_REG(BPF_ADD, R1, R3), 926 BPF_ALU32_REG(BPF_ADD, R1, R4), 927 BPF_ALU32_REG(BPF_ADD, R1, R5), 928 BPF_ALU32_REG(BPF_ADD, R1, R6), 929 BPF_ALU32_REG(BPF_ADD, R1, R7), 930 BPF_ALU32_REG(BPF_ADD, R1, R8), 931 BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */ 932 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1), 933 BPF_EXIT_INSN(), 934 BPF_ALU32_REG(BPF_ADD, R2, R0), 935 BPF_ALU32_REG(BPF_ADD, R2, R1), 936 BPF_ALU32_REG(BPF_ADD, R2, R2), 937 BPF_ALU32_REG(BPF_ADD, R2, R3), 938 BPF_ALU32_REG(BPF_ADD, R2, R4), 939 BPF_ALU32_REG(BPF_ADD, R2, R5), 940 BPF_ALU32_REG(BPF_ADD, R2, R6), 941 BPF_ALU32_REG(BPF_ADD, R2, R7), 942 BPF_ALU32_REG(BPF_ADD, R2, R8), 943 BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */ 944 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1), 945 BPF_EXIT_INSN(), 946 BPF_ALU32_REG(BPF_ADD, R3, R0), 947 BPF_ALU32_REG(BPF_ADD, R3, R1), 948 BPF_ALU32_REG(BPF_ADD, R3, R2), 949 BPF_ALU32_REG(BPF_ADD, R3, R3), 950 BPF_ALU32_REG(BPF_ADD, R3, R4), 951 BPF_ALU32_REG(BPF_ADD, R3, R5), 952 BPF_ALU32_REG(BPF_ADD, R3, R6), 953 BPF_ALU32_REG(BPF_ADD, R3, R7), 954 BPF_ALU32_REG(BPF_ADD, R3, R8), 955 BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */ 956 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1), 957 BPF_EXIT_INSN(), 958 BPF_ALU32_REG(BPF_ADD, R4, R0), 959 BPF_ALU32_REG(BPF_ADD, R4, R1), 960 BPF_ALU32_REG(BPF_ADD, R4, R2), 961 BPF_ALU32_REG(BPF_ADD, R4, R3), 962 BPF_ALU32_REG(BPF_ADD, R4, R4), 963 BPF_ALU32_REG(BPF_ADD, R4, R5), 964 BPF_ALU32_REG(BPF_ADD, R4, R6), 965 BPF_ALU32_REG(BPF_ADD, R4, R7), 966 BPF_ALU32_REG(BPF_ADD, R4, R8), 967 BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */ 968 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1), 969 BPF_EXIT_INSN(), 970 BPF_ALU32_REG(BPF_ADD, R5, R0), 971 BPF_ALU32_REG(BPF_ADD, R5, R1), 972 BPF_ALU32_REG(BPF_ADD, R5, R2), 973 BPF_ALU32_REG(BPF_ADD, R5, R3), 974 BPF_ALU32_REG(BPF_ADD, R5, R4), 975 BPF_ALU32_REG(BPF_ADD, R5, R5), 976 BPF_ALU32_REG(BPF_ADD, R5, R6), 977 BPF_ALU32_REG(BPF_ADD, R5, R7), 978 BPF_ALU32_REG(BPF_ADD, R5, R8), 979 BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */ 980 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1), 981 BPF_EXIT_INSN(), 982 BPF_ALU32_REG(BPF_ADD, R6, R0), 983 BPF_ALU32_REG(BPF_ADD, R6, R1), 984 BPF_ALU32_REG(BPF_ADD, R6, R2), 985 BPF_ALU32_REG(BPF_ADD, R6, R3), 986 BPF_ALU32_REG(BPF_ADD, R6, R4), 987 BPF_ALU32_REG(BPF_ADD, R6, R5), 988 BPF_ALU32_REG(BPF_ADD, R6, R6), 989 BPF_ALU32_REG(BPF_ADD, R6, R7), 990 BPF_ALU32_REG(BPF_ADD, R6, R8), 991 BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */ 992 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1), 993 BPF_EXIT_INSN(), 994 BPF_ALU32_REG(BPF_ADD, R7, R0), 995 BPF_ALU32_REG(BPF_ADD, R7, R1), 996 BPF_ALU32_REG(BPF_ADD, R7, R2), 997 BPF_ALU32_REG(BPF_ADD, R7, R3), 998 BPF_ALU32_REG(BPF_ADD, R7, R4), 999 BPF_ALU32_REG(BPF_ADD, R7, R5), 1000 BPF_ALU32_REG(BPF_ADD, R7, R6), 1001 BPF_ALU32_REG(BPF_ADD, R7, R7), 1002 BPF_ALU32_REG(BPF_ADD, R7, R8), 1003 BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */ 1004 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1), 1005 BPF_EXIT_INSN(), 1006 BPF_ALU32_REG(BPF_ADD, R8, R0), 1007 BPF_ALU32_REG(BPF_ADD, R8, R1), 1008 BPF_ALU32_REG(BPF_ADD, R8, R2), 1009 BPF_ALU32_REG(BPF_ADD, R8, R3), 1010 BPF_ALU32_REG(BPF_ADD, R8, R4), 1011 BPF_ALU32_REG(BPF_ADD, R8, R5), 1012 BPF_ALU32_REG(BPF_ADD, R8, R6), 1013 BPF_ALU32_REG(BPF_ADD, R8, R7), 1014 BPF_ALU32_REG(BPF_ADD, R8, R8), 1015 BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */ 1016 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1), 1017 BPF_EXIT_INSN(), 1018 BPF_ALU32_REG(BPF_ADD, R9, R0), 1019 BPF_ALU32_REG(BPF_ADD, R9, R1), 1020 BPF_ALU32_REG(BPF_ADD, R9, R2), 1021 BPF_ALU32_REG(BPF_ADD, R9, R3), 1022 BPF_ALU32_REG(BPF_ADD, R9, R4), 1023 BPF_ALU32_REG(BPF_ADD, R9, R5), 1024 BPF_ALU32_REG(BPF_ADD, R9, R6), 1025 BPF_ALU32_REG(BPF_ADD, R9, R7), 1026 BPF_ALU32_REG(BPF_ADD, R9, R8), 1027 BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */ 1028 BPF_ALU32_REG(BPF_MOV, R0, R9), 1029 BPF_EXIT_INSN(), 1030 }, 1031 SKB_INT, 1032 { }, 1033 { { 0, 2957380 } } 1034 }, 1035 { /* Mainly checking JIT here. */ 1036 "INT: SUB", 1037 .insns_int = { 1038 BPF_ALU64_IMM(BPF_MOV, R0, 0), 1039 BPF_ALU64_IMM(BPF_MOV, R1, 1), 1040 BPF_ALU64_IMM(BPF_MOV, R2, 2), 1041 BPF_ALU64_IMM(BPF_MOV, R3, 3), 1042 BPF_ALU64_IMM(BPF_MOV, R4, 4), 1043 BPF_ALU64_IMM(BPF_MOV, R5, 5), 1044 BPF_ALU64_IMM(BPF_MOV, R6, 6), 1045 BPF_ALU64_IMM(BPF_MOV, R7, 7), 1046 BPF_ALU64_IMM(BPF_MOV, R8, 8), 1047 BPF_ALU64_IMM(BPF_MOV, R9, 9), 1048 BPF_ALU64_REG(BPF_SUB, R0, R0), 1049 BPF_ALU64_REG(BPF_SUB, R0, R1), 1050 BPF_ALU64_REG(BPF_SUB, R0, R2), 1051 BPF_ALU64_REG(BPF_SUB, R0, R3), 1052 BPF_ALU64_REG(BPF_SUB, R0, R4), 1053 BPF_ALU64_REG(BPF_SUB, R0, R5), 1054 BPF_ALU64_REG(BPF_SUB, R0, R6), 1055 BPF_ALU64_REG(BPF_SUB, R0, R7), 1056 BPF_ALU64_REG(BPF_SUB, R0, R8), 1057 BPF_ALU64_REG(BPF_SUB, R0, R9), 1058 BPF_ALU64_IMM(BPF_SUB, R0, 10), 1059 BPF_JMP_IMM(BPF_JEQ, R0, -55, 1), 1060 BPF_EXIT_INSN(), 1061 BPF_ALU64_REG(BPF_SUB, R1, R0), 1062 BPF_ALU64_REG(BPF_SUB, R1, R2), 1063 BPF_ALU64_REG(BPF_SUB, R1, R3), 1064 BPF_ALU64_REG(BPF_SUB, R1, R4), 1065 BPF_ALU64_REG(BPF_SUB, R1, R5), 1066 BPF_ALU64_REG(BPF_SUB, R1, R6), 1067 BPF_ALU64_REG(BPF_SUB, R1, R7), 1068 BPF_ALU64_REG(BPF_SUB, R1, R8), 1069 BPF_ALU64_REG(BPF_SUB, R1, R9), 1070 BPF_ALU64_IMM(BPF_SUB, R1, 10), 1071 BPF_ALU64_REG(BPF_SUB, R2, R0), 1072 BPF_ALU64_REG(BPF_SUB, R2, R1), 1073 BPF_ALU64_REG(BPF_SUB, R2, R3), 1074 BPF_ALU64_REG(BPF_SUB, R2, R4), 1075 BPF_ALU64_REG(BPF_SUB, R2, R5), 1076 BPF_ALU64_REG(BPF_SUB, R2, R6), 1077 BPF_ALU64_REG(BPF_SUB, R2, R7), 1078 BPF_ALU64_REG(BPF_SUB, R2, R8), 1079 BPF_ALU64_REG(BPF_SUB, R2, R9), 1080 BPF_ALU64_IMM(BPF_SUB, R2, 10), 1081 BPF_ALU64_REG(BPF_SUB, R3, R0), 1082 BPF_ALU64_REG(BPF_SUB, R3, R1), 1083 BPF_ALU64_REG(BPF_SUB, R3, R2), 1084 BPF_ALU64_REG(BPF_SUB, R3, R4), 1085 BPF_ALU64_REG(BPF_SUB, R3, R5), 1086 BPF_ALU64_REG(BPF_SUB, R3, R6), 1087 BPF_ALU64_REG(BPF_SUB, R3, R7), 1088 BPF_ALU64_REG(BPF_SUB, R3, R8), 1089 BPF_ALU64_REG(BPF_SUB, R3, R9), 1090 BPF_ALU64_IMM(BPF_SUB, R3, 10), 1091 BPF_ALU64_REG(BPF_SUB, R4, R0), 1092 BPF_ALU64_REG(BPF_SUB, R4, R1), 1093 BPF_ALU64_REG(BPF_SUB, R4, R2), 1094 BPF_ALU64_REG(BPF_SUB, R4, R3), 1095 BPF_ALU64_REG(BPF_SUB, R4, R5), 1096 BPF_ALU64_REG(BPF_SUB, R4, R6), 1097 BPF_ALU64_REG(BPF_SUB, R4, R7), 1098 BPF_ALU64_REG(BPF_SUB, R4, R8), 1099 BPF_ALU64_REG(BPF_SUB, R4, R9), 1100 BPF_ALU64_IMM(BPF_SUB, R4, 10), 1101 BPF_ALU64_REG(BPF_SUB, R5, R0), 1102 BPF_ALU64_REG(BPF_SUB, R5, R1), 1103 BPF_ALU64_REG(BPF_SUB, R5, R2), 1104 BPF_ALU64_REG(BPF_SUB, R5, R3), 1105 BPF_ALU64_REG(BPF_SUB, R5, R4), 1106 BPF_ALU64_REG(BPF_SUB, R5, R6), 1107 BPF_ALU64_REG(BPF_SUB, R5, R7), 1108 BPF_ALU64_REG(BPF_SUB, R5, R8), 1109 BPF_ALU64_REG(BPF_SUB, R5, R9), 1110 BPF_ALU64_IMM(BPF_SUB, R5, 10), 1111 BPF_ALU64_REG(BPF_SUB, R6, R0), 1112 BPF_ALU64_REG(BPF_SUB, R6, R1), 1113 BPF_ALU64_REG(BPF_SUB, R6, R2), 1114 BPF_ALU64_REG(BPF_SUB, R6, R3), 1115 BPF_ALU64_REG(BPF_SUB, R6, R4), 1116 BPF_ALU64_REG(BPF_SUB, R6, R5), 1117 BPF_ALU64_REG(BPF_SUB, R6, R7), 1118 BPF_ALU64_REG(BPF_SUB, R6, R8), 1119 BPF_ALU64_REG(BPF_SUB, R6, R9), 1120 BPF_ALU64_IMM(BPF_SUB, R6, 10), 1121 BPF_ALU64_REG(BPF_SUB, R7, R0), 1122 BPF_ALU64_REG(BPF_SUB, R7, R1), 1123 BPF_ALU64_REG(BPF_SUB, R7, R2), 1124 BPF_ALU64_REG(BPF_SUB, R7, R3), 1125 BPF_ALU64_REG(BPF_SUB, R7, R4), 1126 BPF_ALU64_REG(BPF_SUB, R7, R5), 1127 BPF_ALU64_REG(BPF_SUB, R7, R6), 1128 BPF_ALU64_REG(BPF_SUB, R7, R8), 1129 BPF_ALU64_REG(BPF_SUB, R7, R9), 1130 BPF_ALU64_IMM(BPF_SUB, R7, 10), 1131 BPF_ALU64_REG(BPF_SUB, R8, R0), 1132 BPF_ALU64_REG(BPF_SUB, R8, R1), 1133 BPF_ALU64_REG(BPF_SUB, R8, R2), 1134 BPF_ALU64_REG(BPF_SUB, R8, R3), 1135 BPF_ALU64_REG(BPF_SUB, R8, R4), 1136 BPF_ALU64_REG(BPF_SUB, R8, R5), 1137 BPF_ALU64_REG(BPF_SUB, R8, R6), 1138 BPF_ALU64_REG(BPF_SUB, R8, R7), 1139 BPF_ALU64_REG(BPF_SUB, R8, R9), 1140 BPF_ALU64_IMM(BPF_SUB, R8, 10), 1141 BPF_ALU64_REG(BPF_SUB, R9, R0), 1142 BPF_ALU64_REG(BPF_SUB, R9, R1), 1143 BPF_ALU64_REG(BPF_SUB, R9, R2), 1144 BPF_ALU64_REG(BPF_SUB, R9, R3), 1145 BPF_ALU64_REG(BPF_SUB, R9, R4), 1146 BPF_ALU64_REG(BPF_SUB, R9, R5), 1147 BPF_ALU64_REG(BPF_SUB, R9, R6), 1148 BPF_ALU64_REG(BPF_SUB, R9, R7), 1149 BPF_ALU64_REG(BPF_SUB, R9, R8), 1150 BPF_ALU64_IMM(BPF_SUB, R9, 10), 1151 BPF_ALU64_IMM(BPF_SUB, R0, 10), 1152 BPF_ALU64_IMM(BPF_NEG, R0, 0), 1153 BPF_ALU64_REG(BPF_SUB, R0, R1), 1154 BPF_ALU64_REG(BPF_SUB, R0, R2), 1155 BPF_ALU64_REG(BPF_SUB, R0, R3), 1156 BPF_ALU64_REG(BPF_SUB, R0, R4), 1157 BPF_ALU64_REG(BPF_SUB, R0, R5), 1158 BPF_ALU64_REG(BPF_SUB, R0, R6), 1159 BPF_ALU64_REG(BPF_SUB, R0, R7), 1160 BPF_ALU64_REG(BPF_SUB, R0, R8), 1161 BPF_ALU64_REG(BPF_SUB, R0, R9), 1162 BPF_EXIT_INSN(), 1163 }, 1164 SKB_INT, 1165 { }, 1166 { { 0, 11 } } 1167 }, 1168 { /* Mainly checking JIT here. */ 1169 "INT: XOR", 1170 .insns_int = { 1171 BPF_ALU64_REG(BPF_SUB, R0, R0), 1172 BPF_ALU64_REG(BPF_XOR, R1, R1), 1173 BPF_JMP_REG(BPF_JEQ, R0, R1, 1), 1174 BPF_EXIT_INSN(), 1175 BPF_ALU64_IMM(BPF_MOV, R0, 10), 1176 BPF_ALU64_IMM(BPF_MOV, R1, -1), 1177 BPF_ALU64_REG(BPF_SUB, R1, R1), 1178 BPF_ALU64_REG(BPF_XOR, R2, R2), 1179 BPF_JMP_REG(BPF_JEQ, R1, R2, 1), 1180 BPF_EXIT_INSN(), 1181 BPF_ALU64_REG(BPF_SUB, R2, R2), 1182 BPF_ALU64_REG(BPF_XOR, R3, R3), 1183 BPF_ALU64_IMM(BPF_MOV, R0, 10), 1184 BPF_ALU64_IMM(BPF_MOV, R1, -1), 1185 BPF_JMP_REG(BPF_JEQ, R2, R3, 1), 1186 BPF_EXIT_INSN(), 1187 BPF_ALU64_REG(BPF_SUB, R3, R3), 1188 BPF_ALU64_REG(BPF_XOR, R4, R4), 1189 BPF_ALU64_IMM(BPF_MOV, R2, 1), 1190 BPF_ALU64_IMM(BPF_MOV, R5, -1), 1191 BPF_JMP_REG(BPF_JEQ, R3, R4, 1), 1192 BPF_EXIT_INSN(), 1193 BPF_ALU64_REG(BPF_SUB, R4, R4), 1194 BPF_ALU64_REG(BPF_XOR, R5, R5), 1195 BPF_ALU64_IMM(BPF_MOV, R3, 1), 1196 BPF_ALU64_IMM(BPF_MOV, R7, -1), 1197 BPF_JMP_REG(BPF_JEQ, R5, R4, 1), 1198 BPF_EXIT_INSN(), 1199 BPF_ALU64_IMM(BPF_MOV, R5, 1), 1200 BPF_ALU64_REG(BPF_SUB, R5, R5), 1201 BPF_ALU64_REG(BPF_XOR, R6, R6), 1202 BPF_ALU64_IMM(BPF_MOV, R1, 1), 1203 BPF_ALU64_IMM(BPF_MOV, R8, -1), 1204 BPF_JMP_REG(BPF_JEQ, R5, R6, 1), 1205 BPF_EXIT_INSN(), 1206 BPF_ALU64_REG(BPF_SUB, R6, R6), 1207 BPF_ALU64_REG(BPF_XOR, R7, R7), 1208 BPF_JMP_REG(BPF_JEQ, R7, R6, 1), 1209 BPF_EXIT_INSN(), 1210 BPF_ALU64_REG(BPF_SUB, R7, R7), 1211 BPF_ALU64_REG(BPF_XOR, R8, R8), 1212 BPF_JMP_REG(BPF_JEQ, R7, R8, 1), 1213 BPF_EXIT_INSN(), 1214 BPF_ALU64_REG(BPF_SUB, R8, R8), 1215 BPF_ALU64_REG(BPF_XOR, R9, R9), 1216 BPF_JMP_REG(BPF_JEQ, R9, R8, 1), 1217 BPF_EXIT_INSN(), 1218 BPF_ALU64_REG(BPF_SUB, R9, R9), 1219 BPF_ALU64_REG(BPF_XOR, R0, R0), 1220 BPF_JMP_REG(BPF_JEQ, R9, R0, 1), 1221 BPF_EXIT_INSN(), 1222 BPF_ALU64_REG(BPF_SUB, R1, R1), 1223 BPF_ALU64_REG(BPF_XOR, R0, R0), 1224 BPF_JMP_REG(BPF_JEQ, R9, R0, 2), 1225 BPF_ALU64_IMM(BPF_MOV, R0, 0), 1226 BPF_EXIT_INSN(), 1227 BPF_ALU64_IMM(BPF_MOV, R0, 1), 1228 BPF_EXIT_INSN(), 1229 }, 1230 SKB_INT, 1231 { }, 1232 { { 0, 1 } } 1233 }, 1234 { /* Mainly checking JIT here. */ 1235 "INT: MUL", 1236 .insns_int = { 1237 BPF_ALU64_IMM(BPF_MOV, R0, 11), 1238 BPF_ALU64_IMM(BPF_MOV, R1, 1), 1239 BPF_ALU64_IMM(BPF_MOV, R2, 2), 1240 BPF_ALU64_IMM(BPF_MOV, R3, 3), 1241 BPF_ALU64_IMM(BPF_MOV, R4, 4), 1242 BPF_ALU64_IMM(BPF_MOV, R5, 5), 1243 BPF_ALU64_IMM(BPF_MOV, R6, 6), 1244 BPF_ALU64_IMM(BPF_MOV, R7, 7), 1245 BPF_ALU64_IMM(BPF_MOV, R8, 8), 1246 BPF_ALU64_IMM(BPF_MOV, R9, 9), 1247 BPF_ALU64_REG(BPF_MUL, R0, R0), 1248 BPF_ALU64_REG(BPF_MUL, R0, R1), 1249 BPF_ALU64_REG(BPF_MUL, R0, R2), 1250 BPF_ALU64_REG(BPF_MUL, R0, R3), 1251 BPF_ALU64_REG(BPF_MUL, R0, R4), 1252 BPF_ALU64_REG(BPF_MUL, R0, R5), 1253 BPF_ALU64_REG(BPF_MUL, R0, R6), 1254 BPF_ALU64_REG(BPF_MUL, R0, R7), 1255 BPF_ALU64_REG(BPF_MUL, R0, R8), 1256 BPF_ALU64_REG(BPF_MUL, R0, R9), 1257 BPF_ALU64_IMM(BPF_MUL, R0, 10), 1258 BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1), 1259 BPF_EXIT_INSN(), 1260 BPF_ALU64_REG(BPF_MUL, R1, R0), 1261 BPF_ALU64_REG(BPF_MUL, R1, R2), 1262 BPF_ALU64_REG(BPF_MUL, R1, R3), 1263 BPF_ALU64_REG(BPF_MUL, R1, R4), 1264 BPF_ALU64_REG(BPF_MUL, R1, R5), 1265 BPF_ALU64_REG(BPF_MUL, R1, R6), 1266 BPF_ALU64_REG(BPF_MUL, R1, R7), 1267 BPF_ALU64_REG(BPF_MUL, R1, R8), 1268 BPF_ALU64_REG(BPF_MUL, R1, R9), 1269 BPF_ALU64_IMM(BPF_MUL, R1, 10), 1270 BPF_ALU64_REG(BPF_MOV, R2, R1), 1271 BPF_ALU64_IMM(BPF_RSH, R2, 32), 1272 BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1), 1273 BPF_EXIT_INSN(), 1274 BPF_ALU64_IMM(BPF_LSH, R1, 32), 1275 BPF_ALU64_IMM(BPF_ARSH, R1, 32), 1276 BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1), 1277 BPF_EXIT_INSN(), 1278 BPF_ALU64_REG(BPF_MUL, R2, R0), 1279 BPF_ALU64_REG(BPF_MUL, R2, R1), 1280 BPF_ALU64_REG(BPF_MUL, R2, R3), 1281 BPF_ALU64_REG(BPF_MUL, R2, R4), 1282 BPF_ALU64_REG(BPF_MUL, R2, R5), 1283 BPF_ALU64_REG(BPF_MUL, R2, R6), 1284 BPF_ALU64_REG(BPF_MUL, R2, R7), 1285 BPF_ALU64_REG(BPF_MUL, R2, R8), 1286 BPF_ALU64_REG(BPF_MUL, R2, R9), 1287 BPF_ALU64_IMM(BPF_MUL, R2, 10), 1288 BPF_ALU64_IMM(BPF_RSH, R2, 32), 1289 BPF_ALU64_REG(BPF_MOV, R0, R2), 1290 BPF_EXIT_INSN(), 1291 }, 1292 SKB_INT, 1293 { }, 1294 { { 0, 0x35d97ef2 } } 1295 }, 1296 { 1297 "INT: ALU MIX", 1298 .insns_int = { 1299 BPF_ALU64_IMM(BPF_MOV, R0, 11), 1300 BPF_ALU64_IMM(BPF_ADD, R0, -1), 1301 BPF_ALU64_IMM(BPF_MOV, R2, 2), 1302 BPF_ALU64_IMM(BPF_XOR, R2, 3), 1303 BPF_ALU64_REG(BPF_DIV, R0, R2), 1304 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1), 1305 BPF_EXIT_INSN(), 1306 BPF_ALU64_IMM(BPF_MOD, R0, 3), 1307 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1), 1308 BPF_EXIT_INSN(), 1309 BPF_ALU64_IMM(BPF_MOV, R0, -1), 1310 BPF_EXIT_INSN(), 1311 }, 1312 SKB_INT, 1313 { }, 1314 { { 0, -1 } } 1315 }, 1316 { 1317 "INT: DIV + ABS", 1318 .insns_int = { 1319 BPF_ALU64_REG(BPF_MOV, R6, R1), 1320 BPF_LD_ABS(BPF_B, 3), 1321 BPF_ALU64_IMM(BPF_MOV, R2, 2), 1322 BPF_ALU32_REG(BPF_DIV, R0, R2), 1323 BPF_ALU64_REG(BPF_MOV, R8, R0), 1324 BPF_LD_ABS(BPF_B, 4), 1325 BPF_ALU64_REG(BPF_ADD, R8, R0), 1326 BPF_LD_IND(BPF_B, R8, -70), 1327 BPF_EXIT_INSN(), 1328 }, 1329 SKB_INT, 1330 { 10, 20, 30, 40, 50 }, 1331 { { 4, 0 }, { 5, 10 } } 1332 }, 1333 { 1334 "INT: DIV by zero", 1335 .insns_int = { 1336 BPF_ALU64_REG(BPF_MOV, R6, R1), 1337 BPF_ALU64_IMM(BPF_MOV, R7, 0), 1338 BPF_LD_ABS(BPF_B, 3), 1339 BPF_ALU32_REG(BPF_DIV, R0, R7), 1340 BPF_EXIT_INSN(), 1341 }, 1342 SKB_INT, 1343 { 10, 20, 30, 40, 50 }, 1344 { { 3, 0 }, { 4, 0 } } 1345 }, 1346 { 1347 "check: missing ret", 1348 .insns = { 1349 BPF_STMT(BPF_LD | BPF_IMM, 1), 1350 }, 1351 EXPECTED_FAIL, 1352 { }, 1353 { } 1354 }, 1355 { 1356 "check: div_k_0", 1357 .insns = { 1358 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0), 1359 BPF_STMT(BPF_RET | BPF_K, 0) 1360 }, 1361 EXPECTED_FAIL, 1362 { }, 1363 { } 1364 }, 1365 { 1366 "check: unknown insn", 1367 .insns = { 1368 /* seccomp insn, rejected in socket filter */ 1369 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0), 1370 BPF_STMT(BPF_RET | BPF_K, 0) 1371 }, 1372 EXPECTED_FAIL, 1373 { }, 1374 { } 1375 }, 1376 { 1377 "check: out of range spill/fill", 1378 .insns = { 1379 BPF_STMT(BPF_STX, 16), 1380 BPF_STMT(BPF_RET | BPF_K, 0) 1381 }, 1382 EXPECTED_FAIL, 1383 { }, 1384 { } 1385 }, 1386 }; 1387 1388 static int get_length(struct sock_filter *fp) 1389 { 1390 int len = 0; 1391 1392 while (fp->code != 0 || fp->k != 0) { 1393 fp++; 1394 len++; 1395 } 1396 1397 return len; 1398 } 1399 1400 struct net_device dev; 1401 struct sk_buff *populate_skb(char *buf, int size) 1402 { 1403 struct sk_buff *skb; 1404 1405 if (size >= MAX_DATA) 1406 return NULL; 1407 1408 skb = alloc_skb(MAX_DATA, GFP_KERNEL); 1409 if (!skb) 1410 return NULL; 1411 1412 memcpy(__skb_put(skb, size), buf, size); 1413 skb_reset_mac_header(skb); 1414 skb->protocol = htons(ETH_P_IP); 1415 skb->pkt_type = SKB_TYPE; 1416 skb->mark = SKB_MARK; 1417 skb->hash = SKB_HASH; 1418 skb->queue_mapping = SKB_QUEUE_MAP; 1419 skb->vlan_tci = SKB_VLAN_TCI; 1420 skb->dev = &dev; 1421 skb->dev->ifindex = SKB_DEV_IFINDEX; 1422 skb->dev->type = SKB_DEV_TYPE; 1423 skb_set_network_header(skb, min(size, ETH_HLEN)); 1424 1425 return skb; 1426 } 1427 1428 static int run_one(struct sk_filter *fp, struct bpf_test *t) 1429 { 1430 u64 start, finish, res, cnt = 100000; 1431 int err_cnt = 0, err, i, j; 1432 u32 ret = 0; 1433 void *data; 1434 1435 for (i = 0; i < MAX_SUBTESTS; i++) { 1436 if (t->test[i].data_size == 0 && 1437 t->test[i].result == 0) 1438 break; 1439 if (t->data_type == SKB || 1440 t->data_type == SKB_INT) { 1441 data = populate_skb(t->data, t->test[i].data_size); 1442 if (!data) 1443 return -ENOMEM; 1444 } else { 1445 data = NULL; 1446 } 1447 1448 start = ktime_to_us(ktime_get()); 1449 for (j = 0; j < cnt; j++) 1450 ret = SK_RUN_FILTER(fp, data); 1451 finish = ktime_to_us(ktime_get()); 1452 1453 res = (finish - start) * 1000; 1454 do_div(res, cnt); 1455 1456 err = ret != t->test[i].result; 1457 if (!err) 1458 pr_cont("%lld ", res); 1459 1460 if (t->data_type == SKB || t->data_type == SKB_INT) 1461 kfree_skb(data); 1462 1463 if (err) { 1464 pr_cont("ret %d != %d ", ret, t->test[i].result); 1465 err_cnt++; 1466 } 1467 } 1468 1469 return err_cnt; 1470 } 1471 1472 static __init int test_bpf(void) 1473 { 1474 struct sk_filter *fp, *fp_ext = NULL; 1475 struct sock_fprog fprog; 1476 int err, i, err_cnt = 0; 1477 1478 for (i = 0; i < ARRAY_SIZE(tests); i++) { 1479 pr_info("#%d %s ", i, tests[i].descr); 1480 1481 fprog.filter = tests[i].insns; 1482 fprog.len = get_length(fprog.filter); 1483 1484 if (tests[i].data_type == SKB_INT) { 1485 fp_ext = kzalloc(4096, GFP_KERNEL); 1486 if (!fp_ext) 1487 return -ENOMEM; 1488 fp = fp_ext; 1489 memcpy(fp_ext->insns, tests[i].insns_int, 1490 fprog.len * 8); 1491 fp->len = fprog.len; 1492 fp->bpf_func = sk_run_filter_int_skb; 1493 } else { 1494 err = sk_unattached_filter_create(&fp, &fprog); 1495 if (tests[i].data_type == EXPECTED_FAIL) { 1496 if (err == -EINVAL) { 1497 pr_cont("PASS\n"); 1498 continue; 1499 } else { 1500 pr_cont("UNEXPECTED_PASS\n"); 1501 /* verifier didn't reject the test 1502 * that's bad enough, just return 1503 */ 1504 return -EINVAL; 1505 } 1506 } 1507 if (err) { 1508 pr_cont("FAIL to attach err=%d len=%d\n", 1509 err, fprog.len); 1510 return err; 1511 } 1512 } 1513 1514 err = run_one(fp, &tests[i]); 1515 1516 if (tests[i].data_type != SKB_INT) 1517 sk_unattached_filter_destroy(fp); 1518 else 1519 kfree(fp); 1520 1521 if (err) { 1522 pr_cont("FAIL %d\n", err); 1523 err_cnt++; 1524 } else { 1525 pr_cont("PASS\n"); 1526 } 1527 } 1528 1529 if (err_cnt) 1530 return -EINVAL; 1531 else 1532 return 0; 1533 } 1534 1535 static int __init test_bpf_init(void) 1536 { 1537 return test_bpf(); 1538 } 1539 1540 static void __exit test_bpf_exit(void) 1541 { 1542 } 1543 1544 module_init(test_bpf_init); 1545 module_exit(test_bpf_exit); 1546 MODULE_LICENSE("GPL"); 1547