2
0
mirror of https://github.com/openvswitch/ovs synced 2025-08-22 09:58:01 +00:00
ovs/lib/lockfile.c
William Tu ae2d6e3f5b lockfile: Fix OVS_REQUIRES macro.
Pass lock objects, not their addresses, to the annotation macros.

Fixes: f21fa45f3085 ("lockfile: Minor code cleanup.")
Tested-at: https://travis-ci.org/github/williamtu/ovs-travis/builds/666098338
Signed-off-by: William Tu <u9012063@gmail.com>
Acked-by: Ben Pfaff <blp@ovn.org>
2020-03-24 07:36:14 -07:00

367 lines
10 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <config.h>
#include "lockfile.h"
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include "coverage.h"
#include "hash.h"
#include "openvswitch/hmap.h"
#include "ovs-thread.h"
#include "timeval.h"
#include "util.h"
#include "openvswitch/vlog.h"
VLOG_DEFINE_THIS_MODULE(lockfile);
COVERAGE_DEFINE(lockfile_lock);
COVERAGE_DEFINE(lockfile_error);
COVERAGE_DEFINE(lockfile_unlock);
struct lockfile {
struct hmap_node hmap_node;
char *name;
dev_t device;
ino_t inode;
int fd;
HANDLE lock_handle;
};
/* Lock table.
*
* We have to do this stupid dance because POSIX says that closing *any* file
* descriptor for a file on which a process holds a lock drops *all* locks on
* that file. That means that we can't afford to open a lockfile more than
* once. */
static struct ovs_mutex lock_table_mutex = OVS_MUTEX_INITIALIZER;
static struct hmap lock_table__ = HMAP_INITIALIZER(&lock_table__);
static struct hmap *const lock_table OVS_GUARDED_BY(lock_table_mutex)
= &lock_table__;
static void lockfile_unhash(struct lockfile *);
static int lockfile_try_lock(const char *name, pid_t *pidp,
struct lockfile **lockfilep)
OVS_REQUIRES(lock_table_mutex);
static void lockfile_do_unlock(struct lockfile * lockfile)
OVS_REQUIRES(lock_table_mutex);
/* Returns the name of the lockfile that would be created for locking a file
* named 'filename_'. The caller is responsible for freeing the returned name,
* with free(), when it is no longer needed. */
char *
lockfile_name(const char *filename_)
{
char *filename;
const char *slash;
char *lockname;
/* If 'filename_' is a symlink, base the name of the lockfile on the
* symlink's target rather than the name of the symlink. That way, if a
* file is symlinked, but there is no symlink for its lockfile, then there
* is only a single lockfile for both the source and the target of the
* symlink, not one for each. */
filename = follow_symlinks(filename_);
slash = strrchr(filename, '/');
#ifdef _WIN32
char *backslash = strrchr(filename, '\\');
if (backslash && (!slash || backslash > slash)) {
slash = backslash;
}
#endif
lockname = (slash
? xasprintf("%.*s/.%s.~lock~",
(int) (slash - filename), filename, slash + 1)
: xasprintf(".%s.~lock~", filename));
free(filename);
return lockname;
}
/* Locks the configuration file against modification by other processes and
* re-reads it from disk.
*
* Returns 0 on success, otherwise a positive errno value. On success,
* '*lockfilep' is set to point to a new "struct lockfile *" that may be
* unlocked with lockfile_unlock(). On failure, '*lockfilep' is set to
* NULL. Will not block if the lock cannot be immediately acquired. */
int
lockfile_lock(const char *file, struct lockfile **lockfilep)
{
/* Only exclusive ("write") locks are supported. This is not a problem
* because the Open vSwitch code that currently uses lock files does so in
* stylized ways such that any number of readers may access a file while it
* is being written. */
char *lock_name;
pid_t pid;
int error;
COVERAGE_INC(lockfile_lock);
lock_name = lockfile_name(file);
ovs_mutex_lock(&lock_table_mutex);
error = lockfile_try_lock(lock_name, &pid, lockfilep);
ovs_mutex_unlock(&lock_table_mutex);
if (error) {
COVERAGE_INC(lockfile_error);
if (error == EACCES) {
error = EAGAIN;
}
if (pid == getpid()) {
VLOG_WARN("%s: cannot lock file because this process has already "
"locked it", lock_name);
} else if (pid) {
VLOG_WARN("%s: cannot lock file because it is already locked by "
"pid %ld", lock_name, (long int) pid);
} else {
VLOG_WARN("%s: failed to lock file: %s",
lock_name, ovs_strerror(error));
}
}
free(lock_name);
return error;
}
/* Unlocks 'lockfile', which must have been created by a call to
* lockfile_lock(), and frees 'lockfile'. */
void
lockfile_unlock(struct lockfile *lockfile)
{
if (lockfile) {
ovs_mutex_lock(&lock_table_mutex);
lockfile_do_unlock(lockfile);
ovs_mutex_unlock(&lock_table_mutex);
COVERAGE_INC(lockfile_unlock);
free(lockfile->name);
free(lockfile);
}
}
/* Marks all the currently locked lockfiles as no longer locked. It makes
* sense to call this function after fork(), because a child created by fork()
* does not hold its parents' locks. */
void
lockfile_postfork(void)
{
struct lockfile *lockfile;
ovs_mutex_lock(&lock_table_mutex);
HMAP_FOR_EACH (lockfile, hmap_node, lock_table) {
if (lockfile->fd >= 0) {
VLOG_WARN("%s: child does not inherit lock", lockfile->name);
lockfile_unhash(lockfile);
}
}
ovs_mutex_unlock(&lock_table_mutex);
}
static uint32_t
lockfile_hash(dev_t device, ino_t inode)
{
return hash_bytes(&device, sizeof device,
hash_bytes(&inode, sizeof inode, 0));
}
static struct lockfile *
lockfile_find(dev_t device, ino_t inode) OVS_REQUIRES(lock_table_mutex)
{
struct lockfile *lockfile;
HMAP_FOR_EACH_WITH_HASH (lockfile, hmap_node,
lockfile_hash(device, inode), lock_table) {
if (lockfile->device == device && lockfile->inode == inode) {
return lockfile;
}
}
return NULL;
}
static void
lockfile_unhash(struct lockfile *lockfile) OVS_REQUIRES(lock_table_mutex)
{
if (lockfile->fd >= 0) {
close(lockfile->fd);
lockfile->fd = -1;
hmap_remove(lock_table, &lockfile->hmap_node);
}
}
static struct lockfile *
lockfile_register(const char *name, dev_t device, ino_t inode, int fd)
OVS_REQUIRES(lock_table_mutex)
{
struct lockfile *lockfile;
lockfile = lockfile_find(device, inode);
if (lockfile) {
VLOG_ERR("%s: lock file disappeared and reappeared!", name);
lockfile_unhash(lockfile);
}
lockfile = xmalloc(sizeof *lockfile);
lockfile->name = xstrdup(name);
lockfile->device = device;
lockfile->inode = inode;
lockfile->fd = fd;
hmap_insert(lock_table, &lockfile->hmap_node,
lockfile_hash(device, inode));
return lockfile;
}
#ifdef _WIN32
static void
lockfile_do_unlock(struct lockfile *lockfile)
OVS_REQUIRES(lock_table_mutex)
{
if (lockfile->fd >= 0) {
OVERLAPPED overl;
overl.hEvent = 0;
overl.Offset = 0;
overl.OffsetHigh = 0;
UnlockFileEx(lockfile->lock_handle, 0, 1, 0, &overl);
close(lockfile->fd);
lockfile->fd = -1;
}
}
static int
lockfile_try_lock(const char *name, pid_t *pidp, struct lockfile **lockfilep)
OVS_REQUIRES(lock_table_mutex)
{
HANDLE lock_handle;
BOOL retval;
OVERLAPPED overl;
struct lockfile *lockfile;
int fd;
*pidp = 0;
fd = open(name, O_RDWR | O_CREAT, 0600);
if (fd < 0) {
VLOG_WARN("%s: failed to open lock file: %s",
name, ovs_strerror(errno));
return errno;
}
lock_handle = (HANDLE)_get_osfhandle(fd);
if (lock_handle < 0) {
VLOG_WARN("%s: failed to get the file handle: %s",
name, ovs_strerror(errno));
return errno;
}
/* Lock the file 'name' for the region that includes just the first
* byte. */
overl.hEvent = 0;
overl.Offset = 0;
overl.OffsetHigh = 0;
retval = LockFileEx(lock_handle, LOCKFILE_EXCLUSIVE_LOCK
| LOCKFILE_FAIL_IMMEDIATELY, 0, 1, 0, &overl);
if (!retval) {
VLOG_DBG("Failed to lock file : %s", ovs_lasterror_to_string());
*pidp = getpid();
return EDEADLK;
}
lockfile = xmalloc(sizeof *lockfile);
lockfile->name = xstrdup(name);
lockfile->fd = fd;
lockfile->lock_handle = lock_handle;
*lockfilep = lockfile;
return 0;
}
#else /* !_WIN32 */
static void
lockfile_do_unlock(struct lockfile *lockfile)
{
lockfile_unhash(lockfile);
}
static int
lockfile_try_lock(const char *name, pid_t *pidp, struct lockfile **lockfilep)
OVS_REQUIRES(lock_table_mutex)
{
struct flock l;
struct stat s;
int error;
int fd;
*lockfilep = NULL;
*pidp = 0;
/* Check whether we've already got a lock on that file. */
if (!stat(name, &s)) {
if (lockfile_find(s.st_dev, s.st_ino)) {
*pidp = getpid();
return EDEADLK;
}
} else if (errno != ENOENT) {
VLOG_WARN("%s: failed to stat lock file: %s",
name, ovs_strerror(errno));
return errno;
}
/* Open the lock file. */
fd = open(name, O_RDWR | O_CREAT, 0600);
if (fd < 0) {
VLOG_WARN("%s: failed to open lock file: %s",
name, ovs_strerror(errno));
return errno;
}
/* Get the inode and device number for the lock table. */
if (fstat(fd, &s)) {
VLOG_ERR("%s: failed to fstat lock file: %s",
name, ovs_strerror(errno));
close(fd);
return errno;
}
/* Try to lock the file. */
memset(&l, 0, sizeof l);
l.l_type = F_WRLCK;
l.l_whence = SEEK_SET;
l.l_start = 0;
l.l_len = 0;
error = fcntl(fd, F_SETLK, &l) == -1 ? errno : 0;
if (!error) {
*lockfilep = lockfile_register(name, s.st_dev, s.st_ino, fd);
} else {
if (!fcntl(fd, F_GETLK, &l) && l.l_type != F_UNLCK) {
*pidp = l.l_pid;
}
close(fd);
}
return error;
}
#endif