lib/test_bpf.c

   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");