![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ratelimiter.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / lib / isc|
Return to ratelimiter.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / lib / isc |
1.1 misho 1: /*
2: * Copyright (C) 2004, 2005, 2007 Internet Systems Consortium, Inc. ("ISC")
3: * Copyright (C) 1999-2002 Internet Software Consortium.
4: *
5: * Permission to use, copy, modify, and/or distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
8: *
9: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10: * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11: * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12: * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13: * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14: * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15: * PERFORMANCE OF THIS SOFTWARE.
16: */
17:
18: /* $Id: ratelimiter.c,v 1.25 2007/06/19 23:47:17 tbox Exp $ */
19:
20: /*! \file */
21:
22: #include <config.h>
23:
24: #include <isc/mem.h>
25: #include <isc/ratelimiter.h>
26: #include <isc/task.h>
27: #include <isc/time.h>
28: #include <isc/timer.h>
29: #include <isc/util.h>
30:
31: typedef enum {
32: isc_ratelimiter_stalled = 0,
33: isc_ratelimiter_ratelimited = 1,
34: isc_ratelimiter_idle = 2,
35: isc_ratelimiter_shuttingdown = 3
36: } isc_ratelimiter_state_t;
37:
38: struct isc_ratelimiter {
39: isc_mem_t * mctx;
40: isc_mutex_t lock;
41: int refs;
42: isc_task_t * task;
43: isc_timer_t * timer;
44: isc_interval_t interval;
45: isc_uint32_t pertic;
46: isc_ratelimiter_state_t state;
47: isc_event_t shutdownevent;
48: ISC_LIST(isc_event_t) pending;
49: };
50:
51: #define ISC_RATELIMITEREVENT_SHUTDOWN (ISC_EVENTCLASS_RATELIMITER + 1)
52:
53: static void
54: ratelimiter_tick(isc_task_t *task, isc_event_t *event);
55:
56: static void
57: ratelimiter_shutdowncomplete(isc_task_t *task, isc_event_t *event);
58:
59: isc_result_t
60: isc_ratelimiter_create(isc_mem_t *mctx, isc_timermgr_t *timermgr,
61: isc_task_t *task, isc_ratelimiter_t **ratelimiterp)
62: {
63: isc_result_t result;
64: isc_ratelimiter_t *rl;
65: INSIST(ratelimiterp != NULL && *ratelimiterp == NULL);
66:
67: rl = isc_mem_get(mctx, sizeof(*rl));
68: if (rl == NULL)
69: return ISC_R_NOMEMORY;
70: rl->mctx = mctx;
71: rl->refs = 1;
72: rl->task = task;
73: isc_interval_set(&rl->interval, 0, 0);
74: rl->timer = NULL;
75: rl->pertic = 1;
76: rl->state = isc_ratelimiter_idle;
77: ISC_LIST_INIT(rl->pending);
78:
79: result = isc_mutex_init(&rl->lock);
80: if (result != ISC_R_SUCCESS)
81: goto free_mem;
82: result = isc_timer_create(timermgr, isc_timertype_inactive,
83: NULL, NULL, rl->task, ratelimiter_tick,
84: rl, &rl->timer);
85: if (result != ISC_R_SUCCESS)
86: goto free_mutex;
87:
88: /*
89: * Increment the reference count to indicate that we may
90: * (soon) have events outstanding.
91: */
92: rl->refs++;
93:
94: ISC_EVENT_INIT(&rl->shutdownevent,
95: sizeof(isc_event_t),
96: 0, NULL, ISC_RATELIMITEREVENT_SHUTDOWN,
97: ratelimiter_shutdowncomplete, rl, rl, NULL, NULL);
98:
99: *ratelimiterp = rl;
100: return (ISC_R_SUCCESS);
101:
102: free_mutex:
103: DESTROYLOCK(&rl->lock);
104: free_mem:
105: isc_mem_put(mctx, rl, sizeof(*rl));
106: return (result);
107: }
108:
109: isc_result_t
110: isc_ratelimiter_setinterval(isc_ratelimiter_t *rl, isc_interval_t *interval) {
111: isc_result_t result = ISC_R_SUCCESS;
112: LOCK(&rl->lock);
113: rl->interval = *interval;
114: /*
115: * If the timer is currently running, change its rate.
116: */
117: if (rl->state == isc_ratelimiter_ratelimited) {
118: result = isc_timer_reset(rl->timer, isc_timertype_ticker, NULL,
119: &rl->interval, ISC_FALSE);
120: }
121: UNLOCK(&rl->lock);
122: return (result);
123: }
124:
125: void
126: isc_ratelimiter_setpertic(isc_ratelimiter_t *rl, isc_uint32_t pertic) {
127: if (pertic == 0)
128: pertic = 1;
129: rl->pertic = pertic;
130: }
131:
132: isc_result_t
133: isc_ratelimiter_enqueue(isc_ratelimiter_t *rl, isc_task_t *task,
134: isc_event_t **eventp)
135: {
136: isc_result_t result = ISC_R_SUCCESS;
137: isc_event_t *ev;
138:
139: REQUIRE(eventp != NULL && *eventp != NULL);
140: REQUIRE(task != NULL);
141: ev = *eventp;
142: REQUIRE(ev->ev_sender == NULL);
143:
144: LOCK(&rl->lock);
145: if (rl->state == isc_ratelimiter_ratelimited ||
146: rl->state == isc_ratelimiter_stalled) {
147: isc_event_t *ev = *eventp;
148: ev->ev_sender = task;
149: ISC_LIST_APPEND(rl->pending, ev, ev_link);
150: *eventp = NULL;
151: } else if (rl->state == isc_ratelimiter_idle) {
152: result = isc_timer_reset(rl->timer, isc_timertype_ticker, NULL,
153: &rl->interval, ISC_FALSE);
154: if (result == ISC_R_SUCCESS) {
155: ev->ev_sender = task;
156: rl->state = isc_ratelimiter_ratelimited;
157: }
158: } else {
159: INSIST(rl->state == isc_ratelimiter_shuttingdown);
160: result = ISC_R_SHUTTINGDOWN;
161: }
162: UNLOCK(&rl->lock);
163: if (*eventp != NULL && result == ISC_R_SUCCESS)
164: isc_task_send(task, eventp);
165: return (result);
166: }
167:
168: static void
169: ratelimiter_tick(isc_task_t *task, isc_event_t *event) {
170: isc_result_t result = ISC_R_SUCCESS;
171: isc_ratelimiter_t *rl = (isc_ratelimiter_t *)event->ev_arg;
172: isc_event_t *p;
173: isc_uint32_t pertic;
174:
175: UNUSED(task);
176:
177: isc_event_free(&event);
178:
179: pertic = rl->pertic;
180: while (pertic != 0) {
181: pertic--;
182: LOCK(&rl->lock);
183: p = ISC_LIST_HEAD(rl->pending);
184: if (p != NULL) {
185: /*
186: * There is work to do. Let's do it after unlocking.
187: */
188: ISC_LIST_UNLINK(rl->pending, p, ev_link);
189: } else {
190: /*
191: * No work left to do. Stop the timer so that we don't
192: * waste resources by having it fire periodically.
193: */
194: result = isc_timer_reset(rl->timer,
195: isc_timertype_inactive,
196: NULL, NULL, ISC_FALSE);
197: RUNTIME_CHECK(result == ISC_R_SUCCESS);
198: rl->state = isc_ratelimiter_idle;
199: pertic = 0; /* Force the loop to exit. */
200: }
201: UNLOCK(&rl->lock);
202: if (p != NULL) {
203: isc_task_t *evtask = p->ev_sender;
204: isc_task_send(evtask, &p);
205: }
206: INSIST(p == NULL);
207: }
208: }
209:
210: void
211: isc_ratelimiter_shutdown(isc_ratelimiter_t *rl) {
212: isc_event_t *ev;
213: isc_task_t *task;
214: LOCK(&rl->lock);
215: rl->state = isc_ratelimiter_shuttingdown;
216: (void)isc_timer_reset(rl->timer, isc_timertype_inactive,
217: NULL, NULL, ISC_FALSE);
218: while ((ev = ISC_LIST_HEAD(rl->pending)) != NULL) {
219: ISC_LIST_UNLINK(rl->pending, ev, ev_link);
220: ev->ev_attributes |= ISC_EVENTATTR_CANCELED;
221: task = ev->ev_sender;
222: isc_task_send(task, &ev);
223: }
224: isc_timer_detach(&rl->timer);
225: /*
226: * Send an event to our task. The delivery of this event
227: * indicates that no more timer events will be delivered.
228: */
229: ev = &rl->shutdownevent;
230: isc_task_send(rl->task, &ev);
231:
232: UNLOCK(&rl->lock);
233: }
234:
235: static void
236: ratelimiter_shutdowncomplete(isc_task_t *task, isc_event_t *event) {
237: isc_ratelimiter_t *rl = (isc_ratelimiter_t *)event->ev_arg;
238:
239: UNUSED(task);
240:
241: isc_ratelimiter_detach(&rl);
242: }
243:
244: static void
245: ratelimiter_free(isc_ratelimiter_t *rl) {
246: DESTROYLOCK(&rl->lock);
247: isc_mem_put(rl->mctx, rl, sizeof(*rl));
248: }
249:
250: void
251: isc_ratelimiter_attach(isc_ratelimiter_t *source, isc_ratelimiter_t **target) {
252: REQUIRE(source != NULL);
253: REQUIRE(target != NULL && *target == NULL);
254:
255: LOCK(&source->lock);
256: REQUIRE(source->refs > 0);
257: source->refs++;
258: INSIST(source->refs > 0);
259: UNLOCK(&source->lock);
260: *target = source;
261: }
262:
263: void
264: isc_ratelimiter_detach(isc_ratelimiter_t **rlp) {
265: isc_ratelimiter_t *rl = *rlp;
266: isc_boolean_t free_now = ISC_FALSE;
267:
268: LOCK(&rl->lock);
269: REQUIRE(rl->refs > 0);
270: rl->refs--;
271: if (rl->refs == 0)
272: free_now = ISC_TRUE;
273: UNLOCK(&rl->lock);
274:
275: if (free_now)
276: ratelimiter_free(rl);
277:
278: *rlp = NULL;
279: }
280:
281: isc_result_t
282: isc_ratelimiter_stall(isc_ratelimiter_t *rl) {
283: isc_result_t result = ISC_R_SUCCESS;
284:
285: LOCK(&rl->lock);
286: switch (rl->state) {
287: case isc_ratelimiter_shuttingdown:
288: result = ISC_R_SHUTTINGDOWN;
289: break;
290: case isc_ratelimiter_ratelimited:
291: result = isc_timer_reset(rl->timer, isc_timertype_inactive,
292: NULL, NULL, ISC_FALSE);
293: RUNTIME_CHECK(result == ISC_R_SUCCESS);
294: case isc_ratelimiter_idle:
295: case isc_ratelimiter_stalled:
296: rl->state = isc_ratelimiter_stalled;
297: break;
298: }
299: UNLOCK(&rl->lock);
300: return (result);
301: }
302:
303: isc_result_t
304: isc_ratelimiter_release(isc_ratelimiter_t *rl) {
305: isc_result_t result = ISC_R_SUCCESS;
306:
307: LOCK(&rl->lock);
308: switch (rl->state) {
309: case isc_ratelimiter_shuttingdown:
310: result = ISC_R_SHUTTINGDOWN;
311: break;
312: case isc_ratelimiter_stalled:
313: if (!ISC_LIST_EMPTY(rl->pending)) {
314: result = isc_timer_reset(rl->timer,
315: isc_timertype_ticker, NULL,
316: &rl->interval, ISC_FALSE);
317: if (result == ISC_R_SUCCESS)
318: rl->state = isc_ratelimiter_ratelimited;
319: } else
320: rl->state = isc_ratelimiter_idle;
321: break;
322: case isc_ratelimiter_ratelimited:
323: case isc_ratelimiter_idle:
324: break;
325: }
326: UNLOCK(&rl->lock);
327: return (result);
328: }