lib/lockfile.c

   1  /* Copyright (c) 2008, 2009 Nicira Networks
   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 "lockfile.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 "coverage.h"
  28 #include "hash.h"
  29 #include "hmap.h"
  30 #include "timeval.h"
  31 #include "util.h"
  32
  33 #define THIS_MODULE VLM_lockfile
  34 #include "vlog.h"
  35
  36 struct lockfile {
  37     struct hmap_node hmap_node;
  38     char *name;
  39     dev_t device;
  40     ino_t inode;
  41     int fd;
  42 };
  43
  44 /* Lock table.
  45  *
  46  * We have to do this stupid dance because POSIX says that closing *any* file
  47  * descriptor for a file on which a process holds a lock drops *all* locks on
  48  * that file.  That means that we can't afford to open a lockfile more than
  49  * once. */
  50 static struct hmap lock_table = HMAP_INITIALIZER(&lock_table);
  51
  52 static void lockfile_unhash(struct lockfile *);
  53 static int lockfile_try_lock(const char *name, bool block,
  54                              struct lockfile **lockfilep);
  55
  56 /* Returns the name of the lockfile that would be created for locking a file
  57  * named 'file_name'.  The caller is responsible for freeing the returned
  58  * name, with free(), when it is no longer needed. */
  59 char *
  60 lockfile_name(const char *file_name)
  61 {
  62     const char *slash = strrchr(file_name, '/');
  63     return (slash
  64             ? xasprintf("%.*s/.%s.~lock~",
  65                         (int) (slash - file_name), file_name, slash + 1)
  66             : xasprintf(".%s.~lock~", file_name));
  67 }
  68
  69 /* Locks the configuration file against modification by other processes and
  70  * re-reads it from disk.
  71  *
  72  * The 'timeout' specifies the maximum number of milliseconds to wait for the
  73  * config file to become free.  Use 0 to avoid waiting or INT_MAX to wait
  74  * forever.
  75  *
  76  * Returns 0 on success, otherwise a positive errno value.  On success,
  77  * '*lockfilep' is set to point to a new "struct lockfile *" that may be
  78  * unlocked with lockfile_unlock().  On failure, '*lockfilep' is set to
  79  * NULL. */
  80 int
  81 lockfile_lock(const char *file, int timeout, struct lockfile **lockfilep)
  82 {
  83     /* Only exclusive ("write") locks are supported.  This is not a problem
  84      * because the Open vSwitch code that currently uses lock files does so in
  85      * stylized ways such that any number of readers may access a file while it
  86      * is being written. */
  87     long long int start, elapsed;
  88     char *lock_name;
  89     int error;
  90
  91     COVERAGE_INC(lockfile_lock);
  92
  93     lock_name = lockfile_name(file);
  94     time_refresh();
  95     start = time_msec();
  96
  97     do {
  98         error = lockfile_try_lock(lock_name, timeout > 0, lockfilep);
  99         time_refresh();
 100         elapsed = time_msec() - start;
 101     } while (error == EINTR && (timeout == INT_MAX || elapsed < timeout));
 102
 103     if (!error) {
 104         if (elapsed) {
 105             VLOG_WARN("%s: waited %lld ms for lock file",
 106                       lock_name, elapsed);
 107         }
 108     } else if (error == EINTR) {
 109         COVERAGE_INC(lockfile_timeout);
 110         VLOG_WARN("%s: giving up on lock file after %lld ms",
 111                   lock_name, elapsed);
 112         error = ETIMEDOUT;
 113     } else {
 114         COVERAGE_INC(lockfile_error);
 115         if (error == EACCES) {
 116             error = EAGAIN;
 117         }
 118         VLOG_WARN("%s: failed to lock file "
 119                   "(after %lld ms, with %d-ms timeout): %s",
 120                   lock_name, elapsed, timeout, strerror(error));
 121     }
 122
 123     free(lock_name);
 124     return error;
 125 }
 126
 127 /* Unlocks 'lockfile', which must have been created by a call to
 128  * lockfile_lock(), and frees 'lockfile'. */
 129 void
 130 lockfile_unlock(struct lockfile *lockfile)
 131 {
 132     if (lockfile) {
 133         COVERAGE_INC(lockfile_unlock);
 134         lockfile_unhash(lockfile);
 135         free(lockfile->name);
 136         free(lockfile);
 137     }
 138 }
 139
 140 /* Marks all the currently locked lockfiles as no longer locked.  It makes
 141  * sense to call this function after fork(), because a child created by fork()
 142  * does not hold its parents' locks. */
 143 void
 144 lockfile_postfork(void)
 145 {
 146     struct lockfile *lockfile;
 147
 148     HMAP_FOR_EACH (lockfile, struct lockfile, hmap_node, &lock_table) {
 149         if (lockfile->fd >= 0) {
 150             VLOG_WARN("%s: child does not inherit lock", lockfile->name);
 151             lockfile_unhash(lockfile);
 152         }
 153     }
 154 }
 155 \f
 156 static uint32_t
 157 lockfile_hash(dev_t device, ino_t inode)
 158 {
 159     return hash_bytes(&device, sizeof device,
 160                       hash_bytes(&inode, sizeof inode, 0));
 161 }
 162
 163 static struct lockfile *
 164 lockfile_find(dev_t device, ino_t inode)
 165 {
 166     struct lockfile *lockfile;
 167
 168     HMAP_FOR_EACH_WITH_HASH (lockfile, struct lockfile, hmap_node,
 169                              lockfile_hash(device, inode), &lock_table) {
 170         if (lockfile->device == device && lockfile->inode == inode) {
 171             return lockfile;
 172         }
 173     }
 174     return NULL;
 175 }
 176
 177 static void
 178 lockfile_unhash(struct lockfile *lockfile)
 179 {
 180     if (lockfile->fd >= 0) {
 181         close(lockfile->fd);
 182         lockfile->fd = -1;
 183         hmap_remove(&lock_table, &lockfile->hmap_node);
 184     }
 185 }
 186
 187 static struct lockfile *
 188 lockfile_register(const char *name, dev_t device, ino_t inode, int fd)
 189 {
 190     struct lockfile *lockfile;
 191
 192     lockfile = lockfile_find(device, inode);
 193     if (lockfile) {
 194         VLOG_ERR("%s: lock file disappeared and reappeared!", name);
 195         lockfile_unhash(lockfile);
 196     }
 197
 198     lockfile = xmalloc(sizeof *lockfile);
 199     lockfile->name = xstrdup(name);
 200     lockfile->device = device;
 201     lockfile->inode = inode;
 202     lockfile->fd = fd;
 203     hmap_insert(&lock_table, &lockfile->hmap_node,
 204                 lockfile_hash(device, inode));
 205     return lockfile;
 206 }
 207
 208 static int
 209 lockfile_try_lock(const char *name, bool block, struct lockfile **lockfilep)
 210 {
 211     struct flock l;
 212     struct stat s;
 213     int error;
 214     int fd;
 215
 216     *lockfilep = NULL;
 217
 218     /* Open the lock file, first creating it if necessary. */
 219     for (;;) {
 220         /* Check whether we've already got a lock on that file. */
 221         if (!stat(name, &s)) {
 222             if (lockfile_find(s.st_dev, s.st_ino)) {
 223                 return EDEADLK;
 224             }
 225         } else if (errno != ENOENT) {
 226             VLOG_WARN("%s: failed to stat lock file: %s",
 227                       name, strerror(errno));
 228             return errno;
 229         }
 230
 231         /* Try to open an existing lock file. */
 232         fd = open(name, O_RDWR);
 233         if (fd >= 0) {
 234             break;
 235         } else if (errno != ENOENT) {
 236             VLOG_WARN("%s: failed to open lock file: %s",
 237                       name, strerror(errno));
 238             return errno;
 239         }
 240
 241         /* Try to create a new lock file. */
 242         VLOG_INFO("%s: lock file does not exist, creating", name);
 243         fd = open(name, O_RDWR | O_CREAT | O_EXCL, 0600);
 244         if (fd >= 0) {
 245             break;
 246         } else if (errno != EEXIST) {
 247             VLOG_WARN("%s: failed to create lock file: %s",
 248                       name, strerror(errno));
 249             return errno;
 250         }
 251
 252         /* Someone else created the lock file.  Try again. */
 253     }
 254
 255     /* Get the inode and device number for the lock table. */
 256     if (fstat(fd, &s)) {
 257         VLOG_ERR("%s: failed to fstat lock file: %s", name, strerror(errno));
 258         close(fd);
 259         return errno;
 260     }
 261
 262     /* Try to lock the file. */
 263     memset(&l, 0, sizeof l);
 264     l.l_type = F_WRLCK;
 265     l.l_whence = SEEK_SET;
 266     l.l_start = 0;
 267     l.l_len = 0;
 268
 269     time_disable_restart();
 270     error = fcntl(fd, block ? F_SETLKW : F_SETLK, &l) == -1 ? errno : 0;
 271     time_enable_restart();
 272
 273     if (!error) {
 274         *lockfilep = lockfile_register(name, s.st_dev, s.st_ino, fd);
 275     } else {
 276         close(fd);
 277     }
 278     return error;
 279 }
 280