ovsdb/transaction.c

   1 /* Copyright (c) 2009, 2010 Nicira Networks
   2  *
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <config.h>
  17
  18 #include "transaction.h"
  19
  20 #include <assert.h>
  21
  22 #include "dynamic-string.h"
  23 #include "hash.h"
  24 #include "hmap.h"
  25 #include "json.h"
  26 #include "list.h"
  27 #include "ovsdb-error.h"
  28 #include "ovsdb.h"
  29 #include "row.h"
  30 #include "table.h"
  31 #include "uuid.h"
  32
  33 struct ovsdb_txn {
  34     struct ovsdb *db;
  35     struct list txn_tables;     /* Contains "struct ovsdb_txn_table"s. */
  36     struct ds comment;
  37 };
  38
  39 /* A table modified by a transaction. */
  40 struct ovsdb_txn_table {
  41     struct list node;           /* Element in ovsdb_txn's txn_tables list. */
  42     struct ovsdb_table *table;
  43     struct hmap txn_rows;       /* Contains "struct ovsdb_txn_row"s. */
  44 };
  45
  46 /* A row modified by the transaction:
  47  *
  48  *      - A row added by a transaction will have null 'old' and non-null 'new'.
  49  *
  50  *      - A row deleted by a transaction will have non-null 'old' and null
  51  *        'new'.
  52  *
  53  *      - A row modified by a transaction will have non-null 'old' and 'new'.
  54  *
  55  *      - 'old' and 'new' both null is invalid.  It would indicate that a row
  56  *        was added then deleted within a single transaction, but we instead
  57  *        handle that case by deleting the txn_row entirely.
  58  */
  59 struct ovsdb_txn_row {
  60     struct hmap_node hmap_node; /* In ovsdb_txn_table's txn_rows hmap. */
  61     struct ovsdb_row *old;      /* The old row. */
  62     struct ovsdb_row *new;      /* The new row. */
  63 };
  64
  65 struct ovsdb_txn *
  66 ovsdb_txn_create(struct ovsdb *db)
  67 {
  68     struct ovsdb_txn *txn = xmalloc(sizeof *txn);
  69     txn->db = db;
  70     list_init(&txn->txn_tables);
  71     ds_init(&txn->comment);
  72     return txn;
  73 }
  74
  75 static void
  76 ovsdb_txn_destroy(struct ovsdb_txn *txn, void (*cb)(struct ovsdb_txn_row *))
  77 {
  78     struct ovsdb_txn_table *txn_table, *next_txn_table;
  79
  80     LIST_FOR_EACH_SAFE (txn_table, next_txn_table,
  81                         struct ovsdb_txn_table, node, &txn->txn_tables) {
  82         struct ovsdb_txn_row *txn_row, *next_txn_row;
  83
  84         HMAP_FOR_EACH_SAFE (txn_row, next_txn_row,
  85                             struct ovsdb_txn_row, hmap_node,
  86                             &txn_table->txn_rows)
  87         {
  88             if (txn_row->old) {
  89                 txn_row->old->txn_row = NULL;
  90             }
  91             if (txn_row->new) {
  92                 txn_row->new->txn_row = NULL;
  93             }
  94             cb(txn_row);
  95             free(txn_row);
  96         }
  97
  98         txn_table->table->txn_table = NULL;
  99         hmap_destroy(&txn_table->txn_rows);
 100         free(txn_table);
 101     }
 102     ds_destroy(&txn->comment);
 103     free(txn);
 104 }
 105
 106 static void
 107 ovsdb_txn_row_abort(struct ovsdb_txn_row *txn_row)
 108 {
 109     struct ovsdb_row *old = txn_row->old;
 110     struct ovsdb_row *new = txn_row->new;
 111
 112     if (!old) {
 113         hmap_remove(&new->table->rows, &new->hmap_node);
 114     } else if (!new) {
 115         hmap_insert(&old->table->rows, &old->hmap_node, ovsdb_row_hash(old));
 116     } else {
 117         hmap_replace(&new->table->rows, &new->hmap_node, &old->hmap_node);
 118     }
 119     ovsdb_row_destroy(new);
 120 }
 121
 122 void
 123 ovsdb_txn_abort(struct ovsdb_txn *txn)
 124 {
 125     ovsdb_txn_destroy(txn, ovsdb_txn_row_abort);
 126 }
 127
 128 static void
 129 ovsdb_txn_row_commit(struct ovsdb_txn_row *txn_row)
 130 {
 131     ovsdb_row_destroy(txn_row->old);
 132 }
 133
 134 struct ovsdb_error *
 135 ovsdb_txn_commit(struct ovsdb_txn *txn, bool durable)
 136 {
 137     struct ovsdb_replica *replica;
 138     struct ovsdb_error *error;
 139
 140     LIST_FOR_EACH (replica, struct ovsdb_replica, node, &txn->db->replicas) {
 141         error = (replica->class->commit)(replica, txn, durable);
 142         if (error) {
 143             /* We don't support two-phase commit so only the first replica is
 144              * allowed to report an error. */
 145             assert(&replica->node == txn->db->replicas.next);
 146
 147             ovsdb_txn_abort(txn);
 148             return error;
 149         }
 150     }
 151
 152     txn->db->run_triggers = true;
 153     ovsdb_txn_destroy(txn, ovsdb_txn_row_commit);
 154     return NULL;
 155 }
 156
 157 void
 158 ovsdb_txn_for_each_change(const struct ovsdb_txn *txn,
 159                           ovsdb_txn_row_cb_func *cb, void *aux)
 160 {
 161     struct ovsdb_txn_table *t;
 162     struct ovsdb_txn_row *r;
 163
 164     LIST_FOR_EACH (t, struct ovsdb_txn_table, node, &txn->txn_tables) {
 165         HMAP_FOR_EACH (r, struct ovsdb_txn_row, hmap_node, &t->txn_rows) {
 166             if (!cb(r->old, r->new, aux)) {
 167                 break;
 168             }
 169         }
 170    }
 171 }
 172
 173 static struct ovsdb_txn_table *
 174 ovsdb_txn_create_txn_table(struct ovsdb_txn *txn, struct ovsdb_table *table)
 175 {
 176     if (!table->txn_table) {
 177         struct ovsdb_txn_table *txn_table;
 178
 179         table->txn_table = txn_table = xmalloc(sizeof *table->txn_table);
 180         txn_table->table = table;
 181         hmap_init(&txn_table->txn_rows);
 182         list_push_back(&txn->txn_tables, &txn_table->node);
 183     }
 184     return table->txn_table;
 185 }
 186
 187 static struct ovsdb_txn_row *
 188 ovsdb_txn_row_create(struct ovsdb_txn *txn, struct ovsdb_table *table,
 189                      const struct ovsdb_row *old, struct ovsdb_row *new)
 190 {
 191     struct ovsdb_txn_table *txn_table;
 192     struct ovsdb_txn_row *txn_row;
 193
 194     txn_row = xmalloc(sizeof *txn_row);
 195     txn_row->old = (struct ovsdb_row *) old;
 196     txn_row->new = new;
 197
 198     txn_table = ovsdb_txn_create_txn_table(txn, table);
 199     hmap_insert(&txn_table->txn_rows, &txn_row->hmap_node,
 200                 ovsdb_row_hash(old ? old : new));
 201
 202     return txn_row;
 203 }
 204
 205 struct ovsdb_row *
 206 ovsdb_txn_row_modify(struct ovsdb_txn *txn, const struct ovsdb_row *ro_row_)
 207 {
 208     struct ovsdb_row *ro_row = (struct ovsdb_row *) ro_row_;
 209
 210     if (ro_row->txn_row) {
 211         assert(ro_row == ro_row->txn_row->new);
 212         return ro_row;
 213     } else {
 214         struct ovsdb_table *table = ro_row->table;
 215         struct ovsdb_row *rw_row;
 216
 217         rw_row = ovsdb_row_clone(ro_row);
 218         uuid_generate(ovsdb_row_get_version_rw(rw_row));
 219         rw_row->txn_row = ovsdb_txn_row_create(txn, table, ro_row, rw_row);
 220         hmap_replace(&table->rows, &ro_row->hmap_node, &rw_row->hmap_node);
 221
 222         return rw_row;
 223     }
 224 }
 225
 226 void
 227 ovsdb_txn_row_insert(struct ovsdb_txn *txn, struct ovsdb_row *row)
 228 {
 229     uint32_t hash = ovsdb_row_hash(row);
 230     struct ovsdb_table *table = row->table;
 231
 232     uuid_generate(ovsdb_row_get_version_rw(row));
 233
 234     row->txn_row = ovsdb_txn_row_create(txn, table, NULL, row);
 235     hmap_insert(&table->rows, &row->hmap_node, hash);
 236 }
 237
 238 /* 'row' must be assumed destroyed upon return; the caller must not reference
 239  * it again. */
 240 void
 241 ovsdb_txn_row_delete(struct ovsdb_txn *txn, const struct ovsdb_row *row_)
 242 {
 243     struct ovsdb_row *row = (struct ovsdb_row *) row_;
 244     struct ovsdb_table *table = row->table;
 245     struct ovsdb_txn_row *txn_row = row->txn_row;
 246
 247     hmap_remove(&table->rows, &row->hmap_node);
 248
 249     if (!txn_row) {
 250         row->txn_row = ovsdb_txn_row_create(txn, table, row, NULL);
 251     } else {
 252         assert(txn_row->new == row);
 253         if (txn_row->old) {
 254             txn_row->new = NULL;
 255         } else {
 256             hmap_remove(&table->txn_table->txn_rows, &txn_row->hmap_node);
 257             free(txn_row);
 258         }
 259         ovsdb_row_destroy(row);
 260     }
 261 }
 262
 263 void
 264 ovsdb_txn_add_comment(struct ovsdb_txn *txn, const char *s)
 265 {
 266     if (txn->comment.length) {
 267         ds_put_char(&txn->comment, '\n');
 268     }
 269     ds_put_cstr(&txn->comment, s);
 270 }
 271
 272 const char *
 273 ovsdb_txn_get_comment(const struct ovsdb_txn *txn)
 274 {
 275     return txn->comment.length ? ds_cstr_ro(&txn->comment) : NULL;
 276 }