From 5c105d9f3fd086aff195d3849dcf847d6b0bd927 Mon Sep 17 00:00:00 2001 From: blogic Date: Fri, 5 Oct 2012 10:12:53 +0000 Subject: branch Attitude Adjustment git-svn-id: svn://svn.openwrt.org/openwrt/branches/attitude_adjustment@33625 3c298f89-4303-0410-b956-a3cf2f4a3e73 --- .../iproute2/patches/000-sync_pkt_sched_h.patch | 121 ++++++ .../patches/001-iproute2-2.6.11_Config.patch | 7 + .../patches/002-iproute2-ipxfrm_no_sctp.patch | 22 ++ package/iproute2/patches/004-darwin_fixes.patch | 59 +++ .../iproute2/patches/006-iproute2-tc_esfq.patch | 219 +++++++++++ package/iproute2/patches/007-no_arpd.patch | 11 + package/iproute2/patches/008-no_netem.patch | 11 + .../iproute2/patches/100-allow_pfifo_fast.patch | 13 + package/iproute2/patches/110-extra-ccopts.patch | 11 + package/iproute2/patches/120-libnetlink-pic.patch | 8 + package/iproute2/patches/200-act_connmark.patch | 84 ++++ package/iproute2/patches/210-add_codel.patch | 437 +++++++++++++++++++++ 12 files changed, 1003 insertions(+) create mode 100644 package/iproute2/patches/000-sync_pkt_sched_h.patch create mode 100644 package/iproute2/patches/001-iproute2-2.6.11_Config.patch create mode 100644 package/iproute2/patches/002-iproute2-ipxfrm_no_sctp.patch create mode 100644 package/iproute2/patches/004-darwin_fixes.patch create mode 100644 package/iproute2/patches/006-iproute2-tc_esfq.patch create mode 100644 package/iproute2/patches/007-no_arpd.patch create mode 100644 package/iproute2/patches/008-no_netem.patch create mode 100644 package/iproute2/patches/100-allow_pfifo_fast.patch create mode 100644 package/iproute2/patches/110-extra-ccopts.patch create mode 100644 package/iproute2/patches/120-libnetlink-pic.patch create mode 100644 package/iproute2/patches/200-act_connmark.patch create mode 100644 package/iproute2/patches/210-add_codel.patch (limited to 'package/iproute2/patches') diff --git a/package/iproute2/patches/000-sync_pkt_sched_h.patch b/package/iproute2/patches/000-sync_pkt_sched_h.patch new file mode 100644 index 000000000..d3315a065 --- /dev/null +++ b/package/iproute2/patches/000-sync_pkt_sched_h.patch @@ -0,0 +1,121 @@ +--- a/include/linux/pkt_sched.h ++++ b/include/linux/pkt_sched.h +@@ -193,6 +193,33 @@ struct tc_sfq_xstats { + __s32 allot; + }; + ++/* ESFQ section */ ++ ++enum ++{ ++ /* traditional */ ++ TCA_SFQ_HASH_CLASSIC, ++ TCA_SFQ_HASH_DST, ++ TCA_SFQ_HASH_SRC, ++ TCA_SFQ_HASH_FWMARK, ++ /* conntrack */ ++ TCA_SFQ_HASH_CTORIGDST, ++ TCA_SFQ_HASH_CTORIGSRC, ++ TCA_SFQ_HASH_CTREPLDST, ++ TCA_SFQ_HASH_CTREPLSRC, ++ TCA_SFQ_HASH_CTNATCHG, ++}; ++ ++struct tc_esfq_qopt ++{ ++ unsigned quantum; /* Bytes per round allocated to flow */ ++ int perturb_period; /* Period of hash perturbation */ ++ __u32 limit; /* Maximal packets in queue */ ++ unsigned divisor; /* Hash divisor */ ++ unsigned flows; /* Maximal number of flows */ ++ unsigned hash_kind; /* Hash function to use for flow identification */ ++}; ++ + /* RED section */ + + enum { +@@ -633,4 +660,84 @@ struct tc_qfq_stats { + __u32 lmax; + }; + ++/* CODEL */ ++ ++enum { ++ TCA_CODEL_UNSPEC, ++ TCA_CODEL_TARGET, ++ TCA_CODEL_LIMIT, ++ TCA_CODEL_INTERVAL, ++ TCA_CODEL_ECN, ++ __TCA_CODEL_MAX ++}; ++ ++#define TCA_CODEL_MAX (__TCA_CODEL_MAX - 1) ++ ++struct tc_codel_xstats { ++ __u32 maxpacket; /* largest packet we've seen so far */ ++ __u32 count; /* how many drops we've done since the last time we ++ * entered dropping state ++ */ ++ __u32 lastcount; /* count at entry to dropping state */ ++ __u32 ldelay; /* in-queue delay seen by most recently dequeued packet */ ++ __s32 drop_next; /* time to drop next packet */ ++ __u32 drop_overlimit; /* number of time max qdisc packet limit was hit */ ++ __u32 ecn_mark; /* number of packets we ECN marked instead of dropped */ ++ __u32 dropping; /* are we in dropping state ? */ ++}; ++ ++/* FQ_CODEL */ ++ ++enum { ++ TCA_FQ_CODEL_UNSPEC, ++ TCA_FQ_CODEL_TARGET, ++ TCA_FQ_CODEL_LIMIT, ++ TCA_FQ_CODEL_INTERVAL, ++ TCA_FQ_CODEL_ECN, ++ TCA_FQ_CODEL_FLOWS, ++ TCA_FQ_CODEL_QUANTUM, ++ __TCA_FQ_CODEL_MAX ++}; ++ ++#define TCA_FQ_CODEL_MAX (__TCA_FQ_CODEL_MAX - 1) ++ ++enum { ++ TCA_FQ_CODEL_XSTATS_QDISC, ++ TCA_FQ_CODEL_XSTATS_CLASS, ++}; ++ ++struct tc_fq_codel_qd_stats { ++ __u32 maxpacket; /* largest packet we've seen so far */ ++ __u32 drop_overlimit; /* number of time max qdisc ++ * packet limit was hit ++ */ ++ __u32 ecn_mark; /* number of packets we ECN marked ++ * instead of being dropped ++ */ ++ __u32 new_flow_count; /* number of time packets ++ * created a 'new flow' ++ */ ++ __u32 new_flows_len; /* count of flows in new list */ ++ __u32 old_flows_len; /* count of flows in old list */ ++}; ++ ++struct tc_fq_codel_cl_stats { ++ __s32 deficit; ++ __u32 ldelay; /* in-queue delay seen by most recently ++ * dequeued packet ++ */ ++ __u32 count; ++ __u32 lastcount; ++ __u32 dropping; ++ __s32 drop_next; ++}; ++ ++struct tc_fq_codel_xstats { ++ __u32 type; ++ union { ++ struct tc_fq_codel_qd_stats qdisc_stats; ++ struct tc_fq_codel_cl_stats class_stats; ++ }; ++}; ++ + #endif diff --git a/package/iproute2/patches/001-iproute2-2.6.11_Config.patch b/package/iproute2/patches/001-iproute2-2.6.11_Config.patch new file mode 100644 index 000000000..ece865299 --- /dev/null +++ b/package/iproute2/patches/001-iproute2-2.6.11_Config.patch @@ -0,0 +1,7 @@ +--- /dev/null ++++ b/Config +@@ -0,0 +1,4 @@ ++# Fixed config to disable ATM support even if present on host system ++TC_CONFIG_ATM:=n ++TC_CONFIG_ACTION_GACT=y ++TC_CONFIG_ACTION_PROB=y diff --git a/package/iproute2/patches/002-iproute2-ipxfrm_no_sctp.patch b/package/iproute2/patches/002-iproute2-ipxfrm_no_sctp.patch new file mode 100644 index 000000000..3b1f4d647 --- /dev/null +++ b/package/iproute2/patches/002-iproute2-ipxfrm_no_sctp.patch @@ -0,0 +1,22 @@ +--- + ip/ipxfrm.c | 2 -- + 1 file changed, 2 deletions(-) + +--- a/ip/ipxfrm.c ++++ b/ip/ipxfrm.c +@@ -468,7 +468,6 @@ void xfrm_selector_print(struct xfrm_sel + switch (sel->proto) { + case IPPROTO_TCP: + case IPPROTO_UDP: +- case IPPROTO_SCTP: + case IPPROTO_DCCP: + default: /* XXX */ + if (sel->sport_mask) +@@ -1263,7 +1262,6 @@ static int xfrm_selector_upspec_parse(st + switch (sel->proto) { + case IPPROTO_TCP: + case IPPROTO_UDP: +- case IPPROTO_SCTP: + case IPPROTO_DCCP: + break; + default: diff --git a/package/iproute2/patches/004-darwin_fixes.patch b/package/iproute2/patches/004-darwin_fixes.patch new file mode 100644 index 000000000..e1a5e9756 --- /dev/null +++ b/package/iproute2/patches/004-darwin_fixes.patch @@ -0,0 +1,59 @@ +--- a/netem/maketable.c ++++ b/netem/maketable.c +@@ -10,7 +10,9 @@ + #include + #include + #include ++#if !defined(__APPLE__) && !defined(__FreeBSD__) + #include ++#endif + #include + #include + #include +--- a/netem/normal.c ++++ b/netem/normal.c +@@ -8,8 +8,12 @@ + #include + #include + ++#if !defined(__APPLE__) && !defined(__FreeBSD__) + #include + #include ++#else ++#define NETEM_DIST_SCALE 8192 ++#endif + + #define TABLESIZE 16384 + #define TABLEFACTOR NETEM_DIST_SCALE +--- a/netem/pareto.c ++++ b/netem/pareto.c +@@ -7,8 +7,12 @@ + #include + #include + ++#if !defined(__APPLE__) && !defined(__FreeBSD__) + #include + #include ++#else ++#define NETEM_DIST_SCALE 8192 ++#endif + + static const double a=3.0; + #define TABLESIZE 16384 +--- a/netem/paretonormal.c ++++ b/netem/paretonormal.c +@@ -15,10 +15,13 @@ + #include + #include + #include ++#if !defined(__APPLE__) && !defined(__FreeBSD__) + #include +- + #include + #include ++#else ++#define NETEM_DIST_SCALE 8192 ++#endif + + #define TABLESIZE 16384 + #define TABLEFACTOR NETEM_DIST_SCALE diff --git a/package/iproute2/patches/006-iproute2-tc_esfq.patch b/package/iproute2/patches/006-iproute2-tc_esfq.patch new file mode 100644 index 000000000..8016dbb96 --- /dev/null +++ b/package/iproute2/patches/006-iproute2-tc_esfq.patch @@ -0,0 +1,219 @@ +--- + include/linux/pkt_sched.h | 59 +++++++++++++ + tc/Makefile | 1 + tc/q_esfq.c | 200 ++++++++++++++++++++++++++++++++++++++++++++++ + 3 files changed, 260 insertions(+) + +--- a/tc/Makefile ++++ b/tc/Makefile +@@ -8,6 +8,7 @@ SHARED_LIBS ?= y + TCMODULES := + TCMODULES += q_fifo.o + TCMODULES += q_sfq.o ++TCMODULES += q_esfq.o + TCMODULES += q_red.o + TCMODULES += q_prio.o + TCMODULES += q_tbf.o +--- /dev/null ++++ b/tc/q_esfq.c +@@ -0,0 +1,200 @@ ++/* ++ * q_esfq.c ESFQ. ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version ++ * 2 of the License, or (at your option) any later version. ++ * ++ * Authors: Alexey Kuznetsov, ++ * ++ * Changes: Alexander Atanasov, ++ * Alexander Clouter, ++ * Corey Hickey, ++ * ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "utils.h" ++#include "tc_util.h" ++ ++static void explain(void) ++{ ++ fprintf(stderr, "Usage: ... esfq [ perturb SECS ] [ quantum BYTES ] [ depth FLOWS ]\n\t[ divisor HASHBITS ] [ limit PKTS ] [ hash HASHTYPE]\n"); ++ fprintf(stderr,"Where: \n"); ++ fprintf(stderr,"HASHTYPE := { classic | src | dst | ctorigdst | ctorigsrc | ctrepldst | ctreplsrc | ctnatchg }\n"); ++} ++ ++#define usage() return(-1) ++ ++static int esfq_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n) ++{ ++ int ok=0; ++ struct tc_esfq_qopt opt; ++ ++ memset(&opt, 0, sizeof(opt)); ++ ++ opt.hash_kind= TCA_SFQ_HASH_CLASSIC; ++ ++ while (argc > 0) { ++ if (strcmp(*argv, "quantum") == 0) { ++ NEXT_ARG(); ++ if (get_size(&opt.quantum, *argv)) { ++ fprintf(stderr, "Illegal \"quantum\"\n"); ++ return -1; ++ } ++ ok++; ++ } else if (strcmp(*argv, "perturb") == 0) { ++ NEXT_ARG(); ++ if (get_integer(&opt.perturb_period, *argv, 0)) { ++ fprintf(stderr, "Illegal \"perturb\"\n"); ++ return -1; ++ } ++ ok++; ++ } else if (strcmp(*argv, "depth") == 0) { ++ NEXT_ARG(); ++ if (get_integer((int *) &opt.flows, *argv, 0)) { ++ fprintf(stderr, "Illegal \"depth\"\n"); ++ return -1; ++ } ++ ok++; ++ } else if (strcmp(*argv, "divisor") == 0) { ++ NEXT_ARG(); ++ if (get_integer((int *) &opt.divisor, *argv, 0)) { ++ fprintf(stderr, "Illegal \"divisor\"\n"); ++ return -1; ++ } ++ if(opt.divisor >= 14) { ++ fprintf(stderr, "Illegal \"divisor\": must be < 14\n"); ++ return -1; ++ } ++ opt.divisor=pow(2,opt.divisor); ++ ok++; ++ } else if (strcmp(*argv, "limit") == 0) { ++ NEXT_ARG(); ++ if (get_integer((int *) &opt.limit, *argv, 0)) { ++ fprintf(stderr, "Illegal \"limit\"\n"); ++ return -1; ++ } ++ ok++; ++ } else if (strcmp(*argv, "hash") == 0) { ++ NEXT_ARG(); ++ if(strcmp(*argv, "classic") == 0) { ++ opt.hash_kind= TCA_SFQ_HASH_CLASSIC; ++ } else ++ if(strcmp(*argv, "dst") == 0) { ++ opt.hash_kind= TCA_SFQ_HASH_DST; ++ } else ++ if(strcmp(*argv, "src") == 0) { ++ opt.hash_kind= TCA_SFQ_HASH_SRC; ++ } else ++ if(strcmp(*argv, "ctorigsrc") == 0) { ++ opt.hash_kind= TCA_SFQ_HASH_CTORIGSRC; ++ } else ++ if(strcmp(*argv, "ctorigdst") == 0) { ++ opt.hash_kind= TCA_SFQ_HASH_CTORIGDST; ++ } else ++ if(strcmp(*argv, "ctreplsrc") == 0) { ++ opt.hash_kind= TCA_SFQ_HASH_CTREPLSRC; ++ } else ++ if(strcmp(*argv, "ctrepldst") == 0) { ++ opt.hash_kind= TCA_SFQ_HASH_CTREPLDST; ++ } else ++ if(strcmp(*argv, "ctnatchg") == 0) { ++ opt.hash_kind= TCA_SFQ_HASH_CTNATCHG; ++ } else { ++ fprintf(stderr, "Illegal \"hash\"\n"); ++ explain(); ++ return -1; ++ } ++ ok++; ++ } else if (strcmp(*argv, "help") == 0) { ++ explain(); ++ return -1; ++ } else { ++ fprintf(stderr, "What is \"%s\"?\n", *argv); ++ explain(); ++ return -1; ++ } ++ argc--; argv++; ++ } ++ ++ if (ok) ++ addattr_l(n, 1024, TCA_OPTIONS, &opt, sizeof(opt)); ++ return 0; ++} ++ ++static int esfq_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) ++{ ++ struct tc_esfq_qopt *qopt; ++ SPRINT_BUF(b1); ++ ++ if (opt == NULL) ++ return 0; ++ ++ if (RTA_PAYLOAD(opt) < sizeof(*qopt)) ++ return -1; ++ qopt = RTA_DATA(opt); ++ fprintf(f, "quantum %s ", sprint_size(qopt->quantum, b1)); ++ if (show_details) { ++ fprintf(f, "limit %up flows %u/%u ", ++ qopt->limit, qopt->flows, qopt->divisor); ++ } ++ if (qopt->perturb_period) ++ fprintf(f, "perturb %dsec ", qopt->perturb_period); ++ ++ fprintf(f,"hash: "); ++ switch(qopt->hash_kind) ++ { ++ case TCA_SFQ_HASH_CLASSIC: ++ fprintf(f,"classic"); ++ break; ++ case TCA_SFQ_HASH_DST: ++ fprintf(f,"dst"); ++ break; ++ case TCA_SFQ_HASH_SRC: ++ fprintf(f,"src"); ++ break; ++ case TCA_SFQ_HASH_CTORIGSRC: ++ fprintf(f,"ctorigsrc"); ++ break; ++ case TCA_SFQ_HASH_CTORIGDST: ++ fprintf(f,"ctorigdst"); ++ break; ++ case TCA_SFQ_HASH_CTREPLSRC: ++ fprintf(f,"ctreplsrc"); ++ break; ++ case TCA_SFQ_HASH_CTREPLDST: ++ fprintf(f,"ctrepldst"); ++ break; ++ case TCA_SFQ_HASH_CTNATCHG: ++ fprintf(f,"ctnatchg"); ++ break; ++ default: ++ fprintf(f,"Unknown"); ++ } ++ return 0; ++} ++ ++static int esfq_print_xstats(struct qdisc_util *qu, FILE *f, struct rtattr *xstats) ++{ ++ return 0; ++} ++ ++ ++struct qdisc_util esfq_qdisc_util = { ++ .id = "esfq", ++ .parse_qopt = esfq_parse_opt, ++ .print_qopt = esfq_print_opt, ++ .print_xstats = esfq_print_xstats, ++}; diff --git a/package/iproute2/patches/007-no_arpd.patch b/package/iproute2/patches/007-no_arpd.patch new file mode 100644 index 000000000..6a7e24ecd --- /dev/null +++ b/package/iproute2/patches/007-no_arpd.patch @@ -0,0 +1,11 @@ +--- a/misc/Makefile ++++ b/misc/Makefile +@@ -1,7 +1,7 @@ + SSOBJ=ss.o ssfilter.o + LNSTATOBJ=lnstat.o lnstat_util.o + +-TARGETS=ss nstat ifstat rtacct arpd lnstat ++TARGETS=ss nstat ifstat rtacct lnstat + + include ../Config + diff --git a/package/iproute2/patches/008-no_netem.patch b/package/iproute2/patches/008-no_netem.patch new file mode 100644 index 000000000..c804b14fc --- /dev/null +++ b/package/iproute2/patches/008-no_netem.patch @@ -0,0 +1,11 @@ +--- a/Makefile ++++ b/Makefile +@@ -33,7 +33,7 @@ CCOPTS = -D_GNU_SOURCE -O2 -Wstrict-prot + CFLAGS = $(CCOPTS) -I../include $(DEFINES) + YACCFLAGS = -d -t -v + +-SUBDIRS=lib ip tc misc netem genl ++SUBDIRS=lib ip tc misc genl + + LIBNETLINK=../lib/libnetlink.a ../lib/libutil.a + LDLIBS += $(LIBNETLINK) diff --git a/package/iproute2/patches/100-allow_pfifo_fast.patch b/package/iproute2/patches/100-allow_pfifo_fast.patch new file mode 100644 index 000000000..b31d4b745 --- /dev/null +++ b/package/iproute2/patches/100-allow_pfifo_fast.patch @@ -0,0 +1,13 @@ +--- + tc/q_fifo.c | 1 + + 1 file changed, 1 insertion(+) + +--- a/tc/q_fifo.c ++++ b/tc/q_fifo.c +@@ -98,5 +98,6 @@ struct qdisc_util pfifo_head_drop_qdisc_ + extern int prio_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt); + struct qdisc_util pfifo_fast_qdisc_util = { + .id = "pfifo_fast", ++ .parse_qopt = fifo_parse_opt, + .print_qopt = prio_print_opt, + }; diff --git a/package/iproute2/patches/110-extra-ccopts.patch b/package/iproute2/patches/110-extra-ccopts.patch new file mode 100644 index 000000000..0bf822f28 --- /dev/null +++ b/package/iproute2/patches/110-extra-ccopts.patch @@ -0,0 +1,11 @@ +--- a/Makefile ++++ b/Makefile +@@ -29,7 +29,7 @@ ADDLIB+=ipx_ntop.o ipx_pton.o + + CC = gcc + HOSTCC = gcc +-CCOPTS = -D_GNU_SOURCE -O2 -Wstrict-prototypes -Wall ++CCOPTS = -D_GNU_SOURCE -O2 -Wstrict-prototypes -Wall $(EXTRA_CCOPTS) + CFLAGS = $(CCOPTS) -I../include $(DEFINES) + YACCFLAGS = -d -t -v + diff --git a/package/iproute2/patches/120-libnetlink-pic.patch b/package/iproute2/patches/120-libnetlink-pic.patch new file mode 100644 index 000000000..c7b78d063 --- /dev/null +++ b/package/iproute2/patches/120-libnetlink-pic.patch @@ -0,0 +1,8 @@ +--- a/lib/Makefile ++++ b/lib/Makefile +@@ -1,4 +1,4 @@ +-CFLAGS += -fPIC ++CFLAGS+=$(FPIC) + + UTILOBJ=utils.o rt_names.o ll_types.o ll_proto.o ll_addr.o inet_proto.o + diff --git a/package/iproute2/patches/200-act_connmark.patch b/package/iproute2/patches/200-act_connmark.patch new file mode 100644 index 000000000..4a48ac3f0 --- /dev/null +++ b/package/iproute2/patches/200-act_connmark.patch @@ -0,0 +1,84 @@ +--- a/tc/Makefile ++++ b/tc/Makefile +@@ -38,6 +38,7 @@ TCMODULES += m_mirred.o + TCMODULES += m_nat.o + TCMODULES += m_pedit.o + TCMODULES += m_skbedit.o ++TCMODULES += m_connmark.o + TCMODULES += m_csum.o + TCMODULES += p_ip.o + TCMODULES += p_icmp.o +--- /dev/null ++++ b/tc/m_connmark.c +@@ -0,0 +1,71 @@ ++/* ++ * m_connmark.c Connection tracking marking import ++ * ++ * Copyright (c) 2011 Felix Fietkau ++ * ++ * This program is free software; you can redistribute it and/or modify it ++ * under the terms and conditions of the GNU General Public License, ++ * version 2, as published by the Free Software Foundation. ++ * ++ * This program is distributed in the hope it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for ++ * more details. ++ * ++ * You should have received a copy of the GNU General Public License along with ++ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple ++ * Place - Suite 330, Boston, MA 02111-1307 USA. ++ */ ++ ++#include ++#include ++#include ++#include ++#include "utils.h" ++#include "tc_util.h" ++ ++static void ++explain(void) ++{ ++ fprintf(stderr, "Usage: ... connmark\n"); ++} ++ ++static void ++usage(void) ++{ ++ explain(); ++ exit(-1); ++} ++ ++static int ++parse_connmark(struct action_util *a, int *argc_p, char ***argv_p, int tca_id, ++ struct nlmsghdr *n) ++{ ++ int argc = *argc_p; ++ char **argv = *argv_p; ++ ++ if (matches(*argv, "connmark") != 0) ++ return -1; ++ ++ NEXT_ARG(); ++ ++ *argc_p = argc; ++ *argv_p = argv; ++ return 0; ++} ++ ++static int print_connmark(struct action_util *au, FILE *f, struct rtattr *arg) ++{ ++ if (arg == NULL) ++ return -1; ++ ++ fprintf(f, " connmark"); ++ ++ return 0; ++} ++ ++struct action_util connmark_action_util = { ++ .id = "connmark", ++ .parse_aopt = parse_connmark, ++ .print_aopt = print_connmark, ++}; diff --git a/package/iproute2/patches/210-add_codel.patch b/package/iproute2/patches/210-add_codel.patch new file mode 100644 index 000000000..a14e276c8 --- /dev/null +++ b/package/iproute2/patches/210-add_codel.patch @@ -0,0 +1,437 @@ +--- a/tc/Makefile ++++ b/tc/Makefile +@@ -49,6 +49,8 @@ TCMODULES += em_cmp.o + TCMODULES += em_u32.o + TCMODULES += em_meta.o + TCMODULES += q_mqprio.o ++TCMODULES += q_codel.o ++TCMODULES += q_fq_codel.o + + TCSO := + ifeq ($(TC_CONFIG_ATM),y) +--- /dev/null ++++ b/tc/q_codel.c +@@ -0,0 +1,188 @@ ++/* ++ * Codel - The Controlled-Delay Active Queue Management algorithm ++ * ++ * Copyright (C) 2011-2012 Kathleen Nichols ++ * Copyright (C) 2011-2012 Van Jacobson ++ * Copyright (C) 2012 Michael D. Taht ++ * Copyright (C) 2012 Eric Dumazet ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions, and the following disclaimer, ++ * without modification. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. The names of the authors may not be used to endorse or promote products ++ * derived from this software without specific prior written permission. ++ * ++ * Alternatively, provided that this notice is retained in full, this ++ * software may be distributed under the terms of the GNU General ++ * Public License ("GPL") version 2, in which case the provisions of the ++ * GPL apply INSTEAD OF those given above. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH ++ * DAMAGE. ++ * ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "utils.h" ++#include "tc_util.h" ++ ++static void explain(void) ++{ ++ fprintf(stderr, "Usage: ... codel [ limit PACKETS ] [ target TIME]\n"); ++ fprintf(stderr, " [ interval TIME ] [ ecn ]\n"); ++} ++ ++static int codel_parse_opt(struct qdisc_util *qu, int argc, char **argv, ++ struct nlmsghdr *n) ++{ ++ unsigned limit = 0; ++ unsigned target = 0; ++ unsigned interval = 0; ++ int ecn = -1; ++ struct rtattr *tail; ++ ++ while (argc > 0) { ++ if (strcmp(*argv, "limit") == 0) { ++ NEXT_ARG(); ++ if (get_unsigned(&limit, *argv, 0)) { ++ fprintf(stderr, "Illegal \"limit\"\n"); ++ return -1; ++ } ++ } else if (strcmp(*argv, "target") == 0) { ++ NEXT_ARG(); ++ if (get_time(&target, *argv)) { ++ fprintf(stderr, "Illegal \"target\"\n"); ++ return -1; ++ } ++ } else if (strcmp(*argv, "interval") == 0) { ++ NEXT_ARG(); ++ if (get_time(&interval, *argv)) { ++ fprintf(stderr, "Illegal \"interval\"\n"); ++ return -1; ++ } ++ } else if (strcmp(*argv, "ecn") == 0) { ++ ecn = 1; ++ } else if (strcmp(*argv, "noecn") == 0) { ++ ecn = 0; ++ } else if (strcmp(*argv, "help") == 0) { ++ explain(); ++ return -1; ++ } else { ++ fprintf(stderr, "What is \"%s\"?\n", *argv); ++ explain(); ++ return -1; ++ } ++ argc--; argv++; ++ } ++ ++ tail = NLMSG_TAIL(n); ++ addattr_l(n, 1024, TCA_OPTIONS, NULL, 0); ++ if (limit) ++ addattr_l(n, 1024, TCA_CODEL_LIMIT, &limit, sizeof(limit)); ++ if (interval) ++ addattr_l(n, 1024, TCA_CODEL_INTERVAL, &interval, sizeof(interval)); ++ if (target) ++ addattr_l(n, 1024, TCA_CODEL_TARGET, &target, sizeof(target)); ++ if (ecn != -1) ++ addattr_l(n, 1024, TCA_CODEL_ECN, &ecn, sizeof(ecn)); ++ tail->rta_len = (void *) NLMSG_TAIL(n) - (void *) tail; ++ return 0; ++} ++ ++static int codel_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) ++{ ++ struct rtattr *tb[TCA_CODEL_MAX + 1]; ++ unsigned limit; ++ unsigned interval; ++ unsigned target; ++ unsigned ecn; ++ SPRINT_BUF(b1); ++ ++ if (opt == NULL) ++ return 0; ++ ++ parse_rtattr_nested(tb, TCA_CODEL_MAX, opt); ++ ++ if (tb[TCA_CODEL_LIMIT] && ++ RTA_PAYLOAD(tb[TCA_CODEL_LIMIT]) >= sizeof(__u32)) { ++ limit = rta_getattr_u32(tb[TCA_CODEL_LIMIT]); ++ fprintf(f, "limit %up ", limit); ++ } ++ if (tb[TCA_CODEL_TARGET] && ++ RTA_PAYLOAD(tb[TCA_CODEL_TARGET]) >= sizeof(__u32)) { ++ target = rta_getattr_u32(tb[TCA_CODEL_TARGET]); ++ fprintf(f, "target %s ", sprint_time(target, b1)); ++ } ++ if (tb[TCA_CODEL_INTERVAL] && ++ RTA_PAYLOAD(tb[TCA_CODEL_INTERVAL]) >= sizeof(__u32)) { ++ interval = rta_getattr_u32(tb[TCA_CODEL_INTERVAL]); ++ fprintf(f, "interval %s ", sprint_time(interval, b1)); ++ } ++ if (tb[TCA_CODEL_ECN] && ++ RTA_PAYLOAD(tb[TCA_CODEL_ECN]) >= sizeof(__u32)) { ++ ecn = rta_getattr_u32(tb[TCA_CODEL_ECN]); ++ if (ecn) ++ fprintf(f, "ecn "); ++ } ++ ++ return 0; ++} ++ ++static int codel_print_xstats(struct qdisc_util *qu, FILE *f, ++ struct rtattr *xstats) ++{ ++ struct tc_codel_xstats *st; ++ SPRINT_BUF(b1); ++ ++ if (xstats == NULL) ++ return 0; ++ ++ if (RTA_PAYLOAD(xstats) < sizeof(*st)) ++ return -1; ++ ++ st = RTA_DATA(xstats); ++ fprintf(f, " count %u lastcount %u ldelay %s", ++ st->count, st->lastcount, sprint_time(st->ldelay, b1)); ++ if (st->dropping) ++ fprintf(f, " dropping"); ++ if (st->drop_next < 0) ++ fprintf(f, " drop_next -%s", sprint_time(-st->drop_next, b1)); ++ else ++ fprintf(f, " drop_next %s", sprint_time(st->drop_next, b1)); ++ fprintf(f, "\n maxpacket %u ecn_mark %u drop_overlimit %u", ++ st->maxpacket, st->ecn_mark, st->drop_overlimit); ++ return 0; ++ ++} ++ ++struct qdisc_util codel_qdisc_util = { ++ .id = "codel", ++ .parse_qopt = codel_parse_opt, ++ .print_qopt = codel_print_opt, ++ .print_xstats = codel_print_xstats, ++}; +--- /dev/null ++++ b/tc/q_fq_codel.c +@@ -0,0 +1,232 @@ ++/* ++ * Fair Queue Codel ++ * ++ * Copyright (C) 2012 Eric Dumazet ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions, and the following disclaimer, ++ * without modification. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. The names of the authors may not be used to endorse or promote products ++ * derived from this software without specific prior written permission. ++ * ++ * Alternatively, provided that this notice is retained in full, this ++ * software may be distributed under the terms of the GNU General ++ * Public License ("GPL") version 2, in which case the provisions of the ++ * GPL apply INSTEAD OF those given above. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH ++ * DAMAGE. ++ * ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "utils.h" ++#include "tc_util.h" ++ ++static void explain(void) ++{ ++ fprintf(stderr, "Usage: ... fq_codel [ limit PACKETS ] [ flows NUMBER ]\n"); ++ fprintf(stderr, " [ target TIME] [ interval TIME ]\n"); ++ fprintf(stderr, " [ quantum BYTES ] [ [no]ecn ]\n"); ++} ++ ++static int fq_codel_parse_opt(struct qdisc_util *qu, int argc, char **argv, ++ struct nlmsghdr *n) ++{ ++ unsigned limit = 0; ++ unsigned flows = 0; ++ unsigned target = 0; ++ unsigned interval = 0; ++ unsigned quantum = 0; ++ int ecn = -1; ++ struct rtattr *tail; ++ ++ while (argc > 0) { ++ if (strcmp(*argv, "limit") == 0) { ++ NEXT_ARG(); ++ if (get_unsigned(&limit, *argv, 0)) { ++ fprintf(stderr, "Illegal \"limit\"\n"); ++ return -1; ++ } ++ } else if (strcmp(*argv, "flows") == 0) { ++ NEXT_ARG(); ++ if (get_unsigned(&flows, *argv, 0)) { ++ fprintf(stderr, "Illegal \"flows\"\n"); ++ return -1; ++ } ++ } else if (strcmp(*argv, "quantum") == 0) { ++ NEXT_ARG(); ++ if (get_unsigned(&quantum, *argv, 0)) { ++ fprintf(stderr, "Illegal \"quantum\"\n"); ++ return -1; ++ } ++ } else if (strcmp(*argv, "target") == 0) { ++ NEXT_ARG(); ++ if (get_time(&target, *argv)) { ++ fprintf(stderr, "Illegal \"target\"\n"); ++ return -1; ++ } ++ } else if (strcmp(*argv, "interval") == 0) { ++ NEXT_ARG(); ++ if (get_time(&interval, *argv)) { ++ fprintf(stderr, "Illegal \"interval\"\n"); ++ return -1; ++ } ++ } else if (strcmp(*argv, "ecn") == 0) { ++ ecn = 1; ++ } else if (strcmp(*argv, "noecn") == 0) { ++ ecn = 0; ++ } else if (strcmp(*argv, "help") == 0) { ++ explain(); ++ return -1; ++ } else { ++ fprintf(stderr, "What is \"%s\"?\n", *argv); ++ explain(); ++ return -1; ++ } ++ argc--; argv++; ++ } ++ ++ tail = NLMSG_TAIL(n); ++ addattr_l(n, 1024, TCA_OPTIONS, NULL, 0); ++ if (limit) ++ addattr_l(n, 1024, TCA_FQ_CODEL_LIMIT, &limit, sizeof(limit)); ++ if (flows) ++ addattr_l(n, 1024, TCA_FQ_CODEL_FLOWS, &flows, sizeof(flows)); ++ if (quantum) ++ addattr_l(n, 1024, TCA_FQ_CODEL_QUANTUM, &quantum, sizeof(quantum)); ++ if (interval) ++ addattr_l(n, 1024, TCA_FQ_CODEL_INTERVAL, &interval, sizeof(interval)); ++ if (target) ++ addattr_l(n, 1024, TCA_FQ_CODEL_TARGET, &target, sizeof(target)); ++ if (ecn != -1) ++ addattr_l(n, 1024, TCA_FQ_CODEL_ECN, &ecn, sizeof(ecn)); ++ tail->rta_len = (void *) NLMSG_TAIL(n) - (void *) tail; ++ return 0; ++} ++ ++static int fq_codel_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) ++{ ++ struct rtattr *tb[TCA_FQ_CODEL_MAX + 1]; ++ unsigned limit; ++ unsigned flows; ++ unsigned interval; ++ unsigned target; ++ unsigned ecn; ++ unsigned quantum; ++ SPRINT_BUF(b1); ++ ++ if (opt == NULL) ++ return 0; ++ ++ parse_rtattr_nested(tb, TCA_FQ_CODEL_MAX, opt); ++ ++ if (tb[TCA_FQ_CODEL_LIMIT] && ++ RTA_PAYLOAD(tb[TCA_FQ_CODEL_LIMIT]) >= sizeof(__u32)) { ++ limit = rta_getattr_u32(tb[TCA_FQ_CODEL_LIMIT]); ++ fprintf(f, "limit %up ", limit); ++ } ++ if (tb[TCA_FQ_CODEL_FLOWS] && ++ RTA_PAYLOAD(tb[TCA_FQ_CODEL_FLOWS]) >= sizeof(__u32)) { ++ flows = rta_getattr_u32(tb[TCA_FQ_CODEL_FLOWS]); ++ fprintf(f, "flows %u ", flows); ++ } ++ if (tb[TCA_FQ_CODEL_QUANTUM] && ++ RTA_PAYLOAD(tb[TCA_FQ_CODEL_QUANTUM]) >= sizeof(__u32)) { ++ quantum = rta_getattr_u32(tb[TCA_FQ_CODEL_QUANTUM]); ++ fprintf(f, "quantum %u ", quantum); ++ } ++ if (tb[TCA_FQ_CODEL_TARGET] && ++ RTA_PAYLOAD(tb[TCA_FQ_CODEL_TARGET]) >= sizeof(__u32)) { ++ target = rta_getattr_u32(tb[TCA_FQ_CODEL_TARGET]); ++ fprintf(f, "target %s ", sprint_time(target, b1)); ++ } ++ if (tb[TCA_FQ_CODEL_INTERVAL] && ++ RTA_PAYLOAD(tb[TCA_FQ_CODEL_INTERVAL]) >= sizeof(__u32)) { ++ interval = rta_getattr_u32(tb[TCA_FQ_CODEL_INTERVAL]); ++ fprintf(f, "interval %s ", sprint_time(interval, b1)); ++ } ++ if (tb[TCA_FQ_CODEL_ECN] && ++ RTA_PAYLOAD(tb[TCA_FQ_CODEL_ECN]) >= sizeof(__u32)) { ++ ecn = rta_getattr_u32(tb[TCA_FQ_CODEL_ECN]); ++ if (ecn) ++ fprintf(f, "ecn "); ++ } ++ ++ return 0; ++} ++ ++static int fq_codel_print_xstats(struct qdisc_util *qu, FILE *f, ++ struct rtattr *xstats) ++{ ++ struct tc_fq_codel_xstats *st; ++ SPRINT_BUF(b1); ++ ++ if (xstats == NULL) ++ return 0; ++ ++ if (RTA_PAYLOAD(xstats) < sizeof(*st)) ++ return -1; ++ ++ st = RTA_DATA(xstats); ++ if (st->type == TCA_FQ_CODEL_XSTATS_QDISC) { ++ fprintf(f, " maxpacket %u drop_overlimit %u new_flow_count %u ecn_mark %u", ++ st->qdisc_stats.maxpacket, ++ st->qdisc_stats.drop_overlimit, ++ st->qdisc_stats.new_flow_count, ++ st->qdisc_stats.ecn_mark); ++ fprintf(f, "\n new_flows_len %u old_flows_len %u", ++ st->qdisc_stats.new_flows_len, ++ st->qdisc_stats.old_flows_len); ++ } ++ if (st->type == TCA_FQ_CODEL_XSTATS_CLASS) { ++ fprintf(f, " deficit %d count %u lastcount %u ldelay %s", ++ st->class_stats.deficit, ++ st->class_stats.count, ++ st->class_stats.lastcount, ++ sprint_time(st->class_stats.ldelay, b1)); ++ if (st->class_stats.dropping) { ++ fprintf(f, " dropping"); ++ if (st->class_stats.drop_next < 0) ++ fprintf(f, " drop_next -%s", ++ sprint_time(-st->class_stats.drop_next, b1)); ++ else ++ fprintf(f, " drop_next %s", ++ sprint_time(st->class_stats.drop_next, b1)); ++ } ++ } ++ return 0; ++ ++} ++ ++struct qdisc_util fq_codel_qdisc_util = { ++ .id = "fq_codel", ++ .parse_qopt = fq_codel_parse_opt, ++ .print_qopt = fq_codel_print_opt, ++ .print_xstats = fq_codel_print_xstats, ++}; -- cgit v1.2.3