52 files changed, 2949 insertions, 1094 deletions

diff --git a/include/uapi/linux/aio_abi.h b/include/uapi/linux/aio_abi.h
index ed0185945bb2..75846164290e 100644
--- a/include/uapi/linux/aio_abi.h
+++ b/include/uapi/linux/aio_abi.h
@@ -53,6 +53,7 @@ enum {
  *                   is valid.
  */
 #define IOCB_FLAG_RESFD         (1 << 0)
+#define IOCB_FLAG_IOPRIO        (1 << 1)
 
 /* read() from /dev/aio returns these structures. */
 struct io_event {
diff --git a/include/uapi/linux/audit.h b/include/uapi/linux/audit.h
index 4e61a9e05132..c35aee9ad4a6 100644
--- a/include/uapi/linux/audit.h
+++ b/include/uapi/linux/audit.h
@@ -147,6 +147,7 @@
 #define AUDIT_INTEGRITY_HASH        1803 /* Integrity HASH type */
 #define AUDIT_INTEGRITY_PCR         1804 /* PCR invalidation msgs */
 #define AUDIT_INTEGRITY_RULE        1805 /* policy rule */
+#define AUDIT_INTEGRITY_EVM_XATTR   1806 /* New EVM-covered xattr */
 
 #define AUDIT_KERNEL            2000    /* Asynchronous audit record. NOT A REQUEST. */
 
@@ -465,6 +466,7 @@ struct audit_tty_status {
 };
 
 #define AUDIT_UID_UNSET (unsigned int)-1
+#define AUDIT_SID_UNSET ((unsigned int)-1)
 
 /* audit_rule_data supports filter rules with both integer and string
  * fields.  It corresponds with AUDIT_ADD_RULE, AUDIT_DEL_RULE and
diff --git a/include/uapi/linux/auto_fs.h b/include/uapi/linux/auto_fs.h
index 2a4432c7a4b4..e13eec3dfb2f 100644
--- a/include/uapi/linux/auto_fs.h
+++ b/include/uapi/linux/auto_fs.h
@@ -1,6 +1,8 @@
 /* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
 /*
- *   Copyright 1997 Transmeta Corporation - All Rights Reserved
+ * Copyright 1997 Transmeta Corporation - All Rights Reserved
+ * Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
+ * Copyright 2005-2006,2013,2017-2018 Ian Kent <raven@themaw.net>
  *
  * This file is part of the Linux kernel and is made available under
  * the terms of the GNU General Public License, version 2, or at your
@@ -8,7 +10,6 @@
  *
  * ----------------------------------------------------------------------- */
 
-
 #ifndef _UAPI_LINUX_AUTO_FS_H
 #define _UAPI_LINUX_AUTO_FS_H
 
@@ -18,13 +19,11 @@
 #include <sys/ioctl.h>
 #endif /* __KERNEL__ */
 
+#define AUTOFS_PROTO_VERSION            5
+#define AUTOFS_MIN_PROTO_VERSION        3
+#define AUTOFS_MAX_PROTO_VERSION        5
 
-/* This file describes autofs v3 */
-#define AUTOFS_PROTO_VERSION    3
-
-/* Range of protocol versions defined */
-#define AUTOFS_MAX_PROTO_VERSION        AUTOFS_PROTO_VERSION
-#define AUTOFS_MIN_PROTO_VERSION        AUTOFS_PROTO_VERSION
+#define AUTOFS_PROTO_SUBVERSION         2
 
 /*
  * The wait_queue_token (autofs_wqt_t) is part of a structure which is passed
@@ -76,9 +75,155 @@ enum {
 #define AUTOFS_IOC_READY        _IO(AUTOFS_IOCTL, AUTOFS_IOC_READY_CMD)
 #define AUTOFS_IOC_FAIL         _IO(AUTOFS_IOCTL, AUTOFS_IOC_FAIL_CMD)
 #define AUTOFS_IOC_CATATONIC    _IO(AUTOFS_IOCTL, AUTOFS_IOC_CATATONIC_CMD)
-#define AUTOFS_IOC_PROTOVER     _IOR(AUTOFS_IOCTL, AUTOFS_IOC_PROTOVER_CMD, int)
-#define AUTOFS_IOC_SETTIMEOUT32 _IOWR(AUTOFS_IOCTL, AUTOFS_IOC_SETTIMEOUT_CMD, compat_ulong_t)
-#define AUTOFS_IOC_SETTIMEOUT   _IOWR(AUTOFS_IOCTL, AUTOFS_IOC_SETTIMEOUT_CMD, unsigned long)
-#define AUTOFS_IOC_EXPIRE       _IOR(AUTOFS_IOCTL, AUTOFS_IOC_EXPIRE_CMD, struct autofs_packet_expire)
+#define AUTOFS_IOC_PROTOVER     _IOR(AUTOFS_IOCTL, \
+                                     AUTOFS_IOC_PROTOVER_CMD, int)
+#define AUTOFS_IOC_SETTIMEOUT32 _IOWR(AUTOFS_IOCTL, \
+                                      AUTOFS_IOC_SETTIMEOUT_CMD, \
+                                      compat_ulong_t)
+#define AUTOFS_IOC_SETTIMEOUT   _IOWR(AUTOFS_IOCTL, \
+                                      AUTOFS_IOC_SETTIMEOUT_CMD, \
+                                      unsigned long)
+#define AUTOFS_IOC_EXPIRE       _IOR(AUTOFS_IOCTL, \
+                                     AUTOFS_IOC_EXPIRE_CMD, \
+                                     struct autofs_packet_expire)
+
+/* autofs version 4 and later definitions */
+
+/* Mask for expire behaviour */
+#define AUTOFS_EXP_IMMEDIATE            1
+#define AUTOFS_EXP_LEAVES               2
+
+#define AUTOFS_TYPE_ANY                 0U
+#define AUTOFS_TYPE_INDIRECT            1U
+#define AUTOFS_TYPE_DIRECT              2U
+#define AUTOFS_TYPE_OFFSET              4U
+
+static inline void set_autofs_type_indirect(unsigned int *type)
+{
+        *type = AUTOFS_TYPE_INDIRECT;
+}
+
+static inline unsigned int autofs_type_indirect(unsigned int type)
+{
+        return (type == AUTOFS_TYPE_INDIRECT);
+}
+
+static inline void set_autofs_type_direct(unsigned int *type)
+{
+        *type = AUTOFS_TYPE_DIRECT;
+}
+
+static inline unsigned int autofs_type_direct(unsigned int type)
+{
+        return (type == AUTOFS_TYPE_DIRECT);
+}
+
+static inline void set_autofs_type_offset(unsigned int *type)
+{
+        *type = AUTOFS_TYPE_OFFSET;
+}
+
+static inline unsigned int autofs_type_offset(unsigned int type)
+{
+        return (type == AUTOFS_TYPE_OFFSET);
+}
+
+static inline unsigned int autofs_type_trigger(unsigned int type)
+{
+        return (type == AUTOFS_TYPE_DIRECT || type == AUTOFS_TYPE_OFFSET);
+}
+
+/*
+ * This isn't really a type as we use it to say "no type set" to
+ * indicate we want to search for "any" mount in the
+ * autofs_dev_ioctl_ismountpoint() device ioctl function.
+ */
+static inline void set_autofs_type_any(unsigned int *type)
+{
+        *type = AUTOFS_TYPE_ANY;
+}
+
+static inline unsigned int autofs_type_any(unsigned int type)
+{
+        return (type == AUTOFS_TYPE_ANY);
+}
+
+/* Daemon notification packet types */
+enum autofs_notify {
+        NFY_NONE,
+        NFY_MOUNT,
+        NFY_EXPIRE
+};
+
+/* Kernel protocol version 4 packet types */
+
+/* Expire entry (umount request) */
+#define autofs_ptype_expire_multi       2
+
+/* Kernel protocol version 5 packet types */
+
+/* Indirect mount missing and expire requests. */
+#define autofs_ptype_missing_indirect   3
+#define autofs_ptype_expire_indirect    4
+
+/* Direct mount missing and expire requests */
+#define autofs_ptype_missing_direct     5
+#define autofs_ptype_expire_direct      6
+
+/* v4 multi expire (via pipe) */
+struct autofs_packet_expire_multi {
+        struct autofs_packet_hdr hdr;
+        autofs_wqt_t wait_queue_token;
+        int len;
+        char name[NAME_MAX+1];
+};
+
+union autofs_packet_union {
+        struct autofs_packet_hdr hdr;
+        struct autofs_packet_missing missing;
+        struct autofs_packet_expire expire;
+        struct autofs_packet_expire_multi expire_multi;
+};
+
+/* autofs v5 common packet struct */
+struct autofs_v5_packet {
+        struct autofs_packet_hdr hdr;
+        autofs_wqt_t wait_queue_token;
+        __u32 dev;
+        __u64 ino;
+        __u32 uid;
+        __u32 gid;
+        __u32 pid;
+        __u32 tgid;
+        __u32 len;
+        char name[NAME_MAX+1];
+};
+
+typedef struct autofs_v5_packet autofs_packet_missing_indirect_t;
+typedef struct autofs_v5_packet autofs_packet_expire_indirect_t;
+typedef struct autofs_v5_packet autofs_packet_missing_direct_t;
+typedef struct autofs_v5_packet autofs_packet_expire_direct_t;
+
+union autofs_v5_packet_union {
+        struct autofs_packet_hdr hdr;
+        struct autofs_v5_packet v5_packet;
+        autofs_packet_missing_indirect_t missing_indirect;
+        autofs_packet_expire_indirect_t expire_indirect;
+        autofs_packet_missing_direct_t missing_direct;
+        autofs_packet_expire_direct_t expire_direct;
+};
+
+enum {
+        AUTOFS_IOC_EXPIRE_MULTI_CMD = 0x66, /* AUTOFS_IOC_EXPIRE_CMD + 1 */
+        AUTOFS_IOC_PROTOSUBVER_CMD,
+        AUTOFS_IOC_ASKUMOUNT_CMD = 0x70, /* AUTOFS_DEV_IOCTL_VERSION_CMD - 1 */
+};
+
+#define AUTOFS_IOC_EXPIRE_MULTI         _IOW(AUTOFS_IOCTL, \
+                                             AUTOFS_IOC_EXPIRE_MULTI_CMD, int)
+#define AUTOFS_IOC_PROTOSUBVER          _IOR(AUTOFS_IOCTL, \
+                                             AUTOFS_IOC_PROTOSUBVER_CMD, int)
+#define AUTOFS_IOC_ASKUMOUNT            _IOR(AUTOFS_IOCTL, \
+                                             AUTOFS_IOC_ASKUMOUNT_CMD, int)
 
 #endif /* _UAPI_LINUX_AUTO_FS_H */
diff --git a/include/uapi/linux/auto_fs4.h b/include/uapi/linux/auto_fs4.h
index 1f608e27a06f..d01ef0a0189c 100644
--- a/include/uapi/linux/auto_fs4.h
+++ b/include/uapi/linux/auto_fs4.h
@@ -7,156 +7,9 @@
  * option, any later version, incorporated herein by reference.
  */
 
-#ifndef _LINUX_AUTO_FS4_H
-#define _LINUX_AUTO_FS4_H
+#ifndef _UAPI_LINUX_AUTO_FS4_H
+#define _UAPI_LINUX_AUTO_FS4_H
 
-/* Include common v3 definitions */
-#include <linux/types.h>
 #include <linux/auto_fs.h>
 
-/* autofs v4 definitions */
-#undef AUTOFS_PROTO_VERSION
-#undef AUTOFS_MIN_PROTO_VERSION
-#undef AUTOFS_MAX_PROTO_VERSION
-
-#define AUTOFS_PROTO_VERSION            5
-#define AUTOFS_MIN_PROTO_VERSION        3
-#define AUTOFS_MAX_PROTO_VERSION        5
-
-#define AUTOFS_PROTO_SUBVERSION         2
-
-/* Mask for expire behaviour */
-#define AUTOFS_EXP_IMMEDIATE            1
-#define AUTOFS_EXP_LEAVES               2
-
-#define AUTOFS_TYPE_ANY                 0U
-#define AUTOFS_TYPE_INDIRECT            1U
-#define AUTOFS_TYPE_DIRECT              2U
-#define AUTOFS_TYPE_OFFSET              4U
-
-static inline void set_autofs_type_indirect(unsigned int *type)
-{
-        *type = AUTOFS_TYPE_INDIRECT;
-}
-
-static inline unsigned int autofs_type_indirect(unsigned int type)
-{
-        return (type == AUTOFS_TYPE_INDIRECT);
-}
-
-static inline void set_autofs_type_direct(unsigned int *type)
-{
-        *type = AUTOFS_TYPE_DIRECT;
-}
-
-static inline unsigned int autofs_type_direct(unsigned int type)
-{
-        return (type == AUTOFS_TYPE_DIRECT);
-}
-
-static inline void set_autofs_type_offset(unsigned int *type)
-{
-        *type = AUTOFS_TYPE_OFFSET;
-}
-
-static inline unsigned int autofs_type_offset(unsigned int type)
-{
-        return (type == AUTOFS_TYPE_OFFSET);
-}
-
-static inline unsigned int autofs_type_trigger(unsigned int type)
-{
-        return (type == AUTOFS_TYPE_DIRECT || type == AUTOFS_TYPE_OFFSET);
-}
-
-/*
- * This isn't really a type as we use it to say "no type set" to
- * indicate we want to search for "any" mount in the
- * autofs_dev_ioctl_ismountpoint() device ioctl function.
- */
-static inline void set_autofs_type_any(unsigned int *type)
-{
-        *type = AUTOFS_TYPE_ANY;
-}
-
-static inline unsigned int autofs_type_any(unsigned int type)
-{
-        return (type == AUTOFS_TYPE_ANY);
-}
-
-/* Daemon notification packet types */
-enum autofs_notify {
-        NFY_NONE,
-        NFY_MOUNT,
-        NFY_EXPIRE
-};
-
-/* Kernel protocol version 4 packet types */
-
-/* Expire entry (umount request) */
-#define autofs_ptype_expire_multi       2
-
-/* Kernel protocol version 5 packet types */
-
-/* Indirect mount missing and expire requests. */
-#define autofs_ptype_missing_indirect   3
-#define autofs_ptype_expire_indirect    4
-
-/* Direct mount missing and expire requests */
-#define autofs_ptype_missing_direct     5
-#define autofs_ptype_expire_direct      6
-
-/* v4 multi expire (via pipe) */
-struct autofs_packet_expire_multi {
-        struct autofs_packet_hdr hdr;
-        autofs_wqt_t wait_queue_token;
-        int len;
-        char name[NAME_MAX+1];
-};
-
-union autofs_packet_union {
-        struct autofs_packet_hdr hdr;
-        struct autofs_packet_missing missing;
-        struct autofs_packet_expire expire;
-        struct autofs_packet_expire_multi expire_multi;
-};
-
-/* autofs v5 common packet struct */
-struct autofs_v5_packet {
-        struct autofs_packet_hdr hdr;
-        autofs_wqt_t wait_queue_token;
-        __u32 dev;
-        __u64 ino;
-        __u32 uid;
-        __u32 gid;
-        __u32 pid;
-        __u32 tgid;
-        __u32 len;
-        char name[NAME_MAX+1];
-};
-
-typedef struct autofs_v5_packet autofs_packet_missing_indirect_t;
-typedef struct autofs_v5_packet autofs_packet_expire_indirect_t;
-typedef struct autofs_v5_packet autofs_packet_missing_direct_t;
-typedef struct autofs_v5_packet autofs_packet_expire_direct_t;
-
-union autofs_v5_packet_union {
-        struct autofs_packet_hdr hdr;
-        struct autofs_v5_packet v5_packet;
-        autofs_packet_missing_indirect_t missing_indirect;
-        autofs_packet_expire_indirect_t expire_indirect;
-        autofs_packet_missing_direct_t missing_direct;
-        autofs_packet_expire_direct_t expire_direct;
-};
-
-enum {
-        AUTOFS_IOC_EXPIRE_MULTI_CMD = 0x66, /* AUTOFS_IOC_EXPIRE_CMD + 1 */
-        AUTOFS_IOC_PROTOSUBVER_CMD,
-        AUTOFS_IOC_ASKUMOUNT_CMD = 0x70, /* AUTOFS_DEV_IOCTL_VERSION_CMD - 1 */
-};
-
-#define AUTOFS_IOC_EXPIRE_MULTI    _IOW(AUTOFS_IOCTL, AUTOFS_IOC_EXPIRE_MULTI_CMD, int)
-#define AUTOFS_IOC_PROTOSUBVER     _IOR(AUTOFS_IOCTL, AUTOFS_IOC_PROTOSUBVER_CMD, int)
-#define AUTOFS_IOC_ASKUMOUNT       _IOR(AUTOFS_IOCTL, AUTOFS_IOC_ASKUMOUNT_CMD, int)
-
-#endif /* _LINUX_AUTO_FS4_H */
+#endif /* _UAPI_LINUX_AUTO_FS4_H */
diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h
index 8c317737ba3f..59b19b6a40d7 100644
--- a/include/uapi/linux/bpf.h
+++ b/include/uapi/linux/bpf.h
@@ -95,6 +95,9 @@ enum bpf_cmd {
         BPF_OBJ_GET_INFO_BY_FD,
         BPF_PROG_QUERY,
         BPF_RAW_TRACEPOINT_OPEN,
+        BPF_BTF_LOAD,
+        BPF_BTF_GET_FD_BY_ID,
+        BPF_TASK_FD_QUERY,
 };
 
 enum bpf_map_type {
@@ -115,6 +118,8 @@ enum bpf_map_type {
         BPF_MAP_TYPE_DEVMAP,
         BPF_MAP_TYPE_SOCKMAP,
         BPF_MAP_TYPE_CPUMAP,
+        BPF_MAP_TYPE_XSKMAP,
+        BPF_MAP_TYPE_SOCKHASH,
 };
 
 enum bpf_prog_type {
@@ -137,6 +142,8 @@ enum bpf_prog_type {
         BPF_PROG_TYPE_SK_MSG,
         BPF_PROG_TYPE_RAW_TRACEPOINT,
         BPF_PROG_TYPE_CGROUP_SOCK_ADDR,
+        BPF_PROG_TYPE_LWT_SEG6LOCAL,
+        BPF_PROG_TYPE_LIRC_MODE2,
 };
 
 enum bpf_attach_type {
@@ -154,6 +161,9 @@ enum bpf_attach_type {
         BPF_CGROUP_INET6_CONNECT,
         BPF_CGROUP_INET4_POST_BIND,
         BPF_CGROUP_INET6_POST_BIND,
+        BPF_CGROUP_UDP4_SENDMSG,
+        BPF_CGROUP_UDP6_SENDMSG,
+        BPF_LIRC_MODE2,
         __MAX_BPF_ATTACH_TYPE
 };
 
@@ -279,6 +289,9 @@ union bpf_attr {
                                          */
                 char    map_name[BPF_OBJ_NAME_LEN];
                 __u32   map_ifindex;    /* ifindex of netdev to create on */
+                __u32   btf_fd;         /* fd pointing to a BTF type data */
+                __u32   btf_key_type_id;        /* BTF type_id of the key */
+                __u32   btf_value_type_id;      /* BTF type_id of the value */
         };
 
         struct { /* anonymous struct used by BPF_MAP_*_ELEM commands */
@@ -339,6 +352,7 @@ union bpf_attr {
                         __u32           start_id;
                         __u32           prog_id;
                         __u32           map_id;
+                        __u32           btf_id;
                 };
                 __u32           next_id;
                 __u32           open_flags;
@@ -363,398 +377,1704 @@ union bpf_attr {
                 __u64 name;
                 __u32 prog_fd;
         } raw_tracepoint;
+
+        struct { /* anonymous struct for BPF_BTF_LOAD */
+                __aligned_u64   btf;
+                __aligned_u64   btf_log_buf;
+                __u32           btf_size;
+                __u32           btf_log_size;
+                __u32           btf_log_level;
+        };
+
+        struct {
+                __u32           pid;            /* input: pid */
+                __u32           fd;             /* input: fd */
+                __u32           flags;          /* input: flags */
+                __u32           buf_len;        /* input/output: buf len */
+                __aligned_u64   buf;            /* input/output:
+                                                 *   tp_name for tracepoint
+                                                 *   symbol for kprobe
+                                                 *   filename for uprobe
+                                                 */
+                __u32           prog_id;        /* output: prod_id */
+                __u32           fd_type;        /* output: BPF_FD_TYPE_* */
+                __u64           probe_offset;   /* output: probe_offset */
+                __u64           probe_addr;     /* output: probe_addr */
+        } task_fd_query;
 } __attribute__((aligned(8)));
 
-/* BPF helper function descriptions:
- *
- * void *bpf_map_lookup_elem(&map, &key)
- *     Return: Map value or NULL
- *
- * int bpf_map_update_elem(&map, &key, &value, flags)
- *     Return: 0 on success or negative error
- *
- * int bpf_map_delete_elem(&map, &key)
- *     Return: 0 on success or negative error
- *
- * int bpf_probe_read(void *dst, int size, void *src)
- *     Return: 0 on success or negative error
+/* The description below is an attempt at providing documentation to eBPF
+ * developers about the multiple available eBPF helper functions. It can be
+ * parsed and used to produce a manual page. The workflow is the following,
+ * and requires the rst2man utility:
+ *
+ *     $ ./scripts/bpf_helpers_doc.py \
+ *             --filename include/uapi/linux/bpf.h > /tmp/bpf-helpers.rst
+ *     $ rst2man /tmp/bpf-helpers.rst > /tmp/bpf-helpers.7
+ *     $ man /tmp/bpf-helpers.7
+ *
+ * Note that in order to produce this external documentation, some RST
+ * formatting is used in the descriptions to get "bold" and "italics" in
+ * manual pages. Also note that the few trailing white spaces are
+ * intentional, removing them would break paragraphs for rst2man.
+ *
+ * Start of BPF helper function descriptions:
+ *
+ * void *bpf_map_lookup_elem(struct bpf_map *map, const void *key)
+ *      Description
+ *              Perform a lookup in *map* for an entry associated to *key*.
+ *      Return
+ *              Map value associated to *key*, or **NULL** if no entry was
+ *              found.
+ *
+ * int bpf_map_update_elem(struct bpf_map *map, const void *key, const void *value, u64 flags)
+ *      Description
+ *              Add or update the value of the entry associated to *key* in
+ *              *map* with *value*. *flags* is one of:
+ *
+ *              **BPF_NOEXIST**
+ *                      The entry for *key* must not exist in the map.
+ *              **BPF_EXIST**
+ *                      The entry for *key* must already exist in the map.
+ *              **BPF_ANY**
+ *                      No condition on the existence of the entry for *key*.
+ *
+ *              Flag value **BPF_NOEXIST** cannot be used for maps of types
+ *              **BPF_MAP_TYPE_ARRAY** or **BPF_MAP_TYPE_PERCPU_ARRAY**  (all
+ *              elements always exist), the helper would return an error.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_map_delete_elem(struct bpf_map *map, const void *key)
+ *      Description
+ *              Delete entry with *key* from *map*.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_probe_read(void *dst, u32 size, const void *src)
+ *      Description
+ *              For tracing programs, safely attempt to read *size* bytes from
+ *              address *src* and store the data in *dst*.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
  *
  * u64 bpf_ktime_get_ns(void)
- *     Return: current ktime
- *
- * int bpf_trace_printk(const char *fmt, int fmt_size, ...)
- *     Return: length of buffer written or negative error
- *
- * u32 bpf_prandom_u32(void)
- *     Return: random value
- *
- * u32 bpf_raw_smp_processor_id(void)
- *     Return: SMP processor ID
- *
- * int bpf_skb_store_bytes(skb, offset, from, len, flags)
- *     store bytes into packet
- *     @skb: pointer to skb
- *     @offset: offset within packet from skb->mac_header
- *     @from: pointer where to copy bytes from
- *     @len: number of bytes to store into packet
- *     @flags: bit 0 - if true, recompute skb->csum
- *             other bits - reserved
- *     Return: 0 on success or negative error
- *
- * int bpf_l3_csum_replace(skb, offset, from, to, flags)
- *     recompute IP checksum
- *     @skb: pointer to skb
- *     @offset: offset within packet where IP checksum is located
- *     @from: old value of header field
- *     @to: new value of header field
- *     @flags: bits 0-3 - size of header field
- *             other bits - reserved
- *     Return: 0 on success or negative error
- *
- * int bpf_l4_csum_replace(skb, offset, from, to, flags)
- *     recompute TCP/UDP checksum
- *     @skb: pointer to skb
- *     @offset: offset within packet where TCP/UDP checksum is located
- *     @from: old value of header field
- *     @to: new value of header field
- *     @flags: bits 0-3 - size of header field
- *             bit 4 - is pseudo header
- *             other bits - reserved
- *     Return: 0 on success or negative error
- *
- * int bpf_tail_call(ctx, prog_array_map, index)
- *     jump into another BPF program
- *     @ctx: context pointer passed to next program
- *     @prog_array_map: pointer to map which type is BPF_MAP_TYPE_PROG_ARRAY
- *     @index: 32-bit index inside array that selects specific program to run
- *     Return: 0 on success or negative error
- *
- * int bpf_clone_redirect(skb, ifindex, flags)
- *     redirect to another netdev
- *     @skb: pointer to skb
- *     @ifindex: ifindex of the net device
- *     @flags: bit 0 - if set, redirect to ingress instead of egress
- *             other bits - reserved
- *     Return: 0 on success or negative error
+ *      Description
+ *              Return the time elapsed since system boot, in nanoseconds.
+ *      Return
+ *              Current *ktime*.
+ *
+ * int bpf_trace_printk(const char *fmt, u32 fmt_size, ...)
+ *      Description
+ *              This helper is a "printk()-like" facility for debugging. It
+ *              prints a message defined by format *fmt* (of size *fmt_size*)
+ *              to file *\/sys/kernel/debug/tracing/trace* from DebugFS, if
+ *              available. It can take up to three additional **u64**
+ *              arguments (as an eBPF helpers, the total number of arguments is
+ *              limited to five).
+ *
+ *              Each time the helper is called, it appends a line to the trace.
+ *              The format of the trace is customizable, and the exact output
+ *              one will get depends on the options set in
+ *              *\/sys/kernel/debug/tracing/trace_options* (see also the
+ *              *README* file under the same directory). However, it usually
+ *              defaults to something like:
+ *
+ *              ::
+ *
+ *                      telnet-470   [001] .N.. 419421.045894: 0x00000001: <formatted msg>
+ *
+ *              In the above:
+ *
+ *                      * ``telnet`` is the name of the current task.
+ *                      * ``470`` is the PID of the current task.
+ *                      * ``001`` is the CPU number on which the task is
+ *                        running.
+ *                      * In ``.N..``, each character refers to a set of
+ *                        options (whether irqs are enabled, scheduling
+ *                        options, whether hard/softirqs are running, level of
+ *                        preempt_disabled respectively). **N** means that
+ *                        **TIF_NEED_RESCHED** and **PREEMPT_NEED_RESCHED**
+ *                        are set.
+ *                      * ``419421.045894`` is a timestamp.
+ *                      * ``0x00000001`` is a fake value used by BPF for the
+ *                        instruction pointer register.
+ *                      * ``<formatted msg>`` is the message formatted with
+ *                        *fmt*.
+ *
+ *              The conversion specifiers supported by *fmt* are similar, but
+ *              more limited than for printk(). They are **%d**, **%i**,
+ *              **%u**, **%x**, **%ld**, **%li**, **%lu**, **%lx**, **%lld**,
+ *              **%lli**, **%llu**, **%llx**, **%p**, **%s**. No modifier (size
+ *              of field, padding with zeroes, etc.) is available, and the
+ *              helper will return **-EINVAL** (but print nothing) if it
+ *              encounters an unknown specifier.
+ *
+ *              Also, note that **bpf_trace_printk**\ () is slow, and should
+ *              only be used for debugging purposes. For this reason, a notice
+ *              bloc (spanning several lines) is printed to kernel logs and
+ *              states that the helper should not be used "for production use"
+ *              the first time this helper is used (or more precisely, when
+ *              **trace_printk**\ () buffers are allocated). For passing values
+ *              to user space, perf events should be preferred.
+ *      Return
+ *              The number of bytes written to the buffer, or a negative error
+ *              in case of failure.
+ *
+ * u32 bpf_get_prandom_u32(void)
+ *      Description
+ *              Get a pseudo-random number.
+ *
+ *              From a security point of view, this helper uses its own
+ *              pseudo-random internal state, and cannot be used to infer the
+ *              seed of other random functions in the kernel. However, it is
+ *              essential to note that the generator used by the helper is not
+ *              cryptographically secure.
+ *      Return
+ *              A random 32-bit unsigned value.
+ *
+ * u32 bpf_get_smp_processor_id(void)
+ *      Description
+ *              Get the SMP (symmetric multiprocessing) processor id. Note that
+ *              all programs run with preemption disabled, which means that the
+ *              SMP processor id is stable during all the execution of the
+ *              program.
+ *      Return
+ *              The SMP id of the processor running the program.
+ *
+ * int bpf_skb_store_bytes(struct sk_buff *skb, u32 offset, const void *from, u32 len, u64 flags)
+ *      Description
+ *              Store *len* bytes from address *from* into the packet
+ *              associated to *skb*, at *offset*. *flags* are a combination of
+ *              **BPF_F_RECOMPUTE_CSUM** (automatically recompute the
+ *              checksum for the packet after storing the bytes) and
+ *              **BPF_F_INVALIDATE_HASH** (set *skb*\ **->hash**, *skb*\
+ *              **->swhash** and *skb*\ **->l4hash** to 0).
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_l3_csum_replace(struct sk_buff *skb, u32 offset, u64 from, u64 to, u64 size)
+ *      Description
+ *              Recompute the layer 3 (e.g. IP) checksum for the packet
+ *              associated to *skb*. Computation is incremental, so the helper
+ *              must know the former value of the header field that was
+ *              modified (*from*), the new value of this field (*to*), and the
+ *              number of bytes (2 or 4) for this field, stored in *size*.
+ *              Alternatively, it is possible to store the difference between
+ *              the previous and the new values of the header field in *to*, by
+ *              setting *from* and *size* to 0. For both methods, *offset*
+ *              indicates the location of the IP checksum within the packet.
+ *
+ *              This helper works in combination with **bpf_csum_diff**\ (),
+ *              which does not update the checksum in-place, but offers more
+ *              flexibility and can handle sizes larger than 2 or 4 for the
+ *              checksum to update.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_l4_csum_replace(struct sk_buff *skb, u32 offset, u64 from, u64 to, u64 flags)
+ *      Description
+ *              Recompute the layer 4 (e.g. TCP, UDP or ICMP) checksum for the
+ *              packet associated to *skb*. Computation is incremental, so the
+ *              helper must know the former value of the header field that was
+ *              modified (*from*), the new value of this field (*to*), and the
+ *              number of bytes (2 or 4) for this field, stored on the lowest
+ *              four bits of *flags*. Alternatively, it is possible to store
+ *              the difference between the previous and the new values of the
+ *              header field in *to*, by setting *from* and the four lowest
+ *              bits of *flags* to 0. For both methods, *offset* indicates the
+ *              location of the IP checksum within the packet. In addition to
+ *              the size of the field, *flags* can be added (bitwise OR) actual
+ *              flags. With **BPF_F_MARK_MANGLED_0**, a null checksum is left
+ *              untouched (unless **BPF_F_MARK_ENFORCE** is added as well), and
+ *              for updates resulting in a null checksum the value is set to
+ *              **CSUM_MANGLED_0** instead. Flag **BPF_F_PSEUDO_HDR** indicates
+ *              the checksum is to be computed against a pseudo-header.
+ *
+ *              This helper works in combination with **bpf_csum_diff**\ (),
+ *              which does not update the checksum in-place, but offers more
+ *              flexibility and can handle sizes larger than 2 or 4 for the
+ *              checksum to update.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_tail_call(void *ctx, struct bpf_map *prog_array_map, u32 index)
+ *      Description
+ *              This special helper is used to trigger a "tail call", or in
+ *              other words, to jump into another eBPF program. The same stack
+ *              frame is used (but values on stack and in registers for the
+ *              caller are not accessible to the callee). This mechanism allows
+ *              for program chaining, either for raising the maximum number of
+ *              available eBPF instructions, or to execute given programs in
+ *              conditional blocks. For security reasons, there is an upper
+ *              limit to the number of successive tail calls that can be
+ *              performed.
+ *
+ *              Upon call of this helper, the program attempts to jump into a
+ *              program referenced at index *index* in *prog_array_map*, a
+ *              special map of type **BPF_MAP_TYPE_PROG_ARRAY**, and passes
+ *              *ctx*, a pointer to the context.
+ *
+ *              If the call succeeds, the kernel immediately runs the first
+ *              instruction of the new program. This is not a function call,
+ *              and it never returns to the previous program. If the call
+ *              fails, then the helper has no effect, and the caller continues
+ *              to run its subsequent instructions. A call can fail if the
+ *              destination program for the jump does not exist (i.e. *index*
+ *              is superior to the number of entries in *prog_array_map*), or
+ *              if the maximum number of tail calls has been reached for this
+ *              chain of programs. This limit is defined in the kernel by the
+ *              macro **MAX_TAIL_CALL_CNT** (not accessible to user space),
+ *              which is currently set to 32.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_clone_redirect(struct sk_buff *skb, u32 ifindex, u64 flags)
+ *      Description
+ *              Clone and redirect the packet associated to *skb* to another
+ *              net device of index *ifindex*. Both ingress and egress
+ *              interfaces can be used for redirection. The **BPF_F_INGRESS**
+ *              value in *flags* is used to make the distinction (ingress path
+ *              is selected if the flag is present, egress path otherwise).
+ *              This is the only flag supported for now.
+ *
+ *              In comparison with **bpf_redirect**\ () helper,
+ *              **bpf_clone_redirect**\ () has the associated cost of
+ *              duplicating the packet buffer, but this can be executed out of
+ *              the eBPF program. Conversely, **bpf_redirect**\ () is more
+ *              efficient, but it is handled through an action code where the
+ *              redirection happens only after the eBPF program has returned.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
  *
  * u64 bpf_get_current_pid_tgid(void)
- *     Return: current->tgid << 32 | current->pid
+ *      Return
+ *              A 64-bit integer containing the current tgid and pid, and
+ *              created as such:
+ *              *current_task*\ **->tgid << 32 \|**
+ *              *current_task*\ **->pid**.
  *
  * u64 bpf_get_current_uid_gid(void)
- *     Return: current_gid << 32 | current_uid
- *
- * int bpf_get_current_comm(char *buf, int size_of_buf)
- *     stores current->comm into buf
- *     Return: 0 on success or negative error
- *
- * u32 bpf_get_cgroup_classid(skb)
- *     retrieve a proc's classid
- *     @skb: pointer to skb
- *     Return: classid if != 0
- *
- * int bpf_skb_vlan_push(skb, vlan_proto, vlan_tci)
- *     Return: 0 on success or negative error
- *
- * int bpf_skb_vlan_pop(skb)
- *     Return: 0 on success or negative error
- *
- * int bpf_skb_get_tunnel_key(skb, key, size, flags)
- * int bpf_skb_set_tunnel_key(skb, key, size, flags)
- *     retrieve or populate tunnel metadata
- *     @skb: pointer to skb
- *     @key: pointer to 'struct bpf_tunnel_key'
- *     @size: size of 'struct bpf_tunnel_key'
- *     @flags: room for future extensions
- *     Return: 0 on success or negative error
- *
- * u64 bpf_perf_event_read(map, flags)
- *     read perf event counter value
- *     @map: pointer to perf_event_array map
- *     @flags: index of event in the map or bitmask flags
- *     Return: value of perf event counter read or error code
- *
- * int bpf_redirect(ifindex, flags)
- *     redirect to another netdev
- *     @ifindex: ifindex of the net device
- *     @flags:
- *        cls_bpf:
- *          bit 0 - if set, redirect to ingress instead of egress
- *          other bits - reserved
- *        xdp_bpf:
- *          all bits - reserved
- *     Return: cls_bpf: TC_ACT_REDIRECT on success or TC_ACT_SHOT on error
- *             xdp_bfp: XDP_REDIRECT on success or XDP_ABORT on error
- * int bpf_redirect_map(map, key, flags)
- *     redirect to endpoint in map
- *     @map: pointer to dev map
- *     @key: index in map to lookup
- *     @flags: --
- *     Return: XDP_REDIRECT on success or XDP_ABORT on error
- *
- * u32 bpf_get_route_realm(skb)
- *     retrieve a dst's tclassid
- *     @skb: pointer to skb
- *     Return: realm if != 0
- *
- * int bpf_perf_event_output(ctx, map, flags, data, size)
- *     output perf raw sample
- *     @ctx: struct pt_regs*
- *     @map: pointer to perf_event_array map
- *     @flags: index of event in the map or bitmask flags
- *     @data: data on stack to be output as raw data
- *     @size: size of data
- *     Return: 0 on success or negative error
- *
- * int bpf_get_stackid(ctx, map, flags)
- *     walk user or kernel stack and return id
- *     @ctx: struct pt_regs*
- *     @map: pointer to stack_trace map
- *     @flags: bits 0-7 - numer of stack frames to skip
- *             bit 8 - collect user stack instead of kernel
- *             bit 9 - compare stacks by hash only
- *             bit 10 - if two different stacks hash into the same stackid
- *                      discard old
- *             other bits - reserved
- *     Return: >= 0 stackid on success or negative error
- *
- * s64 bpf_csum_diff(from, from_size, to, to_size, seed)
- *     calculate csum diff
- *     @from: raw from buffer
- *     @from_size: length of from buffer
- *     @to: raw to buffer
- *     @to_size: length of to buffer
- *     @seed: optional seed
- *     Return: csum result or negative error code
- *
- * int bpf_skb_get_tunnel_opt(skb, opt, size)
- *     retrieve tunnel options metadata
- *     @skb: pointer to skb
- *     @opt: pointer to raw tunnel option data
- *     @size: size of @opt
- *     Return: option size
- *
- * int bpf_skb_set_tunnel_opt(skb, opt, size)
- *     populate tunnel options metadata
- *     @skb: pointer to skb
- *     @opt: pointer to raw tunnel option data
- *     @size: size of @opt
- *     Return: 0 on success or negative error
- *
- * int bpf_skb_change_proto(skb, proto, flags)
- *     Change protocol of the skb. Currently supported is v4 -> v6,
- *     v6 -> v4 transitions. The helper will also resize the skb. eBPF
- *     program is expected to fill the new headers via skb_store_bytes
- *     and lX_csum_replace.
- *     @skb: pointer to skb
- *     @proto: new skb->protocol type
- *     @flags: reserved
- *     Return: 0 on success or negative error
- *
- * int bpf_skb_change_type(skb, type)
- *     Change packet type of skb.
- *     @skb: pointer to skb
- *     @type: new skb->pkt_type type
- *     Return: 0 on success or negative error
- *
- * int bpf_skb_under_cgroup(skb, map, index)
- *     Check cgroup2 membership of skb
- *     @skb: pointer to skb
- *     @map: pointer to bpf_map in BPF_MAP_TYPE_CGROUP_ARRAY type
- *     @index: index of the cgroup in the bpf_map
- *     Return:
- *       == 0 skb failed the cgroup2 descendant test
- *       == 1 skb succeeded the cgroup2 descendant test
- *        < 0 error
- *
- * u32 bpf_get_hash_recalc(skb)
- *     Retrieve and possibly recalculate skb->hash.
- *     @skb: pointer to skb
- *     Return: hash
+ *      Return
+ *              A 64-bit integer containing the current GID and UID, and
+ *              created as such: *current_gid* **<< 32 \|** *current_uid*.
+ *
+ * int bpf_get_current_comm(char *buf, u32 size_of_buf)
+ *      Description
+ *              Copy the **comm** attribute of the current task into *buf* of
+ *              *size_of_buf*. The **comm** attribute contains the name of
+ *              the executable (excluding the path) for the current task. The
+ *              *size_of_buf* must be strictly positive. On success, the
+ *              helper makes sure that the *buf* is NUL-terminated. On failure,
+ *              it is filled with zeroes.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * u32 bpf_get_cgroup_classid(struct sk_buff *skb)
+ *      Description
+ *              Retrieve the classid for the current task, i.e. for the net_cls
+ *              cgroup to which *skb* belongs.
+ *
+ *              This helper can be used on TC egress path, but not on ingress.
+ *
+ *              The net_cls cgroup provides an interface to tag network packets
+ *              based on a user-provided identifier for all traffic coming from
+ *              the tasks belonging to the related cgroup. See also the related
+ *              kernel documentation, available from the Linux sources in file
+ *              *Documentation/cgroup-v1/net_cls.txt*.
+ *
+ *              The Linux kernel has two versions for cgroups: there are
+ *              cgroups v1 and cgroups v2. Both are available to users, who can
+ *              use a mixture of them, but note that the net_cls cgroup is for
+ *              cgroup v1 only. This makes it incompatible with BPF programs
+ *              run on cgroups, which is a cgroup-v2-only feature (a socket can
+ *              only hold data for one version of cgroups at a time).
+ *
+ *              This helper is only available is the kernel was compiled with
+ *              the **CONFIG_CGROUP_NET_CLASSID** configuration option set to
+ *              "**y**" or to "**m**".
+ *      Return
+ *              The classid, or 0 for the default unconfigured classid.
+ *
+ * int bpf_skb_vlan_push(struct sk_buff *skb, __be16 vlan_proto, u16 vlan_tci)
+ *      Description
+ *              Push a *vlan_tci* (VLAN tag control information) of protocol
+ *              *vlan_proto* to the packet associated to *skb*, then update
+ *              the checksum. Note that if *vlan_proto* is different from
+ *              **ETH_P_8021Q** and **ETH_P_8021AD**, it is considered to
+ *              be **ETH_P_8021Q**.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_skb_vlan_pop(struct sk_buff *skb)
+ *      Description
+ *              Pop a VLAN header from the packet associated to *skb*.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_skb_get_tunnel_key(struct sk_buff *skb, struct bpf_tunnel_key *key, u32 size, u64 flags)
+ *      Description
+ *              Get tunnel metadata. This helper takes a pointer *key* to an
+ *              empty **struct bpf_tunnel_key** of **size**, that will be
+ *              filled with tunnel metadata for the packet associated to *skb*.
+ *              The *flags* can be set to **BPF_F_TUNINFO_IPV6**, which
+ *              indicates that the tunnel is based on IPv6 protocol instead of
+ *              IPv4.
+ *
+ *              The **struct bpf_tunnel_key** is an object that generalizes the
+ *              principal parameters used by various tunneling protocols into a
+ *              single struct. This way, it can be used to easily make a
+ *              decision based on the contents of the encapsulation header,
+ *              "summarized" in this struct. In particular, it holds the IP
+ *              address of the remote end (IPv4 or IPv6, depending on the case)
+ *              in *key*\ **->remote_ipv4** or *key*\ **->remote_ipv6**. Also,
+ *              this struct exposes the *key*\ **->tunnel_id**, which is
+ *              generally mapped to a VNI (Virtual Network Identifier), making
+ *              it programmable together with the **bpf_skb_set_tunnel_key**\
+ *              () helper.
+ *
+ *              Let's imagine that the following code is part of a program
+ *              attached to the TC ingress interface, on one end of a GRE
+ *              tunnel, and is supposed to filter out all messages coming from
+ *              remote ends with IPv4 address other than 10.0.0.1:
+ *
+ *              ::
+ *
+ *                      int ret;
+ *                      struct bpf_tunnel_key key = {};
+ *                      
+ *                      ret = bpf_skb_get_tunnel_key(skb, &key, sizeof(key), 0);
+ *                      if (ret < 0)
+ *                              return TC_ACT_SHOT;     // drop packet
+ *                      
+ *                      if (key.remote_ipv4 != 0x0a000001)
+ *                              return TC_ACT_SHOT;     // drop packet
+ *                      
+ *                      return TC_ACT_OK;               // accept packet
+ *
+ *              This interface can also be used with all encapsulation devices
+ *              that can operate in "collect metadata" mode: instead of having
+ *              one network device per specific configuration, the "collect
+ *              metadata" mode only requires a single device where the
+ *              configuration can be extracted from this helper.
+ *
+ *              This can be used together with various tunnels such as VXLan,
+ *              Geneve, GRE or IP in IP (IPIP).
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_skb_set_tunnel_key(struct sk_buff *skb, struct bpf_tunnel_key *key, u32 size, u64 flags)
+ *      Description
+ *              Populate tunnel metadata for packet associated to *skb.* The
+ *              tunnel metadata is set to the contents of *key*, of *size*. The
+ *              *flags* can be set to a combination of the following values:
+ *
+ *              **BPF_F_TUNINFO_IPV6**
+ *                      Indicate that the tunnel is based on IPv6 protocol
+ *                      instead of IPv4.
+ *              **BPF_F_ZERO_CSUM_TX**
+ *                      For IPv4 packets, add a flag to tunnel metadata
+ *                      indicating that checksum computation should be skipped
+ *                      and checksum set to zeroes.
+ *              **BPF_F_DONT_FRAGMENT**
+ *                      Add a flag to tunnel metadata indicating that the
+ *                      packet should not be fragmented.
+ *              **BPF_F_SEQ_NUMBER**
+ *                      Add a flag to tunnel metadata indicating that a
+ *                      sequence number should be added to tunnel header before
+ *                      sending the packet. This flag was added for GRE
+ *                      encapsulation, but might be used with other protocols
+ *                      as well in the future.
+ *
+ *              Here is a typical usage on the transmit path:
+ *
+ *              ::
+ *
+ *                      struct bpf_tunnel_key key;
+ *                           populate key ...
+ *                      bpf_skb_set_tunnel_key(skb, &key, sizeof(key), 0);
+ *                      bpf_clone_redirect(skb, vxlan_dev_ifindex, 0);
+ *
+ *              See also the description of the **bpf_skb_get_tunnel_key**\ ()
+ *              helper for additional information.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * u64 bpf_perf_event_read(struct bpf_map *map, u64 flags)
+ *      Description
+ *              Read the value of a perf event counter. This helper relies on a
+ *              *map* of type **BPF_MAP_TYPE_PERF_EVENT_ARRAY**. The nature of
+ *              the perf event counter is selected when *map* is updated with
+ *              perf event file descriptors. The *map* is an array whose size
+ *              is the number of available CPUs, and each cell contains a value
+ *              relative to one CPU. The value to retrieve is indicated by
+ *              *flags*, that contains the index of the CPU to look up, masked
+ *              with **BPF_F_INDEX_MASK**. Alternatively, *flags* can be set to
+ *              **BPF_F_CURRENT_CPU** to indicate that the value for the
+ *              current CPU should be retrieved.
+ *
+ *              Note that before Linux 4.13, only hardware perf event can be
+ *              retrieved.
+ *
+ *              Also, be aware that the newer helper
+ *              **bpf_perf_event_read_value**\ () is recommended over
+ *              **bpf_perf_event_read**\ () in general. The latter has some ABI
+ *              quirks where error and counter value are used as a return code
+ *              (which is wrong to do since ranges may overlap). This issue is
+ *              fixed with **bpf_perf_event_read_value**\ (), which at the same
+ *              time provides more features over the **bpf_perf_event_read**\
+ *              () interface. Please refer to the description of
+ *              **bpf_perf_event_read_value**\ () for details.
+ *      Return
+ *              The value of the perf event counter read from the map, or a
+ *              negative error code in case of failure.
+ *
+ * int bpf_redirect(u32 ifindex, u64 flags)
+ *      Description
+ *              Redirect the packet to another net device of index *ifindex*.
+ *              This helper is somewhat similar to **bpf_clone_redirect**\
+ *              (), except that the packet is not cloned, which provides
+ *              increased performance.
+ *
+ *              Except for XDP, both ingress and egress interfaces can be used
+ *              for redirection. The **BPF_F_INGRESS** value in *flags* is used
+ *              to make the distinction (ingress path is selected if the flag
+ *              is present, egress path otherwise). Currently, XDP only
+ *              supports redirection to the egress interface, and accepts no
+ *              flag at all.
+ *
+ *              The same effect can be attained with the more generic
+ *              **bpf_redirect_map**\ (), which requires specific maps to be
+ *              used but offers better performance.
+ *      Return
+ *              For XDP, the helper returns **XDP_REDIRECT** on success or
+ *              **XDP_ABORTED** on error. For other program types, the values
+ *              are **TC_ACT_REDIRECT** on success or **TC_ACT_SHOT** on
+ *              error.
+ *
+ * u32 bpf_get_route_realm(struct sk_buff *skb)
+ *      Description
+ *              Retrieve the realm or the route, that is to say the
+ *              **tclassid** field of the destination for the *skb*. The
+ *              indentifier retrieved is a user-provided tag, similar to the
+ *              one used with the net_cls cgroup (see description for
+ *              **bpf_get_cgroup_classid**\ () helper), but here this tag is
+ *              held by a route (a destination entry), not by a task.
+ *
+ *              Retrieving this identifier works with the clsact TC egress hook
+ *              (see also **tc-bpf(8)**), or alternatively on conventional
+ *              classful egress qdiscs, but not on TC ingress path. In case of
+ *              clsact TC egress hook, this has the advantage that, internally,
+ *              the destination entry has not been dropped yet in the transmit
+ *              path. Therefore, the destination entry does not need to be
+ *              artificially held via **netif_keep_dst**\ () for a classful
+ *              qdisc until the *skb* is freed.
+ *
+ *              This helper is available only if the kernel was compiled with
+ *              **CONFIG_IP_ROUTE_CLASSID** configuration option.
+ *      Return
+ *              The realm of the route for the packet associated to *skb*, or 0
+ *              if none was found.
+ *
+ * int bpf_perf_event_output(struct pt_reg *ctx, struct bpf_map *map, u64 flags, void *data, u64 size)
+ *      Description
+ *              Write raw *data* blob into a special BPF perf event held by
+ *              *map* of type **BPF_MAP_TYPE_PERF_EVENT_ARRAY**. This perf
+ *              event must have the following attributes: **PERF_SAMPLE_RAW**
+ *              as **sample_type**, **PERF_TYPE_SOFTWARE** as **type**, and
+ *              **PERF_COUNT_SW_BPF_OUTPUT** as **config**.
+ *
+ *              The *flags* are used to indicate the index in *map* for which
+ *              the value must be put, masked with **BPF_F_INDEX_MASK**.
+ *              Alternatively, *flags* can be set to **BPF_F_CURRENT_CPU**
+ *              to indicate that the index of the current CPU core should be
+ *              used.
+ *
+ *              The value to write, of *size*, is passed through eBPF stack and
+ *              pointed by *data*.
+ *
+ *              The context of the program *ctx* needs also be passed to the
+ *              helper.
+ *
+ *              On user space, a program willing to read the values needs to
+ *              call **perf_event_open**\ () on the perf event (either for
+ *              one or for all CPUs) and to store the file descriptor into the
+ *              *map*. This must be done before the eBPF program can send data
+ *              into it. An example is available in file
+ *              *samples/bpf/trace_output_user.c* in the Linux kernel source
+ *              tree (the eBPF program counterpart is in
+ *              *samples/bpf/trace_output_kern.c*).
+ *
+ *              **bpf_perf_event_output**\ () achieves better performance
+ *              than **bpf_trace_printk**\ () for sharing data with user
+ *              space, and is much better suitable for streaming data from eBPF
+ *              programs.
+ *
+ *              Note that this helper is not restricted to tracing use cases
+ *              and can be used with programs attached to TC or XDP as well,
+ *              where it allows for passing data to user space listeners. Data
+ *              can be:
+ *
+ *              * Only custom structs,
+ *              * Only the packet payload, or
+ *              * A combination of both.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_skb_load_bytes(const struct sk_buff *skb, u32 offset, void *to, u32 len)
+ *      Description
+ *              This helper was provided as an easy way to load data from a
+ *              packet. It can be used to load *len* bytes from *offset* from
+ *              the packet associated to *skb*, into the buffer pointed by
+ *              *to*.
+ *
+ *              Since Linux 4.7, usage of this helper has mostly been replaced
+ *              by "direct packet access", enabling packet data to be
+ *              manipulated with *skb*\ **->data** and *skb*\ **->data_end**
+ *              pointing respectively to the first byte of packet data and to
+ *              the byte after the last byte of packet data. However, it
+ *              remains useful if one wishes to read large quantities of data
+ *              at once from a packet into the eBPF stack.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_get_stackid(struct pt_reg *ctx, struct bpf_map *map, u64 flags)
+ *      Description
+ *              Walk a user or a kernel stack and return its id. To achieve
+ *              this, the helper needs *ctx*, which is a pointer to the context
+ *              on which the tracing program is executed, and a pointer to a
+ *              *map* of type **BPF_MAP_TYPE_STACK_TRACE**.
+ *
+ *              The last argument, *flags*, holds the number of stack frames to
+ *              skip (from 0 to 255), masked with
+ *              **BPF_F_SKIP_FIELD_MASK**. The next bits can be used to set
+ *              a combination of the following flags:
+ *
+ *              **BPF_F_USER_STACK**
+ *                      Collect a user space stack instead of a kernel stack.
+ *              **BPF_F_FAST_STACK_CMP**
+ *                      Compare stacks by hash only.
+ *              **BPF_F_REUSE_STACKID**
+ *                      If two different stacks hash into the same *stackid*,
+ *                      discard the old one.
+ *
+ *              The stack id retrieved is a 32 bit long integer handle which
+ *              can be further combined with other data (including other stack
+ *              ids) and used as a key into maps. This can be useful for
+ *              generating a variety of graphs (such as flame graphs or off-cpu
+ *              graphs).
+ *
+ *              For walking a stack, this helper is an improvement over
+ *              **bpf_probe_read**\ (), which can be used with unrolled loops
+ *              but is not efficient and consumes a lot of eBPF instructions.
+ *              Instead, **bpf_get_stackid**\ () can collect up to
+ *              **PERF_MAX_STACK_DEPTH** both kernel and user frames. Note that
+ *              this limit can be controlled with the **sysctl** program, and
+ *              that it should be manually increased in order to profile long
+ *              user stacks (such as stacks for Java programs). To do so, use:
+ *
+ *              ::
+ *
+ *                      # sysctl kernel.perf_event_max_stack=<new value>
+ *      Return
+ *              The positive or null stack id on success, or a negative error
+ *              in case of failure.
+ *
+ * s64 bpf_csum_diff(__be32 *from, u32 from_size, __be32 *to, u32 to_size, __wsum seed)
+ *      Description
+ *              Compute a checksum difference, from the raw buffer pointed by
+ *              *from*, of length *from_size* (that must be a multiple of 4),
+ *              towards the raw buffer pointed by *to*, of size *to_size*
+ *              (same remark). An optional *seed* can be added to the value
+ *              (this can be cascaded, the seed may come from a previous call
+ *              to the helper).
+ *
+ *              This is flexible enough to be used in several ways:
+ *
+ *              * With *from_size* == 0, *to_size* > 0 and *seed* set to
+ *                checksum, it can be used when pushing new data.
+ *              * With *from_size* > 0, *to_size* == 0 and *seed* set to
+ *                checksum, it can be used when removing data from a packet.
+ *              * With *from_size* > 0, *to_size* > 0 and *seed* set to 0, it
+ *                can be used to compute a diff. Note that *from_size* and
+ *                *to_size* do not need to be equal.
+ *
+ *              This helper can be used in combination with
+ *              **bpf_l3_csum_replace**\ () and **bpf_l4_csum_replace**\ (), to
+ *              which one can feed in the difference computed with
+ *              **bpf_csum_diff**\ ().
+ *      Return
+ *              The checksum result, or a negative error code in case of
+ *              failure.
+ *
+ * int bpf_skb_get_tunnel_opt(struct sk_buff *skb, u8 *opt, u32 size)
+ *      Description
+ *              Retrieve tunnel options metadata for the packet associated to
+ *              *skb*, and store the raw tunnel option data to the buffer *opt*
+ *              of *size*.
+ *
+ *              This helper can be used with encapsulation devices that can
+ *              operate in "collect metadata" mode (please refer to the related
+ *              note in the description of **bpf_skb_get_tunnel_key**\ () for
+ *              more details). A particular example where this can be used is
+ *              in combination with the Geneve encapsulation protocol, where it
+ *              allows for pushing (with **bpf_skb_get_tunnel_opt**\ () helper)
+ *              and retrieving arbitrary TLVs (Type-Length-Value headers) from
+ *              the eBPF program. This allows for full customization of these
+ *              headers.
+ *      Return
+ *              The size of the option data retrieved.
+ *
+ * int bpf_skb_set_tunnel_opt(struct sk_buff *skb, u8 *opt, u32 size)
+ *      Description
+ *              Set tunnel options metadata for the packet associated to *skb*
+ *              to the option data contained in the raw buffer *opt* of *size*.
+ *
+ *              See also the description of the **bpf_skb_get_tunnel_opt**\ ()
+ *              helper for additional information.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_skb_change_proto(struct sk_buff *skb, __be16 proto, u64 flags)
+ *      Description
+ *              Change the protocol of the *skb* to *proto*. Currently
+ *              supported are transition from IPv4 to IPv6, and from IPv6 to
+ *              IPv4. The helper takes care of the groundwork for the
+ *              transition, including resizing the socket buffer. The eBPF
+ *              program is expected to fill the new headers, if any, via
+ *              **skb_store_bytes**\ () and to recompute the checksums with
+ *              **bpf_l3_csum_replace**\ () and **bpf_l4_csum_replace**\
+ *              (). The main case for this helper is to perform NAT64
+ *              operations out of an eBPF program.
+ *
+ *              Internally, the GSO type is marked as dodgy so that headers are
+ *              checked and segments are recalculated by the GSO/GRO engine.
+ *              The size for GSO target is adapted as well.
+ *
+ *              All values for *flags* are reserved for future usage, and must
+ *              be left at zero.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_skb_change_type(struct sk_buff *skb, u32 type)
+ *      Description
+ *              Change the packet type for the packet associated to *skb*. This
+ *              comes down to setting *skb*\ **->pkt_type** to *type*, except
+ *              the eBPF program does not have a write access to *skb*\
+ *              **->pkt_type** beside this helper. Using a helper here allows
+ *              for graceful handling of errors.
+ *
+ *              The major use case is to change incoming *skb*s to
+ *              **PACKET_HOST** in a programmatic way instead of having to
+ *              recirculate via **redirect**\ (..., **BPF_F_INGRESS**), for
+ *              example.
+ *
+ *              Note that *type* only allows certain values. At this time, they
+ *              are:
+ *
+ *              **PACKET_HOST**
+ *                      Packet is for us.
+ *              **PACKET_BROADCAST**
+ *                      Send packet to all.
+ *              **PACKET_MULTICAST**
+ *                      Send packet to group.
+ *              **PACKET_OTHERHOST**
+ *                      Send packet to someone else.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_skb_under_cgroup(struct sk_buff *skb, struct bpf_map *map, u32 index)
+ *      Description
+ *              Check whether *skb* is a descendant of the cgroup2 held by
+ *              *map* of type **BPF_MAP_TYPE_CGROUP_ARRAY**, at *index*.
+ *      Return
+ *              The return value depends on the result of the test, and can be:
+ *
+ *              * 0, if the *skb* failed the cgroup2 descendant test.
+ *              * 1, if the *skb* succeeded the cgroup2 descendant test.
+ *              * A negative error code, if an error occurred.
+ *
+ * u32 bpf_get_hash_recalc(struct sk_buff *skb)
+ *      Description
+ *              Retrieve the hash of the packet, *skb*\ **->hash**. If it is
+ *              not set, in particular if the hash was cleared due to mangling,
+ *              recompute this hash. Later accesses to the hash can be done
+ *              directly with *skb*\ **->hash**.
+ *
+ *              Calling **bpf_set_hash_invalid**\ (), changing a packet
+ *              prototype with **bpf_skb_change_proto**\ (), or calling
+ *              **bpf_skb_store_bytes**\ () with the
+ *              **BPF_F_INVALIDATE_HASH** are actions susceptible to clear
+ *              the hash and to trigger a new computation for the next call to
+ *              **bpf_get_hash_recalc**\ ().
+ *      Return
+ *              The 32-bit hash.
  *
  * u64 bpf_get_current_task(void)
- *     Returns current task_struct
- *     Return: current
- *
- * int bpf_probe_write_user(void *dst, void *src, int len)
- *     safely attempt to write to a location
- *     @dst: destination address in userspace
- *     @src: source address on stack
- *     @len: number of bytes to copy
- *     Return: 0 on success or negative error
- *
- * int bpf_current_task_under_cgroup(map, index)
- *     Check cgroup2 membership of current task
- *     @map: pointer to bpf_map in BPF_MAP_TYPE_CGROUP_ARRAY type
- *     @index: index of the cgroup in the bpf_map
- *     Return:
- *       == 0 current failed the cgroup2 descendant test
- *       == 1 current succeeded the cgroup2 descendant test
- *        < 0 error
- *
- * int bpf_skb_change_tail(skb, len, flags)
- *     The helper will resize the skb to the given new size, to be used f.e.
- *     with control messages.
- *     @skb: pointer to skb
- *     @len: new skb length
- *     @flags: reserved
- *     Return: 0 on success or negative error
- *
- * int bpf_skb_pull_data(skb, len)
- *     The helper will pull in non-linear data in case the skb is non-linear
- *     and not all of len are part of the linear section. Only needed for
- *     read/write with direct packet access.
- *     @skb: pointer to skb
- *     @len: len to make read/writeable
- *     Return: 0 on success or negative error
- *
- * s64 bpf_csum_update(skb, csum)
- *     Adds csum into skb->csum in case of CHECKSUM_COMPLETE.
- *     @skb: pointer to skb
- *     @csum: csum to add
- *     Return: csum on success or negative error
- *
- * void bpf_set_hash_invalid(skb)
- *     Invalidate current skb->hash.
- *     @skb: pointer to skb
- *
- * int bpf_get_numa_node_id()
- *     Return: Id of current NUMA node.
- *
- * int bpf_skb_change_head()
- *     Grows headroom of skb and adjusts MAC header offset accordingly.
- *     Will extends/reallocae as required automatically.
- *     May change skb data pointer and will thus invalidate any check
- *     performed for direct packet access.
- *     @skb: pointer to skb
- *     @len: length of header to be pushed in front
- *     @flags: Flags (unused for now)
- *     Return: 0 on success or negative error
- *
- * int bpf_xdp_adjust_head(xdp_md, delta)
- *     Adjust the xdp_md.data by delta
- *     @xdp_md: pointer to xdp_md
- *     @delta: An positive/negative integer to be added to xdp_md.data
- *     Return: 0 on success or negative on error
+ *      Return
+ *              A pointer to the current task struct.
+ *
+ * int bpf_probe_write_user(void *dst, const void *src, u32 len)
+ *      Description
+ *              Attempt in a safe way to write *len* bytes from the buffer
+ *              *src* to *dst* in memory. It only works for threads that are in
+ *              user context, and *dst* must be a valid user space address.
+ *
+ *              This helper should not be used to implement any kind of
+ *              security mechanism because of TOC-TOU attacks, but rather to
+ *              debug, divert, and manipulate execution of semi-cooperative
+ *              processes.
+ *
+ *              Keep in mind that this feature is meant for experiments, and it
+ *              has a risk of crashing the system and running programs.
+ *              Therefore, when an eBPF program using this helper is attached,
+ *              a warning including PID and process name is printed to kernel
+ *              logs.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_current_task_under_cgroup(struct bpf_map *map, u32 index)
+ *      Description
+ *              Check whether the probe is being run is the context of a given
+ *              subset of the cgroup2 hierarchy. The cgroup2 to test is held by
+ *              *map* of type **BPF_MAP_TYPE_CGROUP_ARRAY**, at *index*.
+ *      Return
+ *              The return value depends on the result of the test, and can be:
+ *
+ *              * 0, if the *skb* task belongs to the cgroup2.
+ *              * 1, if the *skb* task does not belong to the cgroup2.
+ *              * A negative error code, if an error occurred.
+ *
+ * int bpf_skb_change_tail(struct sk_buff *skb, u32 len, u64 flags)
+ *      Description
+ *              Resize (trim or grow) the packet associated to *skb* to the
+ *              new *len*. The *flags* are reserved for future usage, and must
+ *              be left at zero.
+ *
+ *              The basic idea is that the helper performs the needed work to
+ *              change the size of the packet, then the eBPF program rewrites
+ *              the rest via helpers like **bpf_skb_store_bytes**\ (),
+ *              **bpf_l3_csum_replace**\ (), **bpf_l3_csum_replace**\ ()
+ *              and others. This helper is a slow path utility intended for
+ *              replies with control messages. And because it is targeted for
+ *              slow path, the helper itself can afford to be slow: it
+ *              implicitly linearizes, unclones and drops offloads from the
+ *              *skb*.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_skb_pull_data(struct sk_buff *skb, u32 len)
+ *      Description
+ *              Pull in non-linear data in case the *skb* is non-linear and not
+ *              all of *len* are part of the linear section. Make *len* bytes
+ *              from *skb* readable and writable. If a zero value is passed for
+ *              *len*, then the whole length of the *skb* is pulled.
+ *
+ *              This helper is only needed for reading and writing with direct
+ *              packet access.
+ *
+ *              For direct packet access, testing that offsets to access
+ *              are within packet boundaries (test on *skb*\ **->data_end**) is
+ *              susceptible to fail if offsets are invalid, or if the requested
+ *              data is in non-linear parts of the *skb*. On failure the
+ *              program can just bail out, or in the case of a non-linear
+ *              buffer, use a helper to make the data available. The
+ *              **bpf_skb_load_bytes**\ () helper is a first solution to access
+ *              the data. Another one consists in using **bpf_skb_pull_data**
+ *              to pull in once the non-linear parts, then retesting and
+ *              eventually access the data.
+ *
+ *              At the same time, this also makes sure the *skb* is uncloned,
+ *              which is a necessary condition for direct write. As this needs
+ *              to be an invariant for the write part only, the verifier
+ *              detects writes and adds a prologue that is calling
+ *              **bpf_skb_pull_data()** to effectively unclone the *skb* from
+ *              the very beginning in case it is indeed cloned.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * s64 bpf_csum_update(struct sk_buff *skb, __wsum csum)
+ *      Description
+ *              Add the checksum *csum* into *skb*\ **->csum** in case the
+ *              driver has supplied a checksum for the entire packet into that
+ *              field. Return an error otherwise. This helper is intended to be
+ *              used in combination with **bpf_csum_diff**\ (), in particular
+ *              when the checksum needs to be updated after data has been
+ *              written into the packet through direct packet access.
+ *      Return
+ *              The checksum on success, or a negative error code in case of
+ *              failure.
+ *
+ * void bpf_set_hash_invalid(struct sk_buff *skb)
+ *      Description
+ *              Invalidate the current *skb*\ **->hash**. It can be used after
+ *              mangling on headers through direct packet access, in order to
+ *              indicate that the hash is outdated and to trigger a
+ *              recalculation the next time the kernel tries to access this
+ *              hash or when the **bpf_get_hash_recalc**\ () helper is called.
+ *
+ * int bpf_get_numa_node_id(void)
+ *      Description
+ *              Return the id of the current NUMA node. The primary use case
+ *              for this helper is the selection of sockets for the local NUMA
+ *              node, when the program is attached to sockets using the
+ *              **SO_ATTACH_REUSEPORT_EBPF** option (see also **socket(7)**),
+ *              but the helper is also available to other eBPF program types,
+ *              similarly to **bpf_get_smp_processor_id**\ ().
+ *      Return
+ *              The id of current NUMA node.
+ *
+ * int bpf_skb_change_head(struct sk_buff *skb, u32 len, u64 flags)
+ *      Description
+ *              Grows headroom of packet associated to *skb* and adjusts the
+ *              offset of the MAC header accordingly, adding *len* bytes of
+ *              space. It automatically extends and reallocates memory as
+ *              required.
+ *
+ *              This helper can be used on a layer 3 *skb* to push a MAC header
+ *              for redirection into a layer 2 device.
+ *
+ *              All values for *flags* are reserved for future usage, and must
+ *              be left at zero.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_xdp_adjust_head(struct xdp_buff *xdp_md, int delta)
+ *      Description
+ *              Adjust (move) *xdp_md*\ **->data** by *delta* bytes. Note that
+ *              it is possible to use a negative value for *delta*. This helper
+ *              can be used to prepare the packet for pushing or popping
+ *              headers.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
  *
  * int bpf_probe_read_str(void *dst, int size, const void *unsafe_ptr)
- *     Copy a NUL terminated string from unsafe address. In case the string
- *     length is smaller than size, the target is not padded with further NUL
- *     bytes. In case the string length is larger than size, just count-1
- *     bytes are copied and the last byte is set to NUL.
- *     @dst: destination address
- *     @size: maximum number of bytes to copy, including the trailing NUL
- *     @unsafe_ptr: unsafe address
- *     Return:
- *       > 0 length of the string including the trailing NUL on success
- *       < 0 error
- *
- * u64 bpf_get_socket_cookie(skb)
- *     Get the cookie for the socket stored inside sk_buff.
- *     @skb: pointer to skb
- *     Return: 8 Bytes non-decreasing number on success or 0 if the socket
- *     field is missing inside sk_buff
- *
- * u32 bpf_get_socket_uid(skb)
- *     Get the owner uid of the socket stored inside sk_buff.
- *     @skb: pointer to skb
- *     Return: uid of the socket owner on success or overflowuid if failed.
- *
- * u32 bpf_set_hash(skb, hash)
- *     Set full skb->hash.
- *     @skb: pointer to skb
- *     @hash: hash to set
- *
- * int bpf_setsockopt(bpf_socket, level, optname, optval, optlen)
- *     Calls setsockopt. Not all opts are available, only those with
- *     integer optvals plus TCP_CONGESTION.
- *     Supported levels: SOL_SOCKET and IPPROTO_TCP
- *     @bpf_socket: pointer to bpf_socket
- *     @level: SOL_SOCKET or IPPROTO_TCP
- *     @optname: option name
- *     @optval: pointer to option value
- *     @optlen: length of optval in bytes
- *     Return: 0 or negative error
- *
- * int bpf_getsockopt(bpf_socket, level, optname, optval, optlen)
- *     Calls getsockopt. Not all opts are available.
- *     Supported levels: IPPROTO_TCP
- *     @bpf_socket: pointer to bpf_socket
- *     @level: IPPROTO_TCP
- *     @optname: option name
- *     @optval: pointer to option value
- *     @optlen: length of optval in bytes
- *     Return: 0 or negative error
- *
- * int bpf_sock_ops_cb_flags_set(bpf_sock_ops, flags)
- *     Set callback flags for sock_ops
- *     @bpf_sock_ops: pointer to bpf_sock_ops_kern struct
- *     @flags: flags value
- *     Return: 0 for no error
- *             -EINVAL if there is no full tcp socket
- *             bits in flags that are not supported by current kernel
- *
- * int bpf_skb_adjust_room(skb, len_diff, mode, flags)
- *     Grow or shrink room in sk_buff.
- *     @skb: pointer to skb
- *     @len_diff: (signed) amount of room to grow/shrink
- *     @mode: operation mode (enum bpf_adj_room_mode)
- *     @flags: reserved for future use
- *     Return: 0 on success or negative error code
- *
- * int bpf_sk_redirect_map(map, key, flags)
- *     Redirect skb to a sock in map using key as a lookup key for the
- *     sock in map.
- *     @map: pointer to sockmap
- *     @key: key to lookup sock in map
- *     @flags: reserved for future use
- *     Return: SK_PASS
- *
- * int bpf_sock_map_update(skops, map, key, flags)
- *      @skops: pointer to bpf_sock_ops
- *      @map: pointer to sockmap to update
- *      @key: key to insert/update sock in map
- *      @flags: same flags as map update elem
- *
- * int bpf_xdp_adjust_meta(xdp_md, delta)
- *     Adjust the xdp_md.data_meta by delta
- *     @xdp_md: pointer to xdp_md
- *     @delta: An positive/negative integer to be added to xdp_md.data_meta
- *     Return: 0 on success or negative on error
- *
- * int bpf_perf_event_read_value(map, flags, buf, buf_size)
- *     read perf event counter value and perf event enabled/running time
- *     @map: pointer to perf_event_array map
- *     @flags: index of event in the map or bitmask flags
- *     @buf: buf to fill
- *     @buf_size: size of the buf
- *     Return: 0 on success or negative error code
- *
- * int bpf_perf_prog_read_value(ctx, buf, buf_size)
- *     read perf prog attached perf event counter and enabled/running time
- *     @ctx: pointer to ctx
- *     @buf: buf to fill
- *     @buf_size: size of the buf
- *     Return : 0 on success or negative error code
- *
- * int bpf_override_return(pt_regs, rc)
- *      @pt_regs: pointer to struct pt_regs
- *      @rc: the return value to set
- *
- * int bpf_msg_redirect_map(map, key, flags)
- *     Redirect msg to a sock in map using key as a lookup key for the
- *     sock in map.
- *     @map: pointer to sockmap
- *     @key: key to lookup sock in map
- *     @flags: reserved for future use
- *     Return: SK_PASS
- *
- * int bpf_bind(ctx, addr, addr_len)
- *     Bind socket to address. Only binding to IP is supported, no port can be
- *     set in addr.
- *     @ctx: pointer to context of type bpf_sock_addr
- *     @addr: pointer to struct sockaddr to bind socket to
- *     @addr_len: length of sockaddr structure
- *     Return: 0 on success or negative error code
+ *      Description
+ *              Copy a NUL terminated string from an unsafe address
+ *              *unsafe_ptr* to *dst*. The *size* should include the
+ *              terminating NUL byte. In case the string length is smaller than
+ *              *size*, the target is not padded with further NUL bytes. If the
+ *              string length is larger than *size*, just *size*-1 bytes are
+ *              copied and the last byte is set to NUL.
+ *
+ *              On success, the length of the copied string is returned. This
+ *              makes this helper useful in tracing programs for reading
+ *              strings, and more importantly to get its length at runtime. See
+ *              the following snippet:
+ *
+ *              ::
+ *
+ *                      SEC("kprobe/sys_open")
+ *                      void bpf_sys_open(struct pt_regs *ctx)
+ *                      {
+ *                              char buf[PATHLEN]; // PATHLEN is defined to 256
+ *                              int res = bpf_probe_read_str(buf, sizeof(buf),
+ *                                                           ctx->di);
+ *
+ *                              // Consume buf, for example push it to
+ *                              // userspace via bpf_perf_event_output(); we
+ *                              // can use res (the string length) as event
+ *                              // size, after checking its boundaries.
+ *                      }
+ *
+ *              In comparison, using **bpf_probe_read()** helper here instead
+ *              to read the string would require to estimate the length at
+ *              compile time, and would often result in copying more memory
+ *              than necessary.
+ *
+ *              Another useful use case is when parsing individual process
+ *              arguments or individual environment variables navigating
+ *              *current*\ **->mm->arg_start** and *current*\
+ *              **->mm->env_start**: using this helper and the return value,
+ *              one can quickly iterate at the right offset of the memory area.
+ *      Return
+ *              On success, the strictly positive length of the string,
+ *              including the trailing NUL character. On error, a negative
+ *              value.
+ *
+ * u64 bpf_get_socket_cookie(struct sk_buff *skb)
+ *      Description
+ *              If the **struct sk_buff** pointed by *skb* has a known socket,
+ *              retrieve the cookie (generated by the kernel) of this socket.
+ *              If no cookie has been set yet, generate a new cookie. Once
+ *              generated, the socket cookie remains stable for the life of the
+ *              socket. This helper can be useful for monitoring per socket
+ *              networking traffic statistics as it provides a unique socket
+ *              identifier per namespace.
+ *      Return
+ *              A 8-byte long non-decreasing number on success, or 0 if the
+ *              socket field is missing inside *skb*.
+ *
+ * u32 bpf_get_socket_uid(struct sk_buff *skb)
+ *      Return
+ *              The owner UID of the socket associated to *skb*. If the socket
+ *              is **NULL**, or if it is not a full socket (i.e. if it is a
+ *              time-wait or a request socket instead), **overflowuid** value
+ *              is returned (note that **overflowuid** might also be the actual
+ *              UID value for the socket).
+ *
+ * u32 bpf_set_hash(struct sk_buff *skb, u32 hash)
+ *      Description
+ *              Set the full hash for *skb* (set the field *skb*\ **->hash**)
+ *              to value *hash*.
+ *      Return
+ *              0
+ *
+ * int bpf_setsockopt(struct bpf_sock_ops *bpf_socket, int level, int optname, char *optval, int optlen)
+ *      Description
+ *              Emulate a call to **setsockopt()** on the socket associated to
+ *              *bpf_socket*, which must be a full socket. The *level* at
+ *              which the option resides and the name *optname* of the option
+ *              must be specified, see **setsockopt(2)** for more information.
+ *              The option value of length *optlen* is pointed by *optval*.
+ *
+ *              This helper actually implements a subset of **setsockopt()**.
+ *              It supports the following *level*\ s:
+ *
+ *              * **SOL_SOCKET**, which supports the following *optname*\ s:
+ *                **SO_RCVBUF**, **SO_SNDBUF**, **SO_MAX_PACING_RATE**,
+ *                **SO_PRIORITY**, **SO_RCVLOWAT**, **SO_MARK**.
+ *              * **IPPROTO_TCP**, which supports the following *optname*\ s:
+ *                **TCP_CONGESTION**, **TCP_BPF_IW**,
+ *                **TCP_BPF_SNDCWND_CLAMP**.
+ *              * **IPPROTO_IP**, which supports *optname* **IP_TOS**.
+ *              * **IPPROTO_IPV6**, which supports *optname* **IPV6_TCLASS**.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_skb_adjust_room(struct sk_buff *skb, u32 len_diff, u32 mode, u64 flags)
+ *      Description
+ *              Grow or shrink the room for data in the packet associated to
+ *              *skb* by *len_diff*, and according to the selected *mode*.
+ *
+ *              There is a single supported mode at this time:
+ *
+ *              * **BPF_ADJ_ROOM_NET**: Adjust room at the network layer
+ *                (room space is added or removed below the layer 3 header).
+ *
+ *              All values for *flags* are reserved for future usage, and must
+ *              be left at zero.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_redirect_map(struct bpf_map *map, u32 key, u64 flags)
+ *      Description
+ *              Redirect the packet to the endpoint referenced by *map* at
+ *              index *key*. Depending on its type, this *map* can contain
+ *              references to net devices (for forwarding packets through other
+ *              ports), or to CPUs (for redirecting XDP frames to another CPU;
+ *              but this is only implemented for native XDP (with driver
+ *              support) as of this writing).
+ *
+ *              All values for *flags* are reserved for future usage, and must
+ *              be left at zero.
+ *
+ *              When used to redirect packets to net devices, this helper
+ *              provides a high performance increase over **bpf_redirect**\ ().
+ *              This is due to various implementation details of the underlying
+ *              mechanisms, one of which is the fact that **bpf_redirect_map**\
+ *              () tries to send packet as a "bulk" to the device.
+ *      Return
+ *              **XDP_REDIRECT** on success, or **XDP_ABORTED** on error.
+ *
+ * int bpf_sk_redirect_map(struct bpf_map *map, u32 key, u64 flags)
+ *      Description
+ *              Redirect the packet to the socket referenced by *map* (of type
+ *              **BPF_MAP_TYPE_SOCKMAP**) at index *key*. Both ingress and
+ *              egress interfaces can be used for redirection. The
+ *              **BPF_F_INGRESS** value in *flags* is used to make the
+ *              distinction (ingress path is selected if the flag is present,
+ *              egress path otherwise). This is the only flag supported for now.
+ *      Return
+ *              **SK_PASS** on success, or **SK_DROP** on error.
+ *
+ * int bpf_sock_map_update(struct bpf_sock_ops *skops, struct bpf_map *map, void *key, u64 flags)
+ *      Description
+ *              Add an entry to, or update a *map* referencing sockets. The
+ *              *skops* is used as a new value for the entry associated to
+ *              *key*. *flags* is one of:
+ *
+ *              **BPF_NOEXIST**
+ *                      The entry for *key* must not exist in the map.
+ *              **BPF_EXIST**
+ *                      The entry for *key* must already exist in the map.
+ *              **BPF_ANY**
+ *                      No condition on the existence of the entry for *key*.
+ *
+ *              If the *map* has eBPF programs (parser and verdict), those will
+ *              be inherited by the socket being added. If the socket is
+ *              already attached to eBPF programs, this results in an error.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_xdp_adjust_meta(struct xdp_buff *xdp_md, int delta)
+ *      Description
+ *              Adjust the address pointed by *xdp_md*\ **->data_meta** by
+ *              *delta* (which can be positive or negative). Note that this
+ *              operation modifies the address stored in *xdp_md*\ **->data**,
+ *              so the latter must be loaded only after the helper has been
+ *              called.
+ *
+ *              The use of *xdp_md*\ **->data_meta** is optional and programs
+ *              are not required to use it. The rationale is that when the
+ *              packet is processed with XDP (e.g. as DoS filter), it is
+ *              possible to push further meta data along with it before passing
+ *              to the stack, and to give the guarantee that an ingress eBPF
+ *              program attached as a TC classifier on the same device can pick
+ *              this up for further post-processing. Since TC works with socket
+ *              buffers, it remains possible to set from XDP the **mark** or
+ *              **priority** pointers, or other pointers for the socket buffer.
+ *              Having this scratch space generic and programmable allows for
+ *              more flexibility as the user is free to store whatever meta
+ *              data they need.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_perf_event_read_value(struct bpf_map *map, u64 flags, struct bpf_perf_event_value *buf, u32 buf_size)
+ *      Description
+ *              Read the value of a perf event counter, and store it into *buf*
+ *              of size *buf_size*. This helper relies on a *map* of type
+ *              **BPF_MAP_TYPE_PERF_EVENT_ARRAY**. The nature of the perf event
+ *              counter is selected when *map* is updated with perf event file
+ *              descriptors. The *map* is an array whose size is the number of
+ *              available CPUs, and each cell contains a value relative to one
+ *              CPU. The value to retrieve is indicated by *flags*, that
+ *              contains the index of the CPU to look up, masked with
+ *              **BPF_F_INDEX_MASK**. Alternatively, *flags* can be set to
+ *              **BPF_F_CURRENT_CPU** to indicate that the value for the
+ *              current CPU should be retrieved.
+ *
+ *              This helper behaves in a way close to
+ *              **bpf_perf_event_read**\ () helper, save that instead of
+ *              just returning the value observed, it fills the *buf*
+ *              structure. This allows for additional data to be retrieved: in
+ *              particular, the enabled and running times (in *buf*\
+ *              **->enabled** and *buf*\ **->running**, respectively) are
+ *              copied. In general, **bpf_perf_event_read_value**\ () is
+ *              recommended over **bpf_perf_event_read**\ (), which has some
+ *              ABI issues and provides fewer functionalities.
+ *
+ *              These values are interesting, because hardware PMU (Performance
+ *              Monitoring Unit) counters are limited resources. When there are
+ *              more PMU based perf events opened than available counters,
+ *              kernel will multiplex these events so each event gets certain
+ *              percentage (but not all) of the PMU time. In case that
+ *              multiplexing happens, the number of samples or counter value
+ *              will not reflect the case compared to when no multiplexing
+ *              occurs. This makes comparison between different runs difficult.
+ *              Typically, the counter value should be normalized before
+ *              comparing to other experiments. The usual normalization is done
+ *              as follows.
+ *
+ *              ::
+ *
+ *                      normalized_counter = counter * t_enabled / t_running
+ *
+ *              Where t_enabled is the time enabled for event and t_running is
+ *              the time running for event since last normalization. The
+ *              enabled and running times are accumulated since the perf event
+ *              open. To achieve scaling factor between two invocations of an
+ *              eBPF program, users can can use CPU id as the key (which is
+ *              typical for perf array usage model) to remember the previous
+ *              value and do the calculation inside the eBPF program.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_perf_prog_read_value(struct bpf_perf_event_data *ctx, struct bpf_perf_event_value *buf, u32 buf_size)
+ *      Description
+ *              For en eBPF program attached to a perf event, retrieve the
+ *              value of the event counter associated to *ctx* and store it in
+ *              the structure pointed by *buf* and of size *buf_size*. Enabled
+ *              and running times are also stored in the structure (see
+ *              description of helper **bpf_perf_event_read_value**\ () for
+ *              more details).
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_getsockopt(struct bpf_sock_ops *bpf_socket, int level, int optname, char *optval, int optlen)
+ *      Description
+ *              Emulate a call to **getsockopt()** on the socket associated to
+ *              *bpf_socket*, which must be a full socket. The *level* at
+ *              which the option resides and the name *optname* of the option
+ *              must be specified, see **getsockopt(2)** for more information.
+ *              The retrieved value is stored in the structure pointed by
+ *              *opval* and of length *optlen*.
+ *
+ *              This helper actually implements a subset of **getsockopt()**.
+ *              It supports the following *level*\ s:
+ *
+ *              * **IPPROTO_TCP**, which supports *optname*
+ *                **TCP_CONGESTION**.
+ *              * **IPPROTO_IP**, which supports *optname* **IP_TOS**.
+ *              * **IPPROTO_IPV6**, which supports *optname* **IPV6_TCLASS**.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_override_return(struct pt_reg *regs, u64 rc)
+ *      Description
+ *              Used for error injection, this helper uses kprobes to override
+ *              the return value of the probed function, and to set it to *rc*.
+ *              The first argument is the context *regs* on which the kprobe
+ *              works.
+ *
+ *              This helper works by setting setting the PC (program counter)
+ *              to an override function which is run in place of the original
+ *              probed function. This means the probed function is not run at
+ *              all. The replacement function just returns with the required
+ *              value.
+ *
+ *              This helper has security implications, and thus is subject to
+ *              restrictions. It is only available if the kernel was compiled
+ *              with the **CONFIG_BPF_KPROBE_OVERRIDE** configuration
+ *              option, and in this case it only works on functions tagged with
+ *              **ALLOW_ERROR_INJECTION** in the kernel code.
+ *
+ *              Also, the helper is only available for the architectures having
+ *              the CONFIG_FUNCTION_ERROR_INJECTION option. As of this writing,
+ *              x86 architecture is the only one to support this feature.
+ *      Return
+ *              0
+ *
+ * int bpf_sock_ops_cb_flags_set(struct bpf_sock_ops *bpf_sock, int argval)
+ *      Description
+ *              Attempt to set the value of the **bpf_sock_ops_cb_flags** field
+ *              for the full TCP socket associated to *bpf_sock_ops* to
+ *              *argval*.
+ *
+ *              The primary use of this field is to determine if there should
+ *              be calls to eBPF programs of type
+ *              **BPF_PROG_TYPE_SOCK_OPS** at various points in the TCP
+ *              code. A program of the same type can change its value, per
+ *              connection and as necessary, when the connection is
+ *              established. This field is directly accessible for reading, but
+ *              this helper must be used for updates in order to return an
+ *              error if an eBPF program tries to set a callback that is not
+ *              supported in the current kernel.
+ *
+ *              The supported callback values that *argval* can combine are:
+ *
+ *              * **BPF_SOCK_OPS_RTO_CB_FLAG** (retransmission time out)
+ *              * **BPF_SOCK_OPS_RETRANS_CB_FLAG** (retransmission)
+ *              * **BPF_SOCK_OPS_STATE_CB_FLAG** (TCP state change)
+ *
+ *              Here are some examples of where one could call such eBPF
+ *              program:
+ *
+ *              * When RTO fires.
+ *              * When a packet is retransmitted.
+ *              * When the connection terminates.
+ *              * When a packet is sent.
+ *              * When a packet is received.
+ *      Return
+ *              Code **-EINVAL** if the socket is not a full TCP socket;
+ *              otherwise, a positive number containing the bits that could not
+ *              be set is returned (which comes down to 0 if all bits were set
+ *              as required).
+ *
+ * int bpf_msg_redirect_map(struct sk_msg_buff *msg, struct bpf_map *map, u32 key, u64 flags)
+ *      Description
+ *              This helper is used in programs implementing policies at the
+ *              socket level. If the message *msg* is allowed to pass (i.e. if
+ *              the verdict eBPF program returns **SK_PASS**), redirect it to
+ *              the socket referenced by *map* (of type
+ *              **BPF_MAP_TYPE_SOCKMAP**) at index *key*. Both ingress and
+ *              egress interfaces can be used for redirection. The
+ *              **BPF_F_INGRESS** value in *flags* is used to make the
+ *              distinction (ingress path is selected if the flag is present,
+ *              egress path otherwise). This is the only flag supported for now.
+ *      Return
+ *              **SK_PASS** on success, or **SK_DROP** on error.
+ *
+ * int bpf_msg_apply_bytes(struct sk_msg_buff *msg, u32 bytes)
+ *      Description
+ *              For socket policies, apply the verdict of the eBPF program to
+ *              the next *bytes* (number of bytes) of message *msg*.
+ *
+ *              For example, this helper can be used in the following cases:
+ *
+ *              * A single **sendmsg**\ () or **sendfile**\ () system call
+ *                contains multiple logical messages that the eBPF program is
+ *                supposed to read and for which it should apply a verdict.
+ *              * An eBPF program only cares to read the first *bytes* of a
+ *                *msg*. If the message has a large payload, then setting up
+ *                and calling the eBPF program repeatedly for all bytes, even
+ *                though the verdict is already known, would create unnecessary
+ *                overhead.
+ *
+ *              When called from within an eBPF program, the helper sets a
+ *              counter internal to the BPF infrastructure, that is used to
+ *              apply the last verdict to the next *bytes*. If *bytes* is
+ *              smaller than the current data being processed from a
+ *              **sendmsg**\ () or **sendfile**\ () system call, the first
+ *              *bytes* will be sent and the eBPF program will be re-run with
+ *              the pointer for start of data pointing to byte number *bytes*
+ *              **+ 1**. If *bytes* is larger than the current data being
+ *              processed, then the eBPF verdict will be applied to multiple
+ *              **sendmsg**\ () or **sendfile**\ () calls until *bytes* are
+ *              consumed.
+ *
+ *              Note that if a socket closes with the internal counter holding
+ *              a non-zero value, this is not a problem because data is not
+ *              being buffered for *bytes* and is sent as it is received.
+ *      Return
+ *              0
+ *
+ * int bpf_msg_cork_bytes(struct sk_msg_buff *msg, u32 bytes)
+ *      Description
+ *              For socket policies, prevent the execution of the verdict eBPF
+ *              program for message *msg* until *bytes* (byte number) have been
+ *              accumulated.
+ *
+ *              This can be used when one needs a specific number of bytes
+ *              before a verdict can be assigned, even if the data spans
+ *              multiple **sendmsg**\ () or **sendfile**\ () calls. The extreme
+ *              case would be a user calling **sendmsg**\ () repeatedly with
+ *              1-byte long message segments. Obviously, this is bad for
+ *              performance, but it is still valid. If the eBPF program needs
+ *              *bytes* bytes to validate a header, this helper can be used to
+ *              prevent the eBPF program to be called again until *bytes* have
+ *              been accumulated.
+ *      Return
+ *              0
+ *
+ * int bpf_msg_pull_data(struct sk_msg_buff *msg, u32 start, u32 end, u64 flags)
+ *      Description
+ *              For socket policies, pull in non-linear data from user space
+ *              for *msg* and set pointers *msg*\ **->data** and *msg*\
+ *              **->data_end** to *start* and *end* bytes offsets into *msg*,
+ *              respectively.
+ *
+ *              If a program of type **BPF_PROG_TYPE_SK_MSG** is run on a
+ *              *msg* it can only parse data that the (**data**, **data_end**)
+ *              pointers have already consumed. For **sendmsg**\ () hooks this
+ *              is likely the first scatterlist element. But for calls relying
+ *              on the **sendpage** handler (e.g. **sendfile**\ ()) this will
+ *              be the range (**0**, **0**) because the data is shared with
+ *              user space and by default the objective is to avoid allowing
+ *              user space to modify data while (or after) eBPF verdict is
+ *              being decided. This helper can be used to pull in data and to
+ *              set the start and end pointer to given values. Data will be
+ *              copied if necessary (i.e. if data was not linear and if start
+ *              and end pointers do not point to the same chunk).
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *
+ *              All values for *flags* are reserved for future usage, and must
+ *              be left at zero.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_bind(struct bpf_sock_addr *ctx, struct sockaddr *addr, int addr_len)
+ *      Description
+ *              Bind the socket associated to *ctx* to the address pointed by
+ *              *addr*, of length *addr_len*. This allows for making outgoing
+ *              connection from the desired IP address, which can be useful for
+ *              example when all processes inside a cgroup should use one
+ *              single IP address on a host that has multiple IP configured.
+ *
+ *              This helper works for IPv4 and IPv6, TCP and UDP sockets. The
+ *              domain (*addr*\ **->sa_family**) must be **AF_INET** (or
+ *              **AF_INET6**). Looking for a free port to bind to can be
+ *              expensive, therefore binding to port is not permitted by the
+ *              helper: *addr*\ **->sin_port** (or **sin6_port**, respectively)
+ *              must be set to zero.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_xdp_adjust_tail(struct xdp_buff *xdp_md, int delta)
+ *      Description
+ *              Adjust (move) *xdp_md*\ **->data_end** by *delta* bytes. It is
+ *              only possible to shrink the packet as of this writing,
+ *              therefore *delta* must be a negative integer.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_skb_get_xfrm_state(struct sk_buff *skb, u32 index, struct bpf_xfrm_state *xfrm_state, u32 size, u64 flags)
+ *      Description
+ *              Retrieve the XFRM state (IP transform framework, see also
+ *              **ip-xfrm(8)**) at *index* in XFRM "security path" for *skb*.
+ *
+ *              The retrieved value is stored in the **struct bpf_xfrm_state**
+ *              pointed by *xfrm_state* and of length *size*.
+ *
+ *              All values for *flags* are reserved for future usage, and must
+ *              be left at zero.
+ *
+ *              This helper is available only if the kernel was compiled with
+ *              **CONFIG_XFRM** configuration option.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_get_stack(struct pt_regs *regs, void *buf, u32 size, u64 flags)
+ *      Description
+ *              Return a user or a kernel stack in bpf program provided buffer.
+ *              To achieve this, the helper needs *ctx*, which is a pointer
+ *              to the context on which the tracing program is executed.
+ *              To store the stacktrace, the bpf program provides *buf* with
+ *              a nonnegative *size*.
+ *
+ *              The last argument, *flags*, holds the number of stack frames to
+ *              skip (from 0 to 255), masked with
+ *              **BPF_F_SKIP_FIELD_MASK**. The next bits can be used to set
+ *              the following flags:
+ *
+ *              **BPF_F_USER_STACK**
+ *                      Collect a user space stack instead of a kernel stack.
+ *              **BPF_F_USER_BUILD_ID**
+ *                      Collect buildid+offset instead of ips for user stack,
+ *                      only valid if **BPF_F_USER_STACK** is also specified.
+ *
+ *              **bpf_get_stack**\ () can collect up to
+ *              **PERF_MAX_STACK_DEPTH** both kernel and user frames, subject
+ *              to sufficient large buffer size. Note that
+ *              this limit can be controlled with the **sysctl** program, and
+ *              that it should be manually increased in order to profile long
+ *              user stacks (such as stacks for Java programs). To do so, use:
+ *
+ *              ::
+ *
+ *                      # sysctl kernel.perf_event_max_stack=<new value>
+ *      Return
+ *              A non-negative value equal to or less than *size* on success,
+ *              or a negative error in case of failure.
+ *
+ * int skb_load_bytes_relative(const struct sk_buff *skb, u32 offset, void *to, u32 len, u32 start_header)
+ *      Description
+ *              This helper is similar to **bpf_skb_load_bytes**\ () in that
+ *              it provides an easy way to load *len* bytes from *offset*
+ *              from the packet associated to *skb*, into the buffer pointed
+ *              by *to*. The difference to **bpf_skb_load_bytes**\ () is that
+ *              a fifth argument *start_header* exists in order to select a
+ *              base offset to start from. *start_header* can be one of:
+ *
+ *              **BPF_HDR_START_MAC**
+ *                      Base offset to load data from is *skb*'s mac header.
+ *              **BPF_HDR_START_NET**
+ *                      Base offset to load data from is *skb*'s network header.
+ *
+ *              In general, "direct packet access" is the preferred method to
+ *              access packet data, however, this helper is in particular useful
+ *              in socket filters where *skb*\ **->data** does not always point
+ *              to the start of the mac header and where "direct packet access"
+ *              is not available.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_fib_lookup(void *ctx, struct bpf_fib_lookup *params, int plen, u32 flags)
+ *      Description
+ *              Do FIB lookup in kernel tables using parameters in *params*.
+ *              If lookup is successful and result shows packet is to be
+ *              forwarded, the neighbor tables are searched for the nexthop.
+ *              If successful (ie., FIB lookup shows forwarding and nexthop
+ *              is resolved), the nexthop address is returned in ipv4_dst
+ *              or ipv6_dst based on family, smac is set to mac address of
+ *              egress device, dmac is set to nexthop mac address, rt_metric
+ *              is set to metric from route (IPv4/IPv6 only).
+ *
+ *             *plen* argument is the size of the passed in struct.
+ *             *flags* argument can be a combination of one or more of the
+ *             following values:
+ *
+ *              **BPF_FIB_LOOKUP_DIRECT**
+ *                      Do a direct table lookup vs full lookup using FIB
+ *                      rules.
+ *              **BPF_FIB_LOOKUP_OUTPUT**
+ *                      Perform lookup from an egress perspective (default is
+ *                      ingress).
+ *
+ *             *ctx* is either **struct xdp_md** for XDP programs or
+ *             **struct sk_buff** tc cls_act programs.
+ *     Return
+ *             Egress device index on success, 0 if packet needs to continue
+ *             up the stack for further processing or a negative error in case
+ *             of failure.
+ *
+ * int bpf_sock_hash_update(struct bpf_sock_ops_kern *skops, struct bpf_map *map, void *key, u64 flags)
+ *      Description
+ *              Add an entry to, or update a sockhash *map* referencing sockets.
+ *              The *skops* is used as a new value for the entry associated to
+ *              *key*. *flags* is one of:
+ *
+ *              **BPF_NOEXIST**
+ *                      The entry for *key* must not exist in the map.
+ *              **BPF_EXIST**
+ *                      The entry for *key* must already exist in the map.
+ *              **BPF_ANY**
+ *                      No condition on the existence of the entry for *key*.
+ *
+ *              If the *map* has eBPF programs (parser and verdict), those will
+ *              be inherited by the socket being added. If the socket is
+ *              already attached to eBPF programs, this results in an error.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_msg_redirect_hash(struct sk_msg_buff *msg, struct bpf_map *map, void *key, u64 flags)
+ *      Description
+ *              This helper is used in programs implementing policies at the
+ *              socket level. If the message *msg* is allowed to pass (i.e. if
+ *              the verdict eBPF program returns **SK_PASS**), redirect it to
+ *              the socket referenced by *map* (of type
+ *              **BPF_MAP_TYPE_SOCKHASH**) using hash *key*. Both ingress and
+ *              egress interfaces can be used for redirection. The
+ *              **BPF_F_INGRESS** value in *flags* is used to make the
+ *              distinction (ingress path is selected if the flag is present,
+ *              egress path otherwise). This is the only flag supported for now.
+ *      Return
+ *              **SK_PASS** on success, or **SK_DROP** on error.
+ *
+ * int bpf_sk_redirect_hash(struct sk_buff *skb, struct bpf_map *map, void *key, u64 flags)
+ *      Description
+ *              This helper is used in programs implementing policies at the
+ *              skb socket level. If the sk_buff *skb* is allowed to pass (i.e.
+ *              if the verdeict eBPF program returns **SK_PASS**), redirect it
+ *              to the socket referenced by *map* (of type
+ *              **BPF_MAP_TYPE_SOCKHASH**) using hash *key*. Both ingress and
+ *              egress interfaces can be used for redirection. The
+ *              **BPF_F_INGRESS** value in *flags* is used to make the
+ *              distinction (ingress path is selected if the flag is present,
+ *              egress otherwise). This is the only flag supported for now.
+ *      Return
+ *              **SK_PASS** on success, or **SK_DROP** on error.
+ *
+ * int bpf_lwt_push_encap(struct sk_buff *skb, u32 type, void *hdr, u32 len)
+ *      Description
+ *              Encapsulate the packet associated to *skb* within a Layer 3
+ *              protocol header. This header is provided in the buffer at
+ *              address *hdr*, with *len* its size in bytes. *type* indicates
+ *              the protocol of the header and can be one of:
+ *
+ *              **BPF_LWT_ENCAP_SEG6**
+ *                      IPv6 encapsulation with Segment Routing Header
+ *                      (**struct ipv6_sr_hdr**). *hdr* only contains the SRH,
+ *                      the IPv6 header is computed by the kernel.
+ *              **BPF_LWT_ENCAP_SEG6_INLINE**
+ *                      Only works if *skb* contains an IPv6 packet. Insert a
+ *                      Segment Routing Header (**struct ipv6_sr_hdr**) inside
+ *                      the IPv6 header.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_lwt_seg6_store_bytes(struct sk_buff *skb, u32 offset, const void *from, u32 len)
+ *      Description
+ *              Store *len* bytes from address *from* into the packet
+ *              associated to *skb*, at *offset*. Only the flags, tag and TLVs
+ *              inside the outermost IPv6 Segment Routing Header can be
+ *              modified through this helper.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_lwt_seg6_adjust_srh(struct sk_buff *skb, u32 offset, s32 delta)
+ *      Description
+ *              Adjust the size allocated to TLVs in the outermost IPv6
+ *              Segment Routing Header contained in the packet associated to
+ *              *skb*, at position *offset* by *delta* bytes. Only offsets
+ *              after the segments are accepted. *delta* can be as well
+ *              positive (growing) as negative (shrinking).
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_lwt_seg6_action(struct sk_buff *skb, u32 action, void *param, u32 param_len)
+ *      Description
+ *              Apply an IPv6 Segment Routing action of type *action* to the
+ *              packet associated to *skb*. Each action takes a parameter
+ *              contained at address *param*, and of length *param_len* bytes.
+ *              *action* can be one of:
+ *
+ *              **SEG6_LOCAL_ACTION_END_X**
+ *                      End.X action: Endpoint with Layer-3 cross-connect.
+ *                      Type of *param*: **struct in6_addr**.
+ *              **SEG6_LOCAL_ACTION_END_T**
+ *                      End.T action: Endpoint with specific IPv6 table lookup.
+ *                      Type of *param*: **int**.
+ *              **SEG6_LOCAL_ACTION_END_B6**
+ *                      End.B6 action: Endpoint bound to an SRv6 policy.
+ *                      Type of param: **struct ipv6_sr_hdr**.
+ *              **SEG6_LOCAL_ACTION_END_B6_ENCAP**
+ *                      End.B6.Encap action: Endpoint bound to an SRv6
+ *                      encapsulation policy.
+ *                      Type of param: **struct ipv6_sr_hdr**.
+ *
+ *              A call to this helper is susceptible to change the underlaying
+ *              packet buffer. Therefore, at load time, all checks on pointers
+ *              previously done by the verifier are invalidated and must be
+ *              performed again, if the helper is used in combination with
+ *              direct packet access.
+ *      Return
+ *              0 on success, or a negative error in case of failure.
+ *
+ * int bpf_rc_keydown(void *ctx, u32 protocol, u64 scancode, u32 toggle)
+ *      Description
+ *              This helper is used in programs implementing IR decoding, to
+ *              report a successfully decoded key press with *scancode*,
+ *              *toggle* value in the given *protocol*. The scancode will be
+ *              translated to a keycode using the rc keymap, and reported as
+ *              an input key down event. After a period a key up event is
+ *              generated. This period can be extended by calling either
+ *              **bpf_rc_keydown** () again with the same values, or calling
+ *              **bpf_rc_repeat** ().
+ *
+ *              Some protocols include a toggle bit, in case the button was
+ *              released and pressed again between consecutive scancodes.
+ *
+ *              The *ctx* should point to the lirc sample as passed into
+ *              the program.
+ *
+ *              The *protocol* is the decoded protocol number (see
+ *              **enum rc_proto** for some predefined values).
+ *
+ *              This helper is only available is the kernel was compiled with
+ *              the **CONFIG_BPF_LIRC_MODE2** configuration option set to
+ *              "**y**".
+ *
+ *      Return
+ *              0
+ *
+ * int bpf_rc_repeat(void *ctx)
+ *      Description
+ *              This helper is used in programs implementing IR decoding, to
+ *              report a successfully decoded repeat key message. This delays
+ *              the generation of a key up event for previously generated
+ *              key down event.
+ *
+ *              Some IR protocols like NEC have a special IR message for
+ *              repeating last button, for when a button is held down.
+ *
+ *              The *ctx* should point to the lirc sample as passed into
+ *              the program.
+ *
+ *              This helper is only available is the kernel was compiled with
+ *              the **CONFIG_BPF_LIRC_MODE2** configuration option set to
+ *              "**y**".
+ *
+ *      Return
+ *              0
+ *
+ * uint64_t bpf_skb_cgroup_id(struct sk_buff *skb)
+ *      Description
+ *              Return the cgroup v2 id of the socket associated with the *skb*.
+ *              This is roughly similar to the **bpf_get_cgroup_classid**\ ()
+ *              helper for cgroup v1 by providing a tag resp. identifier that
+ *              can be matched on or used for map lookups e.g. to implement
+ *              policy. The cgroup v2 id of a given path in the hierarchy is
+ *              exposed in user space through the f_handle API in order to get
+ *              to the same 64-bit id.
+ *
+ *              This helper can be used on TC egress path, but not on ingress,
+ *              and is available only if the kernel was compiled with the
+ *              **CONFIG_SOCK_CGROUP_DATA** configuration option.
+ *      Return
+ *              The id is returned or 0 in case the id could not be retrieved.
+ *
+ * u64 bpf_get_current_cgroup_id(void)
+ *      Return
+ *              A 64-bit integer containing the current cgroup id based
+ *              on the cgroup within which the current task is running.
  */
 #define __BPF_FUNC_MAPPER(FN)           \
         FN(unspec),                     \
@@ -821,7 +2141,23 @@ union bpf_attr {
         FN(msg_apply_bytes),            \
         FN(msg_cork_bytes),             \
         FN(msg_pull_data),              \
-        FN(bind),
+        FN(bind),                       \
+        FN(xdp_adjust_tail),            \
+        FN(skb_get_xfrm_state),         \
+        FN(get_stack),                  \
+        FN(skb_load_bytes_relative),    \
+        FN(fib_lookup),                 \
+        FN(sock_hash_update),           \
+        FN(msg_redirect_hash),          \
+        FN(sk_redirect_hash),           \
+        FN(lwt_push_encap),             \
+        FN(lwt_seg6_store_bytes),       \
+        FN(lwt_seg6_adjust_srh),        \
+        FN(lwt_seg6_action),            \
+        FN(rc_repeat),                  \
+        FN(rc_keydown),                 \
+        FN(skb_cgroup_id),              \
+        FN(get_current_cgroup_id),
 
 /* integer value in 'imm' field of BPF_CALL instruction selects which helper
  * function eBPF program intends to call
@@ -855,11 +2191,14 @@ enum bpf_func_id {
 /* BPF_FUNC_skb_set_tunnel_key and BPF_FUNC_skb_get_tunnel_key flags. */
 #define BPF_F_TUNINFO_IPV6              (1ULL << 0)
 
-/* BPF_FUNC_get_stackid flags. */
+/* flags for both BPF_FUNC_get_stackid and BPF_FUNC_get_stack. */
 #define BPF_F_SKIP_FIELD_MASK           0xffULL
 #define BPF_F_USER_STACK                (1ULL << 8)
+/* flags used by BPF_FUNC_get_stackid only. */
 #define BPF_F_FAST_STACK_CMP            (1ULL << 9)
 #define BPF_F_REUSE_STACKID             (1ULL << 10)
+/* flags used by BPF_FUNC_get_stack only. */
+#define BPF_F_USER_BUILD_ID             (1ULL << 11)
 
 /* BPF_FUNC_skb_set_tunnel_key flags. */
 #define BPF_F_ZERO_CSUM_TX              (1ULL << 1)
@@ -879,6 +2218,18 @@ enum bpf_adj_room_mode {
         BPF_ADJ_ROOM_NET,
 };
 
+/* Mode for BPF_FUNC_skb_load_bytes_relative helper. */
+enum bpf_hdr_start_off {
+        BPF_HDR_START_MAC,
+        BPF_HDR_START_NET,
+};
+
+/* Encapsulation type for BPF_FUNC_lwt_push_encap helper. */
+enum bpf_lwt_encap_mode {
+        BPF_LWT_ENCAP_SEG6,
+        BPF_LWT_ENCAP_SEG6_INLINE
+};
+
 /* user accessible mirror of in-kernel sk_buff.
  * new fields can only be added to the end of this structure
  */
@@ -923,10 +2274,24 @@ struct bpf_tunnel_key {
         };
         __u8 tunnel_tos;
         __u8 tunnel_ttl;
-        __u16 tunnel_ext;
+        __u16 tunnel_ext;       /* Padding, future use. */
         __u32 tunnel_label;
 };
 
+/* user accessible mirror of in-kernel xfrm_state.
+ * new fields can only be added to the end of this structure
+ */
+struct bpf_xfrm_state {
+        __u32 reqid;
+        __u32 spi;      /* Stored in network byte order */
+        __u16 family;
+        __u16 ext;      /* Padding, future use. */
+        union {
+                __u32 remote_ipv4;      /* Stored in network byte order */
+                __u32 remote_ipv6[4];   /* Stored in network byte order */
+        };
+};
+
 /* Generic BPF return codes which all BPF program types may support.
  * The values are binary compatible with their TC_ACT_* counter-part to
  * provide backwards compatibility with existing SCHED_CLS and SCHED_ACT
@@ -999,6 +2364,14 @@ enum sk_action {
 struct sk_msg_md {
         void *data;
         void *data_end;
+
+        __u32 family;
+        __u32 remote_ip4;       /* Stored in network byte order */
+        __u32 local_ip4;        /* Stored in network byte order */
+        __u32 remote_ip6[4];    /* Stored in network byte order */
+        __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 */
 };
 
 #define BPF_TAG_SIZE    8
@@ -1017,9 +2390,13 @@ struct bpf_prog_info {
         __aligned_u64 map_ids;
         char name[BPF_OBJ_NAME_LEN];
         __u32 ifindex;
-        __u32 :32;
+        __u32 gpl_compatible:1;
         __u64 netns_dev;
         __u64 netns_ino;
+        __u32 nr_jited_ksyms;
+        __u32 nr_jited_func_lens;
+        __aligned_u64 jited_ksyms;
+        __aligned_u64 jited_func_lens;
 } __attribute__((aligned(8)));
 
 struct bpf_map_info {
@@ -1034,6 +2411,15 @@ struct bpf_map_info {
         __u32 :32;
         __u64 netns_dev;
         __u64 netns_ino;
+        __u32 btf_id;
+        __u32 btf_key_type_id;
+        __u32 btf_value_type_id;
+} __attribute__((aligned(8)));
+
+struct bpf_btf_info {
+        __aligned_u64 btf;
+        __u32 btf_size;
+        __u32 id;
 } __attribute__((aligned(8)));
 
 /* User bpf_sock_addr struct to access socket fields and sockaddr struct passed
@@ -1054,6 +2440,12 @@ struct bpf_sock_addr {
         __u32 family;           /* Allows 4-byte read, but no write */
         __u32 type;             /* Allows 4-byte read, but no write */
         __u32 protocol;         /* Allows 4-byte read, but no write */
+        __u32 msg_src_ip4;      /* Allows 1,2,4-byte read an 4-byte write.
+                                 * Stored in network byte order.
+                                 */
+        __u32 msg_src_ip6[4];   /* Allows 1,2,4-byte read an 4-byte write.
+                                 * Stored in network byte order.
+                                 */
 };
 
 /* User bpf_sock_ops struct to access socket values and specify request ops
@@ -1214,4 +2606,64 @@ struct bpf_raw_tracepoint_args {
         __u64 args[0];
 };
 
+/* DIRECT:  Skip the FIB rules and go to FIB table associated with device
+ * OUTPUT:  Do lookup from egress perspective; default is ingress
+ */
+#define BPF_FIB_LOOKUP_DIRECT  BIT(0)
+#define BPF_FIB_LOOKUP_OUTPUT  BIT(1)
+
+struct bpf_fib_lookup {
+        /* input:  network family for lookup (AF_INET, AF_INET6)
+         * output: network family of egress nexthop
+         */
+        __u8    family;
+
+        /* set if lookup is to consider L4 data - e.g., FIB rules */
+        __u8    l4_protocol;
+        __be16  sport;
+        __be16  dport;
+
+        /* total length of packet from network header - used for MTU check */
+        __u16   tot_len;
+        __u32   ifindex;  /* L3 device index for lookup */
+
+        union {
+                /* inputs to lookup */
+                __u8    tos;            /* AF_INET  */
+                __be32  flowinfo;       /* AF_INET6, flow_label + priority */
+
+                /* output: metric of fib result (IPv4/IPv6 only) */
+                __u32   rt_metric;
+        };
+
+        union {
+                __be32          ipv4_src;
+                __u32           ipv6_src[4];  /* in6_addr; network order */
+        };
+
+        /* input to bpf_fib_lookup, ipv{4,6}_dst is destination address in
+         * network header. output: bpf_fib_lookup sets to gateway address
+         * if FIB lookup returns gateway route
+         */
+        union {
+                __be32          ipv4_dst;
+                __u32           ipv6_dst[4];  /* in6_addr; network order */
+        };
+
+        /* output */
+        __be16  h_vlan_proto;
+        __be16  h_vlan_TCI;
+        __u8    smac[6];     /* ETH_ALEN */
+        __u8    dmac[6];     /* ETH_ALEN */
+};
+
+enum bpf_task_fd_type {
+        BPF_FD_TYPE_RAW_TRACEPOINT,     /* tp name */
+        BPF_FD_TYPE_TRACEPOINT,         /* tp name */
+        BPF_FD_TYPE_KPROBE,             /* (symbol + offset) or addr */
+        BPF_FD_TYPE_KRETPROBE,          /* (symbol + offset) or addr */
+        BPF_FD_TYPE_UPROBE,             /* filename + offset */
+        BPF_FD_TYPE_URETPROBE,          /* filename + offset */
+};
+
 #endif /* _UAPI__LINUX_BPF_H__ */
diff --git a/include/uapi/linux/bpfilter.h b/include/uapi/linux/bpfilter.h
new file mode 100644
index 000000000000..2ec3cc99ea4c
--- /dev/null
+++ b/include/uapi/linux/bpfilter.h
@@ -0,0 +1,21 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _UAPI_LINUX_BPFILTER_H
+#define _UAPI_LINUX_BPFILTER_H
+
+#include <linux/if.h>
+
+enum {
+        BPFILTER_IPT_SO_SET_REPLACE = 64,
+        BPFILTER_IPT_SO_SET_ADD_COUNTERS = 65,
+        BPFILTER_IPT_SET_MAX,
+};
+
+enum {
+        BPFILTER_IPT_SO_GET_INFO = 64,
+        BPFILTER_IPT_SO_GET_ENTRIES = 65,
+        BPFILTER_IPT_SO_GET_REVISION_MATCH = 66,
+        BPFILTER_IPT_SO_GET_REVISION_TARGET = 67,
+        BPFILTER_IPT_GET_MAX,
+};
+
+#endif /* _UAPI_LINUX_BPFILTER_H */
diff --git a/include/uapi/linux/btf.h b/include/uapi/linux/btf.h
new file mode 100644
index 000000000000..0b5ddbe135a4
--- /dev/null
+++ b/include/uapi/linux/btf.h
@@ -0,0 +1,113 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/* Copyright (c) 2018 Facebook */
+#ifndef _UAPI__LINUX_BTF_H__
+#define _UAPI__LINUX_BTF_H__
+
+#include <linux/types.h>
+
+#define BTF_MAGIC       0xeB9F
+#define BTF_VERSION     1
+
+struct btf_header {
+        __u16   magic;
+        __u8    version;
+        __u8    flags;
+        __u32   hdr_len;
+
+        /* All offsets are in bytes relative to the end of this header */
+        __u32   type_off;       /* offset of type section       */
+        __u32   type_len;       /* length of type section       */
+        __u32   str_off;        /* offset of string section     */
+        __u32   str_len;        /* length of string section     */
+};
+
+/* Max # of type identifier */
+#define BTF_MAX_TYPE    0x0000ffff
+/* Max offset into the string section */
+#define BTF_MAX_NAME_OFFSET     0x0000ffff
+/* Max # of struct/union/enum members or func args */
+#define BTF_MAX_VLEN    0xffff
+
+struct btf_type {
+        __u32 name_off;
+        /* "info" bits arrangement
+         * 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
+         */
+        __u32 info;
+        /* "size" is used by INT, ENUM, STRUCT and UNION.
+         * "size" tells the size of the type it is describing.
+         *
+         * "type" is used by PTR, TYPEDEF, VOLATILE, CONST and RESTRICT.
+         * "type" is a type_id referring to another type.
+         */
+        union {
+                __u32 size;
+                __u32 type;
+        };
+};
+
+#define BTF_INFO_KIND(info)     (((info) >> 24) & 0x0f)
+#define BTF_INFO_VLEN(info)     ((info) & 0xffff)
+
+#define BTF_KIND_UNKN           0       /* Unknown      */
+#define BTF_KIND_INT            1       /* Integer      */
+#define BTF_KIND_PTR            2       /* Pointer      */
+#define BTF_KIND_ARRAY          3       /* Array        */
+#define BTF_KIND_STRUCT         4       /* Struct       */
+#define BTF_KIND_UNION          5       /* Union        */
+#define BTF_KIND_ENUM           6       /* Enumeration  */
+#define BTF_KIND_FWD            7       /* Forward      */
+#define BTF_KIND_TYPEDEF        8       /* Typedef      */
+#define BTF_KIND_VOLATILE       9       /* Volatile     */
+#define BTF_KIND_CONST          10      /* Const        */
+#define BTF_KIND_RESTRICT       11      /* Restrict     */
+#define BTF_KIND_MAX            11
+#define NR_BTF_KINDS            12
+
+/* For some specific BTF_KIND, "struct btf_type" is immediately
+ * followed by extra data.
+ */
+
+/* BTF_KIND_INT is followed by a u32 and the following
+ * is the 32 bits arrangement:
+ */
+#define BTF_INT_ENCODING(VAL)   (((VAL) & 0x0f000000) >> 24)
+#define BTF_INT_OFFSET(VAL)     (((VAL  & 0x00ff0000)) >> 16)
+#define BTF_INT_BITS(VAL)       ((VAL)  & 0x0000ffff)
+
+/* Attributes stored in the BTF_INT_ENCODING */
+#define BTF_INT_SIGNED  (1 << 0)
+#define BTF_INT_CHAR    (1 << 1)
+#define BTF_INT_BOOL    (1 << 2)
+
+/* BTF_KIND_ENUM is followed by multiple "struct btf_enum".
+ * The exact number of btf_enum is stored in the vlen (of the
+ * info in "struct btf_type").
+ */
+struct btf_enum {
+        __u32   name_off;
+        __s32   val;
+};
+
+/* BTF_KIND_ARRAY is followed by one "struct btf_array" */
+struct btf_array {
+        __u32   type;
+        __u32   index_type;
+        __u32   nelems;
+};
+
+/* BTF_KIND_STRUCT and BTF_KIND_UNION are followed
+ * by multiple "struct btf_member".  The exact number
+ * of btf_member is stored in the vlen (of the info in
+ * "struct btf_type").
+ */
+struct btf_member {
+        __u32   name_off;
+        __u32   type;
+        __u32   offset; /* offset in bits */
+};
+
+#endif /* _UAPI__LINUX_BTF_H__ */
diff --git a/include/uapi/linux/cn_proc.h b/include/uapi/linux/cn_proc.h
index 68ff25414700..db210625cee8 100644
--- a/include/uapi/linux/cn_proc.h
+++ b/include/uapi/linux/cn_proc.h
@@ -116,12 +116,16 @@ struct proc_event {
                 struct coredump_proc_event {
                         __kernel_pid_t process_pid;
                         __kernel_pid_t process_tgid;
+                        __kernel_pid_t parent_pid;
+                        __kernel_pid_t parent_tgid;
                 } coredump;
 
                 struct exit_proc_event {
                         __kernel_pid_t process_pid;
                         __kernel_pid_t process_tgid;
                         __u32 exit_code, exit_signal;
+                        __kernel_pid_t parent_pid;
+                        __kernel_pid_t parent_tgid;
                 } exit;
 
         } event_data;
diff --git a/include/uapi/linux/dcbnl.h b/include/uapi/linux/dcbnl.h
index 2c0c6453c3f4..60aa2e446698 100644
--- a/include/uapi/linux/dcbnl.h
+++ b/include/uapi/linux/dcbnl.h
@@ -163,6 +163,16 @@ struct ieee_pfc {
         __u64   indications[IEEE_8021QAZ_MAX_TCS];
 };
 
+#define IEEE_8021Q_MAX_PRIORITIES 8
+#define DCBX_MAX_BUFFERS  8
+struct dcbnl_buffer {
+        /* priority to buffer mapping */
+        __u8    prio2buffer[IEEE_8021Q_MAX_PRIORITIES];
+        /* buffer size in Bytes */
+        __u32   buffer_size[DCBX_MAX_BUFFERS];
+        __u32   total_size;
+};
+
 /* CEE DCBX std supported values */
 #define CEE_DCBX_MAX_PGS        8
 #define CEE_DCBX_MAX_PRIO       8
@@ -406,6 +416,7 @@ enum ieee_attrs {
         DCB_ATTR_IEEE_MAXRATE,
         DCB_ATTR_IEEE_QCN,
         DCB_ATTR_IEEE_QCN_STATS,
+        DCB_ATTR_DCB_BUFFER,
         __DCB_ATTR_IEEE_MAX
 };
 #define DCB_ATTR_IEEE_MAX (__DCB_ATTR_IEEE_MAX - 1)
diff --git a/include/uapi/linux/devlink.h b/include/uapi/linux/devlink.h
index 1df65a4c2044..75cb5450c851 100644
--- a/include/uapi/linux/devlink.h
+++ b/include/uapi/linux/devlink.h
@@ -132,6 +132,16 @@ enum devlink_eswitch_encap_mode {
         DEVLINK_ESWITCH_ENCAP_MODE_BASIC,
 };
 
+enum devlink_port_flavour {
+        DEVLINK_PORT_FLAVOUR_PHYSICAL, /* Any kind of a port physically
+                                        * facing the user.
+                                        */
+        DEVLINK_PORT_FLAVOUR_CPU, /* CPU port */
+        DEVLINK_PORT_FLAVOUR_DSA, /* Distributed switch architecture
+                                   * interconnect port.
+                                   */
+};
+
 enum devlink_attr {
         /* don't change the order or add anything between, this is ABI! */
         DEVLINK_ATTR_UNSPEC,
@@ -224,6 +234,10 @@ enum devlink_attr {
         DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID,   /* u64 */
         DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS,/* u64 */
 
+        DEVLINK_ATTR_PORT_FLAVOUR,              /* u16 */
+        DEVLINK_ATTR_PORT_NUMBER,               /* u32 */
+        DEVLINK_ATTR_PORT_SPLIT_SUBPORT_NUMBER, /* u32 */
+
         /* add new attributes above here, update the policy in devlink.c */
 
         __DEVLINK_ATTR_MAX,
diff --git a/include/uapi/linux/elf.h b/include/uapi/linux/elf.h
index e2535d6dcec7..4e12c423b9fe 100644
--- a/include/uapi/linux/elf.h
+++ b/include/uapi/linux/elf.h
@@ -421,6 +421,7 @@ typedef struct elf64_shdr {
 #define NT_ARM_SYSTEM_CALL      0x404   /* ARM system call number */
 #define NT_ARM_SVE      0x405           /* ARM Scalable Vector Extension registers */
 #define NT_ARC_V2       0x600           /* ARCv2 accumulator/extra registers */
+#define NT_VMCOREDD     0x700           /* Vmcore Device Dump Note */
 
 /* Note header in a PT_NOTE section */
 typedef struct elf32_note {
diff --git a/include/uapi/linux/fs.h b/include/uapi/linux/fs.h
index d2a8313fabd7..73e01918f996 100644
--- a/include/uapi/linux/fs.h
+++ b/include/uapi/linux/fs.h
@@ -242,6 +242,8 @@ struct fsxattr {
 #define FICLONERANGE    _IOW(0x94, 13, struct file_clone_range)
 #define FIDEDUPERANGE   _IOWR(0x94, 54, struct file_dedupe_range)
 
+#define FSLABEL_MAX 256 /* Max chars for the interface; each fs may differ */
+
 #define FS_IOC_GETFLAGS                 _IOR('f', 1, long)
 #define FS_IOC_SETFLAGS                 _IOW('f', 2, long)
 #define FS_IOC_GETVERSION               _IOR('v', 1, long)
@@ -251,8 +253,10 @@ struct fsxattr {
 #define FS_IOC32_SETFLAGS               _IOW('f', 2, int)
 #define FS_IOC32_GETVERSION             _IOR('v', 1, int)
 #define FS_IOC32_SETVERSION             _IOW('v', 2, int)
-#define FS_IOC_FSGETXATTR               _IOR ('X', 31, struct fsxattr)
-#define FS_IOC_FSSETXATTR               _IOW ('X', 32, struct fsxattr)
+#define FS_IOC_FSGETXATTR               _IOR('X', 31, struct fsxattr)
+#define FS_IOC_FSSETXATTR               _IOW('X', 32, struct fsxattr)
+#define FS_IOC_GETFSLABEL               _IOR(0x94, 49, char[FSLABEL_MAX])
+#define FS_IOC_SETFSLABEL               _IOW(0x94, 50, char[FSLABEL_MAX])
 
 /*
  * File system encryption support
@@ -275,6 +279,8 @@ struct fsxattr {
 #define FS_ENCRYPTION_MODE_AES_256_CTS          4
 #define FS_ENCRYPTION_MODE_AES_128_CBC          5
 #define FS_ENCRYPTION_MODE_AES_128_CTS          6
+#define FS_ENCRYPTION_MODE_SPECK128_256_XTS     7
+#define FS_ENCRYPTION_MODE_SPECK128_256_CTS     8
 
 struct fscrypt_policy {
         __u8 version;
diff --git a/include/uapi/linux/fuse.h b/include/uapi/linux/fuse.h
index 4b5001c57f46..92fa24c24c92 100644
--- a/include/uapi/linux/fuse.h
+++ b/include/uapi/linux/fuse.h
@@ -113,6 +113,9 @@
  *  7.26
  *  - add FUSE_HANDLE_KILLPRIV
  *  - add FUSE_POSIX_ACL
+ *
+ *  7.27
+ *  - add FUSE_ABORT_ERROR
  */
 
 #ifndef _LINUX_FUSE_H
@@ -148,7 +151,7 @@
 #define FUSE_KERNEL_VERSION 7
 
 /** Minor version number of this interface */
-#define FUSE_KERNEL_MINOR_VERSION 26
+#define FUSE_KERNEL_MINOR_VERSION 27
 
 /** The node ID of the root inode */
 #define FUSE_ROOT_ID 1
@@ -245,6 +248,7 @@ struct fuse_file_lock {
  * FUSE_PARALLEL_DIROPS: allow parallel lookups and readdir
  * FUSE_HANDLE_KILLPRIV: fs handles killing suid/sgid/cap on write/chown/trunc
  * FUSE_POSIX_ACL: filesystem supports posix acls
+ * FUSE_ABORT_ERROR: reading the device after abort returns ECONNABORTED
  */
 #define FUSE_ASYNC_READ         (1 << 0)
 #define FUSE_POSIX_LOCKS        (1 << 1)
@@ -267,6 +271,7 @@ struct fuse_file_lock {
 #define FUSE_PARALLEL_DIROPS    (1 << 18)
 #define FUSE_HANDLE_KILLPRIV    (1 << 19)
 #define FUSE_POSIX_ACL          (1 << 20)
+#define FUSE_ABORT_ERROR        (1 << 21)
 
 /**
  * CUSE INIT request/reply flags
diff --git a/include/uapi/linux/if_addr.h b/include/uapi/linux/if_addr.h
index 2ef053d265de..ebaf5701c9db 100644
--- a/include/uapi/linux/if_addr.h
+++ b/include/uapi/linux/if_addr.h
@@ -33,6 +33,7 @@ enum {
         IFA_CACHEINFO,
         IFA_MULTICAST,
         IFA_FLAGS,
+        IFA_RT_PRIORITY,  /* u32, priority/metric for prefix route */
         __IFA_MAX,
 };
 
diff --git a/include/uapi/linux/if_link.h b/include/uapi/linux/if_link.h
index 68699f654118..cf01b6824244 100644
--- a/include/uapi/linux/if_link.h
+++ b/include/uapi/linux/if_link.h
@@ -333,6 +333,7 @@ enum {
         IFLA_BRPORT_BCAST_FLOOD,
         IFLA_BRPORT_GROUP_FWD_MASK,
         IFLA_BRPORT_NEIGH_SUPPRESS,
+        IFLA_BRPORT_ISOLATED,
         __IFLA_BRPORT_MAX
 };
 #define IFLA_BRPORT_MAX (__IFLA_BRPORT_MAX - 1)
@@ -516,6 +517,7 @@ enum {
         IFLA_VXLAN_COLLECT_METADATA,
         IFLA_VXLAN_LABEL,
         IFLA_VXLAN_GPE,
+        IFLA_VXLAN_TTL_INHERIT,
         __IFLA_VXLAN_MAX
 };
 #define IFLA_VXLAN_MAX  (__IFLA_VXLAN_MAX - 1)
diff --git a/include/uapi/linux/if_xdp.h b/include/uapi/linux/if_xdp.h
new file mode 100644
index 000000000000..1fa0e977ea8d
--- /dev/null
+++ b/include/uapi/linux/if_xdp.h
@@ -0,0 +1,78 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/*
+ * if_xdp: XDP socket user-space interface
+ * Copyright(c) 2018 Intel Corporation.
+ *
+ * Author(s): Björn Töpel <bjorn.topel@intel.com>
+ *            Magnus Karlsson <magnus.karlsson@intel.com>
+ */
+
+#ifndef _LINUX_IF_XDP_H
+#define _LINUX_IF_XDP_H
+
+#include <linux/types.h>
+
+/* Options for the sxdp_flags field */
+#define XDP_SHARED_UMEM (1 << 0)
+#define XDP_COPY        (1 << 1) /* Force copy-mode */
+#define XDP_ZEROCOPY    (1 << 2) /* Force zero-copy mode */
+
+struct sockaddr_xdp {
+        __u16 sxdp_family;
+        __u16 sxdp_flags;
+        __u32 sxdp_ifindex;
+        __u32 sxdp_queue_id;
+        __u32 sxdp_shared_umem_fd;
+};
+
+struct xdp_ring_offset {
+        __u64 producer;
+        __u64 consumer;
+        __u64 desc;
+};
+
+struct xdp_mmap_offsets {
+        struct xdp_ring_offset rx;
+        struct xdp_ring_offset tx;
+        struct xdp_ring_offset fr; /* Fill */
+        struct xdp_ring_offset cr; /* Completion */
+};
+
+/* XDP socket options */
+#define XDP_MMAP_OFFSETS                1
+#define XDP_RX_RING                     2
+#define XDP_TX_RING                     3
+#define XDP_UMEM_REG                    4
+#define XDP_UMEM_FILL_RING              5
+#define XDP_UMEM_COMPLETION_RING        6
+#define XDP_STATISTICS                  7
+
+struct xdp_umem_reg {
+        __u64 addr; /* Start of packet data area */
+        __u64 len; /* Length of packet data area */
+        __u32 chunk_size;
+        __u32 headroom;
+};
+
+struct xdp_statistics {
+        __u64 rx_dropped; /* Dropped for reasons other than invalid desc */
+        __u64 rx_invalid_descs; /* Dropped due to invalid descriptor */
+        __u64 tx_invalid_descs; /* Dropped due to invalid descriptor */
+};
+
+/* Pgoff for mmaping the rings */
+#define XDP_PGOFF_RX_RING                         0
+#define XDP_PGOFF_TX_RING                0x80000000
+#define XDP_UMEM_PGOFF_FILL_RING        0x100000000
+#define XDP_UMEM_PGOFF_COMPLETION_RING  0x180000000
+
+/* Rx/Tx descriptor */
+struct xdp_desc {
+        __u64 addr;
+        __u32 len;
+        __u32 options;
+};
+
+/* UMEM descriptor is __u64 */
+
+#endif /* _LINUX_IF_XDP_H */
diff --git a/include/uapi/linux/kernel-page-flags.h b/include/uapi/linux/kernel-page-flags.h
index fa139841ec18..21b9113c69da 100644
--- a/include/uapi/linux/kernel-page-flags.h
+++ b/include/uapi/linux/kernel-page-flags.h
@@ -35,6 +35,6 @@
 #define KPF_BALLOON             23
 #define KPF_ZERO_PAGE           24
 #define KPF_IDLE                25
-
+#define KPF_PGTABLE             26
 
 #endif /* _UAPILINUX_KERNEL_PAGE_FLAGS_H */
diff --git a/include/uapi/linux/lirc.h b/include/uapi/linux/lirc.h
index f189931042a7..6b319581882f 100644
--- a/include/uapi/linux/lirc.h
+++ b/include/uapi/linux/lirc.h
@@ -134,6 +134,12 @@
 #define LIRC_SET_WIDEBAND_RECEIVER     _IOW('i', 0x00000023, __u32)
 
 /*
+ * Return the recording timeout, which is either set by
+ * the ioctl LIRC_SET_REC_TIMEOUT or by the kernel after setting the protocols.
+ */
+#define LIRC_GET_REC_TIMEOUT           _IOR('i', 0x00000024, __u32)
+
+/*
  * struct lirc_scancode - decoded scancode with protocol for use with
  *      LIRC_MODE_SCANCODE
  *
diff --git a/include/uapi/linux/ncp.h b/include/uapi/linux/ncp.h
deleted file mode 100644
index ca6f3d42c88f..000000000000
--- a/include/uapi/linux/ncp.h
+++ /dev/null
@@ -1,202 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
-/*
- *  ncp.h
- *
- *  Copyright (C) 1995 by Volker Lendecke
- *  Modified for sparc by J.F. Chadima
- *  Modified for __constant_ntoh by Frank A. Vorstenbosch
- *
- */
-
-#ifndef _LINUX_NCP_H
-#define _LINUX_NCP_H
-
-#include <linux/types.h>
-
-#define NCP_PTYPE                (0x11)
-#define NCP_PORT                 (0x0451)
-
-#define NCP_ALLOC_SLOT_REQUEST   (0x1111)
-#define NCP_REQUEST              (0x2222)
-#define NCP_DEALLOC_SLOT_REQUEST (0x5555)
-
-struct ncp_request_header {
-        __u16 type;
-        __u8 sequence;
-        __u8 conn_low;
-        __u8 task;
-        __u8 conn_high;
-        __u8 function;
-        __u8 data[0];
-} __attribute__((packed));
-
-#define NCP_REPLY                (0x3333)
-#define NCP_WATCHDOG             (0x3E3E)
-#define NCP_POSITIVE_ACK         (0x9999)
-
-struct ncp_reply_header {
-        __u16 type;
-        __u8 sequence;
-        __u8 conn_low;
-        __u8 task;
-        __u8 conn_high;
-        __u8 completion_code;
-        __u8 connection_state;
-        __u8 data[0];
-} __attribute__((packed));
-
-#define NCP_VOLNAME_LEN (16)
-#define NCP_NUMBER_OF_VOLUMES (256)
-struct ncp_volume_info {
-        __u32 total_blocks;
-        __u32 free_blocks;
-        __u32 purgeable_blocks;
-        __u32 not_yet_purgeable_blocks;
-        __u32 total_dir_entries;
-        __u32 available_dir_entries;
-        __u8 sectors_per_block;
-        char volume_name[NCP_VOLNAME_LEN + 1];
-};
-
-#define AR_READ      (cpu_to_le16(1))
-#define AR_WRITE     (cpu_to_le16(2))
-#define AR_EXCLUSIVE (cpu_to_le16(0x20))
-
-#define NCP_FILE_ID_LEN 6
-
-/* Defines for Name Spaces */
-#define NW_NS_DOS     0
-#define NW_NS_MAC     1
-#define NW_NS_NFS     2
-#define NW_NS_FTAM    3
-#define NW_NS_OS2     4
-
-/*  Defines for ReturnInformationMask */
-#define RIM_NAME              (cpu_to_le32(1))
-#define RIM_SPACE_ALLOCATED   (cpu_to_le32(2))
-#define RIM_ATTRIBUTES        (cpu_to_le32(4))
-#define RIM_DATA_SIZE         (cpu_to_le32(8))
-#define RIM_TOTAL_SIZE        (cpu_to_le32(0x10))
-#define RIM_EXT_ATTR_INFO     (cpu_to_le32(0x20))
-#define RIM_ARCHIVE           (cpu_to_le32(0x40))
-#define RIM_MODIFY            (cpu_to_le32(0x80))
-#define RIM_CREATION          (cpu_to_le32(0x100))
-#define RIM_OWNING_NAMESPACE  (cpu_to_le32(0x200))
-#define RIM_DIRECTORY         (cpu_to_le32(0x400))
-#define RIM_RIGHTS            (cpu_to_le32(0x800))
-#define RIM_ALL               (cpu_to_le32(0xFFF))
-#define RIM_COMPRESSED_INFO   (cpu_to_le32(0x80000000))
-
-/* Defines for NSInfoBitMask */
-#define NSIBM_NFS_NAME          0x0001
-#define NSIBM_NFS_MODE          0x0002
-#define NSIBM_NFS_GID           0x0004
-#define NSIBM_NFS_NLINKS        0x0008
-#define NSIBM_NFS_RDEV          0x0010
-#define NSIBM_NFS_LINK          0x0020
-#define NSIBM_NFS_CREATED       0x0040
-#define NSIBM_NFS_UID           0x0080
-#define NSIBM_NFS_ACSFLAG       0x0100
-#define NSIBM_NFS_MYFLAG        0x0200
-
-/* open/create modes */
-#define OC_MODE_OPEN      0x01
-#define OC_MODE_TRUNCATE  0x02
-#define OC_MODE_REPLACE   0x02
-#define OC_MODE_CREATE    0x08
-
-/* open/create results */
-#define OC_ACTION_NONE     0x00
-#define OC_ACTION_OPEN     0x01
-#define OC_ACTION_CREATE   0x02
-#define OC_ACTION_TRUNCATE 0x04
-#define OC_ACTION_REPLACE  0x04
-
-/* access rights attributes */
-#ifndef AR_READ_ONLY
-#define AR_READ_ONLY       0x0001
-#define AR_WRITE_ONLY      0x0002
-#define AR_DENY_READ       0x0004
-#define AR_DENY_WRITE      0x0008
-#define AR_COMPATIBILITY   0x0010
-#define AR_WRITE_THROUGH   0x0040
-#define AR_OPEN_COMPRESSED 0x0100
-#endif
-
-struct nw_nfs_info {
-        __u32 mode;
-        __u32 rdev;
-};
-
-struct nw_info_struct {
-        __u32 spaceAlloc;
-        __le32 attributes;
-        __u16 flags;
-        __le32 dataStreamSize;
-        __le32 totalStreamSize;
-        __u16 numberOfStreams;
-        __le16 creationTime;
-        __le16 creationDate;
-        __u32 creatorID;
-        __le16 modifyTime;
-        __le16 modifyDate;
-        __u32 modifierID;
-        __le16 lastAccessDate;
-        __u16 archiveTime;
-        __u16 archiveDate;
-        __u32 archiverID;
-        __u16 inheritedRightsMask;
-        __le32 dirEntNum;
-        __le32 DosDirNum;
-        __u32 volNumber;
-        __u32 EADataSize;
-        __u32 EAKeyCount;
-        __u32 EAKeySize;
-        __u32 NSCreator;
-        __u8 nameLen;
-        __u8 entryName[256];
-        /* libncp may depend on there being nothing after entryName */
-#ifdef __KERNEL__
-        struct nw_nfs_info nfs;
-#endif
-} __attribute__((packed));
-
-/* modify mask - use with MODIFY_DOS_INFO structure */
-#define DM_ATTRIBUTES             (cpu_to_le32(0x02))
-#define DM_CREATE_DATE            (cpu_to_le32(0x04))
-#define DM_CREATE_TIME            (cpu_to_le32(0x08))
-#define DM_CREATOR_ID             (cpu_to_le32(0x10))
-#define DM_ARCHIVE_DATE           (cpu_to_le32(0x20))
-#define DM_ARCHIVE_TIME           (cpu_to_le32(0x40))
-#define DM_ARCHIVER_ID            (cpu_to_le32(0x80))
-#define DM_MODIFY_DATE            (cpu_to_le32(0x0100))
-#define DM_MODIFY_TIME            (cpu_to_le32(0x0200))
-#define DM_MODIFIER_ID            (cpu_to_le32(0x0400))
-#define DM_LAST_ACCESS_DATE       (cpu_to_le32(0x0800))
-#define DM_INHERITED_RIGHTS_MASK  (cpu_to_le32(0x1000))
-#define DM_MAXIMUM_SPACE          (cpu_to_le32(0x2000))
-
-struct nw_modify_dos_info {
-        __le32 attributes;
-        __le16 creationDate;
-        __le16 creationTime;
-        __u32 creatorID;
-        __le16 modifyDate;
-        __le16 modifyTime;
-        __u32 modifierID;
-        __u16 archiveDate;
-        __u16 archiveTime;
-        __u32 archiverID;
-        __le16 lastAccessDate;
-        __u16 inheritanceGrantMask;
-        __u16 inheritanceRevokeMask;
-        __u32 maximumSpace;
-} __attribute__((packed));
-
-struct nw_search_sequence {
-        __u8 volNumber;
-        __u32 dirBase;
-        __u32 sequence;
-} __attribute__((packed));
-
-#endif                          /* _LINUX_NCP_H */
diff --git a/include/uapi/linux/ncp_fs.h b/include/uapi/linux/ncp_fs.h
deleted file mode 100644
index e76a44229d2f..000000000000
--- a/include/uapi/linux/ncp_fs.h
+++ /dev/null
@@ -1,147 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
-/*
- *  ncp_fs.h
- *
- *  Copyright (C) 1995, 1996 by Volker Lendecke
- *
- */
-
-#ifndef _LINUX_NCP_FS_H
-#define _LINUX_NCP_FS_H
-
-#include <linux/fs.h>
-#include <linux/in.h>
-#include <linux/types.h>
-#include <linux/magic.h>
-
-#include <linux/ipx.h>
-#include <linux/ncp_no.h>
-
-/*
- * ioctl commands
- */
-
-struct ncp_ioctl_request {
-        unsigned int function;
-        unsigned int size;
-        char __user *data;
-};
-
-struct ncp_fs_info {
-        int version;
-        struct sockaddr_ipx addr;
-        __kernel_uid_t mounted_uid;
-        int connection;         /* Connection number the server assigned us */
-        int buffer_size;        /* The negotiated buffer size, to be
-                                   used for read/write requests! */
-
-        int volume_number;
-        __le32 directory_id;
-};
-
-struct ncp_fs_info_v2 {
-        int version;
-        unsigned long mounted_uid;
-        unsigned int connection;
-        unsigned int buffer_size;
-
-        unsigned int volume_number;
-        __le32 directory_id;
-
-        __u32 dummy1;
-        __u32 dummy2;
-        __u32 dummy3;
-};
-
-struct ncp_sign_init
-{
-        char sign_root[8];
-        char sign_last[16];
-};
-
-struct ncp_lock_ioctl
-{
-#define NCP_LOCK_LOG    0
-#define NCP_LOCK_SH     1
-#define NCP_LOCK_EX     2
-#define NCP_LOCK_CLEAR  256
-        int             cmd;
-        int             origin;
-        unsigned int    offset;
-        unsigned int    length;
-#define NCP_LOCK_DEFAULT_TIMEOUT        18
-#define NCP_LOCK_MAX_TIMEOUT            180
-        int             timeout;
-};
-
-struct ncp_setroot_ioctl
-{
-        int             volNumber;
-        int             namespace;
-        __le32          dirEntNum;
-};
-
-struct ncp_objectname_ioctl
-{
-#define NCP_AUTH_NONE   0x00
-#define NCP_AUTH_BIND   0x31
-#define NCP_AUTH_NDS    0x32
-        int             auth_type;
-        size_t          object_name_len;
-        void __user *   object_name;    /* a userspace data, in most cases user name */
-};
-
-struct ncp_privatedata_ioctl
-{
-        size_t          len;
-        void __user *   data;           /* ~1000 for NDS */
-};
-
-/* NLS charsets by ioctl */
-#define NCP_IOCSNAME_LEN 20
-struct ncp_nls_ioctl
-{
-        unsigned char codepage[NCP_IOCSNAME_LEN+1];
-        unsigned char iocharset[NCP_IOCSNAME_LEN+1];
-};
-
-#define NCP_IOC_NCPREQUEST              _IOR('n', 1, struct ncp_ioctl_request)
-#define NCP_IOC_GETMOUNTUID             _IOW('n', 2, __kernel_old_uid_t)
-#define NCP_IOC_GETMOUNTUID2            _IOW('n', 2, unsigned long)
-
-#define NCP_IOC_CONN_LOGGED_IN          _IO('n', 3)
-
-#define NCP_GET_FS_INFO_VERSION    (1)
-#define NCP_IOC_GET_FS_INFO             _IOWR('n', 4, struct ncp_fs_info)
-#define NCP_GET_FS_INFO_VERSION_V2 (2)
-#define NCP_IOC_GET_FS_INFO_V2          _IOWR('n', 4, struct ncp_fs_info_v2)
-
-#define NCP_IOC_SIGN_INIT               _IOR('n', 5, struct ncp_sign_init)
-#define NCP_IOC_SIGN_WANTED             _IOR('n', 6, int)
-#define NCP_IOC_SET_SIGN_WANTED         _IOW('n', 6, int)
-
-#define NCP_IOC_LOCKUNLOCK              _IOR('n', 7, struct ncp_lock_ioctl)
-
-#define NCP_IOC_GETROOT                 _IOW('n', 8, struct ncp_setroot_ioctl)
-#define NCP_IOC_SETROOT                 _IOR('n', 8, struct ncp_setroot_ioctl)
-
-#define NCP_IOC_GETOBJECTNAME           _IOWR('n', 9, struct ncp_objectname_ioctl)
-#define NCP_IOC_SETOBJECTNAME           _IOR('n', 9, struct ncp_objectname_ioctl)
-#define NCP_IOC_GETPRIVATEDATA          _IOWR('n', 10, struct ncp_privatedata_ioctl)
-#define NCP_IOC_SETPRIVATEDATA          _IOR('n', 10, struct ncp_privatedata_ioctl)
-
-#define NCP_IOC_GETCHARSETS             _IOWR('n', 11, struct ncp_nls_ioctl)
-#define NCP_IOC_SETCHARSETS             _IOR('n', 11, struct ncp_nls_ioctl)
-
-#define NCP_IOC_GETDENTRYTTL            _IOW('n', 12, __u32)
-#define NCP_IOC_SETDENTRYTTL            _IOR('n', 12, __u32)
-
-/*
- * The packet size to allocate. One page should be enough.
- */
-#define NCP_PACKET_SIZE 4070
-
-#define NCP_MAXPATHLEN 255
-#define NCP_MAXNAMELEN 14
-
-#endif                          /* _LINUX_NCP_FS_H */
diff --git a/include/uapi/linux/ncp_mount.h b/include/uapi/linux/ncp_mount.h
deleted file mode 100644
index 9bdbcd68c329..000000000000
--- a/include/uapi/linux/ncp_mount.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
-/*
- *  ncp_mount.h
- *
- *  Copyright (C) 1995, 1996 by Volker Lendecke
- *
- */
-
-#ifndef _LINUX_NCP_MOUNT_H
-#define _LINUX_NCP_MOUNT_H
-
-#include <linux/types.h>
-#include <linux/ncp.h>
-
-#define NCP_MOUNT_VERSION 3     /* Binary */
-
-/* Values for flags */
-#define NCP_MOUNT_SOFT          0x0001
-#define NCP_MOUNT_INTR          0x0002
-#define NCP_MOUNT_STRONG        0x0004  /* enable delete/rename of r/o files */
-#define NCP_MOUNT_NO_OS2        0x0008  /* do not use OS/2 (LONG) namespace */
-#define NCP_MOUNT_NO_NFS        0x0010  /* do not use NFS namespace */
-#define NCP_MOUNT_EXTRAS        0x0020
-#define NCP_MOUNT_SYMLINKS      0x0040  /* enable symlinks */
-#define NCP_MOUNT_NFS_EXTRAS    0x0080  /* Enable use of NFS NS meta-info */
-
-struct ncp_mount_data {
-        int version;
-        unsigned int ncp_fd;    /* The socket to the ncp port */
-        __kernel_uid_t mounted_uid;     /* Who may umount() this filesystem? */
-        __kernel_pid_t wdog_pid;                /* Who cares for our watchdog packets? */
-
-        unsigned char mounted_vol[NCP_VOLNAME_LEN + 1];
-        unsigned int time_out;  /* How long should I wait after
-                                   sending a NCP request? */
-        unsigned int retry_count;       /* And how often should I retry? */
-        unsigned int flags;
-
-        __kernel_uid_t uid;
-        __kernel_gid_t gid;
-        __kernel_mode_t file_mode;
-        __kernel_mode_t dir_mode;
-};
-
-#define NCP_MOUNT_VERSION_V4    (4)     /* Binary or text */
-
-struct ncp_mount_data_v4 {
-        int version;
-        unsigned long flags;    /* NCP_MOUNT_* flags */
-        /* MIPS uses long __kernel_uid_t, but... */
-        /* we neever pass -1, so it is safe */
-        unsigned long mounted_uid;      /* Who may umount() this filesystem? */
-        /* MIPS uses long __kernel_pid_t */
-        long wdog_pid;          /* Who cares for our watchdog packets? */
-
-        unsigned int ncp_fd;    /* The socket to the ncp port */
-        unsigned int time_out;  /* How long should I wait after
-                                   sending a NCP request? */
-        unsigned int retry_count;       /* And how often should I retry? */
-
-        /* MIPS uses long __kernel_uid_t... */
-        /* we never pass -1, so it is safe */
-        unsigned long uid;
-        unsigned long gid;
-        /* MIPS uses unsigned long __kernel_mode_t */
-        unsigned long file_mode;
-        unsigned long dir_mode;
-};
-
-#define NCP_MOUNT_VERSION_V5    (5)     /* Text only */
-
-#endif
diff --git a/include/uapi/linux/ncp_no.h b/include/uapi/linux/ncp_no.h
deleted file mode 100644
index 654d7c7f5d92..000000000000
--- a/include/uapi/linux/ncp_no.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
-#ifndef _NCP_NO
-#define _NCP_NO
-
-/* these define the attribute byte as seen by NCP */
-#define aRONLY                  (__cpu_to_le32(1))
-#define aHIDDEN                 (__cpu_to_le32(2))
-#define aSYSTEM                 (__cpu_to_le32(4))
-#define aEXECUTE                (__cpu_to_le32(8))
-#define aDIR                    (__cpu_to_le32(0x10))
-#define aARCH                   (__cpu_to_le32(0x20))
-#define aSHARED                 (__cpu_to_le32(0x80))
-#define aDONTSUBALLOCATE        (__cpu_to_le32(1L<<11))
-#define aTRANSACTIONAL          (__cpu_to_le32(1L<<12))
-#define aPURGE                  (__cpu_to_le32(1L<<16))
-#define aRENAMEINHIBIT          (__cpu_to_le32(1L<<17))
-#define aDELETEINHIBIT          (__cpu_to_le32(1L<<18))
-#define aDONTCOMPRESS           (__cpu_to_le32(1L<<27))
-
-#endif /* _NCP_NO */
diff --git a/include/uapi/linux/netfilter/nf_nat.h b/include/uapi/linux/netfilter/nf_nat.h
index a33000da7229..4a95c0db14d4 100644
--- a/include/uapi/linux/netfilter/nf_nat.h
+++ b/include/uapi/linux/netfilter/nf_nat.h
@@ -10,6 +10,7 @@
 #define NF_NAT_RANGE_PROTO_RANDOM               (1 << 2)
 #define NF_NAT_RANGE_PERSISTENT                 (1 << 3)
 #define NF_NAT_RANGE_PROTO_RANDOM_FULLY         (1 << 4)
+#define NF_NAT_RANGE_PROTO_OFFSET               (1 << 5)
 
 #define NF_NAT_RANGE_PROTO_RANDOM_ALL           \
         (NF_NAT_RANGE_PROTO_RANDOM | NF_NAT_RANGE_PROTO_RANDOM_FULLY)
@@ -17,7 +18,7 @@
 #define NF_NAT_RANGE_MASK                                       \
         (NF_NAT_RANGE_MAP_IPS | NF_NAT_RANGE_PROTO_SPECIFIED |  \
          NF_NAT_RANGE_PROTO_RANDOM | NF_NAT_RANGE_PERSISTENT |  \
-         NF_NAT_RANGE_PROTO_RANDOM_FULLY)
+         NF_NAT_RANGE_PROTO_RANDOM_FULLY | NF_NAT_RANGE_PROTO_OFFSET)
 
 struct nf_nat_ipv4_range {
         unsigned int                    flags;
@@ -40,4 +41,13 @@ struct nf_nat_range {
         union nf_conntrack_man_proto    max_proto;
 };
 
+struct nf_nat_range2 {
+        unsigned int                    flags;
+        union nf_inet_addr              min_addr;
+        union nf_inet_addr              max_addr;
+        union nf_conntrack_man_proto    min_proto;
+        union nf_conntrack_man_proto    max_proto;
+        union nf_conntrack_man_proto    base_proto;
+};
+
 #endif /* _NETFILTER_NF_NAT_H */
diff --git a/include/uapi/linux/netfilter/nf_osf.h b/include/uapi/linux/netfilter/nf_osf.h
new file mode 100644
index 000000000000..8f2f2f403183
--- /dev/null
+++ b/include/uapi/linux/netfilter/nf_osf.h
@@ -0,0 +1,86 @@
+#ifndef _NF_OSF_H
+#define _NF_OSF_H
+
+#include <linux/types.h>
+
+#define MAXGENRELEN     32
+
+#define NF_OSF_GENRE    (1 << 0)
+#define NF_OSF_TTL      (1 << 1)
+#define NF_OSF_LOG      (1 << 2)
+#define NF_OSF_INVERT   (1 << 3)
+
+#define NF_OSF_LOGLEVEL_ALL             0       /* log all matched fingerprints */
+#define NF_OSF_LOGLEVEL_FIRST           1       /* log only the first matced fingerprint */
+#define NF_OSF_LOGLEVEL_ALL_KNOWN       2       /* do not log unknown packets */
+
+#define NF_OSF_TTL_TRUE                 0       /* True ip and fingerprint TTL comparison */
+
+/* Do not compare ip and fingerprint TTL at all */
+#define NF_OSF_TTL_NOCHECK              2
+
+/* Wildcard MSS (kind of).
+ * It is used to implement a state machine for the different wildcard values
+ * of the MSS and window sizes.
+ */
+struct nf_osf_wc {
+        __u32   wc;
+        __u32   val;
+};
+
+/* This struct represents IANA options
+ * http://www.iana.org/assignments/tcp-parameters
+ */
+struct nf_osf_opt {
+        __u16                   kind, length;
+        struct nf_osf_wc        wc;
+};
+
+struct nf_osf_info {
+        char    genre[MAXGENRELEN];
+        __u32   len;
+        __u32   flags;
+        __u32   loglevel;
+        __u32   ttl;
+};
+
+struct nf_osf_user_finger {
+        struct nf_osf_wc        wss;
+
+        __u8    ttl, df;
+        __u16   ss, mss;
+        __u16   opt_num;
+
+        char    genre[MAXGENRELEN];
+        char    version[MAXGENRELEN];
+        char    subtype[MAXGENRELEN];
+
+        /* MAX_IPOPTLEN is maximum if all options are NOPs or EOLs */
+        struct nf_osf_opt       opt[MAX_IPOPTLEN];
+};
+
+struct nf_osf_nlmsg {
+        struct nf_osf_user_finger       f;
+        struct iphdr                    ip;
+        struct tcphdr                   tcp;
+};
+
+/* Defines for IANA option kinds */
+enum iana_options {
+        OSFOPT_EOL = 0,         /* End of options */
+        OSFOPT_NOP,             /* NOP */
+        OSFOPT_MSS,             /* Maximum segment size */
+        OSFOPT_WSO,             /* Window scale option */
+        OSFOPT_SACKP,           /* SACK permitted */
+        OSFOPT_SACK,            /* SACK */
+        OSFOPT_ECHO,
+        OSFOPT_ECHOREPLY,
+        OSFOPT_TS,              /* Timestamp option */
+        OSFOPT_POCP,            /* Partial Order Connection Permitted */
+        OSFOPT_POSP,            /* Partial Order Service Profile */
+
+        /* Others are not used in the current OSF */
+        OSFOPT_EMPTY = 255,
+};
+
+#endif /* _NF_OSF_H */
diff --git a/include/uapi/linux/netfilter/nf_tables.h b/include/uapi/linux/netfilter/nf_tables.h
index 6a3d653d5b27..ae00a3c49b8a 100644
--- a/include/uapi/linux/netfilter/nf_tables.h
+++ b/include/uapi/linux/netfilter/nf_tables.h
@@ -831,7 +831,9 @@ enum nft_rt_keys {
         NFT_RT_NEXTHOP4,
         NFT_RT_NEXTHOP6,
         NFT_RT_TCPMSS,
+        __NFT_RT_MAX
 };
+#define NFT_RT_MAX              (__NFT_RT_MAX - 1)
 
 /**
  * enum nft_hash_types - nf_tables hash expression types
@@ -854,6 +856,8 @@ enum nft_hash_types {
  * @NFTA_HASH_SEED: seed value (NLA_U32)
  * @NFTA_HASH_OFFSET: add this offset value to hash result (NLA_U32)
  * @NFTA_HASH_TYPE: hash operation (NLA_U32: nft_hash_types)
+ * @NFTA_HASH_SET_NAME: name of the map to lookup (NLA_STRING)
+ * @NFTA_HASH_SET_ID: id of the map (NLA_U32)
  */
 enum nft_hash_attributes {
         NFTA_HASH_UNSPEC,
@@ -864,6 +868,8 @@ enum nft_hash_attributes {
         NFTA_HASH_SEED,
         NFTA_HASH_OFFSET,
         NFTA_HASH_TYPE,
+        NFTA_HASH_SET_NAME,
+        NFTA_HASH_SET_ID,
         __NFTA_HASH_MAX,
 };
 #define NFTA_HASH_MAX   (__NFTA_HASH_MAX - 1)
@@ -899,6 +905,31 @@ enum nft_rt_attributes {
 #define NFTA_RT_MAX             (__NFTA_RT_MAX - 1)
 
 /**
+ * enum nft_socket_attributes - nf_tables socket expression netlink attributes
+ *
+ * @NFTA_SOCKET_KEY: socket key to match
+ * @NFTA_SOCKET_DREG: destination register
+ */
+enum nft_socket_attributes {
+        NFTA_SOCKET_UNSPEC,
+        NFTA_SOCKET_KEY,
+        NFTA_SOCKET_DREG,
+        __NFTA_SOCKET_MAX
+};
+#define NFTA_SOCKET_MAX         (__NFTA_SOCKET_MAX - 1)
+
+/*
+ * enum nft_socket_keys - nf_tables socket expression keys
+ *
+ * @NFT_SOCKET_TRANSPARENT: Value of the IP(V6)_TRANSPARENT socket option_
+ */
+enum nft_socket_keys {
+        NFT_SOCKET_TRANSPARENT,
+        __NFT_SOCKET_MAX
+};
+#define NFT_SOCKET_MAX  (__NFT_SOCKET_MAX - 1)
+
+/**
  * enum nft_ct_keys - nf_tables ct expression keys
  *
  * @NFT_CT_STATE: conntrack state (bitmask of enum ip_conntrack_info)
@@ -949,7 +980,9 @@ enum nft_ct_keys {
         NFT_CT_DST_IP,
         NFT_CT_SRC_IP6,
         NFT_CT_DST_IP6,
+        __NFT_CT_MAX
 };
+#define NFT_CT_MAX              (__NFT_CT_MAX - 1)
 
 /**
  * enum nft_ct_attributes - nf_tables ct expression netlink attributes
@@ -1010,6 +1043,24 @@ enum nft_limit_attributes {
 };
 #define NFTA_LIMIT_MAX          (__NFTA_LIMIT_MAX - 1)
 
+enum nft_connlimit_flags {
+        NFT_CONNLIMIT_F_INV     = (1 << 0),
+};
+
+/**
+ * enum nft_connlimit_attributes - nf_tables connlimit expression netlink attributes
+ *
+ * @NFTA_CONNLIMIT_COUNT: number of connections (NLA_U32)
+ * @NFTA_CONNLIMIT_FLAGS: flags (NLA_U32: enum nft_connlimit_flags)
+ */
+enum nft_connlimit_attributes {
+        NFTA_CONNLIMIT_UNSPEC,
+        NFTA_CONNLIMIT_COUNT,
+        NFTA_CONNLIMIT_FLAGS,
+        __NFTA_CONNLIMIT_MAX
+};
+#define NFTA_CONNLIMIT_MAX      (__NFTA_CONNLIMIT_MAX - 1)
+
 /**
  * enum nft_counter_attributes - nf_tables counter expression netlink attributes
  *
@@ -1048,6 +1099,11 @@ enum nft_log_attributes {
 #define NFTA_LOG_MAX            (__NFTA_LOG_MAX - 1)
 
 /**
+ * LOGLEVEL_AUDIT - a pseudo log level enabling audit logging
+ */
+#define LOGLEVEL_AUDIT          8
+
+/**
  * enum nft_queue_attributes - nf_tables queue expression netlink attributes
  *
  * @NFTA_QUEUE_NUM: netlink queue to send messages to (NLA_U16)
@@ -1222,10 +1278,14 @@ enum nft_dup_attributes {
  * enum nft_fwd_attributes - nf_tables fwd expression netlink attributes
  *
  * @NFTA_FWD_SREG_DEV: source register of output interface (NLA_U32: nft_register)
+ * @NFTA_FWD_SREG_ADDR: source register of destination address (NLA_U32: nft_register)
+ * @NFTA_FWD_NFPROTO: layer 3 family of source register address (NLA_U32: enum nfproto)
  */
 enum nft_fwd_attributes {
         NFTA_FWD_UNSPEC,
         NFTA_FWD_SREG_DEV,
+        NFTA_FWD_SREG_ADDR,
+        NFTA_FWD_NFPROTO,
         __NFTA_FWD_MAX
 };
 #define NFTA_FWD_MAX    (__NFTA_FWD_MAX - 1)
@@ -1315,7 +1375,8 @@ enum nft_ct_helper_attributes {
 #define NFT_OBJECT_QUOTA        2
 #define NFT_OBJECT_CT_HELPER    3
 #define NFT_OBJECT_LIMIT        4
-#define __NFT_OBJECT_MAX        5
+#define NFT_OBJECT_CONNLIMIT    5
+#define __NFT_OBJECT_MAX        6
 #define NFT_OBJECT_MAX          (__NFT_OBJECT_MAX - 1)
 
 /**
@@ -1450,6 +1511,8 @@ enum nft_trace_types {
  * @NFTA_NG_MODULUS: maximum counter value (NLA_U32)
  * @NFTA_NG_TYPE: operation type (NLA_U32)
  * @NFTA_NG_OFFSET: offset to be added to the counter (NLA_U32)
+ * @NFTA_NG_SET_NAME: name of the map to lookup (NLA_STRING)
+ * @NFTA_NG_SET_ID: id of the map (NLA_U32)
  */
 enum nft_ng_attributes {
         NFTA_NG_UNSPEC,
@@ -1457,6 +1520,8 @@ enum nft_ng_attributes {
         NFTA_NG_MODULUS,
         NFTA_NG_TYPE,
         NFTA_NG_OFFSET,
+        NFTA_NG_SET_NAME,
+        NFTA_NG_SET_ID,
         __NFTA_NG_MAX
 };
 #define NFTA_NG_MAX     (__NFTA_NG_MAX - 1)
diff --git a/include/uapi/linux/netfilter/nfnetlink_conntrack.h b/include/uapi/linux/netfilter/nfnetlink_conntrack.h
index 77987111cab0..1d41810d17e2 100644
--- a/include/uapi/linux/netfilter/nfnetlink_conntrack.h
+++ b/include/uapi/linux/netfilter/nfnetlink_conntrack.h
@@ -262,6 +262,7 @@ enum ctattr_stats_cpu {
 enum ctattr_stats_global {
         CTA_STATS_GLOBAL_UNSPEC,
         CTA_STATS_GLOBAL_ENTRIES,
+        CTA_STATS_GLOBAL_MAX_ENTRIES,
         __CTA_STATS_GLOBAL_MAX,
 };
 #define CTA_STATS_GLOBAL_MAX (__CTA_STATS_GLOBAL_MAX - 1)
diff --git a/include/uapi/linux/netfilter/xt_osf.h b/include/uapi/linux/netfilter/xt_osf.h
index dad197e2ab99..72956eceeb09 100644
--- a/include/uapi/linux/netfilter/xt_osf.h
+++ b/include/uapi/linux/netfilter/xt_osf.h
@@ -23,101 +23,29 @@
 #include <linux/types.h>
 #include <linux/ip.h>
 #include <linux/tcp.h>
+#include <linux/netfilter/nf_osf.h>
 
-#define MAXGENRELEN             32
+#define XT_OSF_GENRE            NF_OSF_GENRE
+#define XT_OSF_INVERT           NF_OSF_INVERT
 
-#define XT_OSF_GENRE            (1<<0)
-#define XT_OSF_TTL              (1<<1)
-#define XT_OSF_LOG              (1<<2)
-#define XT_OSF_INVERT           (1<<3)
+#define XT_OSF_TTL              NF_OSF_TTL
+#define XT_OSF_LOG              NF_OSF_LOG
 
-#define XT_OSF_LOGLEVEL_ALL     0       /* log all matched fingerprints */
-#define XT_OSF_LOGLEVEL_FIRST   1       /* log only the first matced fingerprint */
-#define XT_OSF_LOGLEVEL_ALL_KNOWN       2 /* do not log unknown packets */
+#define XT_OSF_LOGLEVEL_ALL             NF_OSF_LOGLEVEL_ALL
+#define XT_OSF_LOGLEVEL_FIRST           NF_OSF_LOGLEVEL_FIRST
+#define XT_OSF_LOGLEVEL_ALL_KNOWN       NF_OSF_LOGLEVEL_ALL_KNOWN
 
-#define XT_OSF_TTL_TRUE         0       /* True ip and fingerprint TTL comparison */
-#define XT_OSF_TTL_LESS         1       /* Check if ip TTL is less than fingerprint one */
-#define XT_OSF_TTL_NOCHECK      2       /* Do not compare ip and fingerprint TTL at all */
+#define XT_OSF_TTL_TRUE         NF_OSF_TTL_TRUE
+#define XT_OSF_TTL_NOCHECK      NF_OSF_TTL_NOCHECK
 
-struct xt_osf_info {
-        char                    genre[MAXGENRELEN];
-        __u32                   len;
-        __u32                   flags;
-        __u32                   loglevel;
-        __u32                   ttl;
-};
-
-/*
- * Wildcard MSS (kind of).
- * It is used to implement a state machine for the different wildcard values
- * of the MSS and window sizes.
- */
-struct xt_osf_wc {
-        __u32                   wc;
-        __u32                   val;
-};
-
-/*
- * This struct represents IANA options
- * http://www.iana.org/assignments/tcp-parameters
- */
-struct xt_osf_opt {
-        __u16                   kind, length;
-        struct xt_osf_wc        wc;
-};
-
-struct xt_osf_user_finger {
-        struct xt_osf_wc        wss;
-
-        __u8                    ttl, df;
-        __u16                   ss, mss;
-        __u16                   opt_num;
-
-        char                    genre[MAXGENRELEN];
-        char                    version[MAXGENRELEN];
-        char                    subtype[MAXGENRELEN];
+#define XT_OSF_TTL_LESS 1       /* Check if ip TTL is less than fingerprint one */
 
-        /* MAX_IPOPTLEN is maximum if all options are NOPs or EOLs */
-        struct xt_osf_opt       opt[MAX_IPOPTLEN];
-};
-
-struct xt_osf_nlmsg {
-        struct xt_osf_user_finger       f;
-        struct iphdr            ip;
-        struct tcphdr           tcp;
-};
-
-/* Defines for IANA option kinds */
-
-enum iana_options {
-        OSFOPT_EOL = 0,         /* End of options */
-        OSFOPT_NOP,             /* NOP */
-        OSFOPT_MSS,             /* Maximum segment size */
-        OSFOPT_WSO,             /* Window scale option */
-        OSFOPT_SACKP,           /* SACK permitted */
-        OSFOPT_SACK,            /* SACK */
-        OSFOPT_ECHO,
-        OSFOPT_ECHOREPLY,
-        OSFOPT_TS,              /* Timestamp option */
-        OSFOPT_POCP,            /* Partial Order Connection Permitted */
-        OSFOPT_POSP,            /* Partial Order Service Profile */
-
-        /* Others are not used in the current OSF */
-        OSFOPT_EMPTY = 255,
-};
-
-/*
- * Initial window size option state machine: multiple of mss, mtu or
- * plain numeric value. Can also be made as plain numeric value which
- * is not a multiple of specified value.
- */
-enum xt_osf_window_size_options {
-        OSF_WSS_PLAIN   = 0,
-        OSF_WSS_MSS,
-        OSF_WSS_MTU,
-        OSF_WSS_MODULO,
-        OSF_WSS_MAX,
-};
+#define xt_osf_wc               nf_osf_wc
+#define xt_osf_opt              nf_osf_opt
+#define xt_osf_info             nf_osf_info
+#define xt_osf_user_finger      nf_osf_user_finger
+#define xt_osf_finger           nf_osf_finger
+#define xt_osf_nlmsg            nf_osf_nlmsg
 
 /*
  * Add/remove fingerprint from the kernel.
diff --git a/include/uapi/linux/netfilter_bridge/ebtables.h b/include/uapi/linux/netfilter_bridge/ebtables.h
index 0c7dc8315013..3b86c14ea49d 100644
--- a/include/uapi/linux/netfilter_bridge/ebtables.h
+++ b/include/uapi/linux/netfilter_bridge/ebtables.h
@@ -191,6 +191,12 @@ struct ebt_entry {
         unsigned char elems[0] __attribute__ ((aligned (__alignof__(struct ebt_replace))));
 };
 
+static __inline__ struct ebt_entry_target *
+ebt_get_target(struct ebt_entry *e)
+{
+        return (void *)e + e->target_offset;
+}
+
 /* {g,s}etsockopt numbers */
 #define EBT_BASE_CTL            128
 
diff --git a/include/uapi/linux/netfilter_ipv6/ip6t_srh.h b/include/uapi/linux/netfilter_ipv6/ip6t_srh.h
index f3cc0ef514a7..54ed83360dac 100644
--- a/include/uapi/linux/netfilter_ipv6/ip6t_srh.h
+++ b/include/uapi/linux/netfilter_ipv6/ip6t_srh.h
@@ -17,7 +17,10 @@
 #define IP6T_SRH_LAST_GT        0x0100
 #define IP6T_SRH_LAST_LT        0x0200
 #define IP6T_SRH_TAG            0x0400
-#define IP6T_SRH_MASK           0x07FF
+#define IP6T_SRH_PSID           0x0800
+#define IP6T_SRH_NSID           0x1000
+#define IP6T_SRH_LSID           0x2000
+#define IP6T_SRH_MASK           0x3FFF
 
 /* Values for "mt_invflags" field in struct ip6t_srh */
 #define IP6T_SRH_INV_NEXTHDR    0x0001
@@ -31,7 +34,10 @@
 #define IP6T_SRH_INV_LAST_GT    0x0100
 #define IP6T_SRH_INV_LAST_LT    0x0200
 #define IP6T_SRH_INV_TAG        0x0400
-#define IP6T_SRH_INV_MASK       0x07FF
+#define IP6T_SRH_INV_PSID       0x0800
+#define IP6T_SRH_INV_NSID       0x1000
+#define IP6T_SRH_INV_LSID       0x2000
+#define IP6T_SRH_INV_MASK       0x3FFF
 
 /**
  *      struct ip6t_srh - SRH match options
@@ -54,4 +60,37 @@ struct ip6t_srh {
         __u16                   mt_invflags;
 };
 
+/**
+ *      struct ip6t_srh1 - SRH match options (revision 1)
+ *      @ next_hdr: Next header field of SRH
+ *      @ hdr_len: Extension header length field of SRH
+ *      @ segs_left: Segments left field of SRH
+ *      @ last_entry: Last entry field of SRH
+ *      @ tag: Tag field of SRH
+ *      @ psid_addr: Address of previous SID in SRH SID list
+ *      @ nsid_addr: Address of NEXT SID in SRH SID list
+ *      @ lsid_addr: Address of LAST SID in SRH SID list
+ *      @ psid_msk: Mask of previous SID in SRH SID list
+ *      @ nsid_msk: Mask of next SID in SRH SID list
+ *      @ lsid_msk: MAsk of last SID in SRH SID list
+ *      @ mt_flags: match options
+ *      @ mt_invflags: Invert the sense of match options
+ */
+
+struct ip6t_srh1 {
+        __u8                    next_hdr;
+        __u8                    hdr_len;
+        __u8                    segs_left;
+        __u8                    last_entry;
+        __u16                   tag;
+        struct in6_addr         psid_addr;
+        struct in6_addr         nsid_addr;
+        struct in6_addr         lsid_addr;
+        struct in6_addr         psid_msk;
+        struct in6_addr         nsid_msk;
+        struct in6_addr         lsid_msk;
+        __u16                   mt_flags;
+        __u16                   mt_invflags;
+};
+
 #endif /*_IP6T_SRH_H*/
diff --git a/include/uapi/linux/nl80211.h b/include/uapi/linux/nl80211.h
index 271b93783d28..28b36545de24 100644
--- a/include/uapi/linux/nl80211.h
+++ b/include/uapi/linux/nl80211.h
@@ -11,6 +11,7 @@
  * Copyright 2008 Jouni Malinen <jouni.malinen@atheros.com>
  * Copyright 2008 Colin McCabe <colin@cozybit.com>
  * Copyright 2015-2017  Intel Deutschland GmbH
+ * Copyright (C) 2018 Intel Corporation
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -203,7 +204,8 @@
  * FILS shared key authentication offload should be able to construct the
  * authentication and association frames for FILS shared key authentication and
  * eventually do a key derivation as per IEEE 802.11ai. The below additional
- * parameters should be given to driver in %NL80211_CMD_CONNECT.
+ * parameters should be given to driver in %NL80211_CMD_CONNECT and/or in
+ * %NL80211_CMD_UPDATE_CONNECT_PARAMS.
  *      %NL80211_ATTR_FILS_ERP_USERNAME - used to construct keyname_nai
  *      %NL80211_ATTR_FILS_ERP_REALM - used to construct keyname_nai
  *      %NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM - used to construct erp message
@@ -214,7 +216,8 @@
  * as specified in IETF RFC 6696.
  *
  * When FILS shared key authentication is completed, driver needs to provide the
- * below additional parameters to userspace.
+ * below additional parameters to userspace, which can be either after setting
+ * up a connection or after roaming.
  *      %NL80211_ATTR_FILS_KEK - used for key renewal
  *      %NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM - used in further EAP-RP exchanges
  *      %NL80211_ATTR_PMKID - used to identify the PMKSA used/generated
@@ -2225,6 +2228,16 @@ enum nl80211_commands {
  * @NL80211_ATTR_NSS: Station's New/updated  RX_NSS value notified using this
  *      u8 attribute. This is used with %NL80211_CMD_STA_OPMODE_CHANGED.
  *
+ * @NL80211_ATTR_TXQ_STATS: TXQ statistics (nested attribute, see &enum
+ *      nl80211_txq_stats)
+ * @NL80211_ATTR_TXQ_LIMIT: Total packet limit for the TXQ queues for this phy.
+ *      The smaller of this and the memory limit is enforced.
+ * @NL80211_ATTR_TXQ_MEMORY_LIMIT: Total memory memory limit (in bytes) for the
+ *      TXQ queues for this phy. The smaller of this and the packet limit is
+ *      enforced.
+ * @NL80211_ATTR_TXQ_QUANTUM: TXQ scheduler quantum (bytes). Number of bytes
+ *      a flow is assigned on each round of the DRR scheduler.
+ *
  * @NUM_NL80211_ATTR: total number of nl80211_attrs available
  * @NL80211_ATTR_MAX: highest attribute number currently defined
  * @__NL80211_ATTR_AFTER_LAST: internal use
@@ -2659,6 +2672,11 @@ enum nl80211_attrs {
 
         NL80211_ATTR_CONTROL_PORT_OVER_NL80211,
 
+        NL80211_ATTR_TXQ_STATS,
+        NL80211_ATTR_TXQ_LIMIT,
+        NL80211_ATTR_TXQ_MEMORY_LIMIT,
+        NL80211_ATTR_TXQ_QUANTUM,
+
         /* add attributes here, update the policy in nl80211.c */
 
         __NL80211_ATTR_AFTER_LAST,
@@ -2982,6 +3000,8 @@ enum nl80211_sta_bss_param {
  *      received from the station (u64, usec)
  * @NL80211_STA_INFO_PAD: attribute used for padding for 64-bit alignment
  * @NL80211_STA_INFO_ACK_SIGNAL: signal strength of the last ACK frame(u8, dBm)
+ * @NL80211_STA_INFO_DATA_ACK_SIGNAL_AVG: avg signal strength of (data)
+ *      ACK frame (s8, dBm)
  * @__NL80211_STA_INFO_AFTER_LAST: internal
  * @NL80211_STA_INFO_MAX: highest possible station info attribute
  */
@@ -3021,6 +3041,7 @@ enum nl80211_sta_info {
         NL80211_STA_INFO_RX_DURATION,
         NL80211_STA_INFO_PAD,
         NL80211_STA_INFO_ACK_SIGNAL,
+        NL80211_STA_INFO_DATA_ACK_SIGNAL_AVG,
 
         /* keep last */
         __NL80211_STA_INFO_AFTER_LAST,
@@ -3038,6 +3059,7 @@ enum nl80211_sta_info {
  * @NL80211_TID_STATS_TX_MSDU_FAILED: number of failed transmitted
  *      MSDUs (u64)
  * @NL80211_TID_STATS_PAD: attribute used for padding for 64-bit alignment
+ * @NL80211_TID_STATS_TXQ_STATS: TXQ stats (nested attribute)
  * @NUM_NL80211_TID_STATS: number of attributes here
  * @NL80211_TID_STATS_MAX: highest numbered attribute here
  */
@@ -3048,6 +3070,7 @@ enum nl80211_tid_stats {
         NL80211_TID_STATS_TX_MSDU_RETRIES,
         NL80211_TID_STATS_TX_MSDU_FAILED,
         NL80211_TID_STATS_PAD,
+        NL80211_TID_STATS_TXQ_STATS,
 
         /* keep last */
         NUM_NL80211_TID_STATS,
@@ -3055,6 +3078,44 @@ enum nl80211_tid_stats {
 };
 
 /**
+ * enum nl80211_txq_stats - per TXQ statistics attributes
+ * @__NL80211_TXQ_STATS_INVALID: attribute number 0 is reserved
+ * @NUM_NL80211_TXQ_STATS: number of attributes here
+ * @NL80211_TXQ_STATS_BACKLOG_BYTES: number of bytes currently backlogged
+ * @NL80211_TXQ_STATS_BACKLOG_PACKETS: number of packets currently
+ *      backlogged
+ * @NL80211_TXQ_STATS_FLOWS: total number of new flows seen
+ * @NL80211_TXQ_STATS_DROPS: total number of packet drops
+ * @NL80211_TXQ_STATS_ECN_MARKS: total number of packet ECN marks
+ * @NL80211_TXQ_STATS_OVERLIMIT: number of drops due to queue space overflow
+ * @NL80211_TXQ_STATS_OVERMEMORY: number of drops due to memory limit overflow
+ *      (only for per-phy stats)
+ * @NL80211_TXQ_STATS_COLLISIONS: number of hash collisions
+ * @NL80211_TXQ_STATS_TX_BYTES: total number of bytes dequeued from TXQ
+ * @NL80211_TXQ_STATS_TX_PACKETS: total number of packets dequeued from TXQ
+ * @NL80211_TXQ_STATS_MAX_FLOWS: number of flow buckets for PHY
+ * @NL80211_TXQ_STATS_MAX: highest numbered attribute here
+ */
+enum nl80211_txq_stats {
+        __NL80211_TXQ_STATS_INVALID,
+        NL80211_TXQ_STATS_BACKLOG_BYTES,
+        NL80211_TXQ_STATS_BACKLOG_PACKETS,
+        NL80211_TXQ_STATS_FLOWS,
+        NL80211_TXQ_STATS_DROPS,
+        NL80211_TXQ_STATS_ECN_MARKS,
+        NL80211_TXQ_STATS_OVERLIMIT,
+        NL80211_TXQ_STATS_OVERMEMORY,
+        NL80211_TXQ_STATS_COLLISIONS,
+        NL80211_TXQ_STATS_TX_BYTES,
+        NL80211_TXQ_STATS_TX_PACKETS,
+        NL80211_TXQ_STATS_MAX_FLOWS,
+
+        /* keep last */
+        NUM_NL80211_TXQ_STATS,
+        NL80211_TXQ_STATS_MAX = NUM_NL80211_TXQ_STATS - 1
+};
+
+/**
  * enum nl80211_mpath_flags - nl80211 mesh path flags
  *
  * @NL80211_MPATH_FLAG_ACTIVE: the mesh path is active
@@ -3144,6 +3205,29 @@ enum nl80211_band_attr {
 #define NL80211_BAND_ATTR_HT_CAPA NL80211_BAND_ATTR_HT_CAPA
 
 /**
+ * enum nl80211_wmm_rule - regulatory wmm rule
+ *
+ * @__NL80211_WMMR_INVALID: attribute number 0 is reserved
+ * @NL80211_WMMR_CW_MIN: Minimum contention window slot.
+ * @NL80211_WMMR_CW_MAX: Maximum contention window slot.
+ * @NL80211_WMMR_AIFSN: Arbitration Inter Frame Space.
+ * @NL80211_WMMR_TXOP: Maximum allowed tx operation time.
+ * @nl80211_WMMR_MAX: highest possible wmm rule.
+ * @__NL80211_WMMR_LAST: Internal use.
+ */
+enum nl80211_wmm_rule {
+        __NL80211_WMMR_INVALID,
+        NL80211_WMMR_CW_MIN,
+        NL80211_WMMR_CW_MAX,
+        NL80211_WMMR_AIFSN,
+        NL80211_WMMR_TXOP,
+
+        /* keep last */
+        __NL80211_WMMR_LAST,
+        NL80211_WMMR_MAX = __NL80211_WMMR_LAST - 1
+};
+
+/**
  * enum nl80211_frequency_attr - frequency attributes
  * @__NL80211_FREQUENCY_ATTR_INVALID: attribute number 0 is reserved
  * @NL80211_FREQUENCY_ATTR_FREQ: Frequency in MHz
@@ -3192,6 +3276,9 @@ enum nl80211_band_attr {
  *      on this channel in current regulatory domain.
  * @NL80211_FREQUENCY_ATTR_NO_10MHZ: 10 MHz operation is not allowed
  *      on this channel in current regulatory domain.
+ * @NL80211_FREQUENCY_ATTR_WMM: this channel has wmm limitations.
+ *      This is a nested attribute that contains the wmm limitation per AC.
+ *      (see &enum nl80211_wmm_rule)
  * @NL80211_FREQUENCY_ATTR_MAX: highest frequency attribute number
  *      currently defined
  * @__NL80211_FREQUENCY_ATTR_AFTER_LAST: internal use
@@ -3220,6 +3307,7 @@ enum nl80211_frequency_attr {
         NL80211_FREQUENCY_ATTR_IR_CONCURRENT,
         NL80211_FREQUENCY_ATTR_NO_20MHZ,
         NL80211_FREQUENCY_ATTR_NO_10MHZ,
+        NL80211_FREQUENCY_ATTR_WMM,
 
         /* keep last */
         __NL80211_FREQUENCY_ATTR_AFTER_LAST,
@@ -5040,6 +5128,11 @@ enum nl80211_feature_flags {
  *      "radar detected" event.
  * @NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211: Driver supports sending and
  *      receiving control port frames over nl80211 instead of the netdevice.
+ * @NL80211_EXT_FEATURE_DATA_ACK_SIGNAL_SUPPORT: This Driver support data ack
+ *      rssi if firmware support, this flag is to intimate about ack rssi
+ *      support to nl80211.
+ * @NL80211_EXT_FEATURE_TXQS: Driver supports FQ-CoDel-enabled intermediate
+ *      TXQs.
  *
  * @NUM_NL80211_EXT_FEATURES: number of extended features.
  * @MAX_NL80211_EXT_FEATURES: highest extended feature index.
@@ -5072,6 +5165,8 @@ enum nl80211_ext_feature_index {
         NL80211_EXT_FEATURE_HIGH_ACCURACY_SCAN,
         NL80211_EXT_FEATURE_DFS_OFFLOAD,
         NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211,
+        NL80211_EXT_FEATURE_DATA_ACK_SIGNAL_SUPPORT,
+        NL80211_EXT_FEATURE_TXQS,
 
         /* add new features before the definition below */
         NUM_NL80211_EXT_FEATURES,
diff --git a/include/uapi/linux/omap3isp.h b/include/uapi/linux/omap3isp.h
index 1a920145db04..87b55755f4ff 100644
--- a/include/uapi/linux/omap3isp.h
+++ b/include/uapi/linux/omap3isp.h
@@ -55,6 +55,8 @@
         _IOWR('V', BASE_VIDIOC_PRIVATE + 5, struct omap3isp_h3a_af_config)
 #define VIDIOC_OMAP3ISP_STAT_REQ \
         _IOWR('V', BASE_VIDIOC_PRIVATE + 6, struct omap3isp_stat_data)
+#define VIDIOC_OMAP3ISP_STAT_REQ_TIME32 \
+        _IOWR('V', BASE_VIDIOC_PRIVATE + 6, struct omap3isp_stat_data_time32)
 #define VIDIOC_OMAP3ISP_STAT_EN \
         _IOWR('V', BASE_VIDIOC_PRIVATE + 7, unsigned long)
 
@@ -165,7 +167,14 @@ struct omap3isp_h3a_aewb_config {
  * @config_counter: Number of the configuration associated with the data.
  */
 struct omap3isp_stat_data {
+#ifdef __KERNEL__
+        struct {
+                __s64   tv_sec;
+                __s64   tv_usec;
+        } ts;
+#else
         struct timeval ts;
+#endif
         void __user *buf;
         __u32 buf_size;
         __u16 frame_number;
@@ -173,6 +182,19 @@ struct omap3isp_stat_data {
         __u16 config_counter;
 };
 
+#ifdef __KERNEL__
+struct omap3isp_stat_data_time32 {
+        struct {
+                __s32   tv_sec;
+                __s32   tv_usec;
+        } ts;
+        __u32 buf;
+        __u32 buf_size;
+        __u16 frame_number;
+        __u16 cur_frame;
+        __u16 config_counter;
+};
+#endif
 
 /* Histogram related structs */
 
diff --git a/include/uapi/linux/openvswitch.h b/include/uapi/linux/openvswitch.h
index 713e56ce681f..863aabaa5cc9 100644
--- a/include/uapi/linux/openvswitch.h
+++ b/include/uapi/linux/openvswitch.h
@@ -937,4 +937,32 @@ enum ovs_meter_band_type {
 
 #define OVS_METER_BAND_TYPE_MAX (__OVS_METER_BAND_TYPE_MAX - 1)
 
+/* Conntrack limit */
+#define OVS_CT_LIMIT_FAMILY  "ovs_ct_limit"
+#define OVS_CT_LIMIT_MCGROUP "ovs_ct_limit"
+#define OVS_CT_LIMIT_VERSION 0x1
+
+enum ovs_ct_limit_cmd {
+        OVS_CT_LIMIT_CMD_UNSPEC,
+        OVS_CT_LIMIT_CMD_SET,           /* Add or modify ct limit. */
+        OVS_CT_LIMIT_CMD_DEL,           /* Delete ct limit. */
+        OVS_CT_LIMIT_CMD_GET            /* Get ct limit. */
+};
+
+enum ovs_ct_limit_attr {
+        OVS_CT_LIMIT_ATTR_UNSPEC,
+        OVS_CT_LIMIT_ATTR_ZONE_LIMIT,   /* Nested struct ovs_zone_limit. */
+        __OVS_CT_LIMIT_ATTR_MAX
+};
+
+#define OVS_CT_LIMIT_ATTR_MAX (__OVS_CT_LIMIT_ATTR_MAX - 1)
+
+#define OVS_ZONE_LIMIT_DEFAULT_ZONE -1
+
+struct ovs_zone_limit {
+        int zone_id;
+        __u32 limit;
+        __u32 count;
+};
+
 #endif /* _LINUX_OPENVSWITCH_H */
diff --git a/include/uapi/linux/pci_regs.h b/include/uapi/linux/pci_regs.h
index 103ba797a8f3..4da87e2ef8a8 100644
--- a/include/uapi/linux/pci_regs.h
+++ b/include/uapi/linux/pci_regs.h
@@ -506,6 +506,8 @@
 #define  PCI_EXP_DEVCTL_READRQ_256B  0x1000 /* 256 Bytes */
 #define  PCI_EXP_DEVCTL_READRQ_512B  0x2000 /* 512 Bytes */
 #define  PCI_EXP_DEVCTL_READRQ_1024B 0x3000 /* 1024 Bytes */
+#define  PCI_EXP_DEVCTL_READRQ_2048B 0x4000 /* 2048 Bytes */
+#define  PCI_EXP_DEVCTL_READRQ_4096B 0x5000 /* 4096 Bytes */
 #define  PCI_EXP_DEVCTL_BCR_FLR 0x8000  /* Bridge Configuration Retry / FLR */
 #define PCI_EXP_DEVSTA          10      /* Device Status */
 #define  PCI_EXP_DEVSTA_CED     0x0001  /* Correctable Error Detected */
@@ -655,6 +657,11 @@
 #define  PCI_EXP_LNKCAP2_SLS_16_0GB     0x00000010 /* Supported Speed 16GT/s */
 #define  PCI_EXP_LNKCAP2_CROSSLINK      0x00000100 /* Crosslink supported */
 #define PCI_EXP_LNKCTL2         48      /* Link Control 2 */
+#define PCI_EXP_LNKCTL2_TLS             0x000f
+#define PCI_EXP_LNKCTL2_TLS_2_5GT       0x0001 /* Supported Speed 2.5GT/s */
+#define PCI_EXP_LNKCTL2_TLS_5_0GT       0x0002 /* Supported Speed 5GT/s */
+#define PCI_EXP_LNKCTL2_TLS_8_0GT       0x0003 /* Supported Speed 8GT/s */
+#define PCI_EXP_LNKCTL2_TLS_16_0GT      0x0004 /* Supported Speed 16GT/s */
 #define PCI_EXP_LNKSTA2         50      /* Link Status 2 */
 #define PCI_CAP_EXP_ENDPOINT_SIZEOF_V2  52      /* v2 endpoints with link end here */
 #define PCI_EXP_SLTCAP2         52      /* Slot Capabilities 2 */
@@ -981,6 +988,7 @@
 #define  PCI_EXP_DPC_CAP_DL_ACTIVE      0x1000  /* ERR_COR signal on DL_Active supported */
 
 #define PCI_EXP_DPC_CTL                 6       /* DPC control */
+#define  PCI_EXP_DPC_CTL_EN_FATAL       0x0001  /* Enable trigger on ERR_FATAL message */
 #define  PCI_EXP_DPC_CTL_EN_NONFATAL    0x0002  /* Enable trigger on ERR_NONFATAL message */
 #define  PCI_EXP_DPC_CTL_INT_EN         0x0008  /* DPC Interrupt Enable */
 
diff --git a/include/uapi/linux/pkt_cls.h b/include/uapi/linux/pkt_cls.h
index be05e66c167b..84e4c1d0f874 100644
--- a/include/uapi/linux/pkt_cls.h
+++ b/include/uapi/linux/pkt_cls.h
@@ -129,6 +129,7 @@ enum {
 #define TCA_CLS_FLAGS_SKIP_SW   (1 << 1) /* don't use filter in SW */
 #define TCA_CLS_FLAGS_IN_HW     (1 << 2) /* filter is offloaded to HW */
 #define TCA_CLS_FLAGS_NOT_IN_HW (1 << 3) /* filter isn't offloaded to HW */
+#define TCA_CLS_FLAGS_VERBOSE   (1 << 4) /* verbose logging */
 
 /* U32 filters */
 
diff --git a/include/uapi/linux/psp-sev.h b/include/uapi/linux/psp-sev.h
index 9008f31c7eb6..ac8c60bcc83b 100644
--- a/include/uapi/linux/psp-sev.h
+++ b/include/uapi/linux/psp-sev.h
@@ -30,6 +30,7 @@ enum {
         SEV_PDH_GEN,
         SEV_PDH_CERT_EXPORT,
         SEV_PEK_CERT_IMPORT,
+        SEV_GET_ID,
 
         SEV_MAX,
 };
@@ -124,6 +125,17 @@ struct sev_user_data_pdh_cert_export {
 } __packed;
 
 /**
+ * struct sev_user_data_get_id - GET_ID command parameters
+ *
+ * @socket1: Buffer to pass unique ID of first socket
+ * @socket2: Buffer to pass unique ID of second socket
+ */
+struct sev_user_data_get_id {
+        __u8 socket1[64];                       /* Out */
+        __u8 socket2[64];                       /* Out */
+} __packed;
+
+/**
  * struct sev_issue_cmd - SEV ioctl parameters
  *
  * @cmd: SEV commands to execute
diff --git a/include/uapi/linux/rseq.h b/include/uapi/linux/rseq.h
new file mode 100644
index 000000000000..d620fa43756c
--- /dev/null
+++ b/include/uapi/linux/rseq.h
@@ -0,0 +1,133 @@
+/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
+#ifndef _UAPI_LINUX_RSEQ_H
+#define _UAPI_LINUX_RSEQ_H
+
+/*
+ * linux/rseq.h
+ *
+ * Restartable sequences system call API
+ *
+ * Copyright (c) 2015-2018 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ */
+
+#ifdef __KERNEL__
+# include <linux/types.h>
+#else
+# include <stdint.h>
+#endif
+
+#include <linux/types_32_64.h>
+
+enum rseq_cpu_id_state {
+        RSEQ_CPU_ID_UNINITIALIZED               = -1,
+        RSEQ_CPU_ID_REGISTRATION_FAILED         = -2,
+};
+
+enum rseq_flags {
+        RSEQ_FLAG_UNREGISTER = (1 << 0),
+};
+
+enum rseq_cs_flags_bit {
+        RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT_BIT  = 0,
+        RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL_BIT   = 1,
+        RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE_BIT  = 2,
+};
+
+enum rseq_cs_flags {
+        RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT      =
+                (1U << RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT_BIT),
+        RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL       =
+                (1U << RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL_BIT),
+        RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE      =
+                (1U << RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE_BIT),
+};
+
+/*
+ * struct rseq_cs is aligned on 4 * 8 bytes to ensure it is always
+ * contained within a single cache-line. It is usually declared as
+ * link-time constant data.
+ */
+struct rseq_cs {
+        /* Version of this structure. */
+        __u32 version;
+        /* enum rseq_cs_flags */
+        __u32 flags;
+        LINUX_FIELD_u32_u64(start_ip);
+        /* Offset from start_ip. */
+        LINUX_FIELD_u32_u64(post_commit_offset);
+        LINUX_FIELD_u32_u64(abort_ip);
+} __attribute__((aligned(4 * sizeof(__u64))));
+
+/*
+ * struct rseq is aligned on 4 * 8 bytes to ensure it is always
+ * contained within a single cache-line.
+ *
+ * A single struct rseq per thread is allowed.
+ */
+struct rseq {
+        /*
+         * Restartable sequences cpu_id_start field. Updated by the
+         * kernel, and read by user-space with single-copy atomicity
+         * semantics. Aligned on 32-bit. Always contains a value in the
+         * range of possible CPUs, although the value may not be the
+         * actual current CPU (e.g. if rseq is not initialized). This
+         * CPU number value should always be compared against the value
+         * of the cpu_id field before performing a rseq commit or
+         * returning a value read from a data structure indexed using
+         * the cpu_id_start value.
+         */
+        __u32 cpu_id_start;
+        /*
+         * Restartable sequences cpu_id field. Updated by the kernel,
+         * and read by user-space with single-copy atomicity semantics.
+         * Aligned on 32-bit. Values RSEQ_CPU_ID_UNINITIALIZED and
+         * RSEQ_CPU_ID_REGISTRATION_FAILED have a special semantic: the
+         * former means "rseq uninitialized", and latter means "rseq
+         * initialization failed". This value is meant to be read within
+         * rseq critical sections and compared with the cpu_id_start
+         * value previously read, before performing the commit instruction,
+         * or read and compared with the cpu_id_start value before returning
+         * a value loaded from a data structure indexed using the
+         * cpu_id_start value.
+         */
+        __u32 cpu_id;
+        /*
+         * Restartable sequences rseq_cs field.
+         *
+         * Contains NULL when no critical section is active for the current
+         * thread, or holds a pointer to the currently active struct rseq_cs.
+         *
+         * Updated by user-space, which sets the address of the currently
+         * active rseq_cs at the beginning of assembly instruction sequence
+         * block, and set to NULL by the kernel when it restarts an assembly
+         * instruction sequence block, as well as when the kernel detects that
+         * it is preempting or delivering a signal outside of the range
+         * targeted by the rseq_cs. Also needs to be set to NULL by user-space
+         * before reclaiming memory that contains the targeted struct rseq_cs.
+         *
+         * Read and set by the kernel with single-copy atomicity semantics.
+         * Set by user-space with single-copy atomicity semantics. Aligned
+         * on 64-bit.
+         */
+        LINUX_FIELD_u32_u64(rseq_cs);
+        /*
+         * - RSEQ_DISABLE flag:
+         *
+         * Fallback fast-track flag for single-stepping.
+         * Set by user-space if lack of progress is detected.
+         * Cleared by user-space after rseq finish.
+         * Read by the kernel.
+         * - RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT
+         *     Inhibit instruction sequence block restart and event
+         *     counter increment on preemption for this thread.
+         * - RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL
+         *     Inhibit instruction sequence block restart and event
+         *     counter increment on signal delivery for this thread.
+         * - RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE
+         *     Inhibit instruction sequence block restart and event
+         *     counter increment on migration for this thread.
+         */
+        __u32 flags;
+} __attribute__((aligned(4 * sizeof(__u64))));
+
+#endif /* _UAPI_LINUX_RSEQ_H */
diff --git a/include/uapi/linux/rtnetlink.h b/include/uapi/linux/rtnetlink.h
index 9b15005955fa..7d8502313c99 100644
--- a/include/uapi/linux/rtnetlink.h
+++ b/include/uapi/linux/rtnetlink.h
@@ -254,6 +254,11 @@ enum {
 #define RTPROT_DHCP     16      /* DHCP client */
 #define RTPROT_MROUTED  17      /* Multicast daemon */
 #define RTPROT_BABEL    42      /* Babel daemon */
+#define RTPROT_BGP      186     /* BGP Routes */
+#define RTPROT_ISIS     187     /* ISIS Routes */
+#define RTPROT_OSPF     188     /* OSPF Routes */
+#define RTPROT_RIP      189     /* RIP Routes */
+#define RTPROT_EIGRP    192     /* EIGRP Routes */
 
 /* rtm_scope
 
@@ -327,6 +332,9 @@ enum rtattr_type_t {
         RTA_PAD,
         RTA_UID,
         RTA_TTL_PROPAGATE,
+        RTA_IP_PROTO,
+        RTA_SPORT,
+        RTA_DPORT,
         __RTA_MAX
 };
 
diff --git a/include/uapi/linux/seg6_local.h b/include/uapi/linux/seg6_local.h
index ef2d8c3e76c1..edc138bdc56d 100644
--- a/include/uapi/linux/seg6_local.h
+++ b/include/uapi/linux/seg6_local.h
@@ -25,6 +25,7 @@ enum {
         SEG6_LOCAL_NH6,
         SEG6_LOCAL_IIF,
         SEG6_LOCAL_OIF,
+        SEG6_LOCAL_BPF,
         __SEG6_LOCAL_MAX,
 };
 #define SEG6_LOCAL_MAX (__SEG6_LOCAL_MAX - 1)
@@ -59,10 +60,21 @@ enum {
         SEG6_LOCAL_ACTION_END_AS        = 13,
         /* forward to SR-unaware VNF with masquerading */
         SEG6_LOCAL_ACTION_END_AM        = 14,
+        /* custom BPF action */
+        SEG6_LOCAL_ACTION_END_BPF       = 15,
 
         __SEG6_LOCAL_ACTION_MAX,
 };
 
 #define SEG6_LOCAL_ACTION_MAX (__SEG6_LOCAL_ACTION_MAX - 1)
 
+enum {
+        SEG6_LOCAL_BPF_PROG_UNSPEC,
+        SEG6_LOCAL_BPF_PROG,
+        SEG6_LOCAL_BPF_PROG_NAME,
+        __SEG6_LOCAL_BPF_PROG_MAX,
+};
+
+#define SEG6_LOCAL_BPF_PROG_MAX (__SEG6_LOCAL_BPF_PROG_MAX - 1)
+
 #endif
diff --git a/include/uapi/linux/snmp.h b/include/uapi/linux/snmp.h
index 33a70ece462f..750d89120335 100644
--- a/include/uapi/linux/snmp.h
+++ b/include/uapi/linux/snmp.h
@@ -276,6 +276,9 @@ enum
         LINUX_MIB_TCPKEEPALIVE,                 /* TCPKeepAlive */
         LINUX_MIB_TCPMTUPFAIL,                  /* TCPMTUPFail */
         LINUX_MIB_TCPMTUPSUCCESS,               /* TCPMTUPSuccess */
+        LINUX_MIB_TCPDELIVERED,                 /* TCPDelivered */
+        LINUX_MIB_TCPDELIVEREDCE,               /* TCPDeliveredCE */
+        LINUX_MIB_TCPACKCOMPRESSED,             /* TCPAckCompressed */
         __LINUX_MIB_MAX
 };
 
diff --git a/include/uapi/linux/tcp.h b/include/uapi/linux/tcp.h
index 560374c978f9..29eb659aa77a 100644
--- a/include/uapi/linux/tcp.h
+++ b/include/uapi/linux/tcp.h
@@ -122,6 +122,10 @@ enum {
 #define TCP_MD5SIG_EXT          32      /* TCP MD5 Signature with extensions */
 #define TCP_FASTOPEN_KEY        33      /* Set the key for Fast Open (cookie) */
 #define TCP_FASTOPEN_NO_COOKIE  34      /* Enable TFO without a TFO cookie */
+#define TCP_ZEROCOPY_RECEIVE    35
+#define TCP_INQ                 36      /* Notify bytes available to read as a cmsg on read */
+
+#define TCP_CM_INQ              TCP_INQ
 
 struct tcp_repair_opt {
         __u32   opt_code;
@@ -224,6 +228,9 @@ struct tcp_info {
         __u64   tcpi_busy_time;      /* Time (usec) busy sending data */
         __u64   tcpi_rwnd_limited;   /* Time (usec) limited by receive window */
         __u64   tcpi_sndbuf_limited; /* Time (usec) limited by send buffer */
+
+        __u32   tcpi_delivered;
+        __u32   tcpi_delivered_ce;
 };
 
 /* netlink attributes types for SCM_TIMESTAMPING_OPT_STATS */
@@ -244,6 +251,8 @@ enum {
         TCP_NLA_SNDQ_SIZE,      /* Data (bytes) pending in send queue */
         TCP_NLA_CA_STATE,       /* ca_state of socket */
         TCP_NLA_SND_SSTHRESH,   /* Slow start size threshold */
+        TCP_NLA_DELIVERED,      /* Data pkts delivered incl. out-of-order */
+        TCP_NLA_DELIVERED_CE,   /* Like above but only ones w/ CE marks */
 
 };
 
@@ -271,4 +280,11 @@ struct tcp_diag_md5sig {
         __u8    tcpm_key[TCP_MD5SIG_MAXKEYLEN];
 };
 
+/* setsockopt(fd, IPPROTO_TCP, TCP_ZEROCOPY_RECEIVE, ...) */
+
+struct tcp_zerocopy_receive {
+        __u64 address;          /* in: address of mapping */
+        __u32 length;           /* in/out: number of bytes to map/mapped */
+        __u32 recv_skip_hint;   /* out: amount of bytes to skip */
+};
 #endif /* _UAPI_LINUX_TCP_H */
diff --git a/include/uapi/linux/time.h b/include/uapi/linux/time.h
index 4c0338ea308a..fcf936656493 100644
--- a/include/uapi/linux/time.h
+++ b/include/uapi/linux/time.h
@@ -42,6 +42,13 @@ struct itimerval {
         struct timeval it_value;        /* current value */
 };
 
+#ifndef __kernel_timespec
+struct __kernel_timespec {
+        __kernel_time64_t       tv_sec;                 /* seconds */
+        long long               tv_nsec;                /* nanoseconds */
+};
+#endif
+
 /*
  * legacy timeval structure, only embedded in structures that
  * traditionally used 'timeval' to pass time intervals (not absolute
diff --git a/include/uapi/linux/tipc.h b/include/uapi/linux/tipc.h
index bf6d28677cfe..6b2fd4d9655f 100644
--- a/include/uapi/linux/tipc.h
+++ b/include/uapi/linux/tipc.h
@@ -209,16 +209,16 @@ struct tipc_group_req {
  * The string formatting for each name element is:
  * media: media
  * interface: media:interface name
- * link: Z.C.N:interface-Z.C.N:interface
- *
+ * link: node:interface-node:interface
  */
-
+#define TIPC_NODEID_LEN         16
 #define TIPC_MAX_MEDIA_NAME     16
 #define TIPC_MAX_IF_NAME        16
 #define TIPC_MAX_BEARER_NAME    32
 #define TIPC_MAX_LINK_NAME      68
 
-#define SIOCGETLINKNAME         SIOCPROTOPRIVATE
+#define SIOCGETLINKNAME        SIOCPROTOPRIVATE
+#define SIOCGETNODEID          (SIOCPROTOPRIVATE + 1)
 
 struct tipc_sioc_ln_req {
         __u32 peer;
@@ -226,6 +226,10 @@ struct tipc_sioc_ln_req {
         char linkname[TIPC_MAX_LINK_NAME];
 };
 
+struct tipc_sioc_nodeid_req {
+        __u32 peer;
+        char node_id[TIPC_NODEID_LEN];
+};
 
 /* The macros and functions below are deprecated:
  */
diff --git a/include/uapi/linux/tipc_config.h b/include/uapi/linux/tipc_config.h
index 3f29e3c8ed06..4b2c93b1934c 100644
--- a/include/uapi/linux/tipc_config.h
+++ b/include/uapi/linux/tipc_config.h
@@ -185,6 +185,11 @@
 #define TIPC_DEF_LINK_WIN 50
 #define TIPC_MAX_LINK_WIN 8191
 
+/*
+ * Default MTU for UDP media
+ */
+
+#define TIPC_DEF_LINK_UDP_MTU 14000
 
 struct tipc_node_info {
         __be32 addr;                    /* network address of node */
diff --git a/include/uapi/linux/tipc_netlink.h b/include/uapi/linux/tipc_netlink.h
index 0affb682e5e3..85c11982c89b 100644
--- a/include/uapi/linux/tipc_netlink.h
+++ b/include/uapi/linux/tipc_netlink.h
@@ -266,6 +266,7 @@ enum {
         TIPC_NLA_PROP_PRIO,             /* u32 */
         TIPC_NLA_PROP_TOL,              /* u32 */
         TIPC_NLA_PROP_WIN,              /* u32 */
+        TIPC_NLA_PROP_MTU,              /* u32 */
 
         __TIPC_NLA_PROP_MAX,
         TIPC_NLA_PROP_MAX = __TIPC_NLA_PROP_MAX - 1
diff --git a/include/uapi/linux/tty_flags.h b/include/uapi/linux/tty_flags.h
index 6ac609a00dea..900a32e63424 100644
--- a/include/uapi/linux/tty_flags.h
+++ b/include/uapi/linux/tty_flags.h
@@ -13,7 +13,7 @@
  */
 #define ASYNCB_HUP_NOTIFY        0 /* Notify getty on hangups and closes
                                     * on the callout port */
-#define ASYNCB_FOURPORT          1 /* Set OU1, OUT2 per AST Fourport settings */
+#define ASYNCB_FOURPORT          1 /* Set OUT1, OUT2 per AST Fourport settings */
 #define ASYNCB_SAK               2 /* Secure Attention Key (Orange book) */
 #define ASYNCB_SPLIT_TERMIOS     3 /* [x] Separate termios for dialin/callout */
 #define ASYNCB_SPD_HI            4 /* Use 57600 instead of 38400 bps */
diff --git a/include/uapi/linux/types_32_64.h b/include/uapi/linux/types_32_64.h
new file mode 100644
index 000000000000..0a87ace34a57
--- /dev/null
+++ b/include/uapi/linux/types_32_64.h
@@ -0,0 +1,50 @@
+/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
+#ifndef _UAPI_LINUX_TYPES_32_64_H
+#define _UAPI_LINUX_TYPES_32_64_H
+
+/*
+ * linux/types_32_64.h
+ *
+ * Integer type declaration for pointers across 32-bit and 64-bit systems.
+ *
+ * Copyright (c) 2015-2018 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ */
+
+#ifdef __KERNEL__
+# include <linux/types.h>
+#else
+# include <stdint.h>
+#endif
+
+#include <asm/byteorder.h>
+
+#ifdef __BYTE_ORDER
+# if (__BYTE_ORDER == __BIG_ENDIAN)
+#  define LINUX_BYTE_ORDER_BIG_ENDIAN
+# else
+#  define LINUX_BYTE_ORDER_LITTLE_ENDIAN
+# endif
+#else
+# ifdef __BIG_ENDIAN
+#  define LINUX_BYTE_ORDER_BIG_ENDIAN
+# else
+#  define LINUX_BYTE_ORDER_LITTLE_ENDIAN
+# endif
+#endif
+
+#ifdef __LP64__
+# define LINUX_FIELD_u32_u64(field)                     __u64 field
+# define LINUX_FIELD_u32_u64_INIT_ONSTACK(field, v)     field = (intptr_t)v
+#else
+# ifdef LINUX_BYTE_ORDER_BIG_ENDIAN
+#  define LINUX_FIELD_u32_u64(field)    __u32 field ## _padding, field
+#  define LINUX_FIELD_u32_u64_INIT_ONSTACK(field, v)    \
+        field ## _padding = 0, field = (intptr_t)v
+# else
+#  define LINUX_FIELD_u32_u64(field)    __u32 field, field ## _padding
+#  define LINUX_FIELD_u32_u64_INIT_ONSTACK(field, v)    \
+        field = (intptr_t)v, field ## _padding = 0
+# endif
+#endif
+
+#endif /* _UAPI_LINUX_TYPES_32_64_H */
diff --git a/include/uapi/linux/udp.h b/include/uapi/linux/udp.h
index efb7b5991c2f..09d00f8c442b 100644
--- a/include/uapi/linux/udp.h
+++ b/include/uapi/linux/udp.h
@@ -32,6 +32,7 @@ struct udphdr {
 #define UDP_ENCAP       100     /* Set the socket to accept encapsulated packets */
 #define UDP_NO_CHECK6_TX 101    /* Disable sending checksum for UDP6X */
 #define UDP_NO_CHECK6_RX 102    /* Disable accpeting checksum for UDP6 */
+#define UDP_SEGMENT     103     /* Set GSO segmentation size */
 
 /* UDP encapsulation types */
 #define UDP_ENCAP_ESPINUDP_NON_IKE      1 /* draft-ietf-ipsec-nat-t-ike-00/01 */
diff --git a/include/uapi/linux/usb/audio.h b/include/uapi/linux/usb/audio.h
index 3a78e7145689..13d98e6e0db1 100644
--- a/include/uapi/linux/usb/audio.h
+++ b/include/uapi/linux/usb/audio.h
@@ -285,9 +285,22 @@ static inline __u8 uac_mixer_unit_iChannelNames(struct uac_mixer_unit_descriptor
 static inline __u8 *uac_mixer_unit_bmControls(struct uac_mixer_unit_descriptor *desc,
                                               int protocol)
 {
-        return (protocol == UAC_VERSION_1) ?
-                &desc->baSourceID[desc->bNrInPins + 4] :
-                &desc->baSourceID[desc->bNrInPins + 6];
+        switch (protocol) {
+        case UAC_VERSION_1:
+                return &desc->baSourceID[desc->bNrInPins + 4];
+        case UAC_VERSION_2:
+                return &desc->baSourceID[desc->bNrInPins + 6];
+        case UAC_VERSION_3:
+                return &desc->baSourceID[desc->bNrInPins + 2];
+        default:
+                return NULL;
+        }
+}
+
+static inline __u16 uac3_mixer_unit_wClusterDescrID(struct uac_mixer_unit_descriptor *desc)
+{
+        return (desc->baSourceID[desc->bNrInPins + 1] << 8) |
+                desc->baSourceID[desc->bNrInPins];
 }
 
 static inline __u8 uac_mixer_unit_iMixer(struct uac_mixer_unit_descriptor *desc)
diff --git a/include/uapi/linux/usb/ch11.h b/include/uapi/linux/usb/ch11.h
index 29c120c88747..fb0cd24c392c 100644
--- a/include/uapi/linux/usb/ch11.h
+++ b/include/uapi/linux/usb/ch11.h
@@ -197,6 +197,11 @@ struct usb_port_status {
 #define USB_EXT_PORT_STAT_RX_LANES      0x00000f00
 #define USB_EXT_PORT_STAT_TX_LANES      0x0000f000
 
+#define USB_EXT_PORT_RX_LANES(p) \
+                        (((p) & USB_EXT_PORT_STAT_RX_LANES) >> 8)
+#define USB_EXT_PORT_TX_LANES(p) \
+                        (((p) & USB_EXT_PORT_STAT_TX_LANES) >> 12)
+
 /*
  * wHubCharacteristics (masks)
  * See USB 2.0 spec Table 11-13, offset 3
diff --git a/include/uapi/linux/virtio_gpu.h b/include/uapi/linux/virtio_gpu.h
index 4b04ead26cd9..f43c3c6171ff 100644
--- a/include/uapi/linux/virtio_gpu.h
+++ b/include/uapi/linux/virtio_gpu.h
@@ -260,6 +260,7 @@ struct virtio_gpu_cmd_submit {
 };
 
 #define VIRTIO_GPU_CAPSET_VIRGL 1
+#define VIRTIO_GPU_CAPSET_VIRGL2 2
 
 /* VIRTIO_GPU_CMD_GET_CAPSET_INFO */
 struct virtio_gpu_get_capset_info {
diff --git a/include/uapi/linux/virtio_net.h b/include/uapi/linux/virtio_net.h
index 5de6ed37695b..a3715a3224c1 100644
--- a/include/uapi/linux/virtio_net.h
+++ b/include/uapi/linux/virtio_net.h
@@ -57,6 +57,9 @@
                                          * Steering */
 #define VIRTIO_NET_F_CTRL_MAC_ADDR 23   /* Set MAC address */
 
+#define VIRTIO_NET_F_STANDBY      62    /* Act as standby for another device
+                                         * with the same MAC.
+                                         */
 #define VIRTIO_NET_F_SPEED_DUPLEX 63    /* Device set linkspeed and duplex */
 
 #ifndef VIRTIO_NET_NO_LEGACY
diff --git a/include/uapi/linux/vmcore.h b/include/uapi/linux/vmcore.h
new file mode 100644
index 000000000000..022619668e0e
--- /dev/null
+++ b/include/uapi/linux/vmcore.h
@@ -0,0 +1,18 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _UAPI_VMCORE_H
+#define _UAPI_VMCORE_H
+
+#include <linux/types.h>
+
+#define VMCOREDD_NOTE_NAME "LINUX"
+#define VMCOREDD_MAX_NAME_BYTES 44
+
+struct vmcoredd_header {
+        __u32 n_namesz; /* Name size */
+        __u32 n_descsz; /* Content size */
+        __u32 n_type;   /* NT_VMCOREDD */
+        __u8 name[8];   /* LINUX\0\0\0 */
+        __u8 dump_name[VMCOREDD_MAX_NAME_BYTES]; /* Device dump's name */
+};
+
+#endif /* _UAPI_VMCORE_H */