![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ngx_event_busy_lock.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / event|
Return to ngx_event_busy_lock.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / event |
1.1 misho 1:
2: /*
3: * Copyright (C) Igor Sysoev
4: * Copyright (C) Nginx, Inc.
5: */
6:
7:
8: #include <ngx_config.h>
9: #include <ngx_core.h>
10: #include <ngx_event.h>
11:
12:
13: static ngx_int_t ngx_event_busy_lock_look_cacheable(ngx_event_busy_lock_t *bl,
14: ngx_event_busy_lock_ctx_t *ctx);
15: static void ngx_event_busy_lock_handler(ngx_event_t *ev);
16: static void ngx_event_busy_lock_posted_handler(ngx_event_t *ev);
17:
18:
19: /*
20: * NGX_OK: the busy lock is held
21: * NGX_AGAIN: the all busy locks are held but we will wait the specified time
22: * NGX_BUSY: ctx->timer == 0: there are many the busy locks
23: * ctx->timer != 0: there are many the waiting locks
24: */
25:
26: ngx_int_t
27: ngx_event_busy_lock(ngx_event_busy_lock_t *bl, ngx_event_busy_lock_ctx_t *ctx)
28: {
29: ngx_int_t rc;
30:
31: ngx_mutex_lock(bl->mutex);
32:
33: ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ctx->event->log, 0,
34: "event busy lock: b:%d mb:%d",
35: bl->busy, bl->max_busy);
36:
37: if (bl->busy < bl->max_busy) {
38: bl->busy++;
39:
40: rc = NGX_OK;
41:
42: } else if (ctx->timer && bl->waiting < bl->max_waiting) {
43: bl->waiting++;
44: ngx_add_timer(ctx->event, ctx->timer);
45: ctx->event->handler = ngx_event_busy_lock_handler;
46:
47: if (bl->events) {
48: bl->last->next = ctx;
49:
50: } else {
51: bl->events = ctx;
52: }
53:
54: bl->last = ctx;
55:
56: rc = NGX_AGAIN;
57:
58: } else {
59: rc = NGX_BUSY;
60: }
61:
62: ngx_mutex_unlock(bl->mutex);
63:
64: return rc;
65: }
66:
67:
68: ngx_int_t
69: ngx_event_busy_lock_cacheable(ngx_event_busy_lock_t *bl,
70: ngx_event_busy_lock_ctx_t *ctx)
71: {
72: ngx_int_t rc;
73:
74: ngx_mutex_lock(bl->mutex);
75:
76: rc = ngx_event_busy_lock_look_cacheable(bl, ctx);
77:
78: ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ctx->event->log, 0,
79: "event busy lock: %d w:%d mw:%d",
80: rc, bl->waiting, bl->max_waiting);
81:
82: /*
83: * NGX_OK: no the same request, there is free slot and we locked it
84: * NGX_BUSY: no the same request and there is no free slot
85: * NGX_AGAIN: the same request is processing
86: */
87:
88: if (rc == NGX_AGAIN) {
89:
90: if (ctx->timer && bl->waiting < bl->max_waiting) {
91: bl->waiting++;
92: ngx_add_timer(ctx->event, ctx->timer);
93: ctx->event->handler = ngx_event_busy_lock_handler;
94:
95: if (bl->events == NULL) {
96: bl->events = ctx;
97: } else {
98: bl->last->next = ctx;
99: }
100: bl->last = ctx;
101:
102: } else {
103: rc = NGX_BUSY;
104: }
105: }
106:
107: ngx_mutex_unlock(bl->mutex);
108:
109: return rc;
110: }
111:
112:
113: void
114: ngx_event_busy_unlock(ngx_event_busy_lock_t *bl,
115: ngx_event_busy_lock_ctx_t *ctx)
116: {
117: ngx_event_t *ev;
118: ngx_event_busy_lock_ctx_t *wakeup;
119:
120: ngx_mutex_lock(bl->mutex);
121:
122: if (bl->events) {
123: wakeup = bl->events;
124: bl->events = bl->events->next;
125:
126: } else {
127: wakeup = NULL;
128: bl->busy--;
129: }
130:
131: /*
132: * MP: all ctx's and their queue must be in shared memory,
133: * each ctx has pid to wake up
134: */
135:
136: if (wakeup == NULL) {
137: ngx_mutex_unlock(bl->mutex);
138: return;
139: }
140:
141: if (ctx->md5) {
142: for (wakeup = bl->events; wakeup; wakeup = wakeup->next) {
143: if (wakeup->md5 == NULL || wakeup->slot != ctx->slot) {
144: continue;
145: }
146:
147: wakeup->handler = ngx_event_busy_lock_posted_handler;
148: wakeup->cache_updated = 1;
149:
150: ev = wakeup->event;
151:
152: ngx_post_event(ev, &ngx_posted_events);
153: }
154:
155: ngx_mutex_unlock(bl->mutex);
156:
157: } else {
158: bl->waiting--;
159:
160: ngx_mutex_unlock(bl->mutex);
161:
162: wakeup->handler = ngx_event_busy_lock_posted_handler;
163: wakeup->locked = 1;
164:
165: ev = wakeup->event;
166:
167: if (ev->timer_set) {
168: ngx_del_timer(ev);
169: }
170:
171: ngx_post_event(ev, &ngx_posted_events);
172: }
173: }
174:
175:
176: void
177: ngx_event_busy_lock_cancel(ngx_event_busy_lock_t *bl,
178: ngx_event_busy_lock_ctx_t *ctx)
179: {
180: ngx_event_busy_lock_ctx_t *c, *p;
181:
182: ngx_mutex_lock(bl->mutex);
183:
184: bl->waiting--;
185:
186: if (ctx == bl->events) {
187: bl->events = ctx->next;
188:
189: } else {
190: p = bl->events;
191: for (c = bl->events->next; c; c = c->next) {
192: if (c == ctx) {
193: p->next = ctx->next;
194: break;
195: }
196: p = c;
197: }
198: }
199:
200: ngx_mutex_unlock(bl->mutex);
201: }
202:
203:
204: static ngx_int_t
205: ngx_event_busy_lock_look_cacheable(ngx_event_busy_lock_t *bl,
206: ngx_event_busy_lock_ctx_t *ctx)
207: {
208: ngx_int_t free;
209: ngx_uint_t i, bit, cacheable, mask;
210:
211: bit = 0;
212: cacheable = 0;
213: free = -1;
214:
215: #if (NGX_SUPPRESS_WARN)
216: mask = 0;
217: #endif
218:
219: for (i = 0; i < bl->max_busy; i++) {
220:
221: if ((bit & 7) == 0) {
222: mask = bl->md5_mask[i / 8];
223: }
224:
225: if (mask & 1) {
226: if (ngx_memcmp(&bl->md5[i * 16], ctx->md5, 16) == 0) {
227: ctx->waiting = 1;
228: ctx->slot = i;
229: return NGX_AGAIN;
230: }
231: cacheable++;
232:
233: } else if (free == -1) {
234: free = i;
235: }
236:
237: if (cacheable == bl->cacheable) {
238: if (free == -1 && cacheable < bl->max_busy) {
239: free = i + 1;
240: }
241:
242: break;
243: }
244:
245: mask >>= 1;
246: bit++;
247: }
248:
249: if (free == -1) {
250: return NGX_BUSY;
251: }
252:
253: #if 0
254: if (bl->busy == bl->max_busy) {
255: return NGX_BUSY;
256: }
257: #endif
258:
259: ngx_memcpy(&bl->md5[free * 16], ctx->md5, 16);
260: bl->md5_mask[free / 8] |= 1 << (free & 7);
261: ctx->slot = free;
262:
263: bl->cacheable++;
264: bl->busy++;
265:
266: return NGX_OK;
267: }
268:
269:
270: static void
271: ngx_event_busy_lock_handler(ngx_event_t *ev)
272: {
273: ev->handler = ngx_event_busy_lock_posted_handler;
274:
275: ngx_post_event(ev, &ngx_posted_events);
276: }
277:
278:
279: static void
280: ngx_event_busy_lock_posted_handler(ngx_event_t *ev)
281: {
282: ngx_event_busy_lock_ctx_t *ctx;
283:
284: ctx = ev->data;
285: ctx->handler(ev);
286: }