ebpfPipeline.h

/*
Copyright 2022-present Orange
Copyright 2022-present Open Networking Foundation
 
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 BACKENDS_EBPF_PSA_EBPFPIPELINE_H_
#define BACKENDS_EBPF_PSA_EBPFPIPELINE_H_
 
#include "backends/ebpf/ebpfProgram.h"
#include "backends/ebpf/target.h"
#include "ebpfPsaControl.h"
#include "ebpfPsaDeparser.h"
 
namespace P4::EBPF {
 
class EBPFPipeline : public EBPFProgram {
 public:
    cstring name;
    cstring sectionName;
    cstring contextVar;
    cstring timestampVar;
    cstring ifindexVar;
    cstring priorityVar;
    cstring packetPathVar, pktInstanceVar;
    cstring compilerGlobalMetadata;
    cstring oneKey;
    unsigned packetMark;
    cstring inputPortVar;
 
    EBPFControlPSA *control;
    EBPFDeparserPSA *deparser;
 
    EBPFPipeline(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
                 P4::TypeMap *typeMap)
        : EBPFProgram(options, nullptr, refMap, typeMap, nullptr),
          name(name),
          packetMark(0x99),
          control(nullptr),
          deparser(nullptr) {
        sectionName = "classifier/" + name;
        functionName = name.replace('-', '_') + "_func";
        errorEnum = "ParserError_t"_cs;
        packetStartVar = "pkt"_cs;
        headerStartVar = "hdr_start"_cs;
        contextVar = "skb"_cs;
        lengthVar = "pkt_len"_cs;
        endLabel = "deparser"_cs;
        timestampVar = "tstamp"_cs;
        ifindexVar = "skb->ifindex"_cs;
        compilerGlobalMetadata = "compiler_meta__"_cs;
        packetPathVar = compilerGlobalMetadata + "->packet_path"_cs;
        pktInstanceVar = compilerGlobalMetadata + "->instance"_cs;
        priorityVar = "skb->priority"_cs;
        oneKey = EBPFModel::reserved("one"_cs);
        inputPortVar = "ebpf_input_port"_cs;
        progTarget = new KernelSamplesTarget(options.emitTraceMessages);
    }
 
    bool isEmpty() const;
 
    virtual cstring dropReturnCode() {
        if (sectionName.startsWith("xdp")) {
            return "XDP_DROP"_cs;
        }
 
        // TC is the default hookpoint
        return "TC_ACT_SHOT"_cs;
    }
    virtual cstring forwardReturnCode() {
        if (sectionName.startsWith("xdp")) {
            return "XDP_PASS"_cs;
        }
 
        // TC is the default hookpoint
        return "TC_ACT_OK"_cs;
    }
 
    virtual void emit(CodeBuilder *builder) = 0;
    virtual void emitTrafficManager(CodeBuilder *builder) = 0;
    virtual void emitPSAControlInputMetadata(CodeBuilder *builder) = 0;
    virtual void emitPSAControlOutputMetadata(CodeBuilder *builder) = 0;
 
    void emitLocalHeaderInstancesAsPointers(CodeBuilder *builder);
    void emitCPUMAPHeadersInitializers(CodeBuilder *builder);
    void emitHeaderInstances(CodeBuilder *builder) override;
    void emitLocalVariables(CodeBuilder *builder) override;
 
    void emitUserMetadataInstance(CodeBuilder *builder);
 
    virtual void emitCPUMAPInitializers(CodeBuilder *builder);
    virtual void emitCPUMAPLookup(CodeBuilder *builder);
    virtual void emitGlobalMetadataInitializer(CodeBuilder *builder);
 
    virtual void emitPacketLength(CodeBuilder *builder);
    virtual void emitTimestamp(CodeBuilder *builder);
    void emitInputPortMapping(CodeBuilder *builder);
 
    void emitHeadersFromCPUMAP(CodeBuilder *builder);
    void emitMetadataFromCPUMAP(CodeBuilder *builder);
 
    bool hasAnyMeter() const {
        auto directMeter = std::find_if(control->tables.begin(), control->tables.end(),
                                        [](std::pair<const cstring, EBPFTable *> elem) {
                                            return !elem.second->to<EBPFTablePSA>()->meters.empty();
                                        });
        bool anyDirectMeter = directMeter != control->tables.end();
        return anyDirectMeter || (!control->meters.empty());
    }
    bool shouldEmitTimestamp() const { return hasAnyMeter() || control->timestampIsUsed; }
 
    DECLARE_TYPEINFO(EBPFPipeline, EBPFProgram);
};
 
class EBPFIngressPipeline : public EBPFPipeline {
 public:
    unsigned int maxResubmitDepth;
    int actUnspecCode;
 
    EBPFIngressPipeline(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
                        P4::TypeMap *typeMap)
        : EBPFPipeline(name, options, refMap, typeMap) {
        // FIXME: hardcoded
        maxResubmitDepth = 4;
        // actUnspecCode should not collide with TC/XDP return codes,
        // but it's safe to use the same value as TC_ACT_UNSPEC.
        actUnspecCode = -1;
    }
 
    void emitSharedMetadataInitializer(CodeBuilder *builder);
 
    void emit(CodeBuilder *builder) override;
    void emitPSAControlInputMetadata(CodeBuilder *builder) override;
    void emitPSAControlOutputMetadata(CodeBuilder *builder) override;
 
    DECLARE_TYPEINFO(EBPFIngressPipeline, EBPFPipeline);
};
 
class EBPFEgressPipeline : public EBPFPipeline {
 public:
    EBPFEgressPipeline(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
                       P4::TypeMap *typeMap)
        : EBPFPipeline(name, options, refMap, typeMap) {}
 
    void emit(CodeBuilder *builder) override;
    void emitPSAControlInputMetadata(CodeBuilder *builder) override;
    void emitPSAControlOutputMetadata(CodeBuilder *builder) override;
    void emitCPUMAPLookup(CodeBuilder *builder) override;
 
    virtual void emitCheckPacketMarkMetadata(CodeBuilder *builder) = 0;
 
    DECLARE_TYPEINFO(EBPFEgressPipeline, EBPFPipeline);
};
 
class TCIngressPipeline : public EBPFIngressPipeline {
 public:
    TCIngressPipeline(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
                      P4::TypeMap *typeMap)
        : EBPFIngressPipeline(name, options, refMap, typeMap) {}
 
    void emitGlobalMetadataInitializer(CodeBuilder *builder) override;
    void emitTrafficManager(CodeBuilder *builder) override;
 
 private:
    void emitTCWorkaroundUsingMeta(CodeBuilder *builder);
    void emitTCWorkaroundUsingHead(CodeBuilder *builder);
    void emitTCWorkaroundUsingCPUMAP(CodeBuilder *builder);
 
    DECLARE_TYPEINFO(TCIngressPipeline, EBPFIngressPipeline);
};
 
class TCEgressPipeline : public EBPFEgressPipeline {
 public:
    TCEgressPipeline(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
                     P4::TypeMap *typeMap)
        : EBPFEgressPipeline(name, options, refMap, typeMap) {}
 
    void emitTrafficManager(CodeBuilder *builder) override;
    void emitCheckPacketMarkMetadata(CodeBuilder *builder) override;
 
    DECLARE_TYPEINFO(TCEgressPipeline, EBPFEgressPipeline);
};
 
class XDPIngressPipeline : public EBPFIngressPipeline {
 public:
    XDPIngressPipeline(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
                       P4::TypeMap *typeMap)
        : EBPFIngressPipeline(name, options, refMap, typeMap) {
        sectionName = "xdp_ingress/" + name;
        ifindexVar = "skb->ingress_ifindex"_cs;
        packetPathVar = compilerGlobalMetadata + "->packet_path"_cs;
        progTarget = new XdpTarget(options.emitTraceMessages);
    }
 
    void emitGlobalMetadataInitializer(CodeBuilder *builder) override;
    void emitTrafficManager(CodeBuilder *builder) override;
 
    DECLARE_TYPEINFO(XDPIngressPipeline, EBPFIngressPipeline);
};
 
class XDPEgressPipeline : public EBPFEgressPipeline {
 public:
    XDPEgressPipeline(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
                      P4::TypeMap *typeMap)
        : EBPFEgressPipeline(name, options, refMap, typeMap) {
        sectionName = "xdp_devmap/" + name;
        ifindexVar = "skb->egress_ifindex"_cs;
        // we do not support packet path, instance & priority in the XDP egress.
        packetPathVar = "0"_cs;
        pktInstanceVar = "0"_cs;
        priorityVar = "0"_cs;
        progTarget = new XdpTarget(options.emitTraceMessages);
    }
 
    void emitGlobalMetadataInitializer(CodeBuilder *builder) override;
    void emitTrafficManager(CodeBuilder *builder) override;
    void emitCheckPacketMarkMetadata(CodeBuilder *builder) override;
 
    DECLARE_TYPEINFO(XDPEgressPipeline, EBPFEgressPipeline);
};
 
class TCTrafficManagerForXDP : public TCIngressPipeline {
 public:
    TCTrafficManagerForXDP(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
                           P4::TypeMap *typeMap)
        : TCIngressPipeline(name, options, refMap, typeMap) {}
 
    void emitGlobalMetadataInitializer(CodeBuilder *builder) override;
    void emit(CodeBuilder *builder) override;
 
 private:
    void emitReadXDP2TCMetadataFromHead(CodeBuilder *builder);
    void emitReadXDP2TCMetadataFromCPUMAP(CodeBuilder *builder);
 
    DECLARE_TYPEINFO(TCTrafficManagerForXDP, TCIngressPipeline);
};
 
}  // namespace P4::EBPF
 
#endif /* BACKENDS_EBPF_PSA_EBPFPIPELINE_H_ */