lib/mcast-snooping.c

   1 /*
   2  * Copyright (c) 2014 Red Hat, Inc.
   3  *
   4  * Based on mac-learning implementation.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at:
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #include <config.h>
  20 #include "mcast-snooping.h"
  21
  22 #include <inttypes.h>
  23 #include <stdlib.h>
  24
  25 #include "bitmap.h"
  26 #include "byte-order.h"
  27 #include "coverage.h"
  28 #include "hash.h"
  29 #include "list.h"
  30 #include "poll-loop.h"
  31 #include "timeval.h"
  32 #include "entropy.h"
  33 #include "unaligned.h"
  34 #include "util.h"
  35 #include "vlan-bitmap.h"
  36 #include "openvswitch/vlog.h"
  37
  38 COVERAGE_DEFINE(mcast_snooping_learned);
  39 COVERAGE_DEFINE(mcast_snooping_expired);
  40
  41 static struct mcast_port_bundle *
  42 mcast_snooping_port_lookup(struct ovs_list *list, void *port);
  43 static struct mcast_mrouter_bundle *
  44 mcast_snooping_mrouter_lookup(struct mcast_snooping *ms, uint16_t vlan,
  45                               void *port)
  46     OVS_REQ_RDLOCK(ms->rwlock);
  47
  48 bool
  49 mcast_snooping_enabled(const struct mcast_snooping *ms)
  50 {
  51     return !!ms;
  52 }
  53
  54 bool
  55 mcast_snooping_flood_unreg(const struct mcast_snooping *ms)
  56 {
  57     return ms->flood_unreg;
  58 }
  59
  60 bool
  61 mcast_snooping_is_query(ovs_be16 igmp_type)
  62 {
  63     return igmp_type == htons(IGMP_HOST_MEMBERSHIP_QUERY);
  64 }
  65
  66 bool
  67 mcast_snooping_is_membership(ovs_be16 igmp_type)
  68 {
  69     switch (ntohs(igmp_type)) {
  70     case IGMP_HOST_MEMBERSHIP_REPORT:
  71     case IGMPV2_HOST_MEMBERSHIP_REPORT:
  72     case IGMPV3_HOST_MEMBERSHIP_REPORT:
  73     case IGMP_HOST_LEAVE_MESSAGE:
  74         return true;
  75     }
  76     return false;
  77 }
  78
  79 /* Returns the number of seconds since multicast group 'b' was learned in a
  80  * port on 'ms'. */
  81 int
  82 mcast_bundle_age(const struct mcast_snooping *ms,
  83                  const struct mcast_group_bundle *b)
  84 {
  85     time_t remaining = b->expires - time_now();
  86     return ms->idle_time - remaining;
  87 }
  88
  89 static uint32_t
  90 mcast_table_hash(const struct mcast_snooping *ms,
  91                  const struct in6_addr *grp_addr, uint16_t vlan)
  92 {
  93     return hash_bytes(grp_addr->s6_addr, 16,
  94                       hash_2words(ms->secret, vlan));
  95 }
  96
  97 static struct mcast_group_bundle *
  98 mcast_group_bundle_from_lru_node(struct ovs_list *list)
  99 {
 100     return CONTAINER_OF(list, struct mcast_group_bundle, bundle_node);
 101 }
 102
 103 static struct mcast_group *
 104 mcast_group_from_lru_node(struct ovs_list *list)
 105 {
 106     return CONTAINER_OF(list, struct mcast_group, group_node);
 107 }
 108
 109 /* Searches 'ms' for and returns an mcast group for destination address
 110  * 'dip' in 'vlan'. */
 111 struct mcast_group *
 112 mcast_snooping_lookup(const struct mcast_snooping *ms,
 113                       const struct in6_addr *dip, uint16_t vlan)
 114     OVS_REQ_RDLOCK(ms->rwlock)
 115 {
 116     struct mcast_group *grp;
 117     uint32_t hash;
 118
 119     hash = mcast_table_hash(ms, dip, vlan);
 120     HMAP_FOR_EACH_WITH_HASH (grp, hmap_node, hash, &ms->table) {
 121         if (grp->vlan == vlan && ipv6_addr_equals(&grp->addr, dip)) {
 122            return grp;
 123         }
 124     }
 125     return NULL;
 126 }
 127
 128 static inline void
 129 in6_addr_set_mapped_ipv4(struct in6_addr *addr, ovs_be32 ip4)
 130 {
 131     union ovs_16aligned_in6_addr *taddr = (void *) addr;
 132     memset(taddr->be16, 0, sizeof(taddr->be16));
 133     taddr->be16[5] = OVS_BE16_MAX;
 134     put_16aligned_be32(&taddr->be32[3], ip4);
 135 }
 136
 137 struct mcast_group *
 138 mcast_snooping_lookup4(const struct mcast_snooping *ms, ovs_be32 ip4,
 139                       uint16_t vlan)
 140     OVS_REQ_RDLOCK(ms->rwlock)
 141 {
 142     struct in6_addr addr;
 143     in6_addr_set_mapped_ipv4(&addr, ip4);
 144     return mcast_snooping_lookup(ms, &addr, vlan);
 145 }
 146
 147 /* If the LRU list is not empty, stores the least-recently-used entry
 148  * in '*e' and returns true.  Otherwise, if the LRU list is empty,
 149  * stores NULL in '*e' and return false. */
 150 static bool
 151 group_get_lru(const struct mcast_snooping *ms, struct mcast_group **grp)
 152     OVS_REQ_RDLOCK(ms->rwlock)
 153 {
 154     if (!list_is_empty(&ms->group_lru)) {
 155         *grp = mcast_group_from_lru_node(ms->group_lru.next);
 156         return true;
 157     } else {
 158         *grp = NULL;
 159         return false;
 160     }
 161 }
 162
 163 static unsigned int
 164 normalize_idle_time(unsigned int idle_time)
 165 {
 166     return (idle_time < 15 ? 15
 167             : idle_time > 3600 ? 3600
 168             : idle_time);
 169 }
 170
 171 /* Creates and returns a new mcast table with an initial mcast aging
 172  * timeout of MCAST_ENTRY_DEFAULT_IDLE_TIME seconds and an initial maximum of
 173  * MCAST_DEFAULT_MAX entries. */
 174 struct mcast_snooping *
 175 mcast_snooping_create(void)
 176 {
 177     struct mcast_snooping *ms;
 178
 179     ms = xmalloc(sizeof *ms);
 180     hmap_init(&ms->table);
 181     list_init(&ms->group_lru);
 182     list_init(&ms->mrouter_lru);
 183     list_init(&ms->fport_list);
 184     list_init(&ms->rport_list);
 185     ms->secret = random_uint32();
 186     ms->idle_time = MCAST_ENTRY_DEFAULT_IDLE_TIME;
 187     ms->max_entries = MCAST_DEFAULT_MAX_ENTRIES;
 188     ms->need_revalidate = false;
 189     ms->flood_unreg = true;
 190     ovs_refcount_init(&ms->ref_cnt);
 191     ovs_rwlock_init(&ms->rwlock);
 192     return ms;
 193 }
 194
 195 struct mcast_snooping *
 196 mcast_snooping_ref(const struct mcast_snooping *ms_)
 197 {
 198     struct mcast_snooping *ms = CONST_CAST(struct mcast_snooping *, ms_);
 199     if (ms) {
 200         ovs_refcount_ref(&ms->ref_cnt);
 201     }
 202     return ms;
 203 }
 204
 205 /* Unreferences (and possibly destroys) mcast snooping table 'ms'. */
 206 void
 207 mcast_snooping_unref(struct mcast_snooping *ms)
 208 {
 209     if (!mcast_snooping_enabled(ms)) {
 210         return;
 211     }
 212
 213     if (ovs_refcount_unref_relaxed(&ms->ref_cnt) == 1) {
 214         mcast_snooping_flush(ms);
 215         hmap_destroy(&ms->table);
 216         ovs_rwlock_destroy(&ms->rwlock);
 217         free(ms);
 218     }
 219 }
 220
 221 /* Changes the mcast aging timeout of 'ms' to 'idle_time' seconds. */
 222 void
 223 mcast_snooping_set_idle_time(struct mcast_snooping *ms, unsigned int idle_time)
 224     OVS_REQ_WRLOCK(ms->rwlock)
 225 {
 226     struct mcast_group *grp;
 227     struct mcast_group_bundle *b;
 228     int delta;
 229
 230     idle_time = normalize_idle_time(idle_time);
 231     if (idle_time != ms->idle_time) {
 232         delta = (int) idle_time - (int) ms->idle_time;
 233         LIST_FOR_EACH (grp, group_node, &ms->group_lru) {
 234             LIST_FOR_EACH (b, bundle_node, &grp->bundle_lru) {
 235                 b->expires += delta;
 236             }
 237         }
 238         ms->idle_time = idle_time;
 239     }
 240 }
 241
 242 /* Sets the maximum number of entries in 'ms' to 'max_entries', adjusting it
 243  * to be within a reasonable range. */
 244 void
 245 mcast_snooping_set_max_entries(struct mcast_snooping *ms,
 246                                size_t max_entries)
 247     OVS_REQ_WRLOCK(ms->rwlock)
 248 {
 249     ms->max_entries = (max_entries < 10 ? 10
 250                        : max_entries > 1000 * 1000 ? 1000 * 1000
 251                        : max_entries);
 252 }
 253
 254 /* Sets if unregistered multicast packets should be flooded to
 255  * all ports or only to ports connected to multicast routers
 256  *
 257  * Returns true if previous state differs from current state,
 258  * false otherwise. */
 259 bool
 260 mcast_snooping_set_flood_unreg(struct mcast_snooping *ms, bool enable)
 261     OVS_REQ_WRLOCK(ms->rwlock)
 262 {
 263     bool prev = ms->flood_unreg;
 264     ms->flood_unreg = enable;
 265     return prev != enable;
 266 }
 267
 268 static struct mcast_group_bundle *
 269 mcast_group_bundle_lookup(struct mcast_snooping *ms OVS_UNUSED,
 270                           struct mcast_group *grp, void *port)
 271     OVS_REQ_RDLOCK(ms->rwlock)
 272 {
 273     struct mcast_group_bundle *b;
 274
 275     LIST_FOR_EACH (b, bundle_node, &grp->bundle_lru) {
 276         if (b->port == port) {
 277             return b;
 278         }
 279     }
 280     return NULL;
 281 }
 282
 283 /* Insert a new bundle to the mcast group or update its
 284  * position and expiration if it is already there. */
 285 static struct mcast_group_bundle *
 286 mcast_group_insert_bundle(struct mcast_snooping *ms OVS_UNUSED,
 287                           struct mcast_group *grp, void *port, int idle_time)
 288     OVS_REQ_WRLOCK(ms->rwlock)
 289 {
 290     struct mcast_group_bundle *b;
 291
 292     b = mcast_group_bundle_lookup(ms, grp, port);
 293     if (b) {
 294         list_remove(&b->bundle_node);
 295     } else {
 296         b = xmalloc(sizeof *b);
 297         list_init(&b->bundle_node);
 298         b->port = port;
 299     }
 300
 301     b->expires = time_now() + idle_time;
 302     list_push_back(&grp->bundle_lru, &b->bundle_node);
 303     return b;
 304 }
 305
 306 /* Return true if multicast still has bundles associated.
 307  * Return false if there is no bundles. */
 308 static bool
 309 mcast_group_has_bundles(struct mcast_group *grp)
 310 {
 311     return !list_is_empty(&grp->bundle_lru);
 312 }
 313
 314 /* Delete 'grp' from the 'ms' hash table.
 315  * Caller is responsible to clean bundle lru first. */
 316 static void
 317 mcast_snooping_flush_group__(struct mcast_snooping *ms,
 318                              struct mcast_group *grp)
 319 {
 320     ovs_assert(list_is_empty(&grp->bundle_lru));
 321     hmap_remove(&ms->table, &grp->hmap_node);
 322     list_remove(&grp->group_node);
 323     free(grp);
 324 }
 325
 326 /* Flush out mcast group and its bundles */
 327 static void
 328 mcast_snooping_flush_group(struct mcast_snooping *ms, struct mcast_group *grp)
 329     OVS_REQ_WRLOCK(ms->rwlock)
 330 {
 331     struct mcast_group_bundle *b;
 332
 333     LIST_FOR_EACH_POP (b, bundle_node, &grp->bundle_lru) {
 334         free(b);
 335     }
 336     mcast_snooping_flush_group__(ms, grp);
 337     ms->need_revalidate = true;
 338 }
 339
 340
 341 /* Delete bundle returning true if it succeeds,
 342  * false if it didn't find the group. */
 343 static bool
 344 mcast_group_delete_bundle(struct mcast_snooping *ms OVS_UNUSED,
 345                           struct mcast_group *grp, void *port)
 346     OVS_REQ_WRLOCK(ms->rwlock)
 347 {
 348     struct mcast_group_bundle *b;
 349
 350     LIST_FOR_EACH (b, bundle_node, &grp->bundle_lru) {
 351         if (b->port == port) {
 352             list_remove(&b->bundle_node);
 353             free(b);
 354             return true;
 355         }
 356     }
 357     return false;
 358 }
 359
 360 /* If any bundle has expired, delete it.  Returns the number of deleted
 361  * bundles. */
 362 static int
 363 mcast_snooping_prune_expired(struct mcast_snooping *ms,
 364                              struct mcast_group *grp)
 365     OVS_REQ_WRLOCK(ms->rwlock)
 366 {
 367     int expired;
 368     struct mcast_group_bundle *b, *next_b;
 369     time_t timenow = time_now();
 370
 371     expired = 0;
 372     LIST_FOR_EACH_SAFE (b, next_b, bundle_node, &grp->bundle_lru) {
 373         /* This list is sorted on expiration time. */
 374         if (b->expires > timenow) {
 375             break;
 376         }
 377         list_remove(&b->bundle_node);
 378         free(b);
 379         expired++;
 380     }
 381
 382     if (!mcast_group_has_bundles(grp)) {
 383         mcast_snooping_flush_group__(ms, grp);
 384         expired++;
 385     }
 386
 387     if (expired) {
 388         ms->need_revalidate = true;
 389         COVERAGE_ADD(mcast_snooping_expired, expired);
 390     }
 391
 392     return expired;
 393 }
 394
 395 /* Add a multicast group to the mdb. If it exists, then
 396  * move to the last position in the LRU list.
 397  */
 398 bool
 399 mcast_snooping_add_group(struct mcast_snooping *ms,
 400                          const struct in6_addr *addr,
 401                          uint16_t vlan, void *port)
 402     OVS_REQ_WRLOCK(ms->rwlock)
 403 {
 404     bool learned;
 405     struct mcast_group *grp;
 406
 407     /* Avoid duplicate packets. */
 408     if (mcast_snooping_mrouter_lookup(ms, vlan, port)
 409         || mcast_snooping_port_lookup(&ms->fport_list, port)) {
 410         return false;
 411     }
 412
 413     learned = false;
 414     grp = mcast_snooping_lookup(ms, addr, vlan);
 415     if (!grp) {
 416         uint32_t hash = mcast_table_hash(ms, addr, vlan);
 417
 418         if (hmap_count(&ms->table) >= ms->max_entries) {
 419             group_get_lru(ms, &grp);
 420             mcast_snooping_flush_group(ms, grp);
 421         }
 422
 423         grp = xmalloc(sizeof *grp);
 424         hmap_insert(&ms->table, &grp->hmap_node, hash);
 425         grp->addr = *addr;
 426         grp->vlan = vlan;
 427         list_init(&grp->bundle_lru);
 428         learned = true;
 429         ms->need_revalidate = true;
 430         COVERAGE_INC(mcast_snooping_learned);
 431     } else {
 432         list_remove(&grp->group_node);
 433     }
 434     mcast_group_insert_bundle(ms, grp, port, ms->idle_time);
 435
 436     /* Mark 'grp' as recently used. */
 437     list_push_back(&ms->group_lru, &grp->group_node);
 438     return learned;
 439 }
 440
 441 bool
 442 mcast_snooping_add_group4(struct mcast_snooping *ms, ovs_be32 ip4,
 443                          uint16_t vlan, void *port)
 444     OVS_REQ_WRLOCK(ms->rwlock)
 445 {
 446     struct in6_addr addr;
 447     in6_addr_set_mapped_ipv4(&addr, ip4);
 448     return mcast_snooping_add_group(ms, &addr, vlan, port);
 449 }
 450
 451 int
 452 mcast_snooping_add_report(struct mcast_snooping *ms,
 453                           const struct dp_packet *p,
 454                           uint16_t vlan, void *port)
 455 {
 456     ovs_be32 ip4;
 457     size_t offset;
 458     const struct igmpv3_header *igmpv3;
 459     const struct igmpv3_record *record;
 460     int count = 0;
 461     int ngrp;
 462
 463     offset = (char *) dp_packet_l4(p) - (char *) dp_packet_data(p);
 464     igmpv3 = dp_packet_at(p, offset, IGMPV3_HEADER_LEN);
 465     if (!igmpv3) {
 466         return 0;
 467     }
 468     ngrp = ntohs(igmpv3->ngrp);
 469     offset += IGMPV3_HEADER_LEN;
 470     while (ngrp--) {
 471         bool ret;
 472         record = dp_packet_at(p, offset, sizeof(struct igmpv3_record));
 473         if (!record) {
 474             break;
 475         }
 476         /* Only consider known record types. */
 477         if (record->type < IGMPV3_MODE_IS_INCLUDE
 478             || record->type > IGMPV3_BLOCK_OLD_SOURCES) {
 479             continue;
 480         }
 481         ip4 = get_16aligned_be32(&record->maddr);
 482         /*
 483          * If record is INCLUDE MODE and there are no sources, it's equivalent
 484          * to a LEAVE.
 485          */
 486         if (ntohs(record->nsrcs) == 0
 487             && (record->type == IGMPV3_MODE_IS_INCLUDE
 488                 || record->type == IGMPV3_CHANGE_TO_INCLUDE_MODE)) {
 489             ret = mcast_snooping_leave_group4(ms, ip4, vlan, port);
 490         } else {
 491             ret = mcast_snooping_add_group4(ms, ip4, vlan, port);
 492         }
 493         if (ret) {
 494             count++;
 495         }
 496         offset += sizeof(*record)
 497                   + ntohs(record->nsrcs) * sizeof(ovs_be32) + record->aux_len;
 498     }
 499     return count;
 500 }
 501
 502 bool
 503 mcast_snooping_leave_group(struct mcast_snooping *ms,
 504                            const struct in6_addr *addr,
 505                            uint16_t vlan, void *port)
 506     OVS_REQ_WRLOCK(ms->rwlock)
 507 {
 508     struct mcast_group *grp;
 509
 510     /* Ports flagged to forward Reports usually have more
 511      * than one host behind it, so don't leave the group
 512      * on the first message and just let it expire */
 513     if (mcast_snooping_port_lookup(&ms->rport_list, port)) {
 514         return false;
 515     }
 516
 517     grp = mcast_snooping_lookup(ms, addr, vlan);
 518     if (grp && mcast_group_delete_bundle(ms, grp, port)) {
 519         ms->need_revalidate = true;
 520         return true;
 521     }
 522     return false;
 523 }
 524
 525 bool
 526 mcast_snooping_leave_group4(struct mcast_snooping *ms, ovs_be32 ip4,
 527                            uint16_t vlan, void *port)
 528 {
 529     struct in6_addr addr;
 530     in6_addr_set_mapped_ipv4(&addr, ip4);
 531     return mcast_snooping_leave_group(ms, &addr, vlan, port);
 532 }
 533
 534 \f
 535 /* Router ports. */
 536
 537 /* Returns the number of seconds since the multicast router
 538  * was learned in a port. */
 539 int
 540 mcast_mrouter_age(const struct mcast_snooping *ms OVS_UNUSED,
 541                   const struct mcast_mrouter_bundle *mrouter)
 542 {
 543     time_t remaining = mrouter->expires - time_now();
 544     return MCAST_MROUTER_PORT_IDLE_TIME - remaining;
 545 }
 546
 547 static struct mcast_mrouter_bundle *
 548 mcast_mrouter_from_lru_node(struct ovs_list *list)
 549 {
 550     return CONTAINER_OF(list, struct mcast_mrouter_bundle, mrouter_node);
 551 }
 552
 553 /* If the LRU list is not empty, stores the least-recently-used mrouter
 554  * in '*m' and returns true.  Otherwise, if the LRU list is empty,
 555  * stores NULL in '*m' and return false. */
 556 static bool
 557 mrouter_get_lru(const struct mcast_snooping *ms,
 558                 struct mcast_mrouter_bundle **m)
 559     OVS_REQ_RDLOCK(ms->rwlock)
 560 {
 561     if (!list_is_empty(&ms->mrouter_lru)) {
 562         *m = mcast_mrouter_from_lru_node(ms->mrouter_lru.next);
 563         return true;
 564     } else {
 565         *m = NULL;
 566         return false;
 567     }
 568 }
 569
 570 static struct mcast_mrouter_bundle *
 571 mcast_snooping_mrouter_lookup(struct mcast_snooping *ms, uint16_t vlan,
 572                               void *port)
 573     OVS_REQ_RDLOCK(ms->rwlock)
 574 {
 575     struct mcast_mrouter_bundle *mrouter;
 576
 577     LIST_FOR_EACH (mrouter, mrouter_node, &ms->mrouter_lru) {
 578         if (mrouter->vlan == vlan && mrouter->port == port) {
 579             return mrouter;
 580         }
 581     }
 582     return NULL;
 583 }
 584
 585 bool
 586 mcast_snooping_add_mrouter(struct mcast_snooping *ms, uint16_t vlan,
 587                            void *port)
 588     OVS_REQ_WRLOCK(ms->rwlock)
 589 {
 590     struct mcast_mrouter_bundle *mrouter;
 591
 592     /* Avoid duplicate packets. */
 593     if (mcast_snooping_port_lookup(&ms->fport_list, port)) {
 594         return false;
 595     }
 596
 597     mrouter = mcast_snooping_mrouter_lookup(ms, vlan, port);
 598     if (mrouter) {
 599         list_remove(&mrouter->mrouter_node);
 600     } else {
 601         mrouter = xmalloc(sizeof *mrouter);
 602         mrouter->vlan = vlan;
 603         mrouter->port = port;
 604         COVERAGE_INC(mcast_snooping_learned);
 605         ms->need_revalidate = true;
 606     }
 607
 608     mrouter->expires = time_now() + MCAST_MROUTER_PORT_IDLE_TIME;
 609     list_push_back(&ms->mrouter_lru, &mrouter->mrouter_node);
 610     return ms->need_revalidate;
 611 }
 612
 613 static void
 614 mcast_snooping_flush_mrouter(struct mcast_mrouter_bundle *mrouter)
 615 {
 616     list_remove(&mrouter->mrouter_node);
 617     free(mrouter);
 618 }
 619 \f
 620 /* Ports */
 621
 622 static struct mcast_port_bundle *
 623 mcast_port_from_list_node(struct ovs_list *list)
 624 {
 625     return CONTAINER_OF(list, struct mcast_port_bundle, node);
 626 }
 627
 628 /* If the list is not empty, stores the fport in '*f' and returns true.
 629  * Otherwise, if the list is empty, stores NULL in '*f' and return false. */
 630 static bool
 631 mcast_snooping_port_get(const struct ovs_list *list,
 632                         struct mcast_port_bundle **f)
 633 {
 634     if (!list_is_empty(list)) {
 635         *f = mcast_port_from_list_node(list->next);
 636         return true;
 637     } else {
 638         *f = NULL;
 639         return false;
 640     }
 641 }
 642
 643 static struct mcast_port_bundle *
 644 mcast_snooping_port_lookup(struct ovs_list *list, void *port)
 645 {
 646     struct mcast_port_bundle *pbundle;
 647
 648     LIST_FOR_EACH (pbundle, node, list) {
 649         if (pbundle->port == port) {
 650             return pbundle;
 651         }
 652     }
 653     return NULL;
 654 }
 655
 656 static void
 657 mcast_snooping_add_port(struct ovs_list *list, void *port)
 658 {
 659     struct mcast_port_bundle *pbundle;
 660
 661     pbundle = xmalloc(sizeof *pbundle);
 662     pbundle->port = port;
 663     list_insert(list, &pbundle->node);
 664 }
 665
 666 static void
 667 mcast_snooping_flush_port(struct mcast_port_bundle *pbundle)
 668 {
 669     list_remove(&pbundle->node);
 670     free(pbundle);
 671 }
 672
 673 \f
 674 /* Flood ports. */
 675 void
 676 mcast_snooping_set_port_flood(struct mcast_snooping *ms, void *port,
 677                               bool flood)
 678     OVS_REQ_WRLOCK(ms->rwlock)
 679 {
 680     struct mcast_port_bundle *fbundle;
 681
 682     fbundle = mcast_snooping_port_lookup(&ms->fport_list, port);
 683     if (flood && !fbundle) {
 684         mcast_snooping_add_port(&ms->fport_list, port);
 685         ms->need_revalidate = true;
 686     } else if (!flood && fbundle) {
 687         mcast_snooping_flush_port(fbundle);
 688         ms->need_revalidate = true;
 689     }
 690 }
 691 \f
 692 /* Flood Reports ports. */
 693
 694 void
 695 mcast_snooping_set_port_flood_reports(struct mcast_snooping *ms, void *port,
 696                                       bool flood)
 697     OVS_REQ_WRLOCK(ms->rwlock)
 698 {
 699     struct mcast_port_bundle *pbundle;
 700
 701     pbundle = mcast_snooping_port_lookup(&ms->rport_list, port);
 702     if (flood && !pbundle) {
 703         mcast_snooping_add_port(&ms->rport_list, port);
 704         ms->need_revalidate = true;
 705     } else if (!flood && pbundle) {
 706         mcast_snooping_flush_port(pbundle);
 707         ms->need_revalidate = true;
 708     }
 709 }
 710 \f
 711 /* Run and flush. */
 712
 713 static void
 714 mcast_snooping_mdb_flush__(struct mcast_snooping *ms)
 715     OVS_REQ_WRLOCK(ms->rwlock)
 716 {
 717     struct mcast_group *grp;
 718     struct mcast_mrouter_bundle *mrouter;
 719
 720     while (group_get_lru(ms, &grp)) {
 721         mcast_snooping_flush_group(ms, grp);
 722     }
 723
 724     hmap_shrink(&ms->table);
 725
 726     while (mrouter_get_lru(ms, &mrouter)) {
 727         mcast_snooping_flush_mrouter(mrouter);
 728     }
 729 }
 730
 731 void
 732 mcast_snooping_mdb_flush(struct mcast_snooping *ms)
 733 {
 734     if (!mcast_snooping_enabled(ms)) {
 735         return;
 736     }
 737
 738     ovs_rwlock_wrlock(&ms->rwlock);
 739     mcast_snooping_mdb_flush__(ms);
 740     ovs_rwlock_unlock(&ms->rwlock);
 741 }
 742
 743 /* Flushes mdb and flood ports. */
 744 static void
 745 mcast_snooping_flush__(struct mcast_snooping *ms)
 746     OVS_REQ_WRLOCK(ms->rwlock)
 747 {
 748     struct mcast_group *grp;
 749     struct mcast_mrouter_bundle *mrouter;
 750     struct mcast_port_bundle *pbundle;
 751
 752     while (group_get_lru(ms, &grp)) {
 753         mcast_snooping_flush_group(ms, grp);
 754     }
 755
 756     hmap_shrink(&ms->table);
 757
 758     /* flush multicast routers */
 759     while (mrouter_get_lru(ms, &mrouter)) {
 760         mcast_snooping_flush_mrouter(mrouter);
 761     }
 762
 763     /* flush flood ports */
 764     while (mcast_snooping_port_get(&ms->fport_list, &pbundle)) {
 765         mcast_snooping_flush_port(pbundle);
 766     }
 767
 768     /* flush flood report ports */
 769     while (mcast_snooping_port_get(&ms->rport_list, &pbundle)) {
 770         mcast_snooping_flush_port(pbundle);
 771     }
 772 }
 773
 774 void
 775 mcast_snooping_flush(struct mcast_snooping *ms)
 776 {
 777     if (!mcast_snooping_enabled(ms)) {
 778         return;
 779     }
 780
 781     ovs_rwlock_wrlock(&ms->rwlock);
 782     mcast_snooping_flush__(ms);
 783     ovs_rwlock_unlock(&ms->rwlock);
 784 }
 785
 786 static bool
 787 mcast_snooping_run__(struct mcast_snooping *ms)
 788     OVS_REQ_WRLOCK(ms->rwlock)
 789 {
 790     bool need_revalidate;
 791     struct mcast_group *grp;
 792     struct mcast_mrouter_bundle *mrouter;
 793     int mrouter_expired;
 794
 795     while (group_get_lru(ms, &grp)) {
 796         if (hmap_count(&ms->table) > ms->max_entries) {
 797             mcast_snooping_flush_group(ms, grp);
 798         } else {
 799             if (!mcast_snooping_prune_expired(ms, grp)) {
 800                 break;
 801             }
 802         }
 803     }
 804
 805     hmap_shrink(&ms->table);
 806
 807     mrouter_expired = 0;
 808     while (mrouter_get_lru(ms, &mrouter)
 809            && time_now() >= mrouter->expires) {
 810         mcast_snooping_flush_mrouter(mrouter);
 811         mrouter_expired++;
 812     }
 813
 814     if (mrouter_expired) {
 815         ms->need_revalidate = true;
 816         COVERAGE_ADD(mcast_snooping_expired, mrouter_expired);
 817     }
 818
 819     need_revalidate = ms->need_revalidate;
 820     ms->need_revalidate = false;
 821     return need_revalidate;
 822 }
 823
 824 /* Does periodic work required by 'ms'. Returns true if something changed
 825  * that may require flow revalidation. */
 826 bool
 827 mcast_snooping_run(struct mcast_snooping *ms)
 828 {
 829     bool need_revalidate;
 830
 831     if (!mcast_snooping_enabled(ms)) {
 832         return false;
 833     }
 834
 835     ovs_rwlock_wrlock(&ms->rwlock);
 836     need_revalidate = mcast_snooping_run__(ms);
 837     ovs_rwlock_unlock(&ms->rwlock);
 838
 839     return need_revalidate;
 840 }
 841
 842 static void
 843 mcast_snooping_wait__(struct mcast_snooping *ms)
 844     OVS_REQ_RDLOCK(ms->rwlock)
 845 {
 846     if (hmap_count(&ms->table) > ms->max_entries
 847         || ms->need_revalidate) {
 848         poll_immediate_wake();
 849     } else {
 850         struct mcast_group *grp;
 851         struct mcast_group_bundle *bundle;
 852         struct mcast_mrouter_bundle *mrouter;
 853         long long int mrouter_msec;
 854         long long int msec = 0;
 855
 856         if (!list_is_empty(&ms->group_lru)) {
 857             grp = mcast_group_from_lru_node(ms->group_lru.next);
 858             bundle = mcast_group_bundle_from_lru_node(grp->bundle_lru.next);
 859             msec = bundle->expires * 1000LL;
 860         }
 861
 862         if (!list_is_empty(&ms->mrouter_lru)) {
 863             mrouter = mcast_mrouter_from_lru_node(ms->mrouter_lru.next);
 864             mrouter_msec = mrouter->expires * 1000LL;
 865             msec = msec ? MIN(msec, mrouter_msec) : mrouter_msec;
 866         }
 867
 868         if (msec) {
 869             poll_timer_wait_until(msec);
 870         }
 871     }
 872 }
 873
 874 void
 875 mcast_snooping_wait(struct mcast_snooping *ms)
 876 {
 877     if (!mcast_snooping_enabled(ms)) {
 878         return;
 879     }
 880
 881     ovs_rwlock_rdlock(&ms->rwlock);
 882     mcast_snooping_wait__(ms);
 883     ovs_rwlock_unlock(&ms->rwlock);
 884 }