]>
Commit | Line | Data |
---|---|---|
448b2003 | 1 | /* Copyright (c) 2009, 2010, 2011, 2012, 2013, 2016 Nicira, Inc. |
bd06962a BP |
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 "file.h" | |
19 | ||
ada496b5 | 20 | #include <errno.h> |
bd06962a | 21 | #include <fcntl.h> |
ada496b5 | 22 | #include <unistd.h> |
bd06962a | 23 | |
17d18afb | 24 | #include "bitmap.h" |
bd06962a BP |
25 | #include "column.h" |
26 | #include "log.h" | |
27 | #include "json.h" | |
ada496b5 | 28 | #include "lockfile.h" |
bd06962a BP |
29 | #include "ovsdb.h" |
30 | #include "ovsdb-error.h" | |
31 | #include "row.h" | |
ada496b5 | 32 | #include "socket-util.h" |
bd06962a | 33 | #include "table.h" |
d171b584 | 34 | #include "timeval.h" |
bd06962a BP |
35 | #include "transaction.h" |
36 | #include "uuid.h" | |
37 | #include "util.h" | |
e6211adc | 38 | #include "openvswitch/vlog.h" |
bd06962a | 39 | |
d98e6007 | 40 | VLOG_DEFINE_THIS_MODULE(ovsdb_file); |
5136ce49 | 41 | |
ada496b5 BP |
42 | /* Minimum number of milliseconds between database compactions. */ |
43 | #define COMPACT_MIN_MSEC (10 * 60 * 1000) /* 10 minutes. */ | |
44 | ||
45 | /* Minimum number of milliseconds between trying to compact the database if | |
46 | * compacting fails. */ | |
47 | #define COMPACT_RETRY_MSEC (60 * 1000) /* 1 minute. */ | |
48 | ||
a3d573ed BP |
49 | /* A transaction being converted to JSON for writing to a file. */ |
50 | struct ovsdb_file_txn { | |
51 | struct json *json; /* JSON for the whole transaction. */ | |
52 | struct json *table_json; /* JSON for 'table''s transaction. */ | |
53 | struct ovsdb_table *table; /* Table described in 'table_json'. */ | |
54 | }; | |
55 | ||
56 | static void ovsdb_file_txn_init(struct ovsdb_file_txn *); | |
57 | static void ovsdb_file_txn_add_row(struct ovsdb_file_txn *, | |
58 | const struct ovsdb_row *old, | |
17d18afb BP |
59 | const struct ovsdb_row *new, |
60 | const unsigned long int *changed); | |
a3d573ed BP |
61 | static struct ovsdb_error *ovsdb_file_txn_commit(struct json *, |
62 | const char *comment, | |
63 | bool durable, | |
64 | struct ovsdb_log *); | |
1e19e50e BP |
65 | |
66 | static struct ovsdb_error *ovsdb_file_open__(const char *file_name, | |
67 | const struct ovsdb_schema *, | |
ada496b5 BP |
68 | bool read_only, struct ovsdb **, |
69 | struct ovsdb_file **); | |
70 | static struct ovsdb_error *ovsdb_file_txn_from_json( | |
2958f35b | 71 | struct ovsdb *, const struct json *, bool converting, struct ovsdb_txn **); |
ada496b5 BP |
72 | static struct ovsdb_error *ovsdb_file_create(struct ovsdb *, |
73 | struct ovsdb_log *, | |
74 | const char *file_name, | |
ada496b5 | 75 | unsigned int n_transactions, |
448b2003 | 76 | off_t snapshot_size, |
ada496b5 | 77 | struct ovsdb_file **filep); |
bd06962a | 78 | |
1e19e50e BP |
79 | /* Opens database 'file_name' and stores a pointer to the new database in |
80 | * '*dbp'. If 'read_only' is false, then the database will be locked and | |
81 | * changes to the database will be written to disk. If 'read_only' is true, | |
82 | * the database will not be locked and changes to the database will persist | |
83 | * only as long as the "struct ovsdb". | |
84 | * | |
ada496b5 BP |
85 | * If 'filep' is nonnull and 'read_only' is false, then on success sets |
86 | * '*filep' to an ovsdb_file that represents the open file. This ovsdb_file | |
87 | * persists until '*dbp' is destroyed. | |
88 | * | |
1e19e50e | 89 | * On success, returns NULL. On failure, returns an ovsdb_error (which the |
ada496b5 | 90 | * caller must destroy) and sets '*dbp' and '*filep' to NULL. */ |
bd06962a | 91 | struct ovsdb_error * |
ada496b5 BP |
92 | ovsdb_file_open(const char *file_name, bool read_only, |
93 | struct ovsdb **dbp, struct ovsdb_file **filep) | |
1e19e50e | 94 | { |
ada496b5 | 95 | return ovsdb_file_open__(file_name, NULL, read_only, dbp, filep); |
1e19e50e BP |
96 | } |
97 | ||
98 | /* Opens database 'file_name' with an alternate schema. The specified 'schema' | |
99 | * is used to interpret the data in 'file_name', ignoring the schema actually | |
100 | * stored in the file. Data in the file for tables or columns that do not | |
101 | * exist in 'schema' are ignored, but the ovsdb file format must otherwise be | |
102 | * observed, including column constraints. | |
103 | * | |
104 | * This function can be useful for upgrading or downgrading databases to | |
105 | * "almost-compatible" formats. | |
106 | * | |
107 | * The database will not be locked. Changes to the database will persist only | |
108 | * as long as the "struct ovsdb". | |
109 | * | |
110 | * On success, stores a pointer to the new database in '*dbp' and returns a | |
111 | * null pointer. On failure, returns an ovsdb_error (which the caller must | |
112 | * destroy) and sets '*dbp' to NULL. */ | |
113 | struct ovsdb_error * | |
114 | ovsdb_file_open_as_schema(const char *file_name, | |
115 | const struct ovsdb_schema *schema, | |
116 | struct ovsdb **dbp) | |
117 | { | |
ada496b5 | 118 | return ovsdb_file_open__(file_name, schema, true, dbp, NULL); |
1e19e50e BP |
119 | } |
120 | ||
121 | static struct ovsdb_error * | |
e1ebc8ce BP |
122 | ovsdb_file_open_log(const char *file_name, enum ovsdb_log_open_mode open_mode, |
123 | struct ovsdb_log **logp, struct ovsdb_schema **schemap) | |
bd06962a | 124 | { |
ada496b5 | 125 | struct ovsdb_schema *schema = NULL; |
ada496b5 | 126 | struct ovsdb_log *log = NULL; |
e1ebc8ce BP |
127 | struct ovsdb_error *error; |
128 | struct json *json = NULL; | |
ada496b5 | 129 | |
cb22974d | 130 | ovs_assert(logp || schemap); |
bd06962a | 131 | |
7446f148 | 132 | error = ovsdb_log_open(file_name, open_mode, -1, &log); |
bd06962a | 133 | if (error) { |
ada496b5 | 134 | goto error; |
bd06962a BP |
135 | } |
136 | ||
137 | error = ovsdb_log_read(log, &json); | |
138 | if (error) { | |
ada496b5 | 139 | goto error; |
bd06962a | 140 | } else if (!json) { |
ada496b5 BP |
141 | error = ovsdb_io_error(EOF, "%s: database file contains no schema", |
142 | file_name); | |
143 | goto error; | |
bd06962a BP |
144 | } |
145 | ||
e1ebc8ce | 146 | if (schemap) { |
1e19e50e BP |
147 | error = ovsdb_schema_from_json(json, &schema); |
148 | if (error) { | |
ada496b5 BP |
149 | error = ovsdb_wrap_error(error, |
150 | "failed to parse \"%s\" as ovsdb schema", | |
151 | file_name); | |
152 | goto error; | |
1e19e50e | 153 | } |
bd06962a BP |
154 | } |
155 | json_destroy(json); | |
156 | ||
e1ebc8ce BP |
157 | if (logp) { |
158 | *logp = log; | |
159 | } else { | |
160 | ovsdb_log_close(log); | |
161 | } | |
162 | if (schemap) { | |
163 | *schemap = schema; | |
164 | } | |
165 | return NULL; | |
166 | ||
167 | error: | |
168 | ovsdb_log_close(log); | |
169 | json_destroy(json); | |
170 | if (logp) { | |
171 | *logp = NULL; | |
172 | } | |
173 | if (schemap) { | |
174 | *schemap = NULL; | |
175 | } | |
176 | return error; | |
177 | } | |
178 | ||
179 | static struct ovsdb_error * | |
180 | ovsdb_file_open__(const char *file_name, | |
181 | const struct ovsdb_schema *alternate_schema, | |
182 | bool read_only, struct ovsdb **dbp, | |
183 | struct ovsdb_file **filep) | |
184 | { | |
185 | enum ovsdb_log_open_mode open_mode; | |
e1ebc8ce BP |
186 | struct ovsdb_schema *schema = NULL; |
187 | struct ovsdb_error *error; | |
188 | struct ovsdb_log *log; | |
189 | struct json *json; | |
190 | struct ovsdb *db = NULL; | |
191 | ||
192 | /* In read-only mode there is no ovsdb_file so 'filep' must be null. */ | |
cb22974d | 193 | ovs_assert(!(read_only && filep)); |
e1ebc8ce BP |
194 | |
195 | open_mode = read_only ? OVSDB_LOG_READ_ONLY : OVSDB_LOG_READ_WRITE; | |
196 | error = ovsdb_file_open_log(file_name, open_mode, &log, | |
197 | alternate_schema ? NULL : &schema); | |
198 | if (error) { | |
199 | goto error; | |
200 | } | |
201 | ||
202 | db = ovsdb_create(schema ? schema : ovsdb_schema_clone(alternate_schema)); | |
ada496b5 | 203 | |
448b2003 BP |
204 | /* When a log gets big, we compact it into a new log that initially has |
205 | * only a single transaction that represents the entire state of the | |
206 | * database. Thus, we consider the first transaction in the database to be | |
207 | * the snapshot. We measure its size to later influence the minimum log | |
208 | * size before compacting again. | |
209 | * | |
210 | * The schema precedes the snapshot in the log; we could compensate for its | |
211 | * size, but it's just not that important. */ | |
212 | off_t snapshot_size = 0; | |
213 | unsigned int n_transactions = 0; | |
bd06962a BP |
214 | while ((error = ovsdb_log_read(log, &json)) == NULL && json) { |
215 | struct ovsdb_txn *txn; | |
216 | ||
1e19e50e | 217 | error = ovsdb_file_txn_from_json(db, json, alternate_schema != NULL, |
2958f35b | 218 | &txn); |
bd06962a BP |
219 | json_destroy(json); |
220 | if (error) { | |
43675e26 | 221 | ovsdb_log_unread(log); |
bd06962a BP |
222 | break; |
223 | } | |
224 | ||
ada496b5 | 225 | n_transactions++; |
43675e26 BP |
226 | error = ovsdb_txn_commit(txn, false); |
227 | if (error) { | |
228 | ovsdb_log_unread(log); | |
229 | break; | |
230 | } | |
448b2003 BP |
231 | |
232 | if (n_transactions == 1) { | |
233 | snapshot_size = ovsdb_log_get_offset(log); | |
234 | } | |
bd06962a BP |
235 | } |
236 | if (error) { | |
ada496b5 BP |
237 | /* Log error but otherwise ignore it. Probably the database just got |
238 | * truncated due to power failure etc. and we should use its current | |
239 | * contents. */ | |
bd06962a | 240 | char *msg = ovsdb_error_to_string(error); |
ff9f6644 | 241 | VLOG_ERR("%s", msg); |
bd06962a BP |
242 | free(msg); |
243 | ||
244 | ovsdb_error_destroy(error); | |
245 | } | |
246 | ||
247 | if (!read_only) { | |
ada496b5 BP |
248 | struct ovsdb_file *file; |
249 | ||
448b2003 BP |
250 | error = ovsdb_file_create(db, log, file_name, n_transactions, |
251 | snapshot_size, &file); | |
ada496b5 BP |
252 | if (error) { |
253 | goto error; | |
254 | } | |
255 | if (filep) { | |
256 | *filep = file; | |
257 | } | |
bd06962a BP |
258 | } else { |
259 | ovsdb_log_close(log); | |
260 | } | |
261 | ||
262 | *dbp = db; | |
263 | return NULL; | |
ada496b5 BP |
264 | |
265 | error: | |
266 | *dbp = NULL; | |
267 | if (filep) { | |
268 | *filep = NULL; | |
269 | } | |
270 | ovsdb_destroy(db); | |
ada496b5 BP |
271 | ovsdb_log_close(log); |
272 | return error; | |
bd06962a BP |
273 | } |
274 | ||
1e19e50e BP |
275 | static struct ovsdb_error * |
276 | ovsdb_file_update_row_from_json(struct ovsdb_row *row, bool converting, | |
277 | const struct json *json) | |
278 | { | |
279 | struct ovsdb_table_schema *schema = row->table->schema; | |
280 | struct ovsdb_error *error; | |
281 | struct shash_node *node; | |
282 | ||
283 | if (json->type != JSON_OBJECT) { | |
284 | return ovsdb_syntax_error(json, NULL, "row must be JSON object"); | |
285 | } | |
286 | ||
287 | SHASH_FOR_EACH (node, json_object(json)) { | |
288 | const char *column_name = node->name; | |
289 | const struct ovsdb_column *column; | |
290 | struct ovsdb_datum datum; | |
291 | ||
292 | column = ovsdb_table_schema_get_column(schema, column_name); | |
293 | if (!column) { | |
294 | if (converting) { | |
295 | continue; | |
296 | } | |
297 | return ovsdb_syntax_error(json, "unknown column", | |
298 | "No column %s in table %s.", | |
299 | column_name, schema->name); | |
300 | } | |
301 | ||
302 | error = ovsdb_datum_from_json(&datum, &column->type, node->data, NULL); | |
303 | if (error) { | |
304 | return error; | |
305 | } | |
306 | ovsdb_datum_swap(&row->fields[column->index], &datum); | |
307 | ovsdb_datum_destroy(&datum, &column->type); | |
308 | } | |
309 | ||
310 | return NULL; | |
311 | } | |
312 | ||
bd06962a BP |
313 | static struct ovsdb_error * |
314 | ovsdb_file_txn_row_from_json(struct ovsdb_txn *txn, struct ovsdb_table *table, | |
1e19e50e | 315 | bool converting, |
bd06962a BP |
316 | const struct uuid *row_uuid, struct json *json) |
317 | { | |
318 | const struct ovsdb_row *row = ovsdb_table_get_row(table, row_uuid); | |
319 | if (json->type == JSON_NULL) { | |
320 | if (!row) { | |
321 | return ovsdb_syntax_error(NULL, NULL, "transaction deletes " | |
322 | "row "UUID_FMT" that does not exist", | |
323 | UUID_ARGS(row_uuid)); | |
324 | } | |
325 | ovsdb_txn_row_delete(txn, row); | |
326 | return NULL; | |
327 | } else if (row) { | |
1e19e50e BP |
328 | return ovsdb_file_update_row_from_json(ovsdb_txn_row_modify(txn, row), |
329 | converting, json); | |
bd06962a BP |
330 | } else { |
331 | struct ovsdb_error *error; | |
332 | struct ovsdb_row *new; | |
333 | ||
334 | new = ovsdb_row_create(table); | |
335 | *ovsdb_row_get_uuid_rw(new) = *row_uuid; | |
1e19e50e | 336 | error = ovsdb_file_update_row_from_json(new, converting, json); |
bd06962a BP |
337 | if (error) { |
338 | ovsdb_row_destroy(new); | |
3697c062 BP |
339 | } else { |
340 | ovsdb_txn_row_insert(txn, new); | |
bd06962a | 341 | } |
bd06962a BP |
342 | return error; |
343 | } | |
344 | } | |
345 | ||
346 | static struct ovsdb_error * | |
347 | ovsdb_file_txn_table_from_json(struct ovsdb_txn *txn, | |
1e19e50e BP |
348 | struct ovsdb_table *table, |
349 | bool converting, struct json *json) | |
bd06962a BP |
350 | { |
351 | struct shash_node *node; | |
352 | ||
353 | if (json->type != JSON_OBJECT) { | |
354 | return ovsdb_syntax_error(json, NULL, "object expected"); | |
355 | } | |
356 | ||
357 | SHASH_FOR_EACH (node, json->u.object) { | |
358 | const char *uuid_string = node->name; | |
359 | struct json *txn_row_json = node->data; | |
360 | struct ovsdb_error *error; | |
361 | struct uuid row_uuid; | |
362 | ||
363 | if (!uuid_from_string(&row_uuid, uuid_string)) { | |
364 | return ovsdb_syntax_error(json, NULL, "\"%s\" is not a valid UUID", | |
365 | uuid_string); | |
366 | } | |
367 | ||
1e19e50e BP |
368 | error = ovsdb_file_txn_row_from_json(txn, table, converting, |
369 | &row_uuid, txn_row_json); | |
bd06962a BP |
370 | if (error) { |
371 | return error; | |
372 | } | |
373 | } | |
374 | ||
375 | return NULL; | |
376 | } | |
377 | ||
ada496b5 BP |
378 | /* Converts 'json' to an ovsdb_txn for 'db', storing the new transaction in |
379 | * '*txnp'. Returns NULL if successful, otherwise an error. | |
380 | * | |
381 | * If 'converting' is true, then unknown table and column names are ignored | |
382 | * (which can ease upgrading and downgrading schemas); otherwise, they are | |
2958f35b | 383 | * treated as errors. */ |
bd06962a BP |
384 | static struct ovsdb_error * |
385 | ovsdb_file_txn_from_json(struct ovsdb *db, const struct json *json, | |
2958f35b | 386 | bool converting, struct ovsdb_txn **txnp) |
bd06962a BP |
387 | { |
388 | struct ovsdb_error *error; | |
389 | struct shash_node *node; | |
390 | struct ovsdb_txn *txn; | |
391 | ||
392 | *txnp = NULL; | |
ada496b5 | 393 | |
bd06962a BP |
394 | if (json->type != JSON_OBJECT) { |
395 | return ovsdb_syntax_error(json, NULL, "object expected"); | |
396 | } | |
397 | ||
398 | txn = ovsdb_txn_create(db); | |
399 | SHASH_FOR_EACH (node, json->u.object) { | |
400 | const char *table_name = node->name; | |
ada496b5 | 401 | struct json *node_json = node->data; |
bd06962a BP |
402 | struct ovsdb_table *table; |
403 | ||
404 | table = shash_find_data(&db->tables, table_name); | |
405 | if (!table) { | |
d171b584 | 406 | if (!strcmp(table_name, "_date") |
ada496b5 | 407 | && node_json->type == JSON_INTEGER) { |
ada496b5 BP |
408 | continue; |
409 | } else if (!strcmp(table_name, "_comment") || converting) { | |
d171b584 BP |
410 | continue; |
411 | } | |
412 | ||
bd06962a BP |
413 | error = ovsdb_syntax_error(json, "unknown table", |
414 | "No table named %s.", table_name); | |
415 | goto error; | |
416 | } | |
417 | ||
1e19e50e | 418 | error = ovsdb_file_txn_table_from_json(txn, table, converting, |
ada496b5 | 419 | node_json); |
bd06962a BP |
420 | if (error) { |
421 | goto error; | |
422 | } | |
423 | } | |
424 | *txnp = txn; | |
425 | return NULL; | |
426 | ||
427 | error: | |
428 | ovsdb_txn_abort(txn); | |
429 | return error; | |
430 | } | |
1e19e50e | 431 | |
ada496b5 BP |
432 | static struct ovsdb_error * |
433 | ovsdb_file_save_copy__(const char *file_name, int locking, | |
434 | const char *comment, const struct ovsdb *db, | |
435 | struct ovsdb_log **logp) | |
1e19e50e BP |
436 | { |
437 | const struct shash_node *node; | |
438 | struct ovsdb_file_txn ftxn; | |
439 | struct ovsdb_error *error; | |
440 | struct ovsdb_log *log; | |
441 | struct json *json; | |
442 | ||
443 | error = ovsdb_log_open(file_name, OVSDB_LOG_CREATE, locking, &log); | |
444 | if (error) { | |
445 | return error; | |
446 | } | |
447 | ||
448 | /* Write schema. */ | |
449 | json = ovsdb_schema_to_json(db->schema); | |
450 | error = ovsdb_log_write(log, json); | |
451 | json_destroy(json); | |
452 | if (error) { | |
453 | goto exit; | |
454 | } | |
455 | ||
456 | /* Write data. */ | |
457 | ovsdb_file_txn_init(&ftxn); | |
458 | SHASH_FOR_EACH (node, &db->tables) { | |
459 | const struct ovsdb_table *table = node->data; | |
460 | const struct ovsdb_row *row; | |
461 | ||
4e8e4213 | 462 | HMAP_FOR_EACH (row, hmap_node, &table->rows) { |
17d18afb | 463 | ovsdb_file_txn_add_row(&ftxn, NULL, row, NULL); |
1e19e50e BP |
464 | } |
465 | } | |
466 | error = ovsdb_file_txn_commit(ftxn.json, comment, true, log); | |
467 | ||
468 | exit: | |
ada496b5 BP |
469 | if (logp) { |
470 | if (!error) { | |
471 | *logp = log; | |
472 | log = NULL; | |
473 | } else { | |
474 | *logp = NULL; | |
475 | } | |
476 | } | |
1e19e50e BP |
477 | ovsdb_log_close(log); |
478 | if (error) { | |
479 | remove(file_name); | |
480 | } | |
481 | return error; | |
482 | } | |
ada496b5 BP |
483 | |
484 | /* Saves a snapshot of 'db''s current contents as 'file_name'. If 'comment' is | |
485 | * nonnull, then it is added along with the data contents and can be viewed | |
486 | * with "ovsdb-tool show-log". | |
487 | * | |
488 | * 'locking' is passed along to ovsdb_log_open() untouched. */ | |
489 | struct ovsdb_error * | |
490 | ovsdb_file_save_copy(const char *file_name, int locking, | |
491 | const char *comment, const struct ovsdb *db) | |
492 | { | |
493 | return ovsdb_file_save_copy__(file_name, locking, comment, db, NULL); | |
494 | } | |
e1ebc8ce BP |
495 | |
496 | /* Opens database 'file_name', reads its schema, and closes it. On success, | |
497 | * stores the schema into '*schemap' and returns NULL; the caller then owns the | |
498 | * schema. On failure, returns an ovsdb_error (which the caller must destroy) | |
499 | * and sets '*dbp' to NULL. */ | |
500 | struct ovsdb_error * | |
501 | ovsdb_file_read_schema(const char *file_name, struct ovsdb_schema **schemap) | |
502 | { | |
cb22974d | 503 | ovs_assert(schemap != NULL); |
e1ebc8ce BP |
504 | return ovsdb_file_open_log(file_name, OVSDB_LOG_READ_ONLY, NULL, schemap); |
505 | } | |
bd06962a BP |
506 | \f |
507 | /* Replica implementation. */ | |
508 | ||
afe20d5c | 509 | struct ovsdb_file { |
bd06962a | 510 | struct ovsdb_replica replica; |
ada496b5 | 511 | struct ovsdb *db; |
bd06962a | 512 | struct ovsdb_log *log; |
ada496b5 | 513 | char *file_name; |
2958f35b | 514 | long long int last_compact; |
ada496b5 BP |
515 | long long int next_compact; |
516 | unsigned int n_transactions; | |
448b2003 | 517 | off_t snapshot_size; |
bd06962a BP |
518 | }; |
519 | ||
afe20d5c | 520 | static const struct ovsdb_replica_class ovsdb_file_class; |
bd06962a | 521 | |
ada496b5 BP |
522 | static struct ovsdb_error * |
523 | ovsdb_file_create(struct ovsdb *db, struct ovsdb_log *log, | |
524 | const char *file_name, | |
448b2003 | 525 | unsigned int n_transactions, off_t snapshot_size, |
ada496b5 | 526 | struct ovsdb_file **filep) |
bd06962a | 527 | { |
ada496b5 | 528 | struct ovsdb_file *file; |
a35ae81c | 529 | char *deref_name; |
ada496b5 BP |
530 | char *abs_name; |
531 | ||
532 | /* Use the absolute name of the file because ovsdb-server opens its | |
533 | * database before daemonize() chdirs to "/". */ | |
a35ae81c BP |
534 | deref_name = follow_symlinks(file_name); |
535 | abs_name = abs_file_name(NULL, deref_name); | |
536 | free(deref_name); | |
ada496b5 BP |
537 | if (!abs_name) { |
538 | *filep = NULL; | |
539 | return ovsdb_io_error(0, "could not determine current " | |
540 | "working directory"); | |
541 | } | |
542 | ||
543 | file = xmalloc(sizeof *file); | |
afe20d5c | 544 | ovsdb_replica_init(&file->replica, &ovsdb_file_class); |
ada496b5 | 545 | file->db = db; |
afe20d5c | 546 | file->log = log; |
ada496b5 | 547 | file->file_name = abs_name; |
2958f35b PI |
548 | file->last_compact = time_msec(); |
549 | file->next_compact = file->last_compact + COMPACT_MIN_MSEC; | |
448b2003 | 550 | file->snapshot_size = snapshot_size; |
ada496b5 | 551 | file->n_transactions = n_transactions; |
afe20d5c | 552 | ovsdb_add_replica(db, &file->replica); |
ada496b5 BP |
553 | |
554 | *filep = file; | |
555 | return NULL; | |
bd06962a BP |
556 | } |
557 | ||
afe20d5c BP |
558 | static struct ovsdb_file * |
559 | ovsdb_file_cast(struct ovsdb_replica *replica) | |
bd06962a | 560 | { |
cb22974d | 561 | ovs_assert(replica->class == &ovsdb_file_class); |
afe20d5c | 562 | return CONTAINER_OF(replica, struct ovsdb_file, replica); |
bd06962a BP |
563 | } |
564 | ||
bd06962a | 565 | static bool |
afe20d5c BP |
566 | ovsdb_file_change_cb(const struct ovsdb_row *old, |
567 | const struct ovsdb_row *new, | |
568 | const unsigned long int *changed, | |
569 | void *ftxn_) | |
a3d573ed BP |
570 | { |
571 | struct ovsdb_file_txn *ftxn = ftxn_; | |
17d18afb | 572 | ovsdb_file_txn_add_row(ftxn, old, new, changed); |
a3d573ed BP |
573 | return true; |
574 | } | |
575 | ||
576 | static struct ovsdb_error * | |
afe20d5c BP |
577 | ovsdb_file_commit(struct ovsdb_replica *replica, |
578 | const struct ovsdb_txn *txn, bool durable) | |
a3d573ed | 579 | { |
afe20d5c | 580 | struct ovsdb_file *file = ovsdb_file_cast(replica); |
a3d573ed | 581 | struct ovsdb_file_txn ftxn; |
ada496b5 | 582 | struct ovsdb_error *error; |
a3d573ed BP |
583 | |
584 | ovsdb_file_txn_init(&ftxn); | |
afe20d5c | 585 | ovsdb_txn_for_each_change(txn, ovsdb_file_change_cb, &ftxn); |
a3d573ed BP |
586 | if (!ftxn.json) { |
587 | /* Nothing to commit. */ | |
588 | return NULL; | |
589 | } | |
590 | ||
ada496b5 BP |
591 | error = ovsdb_file_txn_commit(ftxn.json, ovsdb_txn_get_comment(txn), |
592 | durable, file->log); | |
593 | if (error) { | |
594 | return error; | |
595 | } | |
596 | file->n_transactions++; | |
597 | ||
19616e46 BP |
598 | /* If it has been at least COMPACT_MIN_MSEC ms since the last time we |
599 | * compacted (or at least COMPACT_RETRY_MSEC ms since the last time we | |
ada496b5 | 600 | * tried), and if there are at least 100 transactions in the database, and |
448b2003 BP |
601 | * if the database is at least 10 MB, and the database is at least 4x the |
602 | * size of the previous snapshot, then compact the database. */ | |
603 | off_t log_size = ovsdb_log_get_offset(file->log); | |
ada496b5 BP |
604 | if (time_msec() >= file->next_compact |
605 | && file->n_transactions >= 100 | |
448b2003 BP |
606 | && log_size >= 10 * 1024 * 1024 |
607 | && log_size / 4 >= file->snapshot_size) | |
ada496b5 BP |
608 | { |
609 | error = ovsdb_file_compact(file); | |
610 | if (error) { | |
611 | char *s = ovsdb_error_to_string(error); | |
612 | ovsdb_error_destroy(error); | |
613 | VLOG_WARN("%s: compacting database failed (%s), retrying in " | |
8c7ea6a0 BP |
614 | "%d seconds", |
615 | file->file_name, s, COMPACT_RETRY_MSEC / 1000); | |
ada496b5 BP |
616 | free(s); |
617 | ||
618 | file->next_compact = time_msec() + COMPACT_RETRY_MSEC; | |
619 | } | |
620 | } | |
621 | ||
622 | return NULL; | |
623 | } | |
624 | ||
625 | struct ovsdb_error * | |
626 | ovsdb_file_compact(struct ovsdb_file *file) | |
627 | { | |
628 | struct ovsdb_log *new_log = NULL; | |
629 | struct lockfile *tmp_lock = NULL; | |
630 | struct ovsdb_error *error; | |
631 | char *tmp_name = NULL; | |
632 | char *comment = NULL; | |
633 | int retval; | |
634 | ||
635 | comment = xasprintf("compacting database online " | |
636 | "(%.3f seconds old, %u transactions, %llu bytes)", | |
2958f35b | 637 | (time_wall_msec() - file->last_compact) / 1000.0, |
ada496b5 BP |
638 | file->n_transactions, |
639 | (unsigned long long) ovsdb_log_get_offset(file->log)); | |
640 | VLOG_INFO("%s: %s", file->file_name, comment); | |
641 | ||
642 | /* Commit the old version, so that we can be assured that we'll eventually | |
643 | * have either the old or the new version. */ | |
644 | error = ovsdb_log_commit(file->log); | |
645 | if (error) { | |
646 | goto exit; | |
647 | } | |
648 | ||
649 | /* Lock temporary file. */ | |
650 | tmp_name = xasprintf("%s.tmp", file->file_name); | |
4770e795 | 651 | retval = lockfile_lock(tmp_name, &tmp_lock); |
ada496b5 BP |
652 | if (retval) { |
653 | error = ovsdb_io_error(retval, "could not get lock on %s", tmp_name); | |
654 | goto exit; | |
655 | } | |
656 | ||
657 | /* Remove temporary file. (It might not exist.) */ | |
658 | if (unlink(tmp_name) < 0 && errno != ENOENT) { | |
659 | error = ovsdb_io_error(errno, "failed to remove %s", tmp_name); | |
660 | goto exit; | |
661 | } | |
662 | ||
663 | /* Save a copy. */ | |
664 | error = ovsdb_file_save_copy__(tmp_name, false, comment, file->db, | |
665 | &new_log); | |
666 | if (error) { | |
667 | goto exit; | |
668 | } | |
669 | ||
670 | /* Replace original by temporary. */ | |
671 | if (rename(tmp_name, file->file_name)) { | |
672 | error = ovsdb_io_error(errno, "failed to rename \"%s\" to \"%s\"", | |
673 | tmp_name, file->file_name); | |
674 | goto exit; | |
675 | } | |
676 | fsync_parent_dir(file->file_name); | |
677 | ||
678 | exit: | |
679 | if (!error) { | |
680 | ovsdb_log_close(file->log); | |
681 | file->log = new_log; | |
2958f35b PI |
682 | file->last_compact = time_msec(); |
683 | file->next_compact = file->last_compact + COMPACT_MIN_MSEC; | |
ada496b5 BP |
684 | file->n_transactions = 1; |
685 | } else { | |
686 | ovsdb_log_close(new_log); | |
687 | if (tmp_lock) { | |
688 | unlink(tmp_name); | |
689 | } | |
690 | } | |
691 | ||
692 | lockfile_unlock(tmp_lock); | |
693 | free(tmp_name); | |
694 | free(comment); | |
695 | ||
696 | return error; | |
a3d573ed BP |
697 | } |
698 | ||
699 | static void | |
afe20d5c | 700 | ovsdb_file_destroy(struct ovsdb_replica *replica) |
a3d573ed | 701 | { |
afe20d5c | 702 | struct ovsdb_file *file = ovsdb_file_cast(replica); |
a3d573ed | 703 | |
afe20d5c | 704 | ovsdb_log_close(file->log); |
ada496b5 | 705 | free(file->file_name); |
afe20d5c | 706 | free(file); |
a3d573ed BP |
707 | } |
708 | ||
afe20d5c BP |
709 | static const struct ovsdb_replica_class ovsdb_file_class = { |
710 | ovsdb_file_commit, | |
711 | ovsdb_file_destroy | |
a3d573ed BP |
712 | }; |
713 | \f | |
714 | static void | |
715 | ovsdb_file_txn_init(struct ovsdb_file_txn *ftxn) | |
716 | { | |
717 | ftxn->json = NULL; | |
718 | ftxn->table_json = NULL; | |
719 | ftxn->table = NULL; | |
720 | } | |
721 | ||
722 | static void | |
723 | ovsdb_file_txn_add_row(struct ovsdb_file_txn *ftxn, | |
724 | const struct ovsdb_row *old, | |
17d18afb BP |
725 | const struct ovsdb_row *new, |
726 | const unsigned long int *changed) | |
bd06962a | 727 | { |
bd06962a BP |
728 | struct json *row; |
729 | ||
730 | if (!new) { | |
731 | row = json_null_create(); | |
732 | } else { | |
733 | struct shash_node *node; | |
734 | ||
88942565 | 735 | row = old ? NULL : json_object_create(); |
bd06962a BP |
736 | SHASH_FOR_EACH (node, &new->table->schema->columns) { |
737 | const struct ovsdb_column *column = node->data; | |
738 | const struct ovsdb_type *type = &column->type; | |
739 | unsigned int idx = column->index; | |
740 | ||
741 | if (idx != OVSDB_COL_UUID && column->persistent | |
c532bf9d | 742 | && (old |
17d18afb | 743 | ? bitmap_is_set(changed, idx) |
c532bf9d | 744 | : !ovsdb_datum_is_default(&new->fields[idx], type))) |
bd06962a BP |
745 | { |
746 | if (!row) { | |
747 | row = json_object_create(); | |
748 | } | |
749 | json_object_put(row, column->name, | |
750 | ovsdb_datum_to_json(&new->fields[idx], type)); | |
751 | } | |
752 | } | |
753 | } | |
754 | ||
755 | if (row) { | |
756 | struct ovsdb_table *table = new ? new->table : old->table; | |
757 | char uuid[UUID_LEN + 1]; | |
758 | ||
a3d573ed | 759 | if (table != ftxn->table) { |
bd06962a | 760 | /* Create JSON object for transaction overall. */ |
a3d573ed BP |
761 | if (!ftxn->json) { |
762 | ftxn->json = json_object_create(); | |
bd06962a BP |
763 | } |
764 | ||
765 | /* Create JSON object for transaction on this table. */ | |
a3d573ed BP |
766 | ftxn->table_json = json_object_create(); |
767 | ftxn->table = table; | |
768 | json_object_put(ftxn->json, table->schema->name, ftxn->table_json); | |
bd06962a BP |
769 | } |
770 | ||
771 | /* Add row to transaction for this table. */ | |
772 | snprintf(uuid, sizeof uuid, | |
773 | UUID_FMT, UUID_ARGS(ovsdb_row_get_uuid(new ? new : old))); | |
a3d573ed | 774 | json_object_put(ftxn->table_json, uuid, row); |
bd06962a | 775 | } |
bd06962a BP |
776 | } |
777 | ||
778 | static struct ovsdb_error * | |
a3d573ed BP |
779 | ovsdb_file_txn_commit(struct json *json, const char *comment, |
780 | bool durable, struct ovsdb_log *log) | |
bd06962a | 781 | { |
bd06962a | 782 | struct ovsdb_error *error; |
bd06962a | 783 | |
a3d573ed BP |
784 | if (!json) { |
785 | json = json_object_create(); | |
bd06962a | 786 | } |
d171b584 | 787 | if (comment) { |
a3d573ed | 788 | json_object_put_string(json, "_comment", comment); |
d171b584 | 789 | } |
1ff1065c | 790 | json_object_put(json, "_date", json_integer_create(time_wall_msec())); |
d171b584 | 791 | |
a3d573ed BP |
792 | error = ovsdb_log_write(log, json); |
793 | json_destroy(json); | |
bd06962a BP |
794 | if (error) { |
795 | return ovsdb_wrap_error(error, "writing transaction failed"); | |
796 | } | |
797 | ||
798 | if (durable) { | |
a3d573ed | 799 | error = ovsdb_log_commit(log); |
bd06962a BP |
800 | if (error) { |
801 | return ovsdb_wrap_error(error, "committing transaction failed"); | |
802 | } | |
803 | } | |
804 | ||
805 | return NULL; | |
806 | } |