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