-/* Copyright (c) 2009, 2010, 2011 Nicira Networks.
+/* Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "ovsdb-idl.h"
-#include <assert.h>
#include <errno.h>
#include <inttypes.h>
#include <limits.h>
struct json *monitor_request_id;
unsigned int last_monitor_request_seqno;
unsigned int change_seqno;
+ bool verify_write_only;
+
+ /* Database locking. */
+ char *lock_name; /* Name of lock we need, NULL if none. */
+ bool has_lock; /* Has db server told us we have the lock? */
+ bool is_lock_contended; /* Has db server told us we can't get lock? */
+ struct json *lock_request_id; /* JSON-RPC ID of in-flight lock request. */
/* Transaction support. */
struct ovsdb_idl_txn *txn;
char *error;
bool dry_run;
struct ds comment;
+ unsigned int commit_seqno;
/* Increments. */
- char *inc_table;
- char *inc_column;
- struct json *inc_where;
+ const char *inc_table;
+ const char *inc_column;
+ struct uuid inc_row;
unsigned int inc_index;
int64_t inc_new_value;
/* Inserted rows. */
- struct hmap inserted_rows;
+ struct hmap inserted_rows; /* Contains "struct ovsdb_idl_txn_insert"s. */
};
struct ovsdb_idl_txn_insert {
static bool ovsdb_idl_txn_process_reply(struct ovsdb_idl *,
const struct jsonrpc_msg *msg);
+static void ovsdb_idl_send_lock_request(struct ovsdb_idl *);
+static void ovsdb_idl_send_unlock_request(struct ovsdb_idl *);
+static void ovsdb_idl_parse_lock_reply(struct ovsdb_idl *,
+ const struct json *);
+static void ovsdb_idl_parse_lock_notify(struct ovsdb_idl *,
+ const struct json *params,
+ bool new_has_lock);
+
/* 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
if (idl) {
size_t i;
- assert(!idl->txn);
+ ovs_assert(!idl->txn);
ovsdb_idl_clear(idl);
jsonrpc_session_close(idl->session);
shash_destroy(&idl->table_by_name);
free(idl->tables);
json_destroy(idl->monitor_request_id);
+ free(idl->lock_name);
+ json_destroy(idl->lock_request_id);
+ hmap_destroy(&idl->outstanding_txns);
free(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
+/* Processes a batch of messages from the database server on 'idl'. This may
+ * cause the IDL's contents to change. The client may check for that with
+ * ovsdb_idl_get_seqno(). */
+void
ovsdb_idl_run(struct ovsdb_idl *idl)
{
- unsigned int initial_change_seqno = idl->change_seqno;
int i;
- assert(!idl->txn);
+ ovs_assert(!idl->txn);
jsonrpc_session_run(idl->session);
for (i = 0; jsonrpc_session_is_connected(idl->session) && i < 50; i++) {
struct jsonrpc_msg *msg;
idl->last_monitor_request_seqno = seqno;
ovsdb_idl_txn_abort_all(idl);
ovsdb_idl_send_monitor_request(idl);
+ if (idl->lock_name) {
+ ovsdb_idl_send_lock_request(idl);
+ }
break;
}
}
if (msg->type == JSONRPC_NOTIFY
- && !strcmp(msg->method, "update")
- && msg->params->type == JSON_ARRAY
- && msg->params->u.array.n == 2
- && msg->params->u.array.elems[0]->type == JSON_NULL) {
+ && !strcmp(msg->method, "update")
+ && msg->params->type == JSON_ARRAY
+ && msg->params->u.array.n == 2
+ && msg->params->u.array.elems[0]->type == JSON_NULL) {
+ /* Database contents changed. */
ovsdb_idl_parse_update(idl, msg->params->u.array.elems[1]);
} else if (msg->type == JSONRPC_REPLY
&& idl->monitor_request_id
&& json_equal(idl->monitor_request_id, msg->id)) {
+ /* Reply to our "monitor" request. */
idl->change_seqno++;
json_destroy(idl->monitor_request_id);
idl->monitor_request_id = NULL;
ovsdb_idl_clear(idl);
ovsdb_idl_parse_update(idl, msg->result);
+ } else if (msg->type == JSONRPC_REPLY
+ && idl->lock_request_id
+ && json_equal(idl->lock_request_id, msg->id)) {
+ /* Reply to our "lock" request. */
+ ovsdb_idl_parse_lock_reply(idl, msg->result);
+ } else if (msg->type == JSONRPC_NOTIFY
+ && !strcmp(msg->method, "locked")) {
+ /* We got our lock. */
+ ovsdb_idl_parse_lock_notify(idl, msg->params, true);
+ } else if (msg->type == JSONRPC_NOTIFY
+ && !strcmp(msg->method, "stolen")) {
+ /* Someone else stole our lock. */
+ ovsdb_idl_parse_lock_notify(idl, msg->params, false);
} else if (msg->type == JSONRPC_REPLY && msg->id->type == JSON_STRING
&& !strcmp(msg->id->u.string, "echo")) {
- /* It's a reply to our echo request. Ignore it. */
+ /* Reply to our echo request. Ignore it. */
} else if ((msg->type == JSONRPC_ERROR
|| msg->type == JSONRPC_REPLY)
&& ovsdb_idl_txn_process_reply(idl, msg)) {
}
jsonrpc_msg_destroy(msg);
}
-
- return initial_change_seqno != idl->change_seqno;
}
/* Arranges for poll_block() to wake up when ovsdb_idl_run() has something to
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. */
+/* Returns a "sequence number" that represents the state of 'idl'. When
+ * ovsdb_idl_run() changes the database, the sequence number changes. The
+ * initial fetch of the entire contents of the remote database is considered to
+ * be one kind of change. Successfully acquiring a lock, if one has been
+ * configured with ovsdb_idl_set_lock(), is also considered to be a change.
+ *
+ * As long as the sequence number does not change, the client may continue to
+ * use any data structures it obtains from 'idl'. But when it changes, the
+ * client must not access any of these data structures again, because they
+ * could have freed or reused for other purposes.
+ *
+ * The sequence number can occasionally change even if the database does not.
+ * 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 the IDL already thought was in the database. The database server is
+ * not supposed to do that, but bugs could in theory cause it to do so.) */
unsigned int
ovsdb_idl_get_seqno(const struct ovsdb_idl *idl)
{
{
jsonrpc_session_force_reconnect(idl->session);
}
+
+/* Some IDL users should only write to write-only columns. Furthermore,
+ * writing to a column which is not write-only can cause serious performance
+ * degradations for these users. This function causes 'idl' to reject writes
+ * to columns which are not marked write only using ovsdb_idl_omit_alert(). */
+void
+ovsdb_idl_verify_write_only(struct ovsdb_idl *idl)
+{
+ idl->verify_write_only = true;
+}
\f
static unsigned char *
ovsdb_idl_get_mode(struct ovsdb_idl *idl,
{
size_t i;
- assert(!idl->change_seqno);
+ ovs_assert(!idl->change_seqno);
for (i = 0; i < idl->class->n_tables; i++) {
const struct ovsdb_idl_table *table = &idl->tables[i];
static void
ovsdb_idl_row_clear_old(struct ovsdb_idl_row *row)
{
- assert(row->old == row->new);
+ ovs_assert(row->old == row->new);
if (!ovsdb_idl_row_is_orphan(row)) {
const struct ovsdb_idl_table_class *class = row->table->class;
size_t i;
ovsdb_idl_row_create__(const struct ovsdb_idl_table_class *class)
{
struct ovsdb_idl_row *row = xzalloc(class->allocation_size);
+ class->row_init(row);
list_init(&row->src_arcs);
list_init(&row->dst_arcs);
hmap_node_nullify(&row->txn_node);
const struct ovsdb_idl_table_class *class = row->table->class;
size_t i;
- assert(!row->old && !row->new);
+ ovs_assert(!row->old && !row->new);
row->old = row->new = xmalloc(class->n_columns * sizeof *row->old);
for (i = 0; i < class->n_columns; i++) {
ovsdb_datum_init_default(&row->old[i], &class->columns[i].type);
return &idl->tables[table_class - idl->class->tables];
}
+/* Called by ovsdb-idlc generated code. */
struct ovsdb_idl_row *
ovsdb_idl_get_row_arc(struct ovsdb_idl_row *src,
struct ovsdb_idl_table_class *dst_table_class,
}
}
+/* Searches 'tc''s table in 'idl' for a row with UUID 'uuid'. Returns a
+ * pointer to the row if there is one, otherwise a null pointer. */
const struct ovsdb_idl_row *
ovsdb_idl_get_row_for_uuid(const struct ovsdb_idl *idl,
const struct ovsdb_idl_table_class *tc,
return NULL;
}
+/* Returns a row in 'table_class''s table in 'idl', or a null pointer if that
+ * table is empty.
+ *
+ * Database tables are internally maintained as hash tables, so adding or
+ * removing rows while traversing the same table can cause some rows to be
+ * visited twice or not at apply. */
const struct ovsdb_idl_row *
ovsdb_idl_first_row(const struct ovsdb_idl *idl,
const struct ovsdb_idl_table_class *table_class)
return next_real_row(table, hmap_first(&table->rows));
}
+/* Returns a row following 'row' within its table, or a null pointer if 'row'
+ * is the last row in its table. */
const struct ovsdb_idl_row *
ovsdb_idl_next_row(const struct ovsdb_idl_row *row)
{
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;
+ const struct ovsdb_idl_table_class *class;
+ size_t column_idx;
+
+ ovs_assert(!ovsdb_idl_row_is_synthetic(row));
- assert(row->new != NULL);
- assert(column_idx < class->n_columns);
+ class = row->table->class;
+ column_idx = column - class->columns;
+
+ ovs_assert(row->new != NULL);
+ ovs_assert(column_idx < class->n_columns);
if (row->written && bitmap_is_set(row->written, column_idx)) {
return &row->new[column_idx];
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);
+ ovs_assert(column->type.key.type == key_type);
+ ovs_assert(column->type.value.type == value_type);
return ovsdb_idl_read(row, column);
}
+
+/* Returns false if 'row' was obtained from the IDL, true if it was initialized
+ * to all-zero-bits by some other entity. If 'row' was set up some other way
+ * then the return value is indeterminate. */
+bool
+ovsdb_idl_row_is_synthetic(const struct ovsdb_idl_row *row)
+{
+ return row->table == NULL;
+}
\f
/* Transactions. */
static void ovsdb_idl_txn_complete(struct ovsdb_idl_txn *txn,
enum ovsdb_idl_txn_status);
+/* Returns a string representation of 'status'. The caller must not modify or
+ * free the returned string.
+ *
+ * The return value is probably useful only for debug log messages and unit
+ * tests. */
const char *
ovsdb_idl_txn_status_to_string(enum ovsdb_idl_txn_status status)
{
switch (status) {
+ case TXN_UNCOMMITTED:
+ return "uncommitted";
case TXN_UNCHANGED:
return "unchanged";
case TXN_INCOMPLETE:
return "success";
case TXN_TRY_AGAIN:
return "try again";
+ case TXN_NOT_LOCKED:
+ return "not locked";
case TXN_ERROR:
return "error";
}
return "<unknown>";
}
+/* Starts a new transaction on 'idl'. A given ovsdb_idl may only have a single
+ * active transaction at a time. See the large comment in ovsdb-idl.h for
+ * general information on transactions. */
struct ovsdb_idl_txn *
ovsdb_idl_txn_create(struct ovsdb_idl *idl)
{
struct ovsdb_idl_txn *txn;
- assert(!idl->txn);
+ ovs_assert(!idl->txn);
idl->txn = txn = xmalloc(sizeof *txn);
txn->request_id = NULL;
txn->idl = idl;
hmap_init(&txn->txn_rows);
- txn->status = TXN_INCOMPLETE;
+ txn->status = TXN_UNCOMMITTED;
txn->error = NULL;
txn->dry_run = false;
ds_init(&txn->comment);
+ txn->commit_seqno = txn->idl->change_seqno;
txn->inc_table = NULL;
txn->inc_column = NULL;
- txn->inc_where = NULL;
hmap_init(&txn->inserted_rows);
va_end(args);
}
+/* Marks 'txn' as a transaction that will not actually modify the database. In
+ * almost every way, the transaction is treated like other transactions. It
+ * must be committed or aborted like other transactions, it will be sent to the
+ * database server like other transactions, and so on. The only difference is
+ * that the operations sent to the database server will include, as the last
+ * step, an "abort" operation, so that any changes made by the transaction will
+ * not actually take effect. */
void
ovsdb_idl_txn_set_dry_run(struct ovsdb_idl_txn *txn)
{
txn->dry_run = true;
}
+/* Causes 'txn', when committed, to increment the value of 'column' within
+ * 'row' by 1. 'column' must have an integer type. After 'txn' commits
+ * successfully, the client may retrieve the final (incremented) value of
+ * 'column' with ovsdb_idl_txn_get_increment_new_value().
+ *
+ * The client could accomplish something similar with ovsdb_idl_read(),
+ * ovsdb_idl_txn_verify() and ovsdb_idl_txn_write(), or with ovsdb-idlc
+ * generated wrappers for these functions. However, ovsdb_idl_txn_increment()
+ * will never (by itself) fail because of a verify error.
+ *
+ * The intended use is for incrementing the "next_cfg" column in the
+ * Open_vSwitch table. */
void
-ovsdb_idl_txn_increment(struct ovsdb_idl_txn *txn, const char *table,
- const char *column, const struct json *where)
+ovsdb_idl_txn_increment(struct ovsdb_idl_txn *txn,
+ const struct ovsdb_idl_row *row,
+ const struct ovsdb_idl_column *column)
{
- assert(!txn->inc_table);
- txn->inc_table = xstrdup(table);
- txn->inc_column = xstrdup(column);
- txn->inc_where = where ? json_clone(where) : json_array_create_empty();
+ ovs_assert(!txn->inc_table);
+ ovs_assert(column->type.key.type == OVSDB_TYPE_INTEGER);
+ ovs_assert(column->type.value.type == OVSDB_TYPE_VOID);
+
+ txn->inc_table = row->table->class->name;
+ txn->inc_column = column->name;
+ txn->inc_row = row->uuid;
}
+/* Destroys 'txn' and frees all associated memory. If ovsdb_idl_txn_commit()
+ * has been called for 'txn' but the commit is still incomplete (that is, the
+ * last call returned TXN_INCOMPLETE) then the transaction may or may not still
+ * end up committing at the database server, but the client will not be able to
+ * get any further status information back. */
void
ovsdb_idl_txn_destroy(struct ovsdb_idl_txn *txn)
{
ovsdb_idl_txn_abort(txn);
ds_destroy(&txn->comment);
free(txn->error);
- free(txn->inc_table);
- free(txn->inc_column);
- json_destroy(txn->inc_where);
HMAP_FOR_EACH_SAFE (insert, next, hmap_node, &txn->inserted_rows) {
free(insert);
}
free(txn);
}
+/* Causes poll_block() to wake up if 'txn' has completed committing. */
void
ovsdb_idl_txn_wait(const struct ovsdb_idl_txn *txn)
{
- if (txn->status != TXN_INCOMPLETE) {
+ if (txn->status != TXN_UNCOMMITTED && txn->status != TXN_INCOMPLETE) {
poll_immediate_wake();
}
}
hmap_init(&txn->txn_rows);
}
+/* Attempts to commit 'txn'. Returns the status of the commit operation, one
+ * of the following TXN_* constants:
+ *
+ * TXN_INCOMPLETE:
+ *
+ * The transaction is in progress, but not yet complete. The caller
+ * should call again later, after calling ovsdb_idl_run() to let the IDL
+ * do OVSDB protocol processing.
+ *
+ * TXN_UNCHANGED:
+ *
+ * The transaction is complete. (It didn't actually change the database,
+ * so the IDL didn't send any request to the database server.)
+ *
+ * TXN_ABORTED:
+ *
+ * The caller previously called ovsdb_idl_txn_abort().
+ *
+ * TXN_SUCCESS:
+ *
+ * The transaction was successful. The update made by the transaction
+ * (and possibly other changes made by other database clients) should
+ * already be visible in the IDL.
+ *
+ * TXN_TRY_AGAIN:
+ *
+ * The transaction failed for some transient reason, e.g. because a
+ * "verify" operation reported an inconsistency or due to a network
+ * problem. The caller should wait for a change to the database, then
+ * compose a new transaction, and commit the new transaction.
+ *
+ * Use the return value of ovsdb_idl_get_seqno() to wait for a change in
+ * the database. It is important to use its return value *before* the
+ * initial call to ovsdb_idl_txn_commit() as the baseline for this
+ * purpose, because the change that one should wait for can happen after
+ * the initial call but before the call that returns TXN_TRY_AGAIN, and
+ * using some other baseline value in that situation could cause an
+ * indefinite wait if the database rarely changes.
+ *
+ * TXN_NOT_LOCKED:
+ *
+ * The transaction failed because the IDL has been configured to require
+ * a database lock (with ovsdb_idl_set_lock()) but didn't get it yet or
+ * has already lost it.
+ *
+ * Committing a transaction rolls back all of the changes that it made to the
+ * IDL's copy of the database. If the transaction commits successfully, then
+ * the database server will send an update and, thus, the IDL will be updated
+ * with the committed changes. */
enum ovsdb_idl_txn_status
ovsdb_idl_txn_commit(struct ovsdb_idl_txn *txn)
{
return txn->status;
}
+ /* If we need a lock but don't have it, give up quickly. */
+ if (txn->idl->lock_name && !ovsdb_idl_has_lock(txn->idl)) {
+ txn->status = TXN_NOT_LOCKED;
+ ovsdb_idl_txn_disassemble(txn);
+ return txn->status;
+ }
+
operations = json_array_create_1(
json_string_create(txn->idl->class->database));
+ /* Assert that we have the required lock (avoiding a race). */
+ if (txn->idl->lock_name) {
+ struct json *op = json_object_create();
+ json_array_add(operations, op);
+ json_object_put_string(op, "op", "assert");
+ json_object_put_string(op, "lock", txn->idl->lock_name);
+ }
+
/* Add prerequisites and declarations of new rows. */
HMAP_FOR_EACH (row, txn_node, &txn->txn_rows) {
/* XXX check that deleted rows exist even if no prereqs? */
HMAP_FOR_EACH (row, txn_node, &txn->txn_rows) {
const struct ovsdb_idl_table_class *class = row->table->class;
- if (row->old == row->new) {
- continue;
- } else if (!row->new) {
- struct json *op = json_object_create();
- json_object_put_string(op, "op", "delete");
- json_object_put_string(op, "table", class->name);
- json_object_put(op, "where", where_uuid_equals(&row->uuid));
- json_array_add(operations, op);
- any_updates = true;
- } else {
+ if (!row->new) {
+ if (class->is_root) {
+ struct json *op = json_object_create();
+ json_object_put_string(op, "op", "delete");
+ json_object_put_string(op, "table", class->name);
+ json_object_put(op, "where", where_uuid_equals(&row->uuid));
+ json_array_add(operations, op);
+ any_updates = true;
+ } else {
+ /* Let ovsdb-server decide whether to really delete it. */
+ }
+ } else if (row->old != row->new) {
struct json *row_json;
struct json *op;
size_t idx;
} else {
struct ovsdb_idl_txn_insert *insert;
+ any_updates = true;
+
json_object_put(op, "uuid-name",
json_string_create_nocopy(
uuid_name_from_uuid(&row->uuid)));
&class->columns[idx];
if (row->old
- ? !ovsdb_datum_equals(&row->old[idx], &row->new[idx],
- &column->type)
- : !ovsdb_datum_is_default(&row->new[idx],
+ || !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 anything really changed, consider it an update.
+ * We can't suppress not-really-changed values earlier
+ * or transactions would become nonatomic (see the big
+ * comment inside ovsdb_idl_txn_write()). */
+ if (!any_updates && row->old &&
+ !ovsdb_datum_equals(&row->old[idx], &row->new[idx],
+ &column->type)) {
+ any_updates = true;
+ }
}
}
}
if (!row->old || !shash_is_empty(json_object(row_json))) {
json_array_add(operations, op);
- any_updates = true;
} else {
json_destroy(op);
}
json_object_put_string(op, "op", "mutate");
json_object_put_string(op, "table", txn->inc_table);
json_object_put(op, "where",
- substitute_uuids(json_clone(txn->inc_where), txn));
+ substitute_uuids(where_uuid_equals(&txn->inc_row),
+ txn));
json_object_put(op, "mutations",
json_array_create_1(
json_array_create_3(
json_object_put_string(op, "op", "select");
json_object_put_string(op, "table", txn->inc_table);
json_object_put(op, "where",
- substitute_uuids(json_clone(txn->inc_where), txn));
+ substitute_uuids(where_uuid_equals(&txn->inc_row),
+ txn));
json_object_put(op, "columns",
json_array_create_1(json_string_create(
txn->inc_column)));
"transact", operations, &txn->request_id))) {
hmap_insert(&txn->idl->outstanding_txns, &txn->hmap_node,
json_hash(txn->request_id, 0));
+ txn->status = TXN_INCOMPLETE;
} else {
txn->status = TXN_TRY_AGAIN;
}
/* Attempts to commit 'txn', blocking until the commit either succeeds or
* fails. Returns the final commit status, which may be any TXN_* value other
- * than TXN_INCOMPLETE. */
+ * than TXN_INCOMPLETE.
+ *
+ * This function calls ovsdb_idl_run() on 'txn''s IDL, so it may cause the
+ * return value of ovsdb_idl_get_seqno() to change. */
enum ovsdb_idl_txn_status
ovsdb_idl_txn_commit_block(struct ovsdb_idl_txn *txn)
{
return status;
}
+/* Returns the final (incremented) value of the column in 'txn' that was set to
+ * be incremented by ovsdb_idl_txn_increment(). 'txn' must have committed
+ * successfully. */
int64_t
ovsdb_idl_txn_get_increment_new_value(const struct ovsdb_idl_txn *txn)
{
- assert(txn->status == TXN_SUCCESS);
+ ovs_assert(txn->status == TXN_SUCCESS);
return txn->inc_new_value;
}
+/* Aborts 'txn' without sending it to the database server. This is effective
+ * only if ovsdb_idl_txn_commit() has not yet been called for 'txn'.
+ * Otherwise, it has no effect.
+ *
+ * Aborting a transaction doesn't free its memory. Use
+ * ovsdb_idl_txn_destroy() to do that. */
void
ovsdb_idl_txn_abort(struct ovsdb_idl_txn *txn)
{
ovsdb_idl_txn_disassemble(txn);
- if (txn->status == TXN_INCOMPLETE) {
+ if (txn->status == TXN_UNCOMMITTED || txn->status == TXN_INCOMPLETE) {
txn->status = TXN_ABORTED;
}
}
+/* Returns a string that reports the error status for 'txn'. The caller must
+ * not modify or free the returned string. A call to ovsdb_idl_txn_destroy()
+ * for 'txn' may free the returned string.
+ *
+ * The return value is ordinarily one of the strings that
+ * ovsdb_idl_txn_status_to_string() would return, but if the transaction failed
+ * due to an error reported by the database server, the return value is that
+ * error. */
const char *
ovsdb_idl_txn_get_error(const struct ovsdb_idl_txn *txn)
{
{
const struct ovsdb_idl_txn_insert *insert;
- assert(txn->status == TXN_SUCCESS || txn->status == TXN_UNCHANGED);
+ ovs_assert(txn->status == TXN_SUCCESS || txn->status == TXN_UNCHANGED);
HMAP_FOR_EACH_IN_BUCKET (insert, hmap_node,
uuid_hash(uuid), &txn->inserted_rows) {
if (uuid_equals(uuid, &insert->dummy)) {
* been disabled (by calling ovsdb_idl_omit()).
*
* Usually this function is used indirectly through one of the "set" functions
- * generated by ovsdb-idlc. */
+ * generated by ovsdb-idlc.
+ *
+ * Takes ownership of what 'datum' points to (and in some cases destroys that
+ * data before returning) but makes a copy of 'datum' itself. (Commonly
+ * 'datum' is on the caller's stack.) */
void
ovsdb_idl_txn_write(const struct ovsdb_idl_row *row_,
const struct ovsdb_idl_column *column,
struct ovsdb_datum *datum)
{
- struct ovsdb_idl_row *row = (struct ovsdb_idl_row *) row_;
- const struct ovsdb_idl_table_class *class = row->table->class;
- size_t column_idx = column - class->columns;
+ struct ovsdb_idl_row *row = CONST_CAST(struct ovsdb_idl_row *, row_);
+ const struct ovsdb_idl_table_class *class;
+ size_t column_idx;
+ bool write_only;
+
+ if (ovsdb_idl_row_is_synthetic(row)) {
+ ovsdb_datum_destroy(datum, &column->type);
+ return;
+ }
+
+ class = row->table->class;
+ column_idx = column - class->columns;
+ write_only = row->table->modes[column_idx] == OVSDB_IDL_MONITOR;
+
+ ovs_assert(row->new != NULL);
+ ovs_assert(column_idx < class->n_columns);
+ ovs_assert(row->old == NULL ||
+ row->table->modes[column_idx] & OVSDB_IDL_MONITOR);
+
+ if (row->table->idl->verify_write_only && !write_only) {
+ VLOG_ERR("Bug: Attempt to write to a read/write column (%s:%s) when"
+ " explicitly configured not to.", class->name, column->name);
+ ovsdb_datum_destroy(datum, &column->type);
+ return;
+ }
- assert(row->new != NULL);
- assert(column_idx < class->n_columns);
- assert(row->old == NULL ||
- row->table->modes[column_idx] & OVSDB_IDL_MONITOR);
+ /* If this is a write-only column and the datum being written is the same
+ * as the one already there, just skip the update entirely. This is worth
+ * optimizing because we have a lot of columns that get periodically
+ * refreshed into the database but don't actually change that often.
+ *
+ * We don't do this for read/write columns because that would break
+ * atomicity of transactions--some other client might have written a
+ * different value in that column since we read it. (But if a whole
+ * transaction only does writes of existing values, without making any real
+ * changes, we will drop the whole transaction later in
+ * ovsdb_idl_txn_commit().) */
+ if (write_only && ovsdb_datum_equals(ovsdb_idl_read(row, column),
+ datum, &column->type)) {
+ ovsdb_datum_destroy(datum, &column->type);
+ return;
+ }
if (hmap_node_is_null(&row->txn_node)) {
hmap_insert(&row->table->idl->txn->txn_rows, &row->txn_node,
* prerequisite to completing the transaction. That is, if 'column' in 'row_'
* changed (or if 'row_' was deleted) between the time that the IDL originally
* read its contents and the time that the transaction commits, then the
- * transaction aborts and ovsdb_idl_txn_commit() returns TXN_TRY_AGAIN.
+ * transaction aborts and ovsdb_idl_txn_commit() returns TXN_AGAIN_WAIT or
+ * TXN_AGAIN_NOW (depending on whether the database change has already been
+ * received).
*
* The intention is that, to ensure that no transaction commits based on dirty
* reads, an application should call ovsdb_idl_txn_verify() on each data item
ovsdb_idl_txn_verify(const struct ovsdb_idl_row *row_,
const struct ovsdb_idl_column *column)
{
- struct ovsdb_idl_row *row = (struct ovsdb_idl_row *) row_;
- const struct ovsdb_idl_table_class *class = row->table->class;
- size_t column_idx = column - class->columns;
+ struct ovsdb_idl_row *row = CONST_CAST(struct ovsdb_idl_row *, row_);
+ const struct ovsdb_idl_table_class *class;
+ size_t column_idx;
- assert(row->new != NULL);
- assert(row->old == NULL ||
- row->table->modes[column_idx] & OVSDB_IDL_MONITOR);
+ if (ovsdb_idl_row_is_synthetic(row)) {
+ return;
+ }
+
+ class = row->table->class;
+ column_idx = column - class->columns;
+
+ ovs_assert(row->new != NULL);
+ ovs_assert(row->old == NULL ||
+ row->table->modes[column_idx] & OVSDB_IDL_MONITOR);
if (!row->old
|| (row->written && bitmap_is_set(row->written, column_idx))) {
return;
void
ovsdb_idl_txn_delete(const struct ovsdb_idl_row *row_)
{
- struct ovsdb_idl_row *row = (struct ovsdb_idl_row *) row_;
+ struct ovsdb_idl_row *row = CONST_CAST(struct ovsdb_idl_row *, row_);
- assert(row->new != NULL);
+ if (ovsdb_idl_row_is_synthetic(row)) {
+ return;
+ }
+
+ ovs_assert(row->new != NULL);
if (!row->old) {
ovsdb_idl_row_unparse(row);
ovsdb_idl_row_clear_new(row);
- assert(!row->prereqs);
+ ovs_assert(!row->prereqs);
hmap_remove(&row->table->rows, &row->hmap_node);
hmap_remove(&row->table->idl->txn->txn_rows, &row->txn_node);
free(row);
struct ovsdb_idl_row *row = ovsdb_idl_row_create__(class);
if (uuid) {
- assert(!ovsdb_idl_txn_get_row(txn, uuid));
+ ovs_assert(!ovsdb_idl_txn_get_row(txn, uuid));
row->uuid = *uuid;
} else {
uuid_generate(&row->uuid);
struct json_array *ops = &msg->result->u.array;
int hard_errors = 0;
int soft_errors = 0;
+ int lock_errors = 0;
size_t i;
for (i = 0; i < ops->n; i++) {
if (error->type == JSON_STRING) {
if (!strcmp(error->u.string, "timed out")) {
soft_errors++;
+ } else if (!strcmp(error->u.string, "not owner")) {
+ lock_errors++;
} else if (strcmp(error->u.string, "aborted")) {
hard_errors++;
ovsdb_idl_txn_set_error_json(txn, op);
}
}
- if (!soft_errors && !hard_errors) {
+ if (!soft_errors && !hard_errors && !lock_errors) {
struct ovsdb_idl_txn_insert *insert;
if (txn->inc_table && !ovsdb_idl_txn_process_inc_reply(txn, ops)) {
}
status = (hard_errors ? TXN_ERROR
+ : lock_errors ? TXN_NOT_LOCKED
: soft_errors ? TXN_TRY_AGAIN
: TXN_SUCCESS);
}
return true;
}
+/* Returns the transaction currently active for 'row''s IDL. A transaction
+ * must currently be active. */
struct ovsdb_idl_txn *
ovsdb_idl_txn_get(const struct ovsdb_idl_row *row)
{
struct ovsdb_idl_txn *txn = row->table->idl->txn;
- assert(txn != NULL);
+ ovs_assert(txn != NULL);
return txn;
}
+/* Returns the IDL on which 'txn' acts. */
struct ovsdb_idl *
ovsdb_idl_txn_get_idl (struct ovsdb_idl_txn *txn)
{
return txn->idl;
}
+\f
+/* If 'lock_name' is nonnull, configures 'idl' to obtain the named lock from
+ * the database server and to avoid modifying the database when the lock cannot
+ * be acquired (that is, when another client has the same lock).
+ *
+ * If 'lock_name' is NULL, drops the locking requirement and releases the
+ * lock. */
+void
+ovsdb_idl_set_lock(struct ovsdb_idl *idl, const char *lock_name)
+{
+ ovs_assert(!idl->txn);
+ ovs_assert(hmap_is_empty(&idl->outstanding_txns));
+
+ if (idl->lock_name && (!lock_name || strcmp(lock_name, idl->lock_name))) {
+ /* Release previous lock. */
+ ovsdb_idl_send_unlock_request(idl);
+ free(idl->lock_name);
+ idl->lock_name = NULL;
+ idl->is_lock_contended = false;
+ }
+
+ if (lock_name && !idl->lock_name) {
+ /* Acquire new lock. */
+ idl->lock_name = xstrdup(lock_name);
+ ovsdb_idl_send_lock_request(idl);
+ }
+}
+/* Returns true if 'idl' is configured to obtain a lock and owns that lock.
+ *
+ * Locking and unlocking happens asynchronously from the database client's
+ * point of view, so the information is only useful for optimization (e.g. if
+ * the client doesn't have the lock then there's no point in trying to write to
+ * the database). */
+bool
+ovsdb_idl_has_lock(const struct ovsdb_idl *idl)
+{
+ return idl->has_lock;
+}
+
+/* Returns true if 'idl' is configured to obtain a lock but the database server
+ * has indicated that some other client already owns the requested lock. */
+bool
+ovsdb_idl_is_lock_contended(const struct ovsdb_idl *idl)
+{
+ return idl->is_lock_contended;
+}
+
+static void
+ovsdb_idl_update_has_lock(struct ovsdb_idl *idl, bool new_has_lock)
+{
+ if (new_has_lock && !idl->has_lock) {
+ if (!idl->monitor_request_id) {
+ idl->change_seqno++;
+ } else {
+ /* We're waiting for a monitor reply, so don't signal that the
+ * database changed. The monitor reply will increment change_seqno
+ * anyhow. */
+ }
+ idl->is_lock_contended = false;
+ }
+ idl->has_lock = new_has_lock;
+}
+
+static void
+ovsdb_idl_send_lock_request__(struct ovsdb_idl *idl, const char *method,
+ struct json **idp)
+{
+ ovsdb_idl_update_has_lock(idl, false);
+
+ json_destroy(idl->lock_request_id);
+ idl->lock_request_id = NULL;
+
+ if (jsonrpc_session_is_connected(idl->session)) {
+ struct json *params;
+
+ params = json_array_create_1(json_string_create(idl->lock_name));
+ jsonrpc_session_send(idl->session,
+ jsonrpc_create_request(method, params, idp));
+ }
+}
+
+static void
+ovsdb_idl_send_lock_request(struct ovsdb_idl *idl)
+{
+ ovsdb_idl_send_lock_request__(idl, "lock", &idl->lock_request_id);
+}
+
+static void
+ovsdb_idl_send_unlock_request(struct ovsdb_idl *idl)
+{
+ ovsdb_idl_send_lock_request__(idl, "unlock", NULL);
+}
+
+static void
+ovsdb_idl_parse_lock_reply(struct ovsdb_idl *idl, const struct json *result)
+{
+ bool got_lock;
+
+ json_destroy(idl->lock_request_id);
+ idl->lock_request_id = NULL;
+
+ if (result->type == JSON_OBJECT) {
+ const struct json *locked;
+
+ locked = shash_find_data(json_object(result), "locked");
+ got_lock = locked && locked->type == JSON_TRUE;
+ } else {
+ got_lock = false;
+ }
+
+ ovsdb_idl_update_has_lock(idl, got_lock);
+ if (!got_lock) {
+ idl->is_lock_contended = true;
+ }
+}
+
+static void
+ovsdb_idl_parse_lock_notify(struct ovsdb_idl *idl,
+ const struct json *params,
+ bool new_has_lock)
+{
+ if (idl->lock_name
+ && params->type == JSON_ARRAY
+ && json_array(params)->n > 0
+ && json_array(params)->elems[0]->type == JSON_STRING) {
+ const char *lock_name = json_string(json_array(params)->elems[0]);
+
+ if (!strcmp(idl->lock_name, lock_name)) {
+ ovsdb_idl_update_has_lock(idl, new_has_lock);
+ if (!new_has_lock) {
+ idl->is_lock_contended = true;
+ }
+ }
+ }
+}