bpf: Add IPv6 Segment Routing helpers

The BPF seg6local hook should be powerful enough to enable users to
implement most of the use-cases one could think of. After some thinking,
we figured out that the following actions should be possible on a SRv6
packet, requiring 3 specific helpers :
    - bpf_lwt_seg6_store_bytes: Modify non-sensitive fields of the SRH
    - bpf_lwt_seg6_adjust_srh: Allow to grow or shrink a SRH
                               (to add/delete TLVs)
    - bpf_lwt_seg6_action: Apply some SRv6 network programming actions
                           (specifically End.X, End.T, End.B6 and
                            End.B6.Encap)

The specifications of these helpers are provided in the patch (see
include/uapi/linux/bpf.h).

The non-sensitive fields of the SRH are the following : flags, tag and
TLVs. The other fields can not be modified, to maintain the SRH
integrity. Flags, tag and TLVs can easily be modified as their validity
can be checked afterwards via seg6_validate_srh. It is not allowed to
modify the segments directly. If one wants to add segments on the path,
he should stack a new SRH using the End.B6 action via
bpf_lwt_seg6_action.

Growing, shrinking or editing TLVs via the helpers will flag the SRH as
invalid, and it will have to be re-validated before re-entering the IPv6
layer. This flag is stored in a per-CPU buffer, along with the current
header length in bytes.

Storing the SRH len in bytes in the control block is mandatory when using
bpf_lwt_seg6_adjust_srh. The Header Ext. Length field contains the SRH
len rounded to 8 bytes (a padding TLV can be inserted to ensure the 8-bytes
boundary). When adding/deleting TLVs within the BPF program, the SRH may
temporary be in an invalid state where its length cannot be rounded to 8
bytes without remainder, hence the need to store the length in bytes
separately. The caller of the BPF program can then ensure that the SRH's
final length is valid using this value. Again, a final SRH modified by a
BPF program which doesn’t respect the 8-bytes boundary will be discarded
as it will be considered as invalid.

Finally, a fourth helper is provided, bpf_lwt_push_encap, which is
available from the LWT BPF IN hook, but not from the seg6local BPF one.
This helper allows to encapsulate a Segment Routing Header (either with
a new outer IPv6 header, or by inlining it directly in the existing IPv6
header) into a non-SRv6 packet. This helper is required if we want to
offer the possibility to dynamically encapsulate a SRH for non-SRv6 packet,
as the BPF seg6local hook only works on traffic already containing a SRH.
This is the BPF equivalent of the seg6 LWT infrastructure, which achieves
the same purpose but with a static SRH per route.

These helpers require CONFIG_IPV6=y (and not =m).

Signed-off-by: Mathieu Xhonneux <m.xhonneux@gmail.com>
Acked-by: David Lebrun <dlebrun@google.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>

1 files changed, 95 insertions, 1 deletions

diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h
index 344d2ddcef49..fdaf6a0bfa5b 100644
--- a/include/uapi/linux/bpf.h
+++ b/include/uapi/linux/bpf.h
@@ -1902,6 +1902,90 @@ union bpf_attr {
  *              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.
  */
 #define __BPF_FUNC_MAPPER(FN)           \
         FN(unspec),                     \
@@ -1976,7 +2060,11 @@ union bpf_attr {
         FN(fib_lookup),                 \
         FN(sock_hash_update),           \
         FN(msg_redirect_hash),          \
-        FN(sk_redirect_hash),
+        FN(sk_redirect_hash),           \
+        FN(lwt_push_encap),             \
+        FN(lwt_seg6_store_bytes),       \
+        FN(lwt_seg6_adjust_srh),        \
+        FN(lwt_seg6_action),
 
 /* integer value in 'imm' field of BPF_CALL instruction selects which helper
  * function eBPF program intends to call
@@ -2043,6 +2131,12 @@ enum bpf_hdr_start_off {
         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
  */