Merge git://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next

Daniel Borkmann says:

====================
pull-request: bpf-next 2018-12-21

The following pull-request contains BPF updates for your *net-next* tree.

There is a merge conflict in test_verifier.c. Result looks as follows:

        [...]
        },
        {
                "calls: cross frame pruning",
                .insns = {
                [...]
                .prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
                .errstr_unpriv = "function calls to other bpf functions are allowed for root only",
                .result_unpriv = REJECT,
                .errstr = "!read_ok",
                .result = REJECT,
	},
        {
                "jset: functional",
                .insns = {
        [...]
        {
                "jset: unknown const compare not taken",
                .insns = {
                        BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
                                     BPF_FUNC_get_prandom_u32),
                        BPF_JMP_IMM(BPF_JSET, BPF_REG_0, 1, 1),
                        BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
                        BPF_EXIT_INSN(),
                },
                .prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
                .errstr_unpriv = "!read_ok",
                .result_unpriv = REJECT,
                .errstr = "!read_ok",
                .result = REJECT,
        },
        [...]
        {
                "jset: range",
                .insns = {
                [...]
                },
                .prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
                .result_unpriv = ACCEPT,
                .result = ACCEPT,
        },

The main changes are:

1) Various BTF related improvements in order to get line info
   working. Meaning, verifier will now annotate the corresponding
   BPF C code to the error log, from Martin and Yonghong.

2) Implement support for raw BPF tracepoints in modules, from Matt.

3) Add several improvements to verifier state logic, namely speeding
   up stacksafe check, optimizations for stack state equivalence
   test and safety checks for liveness analysis, from Alexei.

4) Teach verifier to make use of BPF_JSET instruction, add several
   test cases to kselftests and remove nfp specific JSET optimization
   now that verifier has awareness, from Jakub.

5) Improve BPF verifier's slot_type marking logic in order to
   allow more stack slot sharing, from Jiong.

6) Add sk_msg->size member for context access and add set of fixes
   and improvements to make sock_map with kTLS usable with openssl
   based applications, from John.

7) Several cleanups and documentation updates in bpftool as well as
   auto-mount of tracefs for "bpftool prog tracelog" command,
   from Quentin.

8) Include sub-program tags from now on in bpf_prog_info in order to
   have a reliable way for user space to get all tags of the program
   e.g. needed for kallsyms correlation, from Song.

9) Add BTF annotations for cgroup_local_storage BPF maps and
   implement bpf fs pretty print support, from Roman.

10) Fix bpftool in order to allow for cross-compilation, from Ivan.

11) Update of bpftool license to GPLv2-only + BSD-2-Clause in order
    to be compatible with libbfd and allow for Debian packaging,
    from Jakub.

12) Remove an obsolete prog->aux sanitation in dump and get rid of
    version check for prog load, from Daniel.

13) Fix a memory leak in libbpf's line info handling, from Prashant.

14) Fix cpumap's frame alignment for build_skb() so that skb_shared_info
    does not get unaligned, from Jesper.

15) Fix test_progs kselftest to work with older compilers which are less
    smart in optimizing (and thus throwing build error), from Stanislav.

16) Cleanup and simplify AF_XDP socket teardown, from Björn.

17) Fix sk lookup in BPF kselftest's test_sock_addr with regards
    to netns_id argument, from Andrey.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

36 files changed, 1348 insertions, 513 deletions

diff --git a/tools/bpf/bpftool/Documentation/bpftool-map.rst b/tools/bpf/bpftool/Documentation/bpftool-map.rst
index 5318dcb2085e..64b001b4f777 100644
--- a/tools/bpf/bpftool/Documentation/bpftool-map.rst
+++ b/tools/bpf/bpftool/Documentation/bpftool-map.rst
@@ -128,6 +128,10 @@ OPTIONS
         -f, --bpffs
                   Show file names of pinned maps.
 
+        -n, --nomount
+                  Do not automatically attempt to mount any virtual file system
+                  (such as tracefs or BPF virtual file system) when necessary.
+
 EXAMPLES
 ========
 **# bpftool map show**
@@ -170,6 +174,61 @@ The following three commands are equivalent:
 | **# bpftool map pin id 10 /sys/fs/bpf/map**
 | **# bpftool map del pinned /sys/fs/bpf/map key 13 00 07 00**
 
+Note that map update can also be used in order to change the program references
+hold by a program array map. This can be used, for example, to change the
+programs used for tail-call jumps at runtime, without having to reload the
+entry-point program. Below is an example for this use case: we load a program
+defining a prog array map, and with a main function that contains a tail call
+to other programs that can be used either to "process" packets or to "debug"
+processing. Note that the prog array map MUST be pinned into the BPF virtual
+file system for the map update to work successfully, as kernel flushes prog
+array maps when they have no more references from user space (and the update
+would be lost as soon as bpftool exits).
+
+|
+| **# bpftool prog loadall tail_calls.o /sys/fs/bpf/foo type xdp**
+| **# bpftool prog --bpffs**
+
+::
+
+  545: xdp  name main_func  tag 674b4b5597193dc3  gpl
+          loaded_at 2018-12-12T15:02:58+0000  uid 0
+          xlated 240B  jited 257B  memlock 4096B  map_ids 294
+          pinned /sys/fs/bpf/foo/xdp
+  546: xdp  name bpf_func_process  tag e369a529024751fc  gpl
+          loaded_at 2018-12-12T15:02:58+0000  uid 0
+          xlated 200B  jited 164B  memlock 4096B
+          pinned /sys/fs/bpf/foo/process
+  547: xdp  name bpf_func_debug  tag 0b597868bc7f0976  gpl
+          loaded_at 2018-12-12T15:02:58+0000  uid 0
+          xlated 200B  jited 164B  memlock 4096B
+          pinned /sys/fs/bpf/foo/debug
+
+**# bpftool map**
+
+::
+
+  294: prog_array  name jmp_table  flags 0x0
+          key 4B  value 4B  max_entries 1  memlock 4096B
+          owner_prog_type xdp  owner jited
+
+|
+| **# bpftool map pin id 294 /sys/fs/bpf/bar**
+| **# bpftool map dump pinned /sys/fs/bpf/bar**
+
+::
+
+  Found 0 elements
+
+|
+| **# bpftool map update pinned /sys/fs/bpf/bar key 0 0 0 0 value pinned /sys/fs/bpf/foo/debug**
+| **# bpftool map dump pinned /sys/fs/bpf/bar**
+
+::
+
+  key: 00 00 00 00  value: 22 02 00 00
+  Found 1 element
+
 SEE ALSO
 ========
         **bpf**\ (2),
diff --git a/tools/bpf/bpftool/Documentation/bpftool-prog.rst b/tools/bpf/bpftool/Documentation/bpftool-prog.rst
index bb1aeb98b6da..58c8369b77dd 100644
--- a/tools/bpf/bpftool/Documentation/bpftool-prog.rst
+++ b/tools/bpf/bpftool/Documentation/bpftool-prog.rst
@@ -158,83 +158,98 @@ OPTIONS
                   When showing BPF programs, show file names of pinned
                   programs.
 
+        -m, --mapcompat
+                  Allow loading maps with unknown map definitions.
+
+        -n, --nomount
+                  Do not automatically attempt to mount any virtual file system
+                  (such as tracefs or BPF virtual file system) when necessary.
+
 EXAMPLES
 ========
 **# bpftool prog show**
+
 ::
 
-  10: xdp  name some_prog  tag 005a3d2123620c8b  gpl
-        loaded_at Sep 29/20:11  uid 0
-        xlated 528B  jited 370B  memlock 4096B  map_ids 10
+    10: xdp  name some_prog  tag 005a3d2123620c8b  gpl
+            loaded_at 2017-09-29T20:11:00+0000  uid 0
+            xlated 528B  jited 370B  memlock 4096B  map_ids 10
 
 **# bpftool --json --pretty prog show**
 
 ::
 
-    {
-        "programs": [{
-                "id": 10,
-                "type": "xdp",
-                "tag": "005a3d2123620c8b",
-                "gpl_compatible": true,
-                "loaded_at": "Sep 29/20:11",
-                "uid": 0,
-                "bytes_xlated": 528,
-                "jited": true,
-                "bytes_jited": 370,
-                "bytes_memlock": 4096,
-                "map_ids": [10
-                ]
-            }
-        ]
-    }
+    [{
+            "id": 10,
+            "type": "xdp",
+            "tag": "005a3d2123620c8b",
+            "gpl_compatible": true,
+            "loaded_at": 1506715860,
+            "uid": 0,
+            "bytes_xlated": 528,
+            "jited": true,
+            "bytes_jited": 370,
+            "bytes_memlock": 4096,
+            "map_ids": [10
+            ]
+        }
+    ]
 
 |
 | **# bpftool prog dump xlated id 10 file /tmp/t**
 | **# ls -l /tmp/t**
-|   -rw------- 1 root root 560 Jul 22 01:42 /tmp/t
 
-**# bpftool prog dum jited tag 005a3d2123620c8b**
+::
+
+    -rw------- 1 root root 560 Jul 22 01:42 /tmp/t
+
+**# bpftool prog dump jited tag 005a3d2123620c8b**
 
 ::
 
-    push   %rbp
-    mov    %rsp,%rbp
-    sub    $0x228,%rsp
-    sub    $0x28,%rbp
-    mov    %rbx,0x0(%rbp)
+    0:   push   %rbp
+    1:   mov    %rsp,%rbp
+    2:   sub    $0x228,%rsp
+    3:   sub    $0x28,%rbp
+    4:   mov    %rbx,0x0(%rbp)
 
 |
 | **# mount -t bpf none /sys/fs/bpf/**
 | **# bpftool prog pin id 10 /sys/fs/bpf/prog**
 | **# bpftool prog load ./my_prog.o /sys/fs/bpf/prog2**
 | **# ls -l /sys/fs/bpf/**
-|   -rw------- 1 root root 0 Jul 22 01:43 prog
-|   -rw------- 1 root root 0 Jul 22 01:44 prog2
 
-**# bpftool prog dum jited pinned /sys/fs/bpf/prog opcodes**
+::
+
+    -rw------- 1 root root 0 Jul 22 01:43 prog
+    -rw------- 1 root root 0 Jul 22 01:44 prog2
+
+**# bpftool prog dump jited pinned /sys/fs/bpf/prog opcodes**
 
 ::
 
-    push   %rbp
-    55
-    mov    %rsp,%rbp
-    48 89 e5
-    sub    $0x228,%rsp
-    48 81 ec 28 02 00 00
-    sub    $0x28,%rbp
-    48 83 ed 28
-    mov    %rbx,0x0(%rbp)
-    48 89 5d 00
+   0:   push   %rbp
+        55
+   1:   mov    %rsp,%rbp
+        48 89 e5
+   4:   sub    $0x228,%rsp
+        48 81 ec 28 02 00 00
+   b:   sub    $0x28,%rbp
+        48 83 ed 28
+   f:   mov    %rbx,0x0(%rbp)
+        48 89 5d 00
 
 |
 | **# bpftool prog load xdp1_kern.o /sys/fs/bpf/xdp1 type xdp map name rxcnt id 7**
 | **# bpftool prog show pinned /sys/fs/bpf/xdp1**
-|   9: xdp  name xdp_prog1  tag 539ec6ce11b52f98  gpl
-|       loaded_at 2018-06-25T16:17:31-0700  uid 0
-|       xlated 488B  jited 336B  memlock 4096B  map_ids 7
-| **# rm /sys/fs/bpf/xdp1**
-|
+
+::
+
+    9: xdp  name xdp_prog1  tag 539ec6ce11b52f98  gpl
+            loaded_at 2018-06-25T16:17:31-0700  uid 0
+            xlated 488B  jited 336B  memlock 4096B  map_ids 7
+
+**# rm /sys/fs/bpf/xdp1**
 
 SEE ALSO
 ========
diff --git a/tools/bpf/bpftool/Documentation/bpftool.rst b/tools/bpf/bpftool/Documentation/bpftool.rst
index 129b7a9c0f9b..e1677e81ed59 100644
--- a/tools/bpf/bpftool/Documentation/bpftool.rst
+++ b/tools/bpf/bpftool/Documentation/bpftool.rst
@@ -60,6 +60,10 @@ OPTIONS
         -m, --mapcompat
                   Allow loading maps with unknown map definitions.
 
+        -n, --nomount
+                  Do not automatically attempt to mount any virtual file system
+                  (such as tracefs or BPF virtual file system) when necessary.
+
 
 SEE ALSO
 ========
diff --git a/tools/bpf/bpftool/Makefile b/tools/bpf/bpftool/Makefile
index 1bea6b979082..492f0f24e2d3 100644
--- a/tools/bpf/bpftool/Makefile
+++ b/tools/bpf/bpftool/Makefile
@@ -35,8 +35,6 @@ $(LIBBPF)-clean:
 prefix ?= /usr/local
 bash_compdir ?= /usr/share/bash-completion/completions
 
-CC = gcc
-
 CFLAGS += -O2
 CFLAGS += -W -Wall -Wextra -Wno-unused-parameter -Wshadow -Wno-missing-field-initializers
 CFLAGS += -DPACKAGE='"bpftool"' -D__EXPORTED_HEADERS__ \
diff --git a/tools/bpf/bpftool/bash-completion/bpftool b/tools/bpf/bpftool/bash-completion/bpftool
index a57febd6abb1..e4e4fab1b8c7 100644
--- a/tools/bpf/bpftool/bash-completion/bpftool
+++ b/tools/bpf/bpftool/bash-completion/bpftool
@@ -1,37 +1,8 @@
 # bpftool(8) bash completion                               -*- shell-script -*-
 #
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
 # Copyright (C) 2017-2018 Netronome Systems, Inc.
 #
-# This software is dual licensed under the GNU General License
-# Version 2, June 1991 as shown in the file COPYING in the top-level
-# directory of this source tree or the BSD 2-Clause License provided
-# below.  You have the option to license this software under the
-# complete terms of either license.
-#
-# The BSD 2-Clause License:
-#
-#     Redistribution and use in source and binary forms, with or
-#     without modification, are permitted provided that the following
-#     conditions are met:
-#
-#      1. Redistributions of source code must retain the above
-#         copyright notice, this list of conditions and the following
-#         disclaimer.
-#
-#      2. Redistributions in binary form must reproduce the above
-#         copyright notice, this list of conditions and the following
-#         disclaimer in the documentation and/or other materials
-#         provided with the distribution.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-#
 # Author: Quentin Monnet <quentin.monnet@netronome.com>
 
 # Takes a list of words in argument; each one of them is added to COMPREPLY if
diff --git a/tools/bpf/bpftool/btf_dumper.c b/tools/bpf/bpftool/btf_dumper.c
index 2392ccdc918f..3f0629edbca5 100644
--- a/tools/bpf/bpftool/btf_dumper.c
+++ b/tools/bpf/bpftool/btf_dumper.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
 /* Copyright (c) 2018 Facebook */
 
 #include <ctype.h>
@@ -73,20 +73,17 @@ static int btf_dumper_array(const struct btf_dumper *d, __u32 type_id,
         return ret;
 }
 
-static void btf_dumper_int_bits(__u32 int_type, __u8 bit_offset,
+static void btf_dumper_bitfield(__u32 nr_bits, __u8 bit_offset,
                                 const void *data, json_writer_t *jw,
                                 bool is_plain_text)
 {
         int left_shift_bits, right_shift_bits;
-        int nr_bits = BTF_INT_BITS(int_type);
-        int total_bits_offset;
         int bytes_to_copy;
         int bits_to_copy;
         __u64 print_num;
 
-        total_bits_offset = bit_offset + BTF_INT_OFFSET(int_type);
-        data += BITS_ROUNDDOWN_BYTES(total_bits_offset);
-        bit_offset = BITS_PER_BYTE_MASKED(total_bits_offset);
+        data += BITS_ROUNDDOWN_BYTES(bit_offset);
+        bit_offset = BITS_PER_BYTE_MASKED(bit_offset);
         bits_to_copy = bit_offset + nr_bits;
         bytes_to_copy = BITS_ROUNDUP_BYTES(bits_to_copy);
 
@@ -109,6 +106,22 @@ static void btf_dumper_int_bits(__u32 int_type, __u8 bit_offset,
                 jsonw_printf(jw, "%llu", print_num);
 }
 
+
+static void btf_dumper_int_bits(__u32 int_type, __u8 bit_offset,
+                                const void *data, json_writer_t *jw,
+                                bool is_plain_text)
+{
+        int nr_bits = BTF_INT_BITS(int_type);
+        int total_bits_offset;
+
+        /* bits_offset is at most 7.
+         * BTF_INT_OFFSET() cannot exceed 64 bits.
+         */
+        total_bits_offset = bit_offset + BTF_INT_OFFSET(int_type);
+        btf_dumper_bitfield(nr_bits, total_bits_offset, data, jw,
+                            is_plain_text);
+}
+
 static int btf_dumper_int(const struct btf_type *t, __u8 bit_offset,
                           const void *data, json_writer_t *jw,
                           bool is_plain_text)
@@ -180,6 +193,7 @@ static int btf_dumper_struct(const struct btf_dumper *d, __u32 type_id,
         const struct btf_type *t;
         struct btf_member *m;
         const void *data_off;
+        int kind_flag;
         int ret = 0;
         int i, vlen;
 
@@ -187,18 +201,32 @@ static int btf_dumper_struct(const struct btf_dumper *d, __u32 type_id,
         if (!t)
                 return -EINVAL;
 
+        kind_flag = BTF_INFO_KFLAG(t->info);
         vlen = BTF_INFO_VLEN(t->info);
         jsonw_start_object(d->jw);
         m = (struct btf_member *)(t + 1);
 
         for (i = 0; i < vlen; i++) {
-                data_off = data + BITS_ROUNDDOWN_BYTES(m[i].offset);
+                __u32 bit_offset = m[i].offset;
+                __u32 bitfield_size = 0;
+
+                if (kind_flag) {
+                        bitfield_size = BTF_MEMBER_BITFIELD_SIZE(bit_offset);
+                        bit_offset = BTF_MEMBER_BIT_OFFSET(bit_offset);
+                }
+
                 jsonw_name(d->jw, btf__name_by_offset(d->btf, m[i].name_off));
-                ret = btf_dumper_do_type(d, m[i].type,
-                                         BITS_PER_BYTE_MASKED(m[i].offset),
-                                         data_off);
-                if (ret)
-                        break;
+                if (bitfield_size) {
+                        btf_dumper_bitfield(bitfield_size, bit_offset,
+                                            data, d->jw, d->is_plain_text);
+                } else {
+                        data_off = data + BITS_ROUNDDOWN_BYTES(bit_offset);
+                        ret = btf_dumper_do_type(d, m[i].type,
+                                                 BITS_PER_BYTE_MASKED(bit_offset),
+                                                 data_off);
+                        if (ret)
+                                break;
+                }
         }
 
         jsonw_end_object(d->jw);
@@ -285,6 +313,7 @@ static int __btf_dumper_type_only(const struct btf *btf, __u32 type_id,
 
         switch (BTF_INFO_KIND(t->info)) {
         case BTF_KIND_INT:
+        case BTF_KIND_TYPEDEF:
                 BTF_PRINT_ARG("%s ", btf__name_by_offset(btf, t->name_off));
                 break;
         case BTF_KIND_STRUCT:
@@ -308,10 +337,11 @@ static int __btf_dumper_type_only(const struct btf *btf, __u32 type_id,
                 BTF_PRINT_TYPE(t->type);
                 BTF_PRINT_ARG("* ");
                 break;
-        case BTF_KIND_UNKN:
         case BTF_KIND_FWD:
-        case BTF_KIND_TYPEDEF:
-                return -1;
+                BTF_PRINT_ARG("%s %s ",
+                              BTF_INFO_KFLAG(t->info) ? "union" : "struct",
+                              btf__name_by_offset(btf, t->name_off));
+                break;
         case BTF_KIND_VOLATILE:
                 BTF_PRINT_ARG("volatile ");
                 BTF_PRINT_TYPE(t->type);
@@ -335,6 +365,7 @@ static int __btf_dumper_type_only(const struct btf *btf, __u32 type_id,
                 if (pos == -1)
                         return -1;
                 break;
+        case BTF_KIND_UNKN:
         default:
                 return -1;
         }
diff --git a/tools/bpf/bpftool/cfg.c b/tools/bpf/bpftool/cfg.c
index f30b3a4a840b..31f0db41513f 100644
--- a/tools/bpf/bpftool/cfg.c
+++ b/tools/bpf/bpftool/cfg.c
@@ -1,39 +1,5 @@
 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
-/*
- * Copyright (C) 2018 Netronome Systems, Inc.
- *
- * This software is dual licensed under the GNU General License Version 2,
- * June 1991 as shown in the file COPYING in the top-level directory of this
- * source tree or the BSD 2-Clause License provided below.  You have the
- * option to license this software under the complete terms of either license.
- *
- * The BSD 2-Clause License:
- *
- *     Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *      1. Redistributions of source code must retain the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer.
- *
- *      2. Redistributions in binary form must reproduce the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer in the documentation and/or other materials
- *         provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
+/* Copyright (C) 2018 Netronome Systems, Inc. */
 
 #include <linux/list.h>
 #include <stdlib.h>
diff --git a/tools/bpf/bpftool/cfg.h b/tools/bpf/bpftool/cfg.h
index 2cc9bd990b13..e144257ea6d2 100644
--- a/tools/bpf/bpftool/cfg.h
+++ b/tools/bpf/bpftool/cfg.h
@@ -1,39 +1,5 @@
-// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
-/*
- * Copyright (C) 2018 Netronome Systems, Inc.
- *
- * This software is dual licensed under the GNU General License Version 2,
- * June 1991 as shown in the file COPYING in the top-level directory of this
- * source tree or the BSD 2-Clause License provided below.  You have the
- * option to license this software under the complete terms of either license.
- *
- * The BSD 2-Clause License:
- *
- *     Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *      1. Redistributions of source code must retain the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer.
- *
- *      2. Redistributions in binary form must reproduce the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer in the documentation and/or other materials
- *         provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
+/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) */
+/* Copyright (C) 2018 Netronome Systems, Inc. */
 
 #ifndef __BPF_TOOL_CFG_H
 #define __BPF_TOOL_CFG_H
diff --git a/tools/bpf/bpftool/cgroup.c b/tools/bpf/bpftool/cgroup.c
index ee7a9765c6b3..4b5c8da2a7c0 100644
--- a/tools/bpf/bpftool/cgroup.c
+++ b/tools/bpf/bpftool/cgroup.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0+
+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
 // Copyright (C) 2017 Facebook
 // Author: Roman Gushchin <guro@fb.com>
 
diff --git a/tools/bpf/bpftool/common.c b/tools/bpf/bpftool/common.c
index 172d3761d9ab..897483457bf0 100644
--- a/tools/bpf/bpftool/common.c
+++ b/tools/bpf/bpftool/common.c
@@ -1,35 +1,5 @@
-/*
- * Copyright (C) 2017-2018 Netronome Systems, Inc.
- *
- * This software is dual licensed under the GNU General License Version 2,
- * June 1991 as shown in the file COPYING in the top-level directory of this
- * source tree or the BSD 2-Clause License provided below.  You have the
- * option to license this software under the complete terms of either license.
- *
- * The BSD 2-Clause License:
- *
- *     Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *      1. Redistributions of source code must retain the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer.
- *
- *      2. Redistributions in binary form must reproduce the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer in the documentation and/or other materials
- *         provided with the distribution.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+/* Copyright (C) 2017-2018 Netronome Systems, Inc. */
 
 #include <ctype.h>
 #include <errno.h>
@@ -58,7 +28,7 @@
 #define BPF_FS_MAGIC            0xcafe4a11
 #endif
 
-void p_err(const char *fmt, ...)
+void __printf(1, 2) p_err(const char *fmt, ...)
 {
         va_list ap;
 
@@ -76,7 +46,7 @@ void p_err(const char *fmt, ...)
         va_end(ap);
 }
 
-void p_info(const char *fmt, ...)
+void __printf(1, 2) p_info(const char *fmt, ...)
 {
         va_list ap;
 
@@ -106,7 +76,8 @@ void set_max_rlimit(void)
         setrlimit(RLIMIT_MEMLOCK, &rinf);
 }
 
-static int mnt_bpffs(const char *target, char *buff, size_t bufflen)
+static int
+mnt_fs(const char *target, const char *type, char *buff, size_t bufflen)
 {
         bool bind_done = false;
 
@@ -128,15 +99,29 @@ static int mnt_bpffs(const char *target, char *buff, size_t bufflen)
                 bind_done = true;
         }
 
-        if (mount("bpf", target, "bpf", 0, "mode=0700")) {
-                snprintf(buff, bufflen, "mount -t bpf bpf %s failed: %s",
-                         target, strerror(errno));
+        if (mount(type, target, type, 0, "mode=0700")) {
+                snprintf(buff, bufflen, "mount -t %s %s %s failed: %s",
+                         type, type, target, strerror(errno));
                 return -1;
         }
 
         return 0;
 }
 
+int mount_tracefs(const char *target)
+{
+        char err_str[ERR_MAX_LEN];
+        int err;
+
+        err = mnt_fs(target, "tracefs", err_str, ERR_MAX_LEN);
+        if (err) {
+                err_str[ERR_MAX_LEN - 1] = '\0';
+                p_err("can't mount tracefs: %s", err_str);
+        }
+
+        return err;
+}
+
 int open_obj_pinned(char *path, bool quiet)
 {
         int fd;
@@ -192,7 +177,13 @@ int mount_bpffs_for_pin(const char *name)
                 /* nothing to do if already mounted */
                 goto out_free;
 
-        err = mnt_bpffs(dir, err_str, ERR_MAX_LEN);
+        if (block_mount) {
+                p_err("no BPF file system found, not mounting it due to --nomount option");
+                err = -1;
+                goto out_free;
+        }
+
+        err = mnt_fs(dir, "bpf", err_str, ERR_MAX_LEN);
         if (err) {
                 err_str[ERR_MAX_LEN - 1] = '\0';
                 p_err("can't mount BPF file system to pin the object (%s): %s",
diff --git a/tools/bpf/bpftool/jit_disasm.c b/tools/bpf/bpftool/jit_disasm.c
index f381f8628ce9..3ef3093560ba 100644
--- a/tools/bpf/bpftool/jit_disasm.c
+++ b/tools/bpf/bpftool/jit_disasm.c
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
 /*
  * Based on:
  *
diff --git a/tools/bpf/bpftool/json_writer.c b/tools/bpf/bpftool/json_writer.c
index c6eef76322ae..bff7ee026680 100644
--- a/tools/bpf/bpftool/json_writer.c
+++ b/tools/bpf/bpftool/json_writer.c
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
 /*
  * Simple streaming JSON writer
  *
@@ -19,6 +20,7 @@
 #include <malloc.h>
 #include <inttypes.h>
 #include <stdint.h>
+#include <linux/compiler.h>
 
 #include "json_writer.h"
 
@@ -156,7 +158,8 @@ void jsonw_name(json_writer_t *self, const char *name)
                 putc(' ', self->out);
 }
 
-void jsonw_vprintf_enquote(json_writer_t *self, const char *fmt, va_list ap)
+void __printf(2, 0)
+jsonw_vprintf_enquote(json_writer_t *self, const char *fmt, va_list ap)
 {
         jsonw_eor(self);
         putc('"', self->out);
@@ -164,7 +167,7 @@ void jsonw_vprintf_enquote(json_writer_t *self, const char *fmt, va_list ap)
         putc('"', self->out);
 }
 
-void jsonw_printf(json_writer_t *self, const char *fmt, ...)
+void __printf(2, 3) jsonw_printf(json_writer_t *self, const char *fmt, ...)
 {
         va_list ap;
 
diff --git a/tools/bpf/bpftool/json_writer.h b/tools/bpf/bpftool/json_writer.h
index 0fa2fb1b6351..c1ab51aed99c 100644
--- a/tools/bpf/bpftool/json_writer.h
+++ b/tools/bpf/bpftool/json_writer.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) */
 /*
  * Simple streaming JSON writer
  *
diff --git a/tools/bpf/bpftool/main.c b/tools/bpf/bpftool/main.c
index 5c4c1cd5a7ba..f44a1c2c4ea0 100644
--- a/tools/bpf/bpftool/main.c
+++ b/tools/bpf/bpftool/main.c
@@ -1,35 +1,5 @@
-/*
- * Copyright (C) 2017-2018 Netronome Systems, Inc.
- *
- * This software is dual licensed under the GNU General License Version 2,
- * June 1991 as shown in the file COPYING in the top-level directory of this
- * source tree or the BSD 2-Clause License provided below.  You have the
- * option to license this software under the complete terms of either license.
- *
- * The BSD 2-Clause License:
- *
- *     Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *      1. Redistributions of source code must retain the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer.
- *
- *      2. Redistributions in binary form must reproduce the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer in the documentation and/or other materials
- *         provided with the distribution.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+/* Copyright (C) 2017-2018 Netronome Systems, Inc. */
 
 #include <ctype.h>
 #include <errno.h>
@@ -54,6 +24,7 @@ json_writer_t *json_wtr;
 bool pretty_output;
 bool json_output;
 bool show_pinned;
+bool block_mount;
 int bpf_flags;
 struct pinned_obj_table prog_table;
 struct pinned_obj_table map_table;
@@ -343,6 +314,7 @@ int main(int argc, char **argv)
                 { "version",    no_argument,    NULL,   'V' },
                 { "bpffs",      no_argument,    NULL,   'f' },
                 { "mapcompat",  no_argument,    NULL,   'm' },
+                { "nomount",    no_argument,    NULL,   'n' },
                 { 0 }
         };
         int opt, ret;
@@ -351,13 +323,14 @@ int main(int argc, char **argv)
         pretty_output = false;
         json_output = false;
         show_pinned = false;
+        block_mount = false;
         bin_name = argv[0];
 
         hash_init(prog_table.table);
         hash_init(map_table.table);
 
         opterr = 0;
-        while ((opt = getopt_long(argc, argv, "Vhpjfm",
+        while ((opt = getopt_long(argc, argv, "Vhpjfmn",
                                   options, NULL)) >= 0) {
                 switch (opt) {
                 case 'V':
@@ -384,6 +357,9 @@ int main(int argc, char **argv)
                 case 'm':
                         bpf_flags = MAPS_RELAX_COMPAT;
                         break;
+                case 'n':
+                        block_mount = true;
+                        break;
                 default:
                         p_err("unrecognized option '%s'", argv[optind - 1]);
                         if (json_output)
diff --git a/tools/bpf/bpftool/main.h b/tools/bpf/bpftool/main.h
index 0b37599f8cda..052c91d4dc55 100644
--- a/tools/bpf/bpftool/main.h
+++ b/tools/bpf/bpftool/main.h
@@ -1,35 +1,5 @@
-/*
- * Copyright (C) 2017-2018 Netronome Systems, Inc.
- *
- * This software is dual licensed under the GNU General License Version 2,
- * June 1991 as shown in the file COPYING in the top-level directory of this
- * source tree or the BSD 2-Clause License provided below.  You have the
- * option to license this software under the complete terms of either license.
- *
- * The BSD 2-Clause License:
- *
- *     Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *      1. Redistributions of source code must retain the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer.
- *
- *      2. Redistributions in binary form must reproduce the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer in the documentation and/or other materials
- *         provided with the distribution.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
+/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) */
+/* Copyright (C) 2017-2018 Netronome Systems, Inc. */
 
 #ifndef __BPF_TOOL_H
 #define __BPF_TOOL_H
@@ -74,7 +44,8 @@
 #define HELP_SPEC_PROGRAM                                               \
         "PROG := { id PROG_ID | pinned FILE | tag PROG_TAG }"
 #define HELP_SPEC_OPTIONS                                               \
-        "OPTIONS := { {-j|--json} [{-p|--pretty}] | {-f|--bpffs} | {-m|--mapcompat}"
+        "OPTIONS := { {-j|--json} [{-p|--pretty}] | {-f|--bpffs} |\n"   \
+        "\t            {-m|--mapcompat} | {-n|--nomount} }"
 #define HELP_SPEC_MAP                                                   \
         "MAP := { id MAP_ID | pinned FILE }"
 
@@ -115,6 +86,7 @@ extern const char *bin_name;
 extern json_writer_t *json_wtr;
 extern bool json_output;
 extern bool show_pinned;
+extern bool block_mount;
 extern int bpf_flags;
 extern struct pinned_obj_table prog_table;
 extern struct pinned_obj_table map_table;
@@ -128,6 +100,8 @@ void usage(void) __noreturn;
 
 void set_max_rlimit(void);
 
+int mount_tracefs(const char *target);
+
 struct pinned_obj_table {
         DECLARE_HASHTABLE(table, 16);
 };
@@ -177,8 +151,8 @@ int prog_parse_fd(int *argc, char ***argv);
 int map_parse_fd(int *argc, char ***argv);
 int map_parse_fd_and_info(int *argc, char ***argv, void *info, __u32 *info_len);
 
-#ifdef HAVE_LIBBFD_SUPPORT
 struct bpf_prog_linfo;
+#ifdef HAVE_LIBBFD_SUPPORT
 void disasm_print_insn(unsigned char *image, ssize_t len, int opcodes,
                        const char *arch, const char *disassembler_options,
                        const struct btf *btf,
diff --git a/tools/bpf/bpftool/map.c b/tools/bpf/bpftool/map.c
index 8469ea6cf1c8..2037e3dc864b 100644
--- a/tools/bpf/bpftool/map.c
+++ b/tools/bpf/bpftool/map.c
@@ -1,35 +1,5 @@
-/*
- * Copyright (C) 2017-2018 Netronome Systems, Inc.
- *
- * This software is dual licensed under the GNU General License Version 2,
- * June 1991 as shown in the file COPYING in the top-level directory of this
- * source tree or the BSD 2-Clause License provided below.  You have the
- * option to license this software under the complete terms of either license.
- *
- * The BSD 2-Clause License:
- *
- *     Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *      1. Redistributions of source code must retain the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer.
- *
- *      2. Redistributions in binary form must reproduce the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer in the documentation and/or other materials
- *         provided with the distribution.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+/* Copyright (C) 2017-2018 Netronome Systems, Inc. */
 
 #include <assert.h>
 #include <errno.h>
diff --git a/tools/bpf/bpftool/map_perf_ring.c b/tools/bpf/bpftool/map_perf_ring.c
index bdaf4062e26e..0507dfaf7a8f 100644
--- a/tools/bpf/bpftool/map_perf_ring.c
+++ b/tools/bpf/bpftool/map_perf_ring.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0-only
+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
 /* Copyright (C) 2018 Netronome Systems, Inc. */
 /* This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
diff --git a/tools/bpf/bpftool/net.c b/tools/bpf/bpftool/net.c
index d441bb7035ca..db0e7de49d49 100644
--- a/tools/bpf/bpftool/net.c
+++ b/tools/bpf/bpftool/net.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0+
+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
 // Copyright (C) 2018 Facebook
 
 #define _GNU_SOURCE
diff --git a/tools/bpf/bpftool/netlink_dumper.c b/tools/bpf/bpftool/netlink_dumper.c
index 4e9f4531269f..550a0f537eed 100644
--- a/tools/bpf/bpftool/netlink_dumper.c
+++ b/tools/bpf/bpftool/netlink_dumper.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0+
+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
 // Copyright (C) 2018 Facebook
 
 #include <stdlib.h>
diff --git a/tools/bpf/bpftool/netlink_dumper.h b/tools/bpf/bpftool/netlink_dumper.h
index e3516b586a34..774af6c62ef5 100644
--- a/tools/bpf/bpftool/netlink_dumper.h
+++ b/tools/bpf/bpftool/netlink_dumper.h
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0+
+/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) */
 // Copyright (C) 2018 Facebook
 
 #ifndef _NETLINK_DUMPER_H_
diff --git a/tools/bpf/bpftool/perf.c b/tools/bpf/bpftool/perf.c
index b76b77dcfd1f..f2a545e667c4 100644
--- a/tools/bpf/bpftool/perf.c
+++ b/tools/bpf/bpftool/perf.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0+
+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
 // Copyright (C) 2018 Facebook
 // Author: Yonghong Song <yhs@fb.com>
 
diff --git a/tools/bpf/bpftool/prog.c b/tools/bpf/bpftool/prog.c
index b73b4e473948..2d1bb7d6ff51 100644
--- a/tools/bpf/bpftool/prog.c
+++ b/tools/bpf/bpftool/prog.c
@@ -1,35 +1,5 @@
-/*
- * Copyright (C) 2017-2018 Netronome Systems, Inc.
- *
- * This software is dual licensed under the GNU General License Version 2,
- * June 1991 as shown in the file COPYING in the top-level directory of this
- * source tree or the BSD 2-Clause License provided below.  You have the
- * option to license this software under the complete terms of either license.
- *
- * The BSD 2-Clause License:
- *
- *     Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *      1. Redistributions of source code must retain the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer.
- *
- *      2. Redistributions in binary form must reproduce the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer in the documentation and/or other materials
- *         provided with the distribution.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+/* Copyright (C) 2017-2018 Netronome Systems, Inc. */
 
 #define _GNU_SOURCE
 #include <errno.h>
@@ -62,7 +32,7 @@ static const char * const attach_type_strings[] = {
         [__MAX_BPF_ATTACH_TYPE] = NULL,
 };
 
-enum bpf_attach_type parse_attach_type(const char *str)
+static enum bpf_attach_type parse_attach_type(const char *str)
 {
         enum bpf_attach_type type;
 
@@ -626,13 +596,6 @@ static int do_dump(int argc, char **argv)
                 goto err_free;
         }
 
-        if (func_info && !info.func_info) {
-                /* kernel.kptr_restrict is set.  No func_info available. */
-                free(func_info);
-                func_info = NULL;
-                nr_finfo = 0;
-        }
-
         if (linfo && info.nr_line_info != nr_linfo) {
                 p_err("incorrect nr_line_info %u vs. expected %u",
                       info.nr_line_info, nr_linfo);
@@ -835,7 +798,7 @@ struct map_replace {
         char *name;
 };
 
-int map_replace_compar(const void *p1, const void *p2)
+static int map_replace_compar(const void *p1, const void *p2)
 {
         const struct map_replace *a = p1, *b = p2;
 
diff --git a/tools/bpf/bpftool/tracelog.c b/tools/bpf/bpftool/tracelog.c
index 1fa8e513f590..e80a5c79b38f 100644
--- a/tools/bpf/bpftool/tracelog.c
+++ b/tools/bpf/bpftool/tracelog.c
@@ -54,7 +54,7 @@ find_tracefs_mnt_single(unsigned long magic, char *mnt, const char *mntpt)
         return true;
 }
 
-static bool find_tracefs_pipe(char *mnt)
+static bool get_tracefs_pipe(char *mnt)
 {
         static const char * const known_mnts[] = {
                 "/sys/kernel/debug/tracing",
@@ -88,7 +88,20 @@ static bool find_tracefs_pipe(char *mnt)
         fclose(fp);
 
         /* The string from fscanf() might be truncated, check mnt is valid */
-        if (!found || validate_tracefs_mnt(mnt, TRACEFS_MAGIC))
+        if (found && validate_tracefs_mnt(mnt, TRACEFS_MAGIC))
+                goto exit_found;
+
+        if (block_mount)
+                return false;
+
+        p_info("could not find tracefs, attempting to mount it now");
+        /* Most of the time, tracefs is automatically mounted by debugfs at
+         * /sys/kernel/debug/tracing when we try to access it. If we could not
+         * find it, it is likely that debugfs is not mounted. Let's give one
+         * attempt at mounting just tracefs at /sys/kernel/tracing.
+         */
+        strcpy(mnt, known_mnts[1]);
+        if (mount_tracefs(mnt))
                 return false;
 
 exit_found:
@@ -115,17 +128,13 @@ int do_tracelog(int argc, char **argv)
                 .sa_handler = exit_tracelog
         };
         char trace_pipe[PATH_MAX];
-        bool found_trace_pipe;
         size_t buff_len = 0;
 
         if (json_output)
                 jsonw_start_array(json_wtr);
 
-        found_trace_pipe = find_tracefs_pipe(trace_pipe);
-        if (!found_trace_pipe) {
-                p_err("could not find trace pipe, tracefs not mounted?");
+        if (!get_tracefs_pipe(trace_pipe))
                 return -1;
-        }
 
         trace_pipe_fd = fopen(trace_pipe, "r");
         if (!trace_pipe_fd) {
diff --git a/tools/bpf/bpftool/xlated_dumper.c b/tools/bpf/bpftool/xlated_dumper.c
index aef628dcccb6..7073dbe1ff27 100644
--- a/tools/bpf/bpftool/xlated_dumper.c
+++ b/tools/bpf/bpftool/xlated_dumper.c
@@ -1,39 +1,5 @@
 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
-/*
- * Copyright (C) 2018 Netronome Systems, Inc.
- *
- * This software is dual licensed under the GNU General License Version 2,
- * June 1991 as shown in the file COPYING in the top-level directory of this
- * source tree or the BSD 2-Clause License provided below.  You have the
- * option to license this software under the complete terms of either license.
- *
- * The BSD 2-Clause License:
- *
- *     Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *      1. Redistributions of source code must retain the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer.
- *
- *      2. Redistributions in binary form must reproduce the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer in the documentation and/or other materials
- *         provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
+/* Copyright (C) 2018 Netronome Systems, Inc. */
 
 #define _GNU_SOURCE
 #include <stdarg.h>
@@ -115,7 +81,7 @@ struct kernel_sym *kernel_syms_search(struct dump_data *dd,
                        sizeof(*dd->sym_mapping), kernel_syms_cmp) : NULL;
 }
 
-static void print_insn(void *private_data, const char *fmt, ...)
+static void __printf(2, 3) print_insn(void *private_data, const char *fmt, ...)
 {
         va_list args;
 
@@ -124,7 +90,7 @@ static void print_insn(void *private_data, const char *fmt, ...)
         va_end(args);
 }
 
-static void
+static void __printf(2, 3)
 print_insn_for_graph(void *private_data, const char *fmt, ...)
 {
         char buf[64], *p;
@@ -155,7 +121,8 @@ print_insn_for_graph(void *private_data, const char *fmt, ...)
         printf("%s", buf);
 }
 
-static void print_insn_json(void *private_data, const char *fmt, ...)
+static void __printf(2, 3)
+print_insn_json(void *private_data, const char *fmt, ...)
 {
         unsigned int l = strlen(fmt);
         char chomped_fmt[l];
diff --git a/tools/bpf/bpftool/xlated_dumper.h b/tools/bpf/bpftool/xlated_dumper.h
index a24f89df8cb2..54847e174273 100644
--- a/tools/bpf/bpftool/xlated_dumper.h
+++ b/tools/bpf/bpftool/xlated_dumper.h
@@ -1,39 +1,5 @@
-// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
-/*
- * Copyright (C) 2018 Netronome Systems, Inc.
- *
- * This software is dual licensed under the GNU General License Version 2,
- * June 1991 as shown in the file COPYING in the top-level directory of this
- * source tree or the BSD 2-Clause License provided below.  You have the
- * option to license this software under the complete terms of either license.
- *
- * The BSD 2-Clause License:
- *
- *     Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *      1. Redistributions of source code must retain the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer.
- *
- *      2. Redistributions in binary form must reproduce the above
- *         copyright notice, this list of conditions and the following
- *         disclaimer in the documentation and/or other materials
- *         provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
+/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) */
+/* Copyright (C) 2018 Netronome Systems, Inc. */
 
 #ifndef __BPF_TOOL_XLATED_DUMPER_H
 #define __BPF_TOOL_XLATED_DUMPER_H
diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h
index aa582cd5bfcf..91c43884f295 100644
--- a/tools/include/uapi/linux/bpf.h
+++ b/tools/include/uapi/linux/bpf.h
@@ -133,6 +133,14 @@ enum bpf_map_type {
         BPF_MAP_TYPE_STACK,
 };
 
+/* Note that tracing related programs such as
+ * BPF_PROG_TYPE_{KPROBE,TRACEPOINT,PERF_EVENT,RAW_TRACEPOINT}
+ * are not subject to a stable API since kernel internal data
+ * structures can change from release to release and may
+ * therefore break existing tracing BPF programs. Tracing BPF
+ * programs correspond to /a/ specific kernel which is to be
+ * analyzed, and not /a/ specific kernel /and/ all future ones.
+ */
 enum bpf_prog_type {
         BPF_PROG_TYPE_UNSPEC,
         BPF_PROG_TYPE_SOCKET_FILTER,
@@ -343,7 +351,7 @@ union bpf_attr {
                 __u32           log_level;      /* verbosity level of verifier */
                 __u32           log_size;       /* size of user buffer */
                 __aligned_u64   log_buf;        /* user supplied buffer */
-                __u32           kern_version;   /* checked when prog_type=kprobe */
+                __u32           kern_version;   /* not used */
                 __u32           prog_flags;
                 char            prog_name[BPF_OBJ_NAME_LEN];
                 __u32           prog_ifindex;   /* ifindex of netdev to prep for */
@@ -2657,6 +2665,7 @@ struct sk_msg_md {
         __u32 local_ip6[4];     /* Stored in network byte order */
         __u32 remote_port;      /* Stored in network byte order */
         __u32 local_port;       /* stored in host byte order */
+        __u32 size;             /* Total size of sk_msg */
 };
 
 struct sk_reuseport_md {
@@ -2717,6 +2726,8 @@ struct bpf_prog_info {
         __u32 nr_jited_line_info;
         __u32 line_info_rec_size;
         __u32 jited_line_info_rec_size;
+        __u32 nr_prog_tags;
+        __aligned_u64 prog_tags;
 } __attribute__((aligned(8)));
 
 struct bpf_map_info {
diff --git a/tools/include/uapi/linux/btf.h b/tools/include/uapi/linux/btf.h
index 14f66948fc95..7b7475ef2f17 100644
--- a/tools/include/uapi/linux/btf.h
+++ b/tools/include/uapi/linux/btf.h
@@ -34,7 +34,9 @@ struct btf_type {
          * bits  0-15: vlen (e.g. # of struct's members)
          * bits 16-23: unused
          * bits 24-27: kind (e.g. int, ptr, array...etc)
-         * bits 28-31: unused
+         * bits 28-30: unused
+         * bit     31: kind_flag, currently used by
+         *             struct, union and fwd
          */
         __u32 info;
         /* "size" is used by INT, ENUM, STRUCT and UNION.
@@ -52,6 +54,7 @@ struct btf_type {
 
 #define BTF_INFO_KIND(info)     (((info) >> 24) & 0x0f)
 #define BTF_INFO_VLEN(info)     ((info) & 0xffff)
+#define BTF_INFO_KFLAG(info)    ((info) >> 31)
 
 #define BTF_KIND_UNKN           0       /* Unknown      */
 #define BTF_KIND_INT            1       /* Integer      */
@@ -110,9 +113,22 @@ struct btf_array {
 struct btf_member {
         __u32   name_off;
         __u32   type;
-        __u32   offset; /* offset in bits */
+        /* If the type info kind_flag is set, the btf_member offset
+         * contains both member bitfield size and bit offset. The
+         * bitfield size is set for bitfield members. If the type
+         * info kind_flag is not set, the offset contains only bit
+         * offset.
+         */
+        __u32   offset;
 };
 
+/* If the struct/union type info kind_flag is set, the
+ * following two macros are used to access bitfield_size
+ * and bit_offset from btf_member.offset.
+ */
+#define BTF_MEMBER_BITFIELD_SIZE(val)   ((val) >> 24)
+#define BTF_MEMBER_BIT_OFFSET(val)      ((val) & 0xffffff)
+
 /* BTF_KIND_FUNC_PROTO is followed by multiple "struct btf_param".
  * The exact number of btf_param is stored in the vlen (of the
  * info in "struct btf_type").
diff --git a/tools/lib/bpf/bpf_prog_linfo.c b/tools/lib/bpf/bpf_prog_linfo.c
index addd6e9971cc..6978314ea7f6 100644
--- a/tools/lib/bpf/bpf_prog_linfo.c
+++ b/tools/lib/bpf/bpf_prog_linfo.c
@@ -107,11 +107,7 @@ struct bpf_prog_linfo *bpf_prog_linfo__new(const struct bpf_prog_info *info)
 
         nr_linfo = info->nr_line_info;
 
-        /*
-         * Test !info->line_info because the kernel may NULL
-         * the ptr if kernel.kptr_restrict is set.
-         */
-        if (!nr_linfo || !info->line_info)
+        if (!nr_linfo)
                 return NULL;
 
         /*
diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index e2bc75ee1614..169e347c76f6 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -266,6 +266,7 @@ void bpf_program__unload(struct bpf_program *prog)
 
         zclose(prog->btf_fd);
         zfree(&prog->func_info);
+        zfree(&prog->line_info);
 }
 
 static void bpf_program__exit(struct bpf_program *prog)
diff --git a/tools/testing/selftests/bpf/.gitignore b/tools/testing/selftests/bpf/.gitignore
index 1b799e30c06d..4a9785043a39 100644
--- a/tools/testing/selftests/bpf/.gitignore
+++ b/tools/testing/selftests/bpf/.gitignore
@@ -27,3 +27,4 @@ test_flow_dissector
 flow_dissector_load
 test_netcnt
 test_section_names
+test_tcpnotify_user
diff --git a/tools/testing/selftests/bpf/connect4_prog.c b/tools/testing/selftests/bpf/connect4_prog.c
index b8395f3c43e9..1fd244d35ba9 100644
--- a/tools/testing/selftests/bpf/connect4_prog.c
+++ b/tools/testing/selftests/bpf/connect4_prog.c
@@ -35,9 +35,11 @@ int connect_v4_prog(struct bpf_sock_addr *ctx)
         if (ctx->type != SOCK_STREAM && ctx->type != SOCK_DGRAM)
                 return 0;
         else if (ctx->type == SOCK_STREAM)
-                sk = bpf_sk_lookup_tcp(ctx, &tuple, sizeof(tuple.ipv4), 0, 0);
+                sk = bpf_sk_lookup_tcp(ctx, &tuple, sizeof(tuple.ipv4),
+                                       BPF_F_CURRENT_NETNS, 0);
         else
-                sk = bpf_sk_lookup_udp(ctx, &tuple, sizeof(tuple.ipv4), 0, 0);
+                sk = bpf_sk_lookup_udp(ctx, &tuple, sizeof(tuple.ipv4),
+                                       BPF_F_CURRENT_NETNS, 0);
 
         if (!sk)
                 return 0;
diff --git a/tools/testing/selftests/bpf/connect6_prog.c b/tools/testing/selftests/bpf/connect6_prog.c
index 25f5dc7b7aa0..26397ab7b3c7 100644
--- a/tools/testing/selftests/bpf/connect6_prog.c
+++ b/tools/testing/selftests/bpf/connect6_prog.c
@@ -47,9 +47,11 @@ int connect_v6_prog(struct bpf_sock_addr *ctx)
         if (ctx->type != SOCK_STREAM && ctx->type != SOCK_DGRAM)
                 return 0;
         else if (ctx->type == SOCK_STREAM)
-                sk = bpf_sk_lookup_tcp(ctx, &tuple, sizeof(tuple.ipv6), 0, 0);
+                sk = bpf_sk_lookup_tcp(ctx, &tuple, sizeof(tuple.ipv6),
+                                       BPF_F_CURRENT_NETNS, 0);
         else
-                sk = bpf_sk_lookup_udp(ctx, &tuple, sizeof(tuple.ipv6), 0, 0);
+                sk = bpf_sk_lookup_udp(ctx, &tuple, sizeof(tuple.ipv6),
+                                       BPF_F_CURRENT_NETNS, 0);
 
         if (!sk)
                 return 0;
diff --git a/tools/testing/selftests/bpf/netcnt_prog.c b/tools/testing/selftests/bpf/netcnt_prog.c
index 1198abca1360..9f741e69cebe 100644
--- a/tools/testing/selftests/bpf/netcnt_prog.c
+++ b/tools/testing/selftests/bpf/netcnt_prog.c
@@ -16,12 +16,18 @@ struct bpf_map_def SEC("maps") percpu_netcnt = {
         .value_size = sizeof(struct percpu_net_cnt),
 };
 
+BPF_ANNOTATE_KV_PAIR(percpu_netcnt, struct bpf_cgroup_storage_key,
+                     struct percpu_net_cnt);
+
 struct bpf_map_def SEC("maps") netcnt = {
         .type = BPF_MAP_TYPE_CGROUP_STORAGE,
         .key_size = sizeof(struct bpf_cgroup_storage_key),
         .value_size = sizeof(struct net_cnt),
 };
 
+BPF_ANNOTATE_KV_PAIR(netcnt, struct bpf_cgroup_storage_key,
+                     struct net_cnt);
+
 SEC("cgroup/skb")
 int bpf_nextcnt(struct __sk_buff *skb)
 {
diff --git a/tools/testing/selftests/bpf/test_btf.c b/tools/testing/selftests/bpf/test_btf.c
index f570e0a39959..8bcd38010582 100644
--- a/tools/testing/selftests/bpf/test_btf.c
+++ b/tools/testing/selftests/bpf/test_btf.c
@@ -65,8 +65,8 @@ static int __base_pr(const char *format, ...)
         return err;
 }
 
-#define BTF_INFO_ENC(kind, root, vlen)                  \
-        ((!!(root) << 31) | ((kind) << 24) | ((vlen) & BTF_MAX_VLEN))
+#define BTF_INFO_ENC(kind, kind_flag, vlen)                     \
+        ((!!(kind_flag) << 31) | ((kind) << 24) | ((vlen) & BTF_MAX_VLEN))
 
 #define BTF_TYPE_ENC(name, info, size_or_type)  \
         (name), (info), (size_or_type)
@@ -86,6 +86,8 @@ static int __base_pr(const char *format, ...)
 #define BTF_MEMBER_ENC(name, type, bits_offset) \
         (name), (type), (bits_offset)
 #define BTF_ENUM_ENC(name, val) (name), (val)
+#define BTF_MEMBER_OFFSET(bitfield_size, bits_offset) \
+        ((bitfield_size) << 24 | (bits_offset))
 
 #define BTF_TYPEDEF_ENC(name, type) \
         BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_TYPEDEF, 0, 0), type)
@@ -2215,6 +2217,496 @@ static struct btf_raw_test raw_tests[] = {
         .err_str = "Invalid type_id",
 },
 
+{
+        .descr = "invalid int kind_flag",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_INT, 1, 0), 4),   /* [2] */
+                BTF_INT_ENC(0, 0, 32),
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC(""),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "int_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Invalid btf_info kind_flag",
+},
+
+{
+        .descr = "invalid ptr kind_flag",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 1, 0), 1),   /* [2] */
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC(""),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "ptr_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Invalid btf_info kind_flag",
+},
+
+{
+        .descr = "invalid array kind_flag",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ARRAY, 1, 0), 0), /* [2] */
+                BTF_ARRAY_ENC(1, 1, 1),
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC(""),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "array_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Invalid btf_info kind_flag",
+},
+
+{
+        .descr = "invalid enum kind_flag",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 1, 1), 4),  /* [2] */
+                BTF_ENUM_ENC(NAME_TBD, 0),
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "enum_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Invalid btf_info kind_flag",
+},
+
+{
+        .descr = "valid fwd kind_flag",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
+                BTF_TYPE_ENC(NAME_TBD,
+                             BTF_INFO_ENC(BTF_KIND_FWD, 1, 0), 0),      /* [2] */
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "fwd_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+},
+
+{
+        .descr = "invalid typedef kind_flag",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
+                BTF_TYPE_ENC(NAME_TBD,
+                             BTF_INFO_ENC(BTF_KIND_TYPEDEF, 1, 0), 1),  /* [2] */
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "typedef_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Invalid btf_info kind_flag",
+},
+
+{
+        .descr = "invalid volatile kind_flag",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_VOLATILE, 1, 0), 1),      /* [2] */
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC(""),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "volatile_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Invalid btf_info kind_flag",
+},
+
+{
+        .descr = "invalid const kind_flag",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 1, 0), 1), /* [2] */
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC(""),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "const_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Invalid btf_info kind_flag",
+},
+
+{
+        .descr = "invalid restrict kind_flag",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_RESTRICT, 1, 0), 1),      /* [2] */
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC(""),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "restrict_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Invalid btf_info kind_flag",
+},
+
+{
+        .descr = "invalid func kind_flag",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 0), 0),    /* [2] */
+                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FUNC, 1, 0), 2),   /* [3] */
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "func_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Invalid btf_info kind_flag",
+},
+
+{
+        .descr = "invalid func_proto kind_flag",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 1, 0), 0),    /* [2] */
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC(""),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "func_proto_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Invalid btf_info kind_flag",
+},
+
+{
+        .descr = "valid struct, kind_flag, bitfield_size = 0",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 8),        /* [2] */
+                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(0, 0)),
+                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(0, 32)),
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A\0B"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "struct_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+},
+
+{
+        .descr = "valid struct, kind_flag, int member, bitfield_size != 0",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),        /* [2] */
+                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 0)),
+                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 4)),
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A\0B"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "struct_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+},
+
+{
+        .descr = "valid union, kind_flag, int member, bitfield_size != 0",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 4), /* [2] */
+                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 0)),
+                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 0)),
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A\0B"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "union_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+},
+
+{
+        .descr = "valid struct, kind_flag, enum member, bitfield_size != 0",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),  /* [2] */
+                BTF_ENUM_ENC(NAME_TBD, 0),
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),/* [3] */
+                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 0)),
+                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 4)),
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A\0B\0C"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "struct_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+},
+
+{
+        .descr = "valid union, kind_flag, enum member, bitfield_size != 0",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),  /* [2] */
+                BTF_ENUM_ENC(NAME_TBD, 0),
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 4), /* [3] */
+                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 0)),
+                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 0)),
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A\0B\0C"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "union_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+},
+
+{
+        .descr = "valid struct, kind_flag, typedef member, bitfield_size != 0",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),  /* [2] */
+                BTF_ENUM_ENC(NAME_TBD, 0),
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),/* [3] */
+                BTF_MEMBER_ENC(NAME_TBD, 4, BTF_MEMBER_OFFSET(4, 0)),
+                BTF_MEMBER_ENC(NAME_TBD, 5, BTF_MEMBER_OFFSET(4, 4)),
+                BTF_TYPEDEF_ENC(NAME_TBD, 1),                           /* [4] */
+                BTF_TYPEDEF_ENC(NAME_TBD, 2),                           /* [5] */
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A\0B\0C\0D\0E"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "struct_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+},
+
+{
+        .descr = "valid union, kind_flag, typedef member, bitfield_size != 0",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),  /* [2] */
+                BTF_ENUM_ENC(NAME_TBD, 0),
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 4), /* [3] */
+                BTF_MEMBER_ENC(NAME_TBD, 4, BTF_MEMBER_OFFSET(4, 0)),
+                BTF_MEMBER_ENC(NAME_TBD, 5, BTF_MEMBER_OFFSET(4, 0)),
+                BTF_TYPEDEF_ENC(NAME_TBD, 1),                           /* [4] */
+                BTF_TYPEDEF_ENC(NAME_TBD, 2),                           /* [5] */
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A\0B\0C\0D\0E"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "union_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+},
+
+{
+        .descr = "invalid struct, kind_flag, bitfield_size greater than struct size",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),        /* [2] */
+                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(20, 0)),
+                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(20, 20)),
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A\0B"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "struct_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Member exceeds struct_size",
+},
+
+{
+        .descr = "invalid struct, kind_flag, bitfield base_type int not regular",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 20, 4),                  /* [2] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),        /* [3] */
+                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(20, 0)),
+                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(20, 20)),
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A\0B"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "struct_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Invalid member base type",
+},
+
+{
+        .descr = "invalid struct, kind_flag, base_type int not regular",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 12, 4),                  /* [2] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),        /* [3] */
+                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(8, 0)),
+                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(8, 8)),
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A\0B"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "struct_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Invalid member base type",
+},
+
+{
+        .descr = "invalid union, kind_flag, bitfield_size greater than struct size",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 2), /* [2] */
+                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(8, 0)),
+                BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(20, 0)),
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A\0B"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "union_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Member exceeds struct_size",
+},
+
+{
+        .descr = "invalid struct, kind_flag, int member, bitfield_size = 0, wrong byte alignment",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [2] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 12),       /* [3] */
+                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 0)),
+                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 36)),
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A\0B"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "struct_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Invalid member offset",
+},
+
+{
+        .descr = "invalid struct, kind_flag, enum member, bitfield_size = 0, wrong byte alignment",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [1] */
+                BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),                  /* [2] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),  /* [2] */
+                BTF_ENUM_ENC(NAME_TBD, 0),
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 12),       /* [3] */
+                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 0)),
+                BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 36)),
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0A\0B\0C"),
+        .map_type = BPF_MAP_TYPE_ARRAY,
+        .map_name = "struct_type_check_btf",
+        .key_size = sizeof(int),
+        .value_size = sizeof(int),
+        .key_type_id = 1,
+        .value_type_id = 1,
+        .max_entries = 4,
+        .btf_load_err = true,
+        .err_str = "Invalid member offset",
+},
+
 }; /* struct btf_raw_test raw_tests[] */
 
 static const char *get_next_str(const char *start, const char *end)
@@ -2916,7 +3408,7 @@ static int do_test_file(unsigned int test_num)
                 goto done;
         }
         rec_size = info.func_info_rec_size;
-        if (CHECK(rec_size < 4,
+        if (CHECK(rec_size != sizeof(struct bpf_func_info),
                   "incorrect info.func_info_rec_size (1st) %d\n", rec_size)) {
                 err = -1;
                 goto done;
@@ -3036,7 +3528,8 @@ struct pprint_mapv {
         } aenum;
 };
 
-static struct btf_raw_test pprint_test_template = {
+static struct btf_raw_test pprint_test_template[] = {
+{
         .raw_types = {
                 /* unsighed char */                     /* [1] */
                 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 8, 1),
@@ -3086,13 +3579,140 @@ static struct btf_raw_test pprint_test_template = {
                 BTF_MEMBER_ENC(NAME_TBD, 15, 192),      /* aenum */
                 BTF_END_RAW,
         },
-        .str_sec = "\0unsigned char\0unsigned short\0unsigned int\0int\0unsigned long long\0uint8_t\0uint16_t\0uint32_t\0int32_t\0uint64_t\0ui64\0ui8a\0ENUM_ZERO\0ENUM_ONE\0ENUM_TWO\0ENUM_THREE\0pprint_mapv\0ui32\0ui16\0si32\0unused_bits2a\0bits28\0unused_bits2b\0aenum",
-        .str_sec_size = sizeof("\0unsigned char\0unsigned short\0unsigned int\0int\0unsigned long long\0uint8_t\0uint16_t\0uint32_t\0int32_t\0uint64_t\0ui64\0ui8a\0ENUM_ZERO\0ENUM_ONE\0ENUM_TWO\0ENUM_THREE\0pprint_mapv\0ui32\0ui16\0si32\0unused_bits2a\0bits28\0unused_bits2b\0aenum"),
+        BTF_STR_SEC("\0unsigned char\0unsigned short\0unsigned int\0int\0unsigned long long\0uint8_t\0uint16_t\0uint32_t\0int32_t\0uint64_t\0ui64\0ui8a\0ENUM_ZERO\0ENUM_ONE\0ENUM_TWO\0ENUM_THREE\0pprint_mapv\0ui32\0ui16\0si32\0unused_bits2a\0bits28\0unused_bits2b\0aenum"),
+        .key_size = sizeof(unsigned int),
+        .value_size = sizeof(struct pprint_mapv),
+        .key_type_id = 3,       /* unsigned int */
+        .value_type_id = 16,    /* struct pprint_mapv */
+        .max_entries = 128 * 1024,
+},
+
+{
+        /* this type will have the same type as the
+         * first .raw_types definition, but struct type will
+         * be encoded with kind_flag set.
+         */
+        .raw_types = {
+                /* unsighed char */                     /* [1] */
+                BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 8, 1),
+                /* unsigned short */                    /* [2] */
+                BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 16, 2),
+                /* unsigned int */                      /* [3] */
+                BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4),
+                /* int */                               /* [4] */
+                BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
+                /* unsigned long long */                /* [5] */
+                BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 64, 8),
+                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),       /* [6] */
+                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),       /* [7] */
+                /* uint8_t[8] */                        /* [8] */
+                BTF_TYPE_ARRAY_ENC(9, 1, 8),
+                /* typedef unsigned char uint8_t */     /* [9] */
+                BTF_TYPEDEF_ENC(NAME_TBD, 1),
+                /* typedef unsigned short uint16_t */   /* [10] */
+                BTF_TYPEDEF_ENC(NAME_TBD, 2),
+                /* typedef unsigned int uint32_t */     /* [11] */
+                BTF_TYPEDEF_ENC(NAME_TBD, 3),
+                /* typedef int int32_t */               /* [12] */
+                BTF_TYPEDEF_ENC(NAME_TBD, 4),
+                /* typedef unsigned long long uint64_t *//* [13] */
+                BTF_TYPEDEF_ENC(NAME_TBD, 5),
+                /* union (anon) */                      /* [14] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 0, 2), 8),
+                BTF_MEMBER_ENC(NAME_TBD, 13, 0),/* uint64_t ui64; */
+                BTF_MEMBER_ENC(NAME_TBD, 8, 0), /* uint8_t ui8a[8]; */
+                /* enum (anon) */                       /* [15] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 4), 4),
+                BTF_ENUM_ENC(NAME_TBD, 0),
+                BTF_ENUM_ENC(NAME_TBD, 1),
+                BTF_ENUM_ENC(NAME_TBD, 2),
+                BTF_ENUM_ENC(NAME_TBD, 3),
+                /* struct pprint_mapv */                /* [16] */
+                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 8), 32),
+                BTF_MEMBER_ENC(NAME_TBD, 11, BTF_MEMBER_OFFSET(0, 0)),  /* uint32_t ui32 */
+                BTF_MEMBER_ENC(NAME_TBD, 10, BTF_MEMBER_OFFSET(0, 32)), /* uint16_t ui16 */
+                BTF_MEMBER_ENC(NAME_TBD, 12, BTF_MEMBER_OFFSET(0, 64)), /* int32_t si32 */
+                BTF_MEMBER_ENC(NAME_TBD, 6, BTF_MEMBER_OFFSET(2, 96)),  /* unused_bits2a */
+                BTF_MEMBER_ENC(NAME_TBD, 7, BTF_MEMBER_OFFSET(28, 98)), /* bits28 */
+                BTF_MEMBER_ENC(NAME_TBD, 6, BTF_MEMBER_OFFSET(2, 126)), /* unused_bits2b */
+                BTF_MEMBER_ENC(0, 14, BTF_MEMBER_OFFSET(0, 128)),       /* union (anon) */
+                BTF_MEMBER_ENC(NAME_TBD, 15, BTF_MEMBER_OFFSET(0, 192)),        /* aenum */
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0unsigned char\0unsigned short\0unsigned int\0int\0unsigned long long\0uint8_t\0uint16_t\0uint32_t\0int32_t\0uint64_t\0ui64\0ui8a\0ENUM_ZERO\0ENUM_ONE\0ENUM_TWO\0ENUM_THREE\0pprint_mapv\0ui32\0ui16\0si32\0unused_bits2a\0bits28\0unused_bits2b\0aenum"),
+        .key_size = sizeof(unsigned int),
+        .value_size = sizeof(struct pprint_mapv),
+        .key_type_id = 3,       /* unsigned int */
+        .value_type_id = 16,    /* struct pprint_mapv */
+        .max_entries = 128 * 1024,
+},
+
+{
+        /* this type will have the same layout as the
+         * first .raw_types definition. The struct type will
+         * be encoded with kind_flag set, bitfield members
+         * are added typedef/const/volatile, and bitfield members
+         * will have both int and enum types.
+         */
+        .raw_types = {
+                /* unsighed char */                     /* [1] */
+                BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 8, 1),
+                /* unsigned short */                    /* [2] */
+                BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 16, 2),
+                /* unsigned int */                      /* [3] */
+                BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4),
+                /* int */                               /* [4] */
+                BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
+                /* unsigned long long */                /* [5] */
+                BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 64, 8),
+                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),       /* [6] */
+                BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),       /* [7] */
+                /* uint8_t[8] */                        /* [8] */
+                BTF_TYPE_ARRAY_ENC(9, 1, 8),
+                /* typedef unsigned char uint8_t */     /* [9] */
+                BTF_TYPEDEF_ENC(NAME_TBD, 1),
+                /* typedef unsigned short uint16_t */   /* [10] */
+                BTF_TYPEDEF_ENC(NAME_TBD, 2),
+                /* typedef unsigned int uint32_t */     /* [11] */
+                BTF_TYPEDEF_ENC(NAME_TBD, 3),
+                /* typedef int int32_t */               /* [12] */
+                BTF_TYPEDEF_ENC(NAME_TBD, 4),
+                /* typedef unsigned long long uint64_t *//* [13] */
+                BTF_TYPEDEF_ENC(NAME_TBD, 5),
+                /* union (anon) */                      /* [14] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 0, 2), 8),
+                BTF_MEMBER_ENC(NAME_TBD, 13, 0),/* uint64_t ui64; */
+                BTF_MEMBER_ENC(NAME_TBD, 8, 0), /* uint8_t ui8a[8]; */
+                /* enum (anon) */                       /* [15] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 4), 4),
+                BTF_ENUM_ENC(NAME_TBD, 0),
+                BTF_ENUM_ENC(NAME_TBD, 1),
+                BTF_ENUM_ENC(NAME_TBD, 2),
+                BTF_ENUM_ENC(NAME_TBD, 3),
+                /* struct pprint_mapv */                /* [16] */
+                BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 8), 32),
+                BTF_MEMBER_ENC(NAME_TBD, 11, BTF_MEMBER_OFFSET(0, 0)),  /* uint32_t ui32 */
+                BTF_MEMBER_ENC(NAME_TBD, 10, BTF_MEMBER_OFFSET(0, 32)), /* uint16_t ui16 */
+                BTF_MEMBER_ENC(NAME_TBD, 12, BTF_MEMBER_OFFSET(0, 64)), /* int32_t si32 */
+                BTF_MEMBER_ENC(NAME_TBD, 17, BTF_MEMBER_OFFSET(2, 96)), /* unused_bits2a */
+                BTF_MEMBER_ENC(NAME_TBD, 7, BTF_MEMBER_OFFSET(28, 98)), /* bits28 */
+                BTF_MEMBER_ENC(NAME_TBD, 19, BTF_MEMBER_OFFSET(2, 126)),/* unused_bits2b */
+                BTF_MEMBER_ENC(0, 14, BTF_MEMBER_OFFSET(0, 128)),       /* union (anon) */
+                BTF_MEMBER_ENC(NAME_TBD, 15, BTF_MEMBER_OFFSET(0, 192)),        /* aenum */
+                /* typedef unsigned int ___int */       /* [17] */
+                BTF_TYPEDEF_ENC(NAME_TBD, 18),
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_VOLATILE, 0, 0), 6),      /* [18] */
+                BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 15),        /* [19] */
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0unsigned char\0unsigned short\0unsigned int\0int\0unsigned long long\0uint8_t\0uint16_t\0uint32_t\0int32_t\0uint64_t\0ui64\0ui8a\0ENUM_ZERO\0ENUM_ONE\0ENUM_TWO\0ENUM_THREE\0pprint_mapv\0ui32\0ui16\0si32\0unused_bits2a\0bits28\0unused_bits2b\0aenum\0___int"),
         .key_size = sizeof(unsigned int),
         .value_size = sizeof(struct pprint_mapv),
         .key_type_id = 3,       /* unsigned int */
         .value_type_id = 16,    /* struct pprint_mapv */
         .max_entries = 128 * 1024,
+},
+
 };
 
 static struct btf_pprint_test_meta {
@@ -3195,9 +3815,9 @@ static int check_line(const char *expected_line, int nexpected_line,
 }
 
 
-static int do_test_pprint(void)
+static int do_test_pprint(int test_num)
 {
-        const struct btf_raw_test *test = &pprint_test_template;
+        const struct btf_raw_test *test = &pprint_test_template[test_num];
         struct bpf_create_map_attr create_attr = {};
         bool ordered_map, lossless_map, percpu_map;
         int err, ret, num_cpus, rounded_value_size;
@@ -3213,7 +3833,7 @@ static int do_test_pprint(void)
         uint8_t *raw_btf;
         ssize_t nread;
 
-        fprintf(stderr, "%s......", test->descr);
+        fprintf(stderr, "%s(#%d)......", test->descr, test_num);
         raw_btf = btf_raw_create(&hdr_tmpl, test->raw_types,
                                  test->str_sec, test->str_sec_size,
                                  &raw_btf_size, NULL);
@@ -3406,15 +4026,27 @@ static int test_pprint(void)
         unsigned int i;
         int err = 0;
 
+        /* test various maps with the first test template */
         for (i = 0; i < ARRAY_SIZE(pprint_tests_meta); i++) {
-                pprint_test_template.descr = pprint_tests_meta[i].descr;
-                pprint_test_template.map_type = pprint_tests_meta[i].map_type;
-                pprint_test_template.map_name = pprint_tests_meta[i].map_name;
-                pprint_test_template.ordered_map = pprint_tests_meta[i].ordered_map;
-                pprint_test_template.lossless_map = pprint_tests_meta[i].lossless_map;
-                pprint_test_template.percpu_map = pprint_tests_meta[i].percpu_map;
-
-                err |= count_result(do_test_pprint());
+                pprint_test_template[0].descr = pprint_tests_meta[i].descr;
+                pprint_test_template[0].map_type = pprint_tests_meta[i].map_type;
+                pprint_test_template[0].map_name = pprint_tests_meta[i].map_name;
+                pprint_test_template[0].ordered_map = pprint_tests_meta[i].ordered_map;
+                pprint_test_template[0].lossless_map = pprint_tests_meta[i].lossless_map;
+                pprint_test_template[0].percpu_map = pprint_tests_meta[i].percpu_map;
+
+                err |= count_result(do_test_pprint(0));
+        }
+
+        /* test rest test templates with the first map */
+        for (i = 1; i < ARRAY_SIZE(pprint_test_template); i++) {
+                pprint_test_template[i].descr = pprint_tests_meta[0].descr;
+                pprint_test_template[i].map_type = pprint_tests_meta[0].map_type;
+                pprint_test_template[i].map_name = pprint_tests_meta[0].map_name;
+                pprint_test_template[i].ordered_map = pprint_tests_meta[0].ordered_map;
+                pprint_test_template[i].lossless_map = pprint_tests_meta[0].lossless_map;
+                pprint_test_template[i].percpu_map = pprint_tests_meta[0].percpu_map;
+                err |= count_result(do_test_pprint(i));
         }
 
         return err;
@@ -3622,6 +4254,33 @@ static struct prog_info_raw_test {
 },
 
 {
+        .descr = "line_info (Zero bpf insn code)",
+        .raw_types = {
+                BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),   /* [1] */
+                BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 64, 8),        /* [2] */
+                BTF_TYPEDEF_ENC(NAME_TBD, 2),                   /* [3] */
+                BTF_END_RAW,
+        },
+        BTF_STR_SEC("\0int\0unsigned long\0u64\0u64 a=1;\0return a;"),
+        .insns = {
+                BPF_LD_IMM64(BPF_REG_0, 1),
+                BPF_EXIT_INSN(),
+        },
+        .prog_type = BPF_PROG_TYPE_TRACEPOINT,
+        .func_info_cnt = 0,
+        .line_info = {
+                BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
+                BPF_LINE_INFO_ENC(1, 0, 0, 2, 9),
+                BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 8),
+                BTF_END_RAW,
+        },
+        .line_info_rec_size = sizeof(struct bpf_line_info),
+        .nr_jited_ksyms = 1,
+        .err_str = "Invalid insn code at line_info[1]",
+        .expected_prog_load_failure = true,
+},
+
+{
         .descr = "line_info (No subprog. zero tailing line_info",
         .raw_types = {
                 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),   /* [1] */
@@ -3912,7 +4571,7 @@ static int test_get_finfo(const struct prog_info_raw_test *test,
         }
 
         rec_size = info.func_info_rec_size;
-        if (CHECK(rec_size < 8,
+        if (CHECK(rec_size != sizeof(struct bpf_func_info),
                   "incorrect info.func_info_rec_size (1st) %d", rec_size)) {
                 return -1;
         }
@@ -3941,19 +4600,13 @@ static int test_get_finfo(const struct prog_info_raw_test *test,
                 err = -1;
                 goto done;
         }
-        if (CHECK(info.func_info_rec_size < 8,
+        if (CHECK(info.func_info_rec_size != rec_size,
                   "incorrect info.func_info_rec_size (2nd) %d",
                   info.func_info_rec_size)) {
                 err = -1;
                 goto done;
         }
 
-        if (CHECK(!info.func_info,
-                  "info.func_info == 0. kernel.kptr_restrict is set?")) {
-                err = -1;
-                goto done;
-        }
-
         finfo = func_info;
         for (i = 0; i < test->func_info_cnt; i++) {
                 if (CHECK(finfo->type_id != test->func_info[i][1],
@@ -4023,8 +4676,8 @@ static int test_get_linfo(const struct prog_info_raw_test *test,
                 goto done;
         }
 
-        if (CHECK(info.line_info_rec_size < 16 ||
-                  info.jited_line_info_rec_size < 8,
+        if (CHECK(info.line_info_rec_size != sizeof(struct bpf_line_info) ||
+                  info.jited_line_info_rec_size != sizeof(__u64),
                   "info: line_info_rec_size:%u(userspace expected:%u) jited_line_info_rec_size:%u(userspace expected:%u)",
                   info.line_info_rec_size, rec_size,
                   info.jited_line_info_rec_size, jited_rec_size)) {
@@ -4077,7 +4730,6 @@ static int test_get_linfo(const struct prog_info_raw_test *test,
          * Other fields are not the concern of this test.
          */
         if (CHECK(err == -1 ||
-                  !info.line_info ||
                   info.nr_line_info != cnt ||
                   (jited_cnt && !info.jited_line_info) ||
                   info.nr_jited_line_info != jited_cnt ||
diff --git a/tools/testing/selftests/bpf/test_progs.c b/tools/testing/selftests/bpf/test_progs.c
index 26f1fdf3e2bf..126fc624290d 100644
--- a/tools/testing/selftests/bpf/test_progs.c
+++ b/tools/testing/selftests/bpf/test_progs.c
@@ -51,10 +51,10 @@ static struct {
         struct iphdr iph;
         struct tcphdr tcp;
 } __packed pkt_v4 = {
-        .eth.h_proto = bpf_htons(ETH_P_IP),
+        .eth.h_proto = __bpf_constant_htons(ETH_P_IP),
         .iph.ihl = 5,
         .iph.protocol = 6,
-        .iph.tot_len = bpf_htons(MAGIC_BYTES),
+        .iph.tot_len = __bpf_constant_htons(MAGIC_BYTES),
         .tcp.urg_ptr = 123,
 };
 
@@ -64,9 +64,9 @@ static struct {
         struct ipv6hdr iph;
         struct tcphdr tcp;
 } __packed pkt_v6 = {
-        .eth.h_proto = bpf_htons(ETH_P_IPV6),
+        .eth.h_proto = __bpf_constant_htons(ETH_P_IPV6),
         .iph.nexthdr = 6,
-        .iph.payload_len = bpf_htons(MAGIC_BYTES),
+        .iph.payload_len = __bpf_constant_htons(MAGIC_BYTES),
         .tcp.urg_ptr = 123,
 };
 
diff --git a/tools/testing/selftests/bpf/test_verifier.c b/tools/testing/selftests/bpf/test_verifier.c
index c3b799c1ee97..baafe5c76aca 100644
--- a/tools/testing/selftests/bpf/test_verifier.c
+++ b/tools/testing/selftests/bpf/test_verifier.c
@@ -49,6 +49,7 @@
 #define MAX_INSNS       BPF_MAXINSNS
 #define MAX_FIXUPS      8
 #define MAX_NR_MAPS     13
+#define MAX_TEST_RUNS   8
 #define POINTER_VALUE   0xcafe4all
 #define TEST_DATA_LEN   64
 
@@ -76,7 +77,7 @@ struct bpf_test {
         int fixup_percpu_cgroup_storage[MAX_FIXUPS];
         const char *errstr;
         const char *errstr_unpriv;
-        uint32_t retval, retval_unpriv;
+        uint32_t retval, retval_unpriv, insn_processed;
         enum {
                 UNDEF,
                 ACCEPT,
@@ -86,6 +87,14 @@ struct bpf_test {
         uint8_t flags;
         __u8 data[TEST_DATA_LEN];
         void (*fill_helper)(struct bpf_test *self);
+        uint8_t runs;
+        struct {
+                uint32_t retval, retval_unpriv;
+                union {
+                        __u8 data[TEST_DATA_LEN];
+                        __u64 data64[TEST_DATA_LEN / 8];
+                };
+        } retvals[MAX_TEST_RUNS];
 };
 
 /* Note we want this to be 64 bit aligned so that the end of our array is
@@ -1001,15 +1010,45 @@ static struct bpf_test tests[] = {
                         BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_1, -8),
                         /* mess up with R1 pointer on stack */
                         BPF_ST_MEM(BPF_B, BPF_REG_10, -7, 0x23),
-                        /* fill back into R0 should fail */
+                        /* fill back into R0 is fine for priv.
+                         * R0 now becomes SCALAR_VALUE.
+                         */
                         BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_10, -8),
+                        /* Load from R0 should fail. */
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 8),
                         BPF_EXIT_INSN(),
                 },
                 .errstr_unpriv = "attempt to corrupt spilled",
-                .errstr = "corrupted spill",
+                .errstr = "R0 invalid mem access 'inv",
                 .result = REJECT,
         },
         {
+                "check corrupted spill/fill, LSB",
+                .insns = {
+                        BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_1, -8),
+                        BPF_ST_MEM(BPF_H, BPF_REG_10, -8, 0xcafe),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_10, -8),
+                        BPF_EXIT_INSN(),
+                },
+                .errstr_unpriv = "attempt to corrupt spilled",
+                .result_unpriv = REJECT,
+                .result = ACCEPT,
+                .retval = POINTER_VALUE,
+        },
+        {
+                "check corrupted spill/fill, MSB",
+                .insns = {
+                        BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_1, -8),
+                        BPF_ST_MEM(BPF_W, BPF_REG_10, -4, 0x12345678),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_10, -8),
+                        BPF_EXIT_INSN(),
+                },
+                .errstr_unpriv = "attempt to corrupt spilled",
+                .result_unpriv = REJECT,
+                .result = ACCEPT,
+                .retval = POINTER_VALUE,
+        },
+        {
                 "invalid src register in STX",
                 .insns = {
                         BPF_STX_MEM(BPF_B, BPF_REG_10, -1, -1),
@@ -1813,10 +1852,20 @@ static struct bpf_test tests[] = {
                 .prog_type = BPF_PROG_TYPE_SK_SKB,
         },
         {
-                "invalid 64B read of family in SK_MSG",
+                "valid access size in SK_MSG",
+                .insns = {
+                        BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1,
+                                    offsetof(struct sk_msg_md, size)),
+                        BPF_EXIT_INSN(),
+                },
+                .result = ACCEPT,
+                .prog_type = BPF_PROG_TYPE_SK_MSG,
+        },
+        {
+                "invalid 64B read of size in SK_MSG",
                 .insns = {
                         BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_1,
-                                    offsetof(struct sk_msg_md, family)),
+                                    offsetof(struct sk_msg_md, size)),
                         BPF_EXIT_INSN(),
                 },
                 .errstr = "invalid bpf_context access",
@@ -1827,10 +1876,10 @@ static struct bpf_test tests[] = {
                 "invalid read past end of SK_MSG",
                 .insns = {
                         BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
-                                    offsetof(struct sk_msg_md, local_port) + 4),
+                                    offsetof(struct sk_msg_md, size) + 4),
                         BPF_EXIT_INSN(),
                 },
-                .errstr = "R0 !read_ok",
+                .errstr = "invalid bpf_context access",
                 .result = REJECT,
                 .prog_type = BPF_PROG_TYPE_SK_MSG,
         },
@@ -13648,6 +13697,28 @@ static struct bpf_test tests[] = {
                 .result = ACCEPT,
         },
         {
+                "allocated_stack",
+                .insns = {
+                        BPF_ALU64_REG(BPF_MOV, BPF_REG_6, BPF_REG_1),
+                        BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_get_prandom_u32),
+                        BPF_ALU64_REG(BPF_MOV, BPF_REG_7, BPF_REG_0),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 5),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_6, -8),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_6, BPF_REG_10, -8),
+                        BPF_STX_MEM(BPF_B, BPF_REG_10, BPF_REG_7, -9),
+                        BPF_LDX_MEM(BPF_B, BPF_REG_7, BPF_REG_10, -9),
+                        BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 0),
+                        BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 0),
+                        BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 0),
+                        BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .result = ACCEPT,
+                .result_unpriv = ACCEPT,
+                .insn_processed = 15,
+        },
+        {
                 "reference tracking in call: free reference in subprog and outside",
                 .insns = {
                         BPF_SK_LOOKUP,
@@ -14099,6 +14170,7 @@ static struct bpf_test tests[] = {
                 .errstr_unpriv = "R1 leaks addr",
                 .result = REJECT,
         },
+        {
                 "calls: cross frame pruning",
                 .insns = {
                         /* r8 = !!random();
@@ -14122,10 +14194,199 @@ static struct bpf_test tests[] = {
                 },
                 .prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
                 .errstr_unpriv = "function calls to other bpf functions are allowed for root only",
+                .result = REJECT,
+        },
+        {
+                "jset: functional",
+                .insns = {
+                        /* r0 = 0 */
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        /* prep for direct packet access via r2 */
+                        BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+                                    offsetof(struct __sk_buff, data)),
+                        BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
+                                    offsetof(struct __sk_buff, data_end)),
+                        BPF_MOV64_REG(BPF_REG_4, BPF_REG_2),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 8),
+                        BPF_JMP_REG(BPF_JLE, BPF_REG_4, BPF_REG_3, 1),
+                        BPF_EXIT_INSN(),
+
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+
+                        /* reg, bit 63 or bit 0 set, taken */
+                        BPF_LD_IMM64(BPF_REG_8, 0x8000000000000001),
+                        BPF_JMP_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
+                        BPF_EXIT_INSN(),
+
+                        /* reg, bit 62, not taken */
+                        BPF_LD_IMM64(BPF_REG_8, 0x4000000000000000),
+                        BPF_JMP_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
+                        BPF_JMP_IMM(BPF_JA, 0, 0, 1),
+                        BPF_EXIT_INSN(),
+
+                        /* imm, any bit set, taken */
+                        BPF_JMP_IMM(BPF_JSET, BPF_REG_7, -1, 1),
+                        BPF_EXIT_INSN(),
+
+                        /* imm, bit 31 set, taken */
+                        BPF_JMP_IMM(BPF_JSET, BPF_REG_7, 0x80000000, 1),
+                        BPF_EXIT_INSN(),
+
+                        /* all good - return r0 == 2 */
+                        BPF_MOV64_IMM(BPF_REG_0, 2),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+                .result = ACCEPT,
+                .runs = 7,
+                .retvals = {
+                        { .retval = 2,
+                          .data64 = { (1ULL << 63) | (1U << 31) | (1U << 0), }
+                        },
+                        { .retval = 2,
+                          .data64 = { (1ULL << 63) | (1U << 31), }
+                        },
+                        { .retval = 2,
+                          .data64 = { (1ULL << 31) | (1U << 0), }
+                        },
+                        { .retval = 2,
+                          .data64 = { (__u32)-1, }
+                        },
+                        { .retval = 2,
+                          .data64 = { ~0x4000000000000000ULL, }
+                        },
+                        { .retval = 0,
+                          .data64 = { 0, }
+                        },
+                        { .retval = 0,
+                          .data64 = { ~0ULL, }
+                        },
+                },
+        },
+        {
+                "jset: sign-extend",
+                .insns = {
+                        /* r0 = 0 */
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        /* prep for direct packet access via r2 */
+                        BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+                                    offsetof(struct __sk_buff, data)),
+                        BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
+                                    offsetof(struct __sk_buff, data_end)),
+                        BPF_MOV64_REG(BPF_REG_4, BPF_REG_2),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 8),
+                        BPF_JMP_REG(BPF_JLE, BPF_REG_4, BPF_REG_3, 1),
+                        BPF_EXIT_INSN(),
+
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+
+                        BPF_JMP_IMM(BPF_JSET, BPF_REG_7, 0x80000000, 1),
+                        BPF_EXIT_INSN(),
+
+                        BPF_MOV64_IMM(BPF_REG_0, 2),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+                .result = ACCEPT,
+                .retval = 2,
+                .data = { 1, 0, 0, 0, 0, 0, 0, 1, },
+        },
+        {
+                "jset: known const compare",
+                .insns = {
+                        BPF_MOV64_IMM(BPF_REG_0, 1),
+                        BPF_JMP_IMM(BPF_JSET, BPF_REG_0, 1, 1),
+                        BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
+                .retval_unpriv = 1,
+                .result_unpriv = ACCEPT,
+                .retval = 1,
+                .result = ACCEPT,
+        },
+        {
+                "jset: known const compare bad",
+                .insns = {
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_JMP_IMM(BPF_JSET, BPF_REG_0, 1, 1),
+                        BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
+                .errstr_unpriv = "!read_ok",
                 .result_unpriv = REJECT,
                 .errstr = "!read_ok",
                 .result = REJECT,
         },
+        {
+                "jset: unknown const compare taken",
+                .insns = {
+                        BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
+                                     BPF_FUNC_get_prandom_u32),
+                        BPF_JMP_IMM(BPF_JSET, BPF_REG_0, 1, 1),
+                        BPF_JMP_IMM(BPF_JA, 0, 0, 1),
+                        BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
+                .errstr_unpriv = "!read_ok",
+                .result_unpriv = REJECT,
+                .errstr = "!read_ok",
+                .result = REJECT,
+        },
+        {
+                "jset: unknown const compare not taken",
+                .insns = {
+                        BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
+                                     BPF_FUNC_get_prandom_u32),
+                        BPF_JMP_IMM(BPF_JSET, BPF_REG_0, 1, 1),
+                        BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
+                .errstr_unpriv = "!read_ok",
+                .result_unpriv = REJECT,
+                .errstr = "!read_ok",
+                .result = REJECT,
+        },
+        {
+                "jset: half-known const compare",
+                .insns = {
+                        BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
+                                     BPF_FUNC_get_prandom_u32),
+                        BPF_ALU64_IMM(BPF_OR, BPF_REG_0, 2),
+                        BPF_JMP_IMM(BPF_JSET, BPF_REG_0, 3, 1),
+                        BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
+                .result_unpriv = ACCEPT,
+                .result = ACCEPT,
+        },
+        {
+                "jset: range",
+                .insns = {
+                        BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
+                                     BPF_FUNC_get_prandom_u32),
+                        BPF_MOV64_REG(BPF_REG_1, BPF_REG_0),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_ALU64_IMM(BPF_AND, BPF_REG_1, 0xff),
+                        BPF_JMP_IMM(BPF_JSET, BPF_REG_1, 0xf0, 3),
+                        BPF_JMP_IMM(BPF_JLT, BPF_REG_1, 0x10, 1),
+                        BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+                        BPF_EXIT_INSN(),
+                        BPF_JMP_IMM(BPF_JSET, BPF_REG_1, 0x10, 1),
+                        BPF_EXIT_INSN(),
+                        BPF_JMP_IMM(BPF_JGE, BPF_REG_1, 0x10, 1),
+                        BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
+                .result_unpriv = ACCEPT,
+                .result = ACCEPT,
+        },
 };
 
 static int probe_filter_length(const struct bpf_insn *fp)
@@ -14408,16 +14669,42 @@ out:
         return ret;
 }
 
+static int do_prog_test_run(int fd_prog, bool unpriv, uint32_t expected_val,
+                            void *data, size_t size_data)
+{
+        __u8 tmp[TEST_DATA_LEN << 2];
+        __u32 size_tmp = sizeof(tmp);
+        uint32_t retval;
+        int err;
+
+        if (unpriv)
+                set_admin(true);
+        err = bpf_prog_test_run(fd_prog, 1, data, size_data,
+                                tmp, &size_tmp, &retval, NULL);
+        if (unpriv)
+                set_admin(false);
+        if (err && errno != 524/*ENOTSUPP*/ && errno != EPERM) {
+                printf("Unexpected bpf_prog_test_run error ");
+                return err;
+        }
+        if (!err && retval != expected_val &&
+            expected_val != POINTER_VALUE) {
+                printf("FAIL retval %d != %d ", retval, expected_val);
+                return 1;
+        }
+
+        return 0;
+}
+
 static void do_test_single(struct bpf_test *test, bool unpriv,
                            int *passes, int *errors)
 {
         int fd_prog, expected_ret, alignment_prevented_execution;
         int prog_len, prog_type = test->prog_type;
         struct bpf_insn *prog = test->insns;
+        int run_errs, run_successes;
         int map_fds[MAX_NR_MAPS];
         const char *expected_err;
-        uint32_t expected_val;
-        uint32_t retval;
         __u32 pflags;
         int i, err;
 
@@ -14441,8 +14728,6 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
                        test->result_unpriv : test->result;
         expected_err = unpriv && test->errstr_unpriv ?
                        test->errstr_unpriv : test->errstr;
-        expected_val = unpriv && test->retval_unpriv ?
-                       test->retval_unpriv : test->retval;
 
         alignment_prevented_execution = 0;
 
@@ -14454,10 +14739,8 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
                 }
 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
                 if (fd_prog >= 0 &&
-                    (test->flags & F_NEEDS_EFFICIENT_UNALIGNED_ACCESS)) {
+                    (test->flags & F_NEEDS_EFFICIENT_UNALIGNED_ACCESS))
                         alignment_prevented_execution = 1;
-                        goto test_ok;
-                }
 #endif
         } else {
                 if (fd_prog >= 0) {
@@ -14471,33 +14754,67 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
                 }
         }
 
-        if (fd_prog >= 0) {
-                __u8 tmp[TEST_DATA_LEN << 2];
-                __u32 size_tmp = sizeof(tmp);
-
-                if (unpriv)
-                        set_admin(true);
-                err = bpf_prog_test_run(fd_prog, 1, test->data,
-                                        sizeof(test->data), tmp, &size_tmp,
-                                        &retval, NULL);
-                if (unpriv)
-                        set_admin(false);
-                if (err && errno != 524/*ENOTSUPP*/ && errno != EPERM) {
-                        printf("Unexpected bpf_prog_test_run error\n");
+        if (test->insn_processed) {
+                uint32_t insn_processed;
+                char *proc;
+
+                proc = strstr(bpf_vlog, "processed ");
+                insn_processed = atoi(proc + 10);
+                if (test->insn_processed != insn_processed) {
+                        printf("FAIL\nUnexpected insn_processed %u vs %u\n",
+                               insn_processed, test->insn_processed);
                         goto fail_log;
                 }
-                if (!err && retval != expected_val &&
-                    expected_val != POINTER_VALUE) {
-                        printf("FAIL retval %d != %d\n", retval, expected_val);
-                        goto fail_log;
+        }
+
+        run_errs = 0;
+        run_successes = 0;
+        if (!alignment_prevented_execution && fd_prog >= 0) {
+                uint32_t expected_val;
+                int i;
+
+                if (!test->runs) {
+                        expected_val = unpriv && test->retval_unpriv ?
+                                test->retval_unpriv : test->retval;
+
+                        err = do_prog_test_run(fd_prog, unpriv, expected_val,
+                                               test->data, sizeof(test->data));
+                        if (err)
+                                run_errs++;
+                        else
+                                run_successes++;
+                }
+
+                for (i = 0; i < test->runs; i++) {
+                        if (unpriv && test->retvals[i].retval_unpriv)
+                                expected_val = test->retvals[i].retval_unpriv;
+                        else
+                                expected_val = test->retvals[i].retval;
+
+                        err = do_prog_test_run(fd_prog, unpriv, expected_val,
+                                               test->retvals[i].data,
+                                               sizeof(test->retvals[i].data));
+                        if (err) {
+                                printf("(run %d/%d) ", i + 1, test->runs);
+                                run_errs++;
+                        } else {
+                                run_successes++;
+                        }
                 }
         }
-#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
-test_ok:
-#endif
-        (*passes)++;
-        printf("OK%s\n", alignment_prevented_execution ?
-               " (NOTE: not executed due to unknown alignment)" : "");
+
+        if (!run_errs) {
+                (*passes)++;
+                if (run_successes > 1)
+                        printf("%d cases ", run_successes);
+                printf("OK");
+                if (alignment_prevented_execution)
+                        printf(" (NOTE: not executed due to unknown alignment)");
+                printf("\n");
+        } else {
+                printf("\n");
+                goto fail_log;
+        }
 close_fds:
         close(fd_prog);
         for (i = 0; i < MAX_NR_MAPS; i++)