FreeBSD/Linux Kernel Cross Reference
sys/netgraph/ng_car.c
1 /*-
2 * Copyright (c) 2005 Nuno Antunes <nuno.antunes@gmail.com>
3 * Copyright (c) 2007 Alexander Motin <mav@freebsd.org>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 * $FreeBSD: releng/10.2/sys/netgraph/ng_car.c 220768 2011-04-18 09:12:27Z glebius $
28 */
29
30 /*
31 * ng_car - An implementation of commited access rate for netgraph
32 *
33 * TODO:
34 * - Sanitize input config values (impose some limits)
35 * - Implement internal packet painting (possibly using mbuf tags)
36 * - Implement color-aware mode
37 * - Implement DSCP marking for IPv4
38 */
39
40 #include <sys/param.h>
41 #include <sys/errno.h>
42 #include <sys/kernel.h>
43 #include <sys/malloc.h>
44 #include <sys/mbuf.h>
45
46 #include <netgraph/ng_message.h>
47 #include <netgraph/ng_parse.h>
48 #include <netgraph/netgraph.h>
49 #include <netgraph/ng_car.h>
50
51 #define NG_CAR_QUEUE_SIZE 100 /* Maximum queue size for SHAPE mode */
52 #define NG_CAR_QUEUE_MIN_TH 8 /* Minimum RED threshhold for SHAPE mode */
53
54 /* Hook private info */
55 struct hookinfo {
56 hook_p hook; /* this (source) hook */
57 hook_p dest; /* destination hook */
58
59 int64_t tc; /* commited token bucket counter */
60 int64_t te; /* exceeded/peak token bucket counter */
61 struct bintime lastRefill; /* last token refill time */
62
63 struct ng_car_hookconf conf; /* hook configuration */
64 struct ng_car_hookstats stats; /* hook stats */
65
66 struct mbuf *q[NG_CAR_QUEUE_SIZE]; /* circular packet queue */
67 u_int q_first; /* first queue element */
68 u_int q_last; /* last queue element */
69 struct callout q_callout; /* periodic queue processing routine */
70 struct mtx q_mtx; /* queue mutex */
71 };
72
73 /* Private information for each node instance */
74 struct privdata {
75 node_p node; /* the node itself */
76 struct hookinfo upper; /* hook to upper layers */
77 struct hookinfo lower; /* hook to lower layers */
78 };
79 typedef struct privdata *priv_p;
80
81 static ng_constructor_t ng_car_constructor;
82 static ng_rcvmsg_t ng_car_rcvmsg;
83 static ng_shutdown_t ng_car_shutdown;
84 static ng_newhook_t ng_car_newhook;
85 static ng_rcvdata_t ng_car_rcvdata;
86 static ng_disconnect_t ng_car_disconnect;
87
88 static void ng_car_refillhook(struct hookinfo *h);
89 static void ng_car_schedule(struct hookinfo *h);
90 void ng_car_q_event(node_p node, hook_p hook, void *arg, int arg2);
91 static void ng_car_enqueue(struct hookinfo *h, item_p item);
92
93 /* Parse type for struct ng_car_hookstats */
94 static const struct ng_parse_struct_field ng_car_hookstats_type_fields[]
95 = NG_CAR_HOOKSTATS;
96 static const struct ng_parse_type ng_car_hookstats_type = {
97 &ng_parse_struct_type,
98 &ng_car_hookstats_type_fields
99 };
100
101 /* Parse type for struct ng_car_bulkstats */
102 static const struct ng_parse_struct_field ng_car_bulkstats_type_fields[]
103 = NG_CAR_BULKSTATS(&ng_car_hookstats_type);
104 static const struct ng_parse_type ng_car_bulkstats_type = {
105 &ng_parse_struct_type,
106 &ng_car_bulkstats_type_fields
107 };
108
109 /* Parse type for struct ng_car_hookconf */
110 static const struct ng_parse_struct_field ng_car_hookconf_type_fields[]
111 = NG_CAR_HOOKCONF;
112 static const struct ng_parse_type ng_car_hookconf_type = {
113 &ng_parse_struct_type,
114 &ng_car_hookconf_type_fields
115 };
116
117 /* Parse type for struct ng_car_bulkconf */
118 static const struct ng_parse_struct_field ng_car_bulkconf_type_fields[]
119 = NG_CAR_BULKCONF(&ng_car_hookconf_type);
120 static const struct ng_parse_type ng_car_bulkconf_type = {
121 &ng_parse_struct_type,
122 &ng_car_bulkconf_type_fields
123 };
124
125 /* Command list */
126 static struct ng_cmdlist ng_car_cmdlist[] = {
127 {
128 NGM_CAR_COOKIE,
129 NGM_CAR_GET_STATS,
130 "getstats",
131 NULL,
132 &ng_car_bulkstats_type,
133 },
134 {
135 NGM_CAR_COOKIE,
136 NGM_CAR_CLR_STATS,
137 "clrstats",
138 NULL,
139 NULL,
140 },
141 {
142 NGM_CAR_COOKIE,
143 NGM_CAR_GETCLR_STATS,
144 "getclrstats",
145 NULL,
146 &ng_car_bulkstats_type,
147 },
148
149 {
150 NGM_CAR_COOKIE,
151 NGM_CAR_GET_CONF,
152 "getconf",
153 NULL,
154 &ng_car_bulkconf_type,
155 },
156 {
157 NGM_CAR_COOKIE,
158 NGM_CAR_SET_CONF,
159 "setconf",
160 &ng_car_bulkconf_type,
161 NULL,
162 },
163 { 0 }
164 };
165
166 /* Netgraph node type descriptor */
167 static struct ng_type ng_car_typestruct = {
168 .version = NG_ABI_VERSION,
169 .name = NG_CAR_NODE_TYPE,
170 .constructor = ng_car_constructor,
171 .rcvmsg = ng_car_rcvmsg,
172 .shutdown = ng_car_shutdown,
173 .newhook = ng_car_newhook,
174 .rcvdata = ng_car_rcvdata,
175 .disconnect = ng_car_disconnect,
176 .cmdlist = ng_car_cmdlist,
177 };
178 NETGRAPH_INIT(car, &ng_car_typestruct);
179
180 /*
181 * Node constructor
182 */
183 static int
184 ng_car_constructor(node_p node)
185 {
186 priv_p priv;
187
188 /* Initialize private descriptor. */
189 priv = malloc(sizeof(*priv), M_NETGRAPH, M_WAITOK | M_ZERO);
190
191 NG_NODE_SET_PRIVATE(node, priv);
192 priv->node = node;
193
194 /*
195 * Arbitrary default values
196 */
197
198 priv->upper.hook = NULL;
199 priv->upper.dest = NULL;
200 priv->upper.tc = priv->upper.conf.cbs = NG_CAR_CBS_MIN;
201 priv->upper.te = priv->upper.conf.ebs = NG_CAR_EBS_MIN;
202 priv->upper.conf.cir = NG_CAR_CIR_DFLT;
203 priv->upper.conf.green_action = NG_CAR_ACTION_FORWARD;
204 priv->upper.conf.yellow_action = NG_CAR_ACTION_FORWARD;
205 priv->upper.conf.red_action = NG_CAR_ACTION_DROP;
206 priv->upper.conf.mode = 0;
207 getbinuptime(&priv->upper.lastRefill);
208 priv->upper.q_first = 0;
209 priv->upper.q_last = 0;
210 ng_callout_init(&priv->upper.q_callout);
211 mtx_init(&priv->upper.q_mtx, "ng_car_u", NULL, MTX_DEF);
212
213 priv->lower.hook = NULL;
214 priv->lower.dest = NULL;
215 priv->lower.tc = priv->lower.conf.cbs = NG_CAR_CBS_MIN;
216 priv->lower.te = priv->lower.conf.ebs = NG_CAR_EBS_MIN;
217 priv->lower.conf.cir = NG_CAR_CIR_DFLT;
218 priv->lower.conf.green_action = NG_CAR_ACTION_FORWARD;
219 priv->lower.conf.yellow_action = NG_CAR_ACTION_FORWARD;
220 priv->lower.conf.red_action = NG_CAR_ACTION_DROP;
221 priv->lower.conf.mode = 0;
222 priv->lower.lastRefill = priv->upper.lastRefill;
223 priv->lower.q_first = 0;
224 priv->lower.q_last = 0;
225 ng_callout_init(&priv->lower.q_callout);
226 mtx_init(&priv->lower.q_mtx, "ng_car_l", NULL, MTX_DEF);
227
228 return (0);
229 }
230
231 /*
232 * Add a hook.
233 */
234 static int
235 ng_car_newhook(node_p node, hook_p hook, const char *name)
236 {
237 const priv_p priv = NG_NODE_PRIVATE(node);
238
239 if (strcmp(name, NG_CAR_HOOK_LOWER) == 0) {
240 priv->lower.hook = hook;
241 priv->upper.dest = hook;
242 bzero(&priv->lower.stats, sizeof(priv->lower.stats));
243 NG_HOOK_SET_PRIVATE(hook, &priv->lower);
244 } else if (strcmp(name, NG_CAR_HOOK_UPPER) == 0) {
245 priv->upper.hook = hook;
246 priv->lower.dest = hook;
247 bzero(&priv->upper.stats, sizeof(priv->upper.stats));
248 NG_HOOK_SET_PRIVATE(hook, &priv->upper);
249 } else
250 return (EINVAL);
251 return(0);
252 }
253
254 /*
255 * Data has arrived.
256 */
257 static int
258 ng_car_rcvdata(hook_p hook, item_p item )
259 {
260 struct hookinfo *const hinfo = NG_HOOK_PRIVATE(hook);
261 struct mbuf *m;
262 int error = 0;
263 u_int len;
264
265 /* If queue is not empty now then enqueue packet. */
266 if (hinfo->q_first != hinfo->q_last) {
267 ng_car_enqueue(hinfo, item);
268 return (0);
269 }
270
271 m = NGI_M(item);
272
273 #define NG_CAR_PERFORM_MATCH_ACTION(a) \
274 do { \
275 switch (a) { \
276 case NG_CAR_ACTION_FORWARD: \
277 /* Do nothing. */ \
278 break; \
279 case NG_CAR_ACTION_MARK: \
280 /* XXX find a way to mark packets (mbuf tag?) */ \
281 ++hinfo->stats.errors; \
282 break; \
283 case NG_CAR_ACTION_DROP: \
284 default: \
285 /* Drop packet and return. */ \
286 NG_FREE_ITEM(item); \
287 ++hinfo->stats.droped_pkts; \
288 return (0); \
289 } \
290 } while (0)
291
292 /* Packet is counted as 128 tokens for better resolution */
293 if (hinfo->conf.opt & NG_CAR_COUNT_PACKETS) {
294 len = 128;
295 } else {
296 len = m->m_pkthdr.len;
297 }
298
299 /* Check commited token bucket. */
300 if (hinfo->tc - len >= 0) {
301 /* This packet is green. */
302 ++hinfo->stats.green_pkts;
303 hinfo->tc -= len;
304 NG_CAR_PERFORM_MATCH_ACTION(hinfo->conf.green_action);
305 } else {
306
307 /* Refill only if not green without it. */
308 ng_car_refillhook(hinfo);
309
310 /* Check commited token bucket again after refill. */
311 if (hinfo->tc - len >= 0) {
312 /* This packet is green */
313 ++hinfo->stats.green_pkts;
314 hinfo->tc -= len;
315 NG_CAR_PERFORM_MATCH_ACTION(hinfo->conf.green_action);
316
317 /* If not green and mode is SHAPE, enqueue packet. */
318 } else if (hinfo->conf.mode == NG_CAR_SHAPE) {
319 ng_car_enqueue(hinfo, item);
320 return (0);
321
322 /* If not green and mode is RED, calculate probability. */
323 } else if (hinfo->conf.mode == NG_CAR_RED) {
324 /* Is packet is bigger then extended burst? */
325 if (len - (hinfo->tc - len) > hinfo->conf.ebs) {
326 /* This packet is definitely red. */
327 ++hinfo->stats.red_pkts;
328 hinfo->te = 0;
329 NG_CAR_PERFORM_MATCH_ACTION(hinfo->conf.red_action);
330
331 /* Use token bucket to simulate RED-like drop
332 probability. */
333 } else if (hinfo->te + (len - hinfo->tc) <
334 hinfo->conf.ebs) {
335 /* This packet is yellow */
336 ++hinfo->stats.yellow_pkts;
337 hinfo->te += len - hinfo->tc;
338 /* Go to negative tokens. */
339 hinfo->tc -= len;
340 NG_CAR_PERFORM_MATCH_ACTION(hinfo->conf.yellow_action);
341 } else {
342 /* This packet is probaly red. */
343 ++hinfo->stats.red_pkts;
344 hinfo->te = 0;
345 NG_CAR_PERFORM_MATCH_ACTION(hinfo->conf.red_action);
346 }
347 /* If not green and mode is SINGLE/DOUBLE RATE. */
348 } else {
349 /* Check extended token bucket. */
350 if (hinfo->te - len >= 0) {
351 /* This packet is yellow */
352 ++hinfo->stats.yellow_pkts;
353 hinfo->te -= len;
354 NG_CAR_PERFORM_MATCH_ACTION(hinfo->conf.yellow_action);
355 } else {
356 /* This packet is red */
357 ++hinfo->stats.red_pkts;
358 NG_CAR_PERFORM_MATCH_ACTION(hinfo->conf.red_action);
359 }
360 }
361 }
362
363 #undef NG_CAR_PERFORM_MATCH_ACTION
364
365 NG_FWD_ITEM_HOOK(error, item, hinfo->dest);
366 if (error != 0)
367 ++hinfo->stats.errors;
368 ++hinfo->stats.passed_pkts;
369
370 return (error);
371 }
372
373 /*
374 * Receive a control message.
375 */
376 static int
377 ng_car_rcvmsg(node_p node, item_p item, hook_p lasthook)
378 {
379 const priv_p priv = NG_NODE_PRIVATE(node);
380 struct ng_mesg *resp = NULL;
381 int error = 0;
382 struct ng_mesg *msg;
383
384 NGI_GET_MSG(item, msg);
385 switch (msg->header.typecookie) {
386 case NGM_CAR_COOKIE:
387 switch (msg->header.cmd) {
388 case NGM_CAR_GET_STATS:
389 case NGM_CAR_GETCLR_STATS:
390 {
391 struct ng_car_bulkstats *bstats;
392
393 NG_MKRESPONSE(resp, msg,
394 sizeof(*bstats), M_NOWAIT);
395 if (resp == NULL) {
396 error = ENOMEM;
397 break;
398 }
399 bstats = (struct ng_car_bulkstats *)resp->data;
400
401 bcopy(&priv->upper.stats, &bstats->downstream,
402 sizeof(bstats->downstream));
403 bcopy(&priv->lower.stats, &bstats->upstream,
404 sizeof(bstats->upstream));
405 }
406 if (msg->header.cmd == NGM_CAR_GET_STATS)
407 break;
408 case NGM_CAR_CLR_STATS:
409 bzero(&priv->upper.stats,
410 sizeof(priv->upper.stats));
411 bzero(&priv->lower.stats,
412 sizeof(priv->lower.stats));
413 break;
414 case NGM_CAR_GET_CONF:
415 {
416 struct ng_car_bulkconf *bconf;
417
418 NG_MKRESPONSE(resp, msg,
419 sizeof(*bconf), M_NOWAIT);
420 if (resp == NULL) {
421 error = ENOMEM;
422 break;
423 }
424 bconf = (struct ng_car_bulkconf *)resp->data;
425
426 bcopy(&priv->upper.conf, &bconf->downstream,
427 sizeof(bconf->downstream));
428 bcopy(&priv->lower.conf, &bconf->upstream,
429 sizeof(bconf->upstream));
430 /* Convert internal 1/(8*128) of pps into pps */
431 if (bconf->downstream.opt & NG_CAR_COUNT_PACKETS) {
432 bconf->downstream.cir /= 1024;
433 bconf->downstream.pir /= 1024;
434 bconf->downstream.cbs /= 128;
435 bconf->downstream.ebs /= 128;
436 }
437 if (bconf->upstream.opt & NG_CAR_COUNT_PACKETS) {
438 bconf->upstream.cir /= 1024;
439 bconf->upstream.pir /= 1024;
440 bconf->upstream.cbs /= 128;
441 bconf->upstream.ebs /= 128;
442 }
443 }
444 break;
445 case NGM_CAR_SET_CONF:
446 {
447 struct ng_car_bulkconf *const bconf =
448 (struct ng_car_bulkconf *)msg->data;
449
450 /* Check for invalid or illegal config. */
451 if (msg->header.arglen != sizeof(*bconf)) {
452 error = EINVAL;
453 break;
454 }
455 /* Convert pps into internal 1/(8*128) of pps */
456 if (bconf->downstream.opt & NG_CAR_COUNT_PACKETS) {
457 bconf->downstream.cir *= 1024;
458 bconf->downstream.pir *= 1024;
459 bconf->downstream.cbs *= 125;
460 bconf->downstream.ebs *= 125;
461 }
462 if (bconf->upstream.opt & NG_CAR_COUNT_PACKETS) {
463 bconf->upstream.cir *= 1024;
464 bconf->upstream.pir *= 1024;
465 bconf->upstream.cbs *= 125;
466 bconf->upstream.ebs *= 125;
467 }
468 if ((bconf->downstream.cir > 1000000000) ||
469 (bconf->downstream.pir > 1000000000) ||
470 (bconf->upstream.cir > 1000000000) ||
471 (bconf->upstream.pir > 1000000000) ||
472 (bconf->downstream.cbs == 0 &&
473 bconf->downstream.ebs == 0) ||
474 (bconf->upstream.cbs == 0 &&
475 bconf->upstream.ebs == 0))
476 {
477 error = EINVAL;
478 break;
479 }
480 if ((bconf->upstream.mode == NG_CAR_SHAPE) &&
481 (bconf->upstream.cir == 0)) {
482 error = EINVAL;
483 break;
484 }
485 if ((bconf->downstream.mode == NG_CAR_SHAPE) &&
486 (bconf->downstream.cir == 0)) {
487 error = EINVAL;
488 break;
489 }
490
491 /* Copy downstream config. */
492 bcopy(&bconf->downstream, &priv->upper.conf,
493 sizeof(priv->upper.conf));
494 priv->upper.tc = priv->upper.conf.cbs;
495 if (priv->upper.conf.mode == NG_CAR_RED ||
496 priv->upper.conf.mode == NG_CAR_SHAPE) {
497 priv->upper.te = 0;
498 } else {
499 priv->upper.te = priv->upper.conf.ebs;
500 }
501
502 /* Copy upstream config. */
503 bcopy(&bconf->upstream, &priv->lower.conf,
504 sizeof(priv->lower.conf));
505 priv->lower.tc = priv->lower.conf.cbs;
506 if (priv->lower.conf.mode == NG_CAR_RED ||
507 priv->lower.conf.mode == NG_CAR_SHAPE) {
508 priv->lower.te = 0;
509 } else {
510 priv->lower.te = priv->lower.conf.ebs;
511 }
512 }
513 break;
514 default:
515 error = EINVAL;
516 break;
517 }
518 break;
519 default:
520 error = EINVAL;
521 break;
522 }
523 NG_RESPOND_MSG(error, node, item, resp);
524 NG_FREE_MSG(msg);
525 return (error);
526 }
527
528 /*
529 * Do local shutdown processing.
530 */
531 static int
532 ng_car_shutdown(node_p node)
533 {
534 const priv_p priv = NG_NODE_PRIVATE(node);
535
536 ng_uncallout(&priv->upper.q_callout, node);
537 ng_uncallout(&priv->lower.q_callout, node);
538 mtx_destroy(&priv->upper.q_mtx);
539 mtx_destroy(&priv->lower.q_mtx);
540 NG_NODE_UNREF(priv->node);
541 free(priv, M_NETGRAPH);
542 return (0);
543 }
544
545 /*
546 * Hook disconnection.
547 *
548 * For this type, removal of the last link destroys the node.
549 */
550 static int
551 ng_car_disconnect(hook_p hook)
552 {
553 struct hookinfo *const hinfo = NG_HOOK_PRIVATE(hook);
554 const node_p node = NG_HOOK_NODE(hook);
555 const priv_p priv = NG_NODE_PRIVATE(node);
556
557 if (hinfo) {
558 /* Purge queue if not empty. */
559 while (hinfo->q_first != hinfo->q_last) {
560 NG_FREE_M(hinfo->q[hinfo->q_first]);
561 hinfo->q_first++;
562 if (hinfo->q_first >= NG_CAR_QUEUE_SIZE)
563 hinfo->q_first = 0;
564 }
565 /* Remove hook refs. */
566 if (hinfo->hook == priv->upper.hook)
567 priv->lower.dest = NULL;
568 else
569 priv->upper.dest = NULL;
570 hinfo->hook = NULL;
571 }
572 /* Already shutting down? */
573 if ((NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0)
574 && (NG_NODE_IS_VALID(NG_HOOK_NODE(hook))))
575 ng_rmnode_self(NG_HOOK_NODE(hook));
576 return (0);
577 }
578
579 /*
580 * Hook's token buckets refillment.
581 */
582 static void
583 ng_car_refillhook(struct hookinfo *h)
584 {
585 struct bintime newt, deltat;
586 unsigned int deltat_us;
587
588 /* Get current time. */
589 getbinuptime(&newt);
590
591 /* Get time delta since last refill. */
592 deltat = newt;
593 bintime_sub(&deltat, &h->lastRefill);
594
595 /* Time must go forward. */
596 if (deltat.sec < 0) {
597 h->lastRefill = newt;
598 return;
599 }
600
601 /* But not too far forward. */
602 if (deltat.sec >= 1000) {
603 deltat_us = (1000 << 20);
604 } else {
605 /* convert bintime to the 1/(2^20) of sec */
606 deltat_us = (deltat.sec << 20) + (deltat.frac >> 44);
607 }
608
609 if (h->conf.mode == NG_CAR_SINGLE_RATE) {
610 int64_t delta;
611 /* Refill commited token bucket. */
612 h->tc += (h->conf.cir * deltat_us) >> 23;
613 delta = h->tc - h->conf.cbs;
614 if (delta > 0) {
615 h->tc = h->conf.cbs;
616
617 /* Refill exceeded token bucket. */
618 h->te += delta;
619 if (h->te > ((int64_t)h->conf.ebs))
620 h->te = h->conf.ebs;
621 }
622
623 } else if (h->conf.mode == NG_CAR_DOUBLE_RATE) {
624 /* Refill commited token bucket. */
625 h->tc += (h->conf.cir * deltat_us) >> 23;
626 if (h->tc > ((int64_t)h->conf.cbs))
627 h->tc = h->conf.cbs;
628
629 /* Refill peak token bucket. */
630 h->te += (h->conf.pir * deltat_us) >> 23;
631 if (h->te > ((int64_t)h->conf.ebs))
632 h->te = h->conf.ebs;
633
634 } else { /* RED or SHAPE mode. */
635 /* Refill commited token bucket. */
636 h->tc += (h->conf.cir * deltat_us) >> 23;
637 if (h->tc > ((int64_t)h->conf.cbs))
638 h->tc = h->conf.cbs;
639 }
640
641 /* Remember this moment. */
642 h->lastRefill = newt;
643 }
644
645 /*
646 * Schedule callout when we will have required tokens.
647 */
648 static void
649 ng_car_schedule(struct hookinfo *hinfo)
650 {
651 int delay;
652
653 delay = (-(hinfo->tc)) * hz * 8 / hinfo->conf.cir + 1;
654
655 ng_callout(&hinfo->q_callout, NG_HOOK_NODE(hinfo->hook), hinfo->hook,
656 delay, &ng_car_q_event, NULL, 0);
657 }
658
659 /*
660 * Queue processing callout handler.
661 */
662 void
663 ng_car_q_event(node_p node, hook_p hook, void *arg, int arg2)
664 {
665 struct hookinfo *hinfo = NG_HOOK_PRIVATE(hook);
666 struct mbuf *m;
667 int error;
668
669 /* Refill tokens for time we have slept. */
670 ng_car_refillhook(hinfo);
671
672 /* If we have some tokens */
673 while (hinfo->tc >= 0) {
674
675 /* Send packet. */
676 m = hinfo->q[hinfo->q_first];
677 NG_SEND_DATA_ONLY(error, hinfo->dest, m);
678 if (error != 0)
679 ++hinfo->stats.errors;
680 ++hinfo->stats.passed_pkts;
681
682 /* Get next one. */
683 hinfo->q_first++;
684 if (hinfo->q_first >= NG_CAR_QUEUE_SIZE)
685 hinfo->q_first = 0;
686
687 /* Stop if none left. */
688 if (hinfo->q_first == hinfo->q_last)
689 break;
690
691 /* If we have more packet, try it. */
692 m = hinfo->q[hinfo->q_first];
693 if (hinfo->conf.opt & NG_CAR_COUNT_PACKETS) {
694 hinfo->tc -= 128;
695 } else {
696 hinfo->tc -= m->m_pkthdr.len;
697 }
698 }
699
700 /* If something left */
701 if (hinfo->q_first != hinfo->q_last)
702 /* Schedule queue processing. */
703 ng_car_schedule(hinfo);
704 }
705
706 /*
707 * Enqueue packet.
708 */
709 static void
710 ng_car_enqueue(struct hookinfo *hinfo, item_p item)
711 {
712 struct mbuf *m;
713 int len;
714
715 NGI_GET_M(item, m);
716 NG_FREE_ITEM(item);
717
718 /* Lock queue mutex. */
719 mtx_lock(&hinfo->q_mtx);
720
721 /* Calculate used queue length. */
722 len = hinfo->q_last - hinfo->q_first;
723 if (len < 0)
724 len += NG_CAR_QUEUE_SIZE;
725
726 /* If queue is overflowed or we have no RED tokens. */
727 if ((len >= (NG_CAR_QUEUE_SIZE - 1)) ||
728 (hinfo->te + len >= NG_CAR_QUEUE_SIZE)) {
729 /* Drop packet. */
730 ++hinfo->stats.red_pkts;
731 ++hinfo->stats.droped_pkts;
732 NG_FREE_M(m);
733
734 hinfo->te = 0;
735 } else {
736 /* This packet is yellow. */
737 ++hinfo->stats.yellow_pkts;
738
739 /* Enqueue packet. */
740 hinfo->q[hinfo->q_last] = m;
741 hinfo->q_last++;
742 if (hinfo->q_last >= NG_CAR_QUEUE_SIZE)
743 hinfo->q_last = 0;
744
745 /* Use RED tokens. */
746 if (len > NG_CAR_QUEUE_MIN_TH)
747 hinfo->te += len - NG_CAR_QUEUE_MIN_TH;
748
749 /* If this is a first packet in the queue. */
750 if (len == 0) {
751 if (hinfo->conf.opt & NG_CAR_COUNT_PACKETS) {
752 hinfo->tc -= 128;
753 } else {
754 hinfo->tc -= m->m_pkthdr.len;
755 }
756
757 /* Schedule queue processing. */
758 ng_car_schedule(hinfo);
759 }
760 }
761
762 /* Unlock queue mutex. */
763 mtx_unlock(&hinfo->q_mtx);
764 }
Cache object: f0129df22dd5863547ee4a4fb77b1e87
|