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_error);
  39 COVERAGE_DEFINE(lockfile_unlock);
  40
  41 struct lockfile {
  42     struct hmap_node hmap_node;
  43     char *name;
  44     dev_t device;
  45     ino_t inode;
  46     int fd;
  47     HANDLE lock_handle;
  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 #ifdef _WIN32
  63 static int lockfile_try_lock_windows(const char *name, pid_t *pidp,
  64                                      struct lockfile **lockfilep);
  65 static void lockfile_unlock_windows(struct lockfile * lockfile);
  66 #else
  67 static int lockfile_try_lock_posix(const char *name, pid_t *pidp,
  68                                    struct lockfile **lockfilep);
  69 #endif
  70
  71 /* Returns the name of the lockfile that would be created for locking a file
  72  * named 'filename_'.  The caller is responsible for freeing the returned name,
  73  * with free(), when it is no longer needed. */
  74 char *
  75 lockfile_name(const char *filename_)
  76 {
  77     char *filename;
  78     const char *slash;
  79     char *lockname;
  80
  81     /* If 'filename_' is a symlink, base the name of the lockfile on the
  82      * symlink's target rather than the name of the symlink.  That way, if a
  83      * file is symlinked, but there is no symlink for its lockfile, then there
  84      * is only a single lockfile for both the source and the target of the
  85      * symlink, not one for each. */
  86     filename = follow_symlinks(filename_);
  87     slash = strrchr(filename, '/');
  88     lockname = (slash
  89                 ? xasprintf("%.*s/.%s.~lock~",
  90                             (int) (slash - filename), filename, slash + 1)
  91                 : xasprintf(".%s.~lock~", filename));
  92     free(filename);
  93
  94     return lockname;
  95 }
  96
  97 /* Locks the configuration file against modification by other processes and
  98  * re-reads it from disk.
  99  *
 100  * Returns 0 on success, otherwise a positive errno value.  On success,
 101  * '*lockfilep' is set to point to a new "struct lockfile *" that may be
 102  * unlocked with lockfile_unlock().  On failure, '*lockfilep' is set to
 103  * NULL.  Will not block if the lock cannot be immediately acquired. */
 104 int
 105 lockfile_lock(const char *file, struct lockfile **lockfilep)
 106 {
 107     /* Only exclusive ("write") locks are supported.  This is not a problem
 108      * because the Open vSwitch code that currently uses lock files does so in
 109      * stylized ways such that any number of readers may access a file while it
 110      * is being written. */
 111     char *lock_name;
 112     pid_t pid;
 113     int error;
 114
 115     COVERAGE_INC(lockfile_lock);
 116
 117     lock_name = lockfile_name(file);
 118
 119     ovs_mutex_lock(&lock_table_mutex);
 120 #ifdef _WIN32
 121     error = lockfile_try_lock_windows(lock_name, &pid, lockfilep);
 122 #else
 123     error = lockfile_try_lock_posix(lock_name, &pid, lockfilep);
 124 #endif
 125     ovs_mutex_unlock(&lock_table_mutex);
 126
 127     if (error) {
 128         COVERAGE_INC(lockfile_error);
 129         if (error == EACCES) {
 130             error = EAGAIN;
 131         }
 132         if (pid) {
 133             VLOG_WARN("%s: cannot lock file because it is already locked by "
 134                       "pid %ld", lock_name, (long int) pid);
 135         } else {
 136             VLOG_WARN("%s: failed to lock file: %s",
 137                       lock_name, ovs_strerror(error));
 138         }
 139     }
 140
 141     free(lock_name);
 142     return error;
 143 }
 144
 145 /* Unlocks 'lockfile', which must have been created by a call to
 146  * lockfile_lock(), and frees 'lockfile'. */
 147 void
 148 lockfile_unlock(struct lockfile *lockfile)
 149 {
 150     if (lockfile) {
 151         ovs_mutex_lock(&lock_table_mutex);
 152 #ifdef _WIN32
 153         lockfile_unlock_windows(lockfile);
 154 #else
 155         lockfile_unhash(lockfile);
 156 #endif
 157         ovs_mutex_unlock(&lock_table_mutex);
 158
 159         COVERAGE_INC(lockfile_unlock);
 160         free(lockfile->name);
 161         free(lockfile);
 162     }
 163 }
 164
 165 /* Marks all the currently locked lockfiles as no longer locked.  It makes
 166  * sense to call this function after fork(), because a child created by fork()
 167  * does not hold its parents' locks. */
 168 void
 169 lockfile_postfork(void)
 170 {
 171     struct lockfile *lockfile;
 172
 173     ovs_mutex_lock(&lock_table_mutex);
 174     HMAP_FOR_EACH (lockfile, hmap_node, lock_table) {
 175         if (lockfile->fd >= 0) {
 176             VLOG_WARN("%s: child does not inherit lock", lockfile->name);
 177             lockfile_unhash(lockfile);
 178         }
 179     }
 180     ovs_mutex_unlock(&lock_table_mutex);
 181 }
 182 \f
 183 static uint32_t
 184 lockfile_hash(dev_t device, ino_t inode)
 185 {
 186     return hash_bytes(&device, sizeof device,
 187                       hash_bytes(&inode, sizeof inode, 0));
 188 }
 189
 190 static struct lockfile *
 191 lockfile_find(dev_t device, ino_t inode) OVS_REQUIRES(&lock_table_mutex)
 192 {
 193     struct lockfile *lockfile;
 194
 195     HMAP_FOR_EACH_WITH_HASH (lockfile, hmap_node,
 196                              lockfile_hash(device, inode), lock_table) {
 197         if (lockfile->device == device && lockfile->inode == inode) {
 198             return lockfile;
 199         }
 200     }
 201     return NULL;
 202 }
 203
 204 static void
 205 lockfile_unhash(struct lockfile *lockfile) OVS_REQUIRES(&lock_table_mutex)
 206 {
 207     if (lockfile->fd >= 0) {
 208         close(lockfile->fd);
 209         lockfile->fd = -1;
 210         hmap_remove(lock_table, &lockfile->hmap_node);
 211     }
 212 }
 213
 214 static struct lockfile *
 215 lockfile_register(const char *name, dev_t device, ino_t inode, int fd)
 216     OVS_REQUIRES(&lock_table_mutex)
 217 {
 218     struct lockfile *lockfile;
 219
 220     lockfile = lockfile_find(device, inode);
 221     if (lockfile) {
 222         VLOG_ERR("%s: lock file disappeared and reappeared!", name);
 223         lockfile_unhash(lockfile);
 224     }
 225
 226     lockfile = xmalloc(sizeof *lockfile);
 227     lockfile->name = xstrdup(name);
 228     lockfile->device = device;
 229     lockfile->inode = inode;
 230     lockfile->fd = fd;
 231     hmap_insert(lock_table, &lockfile->hmap_node,
 232                 lockfile_hash(device, inode));
 233     return lockfile;
 234 }
 235
 236 #ifdef _WIN32
 237 static void
 238 lockfile_unlock_windows(struct lockfile *lockfile)
 239     OVS_REQUIRES(&lock_table_mutex)
 240 {
 241     if (lockfile->fd >= 0) {
 242         OVERLAPPED overl;
 243         overl.hEvent = 0;
 244         overl.Offset = 0;
 245         overl.OffsetHigh = 0;
 246         UnlockFileEx(lockfile->lock_handle, 0, 1, 0, &overl);
 247
 248         close(lockfile->fd);
 249         lockfile->fd = -1;
 250     }
 251 }
 252
 253 static int
 254 lockfile_try_lock_windows(const char *name, pid_t *pidp,
 255                           struct lockfile **lockfilep)
 256     OVS_REQUIRES(&lock_table_mutex)
 257 {
 258     HANDLE lock_handle;
 259     BOOL retval;
 260     OVERLAPPED overl;
 261     struct lockfile *lockfile;
 262     int fd;
 263
 264     *pidp = 0;
 265
 266     fd = open(name, O_RDWR | O_CREAT, 0600);
 267     if (fd < 0) {
 268         VLOG_WARN("%s: failed to open lock file: %s",
 269                    name, ovs_strerror(errno));
 270         return errno;
 271     }
 272
 273     lock_handle = (HANDLE)_get_osfhandle(fd);
 274     if (lock_handle < 0) {
 275         VLOG_WARN("%s: failed to get the file handle: %s",
 276                    name, ovs_strerror(errno));
 277         return errno;
 278     }
 279
 280     /* Lock the file 'name' for the region that includes just the first
 281      * byte. */
 282     overl.hEvent = 0;
 283     overl.Offset = 0;
 284     overl.OffsetHigh = 0;
 285     retval = LockFileEx(lock_handle, LOCKFILE_EXCLUSIVE_LOCK
 286                         | LOCKFILE_FAIL_IMMEDIATELY, 0, 1, 0, &overl);
 287     if (!retval) {
 288         VLOG_WARN("Failed to lock file : %s", ovs_lasterror_to_string());
 289         return EEXIST;
 290     }
 291
 292     lockfile = xmalloc(sizeof *lockfile);
 293     lockfile->name = xstrdup(name);
 294     lockfile->fd = fd;
 295     lockfile->lock_handle = lock_handle;
 296
 297     *lockfilep = lockfile;
 298     return 0;
 299 }
 300 #endif
 301
 302 #ifndef _WIN32
 303 static int
 304 lockfile_try_lock_posix(const char *name, pid_t *pidp,
 305                         struct lockfile **lockfilep)
 306     OVS_REQUIRES(&lock_table_mutex)
 307 {
 308     struct flock l;
 309     struct stat s;
 310     int error;
 311     int fd;
 312
 313     *lockfilep = NULL;
 314     *pidp = 0;
 315
 316     /* Check whether we've already got a lock on that file. */
 317     if (!stat(name, &s)) {
 318         if (lockfile_find(s.st_dev, s.st_ino)) {
 319             return EDEADLK;
 320         }
 321     } else if (errno != ENOENT) {
 322         VLOG_WARN("%s: failed to stat lock file: %s",
 323                   name, ovs_strerror(errno));
 324         return errno;
 325     }
 326
 327     /* Open the lock file. */
 328     fd = open(name, O_RDWR | O_CREAT, 0600);
 329     if (fd < 0) {
 330         VLOG_WARN("%s: failed to open lock file: %s",
 331                   name, ovs_strerror(errno));
 332         return errno;
 333     }
 334
 335     /* Get the inode and device number for the lock table. */
 336     if (fstat(fd, &s)) {
 337         VLOG_ERR("%s: failed to fstat lock file: %s",
 338                  name, ovs_strerror(errno));
 339         close(fd);
 340         return errno;
 341     }
 342
 343     /* Try to lock the file. */
 344     memset(&l, 0, sizeof l);
 345     l.l_type = F_WRLCK;
 346     l.l_whence = SEEK_SET;
 347     l.l_start = 0;
 348     l.l_len = 0;
 349
 350     error = fcntl(fd, F_SETLK, &l) == -1 ? errno : 0;
 351
 352     if (!error) {
 353         *lockfilep = lockfile_register(name, s.st_dev, s.st_ino, fd);
 354     } else {
 355         if (!fcntl(fd, F_GETLK, &l) && l.l_type != F_UNLCK) {
 356             *pidp = l.l_pid;
 357         }
 358         close(fd);
 359     }
 360     return error;
 361 }
 362 #endif