ebpfPsaGen.h

/*
 * SPDX-FileCopyrightText: 2022 Open Networking Foundation
 * SPDX-FileCopyrightText: 2022 Orange
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef BACKENDS_EBPF_PSA_EBPFPSAGEN_H_
#define BACKENDS_EBPF_PSA_EBPFPSAGEN_H_
 
#include "backends/ebpf/codeGen.h"
#include "backends/ebpf/ebpfObject.h"
#include "backends/ebpf/ebpfOptions.h"
#include "ebpfPipeline.h"
#include "ebpfPsaParser.h"
#include "xdpHelpProgram.h"
 
namespace P4::EBPF {
 
enum pipeline_type { TC_INGRESS, TC_EGRESS, XDP_INGRESS, XDP_EGRESS, TC_TRAFFIC_MANAGER };
 
class EbpfCodeGenerator {
 public:
    const EbpfOptions &options;
    std::vector<EBPF::EBPFType *> ebpfTypes;
 
    EbpfCodeGenerator(const EbpfOptions &options, std::vector<EBPF::EBPFType *> &ebpfTypes)
        : options(options), ebpfTypes(ebpfTypes) {}
 
    virtual void emitCommonPreamble(EBPF::CodeBuilder *builder) const = 0;
    virtual void emitPreamble(CodeBuilder *builder) const = 0;
    virtual void emitInternalStructures(EBPF::CodeBuilder *pBuilder) const = 0;
    virtual void emitTypes(EBPF::CodeBuilder *builder) const = 0;
    virtual void emitGlobalHeadersMetadata(EBPF::CodeBuilder *builder) const = 0;
    virtual void emitPipelineInstances(EBPF::CodeBuilder *builder) const = 0;
};
 
class PSAEbpfGenerator : public EbpfCodeGenerator {
 public:
    static constexpr unsigned MaxClones = 64;
    static constexpr unsigned MaxCloneSessions = 1024;
 
    EBPFPipeline *ingress;
    EBPFPipeline *egress;
 
    PSAEbpfGenerator(const EbpfOptions &options, std::vector<EBPFType *> &ebpfTypes,
                     EBPFPipeline *ingress, EBPFPipeline *egress)
        : EbpfCodeGenerator(options, ebpfTypes), ingress(ingress), egress(egress) {}
 
    virtual void emit(CodeBuilder *builder) const = 0;
    virtual void emitInstances(EBPF::CodeBuilder *builder) const = 0;
 
    void emitPSAIncludes(CodeBuilder *builder) const;
    void emitPreamble(CodeBuilder *builder) const override;
    void emitCommonPreamble(CodeBuilder *builder) const override;
    void emitInternalStructures(CodeBuilder *pBuilder) const override;
    void emitTypes(CodeBuilder *builder) const override;
    void emitGlobalHeadersMetadata(CodeBuilder *builder) const override;
    void emitPacketReplicationTables(CodeBuilder *builder) const;
    void emitPipelineInstances(CodeBuilder *builder) const override;
    void emitInitializer(CodeBuilder *builder) const;
    virtual void emitInitializerSection(CodeBuilder *builder) const = 0;
    void emitHelperFunctions(CodeBuilder *builder) const;

    void emitCRC32LookupTableTypes(CodeBuilder *builder) const;
    void emitCRC32LookupTableInitializer(CodeBuilder *builder) const;
    void emitCRC32LookupTableInstance(CodeBuilder *builder) const;
};
 
class PSAArchTC : public PSAEbpfGenerator {
 public:
    XDPHelpProgram *xdp;
 
    PSAArchTC(const EbpfOptions &options, std::vector<EBPFType *> &ebpfTypes, XDPHelpProgram *xdp,
              EBPFPipeline *tcIngress, EBPFPipeline *tcEgress)
        : PSAEbpfGenerator(options, ebpfTypes, tcIngress, tcEgress), xdp(xdp) {}
 
    void emit(CodeBuilder *builder) const override;
 
    void emitInstances(CodeBuilder *builder) const override;
    void emitInitializerSection(CodeBuilder *builder) const override;
};
 
class PSAArchXDP : public PSAEbpfGenerator {
 public:
    EBPFPipeline *tcIngressForXDP;
    EBPFPipeline *tcEgressForXDP;
    static constexpr unsigned egressDevmapSize = 256;
 
    PSAArchXDP(const EbpfOptions &options, std::vector<EBPFType *> &ebpfTypes,
               EBPFPipeline *xdpIngress, EBPFPipeline *xdpEgress, EBPFPipeline *tcTrafficManager,
               EBPFPipeline *tcEgress)
        : PSAEbpfGenerator(options, ebpfTypes, xdpIngress, xdpEgress),
          tcIngressForXDP(tcTrafficManager),
          tcEgressForXDP(tcEgress) {}
 
    void emit(CodeBuilder *builder) const override;
 
    void emitPreamble(CodeBuilder *builder) const override;
    void emitInstances(CodeBuilder *builder) const override;
    void emitInitializerSection(CodeBuilder *builder) const override;
 
    void emitXDP2TCInternalStructures(CodeBuilder *builder) const;
    void emitDummyProgram(CodeBuilder *builder) const;
};
 
class ConvertToEbpfPSA : public Transform {
    const EbpfOptions &options;
    P4::TypeMap *typemap;
    P4::ReferenceMap *refmap;
    const PSAEbpfGenerator *ebpf_psa_arch;
 
 public:
    ConvertToEbpfPSA(const EbpfOptions &options, P4::ReferenceMap *refmap, P4::TypeMap *typemap)
        : options(options), typemap(typemap), refmap(refmap), ebpf_psa_arch(nullptr) {}
 
    const PSAEbpfGenerator *build(const IR::ToplevelBlock *prog);
    const IR::Node *preorder(IR::ToplevelBlock *p) override;
 
    const PSAEbpfGenerator *getPSAArchForEBPF() { return ebpf_psa_arch; }
};
 
class ConvertToEbpfPipeline : public Inspector {
    const cstring name;
    const pipeline_type type;
    const EbpfOptions &options;
    const IR::ParserBlock *parserBlock;
    const IR::ControlBlock *controlBlock;
    const IR::ControlBlock *deparserBlock;
    P4::TypeMap *typemap;
    P4::ReferenceMap *refmap;
    EBPFPipeline *pipeline;
 
 public:
    ConvertToEbpfPipeline(cstring name, pipeline_type type, const EbpfOptions &options,
                          const IR::ParserBlock *parserBlock, const IR::ControlBlock *controlBlock,
                          const IR::ControlBlock *deparserBlock, P4::ReferenceMap *refmap,
                          P4::TypeMap *typemap)
        : name(name),
          type(type),
          options(options),
          parserBlock(parserBlock),
          controlBlock(controlBlock),
          deparserBlock(deparserBlock),
          typemap(typemap),
          refmap(refmap),
          pipeline(nullptr) {}
 
    bool preorder(const IR::PackageBlock *block) override;
    EBPFPipeline *getEbpfPipeline() { return pipeline; }
};
 
class ConvertToEBPFParserPSA : public Inspector {
    EBPF::EBPFProgram *program;
    pipeline_type type;
 
    P4::TypeMap *typemap;
    EBPF::EBPFPsaParser *parser;
 
 public:
    ConvertToEBPFParserPSA(EBPF::EBPFProgram *program, P4::TypeMap *typemap, pipeline_type type)
        : program(program), type(type), typemap(typemap), parser(nullptr) {}
 
    bool preorder(const IR::ParserBlock *prsr) override;
    bool preorder(const IR::P4ValueSet *pvs) override;
    EBPF::EBPFParser *getEBPFParser() { return parser; }
};
 
class ConvertToEBPFControlPSA : public Inspector {
    EBPF::EBPFProgram *program;
    pipeline_type type;
    EBPF::EBPFControlPSA *control;
 
    const IR::Parameter *parserHeaders;
    P4::ReferenceMap *refmap;
 
 public:
    ConvertToEBPFControlPSA(EBPF::EBPFProgram *program, const IR::Parameter *parserHeaders,
                            P4::ReferenceMap *refmap, pipeline_type type)
        : program(program),
          type(type),
          control(nullptr),
          parserHeaders(parserHeaders),
          refmap(refmap) {}
 
    bool preorder(const IR::TableBlock *) override;
    bool preorder(const IR::ControlBlock *) override;
    bool preorder(const IR::Declaration_Variable *) override;
    bool preorder(const IR::Member *m) override;
    bool preorder(const IR::IfStatement *a) override;
    bool preorder(const IR::ExternBlock *instance) override;
 
    EBPF::EBPFControlPSA *getEBPFControl() { return control; }
};
 
class ConvertToEBPFDeparserPSA : public Inspector {
    EBPF::EBPFProgram *program;
    pipeline_type pipelineType;
 
    const IR::Parameter *parserHeaders;
    const IR::Parameter *istd;
    EBPF::EBPFDeparserPSA *deparser;
 
 public:
    ConvertToEBPFDeparserPSA(EBPFProgram *program, const IR::Parameter *parserHeaders,
                             const IR::Parameter *istd, pipeline_type type)
        : program(program),
          pipelineType(type),
          parserHeaders(parserHeaders),
          istd(istd),
          deparser(nullptr) {}
 
    bool preorder(const IR::ControlBlock *) override;
    bool preorder(const IR::Declaration_Instance *) override;
    EBPF::EBPFDeparserPSA *getEBPFDeparser() { return deparser; }
};
 
}  // namespace P4::EBPF
 
#endif /* BACKENDS_EBPF_PSA_EBPFPSAGEN_H_ */