X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fovsdb-idl.c;h=2132f9fefb8635142ff3908d2193d7396c026ddb;hb=c09c9fb21a4fa7dc68f932595041c90ecc7f9b2d;hp=da97579327aeb3f8991f56700af5a25438fa68d8;hpb=4ea21243f5a6002528d33d2bd58ce41a9d03a4c4;p=openvswitch diff --git a/lib/ovsdb-idl.c b/lib/ovsdb-idl.c index da975793..2132f9fe 100644 --- a/lib/ovsdb-idl.c +++ b/lib/ovsdb-idl.c @@ -34,10 +34,10 @@ #include "poll-loop.h" #include "shash.h" #include "util.h" - -#define THIS_MODULE VLM_ovsdb_idl #include "vlog.h" +VLOG_DEFINE_THIS_MODULE(ovsdb_idl) + /* An arc from one idl_row to another. When row A contains a UUID that * references row B, this is represented by an arc from A (the source) to B * (the destination). @@ -112,13 +112,13 @@ static void ovsdb_idl_send_monitor_request(struct ovsdb_idl *); static void ovsdb_idl_parse_update(struct ovsdb_idl *, const struct json *); static struct ovsdb_error *ovsdb_idl_parse_update__(struct ovsdb_idl *, const struct json *); -static void ovsdb_idl_process_update(struct ovsdb_idl_table *, +static bool ovsdb_idl_process_update(struct ovsdb_idl_table *, const struct uuid *, const struct json *old, const struct json *new); static void ovsdb_idl_insert_row(struct ovsdb_idl_row *, const struct json *); static void ovsdb_idl_delete_row(struct ovsdb_idl_row *); -static void ovsdb_idl_modify_row(struct ovsdb_idl_row *, const struct json *); +static bool ovsdb_idl_modify_row(struct ovsdb_idl_row *, const struct json *); static bool ovsdb_idl_row_is_orphan(const struct ovsdb_idl_row *); static struct ovsdb_idl_row *ovsdb_idl_row_create__( @@ -136,6 +136,11 @@ static void ovsdb_idl_txn_abort_all(struct ovsdb_idl *); static bool ovsdb_idl_txn_process_reply(struct ovsdb_idl *, const struct jsonrpc_msg *msg); +/* Creates and returns a connection to database 'remote', which should be in a + * form acceptable to jsonrpc_session_open(). The connection will maintain an + * in-memory replica of the remote database whose schema is described by + * 'class'. (Ordinarily 'class' is compiled from an OVSDB schema automatically + * by ovsdb-idlc.) */ struct ovsdb_idl * ovsdb_idl_create(const char *remote, const struct ovsdb_idl_class *class) { @@ -152,15 +157,15 @@ ovsdb_idl_create(const char *remote, const struct ovsdb_idl_class *class) struct ovsdb_idl_table *table = &idl->tables[i]; size_t j; - assert(!shash_find(&idl->table_by_name, tc->name)); - shash_add(&idl->table_by_name, tc->name, table); + shash_add_assert(&idl->table_by_name, tc->name, table); table->class = tc; + table->modes = xmalloc(tc->n_columns); + memset(table->modes, OVSDB_IDL_MODE_RW, tc->n_columns); shash_init(&table->columns); for (j = 0; j < tc->n_columns; j++) { const struct ovsdb_idl_column *column = &tc->columns[j]; - assert(!shash_find(&table->columns, column->name)); - shash_add(&table->columns, column->name, column); + shash_add_assert(&table->columns, column->name, column); } hmap_init(&table->rows); table->idl = idl; @@ -171,6 +176,7 @@ ovsdb_idl_create(const char *remote, const struct ovsdb_idl_class *class) return idl; } +/* Destroys 'idl' and all of the data structures that it manages. */ void ovsdb_idl_destroy(struct ovsdb_idl *idl) { @@ -185,6 +191,7 @@ ovsdb_idl_destroy(struct ovsdb_idl *idl) struct ovsdb_idl_table *table = &idl->tables[i]; shash_destroy(&table->columns); hmap_destroy(&table->rows); + free(table->modes); } shash_destroy(&idl->table_by_name); free(idl->tables); @@ -231,6 +238,26 @@ ovsdb_idl_clear(struct ovsdb_idl *idl) } } +/* Processes a batch of messages from the database server on 'idl'. Returns + * true if the database as seen through 'idl' changed, false if it did not + * change. The initial fetch of the entire contents of the remote database is + * considered to be one kind of change. + * + * When this function returns false, the client may continue to use any data + * structures it obtained from 'idl' in the past. But when it returns true, + * the client must not access any of these data structures again, because they + * could have freed or reused for other purposes. + * + * This function can return occasional false positives, that is, report that + * the database changed even though it didn't. This happens if the connection + * to the database drops and reconnects, which causes the database contents to + * be reloaded even if they didn't change. (It could also happen if the + * database server sends out a "change" that reflects what we already thought + * was in the database, but the database server is not supposed to do that.) + * + * As an alternative to checking the return value, the client may check for + * changes in the value returned by ovsdb_idl_get_seqno(). + */ bool ovsdb_idl_run(struct ovsdb_idl *idl) { @@ -266,6 +293,7 @@ ovsdb_idl_run(struct ovsdb_idl *idl) } else if (msg->type == JSONRPC_REPLY && idl->monitor_request_id && json_equal(idl->monitor_request_id, msg->id)) { + idl->change_seqno++; json_destroy(idl->monitor_request_id); idl->monitor_request_id = NULL; ovsdb_idl_clear(idl); @@ -295,6 +323,8 @@ ovsdb_idl_run(struct ovsdb_idl *idl) return initial_change_seqno != idl->change_seqno; } +/* Arranges for poll_block() to wake up when ovsdb_idl_run() has something to + * do or when activity occurs on a transaction on 'idl'. */ void ovsdb_idl_wait(struct ovsdb_idl *idl) { @@ -302,23 +332,94 @@ ovsdb_idl_wait(struct ovsdb_idl *idl) jsonrpc_session_recv_wait(idl->session); } +/* Returns a number that represents the state of 'idl'. When 'idl' is updated + * (by ovsdb_idl_run()), the return value changes. */ unsigned int ovsdb_idl_get_seqno(const struct ovsdb_idl *idl) { return idl->change_seqno; } +/* Returns true if 'idl' successfully connected to the remote database and + * retrieved its contents (even if the connection subsequently dropped and is + * in the process of reconnecting). If so, then 'idl' contains an atomic + * snapshot of the database's contents (but it might be arbitrarily old if the + * connection dropped). + * + * Returns false if 'idl' has never connected or retrieved the database's + * contents. If so, 'idl' is empty. */ bool ovsdb_idl_has_ever_connected(const struct ovsdb_idl *idl) { return ovsdb_idl_get_seqno(idl) != 0; } +/* Forces 'idl' to drop its connection to the database and reconnect. In the + * meantime, the contents of 'idl' will not change. */ void ovsdb_idl_force_reconnect(struct ovsdb_idl *idl) { jsonrpc_session_force_reconnect(idl->session); } + +static void +ovsdb_idl_set_mode(struct ovsdb_idl *idl, + const struct ovsdb_idl_column *column, + enum ovsdb_idl_mode mode) +{ + size_t i; + + for (i = 0; i < idl->class->n_tables; i++) { + const struct ovsdb_idl_table *table = &idl->tables[i]; + const struct ovsdb_idl_table_class *tc = table->class; + + if (column >= tc->columns && column < &tc->columns[tc->n_columns]) { + unsigned char *modep = &table->modes[column - tc->columns]; + assert(*modep == OVSDB_IDL_MODE_RW || *modep == mode); + *modep = mode; + return; + } + } + + NOT_REACHED(); +} + +/* By default, 'idl' replicates all of the columns in the remote database, and + * ovsdb_idl_run() returns true upon a change to any column in the database. + * Call this function to avoid alerting ovsdb_idl_run()'s caller upon changes + * to 'column'. + * + * This is useful for columns that a client treats as "write-only", that is, it + * updates them but doesn't want to get alerted about its own updates. It also + * won't be alerted about other clients' updates, so this is suitable only for + * use by a client that "owns" a particular column. + * + * The client must be careful not to retain pointers to data in 'column' across + * calls to ovsdb_idl_run(), even when that function returns false, because + * the client is not alerted to changes. + * + * This function should be called after ovsdb_idl_create(), but before the + * first call to ovsdb_idl_run(). For any given column, this function may be + * called or ovsdb_idl_omit() may be called, but not both. */ +void +ovsdb_idl_set_write_only(struct ovsdb_idl *idl, + const struct ovsdb_idl_column *column) +{ + ovsdb_idl_set_mode(idl, column, OVSDB_IDL_MODE_WO); +} + +/* By default, 'idl' replicates all of the columns in the remote database. + * Call this function to omit replicating 'column'. This saves CPU time and + * bandwidth to the database. + * + * This function should be called after ovsdb_idl_create(), but before the + * first call to ovsdb_idl_run(). For any given column, this function may be + * called or ovsdb_idl_set_write_only() may be called, but not both. */ +void +ovsdb_idl_omit(struct ovsdb_idl *idl, const struct ovsdb_idl_column *column) +{ + ovsdb_idl_set_mode(idl, column, OVSDB_IDL_MODE_NONE); +} static void ovsdb_idl_send_monitor_request(struct ovsdb_idl *idl) @@ -338,7 +439,9 @@ ovsdb_idl_send_monitor_request(struct ovsdb_idl *idl) columns = json_array_create_empty(); for (i = 0; i < tc->n_columns; i++) { const struct ovsdb_idl_column *column = &tc->columns[i]; - json_array_add(columns, json_string_create(column->name)); + if (table->modes[i] != OVSDB_IDL_MODE_NONE) { + json_array_add(columns, json_string_create(column->name)); + } } json_object_put(monitor_request, "columns", columns); json_object_put(monitor_requests, tc->name, monitor_request); @@ -356,11 +459,7 @@ ovsdb_idl_send_monitor_request(struct ovsdb_idl *idl) static void ovsdb_idl_parse_update(struct ovsdb_idl *idl, const struct json *table_updates) { - struct ovsdb_error *error; - - idl->change_seqno++; - - error = ovsdb_idl_parse_update__(idl, table_updates); + struct ovsdb_error *error = ovsdb_idl_parse_update__(idl, table_updates); if (error) { if (!VLOG_DROP_WARN(&syntax_rl)) { char *s = ovsdb_error_to_string(error); @@ -440,7 +539,9 @@ ovsdb_idl_parse_update__(struct ovsdb_idl *idl, "and \"new\" members"); } - ovsdb_idl_process_update(table, &uuid, old_json, new_json); + if (ovsdb_idl_process_update(table, &uuid, old_json, new_json)) { + idl->change_seqno++; + } } } @@ -461,7 +562,9 @@ ovsdb_idl_get_row(struct ovsdb_idl_table *table, const struct uuid *uuid) return NULL; } -static void +/* Returns true if a column with mode OVSDB_IDL_MODE_RW changed, false + * otherwise. */ +static bool ovsdb_idl_process_update(struct ovsdb_idl_table *table, const struct uuid *uuid, const struct json *old, const struct json *new) @@ -478,6 +581,7 @@ ovsdb_idl_process_update(struct ovsdb_idl_table *table, VLOG_WARN_RL(&semantic_rl, "cannot delete missing row "UUID_FMT" " "from table %s", UUID_ARGS(uuid), table->class->name); + return false; } } else if (!old) { /* Insert row. */ @@ -488,14 +592,14 @@ ovsdb_idl_process_update(struct ovsdb_idl_table *table, } else { VLOG_WARN_RL(&semantic_rl, "cannot add existing row "UUID_FMT" to " "table %s", UUID_ARGS(uuid), table->class->name); - ovsdb_idl_modify_row(row, new); + return ovsdb_idl_modify_row(row, new); } } else { /* Modify row. */ if (row) { /* XXX perhaps we should check the 'old' values? */ if (!ovsdb_idl_row_is_orphan(row)) { - ovsdb_idl_modify_row(row, new); + return ovsdb_idl_modify_row(row, new); } else { VLOG_WARN_RL(&semantic_rl, "cannot modify missing but " "referenced row "UUID_FMT" in table %s", @@ -508,13 +612,18 @@ ovsdb_idl_process_update(struct ovsdb_idl_table *table, ovsdb_idl_insert_row(ovsdb_idl_row_create(table, uuid), new); } } + + return true; } -static void +/* Returns true if a column with mode OVSDB_IDL_MODE_RW changed, false + * otherwise. */ +static bool ovsdb_idl_row_update(struct ovsdb_idl_row *row, const struct json *row_json) { struct ovsdb_idl_table *table = row->table; struct shash_node *node; + bool changed = false; SHASH_FOR_EACH (node, json_object(row_json)) { const char *column_name = node->name; @@ -531,8 +640,19 @@ ovsdb_idl_row_update(struct ovsdb_idl_row *row, const struct json *row_json) error = ovsdb_datum_from_json(&datum, &column->type, node->data, NULL); if (!error) { - ovsdb_datum_swap(&row->old[column - table->class->columns], - &datum); + unsigned int column_idx = column - table->class->columns; + struct ovsdb_datum *old = &row->old[column_idx]; + + if (!ovsdb_datum_equals(old, &datum, &column->type)) { + ovsdb_datum_swap(old, &datum); + if (table->modes[column_idx] == OVSDB_IDL_MODE_RW) { + changed = true; + } + } else { + /* Didn't really change but the OVSDB monitor protocol always + * includes every value in a row. */ + } + ovsdb_datum_destroy(&datum, &column->type); } else { char *s = ovsdb_error_to_string(error); @@ -543,6 +663,7 @@ ovsdb_idl_row_update(struct ovsdb_idl_row *row, const struct json *row_json) ovsdb_error_destroy(error); } } + return changed; } /* When a row A refers to row B through a column with a "refTable" constraint, @@ -630,8 +751,10 @@ ovsdb_idl_row_clear_new(struct ovsdb_idl_row *row) const struct ovsdb_idl_table_class *class = row->table->class; size_t i; - BITMAP_FOR_EACH_1 (i, class->n_columns, row->written) { - ovsdb_datum_destroy(&row->new[i], &class->columns[i].type); + if (row->written) { + BITMAP_FOR_EACH_1 (i, class->n_columns, row->written) { + ovsdb_datum_destroy(&row->new[i], &class->columns[i].type); + } } free(row->new); free(row->written); @@ -747,13 +870,19 @@ ovsdb_idl_delete_row(struct ovsdb_idl_row *row) } } -static void +/* Returns true if a column with mode OVSDB_IDL_MODE_RW changed, false + * otherwise. */ +static bool ovsdb_idl_modify_row(struct ovsdb_idl_row *row, const struct json *row_json) { + bool changed; + ovsdb_idl_row_unparse(row); ovsdb_idl_row_clear_arcs(row, true); - ovsdb_idl_row_update(row, row_json); + changed = ovsdb_idl_row_update(row, row_json); ovsdb_idl_row_parse(row); + + return changed; } static bool @@ -868,6 +997,55 @@ ovsdb_idl_next_row(const struct ovsdb_idl_row *row) return next_real_row(table, hmap_next(&table->rows, &row->hmap_node)); } + +/* Reads and returns the value of 'column' within 'row'. If an ongoing + * transaction has changed 'column''s value, the modified value is returned. + * + * The caller must not modify or free the returned value. + * + * Various kinds of changes can invalidate the returned value: writing to the + * same 'column' in 'row' (e.g. with ovsdb_idl_txn_write()), deleting 'row' + * (e.g. with ovsdb_idl_txn_delete()), or completing an ongoing transaction + * (e.g. with ovsdb_idl_txn_commit() or ovsdb_idl_txn_abort()). If the + * returned value is needed for a long time, it is best to make a copy of it + * with ovsdb_datum_clone(). */ +const struct ovsdb_datum * +ovsdb_idl_read(const struct ovsdb_idl_row *row, + const struct ovsdb_idl_column *column) +{ + const struct ovsdb_idl_table_class *class = row->table->class; + size_t column_idx = column - class->columns; + + assert(row->new != NULL); + assert(column_idx < class->n_columns); + + if (row->written && bitmap_is_set(row->written, column_idx)) { + return &row->new[column_idx]; + } else if (row->old) { + return &row->old[column_idx]; + } else { + return ovsdb_datum_default(&column->type); + } +} + +/* Same as ovsdb_idl_read(), except that it also asserts that 'column' has key + * type 'key_type' and value type 'value_type'. (Scalar and set types will + * have a value type of OVSDB_TYPE_VOID.) + * + * This is useful in code that "knows" that a particular column has a given + * type, so that it will abort if someone changes the column's type without + * updating the code that uses it. */ +const struct ovsdb_datum * +ovsdb_idl_get(const struct ovsdb_idl_row *row, + const struct ovsdb_idl_column *column, + enum ovsdb_atomic_type key_type OVS_UNUSED, + enum ovsdb_atomic_type value_type OVS_UNUSED) +{ + assert(column->type.key.type == key_type); + assert(column->type.value.type == value_type); + + return ovsdb_idl_read(row, column); +} /* Transactions. */ @@ -1193,18 +1371,22 @@ ovsdb_idl_txn_commit(struct ovsdb_idl_txn *txn) row_json = json_object_create(); json_object_put(op, "row", row_json); - BITMAP_FOR_EACH_1 (idx, class->n_columns, row->written) { - const struct ovsdb_idl_column *column = &class->columns[idx]; - - if (row->old - ? !ovsdb_datum_equals(&row->old[idx], &row->new[idx], - &column->type) - : !ovsdb_datum_is_default(&row->new[idx], &column->type)) { - json_object_put(row_json, column->name, - substitute_uuids( - ovsdb_datum_to_json(&row->new[idx], - &column->type), - txn)); + if (row->written) { + BITMAP_FOR_EACH_1 (idx, class->n_columns, row->written) { + const struct ovsdb_idl_column *column = + &class->columns[idx]; + + if (row->old + ? !ovsdb_datum_equals(&row->old[idx], &row->new[idx], + &column->type) + : !ovsdb_datum_is_default(&row->new[idx], + &column->type)) { + json_object_put(row_json, column->name, + substitute_uuids( + ovsdb_datum_to_json(&row->new[idx], + &column->type), + txn)); + } } } @@ -1365,24 +1547,6 @@ ovsdb_idl_txn_complete(struct ovsdb_idl_txn *txn, hmap_remove(&txn->idl->outstanding_txns, &txn->hmap_node); } -void -ovsdb_idl_txn_read(const struct ovsdb_idl_row *row, - const struct ovsdb_idl_column *column, - struct ovsdb_datum *datum) -{ - const struct ovsdb_idl_table_class *class = row->table->class; - size_t column_idx = column - class->columns; - - assert(row->new != NULL); - if (row->written && bitmap_is_set(row->written, column_idx)) { - ovsdb_datum_clone(datum, &row->new[column_idx], &column->type); - } else if (row->old) { - ovsdb_datum_clone(datum, &row->old[column_idx], &column->type); - } else { - ovsdb_datum_init_default(datum, &column->type); - } -} - void ovsdb_idl_txn_write(const struct ovsdb_idl_row *row_, const struct ovsdb_idl_column *column, @@ -1394,6 +1558,8 @@ ovsdb_idl_txn_write(const struct ovsdb_idl_row *row_, assert(row->new != NULL); assert(column_idx < class->n_columns); + assert(row->table->modes[column_idx] != OVSDB_IDL_MODE_NONE); + if (hmap_node_is_null(&row->txn_node)) { hmap_insert(&row->table->idl->txn->txn_rows, &row->txn_node, uuid_hash(&row->uuid)); @@ -1477,7 +1643,6 @@ ovsdb_idl_txn_insert(struct ovsdb_idl_txn *txn, row->table = ovsdb_idl_table_from_class(txn->idl, class); row->new = xmalloc(class->n_columns * sizeof *row->new); - row->written = bitmap_allocate(class->n_columns); hmap_insert(&row->table->rows, &row->hmap_node, uuid_hash(&row->uuid)); hmap_insert(&txn->txn_rows, &row->txn_node, uuid_hash(&row->uuid)); return row;