From 5e165afe5eca8e093879df006a6d61be2cbdda53 Mon Sep 17 00:00:00 2001

From: Dumitru Ceara <dceara@redhat.com>

Date: Fri, 16 Aug 2019 14:20:45 +0200

Subject: [PATCH 2/4] ovn-northd: Add IGMP Relay support

Add a new configuration option 'mcast_relay' to the Logical_Router:options

in the OVN Northbound database.

If a router is configured with 'mcast_relay' enabled then ovn-northd

will install Logical_Flows to allow IP multicast traffic to be routed

between Logical_Switches. The logical router will aggregate all IGMP

groups from attached logical switches and modify the routing pipeline in

the following way:

- Table S_ROUTER_IN_IP_INPUT: add flow allowing IP multicast traffic

  if mcast_relay is enabled on the datapath.

- Table S_ROUTER_IN_IP_ROUTING: add flow matching the group address,

  update TTL and set outport="<Multicast_Group> associated with the

  IGMP group". Continue to next table.

- Table S_ROUTER_IN_ARP_RESOLVE: bypass ARP resolve for IP multicast

  traffic and continue to next table.

- Table S_ROUTER_OUT_DELIVERY: add flow matching IP multicast traffic

  and set ETH.SRC to the MAC address of the logical port on which

  traffic is forwarded.

Signed-off-by: Dumitru Ceara <dceara@redhat.com>

Acked-by: Mark Michelson <mmichels@redhat.com>

Signed-off-by: Numan Siddique <nusiddiq@redhat.com>

(cherry-picked from ovn commit 5d1527b11e9420a36adc2410f78be6b6674c098e)

---

 NEWS                        |   1 +

 ovn/lib/logical-fields.c    |   2 +

 ovn/lib/mcast-group-index.h |  13 +-

 ovn/northd/ovn-northd.8.xml |  79 +++++-

 ovn/northd/ovn-northd.c     | 499 +++++++++++++++++++++++++++---------

 ovn/ovn-nb.xml              |   6 +

 ovn/ovn-sb.xml              |   2 +

 tests/ovn.at                | 199 ++++++++++++--

 8 files changed, 650 insertions(+), 151 deletions(-)

diff --git a/NEWS b/NEWS

index c81890b7e..754ac2e71 100644

--- a/NEWS

+++ b/NEWS

@@ -64,6 +64,7 @@ v2.12.0 - 03 Sep 2019

        members of the same transport zone(s).

      * Support for IGMP Snooping and IGMP Querier.

      * Support for new logical switch port type - 'virtual'.

+     * Support for IGMP Snooping/Querier and Relay.

    - New QoS type "linux-netem" on Linux.

    - Added support for TLS Server Name Indication (SNI).

    - Linux datapath:

diff --git a/ovn/lib/logical-fields.c b/ovn/lib/logical-fields.c

index 4ad5bf481..8fb591c0a 100644

--- a/ovn/lib/logical-fields.c

+++ b/ovn/lib/logical-fields.c

@@ -156,6 +156,8 @@ ovn_init_symtab(struct shash *symtab)

     expr_symtab_add_field(symtab, "ip4.src", MFF_IPV4_SRC, "ip4", false);

     expr_symtab_add_field(symtab, "ip4.dst", MFF_IPV4_DST, "ip4", false);

+    expr_symtab_add_predicate(symtab, "ip4.src_mcast",

+                              "ip4.src[28..31] == 0xe");

     expr_symtab_add_predicate(symtab, "ip4.mcast", "ip4.dst[28..31] == 0xe");

     expr_symtab_add_predicate(symtab, "icmp4", "ip4 && ip.proto == 1");

diff --git a/ovn/lib/mcast-group-index.h b/ovn/lib/mcast-group-index.h

index 859e6a72f..6249cac99 100644

--- a/ovn/lib/mcast-group-index.h

+++ b/ovn/lib/mcast-group-index.h

@@ -20,8 +20,17 @@ struct ovsdb_idl;

 struct sbrec_datapath_binding;

-#define OVN_MCAST_FLOOD_TUNNEL_KEY   65535

-#define OVN_MCAST_UNKNOWN_TUNNEL_KEY (OVN_MCAST_FLOOD_TUNNEL_KEY - 1)

+#define OVN_MIN_MULTICAST 32768

+#define OVN_MAX_MULTICAST 65535

+

+enum ovn_mcast_tunnel_keys {

+

+    OVN_MCAST_FLOOD_TUNNEL_KEY = OVN_MIN_MULTICAST,

+    OVN_MCAST_UNKNOWN_TUNNEL_KEY,

+    OVN_MCAST_MROUTER_FLOOD_TUNNEL_KEY,

+    OVN_MIN_IP_MULTICAST,

+    OVN_MAX_IP_MULTICAST = OVN_MAX_MULTICAST,

+};

 struct ovsdb_idl_index *mcast_group_index_create(struct ovsdb_idl *);

 const struct sbrec_multicast_group *

diff --git a/ovn/northd/ovn-northd.8.xml b/ovn/northd/ovn-northd.8.xml

index 0435dae26..ec2b6454c 100644

--- a/ovn/northd/ovn-northd.8.xml

+++ b/ovn/northd/ovn-northd.8.xml

@@ -952,10 +952,40 @@ output;

-        A priority-100 flow that outputs all packets with an Ethernet broadcast

+        A priority-100 flow that punts all IGMP packets to

+        ovn-controller if IGMP snooping is enabled on the

+        logical switch.

+      

+

+      

+        Priority-90 flows that forward registered IP multicast traffic to

+        their corresponding multicast group, which ovn-northd

+        creates based on learnt <ref table="IGMP_Group" db="OVN_Southbound"/>

+        entries.  The flows also forward packets to the

+        MC_MROUTER_FLOOD multicast group, which

+        ovn-nortdh populates with all the logical ports that

+        are connected to logical routers with

+        <ref column="options" table="Logical_Router"/>:mcast_relay='true'.

+      

+

+      

+        A priority-85 flow that forwards all IP multicast traffic destined to

+        224.0.0.X to the MC_FLOOD multicast group, which

+        ovn-northd populates with all enabled logical ports.

+      

+

+      

+        A priority-80 flow that forwards all unregistered IP multicast traffic

+        to the MC_MROUTER_FLOOD multicast group, if any.

+        Otherwise the flow drops all unregistered IP multicast packets.  This

+        flow is added only if 

+        table="Logical_Switch"/>:mcast_flood_unregistered='false'.

+      

+

+      

+        A priority-70 flow that outputs all packets with an Ethernet broadcast

         or multicast eth.dst to the MC_FLOOD

-        multicast group, which ovn-northd populates with all

-        enabled logical ports.

+        multicast group.

@@ -1236,6 +1266,14 @@ output;

+      

+        

+          A priority-95 flow allows IP multicast traffic if

+          <ref column="options" table="Logical_Router"/>:mcast_relay='true',

+          otherwise drops it.

+        

+      

+

           ICMP echo reply.  These flows reply to ICMP echo requests received

@@ -1982,6 +2020,16 @@ output;

+      

+        

+          Priority-500 flows that match IP multicast traffic destined to

+          groups registered on any of the attached switches and sets

+          outport to the associated multicast group that will

+          eventually flood the traffic to all interested attached logical

+          switches. The flows also decrement TTL.

+        

+      

+

           For distributed logical routers where one of the logical router

@@ -2115,6 +2163,15 @@ next;

+      

+        

+          A priority-500 flow that matches IP multicast traffic that was

+          allowed in the routing pipeline. For this kind of traffic the

+          outport was already set so the flow just advances to

+          the next table.

+        

+      

+

           For distributed logical routers where one of the logical router

@@ -2684,9 +2741,19 @@ clone {

     
Egress Table 3: Delivery

-      Packets that reach this table are ready for delivery.  It contains

-      priority-100 logical flows that match packets on each enabled logical

-      router port, with action output;.

+      Packets that reach this table are ready for delivery.  It contains:

+      

+        

+          Priority-110 logical flows that match IP multicast packets on each

+          enabled logical router port and modify the Ethernet source address

+          of the packets to the Ethernet address of the port and then execute

+          action output;.

+        

+        

+          Priority-100 logical flows that match packets on each enabled

+          logical router port, with action output;.

+        

+      

 </manpage>

diff --git a/ovn/northd/ovn-northd.c b/ovn/northd/ovn-northd.c

index d81cfd893..83a7ec14f 100644

--- a/ovn/northd/ovn-northd.c

+++ b/ovn/northd/ovn-northd.c

@@ -440,32 +440,52 @@ struct ipam_info {

     bool mac_only;

 };

-#define OVN_MIN_MULTICAST 32768

-#define OVN_MAX_MULTICAST OVN_MCAST_FLOOD_TUNNEL_KEY

-BUILD_ASSERT_DECL(OVN_MIN_MULTICAST < OVN_MAX_MULTICAST);

-

-#define OVN_MIN_IP_MULTICAST OVN_MIN_MULTICAST

-#define OVN_MAX_IP_MULTICAST (OVN_MCAST_UNKNOWN_TUNNEL_KEY - 1)

-BUILD_ASSERT_DECL(OVN_MAX_IP_MULTICAST >= OVN_MIN_MULTICAST);

-

 /*

  * Multicast snooping and querier per datapath configuration.

  */

+struct mcast_switch_info {

+

+    bool enabled;               /* True if snooping enabled. */

+    bool querier;               /* True if querier enabled. */

+    bool flood_unregistered;    /* True if unregistered multicast should be

+                                 * flooded.

+                                 */

+    bool flood_relay;           /* True if the switch is connected to a

+                                 * multicast router and unregistered multicast

+                                 * should be flooded to the mrouter. Only

+                                 * applicable if flood_unregistered == false.

+                                 */

+

+    int64_t table_size;         /* Max number of IP multicast groups. */

+    int64_t idle_timeout;       /* Timeout after which an idle group is

+                                 * flushed.

+                                 */

+    int64_t query_interval;     /* Interval between multicast queries. */

+    char *eth_src;              /* ETH src address of the multicast queries. */

+    char *ipv4_src;             /* IP src address of the multicast queries. */

+    int64_t query_max_response; /* Expected time after which reports should

+                                 * be received for queries that were sent out.

+                                 */

+

+    uint32_t active_flows;      /* Current number of active IP multicast

+                                 * flows.

+                                 */

+};

+

+struct mcast_router_info {

+    bool relay; /* True if the router should relay IP multicast. */

+};

+

 struct mcast_info {

-    bool enabled;

-    bool querier;

-    bool flood_unregistered;

-

-    int64_t table_size;

-    int64_t idle_timeout;

-    int64_t query_interval;

-    char *eth_src;

-    char *ipv4_src;

-    int64_t  query_max_response;

-

-    struct hmap group_tnlids;

-    uint32_t group_tnlid_hint;

-    uint32_t active_flows;

+

+    struct hmap group_tnlids;  /* Group tunnel IDs in use on this DP. */

+    uint32_t group_tnlid_hint; /* Hint for allocating next group tunnel ID. */

+    struct ovs_list groups;    /* List of groups learnt on this DP. */

+

+    union {

+        struct mcast_switch_info sw;  /* Switch specific multicast info. */

+        struct mcast_router_info rtr; /* Router specific multicast info. */

+    };

 };

 static uint32_t

@@ -566,6 +586,7 @@ ovn_datapath_create(struct hmap *datapaths, const struct uuid *key,

 }

 static void ovn_ls_port_group_destroy(struct hmap *nb_pgs);

+static void destroy_mcast_info_for_datapath(struct ovn_datapath *od);

 static void

 ovn_datapath_destroy(struct hmap *datapaths, struct ovn_datapath *od)

@@ -579,12 +600,7 @@ ovn_datapath_destroy(struct hmap *datapaths, struct ovn_datapath *od)

         bitmap_free(od->ipam_info.allocated_ipv4s);

         free(od->router_ports);

         ovn_ls_port_group_destroy(&od->nb_pgs);

-

-        if (od->nbs) {

-            free(od->mcast_info.eth_src);

-            free(od->mcast_info.ipv4_src);

-            destroy_tnlids(&od->mcast_info.group_tnlids);

-        }

+        destroy_mcast_info_for_datapath(od);

         free(od);

     }

@@ -721,23 +737,28 @@ init_ipam_info_for_datapath(struct ovn_datapath *od)

 }

 static void

-init_mcast_info_for_datapath(struct ovn_datapath *od)

+init_mcast_info_for_router_datapath(struct ovn_datapath *od)

 {

-    if (!od->nbs) {

-        return;

-    }

+    struct mcast_router_info *mcast_rtr_info = &od->mcast_info.rtr;

-    struct mcast_info *mcast_info = &od->mcast_info;

+    mcast_rtr_info->relay = smap_get_bool(&od->nbr->options, "mcast_relay",

+                                          false);

+}

-    mcast_info->enabled =

+static void

+init_mcast_info_for_switch_datapath(struct ovn_datapath *od)

+{

+    struct mcast_switch_info *mcast_sw_info = &od->mcast_info.sw;

+

+    mcast_sw_info->enabled =

         smap_get_bool(&od->nbs->other_config, "mcast_snoop", false);

-    mcast_info->querier =

+    mcast_sw_info->querier =

         smap_get_bool(&od->nbs->other_config, "mcast_querier", true);

-    mcast_info->flood_unregistered =

+    mcast_sw_info->flood_unregistered =

         smap_get_bool(&od->nbs->other_config, "mcast_flood_unregistered",

                       false);

-    mcast_info->table_size =

+    mcast_sw_info->table_size =

         smap_get_ullong(&od->nbs->other_config, "mcast_table_size",

                         OVN_MCAST_DEFAULT_MAX_ENTRIES);

@@ -749,54 +770,94 @@ init_mcast_info_for_datapath(struct ovn_datapath *od)

     } else if (idle_timeout > OVN_MCAST_MAX_IDLE_TIMEOUT_S) {

         idle_timeout = OVN_MCAST_MAX_IDLE_TIMEOUT_S;

     }

-    mcast_info->idle_timeout = idle_timeout;

+    mcast_sw_info->idle_timeout = idle_timeout;

     uint32_t query_interval =

         smap_get_ullong(&od->nbs->other_config, "mcast_query_interval",

-                        mcast_info->idle_timeout / 2);

+                        mcast_sw_info->idle_timeout / 2);

     if (query_interval < OVN_MCAST_MIN_QUERY_INTERVAL_S) {

         query_interval = OVN_MCAST_MIN_QUERY_INTERVAL_S;

     } else if (query_interval > OVN_MCAST_MAX_QUERY_INTERVAL_S) {

         query_interval = OVN_MCAST_MAX_QUERY_INTERVAL_S;

     }

-    mcast_info->query_interval = query_interval;

+    mcast_sw_info->query_interval = query_interval;

-    mcast_info->eth_src =

+    mcast_sw_info->eth_src =

         nullable_xstrdup(smap_get(&od->nbs->other_config, "mcast_eth_src"));

-    mcast_info->ipv4_src =

+    mcast_sw_info->ipv4_src =

         nullable_xstrdup(smap_get(&od->nbs->other_config, "mcast_ip4_src"));

-    mcast_info->query_max_response =

+    mcast_sw_info->query_max_response =

         smap_get_ullong(&od->nbs->other_config, "mcast_query_max_response",

                         OVN_MCAST_DEFAULT_QUERY_MAX_RESPONSE_S);

-    hmap_init(&mcast_info->group_tnlids);

-    mcast_info->group_tnlid_hint = OVN_MIN_IP_MULTICAST;

-    mcast_info->active_flows = 0;

+    mcast_sw_info->active_flows = 0;

+}

+

+static void

+init_mcast_info_for_datapath(struct ovn_datapath *od)

+{

+    if (!od->nbr && !od->nbs) {

+        return;

+    }

+

+    hmap_init(&od->mcast_info.group_tnlids);

+    od->mcast_info.group_tnlid_hint = OVN_MIN_IP_MULTICAST;

+    ovs_list_init(&od->mcast_info.groups);

+

+    if (od->nbs) {

+        init_mcast_info_for_switch_datapath(od);

+    } else {

+        init_mcast_info_for_router_datapath(od);

+    }

+}

+

+static void

+destroy_mcast_info_for_switch_datapath(struct ovn_datapath *od)

+{

+    struct mcast_switch_info *mcast_sw_info = &od->mcast_info.sw;

+

+    free(mcast_sw_info->eth_src);

+    free(mcast_sw_info->ipv4_src);

+}

+

+static void

+destroy_mcast_info_for_datapath(struct ovn_datapath *od)

+{

+    if (!od->nbr && !od->nbs) {

+        return;

+    }

+

+    if (od->nbs) {

+        destroy_mcast_info_for_switch_datapath(od);

+    }

+

+    destroy_tnlids(&od->mcast_info.group_tnlids);

 }

 static void

-store_mcast_info_for_datapath(const struct sbrec_ip_multicast *sb,

-                              struct ovn_datapath *od)

+store_mcast_info_for_switch_datapath(const struct sbrec_ip_multicast *sb,

+                                     struct ovn_datapath *od)

 {

-    struct mcast_info *mcast_info = &od->mcast_info;

+    struct mcast_switch_info *mcast_sw_info = &od->mcast_info.sw;

     sbrec_ip_multicast_set_datapath(sb, od->sb);

-    sbrec_ip_multicast_set_enabled(sb, &mcast_info->enabled, 1);

-    sbrec_ip_multicast_set_querier(sb, &mcast_info->querier, 1);

-    sbrec_ip_multicast_set_table_size(sb, &mcast_info->table_size, 1);

-    sbrec_ip_multicast_set_idle_timeout(sb, &mcast_info->idle_timeout, 1);

+    sbrec_ip_multicast_set_enabled(sb, &mcast_sw_info->enabled, 1);

+    sbrec_ip_multicast_set_querier(sb, &mcast_sw_info->querier, 1);

+    sbrec_ip_multicast_set_table_size(sb, &mcast_sw_info->table_size, 1);

+    sbrec_ip_multicast_set_idle_timeout(sb, &mcast_sw_info->idle_timeout, 1);

     sbrec_ip_multicast_set_query_interval(sb,

-                                          &mcast_info->query_interval, 1);

+                                          &mcast_sw_info->query_interval, 1);

     sbrec_ip_multicast_set_query_max_resp(sb,

-                                          &mcast_info->query_max_response, 1);

+                                          &mcast_sw_info->query_max_response,

+                                          1);

-    if (mcast_info->eth_src) {

-        sbrec_ip_multicast_set_eth_src(sb, mcast_info->eth_src);

+    if (mcast_sw_info->eth_src) {

+        sbrec_ip_multicast_set_eth_src(sb, mcast_sw_info->eth_src);

     }

-    if (mcast_info->ipv4_src) {

-        sbrec_ip_multicast_set_ip4_src(sb, mcast_info->ipv4_src);

+    if (mcast_sw_info->ipv4_src) {

+        sbrec_ip_multicast_set_ip4_src(sb, mcast_sw_info->ipv4_src);

     }

 }

@@ -913,6 +974,7 @@ join_datapaths(struct northd_context *ctx, struct hmap *datapaths,

                                      NULL, nbr, NULL);

             ovs_list_push_back(nb_only, &od->list);

         }

+        init_mcast_info_for_datapath(od);

         ovs_list_push_back(lr_list, &od->lr_list);

     }

 }

@@ -2006,6 +2068,13 @@ join_logical_ports(struct northd_context *ctx,

                     break;

                 }

             }

+

+            /* If the router is multicast enabled then set relay on the switch

+             * datapath.

+             */

+            if (peer->od && peer->od->mcast_info.rtr.relay) {

+                op->od->mcast_info.sw.flood_relay = true;

+            }

         } else if (op->nbrp && op->nbrp->peer && !op->derived) {

             struct ovn_port *peer = ovn_port_find(ports, op->nbrp->peer);

             if (peer) {

@@ -2861,6 +2930,10 @@ struct multicast_group {

 static const struct multicast_group mc_flood =

     { MC_FLOOD, OVN_MCAST_FLOOD_TUNNEL_KEY };

+#define MC_MROUTER_FLOOD "_MC_mrouter_flood"

+static const struct multicast_group mc_mrouter_flood =

+    { MC_MROUTER_FLOOD, OVN_MCAST_MROUTER_FLOOD_TUNNEL_KEY };

+

 #define MC_UNKNOWN "_MC_unknown"

 static const struct multicast_group mc_unknown =

     { MC_UNKNOWN, OVN_MCAST_UNKNOWN_TUNNEL_KEY };

@@ -2970,7 +3043,8 @@ ovn_multicast_update_sbrec(const struct ovn_multicast *mc,

  */

 struct ovn_igmp_group_entry {

     struct ovs_list list_node; /* Linkage in the list of entries. */

-    const struct sbrec_igmp_group *sb;

+    size_t n_ports;

+    struct ovn_port **ports;

 };

 /*

@@ -2979,12 +3053,13 @@ struct ovn_igmp_group_entry {

  */

 struct ovn_igmp_group {

     struct hmap_node hmap_node; /* Index on 'datapath' and 'address'. */

+    struct ovs_list list_node;  /* Linkage in the per-dp igmp group list. */

     struct ovn_datapath *datapath;

     struct in6_addr address; /* Multicast IPv6-mapped-IPv4 or IPv4 address. */

     struct multicast_group mcgroup;

-    struct ovs_list sb_entries; /* List of SB entries for this group. */

+    struct ovs_list entries; /* List of SB entries for this group. */

 };

 static uint32_t

@@ -3012,77 +3087,120 @@ ovn_igmp_group_find(struct hmap *igmp_groups,

     return NULL;

 }

-static void

+static struct ovn_igmp_group *

 ovn_igmp_group_add(struct northd_context *ctx, struct hmap *igmp_groups,

                    struct ovn_datapath *datapath,

-                   const struct sbrec_igmp_group *sb_igmp_group)

+                   const struct in6_addr *address,

+                   const char *address_s)

 {

-    struct in6_addr group_address;

-    ovs_be32 ipv4;

-

-    if (ip_parse(sb_igmp_group->address, &ipv4)) {

-        group_address = in6_addr_mapped_ipv4(ipv4);

-    } else if (!ipv6_parse(sb_igmp_group->address, &group_address)) {

-        static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);

-        VLOG_WARN_RL(&rl, "invalid IGMP group address: %s",

-                     sb_igmp_group->address);

-        return;

-    }

-

     struct ovn_igmp_group *igmp_group =

-        ovn_igmp_group_find(igmp_groups, datapath, &group_address);

+        ovn_igmp_group_find(igmp_groups, datapath, address);

     if (!igmp_group) {

         igmp_group = xmalloc(sizeof *igmp_group);

         const struct sbrec_multicast_group *mcgroup =

-            mcast_group_lookup(ctx->sbrec_mcast_group_by_name_dp,

-                               sb_igmp_group->address, datapath->sb);

+            mcast_group_lookup(ctx->sbrec_mcast_group_by_name_dp, address_s,

+                               datapath->sb);

         igmp_group->datapath = datapath;

-        igmp_group->address = group_address;

+        igmp_group->address = *address;

         if (mcgroup) {

             igmp_group->mcgroup.key = mcgroup->tunnel_key;

             add_tnlid(&datapath->mcast_info.group_tnlids, mcgroup->tunnel_key);

         } else {

             igmp_group->mcgroup.key = 0;

         }

-        igmp_group->mcgroup.name = sb_igmp_group->address;

-        ovs_list_init(&igmp_group->sb_entries);

+        igmp_group->mcgroup.name = address_s;

+        ovs_list_init(&igmp_group->entries);

         hmap_insert(igmp_groups, &igmp_group->hmap_node,

-                    ovn_igmp_group_hash(datapath, &group_address));

+                    ovn_igmp_group_hash(datapath, address));

+        ovs_list_push_back(&datapath->mcast_info.groups,

+                           &igmp_group->list_node);

     }

+    return igmp_group;

+}

+

+static bool

+ovn_igmp_group_get_address(const struct sbrec_igmp_group *sb_igmp_group,

+                           struct in6_addr *address)

+{

+    ovs_be32 ipv4;

+

+    if (ip_parse(sb_igmp_group->address, &ipv4)) {

+        *address = in6_addr_mapped_ipv4(ipv4);

+        return true;

+    }

+    if (!ipv6_parse(sb_igmp_group->address, address)) {

+        return false;

+    }

+    return true;

+}

+

+static struct ovn_port **

+ovn_igmp_group_get_ports(const struct sbrec_igmp_group *sb_igmp_group,

+                         size_t *n_ports, struct hmap *ovn_ports)

+{

+    struct ovn_port **ports = xmalloc(sb_igmp_group->n_ports * sizeof *ports);

+

+     *n_ports = 0;

+     for (size_t i = 0; i < sb_igmp_group->n_ports; i++) {

+        ports[(*n_ports)] =

+            ovn_port_find(ovn_ports, sb_igmp_group->ports[i]->logical_port);

+        if (ports[(*n_ports)]) {

+            (*n_ports)++;

+        }

+    }

+

+    return ports;

+}

+

+static void

+ovn_igmp_group_add_entry(struct ovn_igmp_group *igmp_group,

+                         struct ovn_port **ports, size_t n_ports)

+{

     struct ovn_igmp_group_entry *entry = xmalloc(sizeof *entry);

-    entry->sb = sb_igmp_group;

-    ovs_list_push_back(&igmp_group->sb_entries , &entry->list_node);

+    entry->ports = ports;

+    entry->n_ports = n_ports;

+    ovs_list_push_back(&igmp_group->entries, &entry->list_node);

+}

+

+static void

+ovn_igmp_group_destroy_entry(struct ovn_igmp_group_entry *entry)

+{

+    free(entry->ports);

+}

+

+static bool

+ovn_igmp_group_allocate_id(struct ovn_igmp_group *igmp_group)

+{

+    if (igmp_group->mcgroup.key == 0) {

+        struct mcast_info *mcast_info = &igmp_group->datapath->mcast_info;

+        igmp_group->mcgroup.key = ovn_mcast_group_allocate_key(mcast_info);

+    }

+

+    if (igmp_group->mcgroup.key == 0) {

+        return false;

+    }

+

+    return true;

 }

 static void

 ovn_igmp_group_aggregate_ports(struct ovn_igmp_group *igmp_group,

-                               struct hmap *ovn_ports,

                                struct hmap *mcast_groups)

 {

     struct ovn_igmp_group_entry *entry;

-    LIST_FOR_EACH_POP (entry, list_node, &igmp_group->sb_entries) {

-        size_t n_oports = 0;

-        struct ovn_port **oports =

-            xmalloc(entry->sb->n_ports * sizeof *oports);

-

-        for (size_t i = 0; i < entry->sb->n_ports; i++) {

-            oports[n_oports] =

-                ovn_port_find(ovn_ports, entry->sb->ports[i]->logical_port);

-            if (oports[n_oports]) {

-                n_oports++;

-            }

-        }

-

+    LIST_FOR_EACH_POP (entry, list_node, &igmp_group->entries) {

         ovn_multicast_add_ports(mcast_groups, igmp_group->datapath,

-                                &igmp_group->mcgroup, oports, n_oports);

-        free(oports);

+                                &igmp_group->mcgroup, entry->ports,

+                                entry->n_ports);

+

+        ovn_igmp_group_destroy_entry(entry);

         free(entry);

     }

 }

@@ -3094,10 +3212,12 @@ ovn_igmp_group_destroy(struct hmap *igmp_groups,

     if (igmp_group) {

         struct ovn_igmp_group_entry *entry;

-        LIST_FOR_EACH_POP (entry, list_node, &igmp_group->sb_entries) {

+        LIST_FOR_EACH_POP (entry, list_node, &igmp_group->entries) {

+            ovn_igmp_group_destroy_entry(entry);

             free(entry);

         }

         hmap_remove(igmp_groups, &igmp_group->hmap_node);

+        ovs_list_remove(&igmp_group->list_node);

         free(igmp_group);

     }

 }

@@ -5404,7 +5524,9 @@ build_lswitch_flows(struct hmap *datapaths, struct hmap *ports,

             continue;

         }

-        if (od->mcast_info.enabled) {

+        struct mcast_switch_info *mcast_sw_info = &od->mcast_info.sw;

+

+        if (mcast_sw_info->enabled) {

             /* Punt IGMP traffic to controller. */

             ovn_lflow_add(lflows, od, S_SWITCH_IN_L2_LKUP, 100,

                           "ip4 && ip.proto == 2", "igmp;");

@@ -5417,9 +5539,16 @@ build_lswitch_flows(struct hmap *datapaths, struct hmap *ports,

                           "outport = \""MC_FLOOD"\"; output;");

             /* Drop unregistered IP multicast if not allowed. */

-            if (!od->mcast_info.flood_unregistered) {

-                ovn_lflow_add(lflows, od, S_SWITCH_IN_L2_LKUP, 80,

-                              "ip4 && ip4.mcast", "drop;");

+            if (!mcast_sw_info->flood_unregistered) {