160
|
1
|
|
2 /*
|
|
3 * Copyright (C) Igor Sysoev
|
644
|
4 * Copyright (C) Nginx, Inc.
|
160
|
5 */
|
|
6
|
|
7
|
|
8 #include <ngx_config.h>
|
|
9 #include <ngx_core.h>
|
|
10
|
|
11
|
|
12 #if (NGX_HAVE_ATOMIC_OPS)
|
|
13
|
|
14
|
|
15 ngx_int_t
|
258
|
16 ngx_shmtx_create(ngx_shmtx_t *mtx, void *addr, u_char *name)
|
160
|
17 {
|
|
18 mtx->lock = addr;
|
|
19
|
624
|
20 if (mtx->spin == (ngx_uint_t) -1) {
|
|
21 return NGX_OK;
|
|
22 }
|
|
23
|
|
24 mtx->spin = 2048;
|
|
25
|
|
26 #if (NGX_HAVE_POSIX_SEM)
|
|
27
|
|
28 if (sem_init(&mtx->sem, 1, 0) == -1) {
|
|
29 ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_errno,
|
|
30 "sem_init() failed");
|
|
31 } else {
|
|
32 mtx->semaphore = 1;
|
|
33 }
|
|
34
|
|
35 #endif
|
|
36
|
160
|
37 return NGX_OK;
|
|
38 }
|
|
39
|
624
|
40
|
|
41 void
|
|
42 ngx_shmtx_destory(ngx_shmtx_t *mtx)
|
|
43 {
|
|
44 #if (NGX_HAVE_POSIX_SEM)
|
|
45
|
|
46 if (mtx->semaphore) {
|
|
47 if (sem_destroy(&mtx->sem) == -1) {
|
|
48 ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_errno,
|
|
49 "sem_destroy() failed");
|
|
50 }
|
|
51 }
|
|
52
|
|
53 #endif
|
|
54 }
|
|
55
|
|
56
|
|
57 ngx_uint_t
|
|
58 ngx_shmtx_trylock(ngx_shmtx_t *mtx)
|
|
59 {
|
|
60 ngx_atomic_uint_t val;
|
|
61
|
|
62 val = *mtx->lock;
|
|
63
|
|
64 return ((val & 0x80000000) == 0
|
|
65 && ngx_atomic_cmp_set(mtx->lock, val, val | 0x80000000));
|
|
66 }
|
|
67
|
|
68
|
|
69 void
|
|
70 ngx_shmtx_lock(ngx_shmtx_t *mtx)
|
|
71 {
|
|
72 ngx_uint_t i, n;
|
|
73 ngx_atomic_uint_t val;
|
|
74
|
|
75 ngx_log_debug0(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0, "shmtx lock");
|
|
76
|
|
77 for ( ;; ) {
|
|
78
|
|
79 val = *mtx->lock;
|
|
80
|
|
81 if ((val & 0x80000000) == 0
|
|
82 && ngx_atomic_cmp_set(mtx->lock, val, val | 0x80000000))
|
|
83 {
|
|
84 return;
|
|
85 }
|
|
86
|
|
87 if (ngx_ncpu > 1) {
|
|
88
|
|
89 for (n = 1; n < mtx->spin; n <<= 1) {
|
|
90
|
|
91 for (i = 0; i < n; i++) {
|
|
92 ngx_cpu_pause();
|
|
93 }
|
|
94
|
|
95 val = *mtx->lock;
|
|
96
|
|
97 if ((val & 0x80000000) == 0
|
|
98 && ngx_atomic_cmp_set(mtx->lock, val, val | 0x80000000))
|
|
99 {
|
|
100 return;
|
|
101 }
|
|
102 }
|
|
103 }
|
|
104
|
|
105 #if (NGX_HAVE_POSIX_SEM)
|
|
106
|
|
107 if (mtx->semaphore) {
|
|
108 val = *mtx->lock;
|
|
109
|
|
110 if ((val & 0x80000000)
|
|
111 && ngx_atomic_cmp_set(mtx->lock, val, val + 1))
|
|
112 {
|
|
113 ngx_log_debug1(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0,
|
|
114 "shmtx wait %XA", val);
|
|
115
|
|
116 while (sem_wait(&mtx->sem) == -1) {
|
|
117 ngx_err_t err;
|
|
118
|
|
119 err = ngx_errno;
|
|
120
|
|
121 if (err != NGX_EINTR) {
|
|
122 ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, err,
|
|
123 "sem_wait() failed while waiting on shmtx");
|
|
124 break;
|
|
125 }
|
|
126 }
|
|
127
|
|
128 ngx_log_debug0(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0,
|
|
129 "shmtx awoke");
|
|
130 }
|
|
131
|
|
132 continue;
|
|
133 }
|
|
134
|
|
135 #endif
|
|
136
|
|
137 ngx_sched_yield();
|
|
138 }
|
|
139 }
|
|
140
|
|
141
|
|
142 void
|
|
143 ngx_shmtx_unlock(ngx_shmtx_t *mtx)
|
|
144 {
|
|
145 ngx_atomic_uint_t val, old, wait;
|
|
146
|
|
147 if (mtx->spin != (ngx_uint_t) -1) {
|
|
148 ngx_log_debug0(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0, "shmtx unlock");
|
|
149 }
|
|
150
|
|
151 for ( ;; ) {
|
|
152
|
|
153 old = *mtx->lock;
|
|
154 wait = old & 0x7fffffff;
|
|
155 val = wait ? wait - 1 : 0;
|
|
156
|
|
157 if (ngx_atomic_cmp_set(mtx->lock, old, val)) {
|
|
158 break;
|
|
159 }
|
|
160 }
|
|
161
|
|
162 #if (NGX_HAVE_POSIX_SEM)
|
|
163
|
|
164 if (wait == 0 || !mtx->semaphore) {
|
|
165 return;
|
|
166 }
|
|
167
|
|
168 ngx_log_debug1(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0,
|
|
169 "shmtx wake %XA", old);
|
|
170
|
|
171 if (sem_post(&mtx->sem) == -1) {
|
|
172 ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_errno,
|
|
173 "sem_post() failed while wake shmtx");
|
|
174 }
|
|
175
|
|
176 #endif
|
|
177 }
|
|
178
|
|
179
|
160
|
180 #else
|
|
181
|
|
182
|
|
183 ngx_int_t
|
258
|
184 ngx_shmtx_create(ngx_shmtx_t *mtx, void *addr, u_char *name)
|
160
|
185 {
|
|
186 if (mtx->name) {
|
|
187
|
|
188 if (ngx_strcmp(name, mtx->name) == 0) {
|
|
189 mtx->name = name;
|
|
190 return NGX_OK;
|
|
191 }
|
|
192
|
|
193 ngx_shmtx_destory(mtx);
|
|
194 }
|
|
195
|
284
|
196 mtx->fd = ngx_open_file(name, NGX_FILE_RDWR, NGX_FILE_CREATE_OR_OPEN,
|
|
197 NGX_FILE_DEFAULT_ACCESS);
|
160
|
198
|
|
199 if (mtx->fd == NGX_INVALID_FILE) {
|
258
|
200 ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_errno,
|
160
|
201 ngx_open_file_n " \"%s\" failed", name);
|
|
202 return NGX_ERROR;
|
|
203 }
|
|
204
|
|
205 if (ngx_delete_file(name) == NGX_FILE_ERROR) {
|
258
|
206 ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_errno,
|
160
|
207 ngx_delete_file_n " \"%s\" failed", name);
|
|
208 }
|
|
209
|
|
210 mtx->name = name;
|
|
211
|
|
212 return NGX_OK;
|
|
213 }
|
|
214
|
|
215
|
|
216 void
|
|
217 ngx_shmtx_destory(ngx_shmtx_t *mtx)
|
|
218 {
|
|
219 if (ngx_close_file(mtx->fd) == NGX_FILE_ERROR) {
|
258
|
220 ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_errno,
|
160
|
221 ngx_close_file_n " \"%s\" failed", mtx->name);
|
|
222 }
|
|
223 }
|
|
224
|
|
225
|
624
|
226 ngx_uint_t
|
|
227 ngx_shmtx_trylock(ngx_shmtx_t *mtx)
|
|
228 {
|
|
229 ngx_err_t err;
|
|
230
|
|
231 err = ngx_trylock_fd(mtx->fd);
|
|
232
|
|
233 if (err == 0) {
|
|
234 return 1;
|
|
235 }
|
|
236
|
|
237 if (err == NGX_EAGAIN) {
|
|
238 return 0;
|
|
239 }
|
|
240
|
|
241 #if __osf__ /* Tru64 UNIX */
|
|
242
|
|
243 if (err == NGX_EACCESS) {
|
|
244 return 0;
|
|
245 }
|
|
246
|
160
|
247 #endif
|
624
|
248
|
|
249 ngx_log_abort(err, ngx_trylock_fd_n " %s failed", mtx->name);
|
|
250
|
|
251 return 0;
|
|
252 }
|
|
253
|
|
254
|
|
255 void
|
|
256 ngx_shmtx_lock(ngx_shmtx_t *mtx)
|
|
257 {
|
|
258 ngx_err_t err;
|
|
259
|
|
260 err = ngx_lock_fd(mtx->fd);
|
|
261
|
|
262 if (err == 0) {
|
|
263 return;
|
|
264 }
|
|
265
|
|
266 ngx_log_abort(err, ngx_lock_fd_n " %s failed", mtx->name);
|
|
267 }
|
|
268
|
|
269
|
|
270 void
|
|
271 ngx_shmtx_unlock(ngx_shmtx_t *mtx)
|
|
272 {
|
|
273 ngx_err_t err;
|
|
274
|
|
275 err = ngx_unlock_fd(mtx->fd);
|
|
276
|
|
277 if (err == 0) {
|
|
278 return;
|
|
279 }
|
|
280
|
|
281 ngx_log_abort(err, ngx_unlock_fd_n " %s failed", mtx->name);
|
|
282 }
|
|
283
|
|
284 #endif
|