Coverage Report

Created: 2026-11-20 08:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/hw/net/rocker/rocker_of_dpa.c
Line
Count
Source
1
/*
2
 * QEMU rocker switch emulation - OF-DPA flow processing support
3
 *
4
 * Copyright (c) 2014 Scott Feldman <sfeldma@gmail.com>
5
 *
6
 * This program is free software; you can redistribute it and/or modify
7
 * it under the terms of the GNU General Public License as published by
8
 * the Free Software Foundation; either version 2 of the License, or
9
 * (at your option) any later version.
10
 *
11
 * This program is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
 * GNU General Public License for more details.
15
 */
16
17
#include "qemu/osdep.h"
18
#include "net/eth.h"
19
#include "qapi/error.h"
20
#include "qapi/qapi-commands-rocker.h"
21
#include "qemu/iov.h"
22
#include "qemu/timer.h"
23
24
#include "rocker.h"
25
#include "rocker_hw.h"
26
#include "rocker_fp.h"
27
#include "rocker_tlv.h"
28
#include "rocker_world.h"
29
#include "rocker_desc.h"
30
#include "rocker_of_dpa.h"
31
32
static const MACAddr zero_mac = { .a = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } };
33
static const MACAddr ff_mac =   { .a = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } };
34
35
typedef struct of_dpa {
36
    World *world;
37
    GHashTable *flow_tbl;
38
    GHashTable *group_tbl;
39
    unsigned int flow_tbl_max_size;
40
    unsigned int group_tbl_max_size;
41
} OfDpa;
42
43
/* flow_key stolen mostly from OVS
44
 *
45
 * Note: fields that compare with network packet header fields
46
 * are stored in network order (BE) to avoid per-packet field
47
 * byte-swaps.
48
 */
49
50
typedef struct of_dpa_flow_key {
51
    uint32_t in_pport;               /* ingress port */
52
    uint32_t tunnel_id;              /* overlay tunnel id */
53
    uint32_t tbl_id;                 /* table id */
54
    struct {
55
        uint16_t vlan_id;              /* 0 if no VLAN */
56
        MACAddr src;                 /* ethernet source address */
57
        MACAddr dst;                 /* ethernet destination address */
58
        uint16_t type;                 /* ethernet frame type */
59
    } eth;
60
    struct {
61
        uint8_t proto;               /* IP protocol or ARP opcode */
62
        uint8_t tos;                 /* IP ToS */
63
        uint8_t ttl;                 /* IP TTL/hop limit */
64
        uint8_t frag;                /* one of FRAG_TYPE_* */
65
    } ip;
66
    union {
67
        struct {
68
            struct {
69
                uint32_t src;          /* IP source address */
70
                uint32_t dst;          /* IP destination address */
71
            } addr;
72
            union {
73
                struct {
74
                    uint16_t src;      /* TCP/UDP/SCTP source port */
75
                    uint16_t dst;      /* TCP/UDP/SCTP destination port */
76
                    uint16_t flags;    /* TCP flags */
77
                } tp;
78
                struct {
79
                    MACAddr sha;     /* ARP source hardware address */
80
                    MACAddr tha;     /* ARP target hardware address */
81
                } arp;
82
            };
83
        } ipv4;
84
        struct {
85
            struct {
86
                Ipv6Addr src;       /* IPv6 source address */
87
                Ipv6Addr dst;       /* IPv6 destination address */
88
            } addr;
89
            uint32_t label;            /* IPv6 flow label */
90
            struct {
91
                uint16_t src;          /* TCP/UDP/SCTP source port */
92
                uint16_t dst;          /* TCP/UDP/SCTP destination port */
93
                uint16_t flags;        /* TCP flags */
94
            } tp;
95
            struct {
96
                Ipv6Addr target;    /* ND target address */
97
                MACAddr sll;         /* ND source link layer address */
98
                MACAddr tll;         /* ND target link layer address */
99
            } nd;
100
        } ipv6;
101
    };
102
    int width;                       /* how many uint32_t's in key? */
103
} OfDpaFlowKey;
104
105
/* Width of key which includes field 'f' in u32s, rounded up */
106
#define FLOW_KEY_WIDTH(f) \
107
0
    DIV_ROUND_UP(offsetof(OfDpaFlowKey, f) + sizeof_field(OfDpaFlowKey, f), \
108
0
    sizeof(uint32_t))
109
110
typedef struct of_dpa_flow_action {
111
    uint32_t goto_tbl;
112
    struct {
113
        uint32_t group_id;
114
        uint32_t tun_log_lport;
115
        uint16_t vlan_id;
116
    } write;
117
    struct {
118
        uint16_t new_vlan_id;
119
        uint32_t out_pport;
120
        uint8_t copy_to_cpu;
121
        uint16_t vlan_id;
122
    } apply;
123
} OfDpaFlowAction;
124
125
typedef struct of_dpa_flow {
126
    uint32_t lpm;
127
    uint32_t priority;
128
    uint32_t hardtime;
129
    uint32_t idletime;
130
    uint64_t cookie;
131
    OfDpaFlowKey key;
132
    OfDpaFlowKey mask;
133
    OfDpaFlowAction action;
134
    struct {
135
        uint64_t hits;
136
        int64_t install_time;
137
        int64_t refresh_time;
138
        uint64_t rx_pkts;
139
        uint64_t tx_pkts;
140
    } stats;
141
} OfDpaFlow;
142
143
typedef struct of_dpa_flow_pkt_fields {
144
    uint32_t tunnel_id;
145
    struct eth_header *ethhdr;
146
    void *h_proto; /* pointer to unaligned uint16_t data */
147
    struct vlan_header *vlanhdr;
148
    struct ip_header *ipv4hdr;
149
    struct ip6_header *ipv6hdr;
150
    Ipv6Addr *ipv6_src_addr;
151
    Ipv6Addr *ipv6_dst_addr;
152
} OfDpaFlowPktFields;
153
154
typedef struct of_dpa_flow_context {
155
    uint32_t in_pport;
156
    uint32_t tunnel_id;
157
    struct iovec *iov;
158
    int iovcnt;
159
    struct eth_header ethhdr_rewrite;
160
    struct vlan_header vlanhdr_rewrite;
161
    struct vlan_header vlanhdr;
162
    OfDpa *of_dpa;
163
    OfDpaFlowPktFields fields;
164
    OfDpaFlowAction action_set;
165
} OfDpaFlowContext;
166
167
typedef struct of_dpa_flow_match {
168
    OfDpaFlowKey value;
169
    OfDpaFlow *best;
170
} OfDpaFlowMatch;
171
172
typedef struct of_dpa_group {
173
    uint32_t id;
174
    union {
175
        struct {
176
            uint32_t out_pport;
177
            uint8_t pop_vlan;
178
        } l2_interface;
179
        struct {
180
            uint32_t group_id;
181
            MACAddr src_mac;
182
            MACAddr dst_mac;
183
            uint16_t vlan_id;
184
        } l2_rewrite;
185
        struct {
186
            uint16_t group_count;
187
            uint32_t *group_ids;
188
        } l2_flood;
189
        struct {
190
            uint32_t group_id;
191
            MACAddr src_mac;
192
            MACAddr dst_mac;
193
            uint16_t vlan_id;
194
            uint8_t ttl_check;
195
        } l3_unicast;
196
    };
197
} OfDpaGroup;
198
199
static uint16_t of_dpa_flow_pkt_h_proto(const OfDpaFlowPktFields *fields)
200
0
{
201
0
    return lduw_he_p(fields->h_proto);
202
0
}
203
204
static int of_dpa_mask2prefix(uint32_t mask)
205
0
{
206
0
    return 32 - ctz32(ntohl(mask));
207
0
}
208
209
#if defined(DEBUG_ROCKER)
210
static void of_dpa_flow_key_dump(OfDpaFlowKey *key, OfDpaFlowKey *mask)
211
{
212
    char buf[512], *b = buf, *mac;
213
214
    b += sprintf(b, " tbl %2d", key->tbl_id);
215
216
    if (key->in_pport || (mask && mask->in_pport)) {
217
        b += sprintf(b, " in_pport %2d", key->in_pport);
218
        if (mask && mask->in_pport != 0xffffffff) {
219
            b += sprintf(b, "/0x%08x", key->in_pport);
220
        }
221
    }
222
223
    if (key->tunnel_id || (mask && mask->tunnel_id)) {
224
        b += sprintf(b, " tun %8d", key->tunnel_id);
225
        if (mask && mask->tunnel_id != 0xffffffff) {
226
            b += sprintf(b, "/0x%08x", key->tunnel_id);
227
        }
228
    }
229
230
    if (key->eth.vlan_id || (mask && mask->eth.vlan_id)) {
231
        b += sprintf(b, " vlan %4d", ntohs(key->eth.vlan_id));
232
        if (mask && mask->eth.vlan_id != 0xffff) {
233
            b += sprintf(b, "/0x%04x", ntohs(key->eth.vlan_id));
234
        }
235
    }
236
237
    if (memcmp(key->eth.src.a, zero_mac.a, ETH_ALEN) ||
238
        (mask && memcmp(mask->eth.src.a, zero_mac.a, ETH_ALEN))) {
239
        mac = qemu_mac_strdup_printf(key->eth.src.a);
240
        b += sprintf(b, " src %s", mac);
241
        g_free(mac);
242
        if (mask && memcmp(mask->eth.src.a, ff_mac.a, ETH_ALEN)) {
243
            mac = qemu_mac_strdup_printf(mask->eth.src.a);
244
            b += sprintf(b, "/%s", mac);
245
            g_free(mac);
246
        }
247
    }
248
249
    if (memcmp(key->eth.dst.a, zero_mac.a, ETH_ALEN) ||
250
        (mask && memcmp(mask->eth.dst.a, zero_mac.a, ETH_ALEN))) {
251
        mac = qemu_mac_strdup_printf(key->eth.dst.a);
252
        b += sprintf(b, " dst %s", mac);
253
        g_free(mac);
254
        if (mask && memcmp(mask->eth.dst.a, ff_mac.a, ETH_ALEN)) {
255
            mac = qemu_mac_strdup_printf(mask->eth.dst.a);
256
            b += sprintf(b, "/%s", mac);
257
            g_free(mac);
258
        }
259
    }
260
261
    if (key->eth.type || (mask && mask->eth.type)) {
262
        b += sprintf(b, " type 0x%04x", ntohs(key->eth.type));
263
        if (mask && mask->eth.type != 0xffff) {
264
            b += sprintf(b, "/0x%04x", ntohs(mask->eth.type));
265
        }
266
        switch (ntohs(key->eth.type)) {
267
        case 0x0800:
268
        case 0x86dd:
269
            if (key->ip.proto || (mask && mask->ip.proto)) {
270
                b += sprintf(b, " ip proto %2d", key->ip.proto);
271
                if (mask && mask->ip.proto != 0xff) {
272
                    b += sprintf(b, "/0x%02x", mask->ip.proto);
273
                }
274
            }
275
            if (key->ip.tos || (mask && mask->ip.tos)) {
276
                b += sprintf(b, " ip tos %2d", key->ip.tos);
277
                if (mask && mask->ip.tos != 0xff) {
278
                    b += sprintf(b, "/0x%02x", mask->ip.tos);
279
                }
280
            }
281
            break;
282
        }
283
        switch (ntohs(key->eth.type)) {
284
        case 0x0800:
285
            if (key->ipv4.addr.dst || (mask && mask->ipv4.addr.dst)) {
286
                b += sprintf(b, " dst %s",
287
                    inet_ntoa(*(struct in_addr *)&key->ipv4.addr.dst));
288
                if (mask) {
289
                    b += sprintf(b, "/%d",
290
                                 of_dpa_mask2prefix(mask->ipv4.addr.dst));
291
                }
292
            }
293
            break;
294
        }
295
    }
296
297
    DPRINTF("%s\n", buf);
298
}
299
#else
300
#define of_dpa_flow_key_dump(k, m)
301
#endif
302
303
static void _of_dpa_flow_match(void *key, void *value, void *user_data)
304
0
{
305
0
    OfDpaFlow *flow = value;
306
0
    OfDpaFlowMatch *match = user_data;
307
0
    uint32_t *k = (uint32_t *)&flow->key;
308
0
    uint32_t *m = (uint32_t *)&flow->mask;
309
0
    uint32_t *v = (uint32_t *)&match->value;
310
0
    int i;
311
312
0
    if (flow->key.tbl_id == match->value.tbl_id) {
313
0
        of_dpa_flow_key_dump(&flow->key, &flow->mask);
314
0
    }
315
316
0
    if (flow->key.width > match->value.width) {
317
0
        return;
318
0
    }
319
320
0
    for (i = 0; i < flow->key.width; i++, k++, m++, v++) {
321
0
        if ((~*k & *m & *v) | (*k & *m & ~*v)) {
322
0
            return;
323
0
        }
324
0
    }
325
326
0
    DPRINTF("match\n");
327
328
0
    if (!match->best ||
329
0
        flow->priority > match->best->priority ||
330
0
        flow->lpm > match->best->lpm) {
331
0
        match->best = flow;
332
0
    }
333
0
}
334
335
static OfDpaFlow *of_dpa_flow_match(OfDpa *of_dpa, OfDpaFlowMatch *match)
336
0
{
337
0
    DPRINTF("\nnew search\n");
338
0
    of_dpa_flow_key_dump(&match->value, NULL);
339
340
0
    g_hash_table_foreach(of_dpa->flow_tbl, _of_dpa_flow_match, match);
341
342
0
    return match->best;
343
0
}
344
345
static OfDpaFlow *of_dpa_flow_find(OfDpa *of_dpa, uint64_t cookie)
346
0
{
347
0
    return g_hash_table_lookup(of_dpa->flow_tbl, &cookie);
348
0
}
349
350
static int of_dpa_flow_add(OfDpa *of_dpa, OfDpaFlow *flow)
351
0
{
352
0
    g_hash_table_insert(of_dpa->flow_tbl, &flow->cookie, flow);
353
354
0
    return ROCKER_OK;
355
0
}
356
357
static void of_dpa_flow_del(OfDpa *of_dpa, OfDpaFlow *flow)
358
0
{
359
0
    g_hash_table_remove(of_dpa->flow_tbl, &flow->cookie);
360
0
}
361
362
static OfDpaFlow *of_dpa_flow_alloc(uint64_t cookie)
363
0
{
364
0
    OfDpaFlow *flow;
365
0
    int64_t now = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) / 1000;
366
367
0
    flow = g_new0(OfDpaFlow, 1);
368
369
0
    flow->cookie = cookie;
370
0
    flow->mask.tbl_id = 0xffffffff;
371
372
0
    flow->stats.install_time = flow->stats.refresh_time = now;
373
374
0
    return flow;
375
0
}
376
377
static void of_dpa_flow_pkt_hdr_reset(OfDpaFlowContext *fc)
378
0
{
379
0
    OfDpaFlowPktFields *fields = &fc->fields;
380
381
0
    fc->iov[0].iov_base = fields->ethhdr;
382
0
    fc->iov[0].iov_len = sizeof(struct eth_header);
383
0
    fc->iov[1].iov_base = fields->vlanhdr;
384
0
    fc->iov[1].iov_len = fields->vlanhdr ? sizeof(struct vlan_header) : 0;
385
0
}
386
387
static void of_dpa_flow_pkt_parse(OfDpaFlowContext *fc,
388
                                  const struct iovec *iov, int iovcnt)
389
0
{
390
0
    OfDpaFlowPktFields *fields = &fc->fields;
391
0
    size_t sofar = 0;
392
0
    int i;
393
394
0
    sofar += sizeof(struct eth_header);
395
0
    if (iov->iov_len < sofar) {
396
0
        DPRINTF("flow_pkt_parse underrun on eth_header\n");
397
0
        return;
398
0
    }
399
400
0
    fields->ethhdr = iov->iov_base;
401
0
    fields->h_proto = &fields->ethhdr->h_proto;
402
403
0
    if (ntohs(of_dpa_flow_pkt_h_proto(fields) == ETH_P_VLAN)) {
404
0
        sofar += sizeof(struct vlan_header);
405
0
        if (iov->iov_len < sofar) {
406
0
            DPRINTF("flow_pkt_parse underrun on vlan_header\n");
407
0
            return;
408
0
        }
409
0
        fields->vlanhdr = (struct vlan_header *)(fields->ethhdr + 1);
410
0
        fields->h_proto = &fields->vlanhdr->h_proto;
411
0
    }
412
413
0
    switch (ntohs(of_dpa_flow_pkt_h_proto(fields))) {
414
0
    case ETH_P_IP:
415
0
        sofar += sizeof(struct ip_header);
416
0
        if (iov->iov_len < sofar) {
417
0
            DPRINTF("flow_pkt_parse underrun on ip_header\n");
418
0
            return;
419
0
        }
420
0
        fields->ipv4hdr = (struct ip_header *)(fields->h_proto + 1);
421
0
        break;
422
0
    case ETH_P_IPV6:
423
0
        sofar += sizeof(struct ip6_header);
424
0
        if (iov->iov_len < sofar) {
425
0
            DPRINTF("flow_pkt_parse underrun on ip6_header\n");
426
0
            return;
427
0
        }
428
0
        fields->ipv6hdr = (struct ip6_header *)(fields->h_proto + 1);
429
0
        break;
430
0
    }
431
432
    /* To facilitate (potential) VLAN tag insertion, Make a
433
     * copy of the iov and insert two new vectors at the
434
     * beginning for eth hdr and vlan hdr.  No data is copied,
435
     * just the vectors.
436
     */
437
438
0
    of_dpa_flow_pkt_hdr_reset(fc);
439
440
0
    fc->iov[2].iov_base = fields->h_proto + 1;
441
0
    fc->iov[2].iov_len = iov->iov_len - fc->iov[0].iov_len - fc->iov[1].iov_len;
442
443
0
    for (i = 1; i < iovcnt; i++) {
444
0
        fc->iov[i+2] = iov[i];
445
0
    }
446
447
0
    fc->iovcnt = iovcnt + 2;
448
0
}
449
450
static void of_dpa_flow_pkt_insert_vlan(OfDpaFlowContext *fc, uint16_t vlan_id)
451
0
{
452
0
    OfDpaFlowPktFields *fields = &fc->fields;
453
0
    uint16_t h_proto = fields->ethhdr->h_proto;
454
455
0
    if (fields->vlanhdr) {
456
0
        DPRINTF("flow_pkt_insert_vlan packet already has vlan\n");
457
0
        return;
458
0
    }
459
460
0
    fields->ethhdr->h_proto = htons(ETH_P_VLAN);
461
0
    fields->vlanhdr = &fc->vlanhdr;
462
0
    fields->vlanhdr->h_tci = vlan_id;
463
0
    fields->vlanhdr->h_proto = h_proto;
464
0
    fields->h_proto = &fields->vlanhdr->h_proto;
465
466
0
    fc->iov[1].iov_base = fields->vlanhdr;
467
0
    fc->iov[1].iov_len = sizeof(struct vlan_header);
468
0
}
469
470
static void of_dpa_flow_pkt_strip_vlan(OfDpaFlowContext *fc)
471
0
{
472
0
    OfDpaFlowPktFields *fields = &fc->fields;
473
474
0
    if (!fields->vlanhdr) {
475
0
        return;
476
0
    }
477
478
0
    fc->iov[0].iov_len -= sizeof(fields->ethhdr->h_proto);
479
0
    fc->iov[1].iov_base = fields->h_proto;
480
0
    fc->iov[1].iov_len = sizeof(fields->ethhdr->h_proto);
481
0
}
482
483
static void of_dpa_flow_pkt_hdr_rewrite(OfDpaFlowContext *fc,
484
                                        uint8_t *src_mac, uint8_t *dst_mac,
485
                                        uint16_t vlan_id)
486
0
{
487
0
    OfDpaFlowPktFields *fields = &fc->fields;
488
489
0
    if (src_mac || dst_mac) {
490
0
        memcpy(&fc->ethhdr_rewrite, fields->ethhdr, sizeof(struct eth_header));
491
0
        if (src_mac && memcmp(src_mac, zero_mac.a, ETH_ALEN)) {
492
0
            memcpy(fc->ethhdr_rewrite.h_source, src_mac, ETH_ALEN);
493
0
        }
494
0
        if (dst_mac && memcmp(dst_mac, zero_mac.a, ETH_ALEN)) {
495
0
            memcpy(fc->ethhdr_rewrite.h_dest, dst_mac, ETH_ALEN);
496
0
        }
497
0
        fc->iov[0].iov_base = &fc->ethhdr_rewrite;
498
0
    }
499
500
0
    if (vlan_id && fields->vlanhdr) {
501
0
        fc->vlanhdr_rewrite = fc->vlanhdr;
502
0
        fc->vlanhdr_rewrite.h_tci = vlan_id;
503
0
        fc->iov[1].iov_base = &fc->vlanhdr_rewrite;
504
0
    }
505
0
}
506
507
static void of_dpa_flow_ig_tbl(OfDpaFlowContext *fc, uint32_t tbl_id);
508
509
static void of_dpa_ig_port_build_match(OfDpaFlowContext *fc,
510
                                       OfDpaFlowMatch *match)
511
0
{
512
0
    match->value.tbl_id = ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT;
513
0
    match->value.in_pport = fc->in_pport;
514
0
    match->value.width = FLOW_KEY_WIDTH(tbl_id);
515
0
}
516
517
static void of_dpa_ig_port_miss(OfDpaFlowContext *fc)
518
0
{
519
0
    uint32_t port;
520
521
    /* The default on miss is for packets from physical ports
522
     * to go to the VLAN Flow Table. There is no default rule
523
     * for packets from logical ports, which are dropped on miss.
524
     */
525
526
0
    if (fp_port_from_pport(fc->in_pport, &port)) {
527
0
        of_dpa_flow_ig_tbl(fc, ROCKER_OF_DPA_TABLE_ID_VLAN);
528
0
    }
529
0
}
530
531
static void of_dpa_vlan_build_match(OfDpaFlowContext *fc,
532
                                    OfDpaFlowMatch *match)
533
0
{
534
0
    match->value.tbl_id = ROCKER_OF_DPA_TABLE_ID_VLAN;
535
0
    match->value.in_pport = fc->in_pport;
536
0
    if (fc->fields.vlanhdr) {
537
0
        match->value.eth.vlan_id = fc->fields.vlanhdr->h_tci;
538
0
    }
539
0
    match->value.width = FLOW_KEY_WIDTH(eth.vlan_id);
540
0
}
541
542
static void of_dpa_vlan_insert(OfDpaFlowContext *fc,
543
                               OfDpaFlow *flow)
544
0
{
545
0
    if (flow->action.apply.new_vlan_id) {
546
0
        of_dpa_flow_pkt_insert_vlan(fc, flow->action.apply.new_vlan_id);
547
0
    }
548
0
}
549
550
static void of_dpa_term_mac_build_match(OfDpaFlowContext *fc,
551
                                        OfDpaFlowMatch *match)
552
0
{
553
0
    match->value.tbl_id = ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC;
554
0
    match->value.in_pport = fc->in_pport;
555
0
    match->value.eth.type = of_dpa_flow_pkt_h_proto(&fc->fields);
556
0
    match->value.eth.vlan_id = fc->fields.vlanhdr->h_tci;
557
0
    memcpy(match->value.eth.dst.a, fc->fields.ethhdr->h_dest,
558
0
           sizeof(match->value.eth.dst.a));
559
0
    match->value.width = FLOW_KEY_WIDTH(eth.type);
560
0
}
561
562
static void of_dpa_term_mac_miss(OfDpaFlowContext *fc)
563
0
{
564
0
    of_dpa_flow_ig_tbl(fc, ROCKER_OF_DPA_TABLE_ID_BRIDGING);
565
0
}
566
567
static void of_dpa_apply_actions(OfDpaFlowContext *fc,
568
                                 OfDpaFlow *flow)
569
0
{
570
0
    fc->action_set.apply.copy_to_cpu = flow->action.apply.copy_to_cpu;
571
0
    fc->action_set.apply.vlan_id = flow->key.eth.vlan_id;
572
0
}
573
574
static void of_dpa_bridging_build_match(OfDpaFlowContext *fc,
575
                                        OfDpaFlowMatch *match)
576
0
{
577
0
    match->value.tbl_id = ROCKER_OF_DPA_TABLE_ID_BRIDGING;
578
0
    if (fc->fields.vlanhdr) {
579
0
        match->value.eth.vlan_id = fc->fields.vlanhdr->h_tci;
580
0
    } else if (fc->tunnel_id) {
581
0
        match->value.tunnel_id = fc->tunnel_id;
582
0
    }
583
0
    memcpy(match->value.eth.dst.a, fc->fields.ethhdr->h_dest,
584
0
           sizeof(match->value.eth.dst.a));
585
0
    match->value.width = FLOW_KEY_WIDTH(eth.dst);
586
0
}
587
588
static void of_dpa_bridging_learn(OfDpaFlowContext *fc,
589
                                  OfDpaFlow *dst_flow)
590
0
{
591
0
    OfDpaFlowMatch match = { { 0, }, };
592
0
    OfDpaFlow *flow;
593
0
    uint8_t *addr;
594
0
    uint16_t vlan_id;
595
0
    int64_t now = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) / 1000;
596
0
    int64_t refresh_delay = 1;
597
598
    /* Do a lookup in bridge table by src_mac/vlan */
599
600
0
    addr = fc->fields.ethhdr->h_source;
601
0
    vlan_id = fc->fields.vlanhdr->h_tci;
602
603
0
    match.value.tbl_id = ROCKER_OF_DPA_TABLE_ID_BRIDGING;
604
0
    match.value.eth.vlan_id = vlan_id;
605
0
    memcpy(match.value.eth.dst.a, addr, sizeof(match.value.eth.dst.a));
606
0
    match.value.width = FLOW_KEY_WIDTH(eth.dst);
607
608
0
    flow = of_dpa_flow_match(fc->of_dpa, &match);
609
0
    if (flow) {
610
0
        if (!memcmp(flow->mask.eth.dst.a, ff_mac.a,
611
0
                    sizeof(flow->mask.eth.dst.a))) {
612
            /* src_mac/vlan already learned; if in_port and out_port
613
             * don't match, the end station has moved and the port
614
             * needs updating */
615
            /* XXX implement the in_port/out_port check */
616
0
            if (now - flow->stats.refresh_time < refresh_delay) {
617
0
                return;
618
0
            }
619
0
            flow->stats.refresh_time = now;
620
0
        }
621
0
    }
622
623
    /* Let driver know about mac/vlan.  This may be a new mac/vlan
624
     * or a refresh of existing mac/vlan that's been hit after the
625
     * refresh_delay.
626
     */
627
628
0
    rocker_event_mac_vlan_seen(world_rocker(fc->of_dpa->world),
629
0
                               fc->in_pport, addr, vlan_id);
630
0
}
631
632
static void of_dpa_bridging_miss(OfDpaFlowContext *fc)
633
0
{
634
0
    of_dpa_bridging_learn(fc, NULL);
635
0
    of_dpa_flow_ig_tbl(fc, ROCKER_OF_DPA_TABLE_ID_ACL_POLICY);
636
0
}
637
638
static void of_dpa_bridging_action_write(OfDpaFlowContext *fc,
639
                                         OfDpaFlow *flow)
640
0
{
641
0
    if (flow->action.write.group_id != ROCKER_GROUP_NONE) {
642
0
        fc->action_set.write.group_id = flow->action.write.group_id;
643
0
    }
644
0
    fc->action_set.write.tun_log_lport = flow->action.write.tun_log_lport;
645
0
}
646
647
static void of_dpa_unicast_routing_build_match(OfDpaFlowContext *fc,
648
                                               OfDpaFlowMatch *match)
649
0
{
650
0
    match->value.tbl_id = ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING;
651
0
    match->value.eth.type = of_dpa_flow_pkt_h_proto(&fc->fields);
652
0
    if (fc->fields.ipv4hdr) {
653
0
        match->value.ipv4.addr.dst = fc->fields.ipv4hdr->ip_dst;
654
0
    }
655
0
    if (fc->fields.ipv6_dst_addr) {
656
0
        memcpy(&match->value.ipv6.addr.dst, fc->fields.ipv6_dst_addr,
657
0
               sizeof(match->value.ipv6.addr.dst));
658
0
    }
659
0
    match->value.width = FLOW_KEY_WIDTH(ipv6.addr.dst);
660
0
}
661
662
static void of_dpa_unicast_routing_miss(OfDpaFlowContext *fc)
663
0
{
664
0
    of_dpa_flow_ig_tbl(fc, ROCKER_OF_DPA_TABLE_ID_ACL_POLICY);
665
0
}
666
667
static void of_dpa_unicast_routing_action_write(OfDpaFlowContext *fc,
668
                                                OfDpaFlow *flow)
669
0
{
670
0
    if (flow->action.write.group_id != ROCKER_GROUP_NONE) {
671
0
        fc->action_set.write.group_id = flow->action.write.group_id;
672
0
    }
673
0
}
674
675
static void
676
of_dpa_multicast_routing_build_match(OfDpaFlowContext *fc,
677
                                     OfDpaFlowMatch *match)
678
0
{
679
0
    match->value.tbl_id = ROCKER_OF_DPA_TABLE_ID_MULTICAST_ROUTING;
680
0
    match->value.eth.type = of_dpa_flow_pkt_h_proto(&fc->fields);
681
0
    match->value.eth.vlan_id = fc->fields.vlanhdr->h_tci;
682
0
    if (fc->fields.ipv4hdr) {
683
0
        match->value.ipv4.addr.src = fc->fields.ipv4hdr->ip_src;
684
0
        match->value.ipv4.addr.dst = fc->fields.ipv4hdr->ip_dst;
685
0
    }
686
0
    if (fc->fields.ipv6_src_addr) {
687
0
        memcpy(&match->value.ipv6.addr.src, fc->fields.ipv6_src_addr,
688
0
               sizeof(match->value.ipv6.addr.src));
689
0
    }
690
0
    if (fc->fields.ipv6_dst_addr) {
691
0
        memcpy(&match->value.ipv6.addr.dst, fc->fields.ipv6_dst_addr,
692
0
               sizeof(match->value.ipv6.addr.dst));
693
0
    }
694
0
    match->value.width = FLOW_KEY_WIDTH(ipv6.addr.dst);
695
0
}
696
697
static void of_dpa_multicast_routing_miss(OfDpaFlowContext *fc)
698
0
{
699
0
    of_dpa_flow_ig_tbl(fc, ROCKER_OF_DPA_TABLE_ID_ACL_POLICY);
700
0
}
701
702
static void
703
of_dpa_multicast_routing_action_write(OfDpaFlowContext *fc,
704
                                      OfDpaFlow *flow)
705
0
{
706
0
    if (flow->action.write.group_id != ROCKER_GROUP_NONE) {
707
0
        fc->action_set.write.group_id = flow->action.write.group_id;
708
0
    }
709
0
    fc->action_set.write.vlan_id = flow->action.write.vlan_id;
710
0
}
711
712
static void of_dpa_acl_build_match(OfDpaFlowContext *fc,
713
                                   OfDpaFlowMatch *match)
714
0
{
715
0
    match->value.tbl_id = ROCKER_OF_DPA_TABLE_ID_ACL_POLICY;
716
0
    match->value.in_pport = fc->in_pport;
717
0
    memcpy(match->value.eth.src.a, fc->fields.ethhdr->h_source,
718
0
           sizeof(match->value.eth.src.a));
719
0
    memcpy(match->value.eth.dst.a, fc->fields.ethhdr->h_dest,
720
0
           sizeof(match->value.eth.dst.a));
721
0
    match->value.eth.type = of_dpa_flow_pkt_h_proto(&fc->fields);
722
0
    match->value.eth.vlan_id = fc->fields.vlanhdr->h_tci;
723
0
    match->value.width = FLOW_KEY_WIDTH(eth.type);
724
0
    if (fc->fields.ipv4hdr) {
725
0
        match->value.ip.proto = fc->fields.ipv4hdr->ip_p;
726
0
        match->value.ip.tos = fc->fields.ipv4hdr->ip_tos;
727
0
        match->value.width = FLOW_KEY_WIDTH(ip.tos);
728
0
    } else if (fc->fields.ipv6hdr) {
729
0
        match->value.ip.proto =
730
0
            fc->fields.ipv6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt;
731
0
        match->value.ip.tos = 0; /* XXX what goes here? */
732
0
        match->value.width = FLOW_KEY_WIDTH(ip.tos);
733
0
    }
734
0
}
735
736
static void of_dpa_eg(OfDpaFlowContext *fc);
737
static void of_dpa_acl_hit(OfDpaFlowContext *fc,
738
                           OfDpaFlow *dst_flow)
739
0
{
740
0
    of_dpa_eg(fc);
741
0
}
742
743
static void of_dpa_acl_action_write(OfDpaFlowContext *fc,
744
                                    OfDpaFlow *flow)
745
0
{
746
0
    if (flow->action.write.group_id != ROCKER_GROUP_NONE) {
747
0
        fc->action_set.write.group_id = flow->action.write.group_id;
748
0
    }
749
0
}
750
751
static void of_dpa_drop(OfDpaFlowContext *fc)
752
0
{
753
    /* drop packet */
754
0
}
755
756
static OfDpaGroup *of_dpa_group_find(OfDpa *of_dpa,
757
                                              uint32_t group_id)
758
0
{
759
0
    return g_hash_table_lookup(of_dpa->group_tbl, &group_id);
760
0
}
761
762
static int of_dpa_group_add(OfDpa *of_dpa, OfDpaGroup *group)
763
0
{
764
0
    g_hash_table_insert(of_dpa->group_tbl, &group->id, group);
765
766
0
    return 0;
767
0
}
768
769
#if 0
770
static int of_dpa_group_mod(OfDpa *of_dpa, OfDpaGroup *group)
771
{
772
    OfDpaGroup *old_group = of_dpa_group_find(of_dpa, group->id);
773
774
    if (!old_group) {
775
        return -ENOENT;
776
    }
777
778
    /* XXX */
779
780
    return 0;
781
}
782
#endif
783
784
static int of_dpa_group_del(OfDpa *of_dpa, OfDpaGroup *group)
785
0
{
786
0
    g_hash_table_remove(of_dpa->group_tbl, &group->id);
787
788
0
    return 0;
789
0
}
790
791
#if 0
792
static int of_dpa_group_get_stats(OfDpa *of_dpa, uint32_t id)
793
{
794
    OfDpaGroup *group = of_dpa_group_find(of_dpa, id);
795
796
    if (!group) {
797
        return -ENOENT;
798
    }
799
800
    /* XXX get/return stats */
801
802
    return 0;
803
}
804
#endif
805
806
static OfDpaGroup *of_dpa_group_alloc(uint32_t id)
807
0
{
808
0
    OfDpaGroup *group = g_new0(OfDpaGroup, 1);
809
810
0
    group->id = id;
811
812
0
    return group;
813
0
}
814
815
static void of_dpa_output_l2_interface(OfDpaFlowContext *fc,
816
                                       OfDpaGroup *group)
817
0
{
818
0
    uint8_t copy_to_cpu = fc->action_set.apply.copy_to_cpu;
819
820
0
    if (group->l2_interface.pop_vlan) {
821
0
        of_dpa_flow_pkt_strip_vlan(fc);
822
0
    }
823
824
    /* Note: By default, and as per the OpenFlow 1.3.1
825
     * specification, a packet cannot be forwarded back
826
     * to the IN_PORT from which it came in. An action
827
     * bucket that specifies the particular packet's
828
     * egress port is not evaluated.
829
     */
830
831
0
    if (group->l2_interface.out_pport == 0) {
832
0
        rx_produce(fc->of_dpa->world, fc->in_pport, fc->iov, fc->iovcnt,
833
0
                   copy_to_cpu);
834
0
    } else if (group->l2_interface.out_pport != fc->in_pport) {
835
0
        rocker_port_eg(world_rocker(fc->of_dpa->world),
836
0
                       group->l2_interface.out_pport,
837
0
                       fc->iov, fc->iovcnt);
838
0
    }
839
0
}
840
841
static void of_dpa_output_l2_rewrite(OfDpaFlowContext *fc,
842
                                     OfDpaGroup *group)
843
0
{
844
0
    OfDpaGroup *l2_group =
845
0
        of_dpa_group_find(fc->of_dpa, group->l2_rewrite.group_id);
846
847
0
    if (!l2_group) {
848
0
        return;
849
0
    }
850
851
0
    of_dpa_flow_pkt_hdr_rewrite(fc, group->l2_rewrite.src_mac.a,
852
0
                         group->l2_rewrite.dst_mac.a,
853
0
                         group->l2_rewrite.vlan_id);
854
0
    of_dpa_output_l2_interface(fc, l2_group);
855
0
}
856
857
static void of_dpa_output_l2_flood(OfDpaFlowContext *fc,
858
                                   OfDpaGroup *group)
859
0
{
860
0
    OfDpaGroup *l2_group;
861
0
    int i;
862
863
0
    for (i = 0; i < group->l2_flood.group_count; i++) {
864
0
        of_dpa_flow_pkt_hdr_reset(fc);
865
0
        l2_group = of_dpa_group_find(fc->of_dpa, group->l2_flood.group_ids[i]);
866
0
        if (!l2_group) {
867
0
            continue;
868
0
        }
869
0
        switch (ROCKER_GROUP_TYPE_GET(l2_group->id)) {
870
0
        case ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE:
871
0
            of_dpa_output_l2_interface(fc, l2_group);
872
0
            break;
873
0
        case ROCKER_OF_DPA_GROUP_TYPE_L2_REWRITE:
874
0
            of_dpa_output_l2_rewrite(fc, l2_group);
875
0
            break;
876
0
        }
877
0
    }
878
0
}
879
880
static void of_dpa_output_l3_unicast(OfDpaFlowContext *fc, OfDpaGroup *group)
881
0
{
882
0
    OfDpaGroup *l2_group =
883
0
        of_dpa_group_find(fc->of_dpa, group->l3_unicast.group_id);
884
885
0
    if (!l2_group) {
886
0
        return;
887
0
    }
888
889
0
    of_dpa_flow_pkt_hdr_rewrite(fc, group->l3_unicast.src_mac.a,
890
0
                                group->l3_unicast.dst_mac.a,
891
0
                                group->l3_unicast.vlan_id);
892
    /* XXX need ttl_check */
893
0
    of_dpa_output_l2_interface(fc, l2_group);
894
0
}
895
896
static void of_dpa_eg(OfDpaFlowContext *fc)
897
0
{
898
0
    OfDpaFlowAction *set = &fc->action_set;
899
0
    OfDpaGroup *group;
900
0
    uint32_t group_id;
901
902
    /* send a copy of pkt to CPU (controller)? */
903
904
0
    if (set->apply.copy_to_cpu) {
905
0
        group_id = ROCKER_GROUP_L2_INTERFACE(set->apply.vlan_id, 0);
906
0
        group = of_dpa_group_find(fc->of_dpa, group_id);
907
0
        if (group) {
908
0
            of_dpa_output_l2_interface(fc, group);
909
0
            of_dpa_flow_pkt_hdr_reset(fc);
910
0
        }
911
0
    }
912
913
    /* process group write actions */
914
915
0
    if (!set->write.group_id) {
916
0
        return;
917
0
    }
918
919
0
    group = of_dpa_group_find(fc->of_dpa, set->write.group_id);
920
0
    if (!group) {
921
0
        return;
922
0
    }
923
924
0
    switch (ROCKER_GROUP_TYPE_GET(group->id)) {
925
0
    case ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE:
926
0
        of_dpa_output_l2_interface(fc, group);
927
0
        break;
928
0
    case ROCKER_OF_DPA_GROUP_TYPE_L2_REWRITE:
929
0
        of_dpa_output_l2_rewrite(fc, group);
930
0
        break;
931
0
    case ROCKER_OF_DPA_GROUP_TYPE_L2_FLOOD:
932
0
    case ROCKER_OF_DPA_GROUP_TYPE_L2_MCAST:
933
0
        of_dpa_output_l2_flood(fc, group);
934
0
        break;
935
0
    case ROCKER_OF_DPA_GROUP_TYPE_L3_UCAST:
936
0
        of_dpa_output_l3_unicast(fc, group);
937
0
        break;
938
0
    }
939
0
}
940
941
typedef struct of_dpa_flow_tbl_ops {
942
    void (*build_match)(OfDpaFlowContext *fc, OfDpaFlowMatch *match);
943
    void (*hit)(OfDpaFlowContext *fc, OfDpaFlow *flow);
944
    void (*miss)(OfDpaFlowContext *fc);
945
    void (*hit_no_goto)(OfDpaFlowContext *fc);
946
    void (*action_apply)(OfDpaFlowContext *fc, OfDpaFlow *flow);
947
    void (*action_write)(OfDpaFlowContext *fc, OfDpaFlow *flow);
948
} OfDpaFlowTblOps;
949
950
static OfDpaFlowTblOps of_dpa_tbl_ops[] = {
951
    [ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT] = {
952
        .build_match = of_dpa_ig_port_build_match,
953
        .miss = of_dpa_ig_port_miss,
954
        .hit_no_goto = of_dpa_drop,
955
    },
956
    [ROCKER_OF_DPA_TABLE_ID_VLAN] = {
957
        .build_match = of_dpa_vlan_build_match,
958
        .hit_no_goto = of_dpa_drop,
959
        .action_apply = of_dpa_vlan_insert,
960
    },
961
    [ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC] = {
962
        .build_match = of_dpa_term_mac_build_match,
963
        .miss = of_dpa_term_mac_miss,
964
        .hit_no_goto = of_dpa_drop,
965
        .action_apply = of_dpa_apply_actions,
966
    },
967
    [ROCKER_OF_DPA_TABLE_ID_BRIDGING] = {
968
        .build_match = of_dpa_bridging_build_match,
969
        .hit = of_dpa_bridging_learn,
970
        .miss = of_dpa_bridging_miss,
971
        .hit_no_goto = of_dpa_drop,
972
        .action_apply = of_dpa_apply_actions,
973
        .action_write = of_dpa_bridging_action_write,
974
    },
975
    [ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING] = {
976
        .build_match = of_dpa_unicast_routing_build_match,
977
        .miss = of_dpa_unicast_routing_miss,
978
        .hit_no_goto = of_dpa_drop,
979
        .action_write = of_dpa_unicast_routing_action_write,
980
    },
981
    [ROCKER_OF_DPA_TABLE_ID_MULTICAST_ROUTING] = {
982
        .build_match = of_dpa_multicast_routing_build_match,
983
        .miss = of_dpa_multicast_routing_miss,
984
        .hit_no_goto = of_dpa_drop,
985
        .action_write = of_dpa_multicast_routing_action_write,
986
    },
987
    [ROCKER_OF_DPA_TABLE_ID_ACL_POLICY] = {
988
        .build_match = of_dpa_acl_build_match,
989
        .hit = of_dpa_acl_hit,
990
        .miss = of_dpa_eg,
991
        .action_apply = of_dpa_apply_actions,
992
        .action_write = of_dpa_acl_action_write,
993
    },
994
};
995
996
static void of_dpa_flow_ig_tbl(OfDpaFlowContext *fc, uint32_t tbl_id)
997
0
{
998
0
    OfDpaFlowTblOps *ops = &of_dpa_tbl_ops[tbl_id];
999
0
    OfDpaFlowMatch match = { { 0, }, };
1000
0
    OfDpaFlow *flow;
1001
1002
0
    if (ops->build_match) {
1003
0
        ops->build_match(fc, &match);
1004
0
    } else {
1005
0
        return;
1006
0
    }
1007
1008
0
    flow = of_dpa_flow_match(fc->of_dpa, &match);
1009
0
    if (!flow) {
1010
0
        if (ops->miss) {
1011
0
            ops->miss(fc);
1012
0
        }
1013
0
        return;
1014
0
    }
1015
1016
0
    flow->stats.hits++;
1017
1018
0
    if (ops->action_apply) {
1019
0
        ops->action_apply(fc, flow);
1020
0
    }
1021
1022
0
    if (ops->action_write) {
1023
0
        ops->action_write(fc, flow);
1024
0
    }
1025
1026
0
    if (ops->hit) {
1027
0
        ops->hit(fc, flow);
1028
0
    }
1029
1030
0
    if (flow->action.goto_tbl) {
1031
0
        of_dpa_flow_ig_tbl(fc, flow->action.goto_tbl);
1032
0
    } else if (ops->hit_no_goto) {
1033
0
        ops->hit_no_goto(fc);
1034
0
    }
1035
1036
    /* drop packet */
1037
0
}
1038
1039
static ssize_t of_dpa_ig(World *world, uint32_t pport,
1040
                         const struct iovec *iov, int iovcnt)
1041
0
{
1042
0
    g_autofree struct iovec *iov_copy = g_new(struct iovec, iovcnt + 2);
1043
0
    OfDpaFlowContext fc = {
1044
0
        .of_dpa = world_private(world),
1045
0
        .in_pport = pport,
1046
0
        .iov = iov_copy,
1047
0
        .iovcnt = iovcnt + 2,
1048
0
    };
1049
1050
0
    of_dpa_flow_pkt_parse(&fc, iov, iovcnt);
1051
0
    of_dpa_flow_ig_tbl(&fc, ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT);
1052
1053
0
    return iov_size(iov, iovcnt);
1054
0
}
1055
1056
0
#define ROCKER_TUNNEL_LPORT 0x00010000
1057
1058
static int of_dpa_cmd_add_ig_port(OfDpaFlow *flow, RockerTlv **flow_tlvs)
1059
0
{
1060
0
    OfDpaFlowKey *key = &flow->key;
1061
0
    OfDpaFlowKey *mask = &flow->mask;
1062
0
    OfDpaFlowAction *action = &flow->action;
1063
0
    bool overlay_tunnel;
1064
1065
0
    if (!flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT] ||
1066
0
        !flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]) {
1067
0
        return -ROCKER_EINVAL;
1068
0
    }
1069
1070
0
    key->tbl_id = ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT;
1071
0
    key->width = FLOW_KEY_WIDTH(tbl_id);
1072
1073
0
    key->in_pport = rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT]);
1074
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT_MASK]) {
1075
0
        mask->in_pport =
1076
0
            rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT_MASK]);
1077
0
    }
1078
1079
0
    overlay_tunnel = !!(key->in_pport & ROCKER_TUNNEL_LPORT);
1080
1081
0
    action->goto_tbl =
1082
0
        rocker_tlv_get_le16(flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]);
1083
1084
0
    if (!overlay_tunnel && action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_VLAN) {
1085
0
        return -ROCKER_EINVAL;
1086
0
    }
1087
1088
0
    if (overlay_tunnel && action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_BRIDGING) {
1089
0
        return -ROCKER_EINVAL;
1090
0
    }
1091
1092
0
    return ROCKER_OK;
1093
0
}
1094
1095
static int of_dpa_cmd_add_vlan(OfDpaFlow *flow, RockerTlv **flow_tlvs)
1096
0
{
1097
0
    OfDpaFlowKey *key = &flow->key;
1098
0
    OfDpaFlowKey *mask = &flow->mask;
1099
0
    OfDpaFlowAction *action = &flow->action;
1100
0
    uint32_t port;
1101
0
    bool untagged;
1102
1103
0
    if (!flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT] ||
1104
0
        !flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]) {
1105
0
        DPRINTF("Must give in_pport and vlan_id to install VLAN tbl entry\n");
1106
0
        return -ROCKER_EINVAL;
1107
0
    }
1108
1109
0
    key->tbl_id = ROCKER_OF_DPA_TABLE_ID_VLAN;
1110
0
    key->width = FLOW_KEY_WIDTH(eth.vlan_id);
1111
1112
0
    key->in_pport = rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT]);
1113
0
    if (!fp_port_from_pport(key->in_pport, &port)) {
1114
0
        DPRINTF("in_pport (%d) not a front-panel port\n", key->in_pport);
1115
0
        return -ROCKER_EINVAL;
1116
0
    }
1117
0
    mask->in_pport = 0xffffffff;
1118
1119
0
    key->eth.vlan_id = rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]);
1120
1121
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID_MASK]) {
1122
0
        mask->eth.vlan_id =
1123
0
            rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID_MASK]);
1124
0
    }
1125
1126
0
    if (key->eth.vlan_id) {
1127
0
        untagged = false; /* filtering */
1128
0
    } else {
1129
0
        untagged = true;
1130
0
    }
1131
1132
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]) {
1133
0
        action->goto_tbl =
1134
0
            rocker_tlv_get_le16(flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]);
1135
0
        if (action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC) {
1136
0
            DPRINTF("Goto tbl (%d) must be TERM_MAC\n", action->goto_tbl);
1137
0
            return -ROCKER_EINVAL;
1138
0
        }
1139
0
    }
1140
1141
0
    if (untagged) {
1142
0
        if (!flow_tlvs[ROCKER_TLV_OF_DPA_NEW_VLAN_ID]) {
1143
0
            DPRINTF("Must specify new vlan_id if untagged\n");
1144
0
            return -ROCKER_EINVAL;
1145
0
        }
1146
0
        action->apply.new_vlan_id =
1147
0
            rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_NEW_VLAN_ID]);
1148
0
        if (1 > ntohs(action->apply.new_vlan_id) ||
1149
0
            ntohs(action->apply.new_vlan_id) > 4095) {
1150
0
            DPRINTF("New vlan_id (%d) must be between 1 and 4095\n",
1151
0
                    ntohs(action->apply.new_vlan_id));
1152
0
            return -ROCKER_EINVAL;
1153
0
        }
1154
0
    }
1155
1156
0
    return ROCKER_OK;
1157
0
}
1158
1159
static int of_dpa_cmd_add_term_mac(OfDpaFlow *flow, RockerTlv **flow_tlvs)
1160
0
{
1161
0
    OfDpaFlowKey *key = &flow->key;
1162
0
    OfDpaFlowKey *mask = &flow->mask;
1163
0
    OfDpaFlowAction *action = &flow->action;
1164
0
    const MACAddr ipv4_mcast = { .a = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00 } };
1165
0
    const MACAddr ipv4_mask =  { .a = { 0xff, 0xff, 0xff, 0x80, 0x00, 0x00 } };
1166
0
    const MACAddr ipv6_mcast = { .a = { 0x33, 0x33, 0x00, 0x00, 0x00, 0x00 } };
1167
0
    const MACAddr ipv6_mask =  { .a = { 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 } };
1168
0
    uint32_t port;
1169
0
    bool unicast = false;
1170
0
    bool multicast = false;
1171
1172
0
    if (!flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT] ||
1173
0
        !flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT_MASK] ||
1174
0
        !flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE] ||
1175
0
        !flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC] ||
1176
0
        !flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC_MASK] ||
1177
0
        !flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID] ||
1178
0
        !flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID_MASK]) {
1179
0
        return -ROCKER_EINVAL;
1180
0
    }
1181
1182
0
    key->tbl_id = ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC;
1183
0
    key->width = FLOW_KEY_WIDTH(eth.type);
1184
1185
0
    key->in_pport = rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT]);
1186
0
    if (!fp_port_from_pport(key->in_pport, &port)) {
1187
0
        return -ROCKER_EINVAL;
1188
0
    }
1189
0
    mask->in_pport =
1190
0
        rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT_MASK]);
1191
1192
0
    key->eth.type = rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE]);
1193
0
    if (key->eth.type != htons(0x0800) && key->eth.type != htons(0x86dd)) {
1194
0
        return -ROCKER_EINVAL;
1195
0
    }
1196
0
    mask->eth.type = htons(0xffff);
1197
1198
0
    memcpy(key->eth.dst.a,
1199
0
           rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]),
1200
0
           sizeof(key->eth.dst.a));
1201
0
    memcpy(mask->eth.dst.a,
1202
0
           rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC_MASK]),
1203
0
           sizeof(mask->eth.dst.a));
1204
1205
0
    if ((key->eth.dst.a[0] & 0x01) == 0x00) {
1206
0
        unicast = true;
1207
0
    }
1208
1209
    /* only two wildcard rules are acceptable for IPv4 and IPv6 multicast */
1210
0
    if (memcmp(key->eth.dst.a, ipv4_mcast.a, sizeof(key->eth.dst.a)) == 0 &&
1211
0
        memcmp(mask->eth.dst.a, ipv4_mask.a, sizeof(mask->eth.dst.a)) == 0) {
1212
0
        multicast = true;
1213
0
    }
1214
0
    if (memcmp(key->eth.dst.a, ipv6_mcast.a, sizeof(key->eth.dst.a)) == 0 &&
1215
0
        memcmp(mask->eth.dst.a, ipv6_mask.a, sizeof(mask->eth.dst.a)) == 0) {
1216
0
        multicast = true;
1217
0
    }
1218
1219
0
    if (!unicast && !multicast) {
1220
0
        return -ROCKER_EINVAL;
1221
0
    }
1222
1223
0
    key->eth.vlan_id = rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]);
1224
0
    mask->eth.vlan_id =
1225
0
        rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID_MASK]);
1226
1227
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]) {
1228
0
        action->goto_tbl =
1229
0
            rocker_tlv_get_le16(flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]);
1230
1231
0
        if (action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING &&
1232
0
            action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_MULTICAST_ROUTING) {
1233
0
            return -ROCKER_EINVAL;
1234
0
        }
1235
1236
0
        if (unicast &&
1237
0
            action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING) {
1238
0
            return -ROCKER_EINVAL;
1239
0
        }
1240
1241
0
        if (multicast &&
1242
0
            action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_MULTICAST_ROUTING) {
1243
0
            return -ROCKER_EINVAL;
1244
0
        }
1245
0
    }
1246
1247
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_COPY_CPU_ACTION]) {
1248
0
        action->apply.copy_to_cpu =
1249
0
            rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_COPY_CPU_ACTION]);
1250
0
    }
1251
1252
0
    return ROCKER_OK;
1253
0
}
1254
1255
static int of_dpa_cmd_add_bridging(OfDpaFlow *flow, RockerTlv **flow_tlvs)
1256
0
{
1257
0
    OfDpaFlowKey *key = &flow->key;
1258
0
    OfDpaFlowKey *mask = &flow->mask;
1259
0
    OfDpaFlowAction *action = &flow->action;
1260
0
    bool unicast = false;
1261
0
    bool dst_mac = false;
1262
0
    bool dst_mac_mask = false;
1263
0
    enum {
1264
0
        BRIDGING_MODE_UNKNOWN,
1265
0
        BRIDGING_MODE_VLAN_UCAST,
1266
0
        BRIDGING_MODE_VLAN_MCAST,
1267
0
        BRIDGING_MODE_VLAN_DFLT,
1268
0
        BRIDGING_MODE_TUNNEL_UCAST,
1269
0
        BRIDGING_MODE_TUNNEL_MCAST,
1270
0
        BRIDGING_MODE_TUNNEL_DFLT,
1271
0
    } mode = BRIDGING_MODE_UNKNOWN;
1272
1273
0
    key->tbl_id = ROCKER_OF_DPA_TABLE_ID_BRIDGING;
1274
1275
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]) {
1276
0
        key->eth.vlan_id =
1277
0
            rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]);
1278
0
        mask->eth.vlan_id = 0xffff;
1279
0
        key->width = FLOW_KEY_WIDTH(eth.vlan_id);
1280
0
    }
1281
1282
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_TUNNEL_ID]) {
1283
0
        key->tunnel_id =
1284
0
            rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_TUNNEL_ID]);
1285
0
        mask->tunnel_id = 0xffffffff;
1286
0
        key->width = FLOW_KEY_WIDTH(tunnel_id);
1287
0
    }
1288
1289
    /* can't do VLAN bridging and tunnel bridging at same time */
1290
0
    if (key->eth.vlan_id && key->tunnel_id) {
1291
0
        DPRINTF("can't do VLAN bridging and tunnel bridging at same time\n");
1292
0
        return -ROCKER_EINVAL;
1293
0
    }
1294
1295
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]) {
1296
0
        memcpy(key->eth.dst.a,
1297
0
               rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]),
1298
0
               sizeof(key->eth.dst.a));
1299
0
        key->width = FLOW_KEY_WIDTH(eth.dst);
1300
0
        dst_mac = true;
1301
0
        unicast = (key->eth.dst.a[0] & 0x01) == 0x00;
1302
0
    }
1303
1304
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC_MASK]) {
1305
0
        memcpy(mask->eth.dst.a,
1306
0
               rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC_MASK]),
1307
0
               sizeof(mask->eth.dst.a));
1308
0
        key->width = FLOW_KEY_WIDTH(eth.dst);
1309
0
        dst_mac_mask = true;
1310
0
    } else if (flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]) {
1311
0
        memcpy(mask->eth.dst.a, ff_mac.a, sizeof(mask->eth.dst.a));
1312
0
    }
1313
1314
0
    if (key->eth.vlan_id) {
1315
0
        if (dst_mac && !dst_mac_mask) {
1316
0
            mode = unicast ? BRIDGING_MODE_VLAN_UCAST :
1317
0
                             BRIDGING_MODE_VLAN_MCAST;
1318
0
        } else if ((dst_mac && dst_mac_mask) || !dst_mac) {
1319
0
            mode = BRIDGING_MODE_VLAN_DFLT;
1320
0
        }
1321
0
    } else if (key->tunnel_id) {
1322
0
        if (dst_mac && !dst_mac_mask) {
1323
0
            mode = unicast ? BRIDGING_MODE_TUNNEL_UCAST :
1324
0
                             BRIDGING_MODE_TUNNEL_MCAST;
1325
0
        } else if ((dst_mac && dst_mac_mask) || !dst_mac) {
1326
0
            mode = BRIDGING_MODE_TUNNEL_DFLT;
1327
0
        }
1328
0
    }
1329
1330
0
    if (mode == BRIDGING_MODE_UNKNOWN) {
1331
0
        DPRINTF("Unknown bridging mode\n");
1332
0
        return -ROCKER_EINVAL;
1333
0
    }
1334
1335
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]) {
1336
0
        action->goto_tbl =
1337
0
            rocker_tlv_get_le16(flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]);
1338
0
        if (action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_ACL_POLICY) {
1339
0
            DPRINTF("Briding goto tbl must be ACL policy\n");
1340
0
            return -ROCKER_EINVAL;
1341
0
        }
1342
0
    }
1343
1344
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]) {
1345
0
        action->write.group_id =
1346
0
            rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]);
1347
0
        switch (mode) {
1348
0
        case BRIDGING_MODE_VLAN_UCAST:
1349
0
            if (ROCKER_GROUP_TYPE_GET(action->write.group_id) !=
1350
0
                ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE) {
1351
0
                DPRINTF("Bridging mode vlan ucast needs L2 "
1352
0
                        "interface group (0x%08x)\n",
1353
0
                        action->write.group_id);
1354
0
                return -ROCKER_EINVAL;
1355
0
            }
1356
0
            break;
1357
0
        case BRIDGING_MODE_VLAN_MCAST:
1358
0
            if (ROCKER_GROUP_TYPE_GET(action->write.group_id) !=
1359
0
                ROCKER_OF_DPA_GROUP_TYPE_L2_MCAST) {
1360
0
                DPRINTF("Bridging mode vlan mcast needs L2 "
1361
0
                        "mcast group (0x%08x)\n",
1362
0
                        action->write.group_id);
1363
0
                return -ROCKER_EINVAL;
1364
0
            }
1365
0
            break;
1366
0
        case BRIDGING_MODE_VLAN_DFLT:
1367
0
            if (ROCKER_GROUP_TYPE_GET(action->write.group_id) !=
1368
0
                ROCKER_OF_DPA_GROUP_TYPE_L2_FLOOD) {
1369
0
                DPRINTF("Bridging mode vlan dflt needs L2 "
1370
0
                        "flood group (0x%08x)\n",
1371
0
                        action->write.group_id);
1372
0
                return -ROCKER_EINVAL;
1373
0
            }
1374
0
            break;
1375
0
        case BRIDGING_MODE_TUNNEL_MCAST:
1376
0
            if (ROCKER_GROUP_TYPE_GET(action->write.group_id) !=
1377
0
                ROCKER_OF_DPA_GROUP_TYPE_L2_OVERLAY) {
1378
0
                DPRINTF("Bridging mode tunnel mcast needs L2 "
1379
0
                        "overlay group (0x%08x)\n",
1380
0
                        action->write.group_id);
1381
0
                return -ROCKER_EINVAL;
1382
0
            }
1383
0
            break;
1384
0
        case BRIDGING_MODE_TUNNEL_DFLT:
1385
0
            if (ROCKER_GROUP_TYPE_GET(action->write.group_id) !=
1386
0
                ROCKER_OF_DPA_GROUP_TYPE_L2_OVERLAY) {
1387
0
                DPRINTF("Bridging mode tunnel dflt needs L2 "
1388
0
                        "overlay group (0x%08x)\n",
1389
0
                        action->write.group_id);
1390
0
                return -ROCKER_EINVAL;
1391
0
            }
1392
0
            break;
1393
0
        default:
1394
0
            return -ROCKER_EINVAL;
1395
0
        }
1396
0
    }
1397
1398
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_TUNNEL_LPORT]) {
1399
0
        action->write.tun_log_lport =
1400
0
            rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_TUNNEL_LPORT]);
1401
0
        if (mode != BRIDGING_MODE_TUNNEL_UCAST) {
1402
0
            DPRINTF("Have tunnel logical port but not "
1403
0
                    "in bridging tunnel mode\n");
1404
0
            return -ROCKER_EINVAL;
1405
0
        }
1406
0
    }
1407
1408
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_COPY_CPU_ACTION]) {
1409
0
        action->apply.copy_to_cpu =
1410
0
            rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_COPY_CPU_ACTION]);
1411
0
    }
1412
1413
0
    return ROCKER_OK;
1414
0
}
1415
1416
static int of_dpa_cmd_add_unicast_routing(OfDpaFlow *flow,
1417
                                          RockerTlv **flow_tlvs)
1418
0
{
1419
0
    OfDpaFlowKey *key = &flow->key;
1420
0
    OfDpaFlowKey *mask = &flow->mask;
1421
0
    OfDpaFlowAction *action = &flow->action;
1422
0
    enum {
1423
0
        UNICAST_ROUTING_MODE_UNKNOWN,
1424
0
        UNICAST_ROUTING_MODE_IPV4,
1425
0
        UNICAST_ROUTING_MODE_IPV6,
1426
0
    } mode = UNICAST_ROUTING_MODE_UNKNOWN;
1427
0
    uint8_t type;
1428
1429
0
    if (!flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE]) {
1430
0
        return -ROCKER_EINVAL;
1431
0
    }
1432
1433
0
    key->tbl_id = ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING;
1434
0
    key->width = FLOW_KEY_WIDTH(ipv6.addr.dst);
1435
1436
0
    key->eth.type = rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE]);
1437
0
    switch (ntohs(key->eth.type)) {
1438
0
    case 0x0800:
1439
0
        mode = UNICAST_ROUTING_MODE_IPV4;
1440
0
        break;
1441
0
    case 0x86dd:
1442
0
        mode = UNICAST_ROUTING_MODE_IPV6;
1443
0
        break;
1444
0
    default:
1445
0
        return -ROCKER_EINVAL;
1446
0
    }
1447
0
    mask->eth.type = htons(0xffff);
1448
1449
0
    switch (mode) {
1450
0
    case UNICAST_ROUTING_MODE_IPV4:
1451
0
        if (!flow_tlvs[ROCKER_TLV_OF_DPA_DST_IP]) {
1452
0
            return -ROCKER_EINVAL;
1453
0
        }
1454
0
        key->ipv4.addr.dst =
1455
0
            rocker_tlv_get_u32(flow_tlvs[ROCKER_TLV_OF_DPA_DST_IP]);
1456
0
        if (ipv4_addr_is_multicast(key->ipv4.addr.dst)) {
1457
0
            return -ROCKER_EINVAL;
1458
0
        }
1459
0
        flow->lpm = of_dpa_mask2prefix(htonl(0xffffffff));
1460
0
        if (flow_tlvs[ROCKER_TLV_OF_DPA_DST_IP_MASK]) {
1461
0
            mask->ipv4.addr.dst =
1462
0
                rocker_tlv_get_u32(flow_tlvs[ROCKER_TLV_OF_DPA_DST_IP_MASK]);
1463
0
            flow->lpm = of_dpa_mask2prefix(mask->ipv4.addr.dst);
1464
0
        }
1465
0
        break;
1466
0
    case UNICAST_ROUTING_MODE_IPV6:
1467
0
        if (!flow_tlvs[ROCKER_TLV_OF_DPA_DST_IPV6]) {
1468
0
            return -ROCKER_EINVAL;
1469
0
        }
1470
0
        memcpy(&key->ipv6.addr.dst,
1471
0
               rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_IPV6]),
1472
0
               sizeof(key->ipv6.addr.dst));
1473
0
        if (ipv6_addr_is_multicast(&key->ipv6.addr.dst)) {
1474
0
            return -ROCKER_EINVAL;
1475
0
        }
1476
0
        if (flow_tlvs[ROCKER_TLV_OF_DPA_DST_IPV6_MASK]) {
1477
0
            memcpy(&mask->ipv6.addr.dst,
1478
0
                   rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_IPV6_MASK]),
1479
0
                   sizeof(mask->ipv6.addr.dst));
1480
0
        }
1481
0
        break;
1482
0
    default:
1483
0
        return -ROCKER_EINVAL;
1484
0
    }
1485
1486
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]) {
1487
0
        action->goto_tbl =
1488
0
            rocker_tlv_get_le16(flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]);
1489
0
        if (action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_ACL_POLICY) {
1490
0
            return -ROCKER_EINVAL;
1491
0
        }
1492
0
    }
1493
1494
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]) {
1495
0
        action->write.group_id =
1496
0
            rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]);
1497
0
        type = ROCKER_GROUP_TYPE_GET(action->write.group_id);
1498
0
        if (type != ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE &&
1499
0
            type != ROCKER_OF_DPA_GROUP_TYPE_L3_UCAST &&
1500
0
            type != ROCKER_OF_DPA_GROUP_TYPE_L3_ECMP) {
1501
0
            return -ROCKER_EINVAL;
1502
0
        }
1503
0
    }
1504
1505
0
    return ROCKER_OK;
1506
0
}
1507
1508
static int of_dpa_cmd_add_multicast_routing(OfDpaFlow *flow,
1509
                                            RockerTlv **flow_tlvs)
1510
0
{
1511
0
    OfDpaFlowKey *key = &flow->key;
1512
0
    OfDpaFlowKey *mask = &flow->mask;
1513
0
    OfDpaFlowAction *action = &flow->action;
1514
0
    enum {
1515
0
        MULTICAST_ROUTING_MODE_UNKNOWN,
1516
0
        MULTICAST_ROUTING_MODE_IPV4,
1517
0
        MULTICAST_ROUTING_MODE_IPV6,
1518
0
    } mode = MULTICAST_ROUTING_MODE_UNKNOWN;
1519
1520
0
    if (!flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE] ||
1521
0
        !flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]) {
1522
0
        return -ROCKER_EINVAL;
1523
0
    }
1524
1525
0
    key->tbl_id = ROCKER_OF_DPA_TABLE_ID_MULTICAST_ROUTING;
1526
0
    key->width = FLOW_KEY_WIDTH(ipv6.addr.dst);
1527
1528
0
    key->eth.type = rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE]);
1529
0
    switch (ntohs(key->eth.type)) {
1530
0
    case 0x0800:
1531
0
        mode = MULTICAST_ROUTING_MODE_IPV4;
1532
0
        break;
1533
0
    case 0x86dd:
1534
0
        mode = MULTICAST_ROUTING_MODE_IPV6;
1535
0
        break;
1536
0
    default:
1537
0
        return -ROCKER_EINVAL;
1538
0
    }
1539
1540
0
    key->eth.vlan_id = rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]);
1541
1542
0
    switch (mode) {
1543
0
    case MULTICAST_ROUTING_MODE_IPV4:
1544
1545
0
        if (flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IP]) {
1546
0
            key->ipv4.addr.src =
1547
0
                rocker_tlv_get_u32(flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IP]);
1548
0
        }
1549
1550
0
        if (flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IP_MASK]) {
1551
0
            mask->ipv4.addr.src =
1552
0
                rocker_tlv_get_u32(flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IP_MASK]);
1553
0
        }
1554
1555
0
        if (!flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IP]) {
1556
0
            if (mask->ipv4.addr.src != 0) {
1557
0
                return -ROCKER_EINVAL;
1558
0
            }
1559
0
        }
1560
1561
0
        if (!flow_tlvs[ROCKER_TLV_OF_DPA_DST_IP]) {
1562
0
            return -ROCKER_EINVAL;
1563
0
        }
1564
1565
0
        key->ipv4.addr.dst =
1566
0
            rocker_tlv_get_u32(flow_tlvs[ROCKER_TLV_OF_DPA_DST_IP]);
1567
0
        if (!ipv4_addr_is_multicast(key->ipv4.addr.dst)) {
1568
0
            return -ROCKER_EINVAL;
1569
0
        }
1570
1571
0
        break;
1572
1573
0
    case MULTICAST_ROUTING_MODE_IPV6:
1574
1575
0
        if (flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IPV6]) {
1576
0
            memcpy(&key->ipv6.addr.src,
1577
0
                   rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IPV6]),
1578
0
                   sizeof(key->ipv6.addr.src));
1579
0
        }
1580
1581
0
        if (flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IPV6_MASK]) {
1582
0
            memcpy(&mask->ipv6.addr.src,
1583
0
                   rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IPV6_MASK]),
1584
0
                   sizeof(mask->ipv6.addr.src));
1585
0
        }
1586
1587
0
        if (!flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IPV6]) {
1588
0
            if (mask->ipv6.addr.src.addr32[0] != 0 &&
1589
0
                mask->ipv6.addr.src.addr32[1] != 0 &&
1590
0
                mask->ipv6.addr.src.addr32[2] != 0 &&
1591
0
                mask->ipv6.addr.src.addr32[3] != 0) {
1592
0
                return -ROCKER_EINVAL;
1593
0
            }
1594
0
        }
1595
1596
0
        if (!flow_tlvs[ROCKER_TLV_OF_DPA_DST_IPV6]) {
1597
0
            return -ROCKER_EINVAL;
1598
0
        }
1599
1600
0
        memcpy(&key->ipv6.addr.dst,
1601
0
               rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_IPV6]),
1602
0
               sizeof(key->ipv6.addr.dst));
1603
0
        if (!ipv6_addr_is_multicast(&key->ipv6.addr.dst)) {
1604
0
            return -ROCKER_EINVAL;
1605
0
        }
1606
1607
0
        break;
1608
1609
0
    default:
1610
0
        return -ROCKER_EINVAL;
1611
0
    }
1612
1613
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]) {
1614
0
        action->goto_tbl =
1615
0
            rocker_tlv_get_le16(flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]);
1616
0
        if (action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_ACL_POLICY) {
1617
0
            return -ROCKER_EINVAL;
1618
0
        }
1619
0
    }
1620
1621
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]) {
1622
0
        action->write.group_id =
1623
0
            rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]);
1624
0
        if (ROCKER_GROUP_TYPE_GET(action->write.group_id) !=
1625
0
            ROCKER_OF_DPA_GROUP_TYPE_L3_MCAST) {
1626
0
            return -ROCKER_EINVAL;
1627
0
        }
1628
0
        action->write.vlan_id = key->eth.vlan_id;
1629
0
    }
1630
1631
0
    return ROCKER_OK;
1632
0
}
1633
1634
static void of_dpa_cmd_add_acl_ip(OfDpaFlowKey *key, OfDpaFlowKey *mask,
1635
                                  RockerTlv **flow_tlvs)
1636
0
{
1637
0
    key->width = FLOW_KEY_WIDTH(ip.tos);
1638
1639
0
    key->ip.proto = 0;
1640
0
    key->ip.tos = 0;
1641
0
    mask->ip.proto = 0;
1642
0
    mask->ip.tos = 0;
1643
1644
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_IP_PROTO]) {
1645
0
        key->ip.proto =
1646
0
            rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_IP_PROTO]);
1647
0
    }
1648
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_IP_PROTO_MASK]) {
1649
0
        mask->ip.proto =
1650
0
            rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_IP_PROTO_MASK]);
1651
0
    }
1652
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_IP_DSCP]) {
1653
0
        key->ip.tos =
1654
0
            rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_IP_DSCP]);
1655
0
    }
1656
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_IP_DSCP_MASK]) {
1657
0
        mask->ip.tos =
1658
0
            rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_IP_DSCP_MASK]);
1659
0
    }
1660
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_IP_ECN]) {
1661
0
        key->ip.tos |=
1662
0
            rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_IP_ECN]) << 6;
1663
0
    }
1664
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_IP_ECN_MASK]) {
1665
0
        mask->ip.tos |=
1666
0
            rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_IP_ECN_MASK]) << 6;
1667
0
    }
1668
0
}
1669
1670
static int of_dpa_cmd_add_acl(OfDpaFlow *flow, RockerTlv **flow_tlvs)
1671
0
{
1672
0
    OfDpaFlowKey *key = &flow->key;
1673
0
    OfDpaFlowKey *mask = &flow->mask;
1674
0
    OfDpaFlowAction *action = &flow->action;
1675
0
    enum {
1676
0
        ACL_MODE_UNKNOWN,
1677
0
        ACL_MODE_IPV4_VLAN,
1678
0
        ACL_MODE_IPV6_VLAN,
1679
0
        ACL_MODE_IPV4_TENANT,
1680
0
        ACL_MODE_IPV6_TENANT,
1681
0
        ACL_MODE_NON_IP_VLAN,
1682
0
        ACL_MODE_NON_IP_TENANT,
1683
0
        ACL_MODE_ANY_VLAN,
1684
0
        ACL_MODE_ANY_TENANT,
1685
0
    } mode = ACL_MODE_UNKNOWN;
1686
1687
0
    if (!flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT] ||
1688
0
        !flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE]) {
1689
0
        return -ROCKER_EINVAL;
1690
0
    }
1691
1692
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID] &&
1693
0
        flow_tlvs[ROCKER_TLV_OF_DPA_TUNNEL_ID]) {
1694
0
        return -ROCKER_EINVAL;
1695
0
    }
1696
1697
0
    key->tbl_id = ROCKER_OF_DPA_TABLE_ID_ACL_POLICY;
1698
0
    key->width = FLOW_KEY_WIDTH(eth.type);
1699
1700
0
    key->in_pport = rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT]);
1701
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT_MASK]) {
1702
0
        mask->in_pport =
1703
0
            rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT_MASK]);
1704
0
    }
1705
1706
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC]) {
1707
0
        memcpy(key->eth.src.a,
1708
0
               rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC]),
1709
0
               sizeof(key->eth.src.a));
1710
0
    }
1711
1712
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC_MASK]) {
1713
0
        memcpy(mask->eth.src.a,
1714
0
               rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC_MASK]),
1715
0
               sizeof(mask->eth.src.a));
1716
0
    }
1717
1718
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]) {
1719
0
        memcpy(key->eth.dst.a,
1720
0
               rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]),
1721
0
               sizeof(key->eth.dst.a));
1722
0
    }
1723
1724
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC_MASK]) {
1725
0
        memcpy(mask->eth.dst.a,
1726
0
               rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC_MASK]),
1727
0
               sizeof(mask->eth.dst.a));
1728
0
    }
1729
1730
0
    key->eth.type = rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE]);
1731
0
    if (key->eth.type) {
1732
0
        mask->eth.type = 0xffff;
1733
0
    }
1734
1735
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]) {
1736
0
        key->eth.vlan_id =
1737
0
            rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]);
1738
0
    }
1739
1740
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID_MASK]) {
1741
0
        mask->eth.vlan_id =
1742
0
            rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID_MASK]);
1743
0
    }
1744
1745
0
    switch (ntohs(key->eth.type)) {
1746
0
    case 0x0000:
1747
0
        mode = (key->eth.vlan_id) ? ACL_MODE_ANY_VLAN : ACL_MODE_ANY_TENANT;
1748
0
        break;
1749
0
    case 0x0800:
1750
0
        mode = (key->eth.vlan_id) ? ACL_MODE_IPV4_VLAN : ACL_MODE_IPV4_TENANT;
1751
0
        break;
1752
0
    case 0x86dd:
1753
0
        mode = (key->eth.vlan_id) ? ACL_MODE_IPV6_VLAN : ACL_MODE_IPV6_TENANT;
1754
0
        break;
1755
0
    default:
1756
0
        mode = (key->eth.vlan_id) ? ACL_MODE_NON_IP_VLAN :
1757
0
                                    ACL_MODE_NON_IP_TENANT;
1758
0
        break;
1759
0
    }
1760
1761
    /* XXX only supporting VLAN modes for now */
1762
0
    if (mode != ACL_MODE_IPV4_VLAN &&
1763
0
        mode != ACL_MODE_IPV6_VLAN &&
1764
0
        mode != ACL_MODE_NON_IP_VLAN &&
1765
0
        mode != ACL_MODE_ANY_VLAN) {
1766
0
        return -ROCKER_EINVAL;
1767
0
    }
1768
1769
0
    switch (ntohs(key->eth.type)) {
1770
0
    case 0x0800:
1771
0
    case 0x86dd:
1772
0
        of_dpa_cmd_add_acl_ip(key, mask, flow_tlvs);
1773
0
        break;
1774
0
    }
1775
1776
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]) {
1777
0
        action->write.group_id =
1778
0
            rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]);
1779
0
    }
1780
1781
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_COPY_CPU_ACTION]) {
1782
0
        action->apply.copy_to_cpu =
1783
0
            rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_COPY_CPU_ACTION]);
1784
0
    }
1785
1786
0
    return ROCKER_OK;
1787
0
}
1788
1789
static int of_dpa_cmd_flow_add_mod(OfDpa *of_dpa, OfDpaFlow *flow,
1790
                                   RockerTlv **flow_tlvs)
1791
0
{
1792
0
    enum rocker_of_dpa_table_id tbl;
1793
0
    int err = ROCKER_OK;
1794
1795
0
    if (!flow_tlvs[ROCKER_TLV_OF_DPA_TABLE_ID] ||
1796
0
        !flow_tlvs[ROCKER_TLV_OF_DPA_PRIORITY] ||
1797
0
        !flow_tlvs[ROCKER_TLV_OF_DPA_HARDTIME]) {
1798
0
        return -ROCKER_EINVAL;
1799
0
    }
1800
1801
0
    tbl = rocker_tlv_get_le16(flow_tlvs[ROCKER_TLV_OF_DPA_TABLE_ID]);
1802
0
    flow->priority = rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_PRIORITY]);
1803
0
    flow->hardtime = rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_HARDTIME]);
1804
1805
0
    if (flow_tlvs[ROCKER_TLV_OF_DPA_IDLETIME]) {
1806
0
        if (tbl == ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT ||
1807
0
            tbl == ROCKER_OF_DPA_TABLE_ID_VLAN ||
1808
0
            tbl == ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC) {
1809
0
            return -ROCKER_EINVAL;
1810
0
        }
1811
0
        flow->idletime =
1812
0
            rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IDLETIME]);
1813
0
    }
1814
1815
0
    switch (tbl) {
1816
0
    case ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT:
1817
0
        err = of_dpa_cmd_add_ig_port(flow, flow_tlvs);
1818
0
        break;
1819
0
    case ROCKER_OF_DPA_TABLE_ID_VLAN:
1820
0
        err = of_dpa_cmd_add_vlan(flow, flow_tlvs);
1821
0
        break;
1822
0
    case ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC:
1823
0
        err = of_dpa_cmd_add_term_mac(flow, flow_tlvs);
1824
0
        break;
1825
0
    case ROCKER_OF_DPA_TABLE_ID_BRIDGING:
1826
0
        err = of_dpa_cmd_add_bridging(flow, flow_tlvs);
1827
0
        break;
1828
0
    case ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING:
1829
0
        err = of_dpa_cmd_add_unicast_routing(flow, flow_tlvs);
1830
0
        break;
1831
0
    case ROCKER_OF_DPA_TABLE_ID_MULTICAST_ROUTING:
1832
0
        err = of_dpa_cmd_add_multicast_routing(flow, flow_tlvs);
1833
0
        break;
1834
0
    case ROCKER_OF_DPA_TABLE_ID_ACL_POLICY:
1835
0
        err = of_dpa_cmd_add_acl(flow, flow_tlvs);
1836
0
        break;
1837
0
    }
1838
1839
0
    return err;
1840
0
}
1841
1842
static int of_dpa_cmd_flow_add(OfDpa *of_dpa, uint64_t cookie,
1843
                               RockerTlv **flow_tlvs)
1844
0
{
1845
0
    OfDpaFlow *flow = of_dpa_flow_find(of_dpa, cookie);
1846
0
    int err = ROCKER_OK;
1847
1848
0
    if (flow) {
1849
0
        return -ROCKER_EEXIST;
1850
0
    }
1851
1852
0
    flow = of_dpa_flow_alloc(cookie);
1853
1854
0
    err = of_dpa_cmd_flow_add_mod(of_dpa, flow, flow_tlvs);
1855
0
    if (err) {
1856
0
        g_free(flow);
1857
0
        return err;
1858
0
    }
1859
1860
0
    return of_dpa_flow_add(of_dpa, flow);
1861
0
}
1862
1863
static int of_dpa_cmd_flow_mod(OfDpa *of_dpa, uint64_t cookie,
1864
                               RockerTlv **flow_tlvs)
1865
0
{
1866
0
    OfDpaFlow *flow = of_dpa_flow_find(of_dpa, cookie);
1867
1868
0
    if (!flow) {
1869
0
        return -ROCKER_ENOENT;
1870
0
    }
1871
1872
0
    return of_dpa_cmd_flow_add_mod(of_dpa, flow, flow_tlvs);
1873
0
}
1874
1875
static int of_dpa_cmd_flow_del(OfDpa *of_dpa, uint64_t cookie)
1876
0
{
1877
0
    OfDpaFlow *flow = of_dpa_flow_find(of_dpa, cookie);
1878
1879
0
    if (!flow) {
1880
0
        return -ROCKER_ENOENT;
1881
0
    }
1882
1883
0
    of_dpa_flow_del(of_dpa, flow);
1884
1885
0
    return ROCKER_OK;
1886
0
}
1887
1888
static int of_dpa_cmd_flow_get_stats(OfDpa *of_dpa, uint64_t cookie,
1889
                                     struct desc_info *info, char *buf)
1890
0
{
1891
0
    OfDpaFlow *flow = of_dpa_flow_find(of_dpa, cookie);
1892
0
    size_t tlv_size;
1893
0
    int64_t now = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) / 1000;
1894
0
    int pos;
1895
1896
0
    if (!flow) {
1897
0
        return -ROCKER_ENOENT;
1898
0
    }
1899
1900
0
    tlv_size = rocker_tlv_total_size(sizeof(uint32_t)) +  /* duration */
1901
0
               rocker_tlv_total_size(sizeof(uint64_t)) +  /* rx_pkts */
1902
0
               rocker_tlv_total_size(sizeof(uint64_t));   /* tx_ptks */
1903
1904
0
    if (tlv_size > desc_buf_size(info)) {
1905
0
        return -ROCKER_EMSGSIZE;
1906
0
    }
1907
1908
0
    pos = 0;
1909
0
    rocker_tlv_put_le32(buf, &pos, ROCKER_TLV_OF_DPA_FLOW_STAT_DURATION,
1910
0
                        (int32_t)(now - flow->stats.install_time));
1911
0
    rocker_tlv_put_le64(buf, &pos, ROCKER_TLV_OF_DPA_FLOW_STAT_RX_PKTS,
1912
0
                        flow->stats.rx_pkts);
1913
0
    rocker_tlv_put_le64(buf, &pos, ROCKER_TLV_OF_DPA_FLOW_STAT_TX_PKTS,
1914
0
                        flow->stats.tx_pkts);
1915
1916
0
    return desc_set_buf(info, tlv_size);
1917
0
}
1918
1919
static int of_dpa_flow_cmd(OfDpa *of_dpa, struct desc_info *info,
1920
                           char *buf, uint16_t cmd,
1921
                           RockerTlv **flow_tlvs)
1922
0
{
1923
0
    uint64_t cookie;
1924
1925
0
    if (!flow_tlvs[ROCKER_TLV_OF_DPA_COOKIE]) {
1926
0
        return -ROCKER_EINVAL;
1927
0
    }
1928
1929
0
    cookie = rocker_tlv_get_le64(flow_tlvs[ROCKER_TLV_OF_DPA_COOKIE]);
1930
1931
0
    switch (cmd) {
1932
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_ADD:
1933
0
        return of_dpa_cmd_flow_add(of_dpa, cookie, flow_tlvs);
1934
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_MOD:
1935
0
        return of_dpa_cmd_flow_mod(of_dpa, cookie, flow_tlvs);
1936
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_DEL:
1937
0
        return of_dpa_cmd_flow_del(of_dpa, cookie);
1938
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_GET_STATS:
1939
0
        return of_dpa_cmd_flow_get_stats(of_dpa, cookie, info, buf);
1940
0
    }
1941
1942
0
    return -ROCKER_ENOTSUP;
1943
0
}
1944
1945
static int of_dpa_cmd_add_l2_interface(OfDpaGroup *group,
1946
                                       RockerTlv **group_tlvs)
1947
0
{
1948
0
    if (!group_tlvs[ROCKER_TLV_OF_DPA_OUT_PPORT] ||
1949
0
        !group_tlvs[ROCKER_TLV_OF_DPA_POP_VLAN]) {
1950
0
        return -ROCKER_EINVAL;
1951
0
    }
1952
1953
0
    group->l2_interface.out_pport =
1954
0
        rocker_tlv_get_le32(group_tlvs[ROCKER_TLV_OF_DPA_OUT_PPORT]);
1955
0
    group->l2_interface.pop_vlan =
1956
0
        rocker_tlv_get_u8(group_tlvs[ROCKER_TLV_OF_DPA_POP_VLAN]);
1957
1958
0
    return ROCKER_OK;
1959
0
}
1960
1961
static int of_dpa_cmd_add_l2_rewrite(OfDpa *of_dpa, OfDpaGroup *group,
1962
                                     RockerTlv **group_tlvs)
1963
0
{
1964
0
    OfDpaGroup *l2_interface_group;
1965
1966
0
    if (!group_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID_LOWER]) {
1967
0
        return -ROCKER_EINVAL;
1968
0
    }
1969
1970
0
    group->l2_rewrite.group_id =
1971
0
        rocker_tlv_get_le32(group_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID_LOWER]);
1972
1973
0
    l2_interface_group = of_dpa_group_find(of_dpa, group->l2_rewrite.group_id);
1974
0
    if (!l2_interface_group ||
1975
0
        ROCKER_GROUP_TYPE_GET(l2_interface_group->id) !=
1976
0
                              ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE) {
1977
0
        DPRINTF("l2 rewrite group needs a valid l2 interface group\n");
1978
0
        return -ROCKER_EINVAL;
1979
0
    }
1980
1981
0
    if (group_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC]) {
1982
0
        memcpy(group->l2_rewrite.src_mac.a,
1983
0
               rocker_tlv_data(group_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC]),
1984
0
               sizeof(group->l2_rewrite.src_mac.a));
1985
0
    }
1986
1987
0
    if (group_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]) {
1988
0
        memcpy(group->l2_rewrite.dst_mac.a,
1989
0
               rocker_tlv_data(group_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]),
1990
0
               sizeof(group->l2_rewrite.dst_mac.a));
1991
0
    }
1992
1993
0
    if (group_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]) {
1994
0
        group->l2_rewrite.vlan_id =
1995
0
            rocker_tlv_get_u16(group_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]);
1996
0
        if (ROCKER_GROUP_VLAN_GET(l2_interface_group->id) !=
1997
0
            (ntohs(group->l2_rewrite.vlan_id) & VLAN_VID_MASK)) {
1998
0
            DPRINTF("Set VLAN ID must be same as L2 interface group\n");
1999
0
            return -ROCKER_EINVAL;
2000
0
        }
2001
0
    }
2002
2003
0
    return ROCKER_OK;
2004
0
}
2005
2006
static int of_dpa_cmd_add_l2_flood(OfDpa *of_dpa, OfDpaGroup *group,
2007
                                   RockerTlv **group_tlvs)
2008
0
{
2009
0
    OfDpaGroup *l2_group;
2010
0
    RockerTlv **tlvs;
2011
0
    int err;
2012
0
    int i;
2013
2014
0
    if (!group_tlvs[ROCKER_TLV_OF_DPA_GROUP_COUNT] ||
2015
0
        !group_tlvs[ROCKER_TLV_OF_DPA_GROUP_IDS]) {
2016
0
        return -ROCKER_EINVAL;
2017
0
    }
2018
2019
0
    group->l2_flood.group_count =
2020
0
        rocker_tlv_get_le16(group_tlvs[ROCKER_TLV_OF_DPA_GROUP_COUNT]);
2021
2022
0
    tlvs = g_new0(RockerTlv *, group->l2_flood.group_count + 1);
2023
2024
0
    g_free(group->l2_flood.group_ids);
2025
0
    group->l2_flood.group_ids =
2026
0
        g_new0(uint32_t, group->l2_flood.group_count);
2027
2028
0
    rocker_tlv_parse_nested(tlvs, group->l2_flood.group_count,
2029
0
                            group_tlvs[ROCKER_TLV_OF_DPA_GROUP_IDS]);
2030
2031
0
    for (i = 0; i < group->l2_flood.group_count; i++) {
2032
0
        if (!tlvs[i + 1]) {
2033
0
            err = -ROCKER_EINVAL;
2034
0
            goto err_out;
2035
0
        }
2036
0
        group->l2_flood.group_ids[i] = rocker_tlv_get_le32(tlvs[i + 1]);
2037
0
    }
2038
2039
    /* All of the L2 interface groups referenced by the L2 flood
2040
     * must have same VLAN
2041
     */
2042
2043
0
    for (i = 0; i < group->l2_flood.group_count; i++) {
2044
0
        l2_group = of_dpa_group_find(of_dpa, group->l2_flood.group_ids[i]);
2045
0
        if (!l2_group) {
2046
0
            continue;
2047
0
        }
2048
0
        if ((ROCKER_GROUP_TYPE_GET(l2_group->id) ==
2049
0
             ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE) &&
2050
0
            (ROCKER_GROUP_VLAN_GET(l2_group->id) !=
2051
0
             ROCKER_GROUP_VLAN_GET(group->id))) {
2052
0
            DPRINTF("l2 interface group 0x%08x VLAN doesn't match l2 "
2053
0
                    "flood group 0x%08x\n",
2054
0
                    group->l2_flood.group_ids[i], group->id);
2055
0
            err = -ROCKER_EINVAL;
2056
0
            goto err_out;
2057
0
        }
2058
0
    }
2059
2060
0
    g_free(tlvs);
2061
0
    return ROCKER_OK;
2062
2063
0
err_out:
2064
0
    group->l2_flood.group_count = 0;
2065
0
    g_free(group->l2_flood.group_ids);
2066
0
    group->l2_flood.group_ids = NULL;
2067
0
    g_free(tlvs);
2068
2069
0
    return err;
2070
0
}
2071
2072
static int of_dpa_cmd_add_l3_unicast(OfDpaGroup *group, RockerTlv **group_tlvs)
2073
0
{
2074
0
    if (!group_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID_LOWER]) {
2075
0
        return -ROCKER_EINVAL;
2076
0
    }
2077
2078
0
    group->l3_unicast.group_id =
2079
0
        rocker_tlv_get_le32(group_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID_LOWER]);
2080
2081
0
    if (group_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC]) {
2082
0
        memcpy(group->l3_unicast.src_mac.a,
2083
0
               rocker_tlv_data(group_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC]),
2084
0
               sizeof(group->l3_unicast.src_mac.a));
2085
0
    }
2086
2087
0
    if (group_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]) {
2088
0
        memcpy(group->l3_unicast.dst_mac.a,
2089
0
               rocker_tlv_data(group_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]),
2090
0
               sizeof(group->l3_unicast.dst_mac.a));
2091
0
    }
2092
2093
0
    if (group_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]) {
2094
0
        group->l3_unicast.vlan_id =
2095
0
            rocker_tlv_get_u16(group_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]);
2096
0
    }
2097
2098
0
    if (group_tlvs[ROCKER_TLV_OF_DPA_TTL_CHECK]) {
2099
0
        group->l3_unicast.ttl_check =
2100
0
            rocker_tlv_get_u8(group_tlvs[ROCKER_TLV_OF_DPA_TTL_CHECK]);
2101
0
    }
2102
2103
0
    return ROCKER_OK;
2104
0
}
2105
2106
static int of_dpa_cmd_group_do(OfDpa *of_dpa, uint32_t group_id,
2107
                               OfDpaGroup *group, RockerTlv **group_tlvs)
2108
0
{
2109
0
    uint8_t type = ROCKER_GROUP_TYPE_GET(group_id);
2110
2111
0
    switch (type) {
2112
0
    case ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE:
2113
0
        return of_dpa_cmd_add_l2_interface(group, group_tlvs);
2114
0
    case ROCKER_OF_DPA_GROUP_TYPE_L2_REWRITE:
2115
0
        return of_dpa_cmd_add_l2_rewrite(of_dpa, group, group_tlvs);
2116
0
    case ROCKER_OF_DPA_GROUP_TYPE_L2_FLOOD:
2117
    /* Treat L2 multicast group same as a L2 flood group */
2118
0
    case ROCKER_OF_DPA_GROUP_TYPE_L2_MCAST:
2119
0
        return of_dpa_cmd_add_l2_flood(of_dpa, group, group_tlvs);
2120
0
    case ROCKER_OF_DPA_GROUP_TYPE_L3_UCAST:
2121
0
        return of_dpa_cmd_add_l3_unicast(group, group_tlvs);
2122
0
    }
2123
2124
0
    return -ROCKER_ENOTSUP;
2125
0
}
2126
2127
static int of_dpa_cmd_group_add(OfDpa *of_dpa, uint32_t group_id,
2128
                                RockerTlv **group_tlvs)
2129
0
{
2130
0
    OfDpaGroup *group = of_dpa_group_find(of_dpa, group_id);
2131
0
    int err;
2132
2133
0
    if (group) {
2134
0
        return -ROCKER_EEXIST;
2135
0
    }
2136
2137
0
    group = of_dpa_group_alloc(group_id);
2138
2139
0
    err = of_dpa_cmd_group_do(of_dpa, group_id, group, group_tlvs);
2140
0
    if (err) {
2141
0
        goto err_cmd_add;
2142
0
    }
2143
2144
0
    err = of_dpa_group_add(of_dpa, group);
2145
0
    if (err) {
2146
0
        goto err_cmd_add;
2147
0
    }
2148
2149
0
    return ROCKER_OK;
2150
2151
0
err_cmd_add:
2152
0
    g_free(group);
2153
0
    return err;
2154
0
}
2155
2156
static int of_dpa_cmd_group_mod(OfDpa *of_dpa, uint32_t group_id,
2157
                                RockerTlv **group_tlvs)
2158
0
{
2159
0
    OfDpaGroup *group = of_dpa_group_find(of_dpa, group_id);
2160
2161
0
    if (!group) {
2162
0
        return -ROCKER_ENOENT;
2163
0
    }
2164
2165
0
    return of_dpa_cmd_group_do(of_dpa, group_id, group, group_tlvs);
2166
0
}
2167
2168
static int of_dpa_cmd_group_del(OfDpa *of_dpa, uint32_t group_id)
2169
0
{
2170
0
    OfDpaGroup *group = of_dpa_group_find(of_dpa, group_id);
2171
2172
0
    if (!group) {
2173
0
        return -ROCKER_ENOENT;
2174
0
    }
2175
2176
0
    return of_dpa_group_del(of_dpa, group);
2177
0
}
2178
2179
static int of_dpa_cmd_group_get_stats(OfDpa *of_dpa, uint32_t group_id,
2180
                                      struct desc_info *info, char *buf)
2181
0
{
2182
0
    return -ROCKER_ENOTSUP;
2183
0
}
2184
2185
static int of_dpa_group_cmd(OfDpa *of_dpa, struct desc_info *info,
2186
                            char *buf, uint16_t cmd, RockerTlv **group_tlvs)
2187
0
{
2188
0
    uint32_t group_id;
2189
2190
0
    if (!group_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]) {
2191
0
        return -ROCKER_EINVAL;
2192
0
    }
2193
2194
0
    group_id = rocker_tlv_get_le32(group_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]);
2195
2196
0
    switch (cmd) {
2197
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_ADD:
2198
0
        return of_dpa_cmd_group_add(of_dpa, group_id, group_tlvs);
2199
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_MOD:
2200
0
        return of_dpa_cmd_group_mod(of_dpa, group_id, group_tlvs);
2201
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_DEL:
2202
0
        return of_dpa_cmd_group_del(of_dpa, group_id);
2203
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_GET_STATS:
2204
0
        return of_dpa_cmd_group_get_stats(of_dpa, group_id, info, buf);
2205
0
    }
2206
2207
0
    return -ROCKER_ENOTSUP;
2208
0
}
2209
2210
static int of_dpa_cmd(World *world, struct desc_info *info,
2211
                      char *buf, uint16_t cmd, RockerTlv *cmd_info_tlv)
2212
0
{
2213
0
    OfDpa *of_dpa = world_private(world);
2214
0
    RockerTlv *tlvs[ROCKER_TLV_OF_DPA_MAX + 1];
2215
2216
0
    rocker_tlv_parse_nested(tlvs, ROCKER_TLV_OF_DPA_MAX, cmd_info_tlv);
2217
2218
0
    switch (cmd) {
2219
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_ADD:
2220
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_MOD:
2221
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_DEL:
2222
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_GET_STATS:
2223
0
        return of_dpa_flow_cmd(of_dpa, info, buf, cmd, tlvs);
2224
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_ADD:
2225
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_MOD:
2226
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_DEL:
2227
0
    case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_GET_STATS:
2228
0
        return of_dpa_group_cmd(of_dpa, info, buf, cmd, tlvs);
2229
0
    }
2230
2231
0
    return -ROCKER_ENOTSUP;
2232
0
}
2233
2234
static gboolean rocker_int64_equal(gconstpointer v1, gconstpointer v2)
2235
0
{
2236
0
    return *((const uint64_t *)v1) == *((const uint64_t *)v2);
2237
0
}
2238
2239
static guint rocker_int64_hash(gconstpointer v)
2240
0
{
2241
0
    return (guint)*(const uint64_t *)v;
2242
0
}
2243
2244
static int of_dpa_init(World *world)
2245
0
{
2246
0
    OfDpa *of_dpa = world_private(world);
2247
2248
0
    of_dpa->world = world;
2249
2250
0
    of_dpa->flow_tbl = g_hash_table_new_full(rocker_int64_hash,
2251
0
                                             rocker_int64_equal,
2252
0
                                             NULL, g_free);
2253
0
    if (!of_dpa->flow_tbl) {
2254
0
        return -ENOMEM;
2255
0
    }
2256
2257
0
    of_dpa->group_tbl = g_hash_table_new_full(g_int_hash, g_int_equal,
2258
0
                                              NULL, g_free);
2259
0
    if (!of_dpa->group_tbl) {
2260
0
        goto err_group_tbl;
2261
0
    }
2262
2263
    /* XXX hardcode some artificial table max values */
2264
0
    of_dpa->flow_tbl_max_size = 100;
2265
0
    of_dpa->group_tbl_max_size = 100;
2266
2267
0
    return 0;
2268
2269
0
err_group_tbl:
2270
0
    g_hash_table_destroy(of_dpa->flow_tbl);
2271
0
    return -ENOMEM;
2272
0
}
2273
2274
static void of_dpa_uninit(World *world)
2275
0
{
2276
0
    OfDpa *of_dpa = world_private(world);
2277
2278
0
    g_hash_table_destroy(of_dpa->group_tbl);
2279
0
    g_hash_table_destroy(of_dpa->flow_tbl);
2280
0
}
2281
2282
struct of_dpa_flow_fill_context {
2283
    RockerOfDpaFlowList *list;
2284
    uint32_t tbl_id;
2285
};
2286
2287
static void of_dpa_flow_fill(void *cookie, void *value, void *user_data)
2288
0
{
2289
0
    struct of_dpa_flow *flow = value;
2290
0
    struct of_dpa_flow_key *key = &flow->key;
2291
0
    struct of_dpa_flow_key *mask = &flow->mask;
2292
0
    struct of_dpa_flow_fill_context *flow_context = user_data;
2293
0
    RockerOfDpaFlow *nflow;
2294
0
    RockerOfDpaFlowKey *nkey;
2295
0
    RockerOfDpaFlowMask *nmask;
2296
0
    RockerOfDpaFlowAction *naction;
2297
2298
0
    if (flow_context->tbl_id != -1 &&
2299
0
        flow_context->tbl_id != key->tbl_id) {
2300
0
        return;
2301
0
    }
2302
2303
0
    nflow = g_malloc0(sizeof(*nflow));
2304
0
    nkey = nflow->key = g_malloc0(sizeof(*nkey));
2305
0
    nmask = nflow->mask = g_malloc0(sizeof(*nmask));
2306
0
    naction = nflow->action = g_malloc0(sizeof(*naction));
2307
2308
0
    nflow->cookie = flow->cookie;
2309
0
    nflow->hits = flow->stats.hits;
2310
0
    nkey->priority = flow->priority;
2311
0
    nkey->tbl_id = key->tbl_id;
2312
2313
0
    if (key->in_pport || mask->in_pport) {
2314
0
        nkey->has_in_pport = true;
2315
0
        nkey->in_pport = key->in_pport;
2316
0
    }
2317
2318
0
    if (nkey->has_in_pport && mask->in_pport != 0xffffffff) {
2319
0
        nmask->has_in_pport = true;
2320
0
        nmask->in_pport = mask->in_pport;
2321
0
    }
2322
2323
0
    if (key->eth.vlan_id || mask->eth.vlan_id) {
2324
0
        nkey->has_vlan_id = true;
2325
0
        nkey->vlan_id = ntohs(key->eth.vlan_id);
2326
0
    }
2327
2328
0
    if (nkey->has_vlan_id && mask->eth.vlan_id != 0xffff) {
2329
0
        nmask->has_vlan_id = true;
2330
0
        nmask->vlan_id = ntohs(mask->eth.vlan_id);
2331
0
    }
2332
2333
0
    if (key->tunnel_id || mask->tunnel_id) {
2334
0
        nkey->has_tunnel_id = true;
2335
0
        nkey->tunnel_id = key->tunnel_id;
2336
0
    }
2337
2338
0
    if (nkey->has_tunnel_id && mask->tunnel_id != 0xffffffff) {
2339
0
        nmask->has_tunnel_id = true;
2340
0
        nmask->tunnel_id = mask->tunnel_id;
2341
0
    }
2342
2343
0
    if (memcmp(key->eth.src.a, zero_mac.a, ETH_ALEN) ||
2344
0
        memcmp(mask->eth.src.a, zero_mac.a, ETH_ALEN)) {
2345
0
        nkey->eth_src = qemu_mac_strdup_printf(key->eth.src.a);
2346
0
    }
2347
2348
0
    if (nkey->eth_src && memcmp(mask->eth.src.a, ff_mac.a, ETH_ALEN)) {
2349
0
        nmask->eth_src = qemu_mac_strdup_printf(mask->eth.src.a);
2350
0
    }
2351
2352
0
    if (memcmp(key->eth.dst.a, zero_mac.a, ETH_ALEN) ||
2353
0
        memcmp(mask->eth.dst.a, zero_mac.a, ETH_ALEN)) {
2354
0
        nkey->eth_dst = qemu_mac_strdup_printf(key->eth.dst.a);
2355
0
    }
2356
2357
0
    if (nkey->eth_dst && memcmp(mask->eth.dst.a, ff_mac.a, ETH_ALEN)) {
2358
0
        nmask->eth_dst = qemu_mac_strdup_printf(mask->eth.dst.a);
2359
0
    }
2360
2361
0
    if (key->eth.type) {
2362
2363
0
        nkey->has_eth_type = true;
2364
0
        nkey->eth_type = ntohs(key->eth.type);
2365
2366
0
        switch (ntohs(key->eth.type)) {
2367
0
        case 0x0800:
2368
0
        case 0x86dd:
2369
0
            if (key->ip.proto || mask->ip.proto) {
2370
0
                nkey->has_ip_proto = true;
2371
0
                nkey->ip_proto = key->ip.proto;
2372
0
            }
2373
0
            if (nkey->has_ip_proto && mask->ip.proto != 0xff) {
2374
0
                nmask->has_ip_proto = true;
2375
0
                nmask->ip_proto = mask->ip.proto;
2376
0
            }
2377
0
            if (key->ip.tos || mask->ip.tos) {
2378
0
                nkey->has_ip_tos = true;
2379
0
                nkey->ip_tos = key->ip.tos;
2380
0
            }
2381
0
            if (nkey->has_ip_tos && mask->ip.tos != 0xff) {
2382
0
                nmask->has_ip_tos = true;
2383
0
                nmask->ip_tos = mask->ip.tos;
2384
0
            }
2385
0
            break;
2386
0
        }
2387
2388
0
        switch (ntohs(key->eth.type)) {
2389
0
        case 0x0800:
2390
0
            if (key->ipv4.addr.dst || mask->ipv4.addr.dst) {
2391
0
                char *dst = inet_ntoa(*(struct in_addr *)&key->ipv4.addr.dst);
2392
0
                int dst_len = of_dpa_mask2prefix(mask->ipv4.addr.dst);
2393
0
                nkey->ip_dst = g_strdup_printf("%s/%d", dst, dst_len);
2394
0
            }
2395
0
            break;
2396
0
        }
2397
0
    }
2398
2399
0
    if (flow->action.goto_tbl) {
2400
0
        naction->has_goto_tbl = true;
2401
0
        naction->goto_tbl = flow->action.goto_tbl;
2402
0
    }
2403
2404
0
    if (flow->action.write.group_id) {
2405
0
        naction->has_group_id = true;
2406
0
        naction->group_id = flow->action.write.group_id;
2407
0
    }
2408
2409
0
    if (flow->action.apply.new_vlan_id) {
2410
0
        naction->has_new_vlan_id = true;
2411
0
        naction->new_vlan_id = flow->action.apply.new_vlan_id;
2412
0
    }
2413
2414
0
    QAPI_LIST_PREPEND(flow_context->list, nflow);
2415
0
}
2416
2417
RockerOfDpaFlowList *qmp_query_rocker_of_dpa_flows(const char *name,
2418
                                                   bool has_tbl_id,
2419
                                                   uint32_t tbl_id,
2420
                                                   Error **errp)
2421
0
{
2422
0
    struct rocker *r;
2423
0
    struct world *w;
2424
0
    struct of_dpa *of_dpa;
2425
0
    struct of_dpa_flow_fill_context fill_context = {
2426
0
        .list = NULL,
2427
0
        .tbl_id = tbl_id,
2428
0
    };
2429
2430
0
    r = rocker_find(name);
2431
0
    if (!r) {
2432
0
        error_setg(errp, "rocker %s not found", name);
2433
0
        return NULL;
2434
0
    }
2435
2436
0
    w = rocker_get_world(r, ROCKER_WORLD_TYPE_OF_DPA);
2437
0
    if (!w) {
2438
0
        error_setg(errp, "rocker %s doesn't have OF-DPA world", name);
2439
0
        return NULL;
2440
0
    }
2441
2442
0
    of_dpa = world_private(w);
2443
2444
0
    g_hash_table_foreach(of_dpa->flow_tbl, of_dpa_flow_fill, &fill_context);
2445
2446
0
    return fill_context.list;
2447
0
}
2448
2449
struct of_dpa_group_fill_context {
2450
    RockerOfDpaGroupList *list;
2451
    uint8_t type;
2452
};
2453
2454
static void of_dpa_group_fill(void *key, void *value, void *user_data)
2455
0
{
2456
0
    struct of_dpa_group *group = value;
2457
0
    struct of_dpa_group_fill_context *flow_context = user_data;
2458
0
    RockerOfDpaGroup *ngroup;
2459
0
    int i;
2460
2461
0
    if (flow_context->type != 9 &&
2462
0
        flow_context->type != ROCKER_GROUP_TYPE_GET(group->id)) {
2463
0
        return;
2464
0
    }
2465
2466
0
    ngroup = g_malloc0(sizeof(*ngroup));
2467
2468
0
    ngroup->id = group->id;
2469
2470
0
    ngroup->type = ROCKER_GROUP_TYPE_GET(group->id);
2471
2472
0
    switch (ngroup->type) {
2473
0
    case ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE:
2474
0
        ngroup->has_vlan_id = true;
2475
0
        ngroup->vlan_id = ROCKER_GROUP_VLAN_GET(group->id);
2476
0
        ngroup->has_pport = true;
2477
0
        ngroup->pport = ROCKER_GROUP_PORT_GET(group->id);
2478
0
        ngroup->has_out_pport = true;
2479
0
        ngroup->out_pport = group->l2_interface.out_pport;
2480
0
        ngroup->has_pop_vlan = true;
2481
0
        ngroup->pop_vlan = group->l2_interface.pop_vlan;
2482
0
        break;
2483
0
    case ROCKER_OF_DPA_GROUP_TYPE_L2_REWRITE:
2484
0
        ngroup->has_index = true;
2485
0
        ngroup->index = ROCKER_GROUP_INDEX_LONG_GET(group->id);
2486
0
        ngroup->has_group_id = true;
2487
0
        ngroup->group_id = group->l2_rewrite.group_id;
2488
0
        if (group->l2_rewrite.vlan_id) {
2489
0
            ngroup->has_set_vlan_id = true;
2490
0
            ngroup->set_vlan_id = ntohs(group->l2_rewrite.vlan_id);
2491
0
        }
2492
0
        if (memcmp(group->l2_rewrite.src_mac.a, zero_mac.a, ETH_ALEN)) {
2493
0
            ngroup->set_eth_src =
2494
0
                qemu_mac_strdup_printf(group->l2_rewrite.src_mac.a);
2495
0
        }
2496
0
        if (memcmp(group->l2_rewrite.dst_mac.a, zero_mac.a, ETH_ALEN)) {
2497
0
            ngroup->set_eth_dst =
2498
0
                qemu_mac_strdup_printf(group->l2_rewrite.dst_mac.a);
2499
0
        }
2500
0
        break;
2501
0
    case ROCKER_OF_DPA_GROUP_TYPE_L2_FLOOD:
2502
0
    case ROCKER_OF_DPA_GROUP_TYPE_L2_MCAST:
2503
0
        ngroup->has_vlan_id = true;
2504
0
        ngroup->vlan_id = ROCKER_GROUP_VLAN_GET(group->id);
2505
0
        ngroup->has_index = true;
2506
0
        ngroup->index = ROCKER_GROUP_INDEX_GET(group->id);
2507
0
        for (i = 0; i < group->l2_flood.group_count; i++) {
2508
0
            ngroup->has_group_ids = true;
2509
0
            QAPI_LIST_PREPEND(ngroup->group_ids, group->l2_flood.group_ids[i]);
2510
0
        }
2511
0
        break;
2512
0
    case ROCKER_OF_DPA_GROUP_TYPE_L3_UCAST:
2513
0
        ngroup->has_index = true;
2514
0
        ngroup->index = ROCKER_GROUP_INDEX_LONG_GET(group->id);
2515
0
        ngroup->has_group_id = true;
2516
0
        ngroup->group_id = group->l3_unicast.group_id;
2517
0
        if (group->l3_unicast.vlan_id) {
2518
0
            ngroup->has_set_vlan_id = true;
2519
0
            ngroup->set_vlan_id = ntohs(group->l3_unicast.vlan_id);
2520
0
        }
2521
0
        if (memcmp(group->l3_unicast.src_mac.a, zero_mac.a, ETH_ALEN)) {
2522
0
            ngroup->set_eth_src =
2523
0
                qemu_mac_strdup_printf(group->l3_unicast.src_mac.a);
2524
0
        }
2525
0
        if (memcmp(group->l3_unicast.dst_mac.a, zero_mac.a, ETH_ALEN)) {
2526
0
            ngroup->set_eth_dst =
2527
0
                qemu_mac_strdup_printf(group->l3_unicast.dst_mac.a);
2528
0
        }
2529
0
        if (group->l3_unicast.ttl_check) {
2530
0
            ngroup->has_ttl_check = true;
2531
0
            ngroup->ttl_check = group->l3_unicast.ttl_check;
2532
0
        }
2533
0
        break;
2534
0
    }
2535
2536
0
    QAPI_LIST_PREPEND(flow_context->list, ngroup);
2537
0
}
2538
2539
RockerOfDpaGroupList *qmp_query_rocker_of_dpa_groups(const char *name,
2540
                                                     bool has_type,
2541
                                                     uint8_t type,
2542
                                                     Error **errp)
2543
0
{
2544
0
    struct rocker *r;
2545
0
    struct world *w;
2546
0
    struct of_dpa *of_dpa;
2547
0
    struct of_dpa_group_fill_context fill_context = {
2548
0
        .list = NULL,
2549
0
        .type = type,
2550
0
    };
2551
2552
0
    r = rocker_find(name);
2553
0
    if (!r) {
2554
0
        error_setg(errp, "rocker %s not found", name);
2555
0
        return NULL;
2556
0
    }
2557
2558
0
    w = rocker_get_world(r, ROCKER_WORLD_TYPE_OF_DPA);
2559
0
    if (!w) {
2560
0
        error_setg(errp, "rocker %s doesn't have OF-DPA world", name);
2561
0
        return NULL;
2562
0
    }
2563
2564
0
    of_dpa = world_private(w);
2565
2566
0
    g_hash_table_foreach(of_dpa->group_tbl, of_dpa_group_fill, &fill_context);
2567
2568
0
    return fill_context.list;
2569
0
}
2570
2571
static WorldOps of_dpa_ops = {
2572
    .name = "ofdpa",
2573
    .init = of_dpa_init,
2574
    .uninit = of_dpa_uninit,
2575
    .ig = of_dpa_ig,
2576
    .cmd = of_dpa_cmd,
2577
};
2578
2579
World *of_dpa_world_alloc(Rocker *r)
2580
0
{
2581
0
    return world_alloc(r, sizeof(OfDpa), ROCKER_WORLD_TYPE_OF_DPA, &of_dpa_ops);
2582
0
}