1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
/* Copyright (c) 2003-2004, Roger Dingledine
* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
* Copyright (c) 2007-2020, The Tor Project, Inc. */
/* See LICENSE for licensing information */
/**
* \file lockfile.c
*
* \brief Implements lock files to prevent two Tor processes from using the
* same data directory at the same time.
**/
#include "orconfig.h"
#include "lib/fs/files.h"
#include "lib/fs/lockfile.h"
#include "lib/log/log.h"
#include "lib/log/util_bug.h"
#include "lib/malloc/malloc.h"
#ifdef HAVE_SYS_FILE_H
#include <sys/file.h>
#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef _WIN32
#include <windows.h>
#include <sys/locking.h>
#endif
#include <errno.h>
#include <string.h>
/** Represents a lockfile on which we hold the lock. */
struct tor_lockfile_t {
/** Name of the file */
char *filename;
/** File descriptor used to hold the file open */
int fd;
};
/** Try to get a lock on the lockfile <b>filename</b>, creating it as
* necessary. If someone else has the lock and <b>blocking</b> is true,
* wait until the lock is available. Otherwise return immediately whether
* we succeeded or not.
*
* Set *<b>locked_out</b> to true if somebody else had the lock, and to false
* otherwise.
*
* Return a <b>tor_lockfile_t</b> on success, NULL on failure.
*
* (Implementation note: because we need to fall back to fcntl on some
* platforms, these locks are per-process, not per-thread. If you want
* to do in-process locking, use tor_mutex_t like a normal person.
* On Windows, when <b>blocking</b> is true, the maximum time that
* is actually waited is 10 seconds, after which NULL is returned
* and <b>locked_out</b> is set to 1.)
*/
tor_lockfile_t *
tor_lockfile_lock(const char *filename, int blocking, int *locked_out)
{
tor_lockfile_t *result;
int fd;
*locked_out = 0;
log_info(LD_FS, "Locking \"%s\"", filename);
fd = tor_open_cloexec(filename, O_RDWR|O_CREAT|O_TRUNC, 0600);
if (fd < 0) {
log_warn(LD_FS,"Couldn't open \"%s\" for locking: %s", filename,
strerror(errno));
return NULL;
}
#ifdef _WIN32
_lseek(fd, 0, SEEK_SET);
if (_locking(fd, blocking ? _LK_LOCK : _LK_NBLCK, 1) < 0) {
if (errno != EACCES && errno != EDEADLOCK)
log_warn(LD_FS,"Couldn't lock \"%s\": %s", filename, strerror(errno));
else
*locked_out = 1;
close(fd);
return NULL;
}
#elif defined(HAVE_FLOCK)
if (flock(fd, LOCK_EX|(blocking ? 0 : LOCK_NB)) < 0) {
if (errno != EWOULDBLOCK)
log_warn(LD_FS,"Couldn't lock \"%s\": %s", filename, strerror(errno));
else
*locked_out = 1;
close(fd);
return NULL;
}
#else
{
struct flock lock;
memset(&lock, 0, sizeof(lock));
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
if (fcntl(fd, blocking ? F_SETLKW : F_SETLK, &lock) < 0) {
if (errno != EACCES && errno != EAGAIN)
log_warn(LD_FS, "Couldn't lock \"%s\": %s", filename, strerror(errno));
else
*locked_out = 1;
close(fd);
return NULL;
}
}
#endif /* defined(_WIN32) || ... */
result = tor_malloc(sizeof(tor_lockfile_t));
result->filename = tor_strdup(filename);
result->fd = fd;
return result;
}
/** Release the lock held as <b>lockfile</b>. */
void
tor_lockfile_unlock(tor_lockfile_t *lockfile)
{
tor_assert(lockfile);
log_info(LD_FS, "Unlocking \"%s\"", lockfile->filename);
#ifdef _WIN32
_lseek(lockfile->fd, 0, SEEK_SET);
if (_locking(lockfile->fd, _LK_UNLCK, 1) < 0) {
log_warn(LD_FS,"Error unlocking \"%s\": %s", lockfile->filename,
strerror(errno));
}
#elif defined(HAVE_FLOCK)
if (flock(lockfile->fd, LOCK_UN) < 0) {
log_warn(LD_FS, "Error unlocking \"%s\": %s", lockfile->filename,
strerror(errno));
}
#else
/* Closing the lockfile is sufficient. */
#endif /* defined(_WIN32) || ... */
close(lockfile->fd);
lockfile->fd = -1;
tor_free(lockfile->filename);
tor_free(lockfile);
}
|
