pna.h

/*
Copyright (C) 2023 Intel Corporation
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions
and limitations under the License.
*/
 
#ifndef P4C_PNA_H
#define P4C_PNA_H
 
#include <stdbool.h>
#include "crc32.h"
 
// pna.p4 information
 
typedef __u32 PortId_t;
typedef __u64 Timestamp_t;
typedef __u8  ClassOfService_t;
typedef __u16 CloneSessionId_t;
typedef __u32 MulticastGroup_t;
typedef __u16 EgressInstance_t;
typedef __u8  MirrorSlotId_t;
typedef __u16 MirrorSessionId_t;
 
// Instead of using enum we define ParserError_t as __u8 to save memory.
typedef __u8 ParserError_t;
static const ParserError_t NoError = 0;          // No error.
static const ParserError_t PacketTooShort = 1;   // Not enough bits in packet for 'extract'.
static const ParserError_t NoMatch = 2;          // 'select' expression has no matches.
static const ParserError_t StackOutOfBounds = 3; // Reference to invalid element of a header stack.
static const ParserError_t HeaderTooShort = 4;   // Extracting too many bits into a varbit field.
static const ParserError_t ParserTimeout = 5;    // Parser execution time limit exceeded.
static const ParserError_t ParserInvalidArgument = 6; // Parser operation was called with a value
                                                      // not supported by the implementation
 
enum PNA_Source_t { FROM_HOST, FROM_NET };
 
enum PNA_MeterColor_t { RED, GREEN, YELLOW };
 
enum MirrorType { NO_MIRROR, PRE_MODIFY, POST_MODIFY };
 
struct pna_main_parser_input_metadata_t {
    bool                     recirculated;
    PortId_t                 input_port;    // taken from xdp_md or __sk_buff
} __attribute__((aligned(4)));
 
struct pna_main_input_metadata_t {
    // All of these values are initialized by the architecture before
    // the control block begins executing.
    bool                     recirculated;
    Timestamp_t              timestamp;         // taken from bpf helper
    ParserError_t            parser_error;      // local to parser
    ClassOfService_t         class_of_service;  // 0, set in control as global metadata
    PortId_t                 input_port;
} __attribute__((aligned(4)));;
 
struct pna_main_output_metadata_t {
    // The comment after each field specifies its initial value when the
    // control block begins executing.
    ClassOfService_t         class_of_service;
} __attribute__((aligned(4)));
 
/*
 * Opaque struct to be used to share global PNA metadata fields.
 * The size of this struct must be less than 32 bytes.
 */
struct pna_global_metadata {
    bool             recirculated;
    bool             recirculate;
    bool             drop; // NOTE : no drop field in PNA metadata, so we keep drop state as internal metadata.
    PortId_t         egress_port;
    enum MirrorType  mirror_type;
    MirrorSlotId_t   mirror_slot_id;
    ParserError_t    parser_error;
    MirrorSessionId_t mirror_session_id;
    __u8             mark;
    bool             pass_to_kernel; // internal metadata, forces sending packet up to kernel stack
} __attribute__((aligned(4)));
 
struct clone_session_entry {
    __u32 egress_port;
    __u16 instance;
    __u8  class_of_service;
    __u8  truncate;
    __u16 packet_length_bytes;
} __attribute__((aligned(4)));
 
#define send_to_port(x) (compiler_meta__->egress_port = x)
#define drop_packet() (compiler_meta__->drop = true)
 
// structures and functions for tc backend
 
struct p4tc_table_entry_act_bpf_params__local {
    u32 pipeid;
    u32 tblid;
};
 
struct __attribute__((__packed__)) p4tc_table_entry_act_bpf {
        u32 act_id;
        u32 hit:1,
        is_default_miss_act:1,
        is_default_hit_act:1;
        u8 params[124];
};
 
struct p4tc_table_entry_create_bpf_params__local {
        struct p4tc_table_entry_act_bpf act_bpf;
        u32 profile_id;
        u32 pipeid;
        u32 tblid;
        u32 handle;
        u32 chain;
        u32 classid;
        u16 proto;
        u16 prio;
};
extern struct p4tc_table_entry_act_bpf * 
bpf_p4tc_tbl_read(struct __sk_buff *skb_ctx,
                  struct p4tc_table_entry_act_bpf_params__local *params,
                  const u32 params__sz,
                  void *key, const __u32 key__sz) __ksym;
 
extern struct p4tc_table_entry_act_bpf * 
xdp_p4tc_tbl_read(struct xdp_md *skb_ctx,
                  struct p4tc_table_entry_act_bpf_params__local *params,
                  const u32 params__sz,
                  void *key, const __u32 key__sz) __ksym;
 
/* No mapping to PNA, but are useful utilities */
extern int
bpf_p4tc_entry_create(struct __sk_buff *skb_ctx,
                      struct p4tc_table_entry_create_bpf_params__local *params,
                      const u32 params__sz,
                      void *key, const u32 key__sz) __ksym;
 
extern int
xdp_p4tc_entry_create(struct xdp_md *xdp_ctx,
                      struct p4tc_table_entry_create_bpf_params__local *params,
                      const u32 params__sz,
                      void *bpf_key_mask, u32 bpf_key_mask__sz) __ksym;
 
/* Equivalent to PNA add-on-miss */
extern int
bpf_p4tc_entry_create_on_miss(struct __sk_buff *skb_ctx,
                              struct p4tc_table_entry_create_bpf_params__local *params,
                              const u32 params__sz,
                              void *key, const u32 key__sz) __ksym;
 
extern int
xdp_p4tc_entry_create_on_miss(struct xdp_md *xdp_ctx,
                              struct p4tc_table_entry_create_bpf_params__local *params,
                              const u32 params__sz,
                              void *key, const u32 key__sz) __ksym;
 
/* No mapping to PNA, but are useful utilities */
extern int
bpf_p4tc_entry_update(struct __sk_buff *skb_ctx,
              struct p4tc_table_entry_create_bpf_params__local *params,
              const u32 params__sz,
              void *key, const u32 key__sz) __ksym;
 
extern int
xdp_p4tc_entry_update(struct xdp_md *xdp_ctx,
              struct p4tc_table_entry_create_bpf_params__local *params,
              const u32 params__sz,
              void *key, const u32 key__sz) __ksym;
 
/* No mapping to PNA, but are useful utilities */
extern int
bpf_p4tc_entry_delete(struct __sk_buff *skb_ctx,
                      struct p4tc_table_entry_create_bpf_params__local *params,
                      const u32 params__sz,
                      void *key, const u32 key__sz) __ksym;
 
extern int
xdp_p4tc_entry_delete(struct xdp_md *xdp_ctx,
                      struct p4tc_table_entry_create_bpf_params__local *params,
                      const u32 params__sz,
                      void *key, const u32 key__sz) __ksym;
 
/* Start generic kfunc interface to any extern */
 
#define P4TC_EXT_CNT_DIRECT 0x1
#define P4TC_EXT_CNT_INDIRECT 0x2
#define P4TC_EXT_METER_DIRECT (1 << 2)
#define P4TC_EXT_METER_INDIRECT (1 << 3)
 
struct p4tc_ext_bpf_params {
    u32 pipe_id;
    u32 ext_id;
    u32 inst_id;
    u32 tbl_id;
    u32 index;
    u32 flags;
    u8  in_params[64]; /* extern specific params if any */
};
 
struct p4tc_ext_bpf_val {
    u32 ext_id;
    u32 index_id;
    u32 verdict;
    u8 out_params[64]; /* specific values if any */
};
 
/* Equivalent to PNA indirect counters */
extern int
bpf_p4tc_extern_count_pktsnbytes(struct __sk_buff *skb_ctx,
                 struct p4tc_ext_bpf_params *params,
                 const u32 params__sz, void *key, const u32 key__sz) __ksym;
 
extern int
bpf_p4tc_extern_count_pkts(struct __sk_buff *skb_ctx,
               struct p4tc_ext_bpf_params *params,
               const u32 params__sz, void *key, const u32 key__sz) __ksym;
 
extern int
bpf_p4tc_extern_count_bytes(struct __sk_buff *skb_ctx,
                struct p4tc_ext_bpf_params *params,
                const u32 params__sz, void *key, const u32 key__sz) __ksym;
 
extern int
xdp_p4tc_extern_count_pktsnbytes(struct xdp_md *xdp_ctx,
                 struct p4tc_ext_bpf_params *params,
                 const u32 params__sz) __ksym;
 
extern int
xdp_p4tc_extern_count_pkts(struct xdp_md *xdp_ctx,
               struct p4tc_ext_bpf_params *params,
               const u32 params__sz) __ksym;
 
extern int
xdp_p4tc_extern_count_bytes(struct xdp_md *xdp_ctx,
                struct p4tc_ext_bpf_params *params,
                const u32 params__sz) __ksym;
 
extern int bpf_p4tc_extern_meter_bytes_color(struct __sk_buff *skb_ctx,
                                             struct p4tc_ext_bpf_params *params,
                                             const u32 params__sz, void *key,
                         const u32 key__sz) __ksym;
extern int
bpf_p4tc_extern_meter_bytes(struct __sk_buff *skb,
                            struct p4tc_ext_bpf_params *params,
                            const u32 params__sz, void *key,
                            const u32 key__sz) __ksym;
 
extern int bpf_p4tc_extern_meter_pkts_color(struct __sk_buff *skb_ctx,
                                            struct p4tc_ext_bpf_params *params,
                                            const u32 params__sz, void *key,
                        const u32 key__sz) __ksym;
extern int
bpf_p4tc_extern_meter_pkts(struct __sk_buff *skb,
                           struct p4tc_ext_bpf_params *params,
                           const u32 params__sz, void *key,
                           const u32 key__sz) __ksym;
 
extern int xdp_p4tc_extern_meter_bytes_color(struct xdp_md *xdp_ctx,
                                             struct p4tc_ext_bpf_params *params,
                                             const u32 params__sz, void *key,
                                             const u32 key__sz) __ksym;
 
extern int xdp_p4tc_extern_meter_bytes(struct xdp_md *xdp_ctx,
                                       struct p4tc_ext_bpf_params *params,
                                       const u32 params__sz, void *key,
                                       const u32 key__sz) __ksym;
 
extern int xdp_p4tc_extern_meter_pkts_color(struct xdp_md *xdp_ctx,
                                            struct p4tc_ext_bpf_params *params,
                                            const u32 params__sz, void *key,
                                            const u32 key__sz) __ksym;
 
extern int xdp_p4tc_extern_meter_pkts(struct xdp_md *xdp_ctx,
                                      struct p4tc_ext_bpf_params *params,
                                      const u32 params__sz, void *key,
                                      const u32 key__sz) __ksym;
 
/* Start checksum related kfuncs */
struct p4tc_ext_csum_params {
        __wsum csum;
};
 
/* Equivalent to PNA CRC16 checksum */
/* Basic checksums are not implemented in DPDK */
extern u16
bpf_p4tc_ext_csum_crc16_add(struct p4tc_ext_csum_params *params,
                const void *data, const u32 data__sz) __ksym;
 
extern u16
bpf_p4tc_ext_csum_crc16_get(struct p4tc_ext_csum_params *params) __ksym;
 
extern void
bpf_p4tc_ext_csum_crc16_clear(struct p4tc_ext_csum_params *params) __ksym;
 
/* Equivalent to PNA CRC32 checksum */
/* Basic checksums are not implemented in DPDK */
extern u32
bpf_p4tc_ext_csum_crc32_add(struct p4tc_ext_csum_params *params,
                            const u32 params__sz,
                            const void *data, const u32 data__sz) __ksym;
 
extern u32
bpf_p4tc_ext_csum_crc32_get(struct p4tc_ext_csum_params *params,
                            const u32 params__sz) __ksym;
 
extern void
bpf_p4tc_ext_csum_crc32_clear(struct p4tc_ext_csum_params *params,
                              const u32 params__sz) __ksym;
 
extern u16
bpf_p4tc_ext_csum_16bit_complement_get(struct p4tc_ext_csum_params *params,
                                       const u32 params__sz) __ksym;
 
/* Equivalent to PNA 16bit complement checksum (incremental checksum) */
extern __wsum
bpf_p4tc_ext_csum_16bit_complement_add(struct p4tc_ext_csum_params *params,
                                       const u32 params__sz,
                                       const void *data, int len) __ksym;
 
extern int
bpf_p4tc_ext_csum_16bit_complement_sub(struct p4tc_ext_csum_params *params,
                                       const u32 params__sz,
                                       const void *data, const u32 data__sz) __ksym;
 
extern void
bpf_p4tc_ext_csum_16bit_complement_clear(struct p4tc_ext_csum_params *params,
                                         const u32 params__sz) __ksym;
 
extern void
bpf_p4tc_ext_csum_16bit_complement_set_state(struct p4tc_ext_csum_params *params,
                                             const u32 params__sz,
                                             u16 csum) __ksym;
 
/* Equivalent to PNA crc16 hash */
extern u16
bpf_p4tc_ext_hash_crc16(const void *data, int len, u16 seed) __ksym;
 
/* Equivalent to PNA crc16 hash base */
static inline u16
bpf_p4tc_ext_hash_base_crc16(const void *data, const u32 data__sz,
                 u32 base, u32 max, u16 seed) {
    u16 hash = bpf_p4tc_ext_hash_crc16(data, data__sz, seed);
 
    return (base + (hash % max));
}
 
/* Equivalent to PNA crc32 hash */
extern u32
bpf_p4tc_ext_hash_crc32(const void *data, const u32 data__sz, u32 seed) __ksym;
 
/* Equivalent to PNA crc32 hash base */
static inline u32
bpf_p4tc_ext_hash_base_crc32(const void *data, const u32 data__sz,
                 u32 base, u32 max, u32 seed) {
    u32 hash = bpf_p4tc_ext_hash_crc32(data, data__sz, seed);
 
    return (base + (hash % max));
}
 
/* Equivalent to PNA 16-bit ones complement hash */
extern u16
bpf_p4tc_ext_hash_16bit_complement(const void *data, const u32 data__sz,
                   u16 seed) __ksym;
 
/* Equivalent to PNA 16-bit ones complement hash base */
static inline u16
bpf_p4tc_ext_hash_base_16bit_complement(const void *data, const u32 data__sz,
                    u32 base, u32 max, u16 seed) {
    u16 hash = bpf_p4tc_ext_hash_16bit_complement(data, data__sz, seed);
 
    return (base + (hash % max));
}
 
/* DPDK doesn't implement this yet */
/* Equivalent to PNA is_net_port */
extern bool
bpf_p4tc_is_net_port(struct __sk_buff *skb_ctx, const u32 ifindex) __ksym;
 
/* DPDK doesn't implement this yet */
/* Equivalent to PNA is_host_port */
extern bool
bpf_p4tc_is_host_port(struct __sk_buff *skb_ctx, const u32 ifindex) __ksym;
 
/* DPDK doesn't implement this yet */
/* Equivalent to PNA is_net_port */
extern bool
xdp_p4tc_is_net_port(struct xdp_md *xdp_ctx, const u32 ifindex) __ksym;
 
/* DPDK doesn't implement this yet */
/* Equivalent to PNA is_host_port */
extern bool
xdp_p4tc_is_host_port(struct xdp_md *xdp_ctx, const u32 ifindex) __ksym;
 
 
/* per extern specifics start */
 
/* in this case it is PNA so  we have these helpers like below
   "is_net_port_skb" but for user specific externs the caller should
    be doing similar flow:
    a) populating p4tc_ext_bpf_params struct with their proper
    parametrization  of pipeline id, extern id, and extern specific params
    b) receiving a response and retrieving their extern-specific data/return
    codes from res->params
*/
 
#define EXTERN_IS_NET_PORT 1234
#define EXTERN_IS_HOST_PORT 4567
 
/* Extern control path read (for example, used for register read) */
extern struct p4tc_ext_bpf_val *
bpf_p4tc_extern_md_read(struct __sk_buff *skb_ctx,
            struct p4tc_ext_bpf_params *params,
            const u32 params__sz) __ksym;
 
/* Extern control path write (for example, used for register write) */
extern int bpf_p4tc_extern_md_write(struct __sk_buff *skb_ctx,
                    struct p4tc_ext_bpf_params *params,
                    const u32 params__sz,
                    struct p4tc_ext_bpf_val *val,
                    const u32 val__sz) __ksym;
 
/* Extern control path read (for example, used for register read) for XDP */
extern struct p4tc_ext_bpf_val *
xdp_p4tc_extern_md_read(struct xdp_md *xdp_ctx,
            struct p4tc_ext_bpf_params *params,
            const u32 params__sz) __ksym;
 
/* Extern control path read (for example, used for register write for XDP */
extern int xdp_p4tc_extern_md_write(struct xdp_md *xdp_ctx,
                    struct p4tc_ext_bpf_params *params,
                    const u32 params__sz,
                    struct p4tc_ext_bpf_val *val,
                    const u32 val__sz) __ksym;
 
int bpf_p4tc_extern_digest_pack(struct __sk_buff *skb,
                struct p4tc_ext_bpf_params *params,
                const u32 params__sz) __ksym;
 
int xdp_p4tc_extern_digest_pack(struct xdp_md *xdp_ctx,
                struct p4tc_ext_bpf_params *params,
                const u32 params__sz) __ksym;
 
/* Timestamp  PNA extern */
static inline u64 bpf_p4tc_extern_timestamp() {
    return bpf_ktime_get_ns();
}
 
#define U32_MAX            ((u32)~0U)
 
/* Random PNA extern */
static inline u32 bpf_p4tc_extern_random(u32 min, u32 max) {
    if (max == U32_MAX)
        return (min + bpf_get_prandom_u32());
 
    return (min + bpf_get_prandom_u32()) % (max + 1);
}
 
#define BIT(x) (1 << x)
 
#define P4TC_SKB_META_SET_TSTAMP BIT(0)
#define P4TC_SKB_META_SET_MARK BIT(1)
#define P4TC_SKB_META_SET_CLASSID BIT(2)
#define P4TC_SKB_META_SET_TC_INDEX BIT(3)
#define P4TC_SKB_META_SET_QMAP BIT(4)
#define P4TC_SKB_META_SET_PROTO BIT(5)
 
struct p4tc_skb_meta_set {
        __u64 tstamp;
        __u32 mark;
        __u16 tc_classid;
        __u16 tc_index;
        __u16 queue_mapping;
        __be16 protocol;
        __u32 bitmask;
};
 
static inline void
bpf_p4tc_skb_set_tstamp(struct __sk_buff *skb,
                       struct p4tc_skb_meta_set *meta_set, __u64 tstamp)
{
       meta_set->tstamp = tstamp;
       meta_set->bitmask |= P4TC_SKB_META_SET_TSTAMP;
}
 
static inline void
bpf_p4tc_skb_set_mark(struct __sk_buff *skb,
                     struct p4tc_skb_meta_set *meta_set, __u32 mark)
{
       meta_set->mark = mark;
       meta_set->bitmask |= P4TC_SKB_META_SET_MARK;
}
 
static inline void
bpf_p4tc_skb_set_tc_classid(struct __sk_buff *skb,
                            struct p4tc_skb_meta_set *meta_set, __u32 tc_classid)
{
       meta_set->tc_classid = tc_classid;
       meta_set->bitmask |= P4TC_SKB_META_SET_CLASSID;
}
 
static inline void
bpf_p4tc_skb_set_tc_index(struct __sk_buff *skb,
                          struct p4tc_skb_meta_set *meta_set, __u16 tc_index)
{
       meta_set->tc_index = tc_index;
       meta_set->bitmask |= P4TC_SKB_META_SET_TC_INDEX;
}
 
static inline void
bpf_p4tc_skb_set_queue_mapping(struct __sk_buff *skb,
                               struct p4tc_skb_meta_set *meta_set,
                               __u16 queue_mapping)
{
       meta_set->queue_mapping = queue_mapping;
       meta_set->bitmask |= P4TC_SKB_META_SET_QMAP;
}
 
static inline void
bpf_p4tc_skb_set_protocol(struct __sk_buff *skb,
                          struct p4tc_skb_meta_set *meta_set, __be16 protocol)
{
       meta_set->protocol = protocol;
       meta_set->bitmask |= P4TC_SKB_META_SET_PROTO;
}
 
int bpf_p4tc_skb_meta_set(struct __sk_buff *skb,
                          struct p4tc_skb_meta_set *skb_meta_set,
                          u32 skb_meta_set__sz) __ksym;
 
#define P4TC_SKB_META_GET_AT_INGRESS_BIT BIT(0)
#define P4TC_SKB_META_GET_FROM_INGRESS_BIT BIT(1)
 
struct p4tc_skb_meta_get {
       u8 tc_at_ingress:1,
          from_ingress:1;
       u8 bitmask;
};
 
static inline __u64
bpf_p4tc_skb_get_tstamp(struct __sk_buff *skb,
                        struct p4tc_skb_meta_get *meta_get)
{
       return skb->tstamp;
}
 
static inline __u16
bpf_p4tc_skb_get_tc_classid(struct __sk_buff *skb,
                            struct p4tc_skb_meta_get *meta_get)
{
       return skb->tc_classid;
}
 
static inline __u16
bpf_p4tc_skb_get_tc_index(struct __sk_buff *skb,
                          struct p4tc_skb_meta_get *meta_get)
{
       return skb->tc_index;
}
 
static inline __u16
bpf_p4tc_skb_get_queue_mapping(struct __sk_buff *skb,
                               struct p4tc_skb_meta_get *meta_get)
{
       return skb->queue_mapping;
}
 
static inline __be16
bpf_p4tc_skb_get_protocol(struct __sk_buff *skb,
                          struct p4tc_skb_meta_get *meta_get)
{
       return skb->protocol;
}
 
static inline int
bpf_p4tc_skb_get_tc_at_ingress(struct __sk_buff *skb,
                               struct p4tc_skb_meta_get *meta_get)
{
       if (meta_get->bitmask & P4TC_SKB_META_GET_AT_INGRESS_BIT)
               return meta_get->tc_at_ingress;
 
       return -1;
}
 
static inline int
bpf_p4tc_skb_get_from_ingress(struct __sk_buff *skb,
                              struct p4tc_skb_meta_get *meta_get)
{
       if (meta_get->bitmask & P4TC_SKB_META_GET_FROM_INGRESS_BIT)
               return meta_get->from_ingress;
 
       return -1;
}
 
static inline __u32
bpf_p4tc_skb_get_mark(struct __sk_buff *skb,
                      struct p4tc_skb_meta_get *meta_get)
{
       return skb->mark;
}
 
int bpf_p4tc_skb_meta_get(struct __sk_buff *skb,
                          struct p4tc_skb_meta_get *skb_meta_get,
                          u32 skb_meta_get__sz) __ksym;
 
#endif /* P4C_PNA_H */