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/lib/ovn-nb-idl.h"
  31 #include "ovn/lib/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 continue
 323          * to the next table 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), "next;");
 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, "; next; ");
 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 unknown_actions {
 363         struct hmap_node hmap_node;
 364         const struct nbrec_logical_switch *ls;
 365         struct ds actions;
 366     };
 367     struct hmap unknown_actions = HMAP_INITIALIZER(&unknown_actions);
 368     NBREC_LOGICAL_PORT_FOR_EACH (lport, ctx->ovnnb_idl) {
 369         lswitch = lport->lswitch;
 370         for (size_t i = 0; i < lport->n_macs; i++) {
 371             uint8_t mac[ETH_ADDR_LEN];
 372
 373             if (eth_addr_from_string(lport->macs[i], mac)) {
 374                 struct ds match, actions;
 375
 376                 ds_init(&match);
 377                 ds_put_format(&match, "eth.dst == %s", lport->macs[i]);
 378
 379                 ds_init(&actions);
 380                 ds_put_cstr(&actions, "outport = ");
 381                 json_string_escape(lport->name, &actions);
 382                 ds_put_cstr(&actions, "; next;");
 383                 pipeline_add(&pc, lswitch, 1, 50,
 384                              ds_cstr(&match), ds_cstr(&actions));
 385                 ds_destroy(&actions);
 386                 ds_destroy(&match);
 387             } else if (!strcmp(lport->macs[i], "unknown")) {
 388                 const struct uuid *uuid = &lswitch->header_.uuid;
 389                 struct unknown_actions *ua = NULL;
 390                 struct unknown_actions *iter;
 391                 HMAP_FOR_EACH_WITH_HASH (iter, hmap_node, uuid_hash(uuid),
 392                                          &unknown_actions) {
 393                     if (uuid_equals(&iter->ls->header_.uuid, uuid)) {
 394                         ua = iter;
 395                         break;
 396                     }
 397                 }
 398                 if (!ua) {
 399                     ua = xmalloc(sizeof *ua);
 400                     hmap_insert(&unknown_actions, &ua->hmap_node,
 401                                 uuid_hash(uuid));
 402                     ua->ls = lswitch;
 403                     ds_init(&ua->actions);
 404                 } else {
 405                     ds_put_char(&ua->actions, ' ');
 406                 }
 407
 408                 ds_put_cstr(&ua->actions, "outport = ");
 409                 json_string_escape(lport->name, &ua->actions);
 410                 ds_put_cstr(&ua->actions, "; next;");
 411             } else {
 412                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
 413
 414                 VLOG_INFO_RL(&rl, "%s: invalid syntax '%s' in macs column",
 415                              lport->name, lport->macs[i]);
 416             }
 417         }
 418     }
 419
 420     /* Table 1: Destination lookup for unknown MACs (priority 0). */
 421     struct unknown_actions *ua, *next_ua;
 422     HMAP_FOR_EACH_SAFE (ua, next_ua, hmap_node, &unknown_actions) {
 423         pipeline_add(&pc, ua->ls, 1, 0, "1", ds_cstr(&ua->actions));
 424         hmap_remove(&unknown_actions, &ua->hmap_node);
 425         ds_destroy(&ua->actions);
 426         free(ua);
 427     }
 428     hmap_destroy(&unknown_actions);
 429
 430     /* Table 2: ACLs. */
 431     const struct nbrec_acl *acl;
 432     NBREC_ACL_FOR_EACH (acl, ctx->ovnnb_idl) {
 433         const char *action;
 434
 435         action = (!strcmp(acl->action, "allow") ||
 436                   !strcmp(acl->action, "allow-related"))
 437                       ? "next;" : "drop;";
 438         pipeline_add(&pc, acl->lswitch, 2, acl->priority, acl->match, action);
 439     }
 440     NBREC_LOGICAL_SWITCH_FOR_EACH (lswitch, ctx->ovnnb_idl) {
 441         pipeline_add(&pc, lswitch, 2, 0, "1", "next;");
 442     }
 443
 444     /* Table 3: Egress port security. */
 445     NBREC_LOGICAL_SWITCH_FOR_EACH (lswitch, ctx->ovnnb_idl) {
 446         pipeline_add(&pc, lswitch, 3, 100, "eth.dst[40]", "output;");
 447     }
 448     NBREC_LOGICAL_PORT_FOR_EACH (lport, ctx->ovnnb_idl) {
 449         struct ds match;
 450
 451         ds_init(&match);
 452         ds_put_cstr(&match, "outport == ");
 453         json_string_escape(lport->name, &match);
 454         build_port_security("eth.dst",
 455                             lport->port_security, lport->n_port_security,
 456                             &match);
 457
 458         pipeline_add(&pc, lport->lswitch, 3, 50, ds_cstr(&match), "output;");
 459
 460         ds_destroy(&match);
 461     }
 462
 463     /* Delete any existing Pipeline rows that were not re-generated.  */
 464     struct pipeline_hash_node *hash_node, *next_hash_node;
 465     HMAP_FOR_EACH_SAFE (hash_node, next_hash_node, node, &pc.pipeline_hmap) {
 466         hmap_remove(&pc.pipeline_hmap, &hash_node->node);
 467         sbrec_pipeline_delete(hash_node->pipeline);
 468         free(hash_node);
 469     }
 470     hmap_destroy(&pc.pipeline_hmap);
 471 }
 472 \f
 473 static bool
 474 parents_equal(const struct sbrec_bindings *binding,
 475               const struct nbrec_logical_port *lport)
 476 {
 477     if (!!binding->parent_port != !!lport->parent_name) {
 478         /* One is set and the other is not. */
 479         return false;
 480     }
 481
 482     if (binding->parent_port) {
 483         /* Both are set. */
 484         return strcmp(binding->parent_port, lport->parent_name) ? false : true;
 485     }
 486
 487     /* Both are NULL. */
 488     return true;
 489 }
 490
 491 static bool
 492 tags_equal(const struct sbrec_bindings *binding,
 493            const struct nbrec_logical_port *lport)
 494 {
 495     if (binding->n_tag != lport->n_tag) {
 496         return false;
 497     }
 498
 499     return binding->n_tag ? (binding->tag[0] == lport->tag[0]) : true;
 500 }
 501
 502 /*
 503  * When a change has occurred in the OVN_Northbound database, we go through and
 504  * make sure that the contents of the Bindings table in the OVN_Southbound
 505  * database are up to date with the logical ports defined in the
 506  * OVN_Northbound database.
 507  */
 508 static void
 509 set_bindings(struct northd_context *ctx)
 510 {
 511     struct hmap bindings_hmap;
 512     const struct sbrec_bindings *binding;
 513     const struct nbrec_logical_port *lport;
 514
 515     struct binding_hash_node {
 516         struct hmap_node node;
 517         const struct sbrec_bindings *binding;
 518     } *hash_node, *hash_node_next;
 519
 520     /*
 521      * We will need to look up a binding for every logical port.  We don't want
 522      * to have to do an O(n) search for every binding, so start out by hashing
 523      * them on the logical port.
 524      *
 525      * As we go through every logical port, we will update the binding if it
 526      * exists or create one otherwise.  When the update is done, we'll remove it
 527      * from the hashmap.  At the end, any bindings left in the hashmap are for
 528      * logical ports that have been deleted.
 529      */
 530     hmap_init(&bindings_hmap);
 531
 532     SBREC_BINDINGS_FOR_EACH(binding, ctx->ovnsb_idl) {
 533         hash_node = xzalloc(sizeof *hash_node);
 534         hash_node->binding = binding;
 535         hmap_insert(&bindings_hmap, &hash_node->node,
 536                 hash_string(binding->logical_port, 0));
 537     }
 538
 539     NBREC_LOGICAL_PORT_FOR_EACH(lport, ctx->ovnnb_idl) {
 540         binding = NULL;
 541         HMAP_FOR_EACH_WITH_HASH(hash_node, node,
 542                 hash_string(lport->name, 0), &bindings_hmap) {
 543             if (!strcmp(lport->name, hash_node->binding->logical_port)) {
 544                 binding = hash_node->binding;
 545                 break;
 546             }
 547         }
 548
 549         if (binding) {
 550             /* We found an existing binding for this logical port.  Update its
 551              * contents. */
 552
 553             hmap_remove(&bindings_hmap, &hash_node->node);
 554             free(hash_node);
 555             hash_node = NULL;
 556
 557             if (!macs_equal(binding->mac, binding->n_mac,
 558                         lport->macs, lport->n_macs)) {
 559                 sbrec_bindings_set_mac(binding,
 560                         (const char **) lport->macs, lport->n_macs);
 561             }
 562             if (!parents_equal(binding, lport)) {
 563                 sbrec_bindings_set_parent_port(binding, lport->parent_name);
 564             }
 565             if (!tags_equal(binding, lport)) {
 566                 sbrec_bindings_set_tag(binding, lport->tag, lport->n_tag);
 567             }
 568         } else {
 569             /* There is no binding for this logical port, so create one. */
 570
 571             binding = sbrec_bindings_insert(ctx->ovnsb_txn);
 572             sbrec_bindings_set_logical_port(binding, lport->name);
 573             sbrec_bindings_set_mac(binding,
 574                     (const char **) lport->macs, lport->n_macs);
 575             if (lport->parent_name && lport->n_tag > 0) {
 576                 sbrec_bindings_set_parent_port(binding, lport->parent_name);
 577                 sbrec_bindings_set_tag(binding, lport->tag, lport->n_tag);
 578             }
 579         }
 580     }
 581
 582     HMAP_FOR_EACH_SAFE(hash_node, hash_node_next, node, &bindings_hmap) {
 583         hmap_remove(&bindings_hmap, &hash_node->node);
 584         sbrec_bindings_delete(hash_node->binding);
 585         free(hash_node);
 586     }
 587     hmap_destroy(&bindings_hmap);
 588 }
 589
 590 static void
 591 ovnnb_db_changed(struct northd_context *ctx)
 592 {
 593     VLOG_DBG("ovn-nb db contents have changed.");
 594
 595     set_bindings(ctx);
 596     build_pipeline(ctx);
 597 }
 598
 599 /*
 600  * The only change we get notified about is if the 'chassis' column of the
 601  * 'Bindings' table changes.  When this column is not empty, it means we need to
 602  * set the corresponding logical port as 'up' in the northbound DB.
 603  */
 604 static void
 605 ovnsb_db_changed(struct northd_context *ctx)
 606 {
 607     struct hmap lports_hmap;
 608     const struct sbrec_bindings *binding;
 609     const struct nbrec_logical_port *lport;
 610
 611     struct lport_hash_node {
 612         struct hmap_node node;
 613         const struct nbrec_logical_port *lport;
 614     } *hash_node, *hash_node_next;
 615
 616     VLOG_DBG("Recalculating port up states for ovn-nb db.");
 617
 618     hmap_init(&lports_hmap);
 619
 620     NBREC_LOGICAL_PORT_FOR_EACH(lport, ctx->ovnnb_idl) {
 621         hash_node = xzalloc(sizeof *hash_node);
 622         hash_node->lport = lport;
 623         hmap_insert(&lports_hmap, &hash_node->node,
 624                 hash_string(lport->name, 0));
 625     }
 626
 627     SBREC_BINDINGS_FOR_EACH(binding, ctx->ovnsb_idl) {
 628         lport = NULL;
 629         HMAP_FOR_EACH_WITH_HASH(hash_node, node,
 630                 hash_string(binding->logical_port, 0), &lports_hmap) {
 631             if (!strcmp(binding->logical_port, hash_node->lport->name)) {
 632                 lport = hash_node->lport;
 633                 break;
 634             }
 635         }
 636
 637         if (!lport) {
 638             /* The logical port doesn't exist for this binding.  This can
 639              * happen under normal circumstances when ovn-northd hasn't gotten
 640              * around to pruning the Binding yet. */
 641             continue;
 642         }
 643
 644         if (*binding->chassis && (!lport->up || !*lport->up)) {
 645             bool up = true;
 646             nbrec_logical_port_set_up(lport, &up, 1);
 647         } else if (!*binding->chassis && (!lport->up || *lport->up)) {
 648             bool up = false;
 649             nbrec_logical_port_set_up(lport, &up, 1);
 650         }
 651     }
 652
 653     HMAP_FOR_EACH_SAFE(hash_node, hash_node_next, node, &lports_hmap) {
 654         hmap_remove(&lports_hmap, &hash_node->node);
 655         free(hash_node);
 656     }
 657     hmap_destroy(&lports_hmap);
 658 }
 659 \f
 660 static const char *
 661 default_db(void)
 662 {
 663     static char *def;
 664     if (!def) {
 665         def = xasprintf("unix:%s/db.sock", ovs_rundir());
 666     }
 667     return def;
 668 }
 669
 670 static void
 671 parse_options(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 672 {
 673     enum {
 674         DAEMON_OPTION_ENUMS,
 675         VLOG_OPTION_ENUMS,
 676     };
 677     static const struct option long_options[] = {
 678         {"ovnsb-db", required_argument, NULL, 'd'},
 679         {"ovnnb-db", required_argument, NULL, 'D'},
 680         {"help", no_argument, NULL, 'h'},
 681         {"options", no_argument, NULL, 'o'},
 682         {"version", no_argument, NULL, 'V'},
 683         DAEMON_LONG_OPTIONS,
 684         VLOG_LONG_OPTIONS,
 685         STREAM_SSL_LONG_OPTIONS,
 686         {NULL, 0, NULL, 0},
 687     };
 688     char *short_options = ovs_cmdl_long_options_to_short_options(long_options);
 689
 690     for (;;) {
 691         int c;
 692
 693         c = getopt_long(argc, argv, short_options, long_options, NULL);
 694         if (c == -1) {
 695             break;
 696         }
 697
 698         switch (c) {
 699         DAEMON_OPTION_HANDLERS;
 700         VLOG_OPTION_HANDLERS;
 701         STREAM_SSL_OPTION_HANDLERS;
 702
 703         case 'd':
 704             ovnsb_db = optarg;
 705             break;
 706
 707         case 'D':
 708             ovnnb_db = optarg;
 709             break;
 710
 711         case 'h':
 712             usage();
 713             exit(EXIT_SUCCESS);
 714
 715         case 'o':
 716             ovs_cmdl_print_options(long_options);
 717             exit(EXIT_SUCCESS);
 718
 719         case 'V':
 720             ovs_print_version(0, 0);
 721             exit(EXIT_SUCCESS);
 722
 723         default:
 724             break;
 725         }
 726     }
 727
 728     if (!ovnsb_db) {
 729         ovnsb_db = default_db();
 730     }
 731
 732     if (!ovnnb_db) {
 733         ovnnb_db = default_db();
 734     }
 735
 736     free(short_options);
 737 }
 738
 739 int
 740 main(int argc, char *argv[])
 741 {
 742     extern struct vlog_module VLM_reconnect;
 743     struct ovsdb_idl *ovnnb_idl, *ovnsb_idl;
 744     unsigned int ovnnb_seqno, ovn_seqno;
 745     int res = EXIT_SUCCESS;
 746     struct northd_context ctx = {
 747         .ovnsb_txn = NULL,
 748     };
 749     bool ovnnb_changes_pending = false;
 750     bool ovn_changes_pending = false;
 751
 752     fatal_ignore_sigpipe();
 753     set_program_name(argv[0]);
 754     vlog_set_levels(NULL, VLF_CONSOLE, VLL_WARN);
 755     vlog_set_levels(&VLM_reconnect, VLF_ANY_DESTINATION, VLL_WARN);
 756     parse_options(argc, argv);
 757
 758     daemonize();
 759
 760     nbrec_init();
 761     sbrec_init();
 762
 763     /* We want to detect all changes to the ovn-nb db. */
 764     ctx.ovnnb_idl = ovnnb_idl = ovsdb_idl_create(ovnnb_db,
 765             &nbrec_idl_class, true, true);
 766
 767     /* There is only a small subset of changes to the ovn-sb db that ovn-northd
 768      * has to care about, so we'll enable monitoring those directly. */
 769     ctx.ovnsb_idl = ovnsb_idl = ovsdb_idl_create(ovnsb_db,
 770             &sbrec_idl_class, false, true);
 771     ovsdb_idl_add_table(ovnsb_idl, &sbrec_table_bindings);
 772     ovsdb_idl_add_column(ovnsb_idl, &sbrec_bindings_col_logical_port);
 773     ovsdb_idl_add_column(ovnsb_idl, &sbrec_bindings_col_chassis);
 774     ovsdb_idl_add_column(ovnsb_idl, &sbrec_bindings_col_mac);
 775     ovsdb_idl_add_column(ovnsb_idl, &sbrec_bindings_col_tag);
 776     ovsdb_idl_add_column(ovnsb_idl, &sbrec_bindings_col_parent_port);
 777     ovsdb_idl_add_column(ovnsb_idl, &sbrec_pipeline_col_logical_datapath);
 778     ovsdb_idl_omit_alert(ovnsb_idl, &sbrec_pipeline_col_logical_datapath);
 779     ovsdb_idl_add_column(ovnsb_idl, &sbrec_pipeline_col_table_id);
 780     ovsdb_idl_omit_alert(ovnsb_idl, &sbrec_pipeline_col_table_id);
 781     ovsdb_idl_add_column(ovnsb_idl, &sbrec_pipeline_col_priority);
 782     ovsdb_idl_omit_alert(ovnsb_idl, &sbrec_pipeline_col_priority);
 783     ovsdb_idl_add_column(ovnsb_idl, &sbrec_pipeline_col_match);
 784     ovsdb_idl_omit_alert(ovnsb_idl, &sbrec_pipeline_col_match);
 785     ovsdb_idl_add_column(ovnsb_idl, &sbrec_pipeline_col_actions);
 786     ovsdb_idl_omit_alert(ovnsb_idl, &sbrec_pipeline_col_actions);
 787
 788     /*
 789      * The loop here just runs the IDL in a loop waiting for the seqno to
 790      * change, which indicates that the contents of the db have changed.
 791      *
 792      * If the contents of the ovn-nb db change, the mappings to the ovn-sb
 793      * db must be recalculated.
 794      *
 795      * If the contents of the ovn-sb db change, it means the 'up' state of
 796      * a port may have changed, as that's the only type of change ovn-northd is
 797      * watching for.
 798      */
 799
 800     ovnnb_seqno = ovsdb_idl_get_seqno(ovnnb_idl);
 801     ovn_seqno = ovsdb_idl_get_seqno(ovnsb_idl);
 802     for (;;) {
 803         ovsdb_idl_run(ovnnb_idl);
 804         ovsdb_idl_run(ovnsb_idl);
 805
 806         if (!ovsdb_idl_is_alive(ovnnb_idl)) {
 807             int retval = ovsdb_idl_get_last_error(ovnnb_idl);
 808             VLOG_ERR("%s: database connection failed (%s)",
 809                     ovnnb_db, ovs_retval_to_string(retval));
 810             res = EXIT_FAILURE;
 811             break;
 812         }
 813
 814         if (!ovsdb_idl_is_alive(ovnsb_idl)) {
 815             int retval = ovsdb_idl_get_last_error(ovnsb_idl);
 816             VLOG_ERR("%s: database connection failed (%s)",
 817                     ovnsb_db, ovs_retval_to_string(retval));
 818             res = EXIT_FAILURE;
 819             break;
 820         }
 821
 822         if (ovnnb_seqno != ovsdb_idl_get_seqno(ovnnb_idl)) {
 823             ovnnb_seqno = ovsdb_idl_get_seqno(ovnnb_idl);
 824             ovnnb_changes_pending = true;
 825         }
 826
 827         if (ovn_seqno != ovsdb_idl_get_seqno(ovnsb_idl)) {
 828             ovn_seqno = ovsdb_idl_get_seqno(ovnsb_idl);
 829             ovn_changes_pending = true;
 830         }
 831
 832         /*
 833          * If there are any pending changes, we delay recalculating the
 834          * necessary updates until after an existing transaction finishes.
 835          * This avoids the possibility of rapid updates causing ovn-northd to
 836          * never be able to successfully make the corresponding updates to the
 837          * other db.  Instead, pending changes are batched up until the next
 838          * time we get a chance to calculate the new state and apply it.
 839          */
 840
 841         if (ovnnb_changes_pending && !ctx.ovnsb_txn) {
 842             /*
 843              * The OVN-nb db contents have changed, so create a transaction for
 844              * updating the OVN-sb DB.
 845              */
 846             ctx.ovnsb_txn = ovsdb_idl_txn_create(ctx.ovnsb_idl);
 847             ovsdb_idl_txn_add_comment(ctx.ovnsb_txn,
 848                                       "ovn-northd: northbound db changed");
 849             ovnnb_db_changed(&ctx);
 850             ovnnb_changes_pending = false;
 851         }
 852
 853         if (ovn_changes_pending && !ctx.ovnnb_txn) {
 854             /*
 855              * The OVN-sb db contents have changed, so create a transaction for
 856              * updating the northbound DB.
 857              */
 858             ctx.ovnnb_txn = ovsdb_idl_txn_create(ctx.ovnnb_idl);
 859             ovsdb_idl_txn_add_comment(ctx.ovnnb_txn,
 860                                       "ovn-northd: southbound db changed");
 861             ovnsb_db_changed(&ctx);
 862             ovn_changes_pending = false;
 863         }
 864
 865         if (ctx.ovnnb_txn) {
 866             enum ovsdb_idl_txn_status txn_status;
 867             txn_status = ovsdb_idl_txn_commit(ctx.ovnnb_txn);
 868             switch (txn_status) {
 869             case TXN_UNCOMMITTED:
 870             case TXN_INCOMPLETE:
 871                 /* Come back around and try to commit this transaction again */
 872                 break;
 873             case TXN_ABORTED:
 874             case TXN_TRY_AGAIN:
 875             case TXN_NOT_LOCKED:
 876             case TXN_ERROR:
 877                 /* Something went wrong, so try creating a new transaction. */
 878                 ovn_changes_pending = true;
 879             case TXN_UNCHANGED:
 880             case TXN_SUCCESS:
 881                 ovsdb_idl_txn_destroy(ctx.ovnnb_txn);
 882                 ctx.ovnnb_txn = NULL;
 883             }
 884         }
 885
 886         if (ctx.ovnsb_txn) {
 887             enum ovsdb_idl_txn_status txn_status;
 888             txn_status = ovsdb_idl_txn_commit(ctx.ovnsb_txn);
 889             switch (txn_status) {
 890             case TXN_UNCOMMITTED:
 891             case TXN_INCOMPLETE:
 892                 /* Come back around and try to commit this transaction again */
 893                 break;
 894             case TXN_ABORTED:
 895             case TXN_TRY_AGAIN:
 896             case TXN_NOT_LOCKED:
 897             case TXN_ERROR:
 898                 /* Something went wrong, so try creating a new transaction. */
 899                 ovnnb_changes_pending = true;
 900             case TXN_UNCHANGED:
 901             case TXN_SUCCESS:
 902                 ovsdb_idl_txn_destroy(ctx.ovnsb_txn);
 903                 ctx.ovnsb_txn = NULL;
 904             }
 905         }
 906
 907         if (ovnnb_seqno == ovsdb_idl_get_seqno(ovnnb_idl) &&
 908                 ovn_seqno == ovsdb_idl_get_seqno(ovnsb_idl)) {
 909             ovsdb_idl_wait(ovnnb_idl);
 910             ovsdb_idl_wait(ovnsb_idl);
 911             if (ctx.ovnnb_txn) {
 912                 ovsdb_idl_txn_wait(ctx.ovnnb_txn);
 913             }
 914             if (ctx.ovnsb_txn) {
 915                 ovsdb_idl_txn_wait(ctx.ovnsb_txn);
 916             }
 917             poll_block();
 918         }
 919     }
 920
 921     ovsdb_idl_destroy(ovnsb_idl);
 922     ovsdb_idl_destroy(ovnnb_idl);
 923
 924     exit(res);
 925 }