1 /* Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
29 #include "openvswitch/hmap.h"
30 #include "ovs-thread.h"
33 #include "openvswitch/vlog.h"
35 VLOG_DEFINE_THIS_MODULE(lockfile
);
37 COVERAGE_DEFINE(lockfile_lock
);
38 COVERAGE_DEFINE(lockfile_error
);
39 COVERAGE_DEFINE(lockfile_unlock
);
42 struct hmap_node hmap_node
;
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
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
)
61 static void lockfile_unhash(struct lockfile
*);
62 static int lockfile_try_lock(const char *name
, pid_t
*pidp
,
63 struct lockfile
**lockfilep
)
64 OVS_REQUIRES(&lock_table_mutex
);
65 static void lockfile_do_unlock(struct lockfile
* lockfile
)
66 OVS_REQUIRES(&lock_table_mutex
);
68 /* Returns the name of the lockfile that would be created for locking a file
69 * named 'filename_'. The caller is responsible for freeing the returned name,
70 * with free(), when it is no longer needed. */
72 lockfile_name(const char *filename_
)
78 /* If 'filename_' is a symlink, base the name of the lockfile on the
79 * symlink's target rather than the name of the symlink. That way, if a
80 * file is symlinked, but there is no symlink for its lockfile, then there
81 * is only a single lockfile for both the source and the target of the
82 * symlink, not one for each. */
83 filename
= follow_symlinks(filename_
);
84 slash
= strrchr(filename
, '/');
87 char *backslash
= strrchr(filename
, '\\');
88 if (backslash
&& (!slash
|| backslash
> slash
)) {
94 ? xasprintf("%.*s/.%s.~lock~",
95 (int) (slash
- filename
), filename
, slash
+ 1)
96 : xasprintf(".%s.~lock~", filename
));
102 /* Locks the configuration file against modification by other processes and
103 * re-reads it from disk.
105 * Returns 0 on success, otherwise a positive errno value. On success,
106 * '*lockfilep' is set to point to a new "struct lockfile *" that may be
107 * unlocked with lockfile_unlock(). On failure, '*lockfilep' is set to
108 * NULL. Will not block if the lock cannot be immediately acquired. */
110 lockfile_lock(const char *file
, struct lockfile
**lockfilep
)
112 /* Only exclusive ("write") locks are supported. This is not a problem
113 * because the Open vSwitch code that currently uses lock files does so in
114 * stylized ways such that any number of readers may access a file while it
115 * is being written. */
120 COVERAGE_INC(lockfile_lock
);
122 lock_name
= lockfile_name(file
);
124 ovs_mutex_lock(&lock_table_mutex
);
125 error
= lockfile_try_lock(lock_name
, &pid
, lockfilep
);
126 ovs_mutex_unlock(&lock_table_mutex
);
129 COVERAGE_INC(lockfile_error
);
130 if (error
== EACCES
) {
133 if (pid
== getpid()) {
134 VLOG_WARN("%s: cannot lock file because this process has already "
135 "locked it", lock_name
);
137 VLOG_WARN("%s: cannot lock file because it is already locked by "
138 "pid %ld", lock_name
, (long int) pid
);
140 VLOG_WARN("%s: failed to lock file: %s",
141 lock_name
, ovs_strerror(error
));
149 /* Unlocks 'lockfile', which must have been created by a call to
150 * lockfile_lock(), and frees 'lockfile'. */
152 lockfile_unlock(struct lockfile
*lockfile
)
155 ovs_mutex_lock(&lock_table_mutex
);
156 lockfile_do_unlock(lockfile
);
157 ovs_mutex_unlock(&lock_table_mutex
);
159 COVERAGE_INC(lockfile_unlock
);
160 free(lockfile
->name
);
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. */
169 lockfile_postfork(void)
171 struct lockfile
*lockfile
;
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
);
180 ovs_mutex_unlock(&lock_table_mutex
);
184 lockfile_hash(dev_t device
, ino_t inode
)
186 return hash_bytes(&device
, sizeof device
,
187 hash_bytes(&inode
, sizeof inode
, 0));
190 static struct lockfile
*
191 lockfile_find(dev_t device
, ino_t inode
) OVS_REQUIRES(&lock_table_mutex
)
193 struct lockfile
*lockfile
;
195 HMAP_FOR_EACH_WITH_HASH (lockfile
, hmap_node
,
196 lockfile_hash(device
, inode
), lock_table
) {
197 if (lockfile
->device
== device
&& lockfile
->inode
== inode
) {
205 lockfile_unhash(struct lockfile
*lockfile
) OVS_REQUIRES(&lock_table_mutex
)
207 if (lockfile
->fd
>= 0) {
210 hmap_remove(lock_table
, &lockfile
->hmap_node
);
214 static struct lockfile
*
215 lockfile_register(const char *name
, dev_t device
, ino_t inode
, int fd
)
216 OVS_REQUIRES(&lock_table_mutex
)
218 struct lockfile
*lockfile
;
220 lockfile
= lockfile_find(device
, inode
);
222 VLOG_ERR("%s: lock file disappeared and reappeared!", name
);
223 lockfile_unhash(lockfile
);
226 lockfile
= xmalloc(sizeof *lockfile
);
227 lockfile
->name
= xstrdup(name
);
228 lockfile
->device
= device
;
229 lockfile
->inode
= inode
;
231 hmap_insert(lock_table
, &lockfile
->hmap_node
,
232 lockfile_hash(device
, inode
));
238 lockfile_do_unlock(struct lockfile
*lockfile
)
239 OVS_REQUIRES(&lock_table_mutex
)
241 if (lockfile
->fd
>= 0) {
245 overl
.OffsetHigh
= 0;
246 UnlockFileEx(lockfile
->lock_handle
, 0, 1, 0, &overl
);
254 lockfile_try_lock(const char *name
, pid_t
*pidp
, struct lockfile
**lockfilep
)
255 OVS_REQUIRES(&lock_table_mutex
)
260 struct lockfile
*lockfile
;
265 fd
= open(name
, O_RDWR
| O_CREAT
, 0600);
267 VLOG_WARN("%s: failed to open lock file: %s",
268 name
, ovs_strerror(errno
));
272 lock_handle
= (HANDLE
)_get_osfhandle(fd
);
273 if (lock_handle
< 0) {
274 VLOG_WARN("%s: failed to get the file handle: %s",
275 name
, ovs_strerror(errno
));
279 /* Lock the file 'name' for the region that includes just the first
283 overl
.OffsetHigh
= 0;
284 retval
= LockFileEx(lock_handle
, LOCKFILE_EXCLUSIVE_LOCK
285 | LOCKFILE_FAIL_IMMEDIATELY
, 0, 1, 0, &overl
);
287 VLOG_DBG("Failed to lock file : %s", ovs_lasterror_to_string());
292 lockfile
= xmalloc(sizeof *lockfile
);
293 lockfile
->name
= xstrdup(name
);
295 lockfile
->lock_handle
= lock_handle
;
297 *lockfilep
= lockfile
;
302 lockfile_do_unlock(struct lockfile
*lockfile
)
304 lockfile_unhash(lockfile
);
308 lockfile_try_lock(const char *name
, pid_t
*pidp
, struct lockfile
**lockfilep
)
309 OVS_REQUIRES(&lock_table_mutex
)
319 /* Check whether we've already got a lock on that file. */
320 if (!stat(name
, &s
)) {
321 if (lockfile_find(s
.st_dev
, s
.st_ino
)) {
325 } else if (errno
!= ENOENT
) {
326 VLOG_WARN("%s: failed to stat lock file: %s",
327 name
, ovs_strerror(errno
));
331 /* Open the lock file. */
332 fd
= open(name
, O_RDWR
| O_CREAT
, 0600);
334 VLOG_WARN("%s: failed to open lock file: %s",
335 name
, ovs_strerror(errno
));
339 /* Get the inode and device number for the lock table. */
341 VLOG_ERR("%s: failed to fstat lock file: %s",
342 name
, ovs_strerror(errno
));
347 /* Try to lock the file. */
348 memset(&l
, 0, sizeof l
);
350 l
.l_whence
= SEEK_SET
;
354 error
= fcntl(fd
, F_SETLK
, &l
) == -1 ? errno
: 0;
357 *lockfilep
= lockfile_register(name
, s
.st_dev
, s
.st_ino
, fd
);
359 if (!fcntl(fd
, F_GETLK
, &l
) && l
.l_type
!= F_UNLCK
) {