X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ovsdb%2Ftransaction.c;h=be40df9a853e2089c2ccc863b0ecbcc99f2f24e8;hb=c5cf10598f8c9f4428291e9df3ecd72a05fb1ccf;hp=b26705a3ab2304d16c5260cb780760866c1e5690;hpb=4e8e4213a815a30216e855a805a8bcd5b8c5a886;p=sliver-openvswitch.git diff --git a/ovsdb/transaction.c b/ovsdb/transaction.c index b26705a3a..be40df9a8 100644 --- a/ovsdb/transaction.c +++ b/ovsdb/transaction.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2009, 2010 Nicira Networks +/* Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,8 +17,6 @@ #include "transaction.h" -#include - #include "bitmap.h" #include "dynamic-string.h" #include "hash.h" @@ -43,6 +41,11 @@ struct ovsdb_txn_table { struct ovsdb_table *table; struct hmap txn_rows; /* Contains "struct ovsdb_txn_row"s. */ + /* This has the same form as the 'indexes' member of struct ovsdb_table, + * but it is only used or updated at transaction commit time, from + * check_index_uniqueness(). */ + struct hmap *txn_indexes; + /* Used by for_each_txn_row(). */ unsigned int serial; /* Serial number of in-progress iteration. */ unsigned int n_processed; /* Number of rows processed. */ @@ -57,9 +60,11 @@ struct ovsdb_txn_table { * * - A row modified by a transaction will have non-null 'old' and 'new'. * - * - 'old' and 'new' both null is invalid. It would indicate that a row - * was added then deleted within a single transaction, but we instead - * handle that case by deleting the txn_row entirely. + * - 'old' and 'new' both null indicates that a row was added then deleted + * within a single transaction. Most of the time we instead delete the + * ovsdb_txn_row entirely, but inside a for_each_txn_row() callback + * there are restrictions that sometimes mean we have to leave the + * ovsdb_txn_row in place. */ struct ovsdb_txn_row { struct hmap_node hmap_node; /* In ovsdb_txn_table's txn_rows hmap. */ @@ -67,12 +72,20 @@ struct ovsdb_txn_row { struct ovsdb_row *new; /* The new row. */ size_t n_refs; /* Number of remaining references. */ + /* These members are the same as the corresponding members of 'old' or + * 'new'. They are present here for convenience and because occasionally + * there can be an ovsdb_txn_row where both 'old' and 'new' are NULL. */ + struct uuid uuid; + struct ovsdb_table *table; + /* Used by for_each_txn_row(). */ unsigned int serial; /* Serial number of in-progress commit. */ unsigned long changed[]; /* Bits set to 1 for columns that changed. */ }; +static struct ovsdb_error * WARN_UNUSED_RESULT +delete_garbage_row(struct ovsdb_txn *txn, struct ovsdb_txn_row *r); static void ovsdb_txn_row_prefree(struct ovsdb_txn_row *); static struct ovsdb_error * WARN_UNUSED_RESULT for_each_txn_row(struct ovsdb_txn *txn, @@ -96,7 +109,7 @@ ovsdb_txn_create(struct ovsdb *db) static void ovsdb_txn_free(struct ovsdb_txn *txn) { - assert(list_is_empty(&txn->txn_tables)); + ovs_assert(list_is_empty(&txn->txn_tables)); ds_destroy(&txn->comment); free(txn); } @@ -110,7 +123,9 @@ ovsdb_txn_row_abort(struct ovsdb_txn *txn OVS_UNUSED, ovsdb_txn_row_prefree(txn_row); if (!old) { - hmap_remove(&new->table->rows, &new->hmap_node); + if (new) { + hmap_remove(&new->table->rows, &new->hmap_node); + } } else if (!new) { hmap_insert(&old->table->rows, &old->hmap_node, ovsdb_row_hash(old)); } else { @@ -122,6 +137,33 @@ ovsdb_txn_row_abort(struct ovsdb_txn *txn OVS_UNUSED, return NULL; } +/* Returns the offset in bytes from the start of an ovsdb_row for 'table' to + * the hmap_node for the index numbered 'i'. */ +static size_t +ovsdb_row_index_offset__(const struct ovsdb_table *table, size_t i) +{ + size_t n_fields = shash_count(&table->schema->columns); + return (offsetof(struct ovsdb_row, fields) + + n_fields * sizeof(struct ovsdb_datum) + + i * sizeof(struct hmap_node)); +} + +/* Returns the hmap_node in 'row' for the index numbered 'i'. */ +static struct hmap_node * +ovsdb_row_get_index_node(struct ovsdb_row *row, size_t i) +{ + return (void *) ((char *) row + ovsdb_row_index_offset__(row->table, i)); +} + +/* Returns the ovsdb_row given 'index_node', which is a pointer to that row's + * hmap_node for the index numbered 'i' within 'table'. */ +static struct ovsdb_row * +ovsdb_row_from_index_node(struct hmap_node *index_node, + const struct ovsdb_table *table, size_t i) +{ + return (void *) ((char *) index_node - ovsdb_row_index_offset__(table, i)); +} + void ovsdb_txn_abort(struct ovsdb_txn *txn) { @@ -140,10 +182,7 @@ find_txn_row(const struct ovsdb_table *table, const struct uuid *uuid) HMAP_FOR_EACH_WITH_HASH (txn_row, hmap_node, uuid_hash(uuid), &table->txn_table->txn_rows) { - const struct ovsdb_row *row; - - row = txn_row->old ? txn_row->old : txn_row->new; - if (uuid_equals(uuid, ovsdb_row_get_uuid(row))) { + if (uuid_equals(uuid, &txn_row->uuid)) { return txn_row; } } @@ -151,6 +190,20 @@ find_txn_row(const struct ovsdb_table *table, const struct uuid *uuid) return NULL; } +static struct ovsdb_txn_row * +find_or_make_txn_row(struct ovsdb_txn *txn, const struct ovsdb_table *table, + const struct uuid *uuid) +{ + struct ovsdb_txn_row *txn_row = find_txn_row(table, uuid); + if (!txn_row) { + const struct ovsdb_row *row = ovsdb_table_get_row(table, uuid); + if (row) { + txn_row = ovsdb_txn_row_modify(txn, row)->txn_row; + } + } + return txn_row; +} + static struct ovsdb_error * WARN_UNUSED_RESULT ovsdb_txn_adjust_atom_refs(struct ovsdb_txn *txn, const struct ovsdb_row *r, const struct ovsdb_column *c, @@ -168,20 +221,22 @@ ovsdb_txn_adjust_atom_refs(struct ovsdb_txn *txn, const struct ovsdb_row *r, table = base->u.uuid.refTable; for (i = 0; i < n; i++) { const struct uuid *uuid = &atoms[i].uuid; - struct ovsdb_txn_row *txn_row = find_txn_row(table, uuid); + struct ovsdb_txn_row *txn_row; + + if (uuid_equals(uuid, ovsdb_row_get_uuid(r))) { + /* Self-references don't count. */ + continue; + } + + txn_row = find_or_make_txn_row(txn, table, uuid); if (!txn_row) { - const struct ovsdb_row *row = ovsdb_table_get_row(table, uuid); - if (row) { - txn_row = ovsdb_txn_row_modify(txn, row)->txn_row; - } else { - return ovsdb_error("referential integrity violation", - "Table %s column %s row "UUID_FMT" " - "references nonexistent row "UUID_FMT" in " - "table %s.", - r->table->schema->name, c->name, - UUID_ARGS(ovsdb_row_get_uuid(r)), - UUID_ARGS(uuid), table->schema->name); - } + return ovsdb_error("referential integrity violation", + "Table %s column %s row "UUID_FMT" " + "references nonexistent row "UUID_FMT" in " + "table %s.", + r->table->schema->name, c->name, + UUID_ARGS(ovsdb_row_get_uuid(r)), + UUID_ARGS(uuid), table->schema->name); } txn_row->n_refs += delta; } @@ -208,7 +263,7 @@ ovsdb_txn_adjust_row_refs(struct ovsdb_txn *txn, const struct ovsdb_row *r, static struct ovsdb_error * WARN_UNUSED_RESULT update_row_ref_count(struct ovsdb_txn *txn, struct ovsdb_txn_row *r) { - struct ovsdb_table *table = r->old ? r->old->table : r->new->table; + struct ovsdb_table *table = r->table; struct shash_node *node; SHASH_FOR_EACH (node, &table->schema->columns) { @@ -218,8 +273,7 @@ update_row_ref_count(struct ovsdb_txn *txn, struct ovsdb_txn_row *r) if (r->old) { error = ovsdb_txn_adjust_row_refs(txn, r->old, column, -1); if (error) { - ovsdb_error_destroy(error); - return OVSDB_BUG("error decreasing refcount"); + return OVSDB_WRAP_BUG("error decreasing refcount", error); } } if (r->new) { @@ -241,13 +295,98 @@ check_ref_count(struct ovsdb_txn *txn OVS_UNUSED, struct ovsdb_txn_row *r) } else { return ovsdb_error("referential integrity violation", "cannot delete %s row "UUID_FMT" because " - "of %zu remaining reference(s)", - r->old->table->schema->name, - UUID_ARGS(ovsdb_row_get_uuid(r->old)), + "of %"PRIuSIZE" remaining reference(s)", + r->table->schema->name, UUID_ARGS(&r->uuid), r->n_refs); } } +static struct ovsdb_error * WARN_UNUSED_RESULT +delete_row_refs(struct ovsdb_txn *txn, const struct ovsdb_row *row, + const struct ovsdb_base_type *base, + const union ovsdb_atom *atoms, unsigned int n) +{ + const struct ovsdb_table *table; + unsigned int i; + + if (!ovsdb_base_type_is_strong_ref(base)) { + return NULL; + } + + table = base->u.uuid.refTable; + for (i = 0; i < n; i++) { + const struct uuid *uuid = &atoms[i].uuid; + struct ovsdb_txn_row *txn_row; + + if (uuid_equals(uuid, ovsdb_row_get_uuid(row))) { + /* Self-references don't count. */ + continue; + } + + txn_row = find_or_make_txn_row(txn, table, uuid); + if (!txn_row) { + return OVSDB_BUG("strong ref target missing"); + } else if (!txn_row->n_refs) { + return OVSDB_BUG("strong ref target has zero n_refs"); + } else if (!txn_row->new) { + return OVSDB_BUG("deleted strong ref target"); + } + + if (--txn_row->n_refs == 0) { + struct ovsdb_error *error = delete_garbage_row(txn, txn_row); + if (error) { + return error; + } + } + } + + return NULL; +} + +static struct ovsdb_error * WARN_UNUSED_RESULT +delete_garbage_row(struct ovsdb_txn *txn, struct ovsdb_txn_row *txn_row) +{ + struct shash_node *node; + struct ovsdb_row *row; + + if (txn_row->table->schema->is_root) { + return NULL; + } + + row = txn_row->new; + txn_row->new = NULL; + hmap_remove(&txn_row->table->rows, &row->hmap_node); + SHASH_FOR_EACH (node, &txn_row->table->schema->columns) { + const struct ovsdb_column *column = node->data; + const struct ovsdb_datum *field = &row->fields[column->index]; + struct ovsdb_error *error; + + error = delete_row_refs(txn, row, + &column->type.key, field->keys, field->n); + if (error) { + return error; + } + + error = delete_row_refs(txn, row, + &column->type.value, field->values, field->n); + if (error) { + return error; + } + } + ovsdb_row_destroy(row); + + return NULL; +} + +static struct ovsdb_error * WARN_UNUSED_RESULT +collect_garbage(struct ovsdb_txn *txn, struct ovsdb_txn_row *txn_row) +{ + if (txn_row->new && !txn_row->n_refs) { + return delete_garbage_row(txn, txn_row); + } + return NULL; +} + static struct ovsdb_error * WARN_UNUSED_RESULT update_ref_counts(struct ovsdb_txn *txn) { @@ -265,6 +404,25 @@ static struct ovsdb_error * ovsdb_txn_row_commit(struct ovsdb_txn *txn OVS_UNUSED, struct ovsdb_txn_row *txn_row) { + size_t n_indexes = txn_row->table->schema->n_indexes; + + if (txn_row->old) { + size_t i; + + for (i = 0; i < n_indexes; i++) { + struct hmap_node *node = ovsdb_row_get_index_node(txn_row->old, i); + hmap_remove(&txn_row->table->indexes[i], node); + } + } + if (txn_row->new) { + size_t i; + + for (i = 0; i < n_indexes; i++) { + struct hmap_node *node = ovsdb_row_get_index_node(txn_row->new, i); + hmap_insert(&txn_row->table->indexes[i], node, node->hash); + } + } + ovsdb_txn_row_prefree(txn_row); if (txn_row->new) { txn_row->new->n_refs = txn_row->n_refs; @@ -279,8 +437,8 @@ static void add_weak_ref(struct ovsdb_txn *txn, const struct ovsdb_row *src_, const struct ovsdb_row *dst_) { - struct ovsdb_row *src = (struct ovsdb_row *) src_; - struct ovsdb_row *dst = (struct ovsdb_row *) dst_; + struct ovsdb_row *src = CONST_CAST(struct ovsdb_row *, src_); + struct ovsdb_row *dst = CONST_CAST(struct ovsdb_row *, dst_); struct ovsdb_weak_ref *weak; if (src == dst) { @@ -329,7 +487,7 @@ assess_weak_refs(struct ovsdb_txn *txn, struct ovsdb_txn_row *txn_row) return NULL; } - table = txn_row->new->table; + table = txn_row->table; SHASH_FOR_EACH (node, &table->schema->columns) { const struct ovsdb_column *column = node->data; struct ovsdb_datum *datum = &txn_row->new->fields[column->index]; @@ -375,6 +533,7 @@ assess_weak_refs(struct ovsdb_txn *txn, struct ovsdb_txn_row *txn_row) } if (datum->n != orig_n) { + bitmap_set1(txn_row->changed, OVSDB_COL_VERSION); bitmap_set1(txn_row->changed, column->index); ovsdb_datum_sort_assert(datum, column->type.key.type); if (datum->n < column->type.n_min) { @@ -413,9 +572,8 @@ assess_weak_refs(struct ovsdb_txn *txn, struct ovsdb_txn_row *txn_row) static struct ovsdb_error * WARN_UNUSED_RESULT determine_changes(struct ovsdb_txn *txn, struct ovsdb_txn_row *txn_row) { - struct ovsdb_table *table; + struct ovsdb_table *table = txn_row->table; - table = (txn_row->old ? txn_row->old : txn_row->new)->table; if (txn_row->old && txn_row->new) { struct shash_node *node; bool changed = false; @@ -457,7 +615,7 @@ check_max_rows(struct ovsdb_txn *txn) if (n_rows > max_rows) { return ovsdb_error("constraint violation", "transaction causes \"%s\" table to contain " - "%zu rows, greater than the schema-defined " + "%"PRIuSIZE" rows, greater than the schema-defined " "limit of %u row(s)", t->table->schema->name, n_rows, max_rows); } @@ -466,6 +624,129 @@ check_max_rows(struct ovsdb_txn *txn) return NULL; } +static struct ovsdb_row * +ovsdb_index_search(struct hmap *index, struct ovsdb_row *row, size_t i, + uint32_t hash) +{ + const struct ovsdb_table *table = row->table; + const struct ovsdb_column_set *columns = &table->schema->indexes[i]; + struct hmap_node *node; + + for (node = hmap_first_with_hash(index, hash); node; + node = hmap_next_with_hash(node)) { + struct ovsdb_row *irow = ovsdb_row_from_index_node(node, table, i); + if (ovsdb_row_equal_columns(row, irow, columns)) { + return irow; + } + } + + return NULL; +} + +static void +duplicate_index_row__(const struct ovsdb_column_set *index, + const struct ovsdb_row *row, + const char *title, + struct ds *out) +{ + size_t n_columns = shash_count(&row->table->schema->columns); + + ds_put_format(out, "%s row, with UUID "UUID_FMT", ", + title, UUID_ARGS(ovsdb_row_get_uuid(row))); + if (!row->txn_row + || bitmap_scan(row->txn_row->changed, 1, 0, n_columns) == n_columns) { + ds_put_cstr(out, "existed in the database before this " + "transaction and was not modified by the transaction."); + } else if (!row->txn_row->old) { + ds_put_cstr(out, "was inserted by this transaction."); + } else if (ovsdb_row_equal_columns(row->txn_row->old, + row->txn_row->new, index)) { + ds_put_cstr(out, "existed in the database before this " + "transaction, which modified some of the row's columns " + "but not any columns in this index."); + } else { + ds_put_cstr(out, "had the following index values before the " + "transaction: "); + ovsdb_row_columns_to_string(row->txn_row->old, index, out); + ds_put_char(out, '.'); + } +} + +static struct ovsdb_error * WARN_UNUSED_RESULT +duplicate_index_row(const struct ovsdb_column_set *index, + const struct ovsdb_row *a, + const struct ovsdb_row *b) +{ + struct ovsdb_column_set all_columns; + struct ovsdb_error *error; + char *index_s; + struct ds s; + + /* Put 'a' and 'b' in a predictable order to make error messages + * reproducible for testing. */ + ovsdb_column_set_init(&all_columns); + ovsdb_column_set_add_all(&all_columns, a->table); + if (ovsdb_row_compare_columns_3way(a, b, &all_columns) < 0) { + const struct ovsdb_row *tmp = a; + a = b; + b = tmp; + } + ovsdb_column_set_destroy(&all_columns); + + index_s = ovsdb_column_set_to_string(index); + + ds_init(&s); + ds_put_format(&s, "Transaction causes multiple rows in \"%s\" table to " + "have identical values (", a->table->schema->name); + ovsdb_row_columns_to_string(a, index, &s); + ds_put_format(&s, ") for index on %s. ", index_s); + duplicate_index_row__(index, a, "First", &s); + ds_put_cstr(&s, " "); + duplicate_index_row__(index, b, "Second", &s); + + free(index_s); + + error = ovsdb_error("constraint violation", "%s", ds_cstr(&s)); + ds_destroy(&s); + return error; +} + +static struct ovsdb_error * WARN_UNUSED_RESULT +check_index_uniqueness(struct ovsdb_txn *txn OVS_UNUSED, + struct ovsdb_txn_row *txn_row) +{ + struct ovsdb_txn_table *txn_table = txn_row->table->txn_table; + struct ovsdb_table *table = txn_row->table; + struct ovsdb_row *row = txn_row->new; + size_t i; + + if (!row) { + return NULL; + } + + for (i = 0; i < table->schema->n_indexes; i++) { + const struct ovsdb_column_set *index = &table->schema->indexes[i]; + struct ovsdb_row *irow; + uint32_t hash; + + hash = ovsdb_row_hash_columns(row, index, 0); + irow = ovsdb_index_search(&txn_table->txn_indexes[i], row, i, hash); + if (irow) { + return duplicate_index_row(index, irow, row); + } + + irow = ovsdb_index_search(&table->indexes[i], row, i, hash); + if (irow && !irow->txn_row) { + return duplicate_index_row(index, irow, row); + } + + hmap_insert(&txn_table->txn_indexes[i], + ovsdb_row_get_index_node(row, i), hash); + } + + return NULL; +} + struct ovsdb_error * ovsdb_txn_commit(struct ovsdb_txn *txn, bool durable) { @@ -476,29 +757,35 @@ ovsdb_txn_commit(struct ovsdb_txn *txn, bool durable) * was really a no-op. */ error = for_each_txn_row(txn, determine_changes); if (error) { - ovsdb_error_destroy(error); - return OVSDB_BUG("can't happen"); + return OVSDB_WRAP_BUG("can't happen", error); } if (list_is_empty(&txn->txn_tables)) { ovsdb_txn_abort(txn); return NULL; } - /* Check maximum rows table constraints. */ - error = check_max_rows(txn); + /* Update reference counts and check referential integrity. */ + error = update_ref_counts(txn); if (error) { ovsdb_txn_abort(txn); return error; } - /* Update reference counts and check referential integrity. */ - error = update_ref_counts(txn); + /* Delete unreferenced, non-root rows. */ + error = for_each_txn_row(txn, collect_garbage); + if (error) { + ovsdb_txn_abort(txn); + return OVSDB_WRAP_BUG("can't happen", error); + } + + /* Check maximum rows table constraints. */ + error = check_max_rows(txn); if (error) { ovsdb_txn_abort(txn); return error; } - /* Check reference counts and remove bad reference for "weak" referential + /* Check reference counts and remove bad references for "weak" referential * integrity. */ error = for_each_txn_row(txn, assess_weak_refs); if (error) { @@ -506,13 +793,20 @@ ovsdb_txn_commit(struct ovsdb_txn *txn, bool durable) return error; } + /* Verify that the indexes will still be unique post-transaction. */ + error = for_each_txn_row(txn, check_index_uniqueness); + if (error) { + ovsdb_txn_abort(txn); + return error; + } + /* Send the commit to each replica. */ LIST_FOR_EACH (replica, node, &txn->db->replicas) { error = (replica->class->commit)(replica, txn, durable); if (error) { /* We don't support two-phase commit so only the first replica is * allowed to report an error. */ - assert(&replica->node == txn->db->replicas.next); + ovs_assert(&replica->node == txn->db->replicas.next); ovsdb_txn_abort(txn); return error; @@ -536,7 +830,7 @@ ovsdb_txn_for_each_change(const struct ovsdb_txn *txn, LIST_FOR_EACH (t, node, &txn->txn_tables) { HMAP_FOR_EACH (r, hmap_node, &t->txn_rows) { - if (!cb(r->old, r->new, r->changed, aux)) { + if ((r->old || r->new) && !cb(r->old, r->new, r->changed, aux)) { break; } } @@ -548,11 +842,17 @@ ovsdb_txn_create_txn_table(struct ovsdb_txn *txn, struct ovsdb_table *table) { if (!table->txn_table) { struct ovsdb_txn_table *txn_table; + size_t i; table->txn_table = txn_table = xmalloc(sizeof *table->txn_table); txn_table->table = table; hmap_init(&txn_table->txn_rows); txn_table->serial = serial - 1; + txn_table->txn_indexes = xmalloc(table->schema->n_indexes + * sizeof *txn_table->txn_indexes); + for (i = 0; i < table->schema->n_indexes; i++) { + hmap_init(&txn_table->txn_indexes[i]); + } list_push_back(&txn->txn_tables, &txn_table->node); } return table->txn_table; @@ -562,14 +862,17 @@ static struct ovsdb_txn_row * ovsdb_txn_row_create(struct ovsdb_txn *txn, struct ovsdb_table *table, const struct ovsdb_row *old_, struct ovsdb_row *new) { - struct ovsdb_row *old = (struct ovsdb_row *) old_; + const struct ovsdb_row *row = old_ ? old_ : new; + struct ovsdb_row *old = CONST_CAST(struct ovsdb_row *, old_); size_t n_columns = shash_count(&table->schema->columns); struct ovsdb_txn_table *txn_table; struct ovsdb_txn_row *txn_row; txn_row = xzalloc(offsetof(struct ovsdb_txn_row, changed) + bitmap_n_bytes(n_columns)); - txn_row->old = (struct ovsdb_row *) old; + txn_row->uuid = *ovsdb_row_get_uuid(row); + txn_row->table = row->table; + txn_row->old = old; txn_row->new = new; txn_row->n_refs = old ? old->n_refs : 0; txn_row->serial = serial - 1; @@ -591,10 +894,10 @@ ovsdb_txn_row_create(struct ovsdb_txn *txn, struct ovsdb_table *table, struct ovsdb_row * ovsdb_txn_row_modify(struct ovsdb_txn *txn, const struct ovsdb_row *ro_row_) { - struct ovsdb_row *ro_row = (struct ovsdb_row *) ro_row_; + struct ovsdb_row *ro_row = CONST_CAST(struct ovsdb_row *, ro_row_); if (ro_row->txn_row) { - assert(ro_row == ro_row->txn_row->new); + ovs_assert(ro_row == ro_row->txn_row->new); return ro_row; } else { struct ovsdb_table *table = ro_row->table; @@ -627,7 +930,7 @@ ovsdb_txn_row_insert(struct ovsdb_txn *txn, struct ovsdb_row *row) void ovsdb_txn_row_delete(struct ovsdb_txn *txn, const struct ovsdb_row *row_) { - struct ovsdb_row *row = (struct ovsdb_row *) row_; + struct ovsdb_row *row = CONST_CAST(struct ovsdb_row *, row_); struct ovsdb_table *table = row->table; struct ovsdb_txn_row *txn_row = row->txn_row; @@ -636,7 +939,7 @@ ovsdb_txn_row_delete(struct ovsdb_txn *txn, const struct ovsdb_row *row_) if (!txn_row) { ovsdb_txn_row_create(txn, table, row, NULL); } else { - assert(txn_row->new == row); + ovs_assert(txn_row->new == row); if (txn_row->old) { txn_row->new = NULL; } else { @@ -665,8 +968,7 @@ ovsdb_txn_get_comment(const struct ovsdb_txn *txn) static void ovsdb_txn_row_prefree(struct ovsdb_txn_row *txn_row) { - struct ovsdb_row *row = txn_row->old ? txn_row->old : txn_row->new; - struct ovsdb_txn_table *txn_table = row->table->txn_table; + struct ovsdb_txn_table *txn_table = txn_row->table->txn_table; txn_table->n_processed--; hmap_remove(&txn_table->txn_rows, &txn_row->hmap_node); @@ -682,7 +984,15 @@ ovsdb_txn_row_prefree(struct ovsdb_txn_row *txn_row) static void ovsdb_txn_table_destroy(struct ovsdb_txn_table *txn_table) { - assert(hmap_is_empty(&txn_table->txn_rows)); + size_t i; + + ovs_assert(hmap_is_empty(&txn_table->txn_rows)); + + for (i = 0; i < txn_table->table->schema->n_indexes; i++) { + hmap_destroy(&txn_table->txn_indexes[i]); + } + free(txn_table->txn_indexes); + txn_table->table->txn_table = NULL; hmap_destroy(&txn_table->txn_rows); list_remove(&txn_table->node); @@ -699,6 +1009,9 @@ ovsdb_txn_table_destroy(struct ovsdb_txn_table *txn_table) * in within the same txn_table. It may *not* delete any txn_tables. As long * as these rules are followed, 'cb' will be called exactly once for each * txn_row in 'txn', even those added by 'cb'. + * + * (Even though 'cb' is not allowed to delete some txn_rows, it can still + * delete any actual row by clearing a txn_row's 'new' member.) */ static struct ovsdb_error * WARN_UNUSED_RESULT for_each_txn_row(struct ovsdb_txn *txn,