1 /* Copyright (c) 2008, 2009, 2010 Nicira Networks
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.
34 VLOG_DEFINE_THIS_MODULE(lockfile);
36 COVERAGE_DEFINE(lockfile_lock);
37 COVERAGE_DEFINE(lockfile_timeout);
38 COVERAGE_DEFINE(lockfile_error);
39 COVERAGE_DEFINE(lockfile_unlock);
42 struct hmap_node hmap_node;
51 * We have to do this stupid dance because POSIX says that closing *any* file
52 * descriptor for a file on which a process holds a lock drops *all* locks on
53 * that file. That means that we can't afford to open a lockfile more than
55 static struct hmap lock_table = HMAP_INITIALIZER(&lock_table);
57 static void lockfile_unhash(struct lockfile *);
58 static int lockfile_try_lock(const char *name, bool block,
59 struct lockfile **lockfilep);
61 /* Returns the name of the lockfile that would be created for locking a file
62 * named 'file_name'. The caller is responsible for freeing the returned
63 * name, with free(), when it is no longer needed. */
65 lockfile_name(const char *file_name)
67 const char *slash = strrchr(file_name, '/');
69 ? xasprintf("%.*s/.%s.~lock~",
70 (int) (slash - file_name), file_name, slash + 1)
71 : xasprintf(".%s.~lock~", file_name));
74 /* Locks the configuration file against modification by other processes and
75 * re-reads it from disk.
77 * The 'timeout' specifies the maximum number of milliseconds to wait for the
78 * config file to become free. Use 0 to avoid waiting or INT_MAX to wait
81 * Returns 0 on success, otherwise a positive errno value. On success,
82 * '*lockfilep' is set to point to a new "struct lockfile *" that may be
83 * unlocked with lockfile_unlock(). On failure, '*lockfilep' is set to
86 lockfile_lock(const char *file, int timeout, struct lockfile **lockfilep)
88 /* Only exclusive ("write") locks are supported. This is not a problem
89 * because the Open vSwitch code that currently uses lock files does so in
90 * stylized ways such that any number of readers may access a file while it
91 * is being written. */
92 long long int warn_elapsed = 1000;
93 long long int start, elapsed;
97 COVERAGE_INC(lockfile_lock);
99 lock_name = lockfile_name(file);
104 error = lockfile_try_lock(lock_name, timeout > 0, lockfilep);
106 elapsed = time_msec() - start;
107 if (elapsed > warn_elapsed) {
109 VLOG_WARN("%s: waiting for lock file, %lld ms elapsed",
112 } while (error == EINTR && (timeout == INT_MAX || elapsed < timeout));
116 VLOG_WARN("%s: waited %lld ms for lock file",
119 } else if (error == EINTR) {
120 COVERAGE_INC(lockfile_timeout);
121 VLOG_WARN("%s: giving up on lock file after %lld ms",
125 COVERAGE_INC(lockfile_error);
126 if (error == EACCES) {
129 VLOG_WARN("%s: failed to lock file "
130 "(after %lld ms, with %d-ms timeout): %s",
131 lock_name, elapsed, timeout, strerror(error));
138 /* Unlocks 'lockfile', which must have been created by a call to
139 * lockfile_lock(), and frees 'lockfile'. */
141 lockfile_unlock(struct lockfile *lockfile)
144 COVERAGE_INC(lockfile_unlock);
145 lockfile_unhash(lockfile);
146 free(lockfile->name);
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. */
155 lockfile_postfork(void)
157 struct lockfile *lockfile;
159 HMAP_FOR_EACH (lockfile, hmap_node, &lock_table) {
160 if (lockfile->fd >= 0) {
161 VLOG_WARN("%s: child does not inherit lock", lockfile->name);
162 lockfile_unhash(lockfile);
168 lockfile_hash(dev_t device, ino_t inode)
170 return hash_bytes(&device, sizeof device,
171 hash_bytes(&inode, sizeof inode, 0));
174 static struct lockfile *
175 lockfile_find(dev_t device, ino_t inode)
177 struct lockfile *lockfile;
179 HMAP_FOR_EACH_WITH_HASH (lockfile, hmap_node,
180 lockfile_hash(device, inode), &lock_table) {
181 if (lockfile->device == device && lockfile->inode == inode) {
189 lockfile_unhash(struct lockfile *lockfile)
191 if (lockfile->fd >= 0) {
194 hmap_remove(&lock_table, &lockfile->hmap_node);
198 static struct lockfile *
199 lockfile_register(const char *name, dev_t device, ino_t inode, int fd)
201 struct lockfile *lockfile;
203 lockfile = lockfile_find(device, inode);
205 VLOG_ERR("%s: lock file disappeared and reappeared!", name);
206 lockfile_unhash(lockfile);
209 lockfile = xmalloc(sizeof *lockfile);
210 lockfile->name = xstrdup(name);
211 lockfile->device = device;
212 lockfile->inode = inode;
214 hmap_insert(&lock_table, &lockfile->hmap_node,
215 lockfile_hash(device, inode));
220 lockfile_try_lock(const char *name, bool block, struct lockfile **lockfilep)
229 /* Open the lock file, first creating it if necessary. */
231 /* Check whether we've already got a lock on that file. */
232 if (!stat(name, &s)) {
233 if (lockfile_find(s.st_dev, s.st_ino)) {
236 } else if (errno != ENOENT) {
237 VLOG_WARN("%s: failed to stat lock file: %s",
238 name, strerror(errno));
242 /* Try to open an existing lock file. */
243 fd = open(name, O_RDWR);
246 } else if (errno != ENOENT) {
247 VLOG_WARN("%s: failed to open lock file: %s",
248 name, strerror(errno));
252 /* Try to create a new lock file. */
253 VLOG_INFO("%s: lock file does not exist, creating", name);
254 fd = open(name, O_RDWR | O_CREAT | O_EXCL, 0600);
257 } else if (errno != EEXIST) {
258 VLOG_WARN("%s: failed to create lock file: %s",
259 name, strerror(errno));
263 /* Someone else created the lock file. Try again. */
266 /* Get the inode and device number for the lock table. */
268 VLOG_ERR("%s: failed to fstat lock file: %s", name, strerror(errno));
273 /* Try to lock the file. */
274 memset(&l, 0, sizeof l);
276 l.l_whence = SEEK_SET;
280 time_disable_restart();
281 error = fcntl(fd, block ? F_SETLKW : F_SETLK, &l) == -1 ? errno : 0;
282 time_enable_restart();
285 *lockfilep = lockfile_register(name, s.st_dev, s.st_ino, fd);