1 /* Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
30 #include "ovsdb-error.h"
32 #include "socket-util.h"
33 #include "transaction.h"
37 VLOG_DEFINE_THIS_MODULE(ovsdb_log);
48 struct lockfile *lockfile;
50 struct ovsdb_error *read_error;
51 struct ovsdb_error *write_error;
52 enum ovsdb_log_mode mode;
55 /* Attempts to open 'name' with the specified 'open_mode'. On success, stores
56 * the new log into '*filep' and returns NULL; otherwise returns NULL and
57 * stores NULL into '*filep'.
59 * Whether the file will be locked using lockfile_lock() depends on 'locking':
60 * use true to lock it, false not to lock it, or -1 to lock it only if
61 * 'open_mode' is a mode that allows writing.
64 ovsdb_log_open(const char *name, enum ovsdb_log_open_mode open_mode,
65 int locking, struct ovsdb_log **filep)
67 struct lockfile *lockfile;
68 struct ovsdb_error *error;
69 struct ovsdb_log *file;
77 ovs_assert(locking == -1 || locking == false || locking == true);
79 locking = open_mode != OVSDB_LOG_READ_ONLY;
82 int retval = lockfile_lock(name, &lockfile);
84 error = ovsdb_io_error(retval, "%s: failed to lock lockfile",
92 if (open_mode == OVSDB_LOG_READ_ONLY) {
94 } else if (open_mode == OVSDB_LOG_READ_WRITE) {
96 } else if (open_mode == OVSDB_LOG_CREATE) {
97 if (stat(name, &s) == -1 && errno == ENOENT
98 && lstat(name, &s) == 0 && S_ISLNK(s.st_mode)) {
99 /* 'name' is a dangling symlink. We want to create the file that
100 * the symlink points to, but POSIX says that open() with O_EXCL
101 * must fail with EEXIST if the named file is a symlink. So, we
102 * have to leave off O_EXCL and accept the race. */
103 flags = O_RDWR | O_CREAT;
105 flags = O_RDWR | O_CREAT | O_EXCL;
110 fd = open(name, flags, 0666);
112 const char *op = open_mode == OVSDB_LOG_CREATE ? "create" : "open";
113 error = ovsdb_io_error(errno, "%s: %s failed", op, name);
117 if (!fstat(fd, &s) && s.st_size == 0) {
118 /* It's (probably) a new file so fsync() its parent directory to ensure
119 * that its directory entry is committed to disk. */
120 fsync_parent_dir(name);
123 stream = fdopen(fd, open_mode == OVSDB_LOG_READ_ONLY ? "rb" : "w+b");
125 error = ovsdb_io_error(errno, "%s: fdopen failed", name);
129 file = xmalloc(sizeof *file);
130 file->name = xstrdup(name);
131 file->lockfile = lockfile;
132 file->stream = stream;
133 file->prev_offset = 0;
135 file->read_error = NULL;
136 file->write_error = NULL;
137 file->mode = OVSDB_LOG_READ;
144 lockfile_unlock(lockfile);
150 ovsdb_log_close(struct ovsdb_log *file)
154 fclose(file->stream);
155 lockfile_unlock(file->lockfile);
156 ovsdb_error_destroy(file->read_error);
157 ovsdb_error_destroy(file->write_error);
162 static const char magic[] = "OVSDB JSON ";
165 parse_header(char *header, unsigned long int *length,
166 uint8_t sha1[SHA1_DIGEST_SIZE])
170 /* 'header' must consist of a magic string... */
171 if (strncmp(header, magic, strlen(magic))) {
175 /* ...followed by a length in bytes... */
176 *length = strtoul(header + strlen(magic), &p, 10);
177 if (!*length || *length == ULONG_MAX || *p != ' ') {
182 /* ...followed by a SHA-1 hash... */
183 if (!sha1_from_hex(sha1, p)) {
186 p += SHA1_HEX_DIGEST_LEN;
188 /* ...and ended by a new-line. */
196 struct ovsdb_log_read_cbdata {
198 struct ovsdb_log *file;
200 unsigned long length;
203 static struct ovsdb_error *
204 parse_body(struct ovsdb_log *file, off_t offset, unsigned long int length,
205 uint8_t sha1[SHA1_DIGEST_SIZE], struct json **jsonp)
207 struct json_parser *parser;
211 parser = json_parser_create(JSPF_TRAILER);
217 chunk = MIN(length, sizeof input);
218 if (fread(input, 1, chunk, file->stream) != chunk) {
219 json_parser_abort(parser);
220 return ovsdb_io_error(ferror(file->stream) ? errno : EOF,
221 "%s: error reading %lu bytes "
222 "starting at offset %lld", file->name,
223 length, (long long int) offset);
225 sha1_update(&ctx, input, chunk);
226 json_parser_feed(parser, input, chunk);
230 sha1_final(&ctx, sha1);
231 *jsonp = json_parser_finish(parser);
236 ovsdb_log_read(struct ovsdb_log *file, struct json **jsonp)
238 uint8_t expected_sha1[SHA1_DIGEST_SIZE];
239 uint8_t actual_sha1[SHA1_DIGEST_SIZE];
240 struct ovsdb_error *error;
242 unsigned long data_length;
246 *jsonp = json = NULL;
248 if (file->read_error) {
249 return ovsdb_error_clone(file->read_error);
250 } else if (file->mode == OVSDB_LOG_WRITE) {
251 return OVSDB_BUG("reading file in write mode");
254 if (!fgets(header, sizeof header, file->stream)) {
255 if (feof(file->stream)) {
258 error = ovsdb_io_error(errno, "%s: read failed", file->name);
263 if (!parse_header(header, &data_length, expected_sha1)) {
264 error = ovsdb_syntax_error(NULL, NULL, "%s: parse error at offset "
265 "%lld in header line \"%.*s\"",
266 file->name, (long long int) file->offset,
267 (int) strcspn(header, "\n"), header);
271 data_offset = file->offset + strlen(header);
272 error = parse_body(file, data_offset, data_length, actual_sha1, &json);
277 if (memcmp(expected_sha1, actual_sha1, SHA1_DIGEST_SIZE)) {
278 error = ovsdb_syntax_error(NULL, NULL, "%s: %lu bytes starting at "
279 "offset %lld have SHA-1 hash "SHA1_FMT" "
280 "but should have hash "SHA1_FMT,
281 file->name, data_length,
282 (long long int) data_offset,
283 SHA1_ARGS(actual_sha1),
284 SHA1_ARGS(expected_sha1));
288 if (json->type == JSON_STRING) {
289 error = ovsdb_syntax_error(NULL, NULL, "%s: %lu bytes starting at "
290 "offset %lld are not valid JSON (%s)",
291 file->name, data_length,
292 (long long int) data_offset,
297 file->prev_offset = file->offset;
298 file->offset = data_offset + data_length;
303 file->read_error = ovsdb_error_clone(error);
308 /* Causes the log record read by the previous call to ovsdb_log_read() to be
309 * effectively discarded. The next call to ovsdb_log_write() will overwrite
310 * that previously read record.
312 * Calling this function more than once has no additional effect.
314 * This function is useful when ovsdb_log_read() successfully reads a record
315 * but that record does not make sense at a higher level (e.g. it specifies an
316 * invalid transaction). */
318 ovsdb_log_unread(struct ovsdb_log *file)
320 ovs_assert(file->mode == OVSDB_LOG_READ);
321 file->offset = file->prev_offset;
325 ovsdb_log_write(struct ovsdb_log *file, struct json *json)
327 uint8_t sha1[SHA1_DIGEST_SIZE];
328 struct ovsdb_error *error;
335 if (file->write_error) {
336 return ovsdb_error_clone(file->write_error);
337 } else if (file->mode == OVSDB_LOG_READ) {
338 file->mode = OVSDB_LOG_WRITE;
339 if (fseeko(file->stream, file->offset, SEEK_SET)) {
340 error = ovsdb_io_error(errno, "%s: cannot seek to offset %lld",
341 file->name, (long long int) file->offset);
344 if (ftruncate(fileno(file->stream), file->offset)) {
345 error = ovsdb_io_error(errno, "%s: cannot truncate to length %lld",
346 file->name, (long long int) file->offset);
351 if (json->type != JSON_OBJECT && json->type != JSON_ARRAY) {
352 error = OVSDB_BUG("bad JSON type");
356 /* Compose content. Add a new-line (replacing the null terminator) to make
357 * the file easier to read, even though it has no semantic value. */
358 json_string = json_to_string(json, 0);
359 length = strlen(json_string) + 1;
360 json_string[length - 1] = '\n';
362 /* Compose header. */
363 sha1_bytes(json_string, length, sha1);
364 snprintf(header, sizeof header, "%s%zu "SHA1_FMT"\n",
365 magic, length, SHA1_ARGS(sha1));
368 if (fwrite(header, strlen(header), 1, file->stream) != 1
369 || fwrite(json_string, length, 1, file->stream) != 1
370 || fflush(file->stream))
372 error = ovsdb_io_error(errno, "%s: write failed", file->name);
374 /* Remove any partially written data, ignoring errors since there is
375 * nothing further we can do. */
376 ignore(ftruncate(fileno(file->stream), file->offset));
381 file->offset += strlen(header) + length;
386 file->write_error = ovsdb_error_clone(error);
392 ovsdb_log_commit(struct ovsdb_log *file)
394 if (fsync(fileno(file->stream))) {
395 return ovsdb_io_error(errno, "%s: fsync failed", file->name);
400 /* Returns the current offset into the file backing 'log', in bytes. This
401 * reflects the number of bytes that have been read or written in the file. If
402 * the whole file has been read, this is the file size. */
404 ovsdb_log_get_offset(const struct ovsdb_log *log)