-/* 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.
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
+#include <sys/stat.h>
#include <unistd.h>
#include "json.h"
#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;
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",
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;
}
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;
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;
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;
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);
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)
{
/* 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);
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;
+}
git://git.onelab.eu / sliver-openvswitch.git / blobdiff