X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ovsdb%2Flog.c;h=48fa847912cb5a9330c9fac72c3783483a5e10fa;hb=c5cf10598f8c9f4428291e9df3ecd72a05fb1ccf;hp=9c2e277ce4a642fa953f00d95e152911bc5dd785;hpb=58fda1dab104041fc693032475ec4662c1a52849;p=sliver-openvswitch.git diff --git a/ovsdb/log.c b/ovsdb/log.c index 9c2e277ce..48fa84791 100644 --- a/ovsdb/log.c +++ b/ovsdb/log.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2009 Nicira Networks +/* Copyright (c) 2009, 2010, 2011, 2012, 2013 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,11 +17,11 @@ #include "log.h" -#include #include #include #include #include +#include #include #include "json.h" @@ -29,43 +29,54 @@ #include "ovsdb.h" #include "ovsdb-error.h" #include "sha1.h" +#include "socket-util.h" #include "transaction.h" #include "util.h" -#define THIS_MODULE VLM_ovsdb_log -#include "vlog.h" - enum ovsdb_log_mode { OVSDB_LOG_READ, OVSDB_LOG_WRITE }; struct ovsdb_log { + off_t prev_offset; off_t offset; char *name; struct lockfile *lockfile; FILE *stream; struct ovsdb_error *read_error; - struct ovsdb_error *write_error; + bool write_error; enum ovsdb_log_mode mode; }; +/* Attempts to open 'name' with the specified 'open_mode'. On success, stores + * the new log into '*filep' and returns NULL; otherwise returns NULL and + * stores NULL into '*filep'. + * + * Whether the file will be locked using lockfile_lock() depends on 'locking': + * use true to lock it, false not to lock it, or -1 to lock it only if + * 'open_mode' is a mode that allows writing. + */ struct ovsdb_error * -ovsdb_log_open(const char *name, int flags, struct ovsdb_log **filep) +ovsdb_log_open(const char *name, enum ovsdb_log_open_mode open_mode, + int locking, struct ovsdb_log **filep) { struct lockfile *lockfile; struct ovsdb_error *error; struct ovsdb_log *file; struct stat s; FILE *stream; - int accmode; + int flags; int fd; *filep = NULL; - accmode = flags & O_ACCMODE; - if (accmode == O_RDWR || accmode == O_WRONLY) { - int retval = lockfile_lock(name, 0, &lockfile); + ovs_assert(locking == -1 || locking == false || locking == true); + if (locking < 0) { + locking = open_mode != OVSDB_LOG_READ_ONLY; + } + if (locking) { + int retval = lockfile_lock(name, &lockfile); if (retval) { error = ovsdb_io_error(retval, "%s: failed to lock lockfile", name); @@ -75,9 +86,31 @@ ovsdb_log_open(const char *name, int flags, struct ovsdb_log **filep) lockfile = NULL; } + if (open_mode == OVSDB_LOG_READ_ONLY) { + flags = O_RDONLY; + } else if (open_mode == OVSDB_LOG_READ_WRITE) { + flags = O_RDWR; + } else if (open_mode == OVSDB_LOG_CREATE) { +#ifndef _WIN32 + if (stat(name, &s) == -1 && errno == ENOENT + && lstat(name, &s) == 0 && S_ISLNK(s.st_mode)) { + /* 'name' is a dangling symlink. We want to create the file that + * the symlink points to, but POSIX says that open() with O_EXCL + * must fail with EEXIST if the named file is a symlink. So, we + * have to leave off O_EXCL and accept the race. */ + flags = O_RDWR | O_CREAT; + } else { + flags = O_RDWR | O_CREAT | O_EXCL; + } +#else + flags = O_RDWR | O_CREAT | O_EXCL; +#endif + } else { + OVS_NOT_REACHED(); + } fd = open(name, flags, 0666); if (fd < 0) { - const char *op = flags & O_CREAT && flags & O_EXCL ? "create" : "open"; + const char *op = open_mode == OVSDB_LOG_CREATE ? "create" : "open"; error = ovsdb_io_error(errno, "%s: %s failed", op, name); goto error_unlock; } @@ -85,22 +118,10 @@ ovsdb_log_open(const char *name, int flags, struct ovsdb_log **filep) if (!fstat(fd, &s) && s.st_size == 0) { /* It's (probably) a new file so fsync() its parent directory to ensure * that its directory entry is committed to disk. */ - char *dir = dir_name(name); - int dirfd = open(dir, O_RDONLY); - if (dirfd >= 0) { - if (fsync(dirfd) && errno != EINVAL) { - VLOG_ERR("%s: fsync failed (%s)", dir, strerror(errno)); - } - close(dirfd); - } else { - VLOG_ERR("%s: open failed (%s)", dir, strerror(errno)); - } - free(dir); + fsync_parent_dir(name); } - stream = fdopen(fd, (accmode == O_RDONLY ? "rb" - : accmode == O_WRONLY ? "wb" - : "w+b")); + stream = fdopen(fd, open_mode == OVSDB_LOG_READ_ONLY ? "rb" : "w+b"); if (!stream) { error = ovsdb_io_error(errno, "%s: fdopen failed", name); goto error_close; @@ -110,9 +131,10 @@ ovsdb_log_open(const char *name, int flags, struct ovsdb_log **filep) file->name = xstrdup(name); file->lockfile = lockfile; file->stream = stream; + file->prev_offset = 0; file->offset = 0; file->read_error = NULL; - file->write_error = NULL; + file->write_error = false; file->mode = OVSDB_LOG_READ; *filep = file; return NULL; @@ -133,7 +155,6 @@ ovsdb_log_close(struct ovsdb_log *file) fclose(file->stream); lockfile_unlock(file->lockfile); ovsdb_error_destroy(file->read_error); - ovsdb_error_destroy(file->write_error); free(file); } } @@ -183,14 +204,12 @@ static struct ovsdb_error * parse_body(struct ovsdb_log *file, off_t offset, unsigned long int length, uint8_t sha1[SHA1_DIGEST_SIZE], struct json **jsonp) { - unsigned long int bytes_left; struct json_parser *parser; struct sha1_ctx ctx; sha1_init(&ctx); parser = json_parser_create(JSPF_TRAILER); - bytes_left = length; while (length > 0) { char input[BUFSIZ]; int chunk; @@ -275,9 +294,10 @@ ovsdb_log_read(struct ovsdb_log *file, struct json **jsonp) goto error; } + file->prev_offset = file->offset; file->offset = data_offset + data_length; *jsonp = json; - return 0; + return NULL; error: file->read_error = ovsdb_error_clone(error); @@ -285,6 +305,22 @@ error: return error; } +/* Causes the log record read by the previous call to ovsdb_log_read() to be + * effectively discarded. The next call to ovsdb_log_write() will overwrite + * that previously read record. + * + * Calling this function more than once has no additional effect. + * + * This function is useful when ovsdb_log_read() successfully reads a record + * but that record does not make sense at a higher level (e.g. it specifies an + * invalid transaction). */ +void +ovsdb_log_unread(struct ovsdb_log *file) +{ + ovs_assert(file->mode == OVSDB_LOG_READ); + file->offset = file->prev_offset; +} + struct ovsdb_error * ovsdb_log_write(struct ovsdb_log *file, struct json *json) { @@ -296,10 +332,9 @@ ovsdb_log_write(struct ovsdb_log *file, struct json *json) json_string = NULL; - if (file->write_error) { - return ovsdb_error_clone(file->write_error); - } else if (file->mode == OVSDB_LOG_READ) { + if (file->mode == OVSDB_LOG_READ || file->write_error) { file->mode = OVSDB_LOG_WRITE; + file->write_error = false; if (fseeko(file->stream, file->offset, SEEK_SET)) { error = ovsdb_io_error(errno, "%s: cannot seek to offset %lld", file->name, (long long int) file->offset); @@ -325,7 +360,7 @@ ovsdb_log_write(struct ovsdb_log *file, struct json *json) /* Compose header. */ sha1_bytes(json_string, length, sha1); - snprintf(header, sizeof header, "%s%zu "SHA1_FMT"\n", + snprintf(header, sizeof header, "%s%"PRIuSIZE" "SHA1_FMT"\n", magic, length, SHA1_ARGS(sha1)); /* Write. */ @@ -337,17 +372,17 @@ ovsdb_log_write(struct ovsdb_log *file, struct json *json) /* Remove any partially written data, ignoring errors since there is * nothing further we can do. */ - ftruncate(fileno(file->stream), file->offset); + ignore(ftruncate(fileno(file->stream), file->offset)); goto error; } file->offset += strlen(header) + length; free(json_string); - return 0; + return NULL; error: - file->write_error = ovsdb_error_clone(error); + file->write_error = true; free(json_string); return error; } @@ -358,6 +393,14 @@ ovsdb_log_commit(struct ovsdb_log *file) if (fsync(fileno(file->stream))) { return ovsdb_io_error(errno, "%s: fsync failed", file->name); } - return 0; + return NULL; } +/* Returns the current offset into the file backing 'log', in bytes. This + * reflects the number of bytes that have been read or written in the file. If + * the whole file has been read, this is the file size. */ +off_t +ovsdb_log_get_offset(const struct ovsdb_log *log) +{ + return log->offset; +}