ovsdb/log.c

   1 /* Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
   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 "log.h"
  19
  20 #include <errno.h>
  21 #include <fcntl.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <sys/stat.h>
  25 #include <unistd.h>
  26
  27 #include "json.h"
  28 #include "lockfile.h"
  29 #include "ovsdb.h"
  30 #include "ovsdb-error.h"
  31 #include "sha1.h"
  32 #include "socket-util.h"
  33 #include "transaction.h"
  34 #include "util.h"
  35
  36 enum ovsdb_log_mode {
  37     OVSDB_LOG_READ,
  38     OVSDB_LOG_WRITE
  39 };
  40
  41 struct ovsdb_log {
  42     off_t prev_offset;
  43     off_t offset;
  44     char *name;
  45     struct lockfile *lockfile;
  46     FILE *stream;
  47     struct ovsdb_error *read_error;
  48     bool write_error;
  49     enum ovsdb_log_mode mode;
  50 };
  51
  52 /* Attempts to open 'name' with the specified 'open_mode'.  On success, stores
  53  * the new log into '*filep' and returns NULL; otherwise returns NULL and
  54  * stores NULL into '*filep'.
  55  *
  56  * Whether the file will be locked using lockfile_lock() depends on 'locking':
  57  * use true to lock it, false not to lock it, or -1 to lock it only if
  58  * 'open_mode' is a mode that allows writing.
  59  */
  60 struct ovsdb_error *
  61 ovsdb_log_open(const char *name, enum ovsdb_log_open_mode open_mode,
  62                int locking, struct ovsdb_log **filep)
  63 {
  64     struct lockfile *lockfile;
  65     struct ovsdb_error *error;
  66     struct ovsdb_log *file;
  67     struct stat s;
  68     FILE *stream;
  69     int flags;
  70     int fd;
  71
  72     *filep = NULL;
  73
  74     ovs_assert(locking == -1 || locking == false || locking == true);
  75     if (locking < 0) {
  76         locking = open_mode != OVSDB_LOG_READ_ONLY;
  77     }
  78     if (locking) {
  79         int retval = lockfile_lock(name, &lockfile);
  80         if (retval) {
  81             error = ovsdb_io_error(retval, "%s: failed to lock lockfile",
  82                                    name);
  83             goto error;
  84         }
  85     } else {
  86         lockfile = NULL;
  87     }
  88
  89     if (open_mode == OVSDB_LOG_READ_ONLY) {
  90         flags = O_RDONLY;
  91     } else if (open_mode == OVSDB_LOG_READ_WRITE) {
  92         flags = O_RDWR;
  93     } else if (open_mode == OVSDB_LOG_CREATE) {
  94         if (stat(name, &s) == -1 && errno == ENOENT
  95             && lstat(name, &s) == 0 && S_ISLNK(s.st_mode)) {
  96             /* 'name' is a dangling symlink.  We want to create the file that
  97              * the symlink points to, but POSIX says that open() with O_EXCL
  98              * must fail with EEXIST if the named file is a symlink.  So, we
  99              * have to leave off O_EXCL and accept the race. */
 100             flags = O_RDWR | O_CREAT;
 101         } else {
 102             flags = O_RDWR | O_CREAT | O_EXCL;
 103         }
 104     } else {
 105         NOT_REACHED();
 106     }
 107     fd = open(name, flags, 0666);
 108     if (fd < 0) {
 109         const char *op = open_mode == OVSDB_LOG_CREATE ? "create" : "open";
 110         error = ovsdb_io_error(errno, "%s: %s failed", op, name);
 111         goto error_unlock;
 112     }
 113
 114     if (!fstat(fd, &s) && s.st_size == 0) {
 115         /* It's (probably) a new file so fsync() its parent directory to ensure
 116          * that its directory entry is committed to disk. */
 117         fsync_parent_dir(name);
 118     }
 119
 120     stream = fdopen(fd, open_mode == OVSDB_LOG_READ_ONLY ? "rb" : "w+b");
 121     if (!stream) {
 122         error = ovsdb_io_error(errno, "%s: fdopen failed", name);
 123         goto error_close;
 124     }
 125
 126     file = xmalloc(sizeof *file);
 127     file->name = xstrdup(name);
 128     file->lockfile = lockfile;
 129     file->stream = stream;
 130     file->prev_offset = 0;
 131     file->offset = 0;
 132     file->read_error = NULL;
 133     file->write_error = false;
 134     file->mode = OVSDB_LOG_READ;
 135     *filep = file;
 136     return NULL;
 137
 138 error_close:
 139     close(fd);
 140 error_unlock:
 141     lockfile_unlock(lockfile);
 142 error:
 143     return error;
 144 }
 145
 146 void
 147 ovsdb_log_close(struct ovsdb_log *file)
 148 {
 149     if (file) {
 150         free(file->name);
 151         fclose(file->stream);
 152         lockfile_unlock(file->lockfile);
 153         ovsdb_error_destroy(file->read_error);
 154         free(file);
 155     }
 156 }
 157
 158 static const char magic[] = "OVSDB JSON ";
 159
 160 static bool
 161 parse_header(char *header, unsigned long int *length,
 162              uint8_t sha1[SHA1_DIGEST_SIZE])
 163 {
 164     char *p;
 165
 166     /* 'header' must consist of a magic string... */
 167     if (strncmp(header, magic, strlen(magic))) {
 168         return false;
 169     }
 170
 171     /* ...followed by a length in bytes... */
 172     *length = strtoul(header + strlen(magic), &p, 10);
 173     if (!*length || *length == ULONG_MAX || *p != ' ') {
 174         return false;
 175     }
 176     p++;
 177
 178     /* ...followed by a SHA-1 hash... */
 179     if (!sha1_from_hex(sha1, p)) {
 180         return false;
 181     }
 182     p += SHA1_HEX_DIGEST_LEN;
 183
 184     /* ...and ended by a new-line. */
 185     if (*p != '\n') {
 186         return false;
 187     }
 188
 189     return true;
 190 }
 191
 192 struct ovsdb_log_read_cbdata {
 193     char input[4096];
 194     struct ovsdb_log *file;
 195     int error;
 196     unsigned long length;
 197 };
 198
 199 static struct ovsdb_error *
 200 parse_body(struct ovsdb_log *file, off_t offset, unsigned long int length,
 201            uint8_t sha1[SHA1_DIGEST_SIZE], struct json **jsonp)
 202 {
 203     struct json_parser *parser;
 204     struct sha1_ctx ctx;
 205
 206     sha1_init(&ctx);
 207     parser = json_parser_create(JSPF_TRAILER);
 208
 209     while (length > 0) {
 210         char input[BUFSIZ];
 211         int chunk;
 212
 213         chunk = MIN(length, sizeof input);
 214         if (fread(input, 1, chunk, file->stream) != chunk) {
 215             json_parser_abort(parser);
 216             return ovsdb_io_error(ferror(file->stream) ? errno : EOF,
 217                                   "%s: error reading %lu bytes "
 218                                   "starting at offset %lld", file->name,
 219                                   length, (long long int) offset);
 220         }
 221         sha1_update(&ctx, input, chunk);
 222         json_parser_feed(parser, input, chunk);
 223         length -= chunk;
 224     }
 225
 226     sha1_final(&ctx, sha1);
 227     *jsonp = json_parser_finish(parser);
 228     return NULL;
 229 }
 230
 231 struct ovsdb_error *
 232 ovsdb_log_read(struct ovsdb_log *file, struct json **jsonp)
 233 {
 234     uint8_t expected_sha1[SHA1_DIGEST_SIZE];
 235     uint8_t actual_sha1[SHA1_DIGEST_SIZE];
 236     struct ovsdb_error *error;
 237     off_t data_offset;
 238     unsigned long data_length;
 239     struct json *json;
 240     char header[128];
 241
 242     *jsonp = json = NULL;
 243
 244     if (file->read_error) {
 245         return ovsdb_error_clone(file->read_error);
 246     } else if (file->mode == OVSDB_LOG_WRITE) {
 247         return OVSDB_BUG("reading file in write mode");
 248     }
 249
 250     if (!fgets(header, sizeof header, file->stream)) {
 251         if (feof(file->stream)) {
 252             error = NULL;
 253         } else {
 254             error = ovsdb_io_error(errno, "%s: read failed", file->name);
 255         }
 256         goto error;
 257     }
 258
 259     if (!parse_header(header, &data_length, expected_sha1)) {
 260         error = ovsdb_syntax_error(NULL, NULL, "%s: parse error at offset "
 261                                    "%lld in header line \"%.*s\"",
 262                                    file->name, (long long int) file->offset,
 263                                    (int) strcspn(header, "\n"), header);
 264         goto error;
 265     }
 266
 267     data_offset = file->offset + strlen(header);
 268     error = parse_body(file, data_offset, data_length, actual_sha1, &json);
 269     if (error) {
 270         goto error;
 271     }
 272
 273     if (memcmp(expected_sha1, actual_sha1, SHA1_DIGEST_SIZE)) {
 274         error = ovsdb_syntax_error(NULL, NULL, "%s: %lu bytes starting at "
 275                                    "offset %lld have SHA-1 hash "SHA1_FMT" "
 276                                    "but should have hash "SHA1_FMT,
 277                                    file->name, data_length,
 278                                    (long long int) data_offset,
 279                                    SHA1_ARGS(actual_sha1),
 280                                    SHA1_ARGS(expected_sha1));
 281         goto error;
 282     }
 283
 284     if (json->type == JSON_STRING) {
 285         error = ovsdb_syntax_error(NULL, NULL, "%s: %lu bytes starting at "
 286                                    "offset %lld are not valid JSON (%s)",
 287                                    file->name, data_length,
 288                                    (long long int) data_offset,
 289                                    json->u.string);
 290         goto error;
 291     }
 292
 293     file->prev_offset = file->offset;
 294     file->offset = data_offset + data_length;
 295     *jsonp = json;
 296     return NULL;
 297
 298 error:
 299     file->read_error = ovsdb_error_clone(error);
 300     json_destroy(json);
 301     return error;
 302 }
 303
 304 /* Causes the log record read by the previous call to ovsdb_log_read() to be
 305  * effectively discarded.  The next call to ovsdb_log_write() will overwrite
 306  * that previously read record.
 307  *
 308  * Calling this function more than once has no additional effect.
 309  *
 310  * This function is useful when ovsdb_log_read() successfully reads a record
 311  * but that record does not make sense at a higher level (e.g. it specifies an
 312  * invalid transaction). */
 313 void
 314 ovsdb_log_unread(struct ovsdb_log *file)
 315 {
 316     ovs_assert(file->mode == OVSDB_LOG_READ);
 317     file->offset = file->prev_offset;
 318 }
 319
 320 struct ovsdb_error *
 321 ovsdb_log_write(struct ovsdb_log *file, struct json *json)
 322 {
 323     uint8_t sha1[SHA1_DIGEST_SIZE];
 324     struct ovsdb_error *error;
 325     char *json_string;
 326     char header[128];
 327     size_t length;
 328
 329     json_string = NULL;
 330
 331     if (file->mode == OVSDB_LOG_READ || file->write_error) {
 332         file->mode = OVSDB_LOG_WRITE;
 333         file->write_error = false;
 334         if (fseeko(file->stream, file->offset, SEEK_SET)) {
 335             error = ovsdb_io_error(errno, "%s: cannot seek to offset %lld",
 336                                    file->name, (long long int) file->offset);
 337             goto error;
 338         }
 339         if (ftruncate(fileno(file->stream), file->offset)) {
 340             error = ovsdb_io_error(errno, "%s: cannot truncate to length %lld",
 341                                    file->name, (long long int) file->offset);
 342             goto error;
 343         }
 344     }
 345
 346     if (json->type != JSON_OBJECT && json->type != JSON_ARRAY) {
 347         error = OVSDB_BUG("bad JSON type");
 348         goto error;
 349     }
 350
 351     /* Compose content.  Add a new-line (replacing the null terminator) to make
 352      * the file easier to read, even though it has no semantic value.  */
 353     json_string = json_to_string(json, 0);
 354     length = strlen(json_string) + 1;
 355     json_string[length - 1] = '\n';
 356
 357     /* Compose header. */
 358     sha1_bytes(json_string, length, sha1);
 359     snprintf(header, sizeof header, "%s%zu "SHA1_FMT"\n",
 360              magic, length, SHA1_ARGS(sha1));
 361
 362     /* Write. */
 363     if (fwrite(header, strlen(header), 1, file->stream) != 1
 364         || fwrite(json_string, length, 1, file->stream) != 1
 365         || fflush(file->stream))
 366     {
 367         error = ovsdb_io_error(errno, "%s: write failed", file->name);
 368
 369         /* Remove any partially written data, ignoring errors since there is
 370          * nothing further we can do. */
 371         ignore(ftruncate(fileno(file->stream), file->offset));
 372
 373         goto error;
 374     }
 375
 376     file->offset += strlen(header) + length;
 377     free(json_string);
 378     return NULL;
 379
 380 error:
 381     file->write_error = true;
 382     free(json_string);
 383     return error;
 384 }
 385
 386 struct ovsdb_error *
 387 ovsdb_log_commit(struct ovsdb_log *file)
 388 {
 389     if (fsync(fileno(file->stream))) {
 390         return ovsdb_io_error(errno, "%s: fsync failed", file->name);
 391     }
 392     return NULL;
 393 }
 394
 395 /* Returns the current offset into the file backing 'log', in bytes.  This
 396  * reflects the number of bytes that have been read or written in the file.  If
 397  * the whole file has been read, this is the file size. */
 398 off_t
 399 ovsdb_log_get_offset(const struct ovsdb_log *log)
 400 {
 401     return log->offset;
 402 }