ovsdb/monitor.c

   1 /*
   2  * Copyright (c) 2015 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18
  19 #include <errno.h>
  20
  21 #include "bitmap.h"
  22 #include "column.h"
  23 #include "dynamic-string.h"
  24 #include "json.h"
  25 #include "jsonrpc.h"
  26 #include "ovsdb-error.h"
  27 #include "ovsdb-parser.h"
  28 #include "ovsdb.h"
  29 #include "row.h"
  30 #include "simap.h"
  31 #include "hash.h"
  32 #include "table.h"
  33 #include "hash.h"
  34 #include "timeval.h"
  35 #include "transaction.h"
  36 #include "jsonrpc-server.h"
  37 #include "monitor.h"
  38 #include "openvswitch/vlog.h"
  39
  40
  41 static const struct ovsdb_replica_class ovsdb_jsonrpc_replica_class;
  42 static struct hmap ovsdb_monitors = HMAP_INITIALIZER(&ovsdb_monitors);
  43
  44 /*  Backend monitor.
  45  *
  46  *  ovsdb_monitor keep track of the ovsdb changes.
  47  */
  48
  49 /* A collection of tables being monitored. */
  50 struct ovsdb_monitor {
  51     struct ovsdb_replica replica;
  52     struct shash tables;     /* Holds "struct ovsdb_monitor_table"s. */
  53     struct ovs_list jsonrpc_monitors;  /* Contains "jsonrpc_monitor_node"s. */
  54     struct ovsdb *db;
  55     uint64_t n_transactions;      /* Count number of committed transactions. */
  56     struct hmap_node hmap_node;   /* Elements within ovsdb_monitors.  */
  57     struct hmap json_cache;       /* Contains "ovsdb_monitor_json_cache_node"s.*/
  58 };
  59
  60 /* A json object of updates between 'from_txn' and 'dbmon->n_transactions'
  61  * inclusive.  */
  62 struct ovsdb_monitor_json_cache_node {
  63     struct hmap_node hmap_node;   /* Elements in json cache. */
  64     uint64_t from_txn;
  65     struct json *json;            /* Null, or a cloned of json */
  66 };
  67
  68 struct jsonrpc_monitor_node {
  69     struct ovsdb_jsonrpc_monitor *jsonrpc_monitor;
  70     struct ovs_list node;
  71 };
  72
  73 /* A particular column being monitored. */
  74 struct ovsdb_monitor_column {
  75     const struct ovsdb_column *column;
  76     enum ovsdb_monitor_selection select;
  77 };
  78
  79 /* A row that has changed in a monitored table. */
  80 struct ovsdb_monitor_row {
  81     struct hmap_node hmap_node; /* In ovsdb_jsonrpc_monitor_table.changes. */
  82     struct uuid uuid;           /* UUID of row that changed. */
  83     struct ovsdb_datum *old;    /* Old data, NULL for an inserted row. */
  84     struct ovsdb_datum *new;    /* New data, NULL for a deleted row. */
  85 };
  86
  87 /* Contains 'struct ovsdb_monitor_row's for rows that have been
  88  * updated but not yet flushed to all the jsonrpc connection.
  89  *
  90  * 'n_refs' represent the number of jsonrpc connections that have
  91  * not received updates. Generate the update for the last jsonprc
  92  * connection will also destroy the whole "struct ovsdb_monitor_changes"
  93  * object.
  94  *
  95  * 'transaction' stores the first update's transaction id.
  96  * */
  97 struct ovsdb_monitor_changes {
  98     struct ovsdb_monitor_table *mt;
  99     struct hmap rows;
 100     int n_refs;
 101     uint64_t transaction;
 102     struct hmap_node hmap_node;  /* Element in ovsdb_monitor_tables' changes
 103                                     hmap.  */
 104 };
 105
 106 /* A particular table being monitored. */
 107 struct ovsdb_monitor_table {
 108     const struct ovsdb_table *table;
 109
 110     /* This is the union (bitwise-OR) of the 'select' values in all of the
 111      * members of 'columns' below. */
 112     enum ovsdb_monitor_selection select;
 113
 114     /* Columns being monitored. */
 115     struct ovsdb_monitor_column *columns;
 116     size_t n_columns;
 117
 118     /* Contains 'ovsdb_monitor_changes' indexed by 'transaction'. */
 119     struct hmap changes;
 120 };
 121
 122 static void ovsdb_monitor_destroy(struct ovsdb_monitor *dbmon);
 123 static struct ovsdb_monitor_changes * ovsdb_monitor_table_add_changes(
 124     struct ovsdb_monitor_table *mt, uint64_t next_txn);
 125 static struct ovsdb_monitor_changes *ovsdb_monitor_table_find_changes(
 126     struct ovsdb_monitor_table *mt, uint64_t unflushed);
 127 static void ovsdb_monitor_changes_destroy(
 128                                   struct ovsdb_monitor_changes *changes);
 129 static void ovsdb_monitor_table_track_changes(struct ovsdb_monitor_table *mt,
 130                                   uint64_t unflushed);
 131
 132 static struct ovsdb_monitor_json_cache_node *
 133 ovsdb_monitor_json_cache_search(const struct ovsdb_monitor *dbmon,
 134                                 uint64_t from_txn)
 135 {
 136     struct ovsdb_monitor_json_cache_node *node;
 137     uint32_t hash = hash_uint64(from_txn);
 138
 139     HMAP_FOR_EACH_WITH_HASH(node, hmap_node, hash, &dbmon->json_cache) {
 140         if (node->from_txn == from_txn) {
 141             return node;
 142         }
 143     }
 144
 145     return NULL;
 146 }
 147
 148 static void
 149 ovsdb_monitor_json_cache_insert(struct ovsdb_monitor *dbmon,
 150                                 uint64_t from_txn, struct json *json)
 151 {
 152     struct ovsdb_monitor_json_cache_node *node;
 153     uint32_t hash;
 154
 155     node = xmalloc(sizeof *node);
 156
 157     hash = hash_uint64(from_txn);
 158     node->from_txn = from_txn;
 159     node->json = json ? json_clone(json) : NULL;
 160
 161     hmap_insert(&dbmon->json_cache, &node->hmap_node, hash);
 162 }
 163
 164 static void
 165 ovsdb_monitor_json_cache_flush(struct ovsdb_monitor *dbmon)
 166 {
 167     struct ovsdb_monitor_json_cache_node *node, *next;
 168
 169     HMAP_FOR_EACH_SAFE(node, next, hmap_node, &dbmon->json_cache) {
 170         hmap_remove(&dbmon->json_cache, &node->hmap_node);
 171         json_destroy(node->json);
 172         free(node);
 173     }
 174 }
 175
 176 static int
 177 compare_ovsdb_monitor_column(const void *a_, const void *b_)
 178 {
 179     const struct ovsdb_monitor_column *a = a_;
 180     const struct ovsdb_monitor_column *b = b_;
 181
 182     return a->column < b->column ? -1 : a->column > b->column;
 183 }
 184
 185 static struct ovsdb_monitor *
 186 ovsdb_monitor_cast(struct ovsdb_replica *replica)
 187 {
 188     ovs_assert(replica->class == &ovsdb_jsonrpc_replica_class);
 189     return CONTAINER_OF(replica, struct ovsdb_monitor, replica);
 190 }
 191
 192 /* Finds and returns the ovsdb_monitor_row in 'mt->changes->rows' for the
 193  * given 'uuid', or NULL if there is no such row. */
 194 static struct ovsdb_monitor_row *
 195 ovsdb_monitor_changes_row_find(const struct ovsdb_monitor_changes *changes,
 196                                const struct uuid *uuid)
 197 {
 198     struct ovsdb_monitor_row *row;
 199
 200     HMAP_FOR_EACH_WITH_HASH (row, hmap_node, uuid_hash(uuid),
 201                              &changes->rows) {
 202         if (uuid_equals(uuid, &row->uuid)) {
 203             return row;
 204         }
 205     }
 206     return NULL;
 207 }
 208
 209 /* Allocates an array of 'mt->n_columns' ovsdb_datums and initializes them as
 210  * copies of the data in 'row' drawn from the columns represented by
 211  * mt->columns[].  Returns the array.
 212  *
 213  * If 'row' is NULL, returns NULL. */
 214 static struct ovsdb_datum *
 215 clone_monitor_row_data(const struct ovsdb_monitor_table *mt,
 216                        const struct ovsdb_row *row)
 217 {
 218     struct ovsdb_datum *data;
 219     size_t i;
 220
 221     if (!row) {
 222         return NULL;
 223     }
 224
 225     data = xmalloc(mt->n_columns * sizeof *data);
 226     for (i = 0; i < mt->n_columns; i++) {
 227         const struct ovsdb_column *c = mt->columns[i].column;
 228         const struct ovsdb_datum *src = &row->fields[c->index];
 229         struct ovsdb_datum *dst = &data[i];
 230         const struct ovsdb_type *type = &c->type;
 231
 232         ovsdb_datum_clone(dst, src, type);
 233     }
 234     return data;
 235 }
 236
 237 /* Replaces the mt->n_columns ovsdb_datums in row[] by copies of the data from
 238  * in 'row' drawn from the columns represented by mt->columns[]. */
 239 static void
 240 update_monitor_row_data(const struct ovsdb_monitor_table *mt,
 241                         const struct ovsdb_row *row,
 242                         struct ovsdb_datum *data)
 243 {
 244     size_t i;
 245
 246     for (i = 0; i < mt->n_columns; i++) {
 247         const struct ovsdb_column *c = mt->columns[i].column;
 248         const struct ovsdb_datum *src = &row->fields[c->index];
 249         struct ovsdb_datum *dst = &data[i];
 250         const struct ovsdb_type *type = &c->type;
 251
 252         if (!ovsdb_datum_equals(src, dst, type)) {
 253             ovsdb_datum_destroy(dst, type);
 254             ovsdb_datum_clone(dst, src, type);
 255         }
 256     }
 257 }
 258
 259 /* Frees all of the mt->n_columns ovsdb_datums in data[], using the types taken
 260  * from mt->columns[], plus 'data' itself. */
 261 static void
 262 free_monitor_row_data(const struct ovsdb_monitor_table *mt,
 263                       struct ovsdb_datum *data)
 264 {
 265     if (data) {
 266         size_t i;
 267
 268         for (i = 0; i < mt->n_columns; i++) {
 269             const struct ovsdb_column *c = mt->columns[i].column;
 270
 271             ovsdb_datum_destroy(&data[i], &c->type);
 272         }
 273         free(data);
 274     }
 275 }
 276
 277 /* Frees 'row', which must have been created from 'mt'. */
 278 static void
 279 ovsdb_monitor_row_destroy(const struct ovsdb_monitor_table *mt,
 280                           struct ovsdb_monitor_row *row)
 281 {
 282     if (row) {
 283         free_monitor_row_data(mt, row->old);
 284         free_monitor_row_data(mt, row->new);
 285         free(row);
 286     }
 287 }
 288
 289 void
 290 ovsdb_monitor_add_jsonrpc_monitor(struct ovsdb_monitor *dbmon,
 291                                   struct ovsdb_jsonrpc_monitor *jsonrpc_monitor)
 292 {
 293     struct jsonrpc_monitor_node *jm;
 294
 295     jm = xzalloc(sizeof *jm);
 296     jm->jsonrpc_monitor = jsonrpc_monitor;
 297     list_push_back(&dbmon->jsonrpc_monitors, &jm->node);
 298 }
 299
 300 struct ovsdb_monitor *
 301 ovsdb_monitor_create(struct ovsdb *db,
 302                      struct ovsdb_jsonrpc_monitor *jsonrpc_monitor)
 303 {
 304     struct ovsdb_monitor *dbmon;
 305
 306     dbmon = xzalloc(sizeof *dbmon);
 307
 308     ovsdb_replica_init(&dbmon->replica, &ovsdb_jsonrpc_replica_class);
 309     ovsdb_add_replica(db, &dbmon->replica);
 310     list_init(&dbmon->jsonrpc_monitors);
 311     dbmon->db = db;
 312     dbmon->n_transactions = 0;
 313     shash_init(&dbmon->tables);
 314     hmap_node_nullify(&dbmon->hmap_node);
 315     hmap_init(&dbmon->json_cache);
 316
 317     ovsdb_monitor_add_jsonrpc_monitor(dbmon, jsonrpc_monitor);
 318     return dbmon;
 319 }
 320
 321 void
 322 ovsdb_monitor_add_table(struct ovsdb_monitor *m,
 323                         const struct ovsdb_table *table)
 324 {
 325     struct ovsdb_monitor_table *mt;
 326
 327     mt = xzalloc(sizeof *mt);
 328     mt->table = table;
 329     shash_add(&m->tables, table->schema->name, mt);
 330     hmap_init(&mt->changes);
 331 }
 332
 333 void
 334 ovsdb_monitor_add_column(struct ovsdb_monitor *dbmon,
 335                          const struct ovsdb_table *table,
 336                          const struct ovsdb_column *column,
 337                          enum ovsdb_monitor_selection select,
 338                          size_t *allocated_columns)
 339 {
 340     struct ovsdb_monitor_table *mt;
 341     struct ovsdb_monitor_column *c;
 342
 343     mt = shash_find_data(&dbmon->tables, table->schema->name);
 344
 345     if (mt->n_columns >= *allocated_columns) {
 346         mt->columns = x2nrealloc(mt->columns, allocated_columns,
 347                                  sizeof *mt->columns);
 348     }
 349
 350     mt->select |= select;
 351     c = &mt->columns[mt->n_columns++];
 352     c->column = column;
 353     c->select = select;
 354 }
 355
 356 /* Check for duplicated column names. Return the first
 357  * duplicated column's name if found. Otherwise return
 358  * NULL.  */
 359 const char * OVS_WARN_UNUSED_RESULT
 360 ovsdb_monitor_table_check_duplicates(struct ovsdb_monitor *m,
 361                                      const struct ovsdb_table *table)
 362 {
 363     struct ovsdb_monitor_table *mt;
 364     int i;
 365
 366     mt = shash_find_data(&m->tables, table->schema->name);
 367
 368     if (mt) {
 369         /* Check for duplicate columns. */
 370         qsort(mt->columns, mt->n_columns, sizeof *mt->columns,
 371               compare_ovsdb_monitor_column);
 372         for (i = 1; i < mt->n_columns; i++) {
 373             if (mt->columns[i].column == mt->columns[i - 1].column) {
 374                 return mt->columns[i].column->name;
 375             }
 376         }
 377     }
 378
 379     return NULL;
 380 }
 381
 382 static struct ovsdb_monitor_changes *
 383 ovsdb_monitor_table_add_changes(struct ovsdb_monitor_table *mt,
 384                                 uint64_t next_txn)
 385 {
 386     struct ovsdb_monitor_changes *changes;
 387
 388     changes = xzalloc(sizeof *changes);
 389
 390     changes->transaction = next_txn;
 391     changes->mt = mt;
 392     changes->n_refs = 1;
 393     hmap_init(&changes->rows);
 394     hmap_insert(&mt->changes, &changes->hmap_node, hash_uint64(next_txn));
 395
 396     return changes;
 397 };
 398
 399 static struct ovsdb_monitor_changes *
 400 ovsdb_monitor_table_find_changes(struct ovsdb_monitor_table *mt,
 401                                  uint64_t transaction)
 402 {
 403     struct ovsdb_monitor_changes *changes;
 404     size_t hash = hash_uint64(transaction);
 405
 406     HMAP_FOR_EACH_WITH_HASH(changes, hmap_node, hash, &mt->changes) {
 407         if (changes->transaction == transaction) {
 408             return changes;
 409         }
 410     }
 411
 412     return NULL;
 413 }
 414
 415 /* Stop currently tracking changes to table 'mt' since 'transaction'. */
 416 static void
 417 ovsdb_monitor_table_untrack_changes(struct ovsdb_monitor_table *mt,
 418                                     uint64_t transaction)
 419 {
 420     struct ovsdb_monitor_changes *changes =
 421                 ovsdb_monitor_table_find_changes(mt, transaction);
 422     if (changes) {
 423         if (--changes->n_refs == 0) {
 424             hmap_remove(&mt->changes, &changes->hmap_node);
 425             ovsdb_monitor_changes_destroy(changes);
 426         }
 427     }
 428 }
 429
 430 /* Start tracking changes to table 'mt' begins from 'transaction' inclusive.
 431  */
 432 static void
 433 ovsdb_monitor_table_track_changes(struct ovsdb_monitor_table *mt,
 434                                   uint64_t transaction)
 435 {
 436     struct ovsdb_monitor_changes *changes;
 437
 438     changes = ovsdb_monitor_table_find_changes(mt, transaction);
 439     if (changes) {
 440         changes->n_refs++;
 441     } else {
 442         ovsdb_monitor_table_add_changes(mt, transaction);
 443     }
 444 }
 445
 446 static void
 447 ovsdb_monitor_changes_destroy(struct ovsdb_monitor_changes *changes)
 448 {
 449     struct ovsdb_monitor_row *row, *next;
 450
 451     HMAP_FOR_EACH_SAFE (row, next, hmap_node, &changes->rows) {
 452         hmap_remove(&changes->rows, &row->hmap_node);
 453         ovsdb_monitor_row_destroy(changes->mt, row);
 454     }
 455     hmap_destroy(&changes->rows);
 456     free(changes);
 457 }
 458
 459 static enum ovsdb_monitor_selection
 460 ovsdb_monitor_row_update_type(bool initial, const bool old, const bool new)
 461 {
 462     return initial ? OJMS_INITIAL
 463             : !old ? OJMS_INSERT
 464             : !new ? OJMS_DELETE
 465             : OJMS_MODIFY;
 466 }
 467
 468 /* Returns JSON for a <row-update> (as described in RFC 7047) for 'row' within
 469  * 'mt', or NULL if no row update should be sent.
 470  *
 471  * The caller should specify 'initial' as true if the returned JSON is going to
 472  * be used as part of the initial reply to a "monitor" request, false if it is
 473  * going to be used as part of an "update" notification.
 474  *
 475  * 'changed' must be a scratch buffer for internal use that is at least
 476  * bitmap_n_bytes(mt->n_columns) bytes long. */
 477 static struct json *
 478 ovsdb_monitor_compose_row_update(
 479     const struct ovsdb_monitor_table *mt,
 480     const struct ovsdb_monitor_row *row,
 481     bool initial, unsigned long int *changed)
 482 {
 483     enum ovsdb_monitor_selection type;
 484     struct json *old_json, *new_json;
 485     struct json *row_json;
 486     size_t i;
 487
 488     type = ovsdb_monitor_row_update_type(initial, row->old, row->new);
 489     if (!(mt->select & type)) {
 490         return NULL;
 491     }
 492
 493     if (type == OJMS_MODIFY) {
 494         size_t n_changes;
 495
 496         n_changes = 0;
 497         memset(changed, 0, bitmap_n_bytes(mt->n_columns));
 498         for (i = 0; i < mt->n_columns; i++) {
 499             const struct ovsdb_column *c = mt->columns[i].column;
 500             if (!ovsdb_datum_equals(&row->old[i], &row->new[i], &c->type)) {
 501                 bitmap_set1(changed, i);
 502                 n_changes++;
 503             }
 504         }
 505         if (!n_changes) {
 506             /* No actual changes: presumably a row changed and then
 507              * changed back later. */
 508             return NULL;
 509         }
 510     }
 511
 512     row_json = json_object_create();
 513     old_json = new_json = NULL;
 514     if (type & (OJMS_DELETE | OJMS_MODIFY)) {
 515         old_json = json_object_create();
 516         json_object_put(row_json, "old", old_json);
 517     }
 518     if (type & (OJMS_INITIAL | OJMS_INSERT | OJMS_MODIFY)) {
 519         new_json = json_object_create();
 520         json_object_put(row_json, "new", new_json);
 521     }
 522     for (i = 0; i < mt->n_columns; i++) {
 523         const struct ovsdb_monitor_column *c = &mt->columns[i];
 524
 525         if (!(type & c->select)) {
 526             /* We don't care about this type of change for this
 527              * particular column (but we will care about it for some
 528              * other column). */
 529             continue;
 530         }
 531
 532         if ((type == OJMS_MODIFY && bitmap_is_set(changed, i))
 533             || type == OJMS_DELETE) {
 534             json_object_put(old_json, c->column->name,
 535                             ovsdb_datum_to_json(&row->old[i],
 536                                                 &c->column->type));
 537         }
 538         if (type & (OJMS_INITIAL | OJMS_INSERT | OJMS_MODIFY)) {
 539             json_object_put(new_json, c->column->name,
 540                             ovsdb_datum_to_json(&row->new[i],
 541                                                 &c->column->type));
 542         }
 543     }
 544
 545     return row_json;
 546 }
 547
 548 static size_t
 549 ovsdb_monitor_max_columns(struct ovsdb_monitor *dbmon)
 550 {
 551     struct shash_node *node;
 552     size_t max_columns = 0;
 553
 554     SHASH_FOR_EACH (node, &dbmon->tables) {
 555         struct ovsdb_monitor_table *mt = node->data;
 556
 557         max_columns = MAX(max_columns, mt->n_columns);
 558     }
 559
 560     return max_columns;
 561 }
 562
 563 /* Constructs and returns JSON for a <table-updates> object (as described in
 564  * RFC 7047) for all the outstanding changes within 'monitor', starting from
 565  * 'transaction'.  */
 566 static struct json*
 567 ovsdb_monitor_compose_update(struct ovsdb_monitor *dbmon,
 568                              bool initial, uint64_t transaction)
 569 {
 570     struct shash_node *node;
 571     struct json *json;
 572     size_t max_columns = ovsdb_monitor_max_columns(dbmon);
 573     unsigned long int *changed = xmalloc(bitmap_n_bytes(max_columns));
 574
 575     json = NULL;
 576     SHASH_FOR_EACH (node, &dbmon->tables) {
 577         struct ovsdb_monitor_table *mt = node->data;
 578         struct ovsdb_monitor_row *row, *next;
 579         struct ovsdb_monitor_changes *changes;
 580         struct json *table_json = NULL;
 581
 582         changes = ovsdb_monitor_table_find_changes(mt, transaction);
 583         if (!changes) {
 584             continue;
 585         }
 586
 587         HMAP_FOR_EACH_SAFE (row, next, hmap_node, &changes->rows) {
 588             struct json *row_json;
 589
 590             row_json = ovsdb_monitor_compose_row_update(
 591                 mt, row, initial, changed);
 592             if (row_json) {
 593                 char uuid[UUID_LEN + 1];
 594
 595                 /* Create JSON object for transaction overall. */
 596                 if (!json) {
 597                     json = json_object_create();
 598                 }
 599
 600                 /* Create JSON object for transaction on this table. */
 601                 if (!table_json) {
 602                     table_json = json_object_create();
 603                     json_object_put(json, mt->table->schema->name, table_json);
 604                 }
 605
 606                 /* Add JSON row to JSON table. */
 607                 snprintf(uuid, sizeof uuid, UUID_FMT, UUID_ARGS(&row->uuid));
 608                 json_object_put(table_json, uuid, row_json);
 609             }
 610         }
 611     }
 612     free(changed);
 613
 614     return json;
 615 }
 616
 617 /* Returns JSON for a <table-updates> object (as described in RFC 7047)
 618  * for all the outstanding changes within 'monitor' that starts from
 619  * '*unflushed' transaction id.
 620  *
 621  * The caller should specify 'initial' as true if the returned JSON is going to
 622  * be used as part of the initial reply to a "monitor" request, false if it is
 623  * going to be used as part of an "update" notification. */
 624 struct json *
 625 ovsdb_monitor_get_update(struct ovsdb_monitor *dbmon,
 626                          bool initial, uint64_t *unflushed)
 627 {
 628     struct ovsdb_monitor_json_cache_node *cache_node;
 629     struct shash_node *node;
 630     struct json *json;
 631     uint64_t prev_txn = *unflushed;
 632     uint64_t next_txn = dbmon->n_transactions + 1;
 633
 634     /* Return a clone of cached json if one exists. Otherwise,
 635      * generate a new one and add it to the cache.  */
 636     cache_node = ovsdb_monitor_json_cache_search(dbmon, prev_txn);
 637     if (cache_node) {
 638         json = cache_node->json ? json_clone(cache_node->json) : NULL;
 639     } else {
 640         json = ovsdb_monitor_compose_update(dbmon, initial, prev_txn);
 641         ovsdb_monitor_json_cache_insert(dbmon, prev_txn, json);
 642     }
 643
 644     /* Maintain transaction id of 'changes'. */
 645     SHASH_FOR_EACH (node, &dbmon->tables) {
 646         struct ovsdb_monitor_table *mt = node->data;
 647
 648         ovsdb_monitor_table_untrack_changes(mt, prev_txn);
 649         ovsdb_monitor_table_track_changes(mt, next_txn);
 650     }
 651     *unflushed = next_txn;
 652
 653     return json;
 654 }
 655
 656 bool
 657 ovsdb_monitor_needs_flush(struct ovsdb_monitor *dbmon,
 658                           uint64_t next_transaction)
 659 {
 660     ovs_assert(next_transaction <= dbmon->n_transactions + 1);
 661     return (next_transaction <= dbmon->n_transactions);
 662 }
 663
 664 void
 665 ovsdb_monitor_table_add_select(struct ovsdb_monitor *dbmon,
 666                                const struct ovsdb_table *table,
 667                                enum ovsdb_monitor_selection select)
 668 {
 669     struct ovsdb_monitor_table * mt;
 670
 671     mt = shash_find_data(&dbmon->tables, table->schema->name);
 672     mt->select |= select;
 673 }
 674
 675  /*
 676  * If a row's change type (insert, delete or modify) matches that of
 677  * the monitor, they should be sent to the monitor's clients as updates.
 678  * Of cause, the monitor should also internally update with this change.
 679  *
 680  * When a change type does not require client side update, the monitor
 681  * may still need to keep track of certain changes in order to generate
 682  * correct future updates.  For example, the monitor internal state should
 683  * be updated whenever a new row is inserted, in order to generate the
 684  * correct initial state, regardless if a insert change type is being
 685  * monitored.
 686  *
 687  * On the other hand, if a transaction only contains changes to columns
 688  * that are not monitored, this transaction can be safely ignored by the
 689  * monitor.
 690  *
 691  * Thus, the order of the declaration is important:
 692  * 'OVSDB_CHANGES_REQUIRE_EXTERNAL_UPDATE' always implies
 693  * 'OVSDB_CHANGES_REQUIRE_INTERNAL_UPDATE', but not vice versa.  */
 694 enum ovsdb_monitor_changes_efficacy {
 695     OVSDB_CHANGES_NO_EFFECT,                /* Monitor does not care about this
 696                                                change.  */
 697     OVSDB_CHANGES_REQUIRE_INTERNAL_UPDATE,  /* Monitor internal updates. */
 698     OVSDB_CHANGES_REQUIRE_EXTERNAL_UPDATE,  /* Client needs to be updated.  */
 699 };
 700
 701 struct ovsdb_monitor_aux {
 702     const struct ovsdb_monitor *monitor;
 703     struct ovsdb_monitor_table *mt;
 704     enum ovsdb_monitor_changes_efficacy efficacy;
 705 };
 706
 707 static void
 708 ovsdb_monitor_init_aux(struct ovsdb_monitor_aux *aux,
 709                        const struct ovsdb_monitor *m)
 710 {
 711     aux->monitor = m;
 712     aux->mt = NULL;
 713     aux->efficacy = OVSDB_CHANGES_NO_EFFECT;
 714 }
 715
 716 static void
 717 ovsdb_monitor_changes_update(const struct ovsdb_row *old,
 718                              const struct ovsdb_row *new,
 719                              const struct ovsdb_monitor_table *mt,
 720                              struct ovsdb_monitor_changes *changes)
 721 {
 722     const struct uuid *uuid = ovsdb_row_get_uuid(new ? new : old);
 723     struct ovsdb_monitor_row *change;
 724
 725     change = ovsdb_monitor_changes_row_find(changes, uuid);
 726     if (!change) {
 727         change = xzalloc(sizeof *change);
 728         hmap_insert(&changes->rows, &change->hmap_node, uuid_hash(uuid));
 729         change->uuid = *uuid;
 730         change->old = clone_monitor_row_data(mt, old);
 731         change->new = clone_monitor_row_data(mt, new);
 732     } else {
 733         if (new) {
 734             update_monitor_row_data(mt, new, change->new);
 735         } else {
 736             free_monitor_row_data(mt, change->new);
 737             change->new = NULL;
 738
 739             if (!change->old) {
 740                 /* This row was added then deleted.  Forget about it. */
 741                 hmap_remove(&changes->rows, &change->hmap_node);
 742                 free(change);
 743             }
 744         }
 745     }
 746 }
 747
 748 static bool
 749 ovsdb_monitor_columns_changed(const struct ovsdb_monitor_table *mt,
 750                               const unsigned long int *changed)
 751 {
 752     size_t i;
 753
 754     for (i = 0; i < mt->n_columns; i++) {
 755         size_t column_index = mt->columns[i].column->index;
 756
 757         if (bitmap_is_set(changed, column_index)) {
 758             return true;
 759         }
 760     }
 761
 762     return false;
 763 }
 764
 765 /* Return the efficacy of a row's change to a monitor table.
 766  *
 767  * Please see the block comment above 'ovsdb_monitor_changes_efficacy'
 768  * definition form more information.  */
 769 static enum ovsdb_monitor_changes_efficacy
 770 ovsdb_monitor_changes_classify(enum ovsdb_monitor_selection type,
 771                                const struct ovsdb_monitor_table *mt,
 772                                const unsigned long int *changed)
 773 {
 774     if (type == OJMS_MODIFY &&
 775         !ovsdb_monitor_columns_changed(mt, changed)) {
 776         return OVSDB_CHANGES_NO_EFFECT;
 777     }
 778
 779     return (mt->select & type)
 780                 ?  OVSDB_CHANGES_REQUIRE_EXTERNAL_UPDATE
 781                 :  OVSDB_CHANGES_REQUIRE_INTERNAL_UPDATE;
 782 }
 783
 784 static bool
 785 ovsdb_monitor_change_cb(const struct ovsdb_row *old,
 786                         const struct ovsdb_row *new,
 787                         const unsigned long int *changed,
 788                         void *aux_)
 789 {
 790     struct ovsdb_monitor_aux *aux = aux_;
 791     const struct ovsdb_monitor *m = aux->monitor;
 792     struct ovsdb_table *table = new ? new->table : old->table;
 793     struct ovsdb_monitor_table *mt;
 794     struct ovsdb_monitor_changes *changes;
 795
 796     if (!aux->mt || table != aux->mt->table) {
 797         aux->mt = shash_find_data(&m->tables, table->schema->name);
 798         if (!aux->mt) {
 799             /* We don't care about rows in this table at all.  Tell the caller
 800              * to skip it.  */
 801             return false;
 802         }
 803     }
 804     mt = aux->mt;
 805
 806     HMAP_FOR_EACH(changes, hmap_node, &mt->changes) {
 807         enum ovsdb_monitor_changes_efficacy efficacy;
 808         enum ovsdb_monitor_selection type;
 809
 810         type = ovsdb_monitor_row_update_type(false, old, new);
 811         efficacy = ovsdb_monitor_changes_classify(type, mt, changed);
 812         if (efficacy > OVSDB_CHANGES_NO_EFFECT) {
 813             ovsdb_monitor_changes_update(old, new, mt, changes);
 814         }
 815
 816         if (aux->efficacy < efficacy) {
 817             aux->efficacy = efficacy;
 818         }
 819     }
 820
 821     return true;
 822 }
 823
 824 void
 825 ovsdb_monitor_get_initial(const struct ovsdb_monitor *dbmon)
 826 {
 827     struct ovsdb_monitor_aux aux;
 828     struct shash_node *node;
 829
 830     ovsdb_monitor_init_aux(&aux, dbmon);
 831     SHASH_FOR_EACH (node, &dbmon->tables) {
 832         struct ovsdb_monitor_table *mt = node->data;
 833
 834         if (mt->select & OJMS_INITIAL) {
 835             struct ovsdb_row *row;
 836             struct ovsdb_monitor_changes *changes;
 837
 838             changes = ovsdb_monitor_table_find_changes(mt, 0);
 839             if (!changes) {
 840                 changes = ovsdb_monitor_table_add_changes(mt, 0);
 841                 HMAP_FOR_EACH (row, hmap_node, &mt->table->rows) {
 842                     ovsdb_monitor_changes_update(NULL, row, mt, changes);
 843                 }
 844             } else {
 845                 changes->n_refs++;
 846             }
 847         }
 848     }
 849 }
 850
 851 void
 852 ovsdb_monitor_remove_jsonrpc_monitor(struct ovsdb_monitor *dbmon,
 853                    struct ovsdb_jsonrpc_monitor *jsonrpc_monitor)
 854 {
 855     struct jsonrpc_monitor_node *jm;
 856
 857     if (list_is_empty(&dbmon->jsonrpc_monitors)) {
 858         ovsdb_monitor_destroy(dbmon);
 859         return;
 860     }
 861
 862     /* Find and remove the jsonrpc monitor from the list.  */
 863     LIST_FOR_EACH(jm, node, &dbmon->jsonrpc_monitors) {
 864         if (jm->jsonrpc_monitor == jsonrpc_monitor) {
 865             list_remove(&jm->node);
 866             free(jm);
 867
 868             /* Destroy ovsdb monitor if this is the last user.  */
 869             if (list_is_empty(&dbmon->jsonrpc_monitors)) {
 870                 ovsdb_monitor_destroy(dbmon);
 871             }
 872
 873             return;
 874         };
 875     }
 876
 877     /* Should never reach here. jsonrpc_monitor should be on the list.  */
 878     OVS_NOT_REACHED();
 879 }
 880
 881 static bool
 882 ovsdb_monitor_table_equal(const struct ovsdb_monitor_table *a,
 883                           const struct ovsdb_monitor_table *b)
 884 {
 885     size_t i;
 886
 887     if ((a->table != b->table) ||
 888         (a->select != b->select) ||
 889         (a->n_columns != b->n_columns)) {
 890         return false;
 891     }
 892
 893     for (i = 0; i < a->n_columns; i++) {
 894         if ((a->columns[i].column != b->columns[i].column) ||
 895             (a->columns[i].select != b->columns[i].select)) {
 896             return false;
 897         }
 898     }
 899
 900     return true;
 901 }
 902
 903 static bool
 904 ovsdb_monitor_equal(const struct ovsdb_monitor *a,
 905                     const struct ovsdb_monitor *b)
 906 {
 907     struct shash_node *node;
 908
 909     if (shash_count(&a->tables) != shash_count(&b->tables)) {
 910         return false;
 911     }
 912
 913     SHASH_FOR_EACH(node, &a->tables) {
 914         const struct ovsdb_monitor_table *mta = node->data;
 915         const struct ovsdb_monitor_table *mtb;
 916
 917         mtb = shash_find_data(&b->tables, node->name);
 918         if (!mtb) {
 919             return false;
 920         }
 921
 922         if (!ovsdb_monitor_table_equal(mta, mtb)) {
 923             return false;
 924         }
 925     }
 926
 927     return true;
 928 }
 929
 930 static size_t
 931 ovsdb_monitor_hash(const struct ovsdb_monitor *dbmon, size_t basis)
 932 {
 933     const struct shash_node **nodes;
 934     size_t i, j, n;
 935
 936     nodes = shash_sort(&dbmon->tables);
 937     n = shash_count(&dbmon->tables);
 938
 939     for (i = 0; i < n; i++) {
 940         struct ovsdb_monitor_table *mt = nodes[i]->data;
 941
 942         basis = hash_pointer(mt->table, basis);
 943         basis = hash_3words(mt->select, mt->n_columns, basis);
 944
 945         for (j = 0; j < mt->n_columns; j++) {
 946             basis = hash_pointer(mt->columns[j].column, basis);
 947             basis = hash_2words(mt->columns[j].select, basis);
 948         }
 949     }
 950     free(nodes);
 951
 952     return basis;
 953 }
 954
 955 struct ovsdb_monitor *
 956 ovsdb_monitor_add(struct ovsdb_monitor *new_dbmon)
 957 {
 958     struct ovsdb_monitor *dbmon;
 959     size_t hash;
 960
 961     /* New_dbmon should be associated with only one jsonrpc
 962      * connections.  */
 963     ovs_assert(list_is_singleton(&new_dbmon->jsonrpc_monitors));
 964
 965     hash = ovsdb_monitor_hash(new_dbmon, 0);
 966     HMAP_FOR_EACH_WITH_HASH(dbmon, hmap_node, hash, &ovsdb_monitors) {
 967         if (ovsdb_monitor_equal(dbmon,  new_dbmon)) {
 968             return dbmon;
 969         }
 970     }
 971
 972     hmap_insert(&ovsdb_monitors, &new_dbmon->hmap_node, hash);
 973     return new_dbmon;
 974 }
 975
 976 static void
 977 ovsdb_monitor_destroy(struct ovsdb_monitor *dbmon)
 978 {
 979     struct shash_node *node;
 980
 981     list_remove(&dbmon->replica.node);
 982
 983     if (!hmap_node_is_null(&dbmon->hmap_node)) {
 984         hmap_remove(&ovsdb_monitors, &dbmon->hmap_node);
 985     }
 986
 987     ovsdb_monitor_json_cache_flush(dbmon);
 988     hmap_destroy(&dbmon->json_cache);
 989
 990     SHASH_FOR_EACH (node, &dbmon->tables) {
 991         struct ovsdb_monitor_table *mt = node->data;
 992         struct ovsdb_monitor_changes *changes, *next;
 993
 994         HMAP_FOR_EACH_SAFE (changes, next, hmap_node, &mt->changes) {
 995             hmap_remove(&mt->changes, &changes->hmap_node);
 996             ovsdb_monitor_changes_destroy(changes);
 997         }
 998         hmap_destroy(&mt->changes);
 999         free(mt->columns);
1000         free(mt);
1001     }
1002     shash_destroy(&dbmon->tables);
1003     free(dbmon);
1004 }
1005
1006 static struct ovsdb_error *
1007 ovsdb_monitor_commit(struct ovsdb_replica *replica,
1008                      const struct ovsdb_txn *txn,
1009                      bool durable OVS_UNUSED)
1010 {
1011     struct ovsdb_monitor *m = ovsdb_monitor_cast(replica);
1012     struct ovsdb_monitor_aux aux;
1013
1014     ovsdb_monitor_init_aux(&aux, m);
1015     ovsdb_txn_for_each_change(txn, ovsdb_monitor_change_cb, &aux);
1016
1017     if (aux.efficacy == OVSDB_CHANGES_REQUIRE_EXTERNAL_UPDATE) {
1018         ovsdb_monitor_json_cache_flush(m);
1019         m->n_transactions++;
1020     }
1021
1022     return NULL;
1023 }
1024
1025 static void
1026 ovsdb_monitor_destroy_callback(struct ovsdb_replica *replica)
1027 {
1028     struct ovsdb_monitor *dbmon = ovsdb_monitor_cast(replica);
1029     struct jsonrpc_monitor_node *jm, *next;
1030
1031     /* Delete all front end monitors. Removing the last front
1032      * end monitor will also destroy the corresponding 'ovsdb_monitor'.
1033      * ovsdb monitor will also be destroied.  */
1034     LIST_FOR_EACH_SAFE(jm, next, node, &dbmon->jsonrpc_monitors) {
1035         ovsdb_jsonrpc_monitor_destroy(jm->jsonrpc_monitor);
1036     }
1037 }
1038
1039 static const struct ovsdb_replica_class ovsdb_jsonrpc_replica_class = {
1040     ovsdb_monitor_commit,
1041     ovsdb_monitor_destroy_callback,
1042 };