![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ip_dummynet.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netinet|
Return to ip_dummynet.c CVS log | Up to [Apple XNU] / XNU / bsd / netinet |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1998 Luigi Rizzo
24: *
25: * Redistribution and use in source forms, with and without modification,
26: * are permitted provided that this entire comment appears intact.
27: *
28: * Redistribution in binary form may occur without any restrictions.
29: * Obviously, it would be nice if you gave credit where credit is due
30: * but requiring it would be too onerous.
31: *
32: * This software is provided ``AS IS'' without any warranties of any kind.
33: *
34: */
35:
36: /*
37: * This module implements IP dummynet, a bandwidth limiter/delay emulator
38: * used in conjunction with the ipfw package.
39: *
40: * Changes:
41: *
42: * 980821: changed conventions in the queueing logic
43: * packets passed from dummynet to ip_in/out are prepended with
44: * a vestigial mbuf type MT_DUMMYNET which contains a pointer
45: * to the matching rule.
46: * ip_input/output will extract the parameters, free the vestigial mbuf,
47: * and do the processing.
48: *
49: * 980519: fixed behaviour when deleting rules.
50: * 980518: added splimp()/splx() to protect against races
51: * 980513: initial release
52: */
53:
54: /* include files marked with XXX are probably not needed */
55:
56: #include <sys/param.h>
57: #include <sys/systm.h>
58: #include <sys/malloc.h>
59: #include <sys/mbuf.h>
60: #include <sys/queue.h> /* XXX */
61: #include <sys/kernel.h>
62: #include <sys/socket.h>
63: #include <sys/socketvar.h>
64: #include <sys/time.h>
65: #include <sys/sysctl.h>
66: #include <net/if.h>
67: #include <net/route.h>
68: #include <netinet/in.h>
69: #include <netinet/in_systm.h>
70: #include <netinet/in_var.h>
71: #include <netinet/ip.h>
72: #include <netinet/ip_fw.h>
73: #include <netinet/ip_dummynet.h>
74: #include <netinet/ip_var.h>
75:
76: #if BRIDGE
77: #include <netinet/if_ether.h> /* for struct arpcom */
78: #include <net/bridge.h>
79: #endif
80:
81: static struct dn_pipe *all_pipes = NULL ; /* list of all pipes */
82:
83: static int dn_debug = 0 ; /* verbose */
84: static int dn_calls = 0 ; /* number of calls */
85: static int dn_idle = 1;
86: #ifdef SYSCTL_NODE
87: SYSCTL_NODE(_net_inet_ip, OID_AUTO, dummynet, CTLFLAG_RW, 0, "Dummynet");
88: SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, debug, CTLFLAG_RW, &dn_debug, 0, "");
89: SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, calls, CTLFLAG_RD, &dn_calls, 0, "");
90: SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, idle, CTLFLAG_RD, &dn_idle, 0, "");
91: #endif
92:
93: static int ip_dn_ctl(struct sockopt *sopt);
94:
95: static void rt_unref(struct rtentry *);
96: static void dummynet(void *);
97: static void dn_restart(void);
98: static void dn_move(struct dn_pipe *pipe, int immediate);
99: static void dummynet_flush(void);
100:
101: /*
102: * the following is needed when deleting a pipe, because rules can
103: * hold references to the pipe.
104: */
105: extern LIST_HEAD (ip_fw_head, ip_fw_chain) ip_fw_chain;
106:
107: /*
108: * invoked to reschedule the periodic task if necessary.
109: * Should only be called when dn_idle = 1 ;
110: */
111: static void
112: dn_restart()
113: {
114: struct dn_pipe *pipe;
115:
116: if (!dn_idle)
117: return;
118:
119: for (pipe = all_pipes ; pipe ; pipe = pipe->next ) {
120: /* if there any pipe that needs work, restart */
121: if (pipe->r.head || pipe->p.head || pipe->numbytes < 0 ) {
122: dn_idle = 0;
123: timeout(dummynet, NULL, 1);
124: return ;
125: }
126: }
127: }
128:
129: static void
130: rt_unref(struct rtentry *rt)
131: {
132: if (rt == NULL)
133: return ;
134: if (rt->rt_refcnt <= 0)
135: printf("-- warning, refcnt now %d, decreasing\n", rt->rt_refcnt);
136: RTFREE(rt);
137: }
138:
139: /*
140: * move packets from R-queue to P-queue
141: */
142: static void
143: dn_move(struct dn_pipe *pipe, int immediate)
144: {
145: struct dn_pkt *pkt;
146:
147: /*
148: * consistency check, should catch new pipes which are
149: * not initialized properly.
150: */
151: if ( pipe->p.head == NULL &&
152: pipe->ticks_from_last_insert != pipe->delay) {
153: printf("Warning, empty pipe and delay %d (should be %d)\n",
154: pipe->ticks_from_last_insert, pipe->delay);
155: pipe->ticks_from_last_insert = pipe->delay;
156: }
157: /* this ought to go in dn_dequeue() */
158: if (!immediate && pipe->ticks_from_last_insert < pipe->delay)
159: pipe->ticks_from_last_insert++;
160: if ( pkt = pipe->r.head ) {
161: /*
162: * Move at most numbytes bytes from src and move to dst.
163: * delay is set to ticks_from_last_insert, which
164: * is reset after the first insertion;
165: */
166: while ( pkt ) {
167: struct ip *ip=mtod(pkt->dn_m, struct ip *);
168:
169: /*
170: * queue limitation: pass packets down if the len is
171: * such that the pkt would go out before the next tick.
172: */
173: if (pipe->bandwidth) {
174: if (pipe->numbytes < ip->ip_len)
175: break;
176: pipe->numbytes -= ip->ip_len;
177: }
178: pipe->r_len--; /* elements in queue */
179: pipe->r_len_bytes -= ip->ip_len ;
180:
181: /*
182: * to add delay jitter, must act here. A lower value
183: * (bounded to 0) means lower delay.
184: */
185: pkt->delay = pipe->ticks_from_last_insert;
186: pipe->ticks_from_last_insert = 0;
187: /* compensate the decrement done next in dn_dequeue */
188: if (!immediate && pkt->delay >0 && pipe->p.head==NULL)
189: pkt->delay++;
190: if (pipe->p.head == NULL)
191: pipe->p.head = pkt;
192: else
193: (struct dn_pkt *)pipe->p.tail->dn_next = pkt;
194: pipe->p.tail = pkt;
195: pkt = (struct dn_pkt *)pkt->dn_next;
196: pipe->p.tail->dn_next = NULL;
197: }
198: pipe->r.head = pkt;
199:
200: /*** XXX just a sanity check */
201: if ( ( pkt == NULL && pipe->r_len != 0) ||
202: ( pkt != NULL && pipe->r_len == 0) )
203: printf("-- Warning, pipe head %p len %d\n",
204: (void *)pkt, pipe->r_len);
205: }
206:
207: /*
208: * deliver packets downstream after the delay in the P-queue.
209: */
210:
211: if (pipe->p.head == NULL)
212: return;
213: if (!immediate)
214: pipe->p.head->delay--;
215: while ( (pkt = pipe->p.head) && pkt->delay < 1) {
216: /*
217: * first unlink, then call procedures since ip_input()
218: * can result in a call to ip_output cnd viceversa,
219: * thus causing nested calls
220: */
221: pipe->p.head = (struct dn_pkt *) pkt->dn_next ;
222:
223: /*
224: * the trick to avoid flow-id settings here is to prepend a
225: * vestigial mbuf to the packet, with the following values:
226: * m_type = MT_DUMMYNET
227: * m_next = the actual mbuf to be processed by ip_input/output
228: * m_data = the matching rule
229: * The vestigial element is the same memory area used by
230: * the dn_pkt, and IS FREED IN ip_input/ip_output. IT IS
231: * NOT A REAL MBUF, just a block of memory acquired with malloc().
232: */
233: switch (pkt->dn_dir) {
234: case DN_TO_IP_OUT: {
235: struct rtentry *tmp_rt = pkt->ro.ro_rt ;
236:
237: (void)ip_output((struct mbuf *)pkt, (struct mbuf *)pkt->ifp,
238: &(pkt->ro), pkt->dn_hlen, NULL);
239: rt_unref (tmp_rt) ;
240: }
241: break ;
242: case DN_TO_IP_IN :
243: ip_input((struct mbuf *)pkt) ;
244: break ;
245: #if BRIDGE
246: case DN_TO_BDG_FWD :
247: bdg_forward((struct mbuf **)&pkt, pkt->ifp);
248: break ;
249: #endif
250: default:
251: printf("dummynet: bad switch %d!\n", pkt->dn_dir);
252: m_freem(pkt->dn_m);
253: FREE(pkt, M_IPFW);
254: break ;
255: }
256: }
257: }
258: /*
259: * this is the periodic task that moves packets between the R-
260: * and the P- queue
261: */
262: /*ARGSUSED*/
263: void
264: dummynet(void * __unused unused)
265: {
266: struct dn_pipe *p ;
267: int s ;
268:
269: dn_calls++ ;
270: for (p = all_pipes ; p ; p = p->next ) {
271: /*
272: * Increment the amount of data that can be sent. However,
273: * don't do that if the channel is idle
274: * (r.head == NULL && numbytes >= bandwidth).
275: * This bug fix is from tim shepard ([email protected])
276: */
277: s = splimp();
278: if (p->r.head != NULL || p->numbytes < p->bandwidth )
279: p->numbytes += p->bandwidth ;
280: dn_move(p, 0); /* is it really 0 (also below) ? */
281: splx(s);
282: }
283:
284: /*
285: * finally, if some queue has data, restart the timer.
286: */
287: dn_idle = 1;
288: dn_restart();
289: }
290:
291: /*
292: * dummynet hook for packets.
293: * input and output use the same code, so i use bit 16 in the pipe
294: * number to chose the direction: 1 for output packets, 0 for input.
295: * for input, only m is significant. For output, also the others.
296: */
297: int
298: dummynet_io(int pipe_nr, int dir,
299: struct mbuf *m, struct ifnet *ifp, struct route *ro, int hlen,
300: struct ip_fw_chain *rule)
301: {
302: struct dn_pkt *pkt;
303: struct dn_pipe *pipe;
304: struct ip *ip=mtod(m, struct ip *);
305:
306: int s=splimp();
307:
308: pipe_nr &= 0xffff ;
309: /*
310: * locate pipe. First time is expensive, next have direct access.
311: */
312:
313: if ( (pipe = rule->rule->pipe_ptr) == NULL ) {
314: for (pipe=all_pipes; pipe && pipe->pipe_nr !=pipe_nr; pipe=pipe->next)
315: ;
316: if (pipe == NULL) {
317: splx(s);
318: if (dn_debug)
319: printf("warning, pkt for no pipe %d\n", pipe_nr);
320: m_freem(m);
321: return 0 ;
322: } else
323: rule->rule->pipe_ptr = pipe ;
324: }
325:
326: /*
327: * should i drop ?
328: * This section implements random packet drop.
329: */
330: if ( (pipe->plr && random() < pipe->plr) ||
331: (pipe->queue_size && pipe->r_len >= pipe->queue_size) ||
332: (pipe->queue_size_bytes &&
333: ip->ip_len + pipe->r_len_bytes > pipe->queue_size_bytes) ||
334: (pkt = (struct dn_pkt *) _MALLOC(sizeof (*pkt),
335: M_IPFW, M_NOWAIT) ) == NULL ) {
336: splx(s);
337: if (dn_debug)
338: printf("-- dummynet: drop from pipe %d, have %d pks, %d bytes\n",
339: pipe_nr, pipe->r_len, pipe->r_len_bytes);
340: pipe->r_drops++ ;
341: m_freem(m);
342: return 0 ; /* XXX error */
343: }
344: bzero(pkt, sizeof(*pkt) );
345: /* build and enqueue packet */
346: pkt->hdr.mh_type = MT_DUMMYNET ;
347: (struct ip_fw_chain *)pkt->hdr.mh_data = rule ;
348: pkt->dn_next = NULL;
349: pkt->dn_m = m;
350: pkt->dn_dir = dir ;
351: pkt->delay = 0;
352:
353: pkt->ifp = ifp;
354: if (dir == DN_TO_IP_OUT) {
355: pkt->ro = *ro; /* XXX copied! */
356: if (ro->ro_rt)
357: ro->ro_rt->rt_refcnt++ ; /* XXX */
358: }
359: pkt->dn_hlen = hlen;
360: if (pipe->r.head == NULL)
361: pipe->r.head = pkt;
362: else
363: (struct dn_pkt *)pipe->r.tail->dn_next = pkt;
364: pipe->r.tail = pkt;
365: pipe->r_len++;
366: pipe->r_len_bytes += ip->ip_len ;
367:
368: /*
369: * here we could implement RED if we like to
370: */
371:
372: if (pipe->r.head == pkt) { /* process immediately */
373: dn_move(pipe, 1);
374: }
375: splx(s);
376: if (dn_idle)
377: dn_restart();
378: return 0;
379: }
380:
381: /*
382: * dispose all packets queued on a pipe
383: */
384: static void
385: purge_pipe(struct dn_pipe *pipe)
386: {
387: struct dn_pkt *pkt, *n ;
388: struct rtentry *tmp_rt ;
389:
390: for (pkt = pipe->r.head ; pkt ; ) {
391: rt_unref (tmp_rt = pkt->ro.ro_rt ) ;
392: m_freem(pkt->dn_m);
393: n = pkt ;
394: pkt = (struct dn_pkt *)pkt->dn_next ;
395: FREE(n, M_IPFW) ;
396: }
397: for (pkt = pipe->p.head ; pkt ; ) {
398: rt_unref (tmp_rt = pkt->ro.ro_rt ) ;
399: m_freem(pkt->dn_m);
400: n = pkt ;
401: pkt = (struct dn_pkt *)pkt->dn_next ;
402: FREE(n, M_IPFW) ;
403: }
404: }
405:
406: /*
407: * delete all pipes returning memory
408: */
409: static void
410: dummynet_flush()
411: {
412: struct dn_pipe *q, *p = all_pipes ;
413: int s = splnet() ;
414:
415: all_pipes = NULL ;
416: splx(s) ;
417: /*
418: * purge all queued pkts and delete all pipes
419: */
420: for ( ; p ; ) {
421: purge_pipe(p);
422: q = p ;
423: p = p->next ;
424: FREE(q, M_IPFW);
425: }
426: }
427:
428: extern struct ip_fw_chain *ip_fw_default_rule ;
429: /*
430: * when a firewall rule is deleted, scan all pipes and remove the flow-id
431: * from packets matching this rule.
432: */
433: void
434: dn_rule_delete(void *r)
435: {
436: struct dn_pipe *p ;
437: int matches = 0 ;
438:
439: for ( p = all_pipes ; p ; p = p->next ) {
440: struct dn_pkt *x ;
441: for (x = p->r.head ; x ; x = (struct dn_pkt *)x->dn_next )
442: if (x->hdr.mh_data == r) {
443: matches++ ;
444: x->hdr.mh_data = (void *)ip_fw_default_rule ;
445: }
446: for (x = p->p.head ; x ; x = (struct dn_pkt *)x->dn_next )
447: if (x->hdr.mh_data == r) {
448: matches++ ;
449: x->hdr.mh_data = (void *)ip_fw_default_rule ;
450: }
451: }
452: printf("dn_rule_delete, r %p, default %p%s, %d matches\n",
453: (void *)r, (void *)ip_fw_default_rule,
454: r == ip_fw_default_rule ? " AARGH!":"", matches);
455: }
456:
457: /*
458: * handler for the various dummynet socket options
459: * (get, flush, config, del)
460: */
461: static int
462: ip_dn_ctl(struct sockopt *sopt)
463: {
464: int error = 0 ;
465: size_t size ;
466: char *buf, *bp ;
467: struct dn_pipe *p, tmp_pipe ;
468:
469: struct dn_pipe *x, *a, *b ;
470:
471: /* Disallow sets in really-really secure mode. */
472: if (sopt->sopt_dir == SOPT_SET && securelevel >= 3)
473: return (EPERM);
474:
475: switch (sopt->sopt_name) {
476: default :
477: panic("ip_dn_ctl -- unknown option");
478:
479: case IP_DUMMYNET_GET :
480: for (p = all_pipes, size = 0 ; p ; p = p->next )
481: size += sizeof( *p ) ;
482: buf = _MALLOC(size, M_TEMP, M_WAITOK);
483: if (buf == 0) {
484: error = ENOBUFS ;
485: break ;
486: }
487: for (p = all_pipes, bp = buf ; p ; p = p->next ) {
488: struct dn_pipe *q = (struct dn_pipe *)bp ;
489:
490: bcopy(p, bp, sizeof( *p ) );
491: /*
492: * return bw and delay in bits/s and ms, respectively
493: */
494: q->bandwidth *= (8*hz) ;
495: q->delay = (q->delay * 1000) / hz ;
496: bp += sizeof( *p ) ;
497: }
498: error = sooptcopyout(sopt, buf, size);
499: FREE(buf, M_TEMP);
500: break ;
501: case IP_DUMMYNET_FLUSH :
502: dummynet_flush() ;
503: break ;
504: case IP_DUMMYNET_CONFIGURE :
505: p = &tmp_pipe ;
506: error = sooptcopyin(sopt, p, sizeof *p, sizeof *p);
507: if (error)
508: break ;
509: /*
510: * The config program passes parameters as follows:
511: * bandwidth = bits/second (0 = no limits);
512: * must be translated in bytes/tick.
513: * delay = ms
514: * must be translated in ticks.
515: * queue_size = slots (0 = no limit)
516: * queue_size_bytes = bytes (0 = no limit)
517: * only one can be set, must be bound-checked
518: */
519: if ( p->bandwidth > 0 ) {
520: p->bandwidth = p->bandwidth / 8 / hz ;
521: if (p->bandwidth == 0) /* too little does not make sense! */
522: p->bandwidth = 10 ;
523: }
524: p->delay = ( p->delay * hz ) / 1000 ;
525: if (p->queue_size == 0 && p->queue_size_bytes == 0)
526: p->queue_size = 100 ;
527: if (p->queue_size != 0 ) /* buffers are prevailing */
528: p->queue_size_bytes = 0 ;
529: if (p->queue_size > 100)
530: p->queue_size = 100 ;
531: if (p->queue_size_bytes > 1024*1024)
532: p->queue_size_bytes = 1024*1024 ;
533: #if 0
534: printf("ip_dn: config pipe %d %d bit/s %d ms %d bufs\n",
535: p->pipe_nr,
536: p->bandwidth * 8 * hz ,
537: p->delay * 1000 / hz , p->queue_size);
538: #endif
539: for (a = NULL , b = all_pipes ; b && b->pipe_nr < p->pipe_nr ;
540: a = b , b = b->next) ;
541: if (b && b->pipe_nr == p->pipe_nr) {
542: /* XXX should spl and flush old pipe... */
543: b->bandwidth = p->bandwidth ;
544: b->delay = p->delay ;
545: b->ticks_from_last_insert = p->delay ;
546: b->queue_size = p->queue_size ;
547: b->queue_size_bytes = p->queue_size_bytes ;
548: b->plr = p->plr ;
549: } else {
550: int s ;
551: x = _MALLOC(sizeof(struct dn_pipe), M_IPFW, M_DONTWAIT) ;
552: if (x == NULL) {
553: printf("ip_dummynet.c: sorry no memory\n");
554: error = ENOSPC ;
555: break ;
556: }
557: bzero(x, sizeof(*x) );
558: x->bandwidth = p->bandwidth ;
559: x->delay = p->delay ;
560: x->ticks_from_last_insert = p->delay ;
561: x->pipe_nr = p->pipe_nr ;
562: x->queue_size = p->queue_size ;
563: x->queue_size_bytes = p->queue_size_bytes ;
564: x->plr = p->plr ;
565:
566: s = splnet() ;
567: x->next = b ;
568: if (a == NULL)
569: all_pipes = x ;
570: else
571: a->next = x ;
572: splx(s);
573: }
574: break ;
575:
576: case IP_DUMMYNET_DEL :
577: p = &tmp_pipe ;
578: error = sooptcopyin(sopt, p, sizeof *p, sizeof *p);
579: if (error)
580: break ;
581:
582: for (a = NULL , b = all_pipes ; b && b->pipe_nr < p->pipe_nr ;
583: a = b , b = b->next) ;
584: if (b && b->pipe_nr == p->pipe_nr) { /* found pipe */
585: int s = splnet() ;
586: struct ip_fw_chain *chain = ip_fw_chain.lh_first;
587:
588: if (a == NULL)
589: all_pipes = b->next ;
590: else
591: a->next = b->next ;
592: /*
593: * remove references to this pipe from the ip_fw rules.
594: */
595: for (; chain; chain = chain->chain.le_next) {
596: register struct ip_fw *const f = chain->rule;
597: if (f->pipe_ptr == b)
598: f->pipe_ptr = NULL ;
599: }
600: splx(s);
601: purge_pipe(b); /* remove pkts from here */
602: FREE(b, M_IPFW);
603: }
604: break ;
605: }
606: return error ;
607: }
608:
609: void
610: ip_dn_init(void)
611: {
612: printf("DUMMYNET initialized (980901) -- size dn_pkt %d\n",
613: sizeof(struct dn_pkt));
614: all_pipes = NULL ;
615: ip_dn_ctl_ptr = ip_dn_ctl;
616: }
617:
618: #if DUMMYNET_MODULE
619:
620: #include <sys/exec.h>
621: #include <sys/sysent.h>
622: #include <sys/lkm.h>
623:
624: MOD_MISC(dummynet);
625:
626: static ip_dn_ctl_t *old_dn_ctl_ptr ;
627:
628: static int
629: dummynet_load(struct lkm_table *lkmtp, int cmd)
630: {
631: int s=splnet();
632: old_dn_ctl_ptr = ip_dn_ctl_ptr;
633: ip_dn_init();
634: splx(s);
635: return 0;
636: }
637:
638: static int
639: dummynet_unload(struct lkm_table *lkmtp, int cmd)
640: {
641: int s=splnet();
642: ip_dn_ctl_ptr = old_dn_ctl_ptr;
643: splx(s);
644: dummynet_flush();
645: printf("DUMMYNET unloaded\n");
646: return 0;
647: }
648:
649: int
650: dummynet_mod(struct lkm_table *lkmtp, int cmd, int ver)
651: {
652: DISPATCH(lkmtp, cmd, ver, dummynet_load, dummynet_unload, lkm_nullcmd);
653: }
654: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.