X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ovsdb%2Flog.c;h=f0926c0e6d976c138ffe3b16867323f7e47514a4;hb=refs%2Fheads%2Fbranch-1.5;hp=9c2e277ce4a642fa953f00d95e152911bc5dd785;hpb=58fda1dab104041fc693032475ec4662c1a52849;p=sliver-openvswitch.git

diff --git a/ovsdb/log.c b/ovsdb/log.c
index 9c2e277ce..f0926c0e6 100644
--- a/ovsdb/log.c
+++ b/ovsdb/log.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009 Nicira Networks
+/* Copyright (c) 2009, 2010, 2011 Nicira Networks
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,7 @@
 #include <fcntl.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/stat.h>
 #include <unistd.h>
 
 #include "json.h"
@@ -29,18 +30,20 @@
 #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"
 
+VLOG_DEFINE_THIS_MODULE(ovsdb_log);
+
 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;
@@ -50,21 +53,33 @@ struct ovsdb_log {
     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) {
+    assert(locking == -1 || locking == false || locking == true);
+    if (locking < 0) {
+        locking = open_mode != OVSDB_LOG_READ_ONLY;
+    }
+    if (locking) {
         int retval = lockfile_lock(name, 0, &lockfile);
         if (retval) {
             error = ovsdb_io_error(retval, "%s: failed to lock lockfile",
@@ -75,9 +90,18 @@ 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) {
+        flags = O_RDWR | O_CREAT | O_EXCL;
+    } else {
+        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 +109,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,6 +122,7 @@ 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;
@@ -183,14 +196,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 +286,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 +297,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)
+{
+    assert(file->mode == OVSDB_LOG_READ);
+    file->offset = file->prev_offset;
+}
+
 struct ovsdb_error *
 ovsdb_log_write(struct ovsdb_log *file, struct json *json)
 {
@@ -337,14 +365,14 @@ 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);
@@ -358,6 +386,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;
+}