ovn/northd/ovn-northd.c

   1 /*
   2  * Licensed under the Apache License, Version 2.0 (the "License");
   3  * you may not use this file except in compliance with the License.
   4  * You may obtain a copy of the License at:
   5  *
   6  *     http://www.apache.org/licenses/LICENSE-2.0
   7  *
   8  * Unless required by applicable law or agreed to in writing, software
   9  * distributed under the License is distributed on an "AS IS" BASIS,
  10  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11  * See the License for the specific language governing permissions and
  12  * limitations under the License.
  13  */
  14
  15 #include <config.h>
  16
  17 #include <getopt.h>
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20
  21 #include "command-line.h"
  22 #include "daemon.h"
  23 #include "dirs.h"
  24 #include "dynamic-string.h"
  25 #include "fatal-signal.h"
  26 #include "hash.h"
  27 #include "hmap.h"
  28 #include "json.h"
  29 #include "ovn/lib/lex.h"
  30 #include "ovn/ovn-nb-idl.h"
  31 #include "ovn/ovn-sb-idl.h"
  32 #include "poll-loop.h"
  33 #include "stream.h"
  34 #include "stream-ssl.h"
  35 #include "util.h"
  36 #include "uuid.h"
  37 #include "openvswitch/vlog.h"
  38
  39 VLOG_DEFINE_THIS_MODULE(ovn_northd);
  40
  41 struct northd_context {
  42     struct ovsdb_idl *ovnnb_idl;
  43     struct ovsdb_idl *ovnsb_idl;
  44     struct ovsdb_idl_txn *ovnnb_txn;
  45     struct ovsdb_idl_txn *ovnsb_txn;
  46 };
  47
  48 static const char *ovnnb_db;
  49 static const char *ovnsb_db;
  50
  51 static const char *default_db(void);
  52
  53 static void
  54 usage(void)
  55 {
  56     printf("\
  57 %s: OVN northbound management daemon\n\
  58 usage: %s [OPTIONS]\n\
  59 \n\
  60 Options:\n\
  61   --ovnnb-db=DATABASE       connect to ovn-nb database at DATABASE\n\
  62                             (default: %s)\n\
  63   --ovnsb-db=DATABASE       connect to ovn-sb database at DATABASE\n\
  64                             (default: %s)\n\
  65   -h, --help                display this help message\n\
  66   -o, --options             list available options\n\
  67   -V, --version             display version information\n\
  68 ", program_name, program_name, default_db(), default_db());
  69     daemon_usage();
  70     vlog_usage();
  71     stream_usage("database", true, true, false);
  72 }
  73 \f
  74 static int
  75 compare_strings(const void *a_, const void *b_)
  76 {
  77     char *const *a = a_;
  78     char *const *b = b_;
  79     return strcmp(*a, *b);
  80 }
  81
  82 /*
  83  * Determine whether 2 arrays of MAC addresses are the same.  It's possible that
  84  * the lists could be *very* long and this check is being done a lot (every
  85  * time the OVN_Northbound database changes).
  86  */
  87 static bool
  88 macs_equal(char **binding_macs_, size_t b_n_macs,
  89            char **lport_macs_, size_t l_n_macs)
  90 {
  91     char **binding_macs, **lport_macs;
  92     size_t bytes, i;
  93
  94     if (b_n_macs != l_n_macs) {
  95         return false;
  96     }
  97
  98     bytes = b_n_macs * sizeof binding_macs_[0];
  99     binding_macs = xmalloc(bytes);
 100     lport_macs = xmalloc(bytes);
 101
 102     memcpy(binding_macs, binding_macs_, bytes);
 103     memcpy(lport_macs, lport_macs_, bytes);
 104
 105     qsort(binding_macs, b_n_macs, sizeof binding_macs[0], compare_strings);
 106     qsort(lport_macs, l_n_macs, sizeof lport_macs[0], compare_strings);
 107
 108     for (i = 0; i < b_n_macs; i++) {
 109         if (strcmp(binding_macs[i], lport_macs[i])) {
 110             break;
 111         }
 112     }
 113
 114     free(binding_macs);
 115     free(lport_macs);
 116
 117     return (i == b_n_macs) ? true : false;
 118 }
 119 \f
 120 /* Pipeline generation.
 121  *
 122  * This code generates the Pipeline table in the southbound database, as a
 123  * function of most of the northbound database.
 124  */
 125
 126 /* Enough context to add a Pipeline row, using pipeline_add(). */
 127 struct pipeline_ctx {
 128     /* From northd_context. */
 129     struct ovsdb_idl *ovnsb_idl;
 130     struct ovsdb_idl_txn *ovnsb_txn;
 131
 132     /* Contains "struct pipeline_hash_node"s.  Used to figure out what existing
 133      * Pipeline rows should be deleted: we index all of the Pipeline rows into
 134      * this data structure, then as existing rows are generated we remove them.
 135      * After generating all the rows, any remaining in 'pipeline_hmap' must be
 136      * deleted from the database. */
 137     struct hmap pipeline_hmap;
 138 };
 139
 140 /* A row in the Pipeline table, indexed by its full contents, */
 141 struct pipeline_hash_node {
 142     struct hmap_node node;
 143     const struct sbrec_pipeline *pipeline;
 144 };
 145
 146 static size_t
 147 pipeline_hash(const struct uuid *logical_datapath, uint8_t table_id,
 148               uint16_t priority, const char *match, const char *actions)
 149 {
 150     size_t hash = uuid_hash(logical_datapath);
 151     hash = hash_2words((table_id << 16) | priority, hash);
 152     hash = hash_string(match, hash);
 153     return hash_string(actions, hash);
 154 }
 155
 156 static size_t
 157 pipeline_hash_rec(const struct sbrec_pipeline *pipeline)
 158 {
 159     return pipeline_hash(&pipeline->logical_datapath, pipeline->table_id,
 160                          pipeline->priority, pipeline->match,
 161                          pipeline->actions);
 162 }
 163
 164 /* Adds a row with the specified contents to the Pipeline table. */
 165 static void
 166 pipeline_add(struct pipeline_ctx *ctx,
 167              const struct nbrec_logical_switch *logical_datapath,
 168              uint8_t table_id,
 169              uint16_t priority,
 170              const char *match,
 171              const char *actions)
 172 {
 173     struct pipeline_hash_node *hash_node;
 174
 175     /* Check whether such a row already exists in the Pipeline table.  If so,
 176      * remove it from 'ctx->pipeline_hmap' and we're done. */
 177     HMAP_FOR_EACH_WITH_HASH (hash_node, node,
 178                              pipeline_hash(&logical_datapath->header_.uuid,
 179                                            table_id, priority, match, actions),
 180                              &ctx->pipeline_hmap) {
 181         const struct sbrec_pipeline *pipeline = hash_node->pipeline;
 182         if (uuid_equals(&pipeline->logical_datapath,
 183                         &logical_datapath->header_.uuid)
 184             && pipeline->table_id == table_id
 185             && pipeline->priority == priority
 186             && !strcmp(pipeline->match, match)
 187             && !strcmp(pipeline->actions, actions)) {
 188             hmap_remove(&ctx->pipeline_hmap, &hash_node->node);
 189             free(hash_node);
 190             return;
 191         }
 192     }
 193
 194     /* No such Pipeline row.  Add one. */
 195     const struct sbrec_pipeline *pipeline;
 196     pipeline = sbrec_pipeline_insert(ctx->ovnsb_txn);
 197     sbrec_pipeline_set_logical_datapath(pipeline,
 198                                         logical_datapath->header_.uuid);
 199     sbrec_pipeline_set_table_id(pipeline, table_id);
 200     sbrec_pipeline_set_priority(pipeline, priority);
 201     sbrec_pipeline_set_match(pipeline, match);
 202     sbrec_pipeline_set_actions(pipeline, actions);
 203 }
 204
 205 /* A single port security constraint.  This is a parsed version of a single
 206  * member of the port_security column in the OVN_NB Logical_Port table.
 207  *
 208  * Each token has type LEX_T_END if that field is missing, otherwise
 209  * LEX_T_INTEGER or LEX_T_MASKED_INTEGER. */
 210 struct ps_constraint {
 211     struct lex_token eth;
 212     struct lex_token ip4;
 213     struct lex_token ip6;
 214 };
 215
 216 /* Parses a member of the port_security column 'ps' into 'c'.  Returns true if
 217  * successful, false on syntax error. */
 218 static bool
 219 parse_port_security(const char *ps, struct ps_constraint *c)
 220 {
 221     c->eth.type = LEX_T_END;
 222     c->ip4.type = LEX_T_END;
 223     c->ip6.type = LEX_T_END;
 224
 225     struct lexer lexer;
 226     lexer_init(&lexer, ps);
 227     do {
 228         if (lexer.token.type == LEX_T_INTEGER ||
 229             lexer.token.type == LEX_T_MASKED_INTEGER) {
 230             struct lex_token *t;
 231
 232             t = (lexer.token.format == LEX_F_IPV4 ? &c->ip4
 233                  : lexer.token.format == LEX_F_IPV6 ? &c->ip6
 234                  : lexer.token.format == LEX_F_ETHERNET ? &c->eth
 235                  : NULL);
 236             if (t) {
 237                 if (t->type == LEX_T_END) {
 238                     *t = lexer.token;
 239                 } else {
 240                     VLOG_INFO("%s: port_security has duplicate %s address",
 241                               ps, lex_format_to_string(lexer.token.format));
 242                 }
 243                 lexer_get(&lexer);
 244                 lexer_match(&lexer, LEX_T_COMMA);
 245                 continue;
 246             }
 247         }
 248
 249         VLOG_INFO("%s: syntax error in port_security", ps);
 250         lexer_destroy(&lexer);
 251         return false;
 252     } while (lexer.token.type != LEX_T_END);
 253     lexer_destroy(&lexer);
 254
 255     return true;
 256 }
 257
 258 /* Appends port security constraints on L2 address field 'eth_addr_field'
 259  * (e.g. "eth.src" or "eth.dst") to 'match'.  'port_security', with
 260  * 'n_port_security' elements, is the collection of port_security constraints
 261  * from an OVN_NB Logical_Port row.
 262  *
 263  * (This is naive; it's not yet possible to express complete L2 and L3 port
 264  * security constraints as a single Boolean expression.) */
 265 static void
 266 build_port_security(const char *eth_addr_field,
 267                     char **port_security, size_t n_port_security,
 268                     struct ds *match)
 269 {
 270     size_t base_len = match->length;
 271     ds_put_format(match, " && %s == {", eth_addr_field);
 272
 273     size_t n = 0;
 274     for (size_t i = 0; i < n_port_security; i++) {
 275         struct ps_constraint c;
 276         if (parse_port_security(port_security[i], &c)
 277             && c.eth.type != LEX_T_END) {
 278             lex_token_format(&c.eth, match);
 279             ds_put_char(match, ' ');
 280             n++;
 281         }
 282     }
 283     ds_put_cstr(match, "}");
 284
 285     if (!n) {
 286         match->length = base_len;
 287     }
 288 }
 289
 290 /* Updates the Pipeline table in the OVN_SB database, constructing its contents
 291  * based on the OVN_NB database. */
 292 static void
 293 build_pipeline(struct northd_context *ctx)
 294 {
 295     struct pipeline_ctx pc = {
 296         .ovnsb_idl = ctx->ovnsb_idl,
 297         .ovnsb_txn = ctx->ovnsb_txn,
 298         .pipeline_hmap = HMAP_INITIALIZER(&pc.pipeline_hmap)
 299     };
 300
 301     /* Add all the Pipeline entries currently in the southbound database to
 302      * 'pc.pipeline_hmap'.  We remove entries that we generate from the hmap,
 303      * thus by the time we're done only entries that need to be removed
 304      * remain. */
 305     const struct sbrec_pipeline *pipeline;
 306     SBREC_PIPELINE_FOR_EACH (pipeline, ctx->ovnsb_idl) {
 307         struct pipeline_hash_node *hash_node = xzalloc(sizeof *hash_node);
 308         hash_node->pipeline = pipeline;
 309         hmap_insert(&pc.pipeline_hmap, &hash_node->node,
 310                     pipeline_hash_rec(pipeline));
 311     }
 312
 313     /* Table 0: Admission control framework. */
 314     const struct nbrec_logical_switch *lswitch;
 315     NBREC_LOGICAL_SWITCH_FOR_EACH (lswitch, ctx->ovnnb_idl) {
 316         /* Logical VLANs not supported. */
 317         pipeline_add(&pc, lswitch, 0, 100, "vlan.present", "drop");
 318
 319         /* Broadcast/multicast source address is invalid. */
 320         pipeline_add(&pc, lswitch, 0, 100, "eth.src[40]", "drop");
 321
 322         /* Port security flows have priority 50 (see below) and will resubmit
 323          * if packet source is acceptable. */
 324
 325         /* Otherwise drop the packet. */
 326         pipeline_add(&pc, lswitch, 0, 0, "1", "drop");
 327     }
 328
 329     /* Table 0: Ingress port security. */
 330     const struct nbrec_logical_port *lport;
 331     NBREC_LOGICAL_PORT_FOR_EACH (lport, ctx->ovnnb_idl) {
 332         struct ds match = DS_EMPTY_INITIALIZER;
 333         ds_put_cstr(&match, "inport == ");
 334         json_string_escape(lport->name, &match);
 335         build_port_security("eth.src",
 336                             lport->port_security, lport->n_port_security,
 337                             &match);
 338         pipeline_add(&pc, lport->lswitch, 0, 50, ds_cstr(&match), "resubmit");
 339         ds_destroy(&match);
 340     }
 341
 342     /* Table 1: Destination lookup, broadcast and multicast handling (priority
 343      * 100). */
 344     NBREC_LOGICAL_SWITCH_FOR_EACH (lswitch, ctx->ovnnb_idl) {
 345         struct ds actions;
 346
 347         ds_init(&actions);
 348         NBREC_LOGICAL_PORT_FOR_EACH (lport, ctx->ovnnb_idl) {
 349             if (lport->lswitch == lswitch) {
 350                 ds_put_cstr(&actions, "outport = ");
 351                 json_string_escape(lport->name, &actions);
 352                 ds_put_cstr(&actions, "; resubmit; ");
 353             }
 354         }
 355         ds_chomp(&actions, ' ');
 356
 357         pipeline_add(&pc, lswitch, 1, 100, "eth.dst[40]", ds_cstr(&actions));
 358         ds_destroy(&actions);
 359     }
 360
 361     /* Table 1: Destination lookup, unicast handling (priority 50),  */
 362     struct ds unknown_actions = DS_EMPTY_INITIALIZER;
 363     NBREC_LOGICAL_PORT_FOR_EACH (lport, ctx->ovnnb_idl) {
 364         for (size_t i = 0; i < lport->n_macs; i++) {
 365             uint8_t mac[ETH_ADDR_LEN];
 366
 367             if (eth_addr_from_string(lport->macs[i], mac)) {
 368                 struct ds match, actions;
 369
 370                 ds_init(&match);
 371                 ds_put_format(&match, "eth.dst == %s", lport->macs[i]);
 372
 373                 ds_init(&actions);
 374                 ds_put_cstr(&actions, "outport = ");
 375                 json_string_escape(lport->name, &actions);
 376                 ds_put_cstr(&actions, "; resubmit;");
 377                 pipeline_add(&pc, lport->lswitch, 1, 50,
 378                              ds_cstr(&match), ds_cstr(&actions));
 379                 ds_destroy(&actions);
 380                 ds_destroy(&match);
 381             } else if (!strcmp(lport->macs[i], "unknown")) {
 382                 ds_put_cstr(&unknown_actions, "outport = ");
 383                 json_string_escape(lport->name, &unknown_actions);
 384                 ds_put_cstr(&unknown_actions, "; resubmit; ");
 385             } else {
 386                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
 387
 388                 VLOG_INFO_RL(&rl, "%s: invalid syntax '%s' in macs column",
 389                              lport->name, lport->macs[i]);
 390             }
 391         }
 392     }
 393
 394     /* Table 1: Destination lookup for unknown MACs (priority 0). */
 395     if (unknown_actions.length) {
 396         ds_chomp(&unknown_actions, ' ');
 397         pipeline_add(&pc, lport->lswitch, 1, 0, "1",
 398                      ds_cstr(&unknown_actions));
 399     }
 400     ds_destroy(&unknown_actions);
 401
 402     /* Table 2: ACLs. */
 403     const struct nbrec_acl *acl;
 404     NBREC_ACL_FOR_EACH (acl, ctx->ovnnb_idl) {
 405         const char *action;
 406
 407         action = (!strcmp(acl->action, "allow") ||
 408                   !strcmp(acl->action, "allow-related")) ? "resubmit" : "drop";
 409         pipeline_add(&pc, acl->lswitch, 2, acl->priority, acl->match, action);
 410     }
 411     NBREC_LOGICAL_SWITCH_FOR_EACH (lswitch, ctx->ovnnb_idl) {
 412         pipeline_add(&pc, lswitch, 2, 0, "1", "resubmit");
 413     }
 414
 415     /* Table 3: Egress port security. */
 416     NBREC_LOGICAL_PORT_FOR_EACH (lport, ctx->ovnnb_idl) {
 417         struct ds match, actions;
 418
 419         ds_init(&match);
 420         ds_put_cstr(&match, "outport == ");
 421         json_string_escape(lport->name, &match);
 422         build_port_security("eth.dst",
 423                             lport->port_security, lport->n_port_security,
 424                             &match);
 425
 426         ds_init(&actions);
 427         ds_put_cstr(&actions, "output(");
 428         json_string_escape(lport->name, &actions);
 429         ds_put_char(&actions, ')');
 430
 431         pipeline_add(&pc, lport->lswitch, 3, 50,
 432                      ds_cstr(&match), ds_cstr(&actions));
 433
 434         ds_destroy(&actions);
 435         ds_destroy(&match);
 436     }
 437
 438     /* Delete any existing Pipeline rows that were not re-generated.  */
 439     struct pipeline_hash_node *hash_node, *next_hash_node;
 440     HMAP_FOR_EACH_SAFE (hash_node, next_hash_node, node, &pc.pipeline_hmap) {
 441         hmap_remove(&pc.pipeline_hmap, &hash_node->node);
 442         sbrec_pipeline_delete(hash_node->pipeline);
 443         free(hash_node);
 444     }
 445     hmap_destroy(&pc.pipeline_hmap);
 446 }
 447 \f
 448 static bool
 449 parents_equal(const struct sbrec_bindings *binding,
 450               const struct nbrec_logical_port *lport)
 451 {
 452     if (!!binding->parent_port != !!lport->parent_name) {
 453         /* One is set and the other is not. */
 454         return false;
 455     }
 456
 457     if (binding->parent_port) {
 458         /* Both are set. */
 459         return strcmp(binding->parent_port, lport->parent_name) ? false : true;
 460     }
 461
 462     /* Both are NULL. */
 463     return true;
 464 }
 465
 466 static bool
 467 tags_equal(const struct sbrec_bindings *binding,
 468            const struct nbrec_logical_port *lport)
 469 {
 470     if (binding->n_tag != lport->n_tag) {
 471         return false;
 472     }
 473
 474     return binding->n_tag ? (binding->tag[0] == lport->tag[0]) : true;
 475 }
 476
 477 /*
 478  * When a change has occurred in the OVN_Northbound database, we go through and
 479  * make sure that the contents of the Bindings table in the OVN_Southbound
 480  * database are up to date with the logical ports defined in the
 481  * OVN_Northbound database.
 482  */
 483 static void
 484 set_bindings(struct northd_context *ctx)
 485 {
 486     struct hmap bindings_hmap;
 487     const struct sbrec_bindings *binding;
 488     const struct nbrec_logical_port *lport;
 489
 490     struct binding_hash_node {
 491         struct hmap_node node;
 492         const struct sbrec_bindings *binding;
 493     } *hash_node, *hash_node_next;
 494
 495     /*
 496      * We will need to look up a binding for every logical port.  We don't want
 497      * to have to do an O(n) search for every binding, so start out by hashing
 498      * them on the logical port.
 499      *
 500      * As we go through every logical port, we will update the binding if it
 501      * exists or create one otherwise.  When the update is done, we'll remove it
 502      * from the hashmap.  At the end, any bindings left in the hashmap are for
 503      * logical ports that have been deleted.
 504      */
 505     hmap_init(&bindings_hmap);
 506
 507     SBREC_BINDINGS_FOR_EACH(binding, ctx->ovnsb_idl) {
 508         hash_node = xzalloc(sizeof *hash_node);
 509         hash_node->binding = binding;
 510         hmap_insert(&bindings_hmap, &hash_node->node,
 511                 hash_string(binding->logical_port, 0));
 512     }
 513
 514     NBREC_LOGICAL_PORT_FOR_EACH(lport, ctx->ovnnb_idl) {
 515         binding = NULL;
 516         HMAP_FOR_EACH_WITH_HASH(hash_node, node,
 517                 hash_string(lport->name, 0), &bindings_hmap) {
 518             if (!strcmp(lport->name, hash_node->binding->logical_port)) {
 519                 binding = hash_node->binding;
 520                 break;
 521             }
 522         }
 523
 524         if (binding) {
 525             /* We found an existing binding for this logical port.  Update its
 526              * contents. */
 527
 528             hmap_remove(&bindings_hmap, &hash_node->node);
 529             free(hash_node);
 530             hash_node = NULL;
 531
 532             if (!macs_equal(binding->mac, binding->n_mac,
 533                         lport->macs, lport->n_macs)) {
 534                 sbrec_bindings_set_mac(binding,
 535                         (const char **) lport->macs, lport->n_macs);
 536             }
 537             if (!parents_equal(binding, lport)) {
 538                 sbrec_bindings_set_parent_port(binding, lport->parent_name);
 539             }
 540             if (!tags_equal(binding, lport)) {
 541                 sbrec_bindings_set_tag(binding, lport->tag, lport->n_tag);
 542             }
 543         } else {
 544             /* There is no binding for this logical port, so create one. */
 545
 546             binding = sbrec_bindings_insert(ctx->ovnsb_txn);
 547             sbrec_bindings_set_logical_port(binding, lport->name);
 548             sbrec_bindings_set_mac(binding,
 549                     (const char **) lport->macs, lport->n_macs);
 550             if (lport->parent_name && lport->n_tag > 0) {
 551                 sbrec_bindings_set_parent_port(binding, lport->parent_name);
 552                 sbrec_bindings_set_tag(binding, lport->tag, lport->n_tag);
 553             }
 554         }
 555     }
 556
 557     HMAP_FOR_EACH_SAFE(hash_node, hash_node_next, node, &bindings_hmap) {
 558         hmap_remove(&bindings_hmap, &hash_node->node);
 559         sbrec_bindings_delete(hash_node->binding);
 560         free(hash_node);
 561     }
 562     hmap_destroy(&bindings_hmap);
 563 }
 564
 565 static void
 566 ovnnb_db_changed(struct northd_context *ctx)
 567 {
 568     VLOG_DBG("ovn-nb db contents have changed.");
 569
 570     set_bindings(ctx);
 571     build_pipeline(ctx);
 572 }
 573
 574 /*
 575  * The only change we get notified about is if the 'chassis' column of the
 576  * 'Bindings' table changes.  When this column is not empty, it means we need to
 577  * set the corresponding logical port as 'up' in the northbound DB.
 578  */
 579 static void
 580 ovnsb_db_changed(struct northd_context *ctx)
 581 {
 582     struct hmap lports_hmap;
 583     const struct sbrec_bindings *binding;
 584     const struct nbrec_logical_port *lport;
 585
 586     struct lport_hash_node {
 587         struct hmap_node node;
 588         const struct nbrec_logical_port *lport;
 589     } *hash_node, *hash_node_next;
 590
 591     VLOG_DBG("Recalculating port up states for ovn-nb db.");
 592
 593     hmap_init(&lports_hmap);
 594
 595     NBREC_LOGICAL_PORT_FOR_EACH(lport, ctx->ovnnb_idl) {
 596         hash_node = xzalloc(sizeof *hash_node);
 597         hash_node->lport = lport;
 598         hmap_insert(&lports_hmap, &hash_node->node,
 599                 hash_string(lport->name, 0));
 600     }
 601
 602     SBREC_BINDINGS_FOR_EACH(binding, ctx->ovnsb_idl) {
 603         lport = NULL;
 604         HMAP_FOR_EACH_WITH_HASH(hash_node, node,
 605                 hash_string(binding->logical_port, 0), &lports_hmap) {
 606             if (!strcmp(binding->logical_port, hash_node->lport->name)) {
 607                 lport = hash_node->lport;
 608                 break;
 609             }
 610         }
 611
 612         if (!lport) {
 613             /* The logical port doesn't exist for this binding.  This can
 614              * happen under normal circumstances when ovn-northd hasn't gotten
 615              * around to pruning the Binding yet. */
 616             continue;
 617         }
 618
 619         if (*binding->chassis && (!lport->up || !*lport->up)) {
 620             bool up = true;
 621             nbrec_logical_port_set_up(lport, &up, 1);
 622         } else if (!*binding->chassis && (!lport->up || *lport->up)) {
 623             bool up = false;
 624             nbrec_logical_port_set_up(lport, &up, 1);
 625         }
 626     }
 627
 628     HMAP_FOR_EACH_SAFE(hash_node, hash_node_next, node, &lports_hmap) {
 629         hmap_remove(&lports_hmap, &hash_node->node);
 630         free(hash_node);
 631     }
 632     hmap_destroy(&lports_hmap);
 633 }
 634 \f
 635 static const char *
 636 default_db(void)
 637 {
 638     static char *def;
 639     if (!def) {
 640         def = xasprintf("unix:%s/db.sock", ovs_rundir());
 641     }
 642     return def;
 643 }
 644
 645 static void
 646 parse_options(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 647 {
 648     enum {
 649         DAEMON_OPTION_ENUMS,
 650         VLOG_OPTION_ENUMS,
 651     };
 652     static const struct option long_options[] = {
 653         {"ovnsb-db", required_argument, NULL, 'd'},
 654         {"ovnnb-db", required_argument, NULL, 'D'},
 655         {"help", no_argument, NULL, 'h'},
 656         {"options", no_argument, NULL, 'o'},
 657         {"version", no_argument, NULL, 'V'},
 658         DAEMON_LONG_OPTIONS,
 659         VLOG_LONG_OPTIONS,
 660         STREAM_SSL_LONG_OPTIONS,
 661         {NULL, 0, NULL, 0},
 662     };
 663     char *short_options = ovs_cmdl_long_options_to_short_options(long_options);
 664
 665     for (;;) {
 666         int c;
 667
 668         c = getopt_long(argc, argv, short_options, long_options, NULL);
 669         if (c == -1) {
 670             break;
 671         }
 672
 673         switch (c) {
 674         DAEMON_OPTION_HANDLERS;
 675         VLOG_OPTION_HANDLERS;
 676         STREAM_SSL_OPTION_HANDLERS;
 677
 678         case 'd':
 679             ovnsb_db = optarg;
 680             break;
 681
 682         case 'D':
 683             ovnnb_db = optarg;
 684             break;
 685
 686         case 'h':
 687             usage();
 688             exit(EXIT_SUCCESS);
 689
 690         case 'o':
 691             ovs_cmdl_print_options(long_options);
 692             exit(EXIT_SUCCESS);
 693
 694         case 'V':
 695             ovs_print_version(0, 0);
 696             exit(EXIT_SUCCESS);
 697
 698         default:
 699             break;
 700         }
 701     }
 702
 703     if (!ovnsb_db) {
 704         ovnsb_db = default_db();
 705     }
 706
 707     if (!ovnnb_db) {
 708         ovnnb_db = default_db();
 709     }
 710
 711     free(short_options);
 712 }
 713
 714 int
 715 main(int argc, char *argv[])
 716 {
 717     extern struct vlog_module VLM_reconnect;
 718     struct ovsdb_idl *ovnnb_idl, *ovnsb_idl;
 719     unsigned int ovnnb_seqno, ovn_seqno;
 720     int res = EXIT_SUCCESS;
 721     struct northd_context ctx = {
 722         .ovnsb_txn = NULL,
 723     };
 724     bool ovnnb_changes_pending = false;
 725     bool ovn_changes_pending = false;
 726
 727     fatal_ignore_sigpipe();
 728     set_program_name(argv[0]);
 729     vlog_set_levels(NULL, VLF_CONSOLE, VLL_WARN);
 730     vlog_set_levels(&VLM_reconnect, VLF_ANY_DESTINATION, VLL_WARN);
 731     parse_options(argc, argv);
 732
 733     daemonize();
 734
 735     nbrec_init();
 736     sbrec_init();
 737
 738     /* We want to detect all changes to the ovn-nb db. */
 739     ctx.ovnnb_idl = ovnnb_idl = ovsdb_idl_create(ovnnb_db,
 740             &nbrec_idl_class, true, true);
 741
 742     /* There is only a small subset of changes to the ovn-sb db that ovn-northd
 743      * has to care about, so we'll enable monitoring those directly. */
 744     ctx.ovnsb_idl = ovnsb_idl = ovsdb_idl_create(ovnsb_db,
 745             &sbrec_idl_class, false, true);
 746     ovsdb_idl_add_table(ovnsb_idl, &sbrec_table_bindings);
 747     ovsdb_idl_add_column(ovnsb_idl, &sbrec_bindings_col_logical_port);
 748     ovsdb_idl_add_column(ovnsb_idl, &sbrec_bindings_col_chassis);
 749     ovsdb_idl_add_column(ovnsb_idl, &sbrec_bindings_col_mac);
 750     ovsdb_idl_add_column(ovnsb_idl, &sbrec_bindings_col_tag);
 751     ovsdb_idl_add_column(ovnsb_idl, &sbrec_bindings_col_parent_port);
 752     ovsdb_idl_add_column(ovnsb_idl, &sbrec_pipeline_col_logical_datapath);
 753     ovsdb_idl_omit_alert(ovnsb_idl, &sbrec_pipeline_col_logical_datapath);
 754     ovsdb_idl_add_column(ovnsb_idl, &sbrec_pipeline_col_table_id);
 755     ovsdb_idl_omit_alert(ovnsb_idl, &sbrec_pipeline_col_table_id);
 756     ovsdb_idl_add_column(ovnsb_idl, &sbrec_pipeline_col_priority);
 757     ovsdb_idl_omit_alert(ovnsb_idl, &sbrec_pipeline_col_priority);
 758     ovsdb_idl_add_column(ovnsb_idl, &sbrec_pipeline_col_match);
 759     ovsdb_idl_omit_alert(ovnsb_idl, &sbrec_pipeline_col_match);
 760     ovsdb_idl_add_column(ovnsb_idl, &sbrec_pipeline_col_actions);
 761     ovsdb_idl_omit_alert(ovnsb_idl, &sbrec_pipeline_col_actions);
 762
 763     /*
 764      * The loop here just runs the IDL in a loop waiting for the seqno to
 765      * change, which indicates that the contents of the db have changed.
 766      *
 767      * If the contents of the ovn-nb db change, the mappings to the ovn-sb
 768      * db must be recalculated.
 769      *
 770      * If the contents of the ovn-sb db change, it means the 'up' state of
 771      * a port may have changed, as that's the only type of change ovn-northd is
 772      * watching for.
 773      */
 774
 775     ovnnb_seqno = ovsdb_idl_get_seqno(ovnnb_idl);
 776     ovn_seqno = ovsdb_idl_get_seqno(ovnsb_idl);
 777     for (;;) {
 778         ovsdb_idl_run(ovnnb_idl);
 779         ovsdb_idl_run(ovnsb_idl);
 780
 781         if (!ovsdb_idl_is_alive(ovnnb_idl)) {
 782             int retval = ovsdb_idl_get_last_error(ovnnb_idl);
 783             VLOG_ERR("%s: database connection failed (%s)",
 784                     ovnnb_db, ovs_retval_to_string(retval));
 785             res = EXIT_FAILURE;
 786             break;
 787         }
 788
 789         if (!ovsdb_idl_is_alive(ovnsb_idl)) {
 790             int retval = ovsdb_idl_get_last_error(ovnsb_idl);
 791             VLOG_ERR("%s: database connection failed (%s)",
 792                     ovnsb_db, ovs_retval_to_string(retval));
 793             res = EXIT_FAILURE;
 794             break;
 795         }
 796
 797         if (ovnnb_seqno != ovsdb_idl_get_seqno(ovnnb_idl)) {
 798             ovnnb_seqno = ovsdb_idl_get_seqno(ovnnb_idl);
 799             ovnnb_changes_pending = true;
 800         }
 801
 802         if (ovn_seqno != ovsdb_idl_get_seqno(ovnsb_idl)) {
 803             ovn_seqno = ovsdb_idl_get_seqno(ovnsb_idl);
 804             ovn_changes_pending = true;
 805         }
 806
 807         /*
 808          * If there are any pending changes, we delay recalculating the
 809          * necessary updates until after an existing transaction finishes.
 810          * This avoids the possibility of rapid updates causing ovn-northd to
 811          * never be able to successfully make the corresponding updates to the
 812          * other db.  Instead, pending changes are batched up until the next
 813          * time we get a chance to calculate the new state and apply it.
 814          */
 815
 816         if (ovnnb_changes_pending && !ctx.ovnsb_txn) {
 817             /*
 818              * The OVN-nb db contents have changed, so create a transaction for
 819              * updating the OVN-sb DB.
 820              */
 821             ctx.ovnsb_txn = ovsdb_idl_txn_create(ctx.ovnsb_idl);
 822             ovsdb_idl_txn_add_comment(ctx.ovnsb_txn,
 823                                       "ovn-northd: northbound db changed");
 824             ovnnb_db_changed(&ctx);
 825             ovnnb_changes_pending = false;
 826         }
 827
 828         if (ovn_changes_pending && !ctx.ovnnb_txn) {
 829             /*
 830              * The OVN-sb db contents have changed, so create a transaction for
 831              * updating the northbound DB.
 832              */
 833             ctx.ovnnb_txn = ovsdb_idl_txn_create(ctx.ovnnb_idl);
 834             ovsdb_idl_txn_add_comment(ctx.ovnnb_txn,
 835                                       "ovn-northd: southbound db changed");
 836             ovnsb_db_changed(&ctx);
 837             ovn_changes_pending = false;
 838         }
 839
 840         if (ctx.ovnnb_txn) {
 841             enum ovsdb_idl_txn_status txn_status;
 842             txn_status = ovsdb_idl_txn_commit(ctx.ovnnb_txn);
 843             switch (txn_status) {
 844             case TXN_UNCOMMITTED:
 845             case TXN_INCOMPLETE:
 846                 /* Come back around and try to commit this transaction again */
 847                 break;
 848             case TXN_ABORTED:
 849             case TXN_TRY_AGAIN:
 850             case TXN_NOT_LOCKED:
 851             case TXN_ERROR:
 852                 /* Something went wrong, so try creating a new transaction. */
 853                 ovn_changes_pending = true;
 854             case TXN_UNCHANGED:
 855             case TXN_SUCCESS:
 856                 ovsdb_idl_txn_destroy(ctx.ovnnb_txn);
 857                 ctx.ovnnb_txn = NULL;
 858             }
 859         }
 860
 861         if (ctx.ovnsb_txn) {
 862             enum ovsdb_idl_txn_status txn_status;
 863             txn_status = ovsdb_idl_txn_commit(ctx.ovnsb_txn);
 864             switch (txn_status) {
 865             case TXN_UNCOMMITTED:
 866             case TXN_INCOMPLETE:
 867                 /* Come back around and try to commit this transaction again */
 868                 break;
 869             case TXN_ABORTED:
 870             case TXN_TRY_AGAIN:
 871             case TXN_NOT_LOCKED:
 872             case TXN_ERROR:
 873                 /* Something went wrong, so try creating a new transaction. */
 874                 ovnnb_changes_pending = true;
 875             case TXN_UNCHANGED:
 876             case TXN_SUCCESS:
 877                 ovsdb_idl_txn_destroy(ctx.ovnsb_txn);
 878                 ctx.ovnsb_txn = NULL;
 879             }
 880         }
 881
 882         if (ovnnb_seqno == ovsdb_idl_get_seqno(ovnnb_idl) &&
 883                 ovn_seqno == ovsdb_idl_get_seqno(ovnsb_idl)) {
 884             ovsdb_idl_wait(ovnnb_idl);
 885             ovsdb_idl_wait(ovnsb_idl);
 886             if (ctx.ovnnb_txn) {
 887                 ovsdb_idl_txn_wait(ctx.ovnnb_txn);
 888             }
 889             if (ctx.ovnsb_txn) {
 890                 ovsdb_idl_txn_wait(ctx.ovnsb_txn);
 891             }
 892             poll_block();
 893         }
 894     }
 895
 896     ovsdb_idl_destroy(ovnsb_idl);
 897     ovsdb_idl_destroy(ovnnb_idl);
 898
 899     exit(res);
 900 }