projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Add missing iptables extensions
[openwrt.git] / openwrt / package / iproute2 / patches / debian-patches-3.patch
1 --- iproute-20041019.orig/ip/Makefile
2 +++ iproute-20041019/ip/Makefile
3 @@ -6,7 +6,7 @@
4 RTMONOBJ=rtmon.o
5
6 ALLOBJ=$(IPOBJ) $(RTMONOBJ)
7 -TARGETS=ip rtmon ifcfg rtpr
8 +TARGETS=ip rtmon
9
10 all: $(TARGETS)
11
12 --- iproute-20041019.orig/tc/q_htb.c
13 +++ iproute-20041019/tc/q_htb.c
14 @@ -1,3 +1,311 @@
15 +#if 0
16 +/*
17 + * q_htb.c HTB.
18 + *
19 + * This program is free software; you can redistribute it and/or
20 + * modify it under the terms of the GNU General Public License
21 + * as published by the Free Software Foundation; either version
22 + * 2 of the License, or (at your option) any later version.
23 + *
24 + * Authors: Martin Devera, devik@cdi.cz
25 + *
26 + */
27 +
28 +#include <stdio.h>
29 +#include <stdlib.h>
30 +#include <unistd.h>
31 +#include <syslog.h>
32 +#include <fcntl.h>
33 +#include <sys/socket.h>
34 +#include <netinet/in.h>
35 +#include <arpa/inet.h>
36 +#include <string.h>
37 +
38 +#include "utils.h"
39 +#include "tc_util.h"
40 +
41 +#define HTB_TC_VER 0x30003
42 +#if HTB_TC_VER >> 16 != TC_HTB_PROTOVER
43 +#error "Different kernel and TC HTB versions"
44 +#endif
45 +
46 +static void explain(void)
47 +{
48 + fprintf(stderr, "Usage: ... qdisc add ... htb [default N] [r2q N]\n"
49 + " default minor id of class to which unclassified packets are sent {0}\n"
50 + " r2q DRR quantums are computed as rate in Bps/r2q {10}\n"
51 + " debug string of 16 numbers each 0-3 {0}\n\n"
52 + "... class add ... htb rate R1 burst B1 [prio P] [slot S] [pslot PS]\n"
53 + " [ceil R2] [cburst B2] [mtu MTU] [quantum Q]\n"
54 + " rate rate allocated to this class (class can still borrow)\n"
55 + " burst max bytes burst which can be accumulated during idle period {computed}\n"
56 + " ceil definite upper class rate (no borrows) {rate}\n"
57 + " cburst burst but for ceil {computed}\n"
58 + " mtu max packet size we create rate map for {1600}\n"
59 + " prio priority of leaf; lower are served first {0}\n"
60 + " quantum how much bytes to serve from leaf at once {use r2q}\n"
61 + "\nTC HTB version %d.%d\n",HTB_TC_VER>>16,HTB_TC_VER&0xffff
62 + );
63 +}
64 +
65 +static void explain1(char *arg)
66 +{
67 + fprintf(stderr, "Illegal \"%s\"\n", arg);
68 + explain();
69 +}
70 +
71 +
72 +#define usage() return(-1)
73 +
74 +static int htb_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
75 +{
76 + struct tc_htb_glob opt;
77 + struct rtattr *tail;
78 + unsigned i; char *p;
79 + memset(&opt,0,sizeof(opt));
80 + opt.rate2quantum = 10;
81 + opt.version = 3;
82 +
83 + while (argc > 0) {
84 + if (matches(*argv, "r2q") == 0) {
85 + NEXT_ARG();
86 + if (get_u32(&opt.rate2quantum, *argv, 10)) {
87 + explain1("r2q"); return -1;
88 + }
89 + } else if (matches(*argv, "default") == 0) {
90 + NEXT_ARG();
91 + if (get_u32(&opt.defcls, *argv, 16)) {
92 + explain1("default"); return -1;
93 + }
94 + } else if (matches(*argv, "debug") == 0) {
95 + NEXT_ARG(); p = *argv;
96 + for (i=0; i<16; i++,p++) {
97 + if (*p<'0' || *p>'3') break;
98 + opt.debug |= (*p-'0')<<(2*i);
99 + }
100 + } else {
101 + fprintf(stderr, "What is \"%s\"?\n", *argv);
102 + explain();
103 + return -1;
104 + }
105 + argc--; argv++;
106 + }
107 + tail = (struct rtattr*)(((void*)n)+NLMSG_ALIGN(n->nlmsg_len));
108 + addattr_l(n, 1024, TCA_OPTIONS, NULL, 0);
109 + addattr_l(n, 2024, TCA_HTB_INIT, &opt, NLMSG_ALIGN(sizeof(opt)));
110 + tail->rta_len = (((void*)n)+NLMSG_ALIGN(n->nlmsg_len)) - (void*)tail;
111 + return 0;
112 +}
113 +
114 +static int htb_parse_class_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
115 +{
116 + int ok=0;
117 + struct tc_htb_opt opt;
118 + __u32 rtab[256],ctab[256];
119 + unsigned buffer=0,cbuffer=0;
120 + int cell_log=-1,ccell_log = -1,mtu;
121 + struct rtattr *tail;
122 +
123 + memset(&opt, 0, sizeof(opt)); mtu = 1600; /* eth packet len */
124 +
125 + while (argc > 0) {
126 + if (matches(*argv, "prio") == 0) {
127 + NEXT_ARG();
128 + if (get_u32(&opt.prio, *argv, 10)) {
129 + explain1("prio"); return -1;
130 + }
131 + ok++;
132 + } else if (matches(*argv, "mtu") == 0) {
133 + NEXT_ARG();
134 + if (get_u32(&mtu, *argv, 10)) {
135 + explain1("mtu"); return -1;
136 + }
137 + } else if (matches(*argv, "quantum") == 0) {
138 + NEXT_ARG();
139 + if (get_u32(&opt.quantum, *argv, 10)) {
140 + explain1("quantum"); return -1;
141 + }
142 + } else if (matches(*argv, "burst") == 0 ||
143 + strcmp(*argv, "buffer") == 0 ||
144 + strcmp(*argv, "maxburst") == 0) {
145 + NEXT_ARG();
146 + if (get_size_and_cell(&buffer, &cell_log, *argv) < 0) {
147 + explain1("buffer");
148 + return -1;
149 + }
150 + ok++;
151 + } else if (matches(*argv, "cburst") == 0 ||
152 + strcmp(*argv, "cbuffer") == 0 ||
153 + strcmp(*argv, "cmaxburst") == 0) {
154 + NEXT_ARG();
155 + if (get_size_and_cell(&cbuffer, &ccell_log, *argv) < 0) {
156 + explain1("cbuffer");
157 + return -1;
158 + }
159 + ok++;
160 + } else if (strcmp(*argv, "ceil") == 0) {
161 + NEXT_ARG();
162 + if (opt.ceil.rate) {
163 + fprintf(stderr, "Double \"ceil\" spec\n");
164 + return -1;
165 + }
166 + if (get_rate(&opt.ceil.rate, *argv)) {
167 + explain1("ceil");
168 + return -1;
169 + }
170 + ok++;
171 + } else if (strcmp(*argv, "rate") == 0) {
172 + NEXT_ARG();
173 + if (opt.rate.rate) {
174 + fprintf(stderr, "Double \"rate\" spec\n");
175 + return -1;
176 + }
177 + if (get_rate(&opt.rate.rate, *argv)) {
178 + explain1("rate");
179 + return -1;
180 + }
181 + ok++;
182 + } else if (strcmp(*argv, "help") == 0) {
183 + explain();
184 + return -1;
185 + } else {
186 + fprintf(stderr, "What is \"%s\"?\n", *argv);
187 + explain();
188 + return -1;
189 + }
190 + argc--; argv++;
191 + }
192 +
193 +/* if (!ok)
194 + return 0;*/
195 +
196 + if (opt.rate.rate == 0) {
197 + fprintf(stderr, "\"rate\" is required.\n");
198 + return -1;
199 + }
200 + /* if ceil params are missing, use the same as rate */
201 + if (!opt.ceil.rate) opt.ceil = opt.rate;
202 +
203 + /* compute minimal allowed burst from rate; mtu is added here to make
204 + sute that buffer is larger than mtu and to have some safeguard space */
205 + if (!buffer) buffer = opt.rate.rate / HZ + mtu;
206 + if (!cbuffer) cbuffer = opt.ceil.rate / HZ + mtu;
207 +
208 + if ((cell_log = tc_calc_rtable(opt.rate.rate, rtab, cell_log, mtu, 0)) < 0) {
209 + fprintf(stderr, "htb: failed to calculate rate table.\n");
210 + return -1;
211 + }
212 + opt.buffer = tc_calc_xmittime(opt.rate.rate, buffer);
213 + opt.rate.cell_log = cell_log;
214 +
215 + if ((ccell_log = tc_calc_rtable(opt.ceil.rate, ctab, cell_log, mtu, 0)) < 0) {
216 + fprintf(stderr, "htb: failed to calculate ceil rate table.\n");
217 + return -1;
218 + }
219 + opt.cbuffer = tc_calc_xmittime(opt.ceil.rate, cbuffer);
220 + opt.ceil.cell_log = ccell_log;
221 +
222 + tail = (struct rtattr*)(((void*)n)+NLMSG_ALIGN(n->nlmsg_len));
223 + addattr_l(n, 1024, TCA_OPTIONS, NULL, 0);
224 + addattr_l(n, 2024, TCA_HTB_PARMS, &opt, sizeof(opt));
225 + addattr_l(n, 3024, TCA_HTB_RTAB, rtab, 1024);
226 + addattr_l(n, 4024, TCA_HTB_CTAB, ctab, 1024);
227 + tail->rta_len = (((void*)n)+NLMSG_ALIGN(n->nlmsg_len)) - (void*)tail;
228 + return 0;
229 +}
230 +
231 +static int htb_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
232 +{
233 + struct rtattr *tb[TCA_HTB_RTAB+1];
234 + struct tc_htb_opt *hopt;
235 + struct tc_htb_glob *gopt;
236 + double buffer,cbuffer;
237 + SPRINT_BUF(b1);
238 + SPRINT_BUF(b2);
239 +
240 + if (opt == NULL)
241 + return 0;
242 +
243 + memset(tb, 0, sizeof(tb));
244 + parse_rtattr(tb, TCA_HTB_RTAB, RTA_DATA(opt), RTA_PAYLOAD(opt));
245 +
246 + if (tb[TCA_HTB_PARMS]) {
247 +
248 + hopt = RTA_DATA(tb[TCA_HTB_PARMS]);
249 + if (RTA_PAYLOAD(tb[TCA_HTB_PARMS]) < sizeof(*hopt)) return -1;
250 +
251 + if (!hopt->level) {
252 + fprintf(f, "prio %d ", (int)hopt->prio);
253 + if (show_details)
254 + fprintf(f, "quantum %d ", (int)hopt->quantum);
255 + }
256 + fprintf(f, "rate %s ", sprint_rate(hopt->rate.rate, b1));
257 + buffer = ((double)hopt->rate.rate*tc_core_tick2usec(hopt->buffer))/1000000;
258 + fprintf(f, "ceil %s ", sprint_rate(hopt->ceil.rate, b1));
259 + cbuffer = ((double)hopt->ceil.rate*tc_core_tick2usec(hopt->cbuffer))/1000000;
260 + if (show_details) {
261 + fprintf(f, "burst %s/%u mpu %s ", sprint_size(buffer, b1),
262 + 1<<hopt->rate.cell_log, sprint_size(hopt->rate.mpu, b2));
263 + fprintf(f, "cburst %s/%u mpu %s ", sprint_size(cbuffer, b1),
264 + 1<<hopt->ceil.cell_log, sprint_size(hopt->ceil.mpu, b2));
265 + fprintf(f, "level %d ", (int)hopt->level);
266 + } else {
267 + fprintf(f, "burst %s ", sprint_size(buffer, b1));
268 + fprintf(f, "cburst %s ", sprint_size(cbuffer, b1));
269 + }
270 + if (show_raw)
271 + fprintf(f, "buffer [%08x] cbuffer [%08x] ",
272 + hopt->buffer,hopt->cbuffer);
273 + }
274 + if (tb[TCA_HTB_INIT]) {
275 + gopt = RTA_DATA(tb[TCA_HTB_INIT]);
276 + if (RTA_PAYLOAD(tb[TCA_HTB_INIT]) < sizeof(*gopt)) return -1;
277 +
278 + fprintf(f, "r2q %d default %x direct_packets_stat %u",
279 + gopt->rate2quantum,gopt->defcls,gopt->direct_pkts);
280 + if (show_details)
281 + fprintf(f," ver %d.%d",gopt->version >> 16,gopt->version & 0xffff);
282 + }
283 + return 0;
284 +}
285 +
286 +static int htb_print_xstats(struct qdisc_util *qu, FILE *f, struct rtattr *xstats)
287 +{
288 + struct tc_htb_xstats *st;
289 + if (xstats == NULL)
290 + return 0;
291 +
292 + if (RTA_PAYLOAD(xstats) < sizeof(*st))
293 + return -1;
294 +
295 + st = RTA_DATA(xstats);
296 + fprintf(f, " lended: %u borrowed: %u giants: %u\n",
297 + st->lends,st->borrows,st->giants);
298 + fprintf(f, " tokens: %d ctokens: %d\n", st->tokens,st->ctokens);
299 + return 0;
300 +}
301 +
302 +struct qdisc_util htb_util = {
303 + NULL,
304 + "htb",
305 + htb_parse_opt,
306 + htb_print_opt,
307 + htb_print_xstats,
308 + htb_parse_class_opt,
309 + htb_print_opt,
310 +};
311 +
312 +/* for testing of old one */
313 +struct qdisc_util htb2_util = {
314 + NULL,
315 + "htb2",
316 + htb_parse_opt,
317 + htb_print_opt,
318 + htb_print_xstats,
319 + htb_parse_class_opt,
320 + htb_print_opt,
321 +};
322 +#endif
323 /*
324 * q_htb.c HTB.
325 *
326 --- iproute-20041019.orig/doc/Makefile
327 +++ iproute-20041019/doc/Makefile
328 @@ -14,6 +14,7 @@
329 PAGESPERPAGE=2
330
331 HTMLFILES=$(subst .sgml,.html,$(shell echo *.sgml))
332 +TXTFILES=$(subst .sgml,.txt,$(shell echo *.sgml))
333 DVIFILES=$(subst .ps,.dvi,$(PSFILES))
334
335
336 @@ -23,6 +24,8 @@
337
338 html: $(HTMLFILES)
339
340 +txt: $(TXTFILES)
341 +
342 dvi: $(DVIFILES)
343
344 print: $(PSFILES)
345 @@ -42,16 +45,17 @@
346 done
347
348 %.ps: %.dvi
349 - $(DVIPS) $< -o $@.tmp
350 - ./do-psnup $@.tmp $@ $(PAGESIZE) $(PAGESPERPAGE)
351 - rm -f $@.tmp
352 + $(DVIPS) $< -o $@
353
354 %.html: %.sgml
355 $(SGML2HTML) $<
356
357 +%.txt: %.html
358 + lynx -nolist -dump $< > $@
359 +
360 install:
361 install -m 0644 $(shell echo *.tex) $(DESTDIR)$(DOCDIR)
362 install -m 0644 $(shell echo *.sgml) $(DESTDIR)$(DOCDIR)
363
364 clean:
365 - rm -f *.aux *.log *.toc $(PSFILES) $(DVIFILES) *.html
366 + rm -f *.aux *.log *.toc $(PSFILES) $(DVIFILES) *.html $(TXTFILES)
367 --- iproute-20041019.orig/misc/Makefile
368 +++ iproute-20041019/misc/Makefile
369 @@ -1,7 +1,8 @@
370 SSOBJ=ss.o ssfilter.o
371 LNSTATOBJ=lnstat.o lnstat_util.o
372
373 -TARGETS=ss nstat ifstat rtacct arpd lnstat
374 +#TARGETS=ss nstat ifstat rtacct arpd lnstat
375 +TARGETS=ss nstat rtacct lnstat
376
377 include ../Config
378
379 --- iproute-20041019.orig/misc/netbug
380 +++ iproute-20041019/misc/netbug
381 @@ -1,23 +1,16 @@
382 #! /bin/bash
383
384 +set -e
385 +
386 echo -n "Send network configuration summary to [ENTER means kuznet@ms2.inr.ac.ru] "
387 IFS="" read mail || exit 1
388 [ -z "$mail" ] && mail=kuznet@ms2.inr.ac.ru
389
390 +netbug=`mktemp -d -t netbug.XXXXXX` || {echo "$0: Cannot create temporary directory" >&2; exit 1; }
391 +netbugtar=`tempfile -d $netbug --suffix=tar.gz` || {echo "$0: Cannot create temporary file" >&2; exit 1; }
392 +tmppath=$netbug
393 +trap "/bin/rm -rf $netbug $netbugtar" 0 1 2 3 13 15
394
395 -netbug=""
396 -while [ "$netbug" = "" ]; do
397 - netbug=`echo netbug.$$.$RANDOM`
398 - if [ -e /tmp/$netbug ]; then
399 - netbug=""
400 - fi
401 -done
402 -
403 -tmppath=/tmp/$netbug
404 -
405 -trap "rm -rf $tmppath $tmppath.tar.gz" 0 SIGINT
406 -
407 -mkdir $tmppath
408 mkdir $tmppath/net
409
410 cat /proc/slabinfo > $tmppath/slabinfo
411 @@ -44,9 +37,8 @@
412 fi
413
414 cd /tmp
415 -tar c $netbug | gzip -9c > $netbug.tar.gz
416 -
417 -uuencode $netbug.tar.gz $netbug.tar.gz | mail -s $netbug "$mail"
418 +tar c $tmppath | gzip -9c > $netbugtar
419 +uuencode $netbugtar $netbugtar | mail -s $netbug "$mail"
420
421 echo "Sending to <$mail>; subject is $netbug"
422
423 --- iproute-20041019.orig/Makefile
424 +++ iproute-20041019/Makefile
425 @@ -30,7 +30,7 @@
426 LIBNETLINK=../lib/libnetlink.a ../lib/libutil.a
427
428 all: Config
429 - @for i in $(SUBDIRS); \
430 + @set -e; for i in $(SUBDIRS); \
431 do $(MAKE) $(MFLAGS) -C $$i; done
432
433 Config:
434 @@ -45,7 +45,7 @@
435 $(DESTDIR)$(DOCDIR)/examples
436 install -m 0644 $(shell find examples/diffserv -type f -maxdepth 1) \
437 $(DESTDIR)$(DOCDIR)/examples/diffserv
438 - @for i in $(SUBDIRS) doc; do $(MAKE) -C $$i install; done
439 + @set -e; for i in $(SUBDIRS) doc; do $(MAKE) -C $$i install; done
440 install -m 0644 $(shell find etc/iproute2 -type f -maxdepth 1) $(DESTDIR)$(CONFDIR)
441 install -m 0755 -d $(DESTDIR)$(MANDIR)/man8
442 install -m 0644 $(shell find man/man8 -type f -maxdepth 1) $(DESTDIR)$(MANDIR)/man8
443 @@ -53,7 +53,7 @@
444 ln -sf $(MANDIR)/man8/tc-pbfifo.8 $(DESTDIR)$(MANDIR)/man8/tc-pfifo.8
445
446 clean:
447 - @for i in $(SUBDIRS) doc; \
448 + @set -e; for i in $(SUBDIRS) doc; \
449 do $(MAKE) $(MFLAGS) -C $$i clean; done
450
451 clobber: clean
452 --- iproute-20041019.orig/include/linux/pkt_sched.h
453 +++ iproute-20041019/include/linux/pkt_sched.h
454 @@ -1,3 +1,409 @@
455 +#if 0
456 +#ifndef __LINUX_PKT_SCHED_H
457 +#define __LINUX_PKT_SCHED_H
458 +
459 +/* Logical priority bands not depending on specific packet scheduler.
460 + Every scheduler will map them to real traffic classes, if it has
461 + no more precise mechanism to classify packets.
462 +
463 + These numbers have no special meaning, though their coincidence
464 + with obsolete IPv6 values is not occasional :-). New IPv6 drafts
465 + preferred full anarchy inspired by diffserv group.
466 +
467 + Note: TC_PRIO_BESTEFFORT does not mean that it is the most unhappy
468 + class, actually, as rule it will be handled with more care than
469 + filler or even bulk.
470 + */
471 +
472 +#define TC_PRIO_BESTEFFORT 0
473 +#define TC_PRIO_FILLER 1
474 +#define TC_PRIO_BULK 2
475 +#define TC_PRIO_INTERACTIVE_BULK 4
476 +#define TC_PRIO_INTERACTIVE 6
477 +#define TC_PRIO_CONTROL 7
478 +
479 +#define TC_PRIO_MAX 15
480 +
481 +/* Generic queue statistics, available for all the elements.
482 + Particular schedulers may have also their private records.
483 + */
484 +
485 +struct tc_stats
486 +{
487 + __u64 bytes; /* NUmber of enqueues bytes */
488 + __u32 packets; /* Number of enqueued packets */
489 + __u32 drops; /* Packets dropped because of lack of resources */
490 + __u32 overlimits; /* Number of throttle events when this
491 + * flow goes out of allocated bandwidth */
492 + __u32 bps; /* Current flow byte rate */
493 + __u32 pps; /* Current flow packet rate */
494 + __u32 qlen;
495 + __u32 backlog;
496 +#ifdef __KERNEL__
497 + spinlock_t *lock;
498 +#endif
499 +};
500 +
501 +struct tc_estimator
502 +{
503 + char interval;
504 + unsigned char ewma_log;
505 +};
506 +
507 +/* "Handles"
508 + ---------
509 +
510 + All the traffic control objects have 32bit identifiers, or "handles".
511 +
512 + They can be considered as opaque numbers from user API viewpoint,
513 + but actually they always consist of two fields: major and
514 + minor numbers, which are interpreted by kernel specially,
515 + that may be used by applications, though not recommended.
516 +
517 + F.e. qdisc handles always have minor number equal to zero,
518 + classes (or flows) have major equal to parent qdisc major, and
519 + minor uniquely identifying class inside qdisc.
520 +
521 + Macros to manipulate handles:
522 + */
523 +
524 +#define TC_H_MAJ_MASK (0xFFFF0000U)
525 +#define TC_H_MIN_MASK (0x0000FFFFU)
526 +#define TC_H_MAJ(h) ((h)&TC_H_MAJ_MASK)
527 +#define TC_H_MIN(h) ((h)&TC_H_MIN_MASK)
528 +#define TC_H_MAKE(maj,min) (((maj)&TC_H_MAJ_MASK)|((min)&TC_H_MIN_MASK))
529 +
530 +#define TC_H_UNSPEC (0U)
531 +#define TC_H_ROOT (0xFFFFFFFFU)
532 +#define TC_H_INGRESS (0xFFFFFFF1U)
533 +
534 +struct tc_ratespec
535 +{
536 + unsigned char cell_log;
537 + unsigned char __reserved;
538 + unsigned short feature;
539 + short addend;
540 + unsigned short mpu;
541 + __u32 rate;
542 +};
543 +
544 +/* FIFO section */
545 +
546 +struct tc_fifo_qopt
547 +{
548 + __u32 limit; /* Queue length: bytes for bfifo, packets for pfifo */
549 +};
550 +
551 +/* PRIO section */
552 +
553 +#define TCQ_PRIO_BANDS 16
554 +
555 +struct tc_prio_qopt
556 +{
557 + int bands; /* Number of bands */
558 + __u8 priomap[TC_PRIO_MAX+1]; /* Map: logical priority -> PRIO band */
559 +};
560 +
561 +/* CSZ section */
562 +
563 +struct tc_csz_qopt
564 +{
565 + int flows; /* Maximal number of guaranteed flows */
566 + unsigned char R_log; /* Fixed point position for round number */
567 + unsigned char delta_log; /* Log of maximal managed time interval */
568 + __u8 priomap[TC_PRIO_MAX+1]; /* Map: logical priority -> CSZ band */
569 +};
570 +
571 +struct tc_csz_copt
572 +{
573 + struct tc_ratespec slice;
574 + struct tc_ratespec rate;
575 + struct tc_ratespec peakrate;
576 + __u32 limit;
577 + __u32 buffer;
578 + __u32 mtu;
579 +};
580 +
581 +enum
582 +{
583 + TCA_CSZ_UNSPEC,
584 + TCA_CSZ_PARMS,
585 + TCA_CSZ_RTAB,
586 + TCA_CSZ_PTAB,
587 +};
588 +
589 +/* TBF section */
590 +
591 +struct tc_tbf_qopt
592 +{
593 + struct tc_ratespec rate;
594 + struct tc_ratespec peakrate;
595 + __u32 limit;
596 + __u32 buffer;
597 + __u32 mtu;
598 +};
599 +
600 +enum
601 +{
602 + TCA_TBF_UNSPEC,
603 + TCA_TBF_PARMS,
604 + TCA_TBF_RTAB,
605 + TCA_TBF_PTAB,
606 +};
607 +
608 +
609 +/* TEQL section */
610 +
611 +/* TEQL does not require any parameters */
612 +
613 +/* SFQ section */
614 +
615 +struct tc_sfq_qopt
616 +{
617 + unsigned quantum; /* Bytes per round allocated to flow */
618 + int perturb_period; /* Period of hash perturbation */
619 + __u32 limit; /* Maximal packets in queue */
620 + unsigned divisor; /* Hash divisor */
621 + unsigned flows; /* Maximal number of flows */
622 +};
623 +
624 +/*
625 + * NOTE: limit, divisor and flows are hardwired to code at the moment.
626 + *
627 + * limit=flows=128, divisor=1024;
628 + *
629 + * The only reason for this is efficiency, it is possible
630 + * to change these parameters in compile time.
631 + */
632 +
633 +/* RED section */
634 +
635 +enum
636 +{
637 + TCA_RED_UNSPEC,
638 + TCA_RED_PARMS,
639 + TCA_RED_STAB,
640 +};
641 +
642 +struct tc_red_qopt
643 +{
644 + __u32 limit; /* HARD maximal queue length (bytes) */
645 + __u32 qth_min; /* Min average length threshold (bytes) */
646 + __u32 qth_max; /* Max average length threshold (bytes) */
647 + unsigned char Wlog; /* log(W) */
648 + unsigned char Plog; /* log(P_max/(qth_max-qth_min)) */
649 + unsigned char Scell_log; /* cell size for idle damping */
650 + unsigned char flags;
651 +#define TC_RED_ECN 1
652 +};
653 +
654 +struct tc_red_xstats
655 +{
656 + __u32 early; /* Early drops */
657 + __u32 pdrop; /* Drops due to queue limits */
658 + __u32 other; /* Drops due to drop() calls */
659 + __u32 marked; /* Marked packets */
660 +};
661 +
662 +/* GRED section */
663 +
664 +#define MAX_DPs 16
665 +
666 +enum
667 +{
668 + TCA_GRED_UNSPEC,
669 + TCA_GRED_PARMS,
670 + TCA_GRED_STAB,
671 + TCA_GRED_DPS,
672 +};
673 +
674 +#define TCA_SET_OFF TCA_GRED_PARMS
675 +struct tc_gred_qopt
676 +{
677 + __u32 limit; /* HARD maximal queue length (bytes)
678 +*/
679 + __u32 qth_min; /* Min average length threshold (bytes)
680 +*/
681 + __u32 qth_max; /* Max average length threshold (bytes)
682 +*/
683 + __u32 DP; /* upto 2^32 DPs */
684 + __u32 backlog;
685 + __u32 qave;
686 + __u32 forced;
687 + __u32 early;
688 + __u32 other;
689 + __u32 pdrop;
690 +
691 + unsigned char Wlog; /* log(W) */
692 + unsigned char Plog; /* log(P_max/(qth_max-qth_min)) */
693 + unsigned char Scell_log; /* cell size for idle damping */
694 + __u8 prio; /* prio of this VQ */
695 + __u32 packets;
696 + __u32 bytesin;
697 +};
698 +/* gred setup */
699 +struct tc_gred_sopt
700 +{
701 + __u32 DPs;
702 + __u32 def_DP;
703 + __u8 grio;
704 +};
705 +
706 +/* HTB section */
707 +#define TC_HTB_NUMPRIO 8
708 +#define TC_HTB_MAXDEPTH 8
709 +#define TC_HTB_PROTOVER 3 /* the same as HTB and TC's major */
710 +
711 +struct tc_htb_opt
712 +{
713 + struct tc_ratespec rate;
714 + struct tc_ratespec ceil;
715 + __u32 buffer;
716 + __u32 cbuffer;
717 + __u32 quantum;
718 + __u32 level; /* out only */
719 + __u32 prio;
720 +};
721 +struct tc_htb_glob
722 +{
723 + __u32 version; /* to match HTB/TC */
724 + __u32 rate2quantum; /* bps->quantum divisor */
725 + __u32 defcls; /* default class number */
726 + __u32 debug; /* debug flags */
727 +
728 + /* stats */
729 + __u32 direct_pkts; /* count of non shapped packets */
730 +};
731 +enum
732 +{
733 + TCA_HTB_UNSPEC,
734 + TCA_HTB_PARMS,
735 + TCA_HTB_INIT,
736 + TCA_HTB_CTAB,
737 + TCA_HTB_RTAB,
738 +};
739 +struct tc_htb_xstats
740 +{
741 + __u32 lends;
742 + __u32 borrows;
743 + __u32 giants; /* too big packets (rate will not be accurate) */
744 + __u32 tokens;
745 + __u32 ctokens;
746 +};
747 +
748 +/* CBQ section */
749 +
750 +#define TC_CBQ_MAXPRIO 8
751 +#define TC_CBQ_MAXLEVEL 8
752 +#define TC_CBQ_DEF_EWMA 5
753 +
754 +struct tc_cbq_lssopt
755 +{
756 + unsigned char change;
757 + unsigned char flags;
758 +#define TCF_CBQ_LSS_BOUNDED 1
759 +#define TCF_CBQ_LSS_ISOLATED 2
760 + unsigned char ewma_log;
761 + unsigned char level;
762 +#define TCF_CBQ_LSS_FLAGS 1
763 +#define TCF_CBQ_LSS_EWMA 2
764 +#define TCF_CBQ_LSS_MAXIDLE 4
765 +#define TCF_CBQ_LSS_MINIDLE 8
766 +#define TCF_CBQ_LSS_OFFTIME 0x10
767 +#define TCF_CBQ_LSS_AVPKT 0x20
768 + __u32 maxidle;
769 + __u32 minidle;
770 + __u32 offtime;
771 + __u32 avpkt;
772 +};
773 +
774 +struct tc_cbq_wrropt
775 +{
776 + unsigned char flags;
777 + unsigned char priority;
778 + unsigned char cpriority;
779 + unsigned char __reserved;
780 + __u32 allot;
781 + __u32 weight;
782 +};
783 +
784 +struct tc_cbq_ovl
785 +{
786 + unsigned char strategy;
787 +#define TC_CBQ_OVL_CLASSIC 0
788 +#define TC_CBQ_OVL_DELAY 1
789 +#define TC_CBQ_OVL_LOWPRIO 2
790 +#define TC_CBQ_OVL_DROP 3
791 +#define TC_CBQ_OVL_RCLASSIC 4
792 + unsigned char priority2;
793 + __u32 penalty;
794 +};
795 +
796 +struct tc_cbq_police
797 +{
798 + unsigned char police;
799 + unsigned char __res1;
800 + unsigned short __res2;
801 +};
802 +
803 +struct tc_cbq_fopt
804 +{
805 + __u32 split;
806 + __u32 defmap;
807 + __u32 defchange;
808 +};
809 +
810 +struct tc_cbq_xstats
811 +{
812 + __u32 borrows;
813 + __u32 overactions;
814 + __s32 avgidle;
815 + __s32 undertime;
816 +};
817 +
818 +enum
819 +{
820 + TCA_CBQ_UNSPEC,
821 + TCA_CBQ_LSSOPT,
822 + TCA_CBQ_WRROPT,
823 + TCA_CBQ_FOPT,
824 + TCA_CBQ_OVL_STRATEGY,
825 + TCA_CBQ_RATE,
826 + TCA_CBQ_RTAB,
827 + TCA_CBQ_POLICE,
828 +};
829 +
830 +#define TCA_CBQ_MAX TCA_CBQ_POLICE
831 +
832 +/* dsmark section */
833 +
834 +enum {
835 + TCA_DSMARK_UNSPEC,
836 + TCA_DSMARK_INDICES,
837 + TCA_DSMARK_DEFAULT_INDEX,
838 + TCA_DSMARK_SET_TC_INDEX,
839 + TCA_DSMARK_MASK,
840 + TCA_DSMARK_VALUE
841 +};
842 +
843 +#define TCA_DSMARK_MAX TCA_DSMARK_VALUE
844 +
845 +/* ATM section */
846 +
847 +enum {
848 + TCA_ATM_UNSPEC,
849 + TCA_ATM_FD, /* file/socket descriptor */
850 + TCA_ATM_PTR, /* pointer to descriptor - later */
851 + TCA_ATM_HDR, /* LL header */
852 + TCA_ATM_EXCESS, /* excess traffic class (0 for CLP) */
853 + TCA_ATM_ADDR, /* PVC address (for output only) */
854 + TCA_ATM_STATE /* VC state (ATM_VS_*; for output only) */
855 +};
856 +
857 +#define TCA_ATM_MAX TCA_ATM_STATE
858 +
859 +#endif
860 +#endif
861 #ifndef __LINUX_PKT_SCHED_H
862 #define __LINUX_PKT_SCHED_H
863
864 --- iproute-20010824/ip/iproute.c
865 +++ iproute-20010824/ip/iproute.c
866 @@ -57,7 +57,7 @@
867 fprintf(stderr, "OPTIONS := FLAGS [ mtu NUMBER ] [ advmss NUMBER ]\n");
868 fprintf(stderr, " [ rtt NUMBER ] [ rttvar NUMBER ]\n");
869 fprintf(stderr, " [ window NUMBER] [ cwnd NUMBER ] [ ssthresh REALM ]\n");
870 - fprintf(stderr, " [ realms REALM ]\n");
871 + fprintf(stderr, " [ realms REALM ] [ hoplimit NUMBER ] [ initcwnd NUMBER ]\n");
872 fprintf(stderr, "TYPE := [ unicast | local | broadcast | multicast | throw |\n");
873 fprintf(stderr, " unreachable | prohibit | blackhole | nat ]\n");
874 fprintf(stderr, "TABLE_ID := [ local | main | default | all | NUMBER ]\n");
875 @@ -481,6 +481,8 @@
876 "cwnd",
877 "advmss",
878 "reordering",
879 + "hoplimit",
880 + "initcwnd",
881 };
882 static int hz;
883 if (mxrta[i] == NULL)
884 @@ -750,6 +752,30 @@
885 invarg("\"reordering\" value is invalid\n", *argv);
886 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_REORDERING, reord);
887 #endif
888 +#ifdef RTAX_HOPLIMIT
889 + } else if (strcmp(*argv, "hoplimit") == 0) {
890 + unsigned hoplim;
891 + NEXT_ARG();
892 + if (strcmp(*argv, "lock") == 0) {
893 + mxlock |= (1<<RTAX_HOPLIMIT);
894 + NEXT_ARG();
895 + }
896 + if (get_unsigned(&hoplim, *argv, 0))
897 + invarg("\"hoplimit\" value is invalid\n", *argv);
898 + rta_addattr32(mxrta, sizeof(mxbuf), RTAX_HOPLIMIT, hoplim);
899 +#endif
900 +#ifdef RTAX_INITCWND
901 + } else if (strcmp(*argv, "initcwnd") == 0) {
902 + unsigned initcwnd;
903 + NEXT_ARG();
904 + if (strcmp(*argv, "lock") == 0) {
905 + mxlock |= (1<<RTAX_HOPLIMIT);
906 + NEXT_ARG();
907 + }
908 + if (get_unsigned(&initcwnd, *argv, 0))
909 + invarg("\"initcwnd\" value is invalid\n", *argv);
910 + rta_addattr32(mxrta, sizeof(mxbuf), RTAX_INITCWND, initcwnd);
911 +#endif
912 } else if (strcmp(*argv, "rtt") == 0) {
913 unsigned rtt;
914 NEXT_ARG();
915 --- iproute-20010824.orig/doc/ip-cref.tex
916 +++ iproute-20010824/doc/ip-cref.tex
917 @@ -1324,2 +1324,15 @@
918
919 +\item \verb|hoplimit NUMBER|
920 +
921 +--- [2.5.74+ only] Hop limit on the path to this destination. If it is not
922 + given, Linux uses the value selected with \verb|sysctl| variable
923 + \verb|net/ipv4/ip_default_ttl|.
924 +
925 +\item \verb|initcwnd NUMBER|
926 +
927 +--- [2.5.70+ only] Initial congestion window size when establishing
928 + connections to this destination. This value is multiplied with the
929 + MSS (``Maximal Segment Size'') for the connection to get the actual
930 + window size. If it is not given (or set to zero), Linux uses the
931 + values specified in~\cite{RFC2414}.
932
933 @@ -2653,2 +2666,5 @@
934
935 +\bibitem{RFC2414} M.~Allman, S.~Floyd, C.~Partridge.
936 +``Increasing TCP's Initial Window'', RFC-2414.
937 +
938 \end{thebibliography}
939 #! /bin/sh -e
940 ##
941 ## All lines beginning with `## DP:' are a description of the patch.
942 ## DP: add references to lartc
943 ## DP: also drop bogus reference to tc-filters
944
945 [ -f debian/patches/00patch-opts ] && . debian/patches/00patch-opts
946 patch_opts="${patch_opts:--f --no-backup-if-mismatch}"
947
948 if [ $# -ne 1 ]; then
949 echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
950 exit 1
951 fi
952 case "$1" in
953 -patch) patch $patch_opts -p1 < $0;;
954 -unpatch) patch $patch_opts -p1 -R < $0;;
955 *)
956 echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
957 exit 1;;
958 esac
959
960 exit 0
961 @DPATCH@
962 diff -Nur old/man/man8/ip.8 new/man/man8/ip.8
963 --- old/man/man8/ip.8 2005-01-05 22:40:29.000000000 +0000
964 +++ new/man/man8/ip.8 2005-01-05 22:47:03.000000000 +0000
965 @@ -1803,6 +1803,8 @@
966 .RB "IP Command reference " ip-cref.ps
967 .br
968 .RB "IP tunnels " ip-cref.ps
969 +.br
970 +.RB http://lartc.org/
971
972 .SH AUTHOR
973
974 diff -Nur old/man/man8/tc.8 new/man/man8/tc.8
975 --- old/man/man8/tc.8 2004-10-19 20:49:02.000000000 +0000
976 +++ new/man/man8/tc.8 2005-01-05 22:46:15.000000000 +0000
977 @@ -341,7 +341,7 @@
978 .BR tc-pfifo (8),
979 .BR tc-bfifo (8),
980 .BR tc-pfifo_fast (8),
981 -.BR tc-filters (8)
982 +.BR http://lartc.org/
983
984 .SH AUTHOR
985 Manpage maintained by bert hubert (ahu@ds9a.nl)
986 #! /bin/sh -e
987 ##
988 ## All lines beginning with `## DP:' are a description of the patch.
989 ## DP: fixes typo
990
991 [ -f debian/patches/00patch-opts ] && . debian/patches/00patch-opts
992 patch_opts="${patch_opts:--f --no-backup-if-mismatch}"
993
994 if [ $# -ne 1 ]; then
995 echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
996 exit 1
997 fi
998 case "$1" in
999 -patch) patch $patch_opts -p1 < $0;;
1000 -unpatch) patch $patch_opts -p1 -R < $0;;
1001 *)
1002 echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
1003 exit 1;;
1004 esac
1005
1006 exit 0
1007 @DPATCH@
1008 --- iproute/ip/iptunnel.c.orig 2003-07-10 11:47:06.000000000 +1000
1009 +++ iproute/ip/iptunnel.c 2003-07-10 11:47:11.000000000 +1000
1010 @@ -221,7 +221,7 @@
1011 NEXT_ARG();
1012 p->i_flags |= GRE_KEY;
1013 if (strchr(*argv, '.'))
1014 - p->o_key = get_addr32(*argv);
1015 + p->i_key = get_addr32(*argv);
1016 else {
1017 if (get_unsigned(&uval, *argv, 0)<0) {
1018 fprintf(stderr, "invalid value of \"ikey\"\n");
1019 #! /bin/sh -e
1020 ##
1021 ## All lines beginning with `## DP:' are a description of the patch.
1022 ## DP: add the wrr qdisc scheduler, see #198414
1023
1024 [ -f debian/patches/00patch-opts ] && . debian/patches/00patch-opts
1025 patch_opts="${patch_opts:--f --no-backup-if-mismatch}"
1026
1027 if [ $# -ne 1 ]; then
1028 echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
1029 exit 1
1030 fi
1031 case "$1" in
1032 -patch) patch $patch_opts -p1 < $0;;
1033 -unpatch) patch $patch_opts -p1 -R < $0;;
1034 *)
1035 echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
1036 exit 1;;
1037 esac
1038
1039 exit 0
1040 @DPATCH@
1041 diff -urN iproute-20041019.orig/include/linux/pkt_sched.h iproute-20041019/include/linux/pkt_sched.h
1042 --- iproute-20041019.orig/include/linux/pkt_sched.h 2005-01-06 00:42:42.000000000 +0100
1043 +++ iproute-20041019/include/linux/pkt_sched.h 2005-01-06 00:38:06.000000000 +0100
1044 @@ -837,4 +837,116 @@
1045
1046 #define NETEM_DIST_SCALE 8192
1047
1048 +/* WRR section */
1049 +
1050 +/* Other includes */
1051 +#include <linux/if_ether.h>
1052 +
1053 +// A sub weight and of a class
1054 +// All numbers are represented as parts of (2^64-1).
1055 +struct tc_wrr_class_weight {
1056 + __u64 val; // Current value (0 is not valid)
1057 + __u64 decr; // Value pr bytes (2^64-1 is not valid)
1058 + __u64 incr; // Value pr seconds (2^64-1 is not valid)
1059 + __u64 min; // Minimal value (0 is not valid)
1060 + __u64 max; // Minimal value (0 is not valid)
1061 +
1062 +// The time where the above information was correct:
1063 + time_t tim;
1064 +};
1065 +
1066 +// Packet send when modifying a class:
1067 +struct tc_wrr_class_modf {
1068 + // Not-valid values are ignored.
1069 + struct tc_wrr_class_weight weight1;
1070 + struct tc_wrr_class_weight weight2;
1071 +};
1072 +
1073 +// Packet returned when quering a class:
1074 +struct tc_wrr_class_stats {
1075 + char used; // If this is false the information below is invalid
1076 +
1077 + struct tc_wrr_class_modf class_modf;
1078 +
1079 + unsigned char addr[ETH_ALEN];
1080 + char usemac; // True if addr is a MAC address, else it is an IP address
1081 + // (this value is only for convience, it is always the same
1082 + // value as in the qdisc)
1083 + int heappos; // Current heap position or 0 if not in heap
1084 + __u64 penal_ls; // Penalty value in heap (ls)
1085 + __u64 penal_ms; // Penalty value in heap (ms)
1086 +};
1087 +
1088 +// Qdisc-wide penalty information (boolean values - 2 not valid)
1089 +struct tc_wrr_qdisc_weight {
1090 + char weight_mode; // 0=No automatic change to weight
1091 + // 1=Decrease normally
1092 + // 2=Also multiply with number of machines
1093 + // 3=Instead multiply with priority divided
1094 + // with priority of the other.
1095 + // -1=no change
1096 +};
1097 +
1098 +// Packet send when modifing a qdisc:
1099 +struct tc_wrr_qdisc_modf {
1100 + // Not-valid values are ignored:
1101 + struct tc_wrr_qdisc_weight weight1;
1102 + struct tc_wrr_qdisc_weight weight2;
1103 +};
1104 +
1105 +// Packet send when creating a qdisc:
1106 +struct tc_wrr_qdisc_crt {
1107 + struct tc_wrr_qdisc_modf qdisc_modf;
1108 +
1109 + char srcaddr; // 1=lookup source, 0=lookup destination
1110 + char usemac; // 1=Classify on MAC addresses, 0=classify on IP
1111 + char usemasq; // 1=Classify based on masqgrading - only valid
1112 + // if usemac is zero
1113 + int bands_max; // Maximal number of bands (i.e.: classes)
1114 + int proxy_maxconn;// If differnt from 0 then we support proxy remapping
1115 + // of packets. And this is the number of maximal
1116 + // concurrent proxy connections.
1117 +};
1118 +
1119 +// Packet returned when quering a qdisc:
1120 +struct tc_wrr_qdisc_stats {
1121 + struct tc_wrr_qdisc_crt qdisc_crt;
1122 + int proxy_curconn;
1123 + int nodes_in_heap; // Current number of bands wanting to send something
1124 + int bands_cur; // Current number of bands used (i.e.: MAC/IP addresses seen)
1125 + int bands_reused; // Number of times this band has been reused.
1126 + int packets_requed; // Number of times packets have been requeued.
1127 + __u64 priosum; // Sum of priorities in heap where 1 is 2^32
1128 +};
1129 +
1130 +struct tc_wrr_qdisc_modf_std {
1131 + // This indicates which of the tc_wrr_qdisc_modf structers this is:
1132 + char proxy; // 0=This struct
1133 +
1134 + // Should we also change a class?
1135 + char change_class;
1136 +
1137 + // Only valid if change_class is false
1138 + struct tc_wrr_qdisc_modf qdisc_modf;
1139 +
1140 + // Only valid if change_class is true:
1141 + unsigned char addr[ETH_ALEN]; // Class to change (non-used bytes should be 0)
1142 + struct tc_wrr_class_modf class_modf; // The change
1143 +};
1144 +
1145 +// Used for proxyrempping:
1146 +struct tc_wrr_qdisc_modf_proxy {
1147 + // This indicates which of the tc_wrr_qdisc_modf structers this is:
1148 + char proxy; // 1=This struct
1149 +
1150 + // This is 1 if the proxyremap information should be reset
1151 + char reset;
1152 +
1153 + // changec is the number of elements in changes.
1154 + int changec;
1155 +
1156 + // This is an array of type ProxyRemapBlock:
1157 + long changes[0];
1158 +};
1159 +
1160 #endif
1161 diff -urN iproute-20041019.orig/tc/Makefile iproute-20041019/tc/Makefile
1162 --- iproute-20041019.orig/tc/Makefile 2004-10-19 22:49:02.000000000 +0200
1163 +++ iproute-20041019/tc/Makefile 2005-01-06 00:33:47.000000000 +0100
1164 @@ -10,6 +10,7 @@
1165 TCMODULES += q_prio.o
1166 TCMODULES += q_tbf.o
1167 TCMODULES += q_cbq.o
1168 +TCMODULES += q_wrr.o
1169 TCMODULES += f_rsvp.o
1170 TCMODULES += f_u32.o
1171 TCMODULES += f_route.o
1172 diff -urN iproute-20041019.orig/tc/q_wrr.c iproute-20041019/tc/q_wrr.c
1173 --- iproute-20041019.orig/tc/q_wrr.c 1970-01-01 01:00:00.000000000 +0100
1174 +++ iproute-20041019/tc/q_wrr.c 2005-01-06 00:34:06.000000000 +0100
1175 @@ -0,0 +1,322 @@
1176 +#include <stdio.h>
1177 +#include <stdlib.h>
1178 +#include <unistd.h>
1179 +#include <syslog.h>
1180 +#include <fcntl.h>
1181 +#include <sys/socket.h>
1182 +#include <netinet/in.h>
1183 +#include <arpa/inet.h>
1184 +#include <string.h>
1185 +#include <math.h>
1186 +
1187 +#include "utils.h"
1188 +#include "tc_util.h"
1189 +
1190 +#define usage() return(-1)
1191 +
1192 +// Returns -1 on error
1193 +static int wrr_parse_qdisc_weight(int argc, char** argv,
1194 + struct tc_wrr_qdisc_modf* opt) {
1195 + int i;
1196 +
1197 + opt->weight1.weight_mode=-1;
1198 + opt->weight2.weight_mode=-1;
1199 +
1200 + for(i=0; i<argc; i++) {
1201 + if(!memcmp(argv[i],"wmode1=",7)) {
1202 + opt->weight1.weight_mode=atoi(argv[i]+7);
1203 + } else if(!memcmp(argv[i],"wmode2=",7)) {
1204 + opt->weight2.weight_mode=atoi(argv[i]+7);
1205 + } else {
1206 + printf("Usage: ... [wmode1=0|1|2|3] [wmode2=0|1|2|3]\n");
1207 + return -1;
1208 + }
1209 + }
1210 + return 0;
1211 +}
1212 +
1213 +static int wrr_parse_class_modf(int argc, char** argv,
1214 + struct tc_wrr_class_modf* modf) {
1215 + int i;
1216 +
1217 + if(argc<1) {
1218 + fprintf(stderr, "Usage: ... [weight1=val] [decr1=val] [incr1=val] [min1=val] [max1=val] [val2=val] ...\n");
1219 + fprintf(stderr, " The values can be floating point like 0.42 or divisions like 42/100\n");
1220 + return -1;
1221 + }
1222 +
1223 + // Set meaningless values:
1224 + modf->weight1.val=0;
1225 + modf->weight1.decr=(__u64)-1;
1226 + modf->weight1.incr=(__u64)-1;
1227 + modf->weight1.min=0;
1228 + modf->weight1.max=0;
1229 + modf->weight2.val=0;
1230 + modf->weight2.decr=(__u64)-1;
1231 + modf->weight2.incr=(__u64)-1;
1232 + modf->weight2.min=0;
1233 + modf->weight2.max=0;
1234 +
1235 + // And read values:
1236 + for(i=0; i<argc; i++) {
1237 + char arg[80];
1238 + char* name,*value1=0,*value2=0;
1239 + long double f_val1,f_val2=1,value;
1240 + if(strlen(argv[i])>=sizeof(arg)) {
1241 + fprintf(stderr,"Argument too long: %s\n",argv[i]);
1242 + return -1;
1243 + }
1244 + strcpy(arg,argv[i]);
1245 +
1246 + name=strtok(arg,"=");
1247 + if(name) value1=strtok(0,"/");
1248 + if(value1) value2=strtok(0,"");
1249 +
1250 + if(!value1) {
1251 + fprintf(stderr,"No = found in argument: %s\n",argv[i]);
1252 + return -1;
1253 + }
1254 +
1255 + f_val1=atof(value1);
1256 + if(value2) f_val2=atof(value2);
1257 +
1258 + if(f_val2==0) {
1259 + fprintf(stderr,"Division by 0\n");
1260 + return -1;
1261 + }
1262 +
1263 + value=f_val1/f_val2;
1264 + if(value>1) value=1;
1265 + if(value<0) value=0;
1266 + value*=((__u64)-1);
1267 +
1268 + // And find the value set
1269 + if(!strcmp(name,"weight1")) modf->weight1.val=value;
1270 + else if(!strcmp(name,"decr1")) modf->weight1.decr=value;
1271 + else if(!strcmp(name,"incr1")) modf->weight1.incr=value;
1272 + else if(!strcmp(name,"min1")) modf->weight1.min=value;
1273 + else if(!strcmp(name,"max1")) modf->weight1.max=value;
1274 + else if(!strcmp(name,"weight2")) modf->weight2.val=value;
1275 + else if(!strcmp(name,"decr2")) modf->weight2.decr=value;
1276 + else if(!strcmp(name,"incr2")) modf->weight2.incr=value;
1277 + else if(!strcmp(name,"min2")) modf->weight2.min=value;
1278 + else if(!strcmp(name,"max2")) modf->weight2.max=value;
1279 + else {
1280 + fprintf(stderr,"illegal value: %s\n",name);
1281 + return -1;
1282 + }
1283 + }
1284 +
1285 + return 0;
1286 +}
1287 +
1288 +static int wrr_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
1289 +{
1290 + if(n->nlmsg_flags & NLM_F_CREATE) {
1291 + // This is a create request:
1292 + struct tc_wrr_qdisc_crt opt;
1293 +
1294 + int sour,dest,ip,mac,masq;
1295 +
1296 + if(argc<4) {
1297 + fprintf(stderr, "Usage: ... wrr sour|dest ip|masq|mac maxclasses proxymaxcon [penalty-setup]\n");
1298 + return -1;
1299 + }
1300 +
1301 + // Read sour/dest:
1302 + memset(&opt,0,sizeof(opt));
1303 + sour=!strcmp(argv[0],"sour");
1304 + dest=!strcmp(argv[0],"dest");
1305 +
1306 + if(!sour && !dest) {
1307 + fprintf(stderr,"sour or dest must be specified\n");
1308 + return -1;
1309 + }
1310 +
1311 + // Read ip/mac
1312 + ip=!strcmp(argv[1],"ip");
1313 + mac=!strcmp(argv[1],"mac");
1314 + masq=!strcmp(argv[1],"masq");
1315 +
1316 + if(!ip && !mac && !masq) {
1317 + fprintf(stderr,"ip, masq or mac must be specified\n");
1318 + return -1;
1319 + }
1320 +
1321 + opt.srcaddr=sour;
1322 + opt.usemac=mac;
1323 + opt.usemasq=masq;
1324 + opt.bands_max=atoi(argv[2]);
1325 +
1326 + opt.proxy_maxconn=atoi(argv[3]);
1327 +
1328 + // Read weights:
1329 + if(wrr_parse_qdisc_weight(argc-4,argv+4,&opt.qdisc_modf)<0) return -1;
1330 + if(opt.qdisc_modf.weight1.weight_mode==-1) opt.qdisc_modf.weight1.weight_mode=0;
1331 + if(opt.qdisc_modf.weight2.weight_mode==-1) opt.qdisc_modf.weight2.weight_mode=0;
1332 +
1333 + addattr_l(n, 1024, TCA_OPTIONS, &opt, sizeof(opt));
1334 + } else {
1335 + struct tc_wrr_qdisc_modf_std opt;
1336 + char qdisc,class;
1337 +
1338 + // This is a modify request:
1339 + if(argc<1) {
1340 + fprintf(stderr,"... qdisc ... or ... class ...\n");
1341 + return -1;
1342 + }
1343 +
1344 + qdisc=!strcmp(argv[0],"qdisc");
1345 + class=!strcmp(argv[0],"class");
1346 +
1347 + if(!qdisc && !class) {
1348 + fprintf(stderr,"qdisc or class must be specified\n");
1349 + return -1;
1350 + }
1351 +
1352 + argc--;
1353 + argv++;
1354 +
1355 + opt.proxy=0;
1356 +
1357 + if(qdisc) {
1358 + opt.change_class=0;
1359 + if(wrr_parse_qdisc_weight(argc, argv, &opt.qdisc_modf)<0) return -1;
1360 + } else {
1361 + int a0,a1,a2,a3,a4=0,a5=0;
1362 +
1363 + opt.change_class=1;
1364 +
1365 + if(argc<1) {
1366 + fprintf(stderr,"... <mac>|<ip>|<masq> ...\n");
1367 + return -1;
1368 + }
1369 + memset(opt.addr,0,sizeof(opt.addr));
1370 +
1371 + if((sscanf(argv[0],"%i.%i.%i.%i",&a0,&a1,&a2,&a3)!=4) &&
1372 + (sscanf(argv[0],"%x:%x:%x:%x:%x:%x",&a0,&a1,&a2,&a3,&a4,&a5)!=6)) {
1373 + fprintf(stderr,"Wrong format of mac or ip address\n");
1374 + return -1;
1375 + }
1376 +
1377 + opt.addr[0]=a0; opt.addr[1]=a1; opt.addr[2]=a2;
1378 + opt.addr[3]=a3; opt.addr[4]=a4; opt.addr[5]=a5;
1379 +
1380 + if(wrr_parse_class_modf(argc-1, argv+1, &opt.class_modf)<0) return -1;
1381 + }
1382 +
1383 + addattr_l(n, 1024, TCA_OPTIONS, &opt, sizeof(opt));
1384 + }
1385 + return 0;
1386 +}
1387 +
1388 +static int wrr_parse_copt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n) {
1389 + struct tc_wrr_class_modf opt;
1390 +
1391 + memset(&opt,0,sizeof(opt));
1392 + if(wrr_parse_class_modf(argc,argv,&opt)<0) return -1;
1393 +
1394 + addattr_l(n, 1024, TCA_OPTIONS, &opt, sizeof(opt));
1395 + return 0;
1396 +}
1397 +
1398 +static int wrr_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
1399 +{
1400 + struct tc_wrr_qdisc_stats *qopt;
1401 +
1402 + if (opt == NULL)
1403 + return 0;
1404 +
1405 + if (RTA_PAYLOAD(opt) < sizeof(*qopt))
1406 + return -1;
1407 + qopt = RTA_DATA(opt);
1408 +
1409 + fprintf(f,"\n (%s/%s) (maxclasses %i) (usedclasses %i) (reused classes %i)\n",
1410 + qopt->qdisc_crt.srcaddr ? "sour" : "dest",
1411 + qopt->qdisc_crt.usemac ? "mac" : (qopt->qdisc_crt.usemasq ? "masq" : "ip"),
1412 + qopt->qdisc_crt.bands_max,
1413 + qopt->bands_cur,
1414 + qopt->bands_reused
1415 + );
1416 +
1417 + if(qopt->qdisc_crt.proxy_maxconn) {
1418 + fprintf(f," (proxy maxcon %i) (proxy curcon %i)\n",
1419 + qopt->qdisc_crt.proxy_maxconn,qopt->proxy_curconn);
1420 + }
1421 +
1422 + fprintf(f," (waiting classes %i) (packets requeued %i) (priosum: %Lg)\n",
1423 + qopt->nodes_in_heap,
1424 + qopt->packets_requed,
1425 + qopt->priosum/((long double)((__u32)-1))
1426 + );
1427 +
1428 + fprintf(f," (wmode1 %i) (wmode2 %i) \n",
1429 + qopt->qdisc_crt.qdisc_modf.weight1.weight_mode,
1430 + qopt->qdisc_crt.qdisc_modf.weight2.weight_mode);
1431 +
1432 + return 0;
1433 +}
1434 +
1435 +static int wrr_print_copt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) {
1436 + struct tc_wrr_class_stats *copt;
1437 + long double d=(__u64)-1;
1438 +
1439 + if (opt == NULL) return 0;
1440 +
1441 + if (RTA_PAYLOAD(opt) < sizeof(*copt))
1442 + return -1;
1443 + copt = RTA_DATA(opt);
1444 +
1445 + if(!copt->used) {
1446 + fprintf(f,"(unused)");
1447 + return 0;
1448 + }
1449 +
1450 + if(copt->usemac) {
1451 + fprintf(f,"\n (address: %.2X:%.2X:%.2X:%.2X:%.2X:%.2X)\n",
1452 + copt->addr[0],copt->addr[1],copt->addr[2],
1453 + copt->addr[3],copt->addr[4],copt->addr[5]);
1454 + } else {
1455 + fprintf(f,"\n (address: %i.%i.%i.%i)\n",copt->addr[0],copt->addr[1],copt->addr[2],copt->addr[3]);
1456 + }
1457 +
1458 + fprintf(f," (total weight: %Lg) (current position: %i) (counters: %u %u : %u %u)\n",
1459 + (copt->class_modf.weight1.val/d)*(copt->class_modf.weight2.val/d),
1460 + copt->heappos,
1461 + (unsigned)(copt->penal_ms>>32),
1462 + (unsigned)(copt->penal_ms & 0xffffffffU),
1463 + (unsigned)(copt->penal_ls>>32),
1464 + (unsigned)(copt->penal_ls & 0xffffffffU)
1465 + );
1466 +
1467 + fprintf(f," Pars 1: (weight %Lg) (decr: %Lg) (incr: %Lg) (min: %Lg) (max: %Lg)\n",
1468 + copt->class_modf.weight1.val/d,
1469 + copt->class_modf.weight1.decr/d,
1470 + copt->class_modf.weight1.incr/d,
1471 + copt->class_modf.weight1.min/d,
1472 + copt->class_modf.weight1.max/d);
1473 +
1474 + fprintf(f," Pars 2: (weight %Lg) (decr: %Lg) (incr: %Lg) (min: %Lg) (max: %Lg)",
1475 + copt->class_modf.weight2.val/d,
1476 + copt->class_modf.weight2.decr/d,
1477 + copt->class_modf.weight2.incr/d,
1478 + copt->class_modf.weight2.min/d,
1479 + copt->class_modf.weight2.max/d);
1480 +
1481 + return 0;
1482 +}
1483 +
1484 +static int wrr_print_xstats(struct qdisc_util *qu, FILE *f, struct rtattr *xstats)
1485 +{
1486 + return 0;
1487 +}
1488 +
1489 +
1490 +struct qdisc_util wrr_qdisc_util = {
1491 + .id = "wrr",
1492 + .parse_qopt = wrr_parse_opt,
1493 + .print_qopt = wrr_print_opt,
1494 + .print_xstats = wrr_print_xstats,
1495 + .parse_copt = wrr_parse_copt,
1496 + .print_copt = wrr_print_copt
1497 +};
Personal OpenWRT clone
This page took 0.110818 seconds and 5 git commands to generate.