P4C
The P4 Compiler
Loading...
Searching...
No Matches
ebpfPipeline.h
1/*
2 * SPDX-FileCopyrightText: 2022 Open Networking Foundation
3 * SPDX-FileCopyrightText: 2022 Orange
4 *
5 * SPDX-License-Identifier: Apache-2.0
6 */
7#ifndef BACKENDS_EBPF_PSA_EBPFPIPELINE_H_
8#define BACKENDS_EBPF_PSA_EBPFPIPELINE_H_
9
10#include "backends/ebpf/ebpfProgram.h"
11#include "backends/ebpf/target.h"
12#include "ebpfPsaControl.h"
13#include "ebpfPsaDeparser.h"
14
15namespace P4::EBPF {
16
18class EBPFPipeline : public EBPFProgram {
19 public:
33 cstring packetPathVar, pktInstanceVar;
39 unsigned packetMark;
42
44 cstring cpumapHeadersField = "cpumap_hdr"_cs;
45 cstring cpumapUserMetadataField = "cpumap_usermeta"_cs;
46
47 EBPFControlPSA *control;
48 EBPFDeparserPSA *deparser;
49
50 EBPFPipeline(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
51 P4::TypeMap *typeMap)
52 : EBPFProgram(options, nullptr, refMap, typeMap, nullptr),
53 name(name),
54 packetMark(0x99),
55 control(nullptr),
56 deparser(nullptr) {
57 sectionName = "classifier/" + name;
58 functionName = name.replace('-', '_') + "_func";
59 errorEnum = "ParserError_t"_cs;
60 packetStartVar = "pkt"_cs;
61 headerStartVar = "hdr_start"_cs;
62 contextVar = "skb"_cs;
63 lengthVar = "pkt_len"_cs;
64 endLabel = "deparser"_cs;
65 timestampVar = "tstamp"_cs;
66 ifindexVar = "skb->ifindex"_cs;
67 compilerGlobalMetadata = "compiler_meta__"_cs;
68 packetPathVar = compilerGlobalMetadata + "->packet_path"_cs;
69 pktInstanceVar = compilerGlobalMetadata + "->instance"_cs;
70 priorityVar = "skb->priority"_cs;
71 oneKey = EBPFModel::reserved("one"_cs);
72 inputPortVar = "ebpf_input_port"_cs;
73 progTarget = new KernelSamplesTarget(options.emitTraceMessages);
74 }
75
78 bool isEmpty() const;
79
80 virtual cstring dropReturnCode() {
81 if (sectionName.startsWith("xdp")) {
82 return "XDP_DROP"_cs;
83 }
84
85 // TC is the default hookpoint
86 return "TC_ACT_SHOT"_cs;
87 }
88 virtual cstring forwardReturnCode() {
89 if (sectionName.startsWith("xdp")) {
90 return "XDP_PASS"_cs;
91 }
92
93 // TC is the default hookpoint
94 return "TC_ACT_OK"_cs;
95 }
96
97 virtual void emit(CodeBuilder *builder) = 0;
98 virtual void emitTrafficManager(CodeBuilder *builder) = 0;
99 virtual void emitPSAControlInputMetadata(CodeBuilder *builder) = 0;
100 virtual void emitPSAControlOutputMetadata(CodeBuilder *builder) = 0;
101
103 void emitLocalHeaderInstancesAsPointers(CodeBuilder *builder);
105 void emitCPUMAPHeadersInitializers(CodeBuilder *builder);
108 void emitHeaderInstances(CodeBuilder *builder) override;
110 void emitLocalVariables(CodeBuilder *builder) override;
111
114 void emitUserMetadataInstance(CodeBuilder *builder);
115
116 virtual void emitCPUMAPInitializers(CodeBuilder *builder);
117 virtual void emitCPUMAPLookup(CodeBuilder *builder);
120 virtual void emitGlobalMetadataInitializer(CodeBuilder *builder);
121
122 virtual void emitPacketLength(CodeBuilder *builder);
123 virtual void emitTimestamp(CodeBuilder *builder);
124 void emitInputPortMapping(CodeBuilder *builder);
125
126 void emitHeadersFromCPUMAP(CodeBuilder *builder);
127 void emitMetadataFromCPUMAP(CodeBuilder *builder);
128
129 bool hasAnyMeter() const {
130 auto directMeter = std::find_if(control->tables.begin(), control->tables.end(),
131 [](std::pair<const cstring, EBPFTable *> elem) {
132 return !elem.second->to<EBPFTablePSA>()->meters.empty();
133 });
134 bool anyDirectMeter = directMeter != control->tables.end();
135 return anyDirectMeter || (!control->meters.empty());
136 }
142 bool shouldEmitTimestamp() const { return hasAnyMeter() || control->timestampIsUsed; }
143
144 DECLARE_TYPEINFO(EBPFPipeline, EBPFProgram);
145};
146
149class EBPFIngressPipeline : public EBPFPipeline {
150 public:
151 unsigned int maxResubmitDepth;
155
156 EBPFIngressPipeline(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
157 P4::TypeMap *typeMap)
158 : EBPFPipeline(name, options, refMap, typeMap) {
159 // FIXME: hardcoded
160 maxResubmitDepth = 4;
161 // actUnspecCode should not collide with TC/XDP return codes,
162 // but it's safe to use the same value as TC_ACT_UNSPEC.
163 actUnspecCode = -1;
164 }
165
166 void emitSharedMetadataInitializer(CodeBuilder *builder);
167
168 void emit(CodeBuilder *builder) override;
169 void emitPSAControlInputMetadata(CodeBuilder *builder) override;
170 void emitPSAControlOutputMetadata(CodeBuilder *builder) override;
171
172 DECLARE_TYPEINFO(EBPFIngressPipeline, EBPFPipeline);
173};
174
177class EBPFEgressPipeline : public EBPFPipeline {
178 public:
179 EBPFEgressPipeline(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
180 P4::TypeMap *typeMap)
181 : EBPFPipeline(name, options, refMap, typeMap) {}
182
183 void emit(CodeBuilder *builder) override;
184 void emitPSAControlInputMetadata(CodeBuilder *builder) override;
185 void emitPSAControlOutputMetadata(CodeBuilder *builder) override;
186 void emitCPUMAPLookup(CodeBuilder *builder) override;
187
188 virtual void emitCheckPacketMarkMetadata(CodeBuilder *builder) = 0;
189
190 DECLARE_TYPEINFO(EBPFEgressPipeline, EBPFPipeline);
191};
192
193class TCIngressPipeline : public EBPFIngressPipeline {
194 public:
195 TCIngressPipeline(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
196 P4::TypeMap *typeMap)
197 : EBPFIngressPipeline(name, options, refMap, typeMap) {}
198
199 void emitGlobalMetadataInitializer(CodeBuilder *builder) override;
200 void emitTrafficManager(CodeBuilder *builder) override;
201
202 protected:
205
206 private:
207 void emitTCWorkaroundUsingMeta(CodeBuilder *builder);
208 void emitTCWorkaroundUsingHead(CodeBuilder *builder);
209 void emitTCWorkaroundUsingCPUMAP(CodeBuilder *builder);
210
211 DECLARE_TYPEINFO(TCIngressPipeline, EBPFIngressPipeline);
212};
213
214class TCEgressPipeline : public EBPFEgressPipeline {
215 public:
216 TCEgressPipeline(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
217 P4::TypeMap *typeMap)
218 : EBPFEgressPipeline(name, options, refMap, typeMap) {}
219
220 void emitTrafficManager(CodeBuilder *builder) override;
221 void emitCheckPacketMarkMetadata(CodeBuilder *builder) override;
222
223 DECLARE_TYPEINFO(TCEgressPipeline, EBPFEgressPipeline);
224};
225
226class XDPIngressPipeline : public EBPFIngressPipeline {
227 public:
228 XDPIngressPipeline(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
229 P4::TypeMap *typeMap)
230 : EBPFIngressPipeline(name, options, refMap, typeMap) {
231 sectionName = "xdp_ingress/" + name;
232 ifindexVar = "skb->ingress_ifindex"_cs;
233 packetPathVar = compilerGlobalMetadata + "->packet_path"_cs;
234 progTarget = new XdpTarget(options.emitTraceMessages);
235 }
236
237 void emitGlobalMetadataInitializer(CodeBuilder *builder) override;
238 void emitTrafficManager(CodeBuilder *builder) override;
239
240 DECLARE_TYPEINFO(XDPIngressPipeline, EBPFIngressPipeline);
241};
242
243class XDPEgressPipeline : public EBPFEgressPipeline {
244 public:
245 XDPEgressPipeline(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
246 P4::TypeMap *typeMap)
247 : EBPFEgressPipeline(name, options, refMap, typeMap) {
248 sectionName = "xdp_devmap/" + name;
249 ifindexVar = "skb->egress_ifindex"_cs;
250 // we do not support packet path, instance & priority in the XDP egress.
251 packetPathVar = "0"_cs;
252 pktInstanceVar = "0"_cs;
253 priorityVar = "0"_cs;
254 progTarget = new XdpTarget(options.emitTraceMessages);
255 }
256
257 void emitGlobalMetadataInitializer(CodeBuilder *builder) override;
258 void emitTrafficManager(CodeBuilder *builder) override;
259 void emitCheckPacketMarkMetadata(CodeBuilder *builder) override;
260
261 DECLARE_TYPEINFO(XDPEgressPipeline, EBPFEgressPipeline);
262};
263
264class TCTrafficManagerForXDP : public TCIngressPipeline {
265 public:
266 TCTrafficManagerForXDP(cstring name, const EbpfOptions &options, P4::ReferenceMap *refMap,
267 P4::TypeMap *typeMap)
268 : TCIngressPipeline(name, options, refMap, typeMap) {}
269
270 void emitGlobalMetadataInitializer(CodeBuilder *builder) override;
271 void emit(CodeBuilder *builder) override;
272
273 private:
274 void emitReadXDP2TCMetadataFromHead(CodeBuilder *builder);
275 void emitReadXDP2TCMetadataFromCPUMAP(CodeBuilder *builder);
276
277 DECLARE_TYPEINFO(TCTrafficManagerForXDP, TCIngressPipeline);
278};
279
280} // namespace P4::EBPF
281
282#endif /* BACKENDS_EBPF_PSA_EBPFPIPELINE_H_ */
Definition ebpf/codeGen.h:24
Definition ebpfPsaControl.h:53
Definition ebpfPsaDeparser.h:29
Definition ebpfPipeline.h:149
int actUnspecCode
Definition ebpfPipeline.h:154
EBPFPipeline represents a single eBPF program in the TC/XDP hook.
Definition ebpfPipeline.h:18
void emitLocalHeaderInstancesAsPointers(CodeBuilder *builder)
Generates a pointer to struct Headers_t and puts it on the BPF program's stack.
Definition ebpfPipeline.cpp:93
cstring name
A custom name of eBPF program.
Definition ebpfPipeline.h:21
void emitHeaderInstances(CodeBuilder *builder) override
Definition ebpfPipeline.cpp:105
cstring packetPathVar
Variables storing global metadata (packet_path & instance).
Definition ebpfPipeline.h:33
cstring inputPortVar
A variable to store ifindex after mapping (e.g. due to recirculation).
Definition ebpfPipeline.h:41
bool shouldEmitTimestamp() const
Definition ebpfPipeline.h:142
cstring ifindexVar
Variable storing ingress interface index.
Definition ebpfPipeline.h:29
cstring oneKey
A variable name storing "1" value. Used to access BPF array map index.
Definition ebpfPipeline.h:37
virtual void emitGlobalMetadataInitializer(CodeBuilder *builder)
Definition ebpfPipeline.cpp:142
cstring cpumapHeadersField
Fields of struct hdr_md that hold this pipeline's headers and user metadata.
Definition ebpfPipeline.h:44
void emitLocalVariables(CodeBuilder *builder) override
Generates a set of helper variables that are used during packet processing.
Definition ebpfPipeline.cpp:38
bool isEmpty() const
Definition ebpfPipeline.cpp:11
unsigned packetMark
A unique mark used to differentiate packets processed by P4/eBPF from others.
Definition ebpfPipeline.h:39
void emitCPUMAPHeadersInitializers(CodeBuilder *builder)
Generates a pointer to struct hdr_md. The pointer is used to access data from per-CPU map.
Definition ebpfPipeline.cpp:100
cstring sectionName
eBPF section name, which should a concatenation of classifier/ + a custom name.
Definition ebpfPipeline.h:23
cstring compilerGlobalMetadata
A name of an internal variable storing global metadata.
Definition ebpfPipeline.h:35
cstring timestampVar
Variable name storing current timestamp retrieved from bpf_ktime_get_ns().
Definition ebpfPipeline.h:27
cstring priorityVar
Variable storing skb->priority value (TC only).
Definition ebpfPipeline.h:31
void emitUserMetadataInstance(CodeBuilder *builder)
Definition ebpfPipeline.cpp:82
cstring contextVar
Variable name storing pointer to eBPF packet descriptor (e.g., __sk_buff).
Definition ebpfPipeline.h:25
Definition ebpfProgram.h:30
EBPFProgram(const EbpfOptions &options, const IR::P4Program *program, P4::ReferenceMap *refMap, P4::TypeMap *typeMap, const IR::ToplevelBlock *toplevel)
return 'true' on success
Definition ebpfProgram.h:56
Definition ebpf/target.h:121
void emitTrafficManager(CodeBuilder *builder) override
Definition ebpfPipeline.cpp:559
void emitGlobalMetadataInitializer(CodeBuilder *builder) override
Definition ebpfPipeline.cpp:474
void emitResetUnmarkedGlobalMetadata(CodeBuilder *builder)
Clears the global metadata of a packet that this pipeline has not marked yet.
Definition ebpfPipeline.cpp:461
void emitGlobalMetadataInitializer(CodeBuilder *builder) override
Definition ebpfPipeline.cpp:753
void emitGlobalMetadataInitializer(CodeBuilder *builder) override
Definition ebpfPipeline.cpp:709
void emitGlobalMetadataInitializer(CodeBuilder *builder) override
Definition ebpfPipeline.cpp:685
Target XDP.
Definition ebpf/target.h:240
Definition ebpfOptions.h:17
Class used to encode maps from paths to declarations.
Definition referenceMap.h:58
Definition typeMap.h:32
Definition cstring.h:76
Definition codeGen.cpp:14