lib/lockfile.c

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