d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ALTQ FAIRQ discipline import from DragonFLY

Browse Source 
Differential Revision:  https://reviews.freebsd.org/D2847
Reviewed by:    glebius, wblock(manpage)
Approved by:    gnn(mentor)
Obtained from:  pfSense
Sponsored by:   Netgate
This commit is contained in:
eri 2015-06-24 19:16:41 +00:00
parent 66af80ae2d
commit 70cda65ad9
16 changed files with 1445 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
sbin/pfctl/parse.y
View File

@ -48,6 +48,7 @@ __FBSDID("$FreeBSD$");
#include <net/altq/altq_cbq.h>
#include <net/altq/altq_priq.h>
#include <net/altq/altq_hfsc.h>
#include <net/altq/altq_fairq.h>
#include <stdio.h>
#include <unistd.h>
@ -300,6 +301,7 @@ struct pool_opts {
struct node_hfsc_opts hfsc_opts;
struct node_fairq_opts fairq_opts;
struct node_state_opt *keep_state_defaults = NULL;
int disallow_table(struct node_host *, const char *);
@ -422,6 +424,7 @@ typedef struct {
struct table_opts table_opts;
struct pool_opts pool_opts;
struct node_hfsc_opts hfsc_opts;
struct node_fairq_opts fairq_opts;
} v;
int lineno;
} YYSTYPE;
@ -446,8 +449,8 @@ int parseport(char *, struct range *r, int);
%token REQUIREORDER SYNPROXY FINGERPRINTS NOSYNC DEBUG SKIP HOSTID
%token ANTISPOOF FOR INCLUDE
%token BITMASK RANDOM SOURCEHASH ROUNDROBIN STATICPORT PROBABILITY
%token ALTQ CBQ PRIQ HFSC BANDWIDTH TBRSIZE LINKSHARE REALTIME UPPERLIMIT
%token QUEUE PRIORITY QLIMIT RTABLE
%token ALTQ CBQ PRIQ HFSC FAIRQ BANDWIDTH TBRSIZE LINKSHARE REALTIME UPPERLIMIT
%token QUEUE PRIORITY QLIMIT HOGS BUCKETS RTABLE
%token LOAD RULESET_OPTIMIZATION
%token STICKYADDRESS MAXSRCSTATES MAXSRCNODES SOURCETRACK GLOBAL RULE
%token MAXSRCCONN MAXSRCCONNRATE OVERLOAD FLUSH SLOPPY
@ -495,6 +498,7 @@ int parseport(char *, struct range *r, int);
%type <v.number> cbqflags_list cbqflags_item
%type <v.number> priqflags_list priqflags_item
%type <v.hfsc_opts> hfscopts_list hfscopts_item hfsc_opts
%type <v.fairq_opts> fairqopts_list fairqopts_item fairq_opts
%type <v.queue_bwspec> bandwidth
%type <v.filter_opts> filter_opts filter_opt filter_opts_l
%type <v.antispoof_opts> antispoof_opts antispoof_opt antispoof_opts_l
@ -1659,6 +1663,15 @@ scheduler : CBQ {
$$.qtype = ALTQT_HFSC;
$$.data.hfsc_opts = $3;
}
| FAIRQ {
$$.qtype = ALTQT_FAIRQ;
bzero(&$$.data.fairq_opts,
sizeof(struct node_fairq_opts));
}
| FAIRQ '(' fairq_opts ')' {
$$.qtype = ALTQT_FAIRQ;
$$.data.fairq_opts = $3;
}
;
cbqflags_list : cbqflags_item { $$ |= $1; }
@ -1807,6 +1820,61 @@ hfscopts_item : LINKSHARE bandwidth {
}
;
fairq_opts : {
bzero(&fairq_opts,
sizeof(struct node_fairq_opts));
}
fairqopts_list {
$$ = fairq_opts;
}
;
fairqopts_list : fairqopts_item
| fairqopts_list comma fairqopts_item
;
fairqopts_item : LINKSHARE bandwidth {
if (fairq_opts.linkshare.used) {
yyerror("linkshare already specified");
YYERROR;
}
fairq_opts.linkshare.m2 = $2;
fairq_opts.linkshare.used = 1;
}
| LINKSHARE '(' bandwidth number bandwidth ')' {
if (fairq_opts.linkshare.used) {
yyerror("linkshare already specified");
YYERROR;
}
fairq_opts.linkshare.m1 = $3;
fairq_opts.linkshare.d = $4;
fairq_opts.linkshare.m2 = $5;
fairq_opts.linkshare.used = 1;
}
| HOGS bandwidth {
fairq_opts.hogs_bw = $2;
}
| BUCKETS number {
fairq_opts.nbuckets = $2;
}
| STRING {
if (!strcmp($1, "default"))
fairq_opts.flags |= FARF_DEFAULTCLASS;
else if (!strcmp($1, "red"))
fairq_opts.flags |= FARF_RED;
else if (!strcmp($1, "ecn"))
fairq_opts.flags |= FARF_RED|FARF_ECN;
else if (!strcmp($1, "rio"))
fairq_opts.flags |= FARF_RIO;
else {
yyerror("unknown fairq flag \"%s\"", $1);
free($1);
YYERROR;
}
free($1);
}
;
qassign : /* empty */ { $$ = NULL; }
| qassign_item { $$ = $1; }
| '{' optnl qassign_list '}' { $$ = $3; }
@ -5226,6 +5294,7 @@ lookup(char *s)
{ "bitmask", BITMASK},
{ "block", BLOCK},
{ "block-policy", BLOCKPOLICY},
{ "buckets", BUCKETS},
{ "cbq", CBQ},
{ "code", CODE},
{ "crop", FRAGCROP},
@ -5235,6 +5304,7 @@ lookup(char *s)
{ "drop", DROP},
{ "drop-ovl", FRAGDROP},
{ "dup-to", DUPTO},
{ "fairq", FAIRQ},
{ "fastroute", FASTROUTE},
{ "file", FILENAME},
{ "fingerprints", FINGERPRINTS},
@ -5247,6 +5317,7 @@ lookup(char *s)
{ "global", GLOBAL},
{ "group", GROUP},
{ "hfsc", HFSC},
{ "hogs", HOGS},
{ "hostid", HOSTID},
{ "icmp-type", ICMPTYPE},
{ "icmp6-type", ICMP6TYPE},

221
sbin/pfctl/pfctl_altq.c
View File

@ -42,6 +42,7 @@ __FBSDID("$FreeBSD$");
#include <net/altq/altq_cbq.h>
#include <net/altq/altq_priq.h>
#include <net/altq/altq_hfsc.h>
#include <net/altq/altq_fairq.h>
#include "pfctl_parser.h"
#include "pfctl.h"
@ -68,6 +69,11 @@ static int check_commit_hfsc(int, int, struct pf_altq *);
static int print_hfsc_opts(const struct pf_altq *,
const struct node_queue_opt *);
static int eval_pfqueue_fairq(struct pfctl *, struct pf_altq *);
static int print_fairq_opts(const struct pf_altq *,
const struct node_queue_opt *);
static int check_commit_fairq(int, int, struct pf_altq *);
static void gsc_add_sc(struct gen_sc *, struct service_curve *);
static int is_gsc_under_sc(struct gen_sc *,
struct service_curve *);
@ -88,6 +94,8 @@ int eval_queue_opts(struct pf_altq *, struct node_queue_opt *,
u_int32_t eval_bwspec(struct node_queue_bw *, u_int32_t);
void print_hfsc_sc(const char *, u_int, u_int, u_int,
const struct node_hfsc_sc *);
void print_fairq_sc(const char *, u_int, u_int, u_int,
const struct node_fairq_sc *);
void
pfaltq_store(struct pf_altq *a)
@ -173,6 +181,10 @@ print_altq(const struct pf_altq *a, unsigned int level,
if (!print_hfsc_opts(a, qopts))
printf("hfsc ");
break;
case ALTQT_FAIRQ:
if (!print_fairq_opts(a, qopts))
printf("fairq ");
break;
}
if (bw != NULL && bw->bw_percent > 0) {
@ -203,7 +215,8 @@ print_queue(const struct pf_altq *a, unsigned int level,
printf("%s ", a->qname);
if (print_interface)
printf("on %s ", a->ifname);
if (a->scheduler == ALTQT_CBQ || a->scheduler == ALTQT_HFSC) {
if (a->scheduler == ALTQT_CBQ || a->scheduler == ALTQT_HFSC ||
a->scheduler == ALTQT_FAIRQ) {
if (bw != NULL && bw->bw_percent > 0) {
if (bw->bw_percent < 100)
printf("bandwidth %u%% ", bw->bw_percent);
@ -224,6 +237,9 @@ print_queue(const struct pf_altq *a, unsigned int level,
case ALTQT_HFSC:
print_hfsc_opts(a, qopts);
break;
case ALTQT_FAIRQ:
print_fairq_opts(a, qopts);
break;
}
}
@ -294,6 +310,9 @@ check_commit_altq(int dev, int opts)
case ALTQT_HFSC:
error = check_commit_hfsc(dev, opts, altq);
break;
case ALTQT_FAIRQ:
error = check_commit_fairq(dev, opts, altq);
break;
default:
break;
}
@ -342,7 +361,8 @@ eval_pfqueue(struct pfctl *pf, struct pf_altq *pa, struct node_queue_bw *bw,
if (pa->qlimit == 0)
pa->qlimit = DEFAULT_QLIMIT;
if (pa->scheduler == ALTQT_CBQ || pa->scheduler == ALTQT_HFSC) {
if (pa->scheduler == ALTQT_CBQ || pa->scheduler == ALTQT_HFSC ||
pa->scheduler == ALTQT_FAIRQ) {
pa->bandwidth = eval_bwspec(bw,
parent == NULL ? 0 : parent->bandwidth);
@ -388,6 +408,9 @@ eval_pfqueue(struct pfctl *pf, struct pf_altq *pa, struct node_queue_bw *bw,
case ALTQT_HFSC:
error = eval_pfqueue_hfsc(pf, pa);
break;
case ALTQT_FAIRQ:
error = eval_pfqueue_fairq(pf, pa);
break;
default:
break;
}
@ -807,6 +830,85 @@ eval_pfqueue_hfsc(struct pfctl *pf, struct pf_altq *pa)
return (-1);
}
/*
* FAIRQ support functions
*/
static int
eval_pfqueue_fairq(struct pfctl *pf __unused, struct pf_altq *pa)
{
struct pf_altq *altq, *parent;
struct fairq_opts *opts;
struct service_curve sc;
opts = &pa->pq_u.fairq_opts;
if (pa->parent[0] == 0) {
/* root queue */
opts->lssc_m1 = pa->ifbandwidth;
opts->lssc_m2 = pa->ifbandwidth;
opts->lssc_d = 0;
return (0);
}
LIST_INIT(&lssc);
/* if link_share is not specified, use bandwidth */
if (opts->lssc_m2 == 0)
opts->lssc_m2 = pa->bandwidth;
/*
* admission control:
* for the real-time service curve, the sum of the service curves
* should not exceed 80% of the interface bandwidth. 20% is reserved
* not to over-commit the actual interface bandwidth.
* for the link-sharing service curve, the sum of the child service
* curve should not exceed the parent service curve.
* for the upper-limit service curve, the assigned bandwidth should
* be smaller than the interface bandwidth, and the upper-limit should
* be larger than the real-time service curve when both are defined.
*/
parent = qname_to_pfaltq(pa->parent, pa->ifname);
if (parent == NULL)
errx(1, "parent %s not found for %s", pa->parent, pa->qname);
TAILQ_FOREACH(altq, &altqs, entries) {
if (strncmp(altq->ifname, pa->ifname, IFNAMSIZ) != 0)
continue;
if (altq->qname[0] == 0) /* this is for interface */
continue;
if (strncmp(altq->parent, pa->parent, PF_QNAME_SIZE) != 0)
continue;
/* if the class has a link-sharing service curve, add it. */
if (opts->lssc_m2 != 0 && altq->pq_u.fairq_opts.lssc_m2 != 0) {
sc.m1 = altq->pq_u.fairq_opts.lssc_m1;
sc.d = altq->pq_u.fairq_opts.lssc_d;
sc.m2 = altq->pq_u.fairq_opts.lssc_m2;
gsc_add_sc(&lssc, &sc);
}
}
/* check the link-sharing service curve. */
if (opts->lssc_m2 != 0) {
sc.m1 = parent->pq_u.fairq_opts.lssc_m1;
sc.d = parent->pq_u.fairq_opts.lssc_d;
sc.m2 = parent->pq_u.fairq_opts.lssc_m2;
if (!is_gsc_under_sc(&lssc, &sc)) {
warnx("link-sharing sc exceeds parent's sc");
goto err_ret;
}
}
gsc_destroy(&lssc);
return (0);
err_ret:
gsc_destroy(&lssc);
return (-1);
}
static int
check_commit_hfsc(int dev, int opts, struct pf_altq *pa)
{
@ -846,6 +948,43 @@ check_commit_hfsc(int dev, int opts, struct pf_altq *pa)
return (error);
}
static int
check_commit_fairq(int dev __unused, int opts __unused, struct pf_altq *pa)
{
struct pf_altq *altq, *def = NULL;
int default_class;
int error = 0;
/* check if fairq has one default queue for this interface */
default_class = 0;
TAILQ_FOREACH(altq, &altqs, entries) {
if (strncmp(altq->ifname, pa->ifname, IFNAMSIZ) != 0)
continue;
if (altq->qname[0] == 0) /* this is for interface */
continue;
if (altq->pq_u.fairq_opts.flags & FARF_DEFAULTCLASS) {
default_class++;
def = altq;
}
}
if (default_class != 1) {
warnx("should have one default queue on %s", pa->ifname);
return (1);
}
/* make sure the default queue is a leaf */
TAILQ_FOREACH(altq, &altqs, entries) {
if (strncmp(altq->ifname, pa->ifname, IFNAMSIZ) != 0)
continue;
if (altq->qname[0] == 0) /* this is for interface */
continue;
if (strncmp(altq->parent, def->qname, PF_QNAME_SIZE) == 0) {
warnx("default queue is not a leaf");
error++;
}
}
return (error);
}
static int
print_hfsc_opts(const struct pf_altq *a, const struct node_queue_opt *qopts)
{
@ -892,6 +1031,43 @@ print_hfsc_opts(const struct pf_altq *a, const struct node_queue_opt *qopts)
return (0);
}
static int
print_fairq_opts(const struct pf_altq *a, const struct node_queue_opt *qopts)
{
const struct fairq_opts *opts;
const struct node_fairq_sc *loc_lssc;
opts = &a->pq_u.fairq_opts;
if (qopts == NULL)
loc_lssc = NULL;
else
loc_lssc = &qopts->data.fairq_opts.linkshare;
if (opts->flags ||
(opts->lssc_m2 != 0 && (opts->lssc_m2 != a->bandwidth ||
opts->lssc_d != 0))) {
printf("fairq(");
if (opts->flags & FARF_RED)
printf(" red");
if (opts->flags & FARF_ECN)
printf(" ecn");
if (opts->flags & FARF_RIO)
printf(" rio");
if (opts->flags & FARF_CLEARDSCP)
printf(" cleardscp");
if (opts->flags & FARF_DEFAULTCLASS)
printf(" default");
if (opts->lssc_m2 != 0 && (opts->lssc_m2 != a->bandwidth ||
opts->lssc_d != 0))
print_fairq_sc("linkshare", opts->lssc_m1, opts->lssc_d,
opts->lssc_m2, loc_lssc);
printf(" ) ");
return (1);
} else
return (0);
}
/*
* admission control using generalized service curve
*/
@ -1211,6 +1387,23 @@ eval_queue_opts(struct pf_altq *pa, struct node_queue_opt *opts,
opts->data.hfsc_opts.upperlimit.d;
}
break;
case ALTQT_FAIRQ:
pa->pq_u.fairq_opts.flags = opts->data.fairq_opts.flags;
pa->pq_u.fairq_opts.nbuckets = opts->data.fairq_opts.nbuckets;
pa->pq_u.fairq_opts.hogs_m1 =
eval_bwspec(&opts->data.fairq_opts.hogs_bw, ref_bw);
if (opts->data.fairq_opts.linkshare.used) {
pa->pq_u.fairq_opts.lssc_m1 =
eval_bwspec(&opts->data.fairq_opts.linkshare.m1,
ref_bw);
pa->pq_u.fairq_opts.lssc_m2 =
eval_bwspec(&opts->data.fairq_opts.linkshare.m2,
ref_bw);
pa->pq_u.fairq_opts.lssc_d =
opts->data.fairq_opts.linkshare.d;
}
break;
default:
warnx("eval_queue_opts: unknown scheduler type %u",
opts->qtype);
@ -1256,3 +1449,27 @@ print_hfsc_sc(const char *scname, u_int m1, u_int d, u_int m2,
if (d != 0)
printf(")");
}
void
print_fairq_sc(const char *scname, u_int m1, u_int d, u_int m2,
const struct node_fairq_sc *sc)
{
printf(" %s", scname);
if (d != 0) {
printf("(");
if (sc != NULL && sc->m1.bw_percent > 0)
printf("%u%%", sc->m1.bw_percent);
else
printf("%s", rate2str((double)m1));
printf(" %u", d);
}
if (sc != NULL && sc->m2.bw_percent > 0)
printf(" %u%%", sc->m2.bw_percent);
else
printf(" %s", rate2str((double)m2));
if (d != 0)
printf(")");
}

15
sbin/pfctl/pfctl_parser.h
View File

@ -150,12 +150,27 @@ struct node_hfsc_opts {
int flags;
};
struct node_fairq_sc {
struct node_queue_bw m1; /* slope of 1st segment; bps */
u_int d; /* x-projection of m1; msec */
struct node_queue_bw m2; /* slope of 2nd segment; bps */
u_int8_t used;
};
struct node_fairq_opts {
struct node_fairq_sc linkshare;
struct node_queue_bw hogs_bw;
u_int nbuckets;
int flags;
};
struct node_queue_opt {
int qtype;
union {
struct cbq_opts cbq_opts;
struct priq_opts priq_opts;
struct node_hfsc_opts hfsc_opts;
struct node_fairq_opts fairq_opts;
} data;
};

30
sbin/pfctl/pfctl_qstats.c
View File

@ -38,6 +38,7 @@ __FBSDID("$FreeBSD$");
#include <net/altq/altq_cbq.h>
#include <net/altq/altq_priq.h>
#include <net/altq/altq_hfsc.h>
#include <net/altq/altq_fairq.h>
#include "pfctl.h"
#include "pfctl_parser.h"
@ -46,6 +47,7 @@ union class_stats {
class_stats_t cbq_stats;
struct priq_classstats priq_stats;
struct hfsc_classstats hfsc_stats;
struct fairq_classstats fairq_stats;
};
#define AVGN_MAX 8
@ -77,6 +79,7 @@ void pfctl_print_altq_node(int, const struct pf_altq_node *,
void print_cbqstats(struct queue_stats);
void print_priqstats(struct queue_stats);
void print_hfscstats(struct queue_stats);
void print_fairqstats(struct queue_stats);
void pfctl_free_altq_node(struct pf_altq_node *);
void pfctl_print_altq_nodestat(int,
const struct pf_altq_node *);
@ -317,6 +320,9 @@ pfctl_print_altq_nodestat(int dev, const struct pf_altq_node *a)
case ALTQT_HFSC:
print_hfscstats(a->qstats);
break;
case ALTQT_FAIRQ:
print_fairqstats(a->qstats);
break;
}
}
@ -381,6 +387,26 @@ print_hfscstats(struct queue_stats cur)
rate2str((8 * cur.avg_bytes) / STAT_INTERVAL));
}
void
print_fairqstats(struct queue_stats cur)
{
printf(" [ pkts: %10llu bytes: %10llu "
"dropped pkts: %6llu bytes: %6llu ]\n",
(unsigned long long)cur.data.fairq_stats.xmit_cnt.packets,
(unsigned long long)cur.data.fairq_stats.xmit_cnt.bytes,
(unsigned long long)cur.data.fairq_stats.drop_cnt.packets,
(unsigned long long)cur.data.fairq_stats.drop_cnt.bytes);
printf(" [ qlength: %3d/%3d ]\n",
cur.data.fairq_stats.qlength, cur.data.fairq_stats.qlimit);
if (cur.avgn < 2)
return;
printf(" [ measured: %7.1f packets/s, %s/s ]\n",
cur.avg_packets / STAT_INTERVAL,
rate2str((8 * cur.avg_bytes) / STAT_INTERVAL));
}
void
pfctl_free_altq_node(struct pf_altq_node *node)
{
@ -421,6 +447,10 @@ update_avg(struct pf_altq_node *a)
b = qs->data.hfsc_stats.xmit_cnt.bytes;
p = qs->data.hfsc_stats.xmit_cnt.packets;
break;
case ALTQT_FAIRQ:
b = qs->data.fairq_stats.xmit_cnt.bytes;
p = qs->data.fairq_stats.xmit_cnt.packets;
break;
default:
b = 0;
p = 0;

7
share/man/man4/altq.4
View File

@ -25,7 +25,7 @@
.\"
.\" $FreeBSD$
.\"
.Dd December 9, 2011
.Dd June 24, 2015
.Dt ALTQ 4
.Os
.Sh NAME
@ -40,6 +40,7 @@
.Cd options ALTQ_HFSC
.Cd options ALTQ_CDNR
.Cd options ALTQ_PRIQ
.Cd options ALTQ_FAIRQ
.Sh DESCRIPTION
The
.Nm
@ -93,6 +94,10 @@ any of the available disciplines or consumers.
Build the
.Dq "Priority Queuing"
discipline.
.It Dv ALTQ_FAIRQ
Build the
.Dq "Fair Queuing"
discipline.
.It Dv ALTQ_NOPCC
Required if the TSC is unusable.
.It Dv ALTQ_DEBUG

1
sys/conf/NOTES
View File

@ -709,6 +709,7 @@ options ALTQ_CBQ # Class Based Queueing
options ALTQ_RED # Random Early Detection
options ALTQ_RIO # RED In/Out
options ALTQ_HFSC # Hierarchical Packet Scheduler
options ALTQ_FAIRQ # Fair Packet Scheduler
options ALTQ_CDNR # Traffic conditioner
options ALTQ_PRIQ # Priority Queueing
options ALTQ_NOPCC # Required if the TSC is unusable

1
sys/conf/files
View File

@ -3254,6 +3254,7 @@ libkern/zlib.c optional crypto | geom_uzip | ipsec | \
net/altq/altq_cbq.c optional altq
net/altq/altq_cdnr.c optional altq
net/altq/altq_hfsc.c optional altq
net/altq/altq_fairq.c optional altq
net/altq/altq_priq.c optional altq
net/altq/altq_red.c optional altq
net/altq/altq_rio.c optional altq

1
sys/conf/options
View File

@ -389,6 +389,7 @@ ALTQ_CBQ opt_altq.h
ALTQ_CDNR opt_altq.h
ALTQ_DEBUG opt_altq.h
ALTQ_HFSC opt_altq.h
ALTQ_FAIRQ opt_altq.h
ALTQ_NOPCC opt_altq.h
ALTQ_PRIQ opt_altq.h
ALTQ_RED opt_altq.h

3
sys/net/altq/altq.h
View File

@ -63,7 +63,8 @@
#define ALTQT_BLUE 10 /* blue */
#define ALTQT_PRIQ 11 /* priority queue */
#define ALTQT_JOBS 12 /* JoBS */
#define ALTQT_MAX 13 /* should be max discipline type + 1 */
#define ALTQT_FAIRQ 13 /* fairq */
#define ALTQT_MAX 14 /* should be max discipline type + 1 */
#ifdef ALTQ3_COMPAT
struct altqreq {

889
sys/net/altq/altq_fairq.c Normal file
View File

@ -0,0 +1,889 @@
/*
* Copyright (c) 2008 The DragonFly Project. All rights reserved.
*
* This code is derived from software contributed to The DragonFly Project
* by Matthew Dillon <dillon@backplane.com>
*
* 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.
* 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. Neither the name of The DragonFly Project nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific, prior written permission.
*
* 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 HOLDERS 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.
*
* $DragonFly: src/sys/net/altq/altq_fairq.c,v 1.1 2008/04/06 18:58:15 dillon Exp $
* $FreeBSD$
*/
/*
* Matt: I gutted altq_priq.c and used it as a skeleton on which to build
* fairq. The fairq algorithm is completely different then priq, of course,
* but because I used priq's skeleton I believe I should include priq's
* copyright.
*
* Copyright (C) 2000-2003
* Sony Computer Science Laboratories Inc. All rights reserved.
*
* 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.
* 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.
*
* THIS SOFTWARE IS PROVIDED BY SONY CSL 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 SONY CSL 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.
*/
/*
* FAIRQ - take traffic classified by keep state (hashed into
* mbuf->m_pkthdr.altq_state_hash) and bucketize it. Fairly extract
* the first packet from each bucket in a round-robin fashion.
*
* TODO - better overall qlimit support (right now it is per-bucket).
* - NOTE: red etc is per bucket, not overall.
* - better service curve support.
*
* EXAMPLE:
*
* altq on em0 fairq bandwidth 650Kb queue { std, bulk }
* queue std priority 3 bandwidth 400Kb \
* fairq (buckets 64, default, hogs 1Kb) qlimit 50
* queue bulk priority 2 bandwidth 100Kb \
* fairq (buckets 64, hogs 1Kb) qlimit 50
*
* pass out on em0 from any to any keep state queue std
* pass out on em0 inet proto tcp ..... port ... keep state queue bulk
*/
#include "opt_altq.h"
#include "opt_inet.h"
#include "opt_inet6.h"
#ifdef ALTQ_FAIRQ /* fairq is enabled in the kernel conf */
#include <sys/param.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/errno.h>
#include <sys/kernel.h>
#include <sys/queue.h>
#include <net/if.h>
#include <netinet/in.h>
#include <net/pfvar.h>
#include <net/altq/altq.h>
#include <net/altq/altq_fairq.h>
/*
* function prototypes
*/
static int fairq_clear_interface(struct fairq_if *);
static int fairq_request(struct ifaltq *, int, void *);
static void fairq_purge(struct fairq_if *);
static struct fairq_class *fairq_class_create(struct fairq_if *, int, int, u_int, struct fairq_opts *, int);
static int fairq_class_destroy(struct fairq_class *);
static int fairq_enqueue(struct ifaltq *, struct mbuf *, struct altq_pktattr *);
static struct mbuf *fairq_dequeue(struct ifaltq *, int);
static int fairq_addq(struct fairq_class *, struct mbuf *, u_int32_t);
static struct mbuf *fairq_getq(struct fairq_class *, uint64_t);
static struct mbuf *fairq_pollq(struct fairq_class *, uint64_t, int *);
static fairq_bucket_t *fairq_selectq(struct fairq_class *, int);
static void fairq_purgeq(struct fairq_class *);
static void get_class_stats(struct fairq_classstats *, struct fairq_class *);
static struct fairq_class *clh_to_clp(struct fairq_if *, uint32_t);
int
fairq_pfattach(struct pf_altq *a)
{
struct ifnet *ifp;
int error;
if ((ifp = ifunit(a->ifname)) == NULL || a->altq_disc == NULL)
return (EINVAL);
error = altq_attach(&ifp->if_snd, ALTQT_FAIRQ, a->altq_disc,
fairq_enqueue, fairq_dequeue, fairq_request, NULL, NULL);
return (error);
}
int
fairq_add_altq(struct pf_altq *a)
{
struct fairq_if *pif;
struct ifnet *ifp;
if ((ifp = ifunit(a->ifname)) == NULL)
return (EINVAL);
if (!ALTQ_IS_READY(&ifp->if_snd))
return (ENODEV);
pif = malloc(sizeof(struct fairq_if),
M_DEVBUF, M_WAITOK | M_ZERO);
pif->pif_bandwidth = a->ifbandwidth;
pif->pif_maxpri = -1;
pif->pif_ifq = &ifp->if_snd;
/* keep the state in pf_altq */
a->altq_disc = pif;
return (0);
}
int
fairq_remove_altq(struct pf_altq *a)
{
struct fairq_if *pif;
if ((pif = a->altq_disc) == NULL)
return (EINVAL);
a->altq_disc = NULL;
fairq_clear_interface(pif);
free(pif, M_DEVBUF);
return (0);
}
int
fairq_add_queue(struct pf_altq *a)
{
struct fairq_if *pif;
struct fairq_class *cl;
if ((pif = a->altq_disc) == NULL)
return (EINVAL);
/* check parameters */
if (a->priority >= FAIRQ_MAXPRI)
return (EINVAL);
if (a->qid == 0)
return (EINVAL);
if (pif->pif_classes[a->priority] != NULL)
return (EBUSY);
if (clh_to_clp(pif, a->qid) != NULL)
return (EBUSY);
cl = fairq_class_create(pif, a->priority, a->qlimit, a->bandwidth,
&a->pq_u.fairq_opts, a->qid);
if (cl == NULL)
return (ENOMEM);
return (0);
}
int
fairq_remove_queue(struct pf_altq *a)
{
struct fairq_if *pif;
struct fairq_class *cl;
if ((pif = a->altq_disc) == NULL)
return (EINVAL);
if ((cl = clh_to_clp(pif, a->qid)) == NULL)
return (EINVAL);
return (fairq_class_destroy(cl));
}
int
fairq_getqstats(struct pf_altq *a, void *ubuf, int *nbytes)
{
struct fairq_if *pif;
struct fairq_class *cl;
struct fairq_classstats stats;
int error = 0;
if ((pif = altq_lookup(a->ifname, ALTQT_FAIRQ)) == NULL)
return (EBADF);
if ((cl = clh_to_clp(pif, a->qid)) == NULL)
return (EINVAL);
if (*nbytes < sizeof(stats))
return (EINVAL);
get_class_stats(&stats, cl);
if ((error = copyout((caddr_t)&stats, ubuf, sizeof(stats))) != 0)
return (error);
*nbytes = sizeof(stats);
return (0);
}
/*
* bring the interface back to the initial state by discarding
* all the filters and classes.
*/
static int
fairq_clear_interface(struct fairq_if *pif)
{
struct fairq_class *cl;
int pri;
/* clear out the classes */
for (pri = 0; pri <= pif->pif_maxpri; pri++) {
if ((cl = pif->pif_classes[pri]) != NULL)
fairq_class_destroy(cl);
}
return (0);
}
static int
fairq_request(struct ifaltq *ifq, int req, void *arg)
{
struct fairq_if *pif = (struct fairq_if *)ifq->altq_disc;
IFQ_LOCK_ASSERT(ifq);
switch (req) {
case ALTRQ_PURGE:
fairq_purge(pif);
break;
}
return (0);
}
/* discard all the queued packets on the interface */
static void
fairq_purge(struct fairq_if *pif)
{
struct fairq_class *cl;
int pri;
for (pri = 0; pri <= pif->pif_maxpri; pri++) {
if ((cl = pif->pif_classes[pri]) != NULL && cl->cl_head)
fairq_purgeq(cl);
}
if (ALTQ_IS_ENABLED(pif->pif_ifq))
pif->pif_ifq->ifq_len = 0;
}
static struct fairq_class *
fairq_class_create(struct fairq_if *pif, int pri, int qlimit,
u_int bandwidth, struct fairq_opts *opts, int qid)
{
struct fairq_class *cl;
int flags = opts->flags;
u_int nbuckets = opts->nbuckets;
int i;
#ifndef ALTQ_RED
if (flags & FARF_RED) {
#ifdef ALTQ_DEBUG
printf("fairq_class_create: RED not configured for FAIRQ!\n");
#endif
return (NULL);
}
#endif
if (nbuckets == 0)
nbuckets = 256;
if (nbuckets > FAIRQ_MAX_BUCKETS)
nbuckets = FAIRQ_MAX_BUCKETS;
/* enforce power-of-2 size */
while ((nbuckets ^ (nbuckets - 1)) != ((nbuckets << 1) - 1))
++nbuckets;
if ((cl = pif->pif_classes[pri]) != NULL) {
/* modify the class instead of creating a new one */
IFQ_LOCK(cl->cl_pif->pif_ifq);
if (cl->cl_head)
fairq_purgeq(cl);
IFQ_UNLOCK(cl->cl_pif->pif_ifq);
#ifdef ALTQ_RIO
if (cl->cl_qtype == Q_RIO)
rio_destroy((rio_t *)cl->cl_red);
#endif
#ifdef ALTQ_RED
if (cl->cl_qtype == Q_RED)
red_destroy(cl->cl_red);
#endif
} else {
cl = malloc(sizeof(struct fairq_class),
M_DEVBUF, M_WAITOK | M_ZERO);
cl->cl_nbuckets = nbuckets;
cl->cl_nbucket_mask = nbuckets - 1;
cl->cl_buckets = malloc(
sizeof(struct fairq_bucket) * cl->cl_nbuckets,
M_DEVBUF, M_WAITOK | M_ZERO);
cl->cl_head = NULL;
}
pif->pif_classes[pri] = cl;
if (flags & FARF_DEFAULTCLASS)
pif->pif_default = cl;
if (qlimit == 0)
qlimit = 50; /* use default */
cl->cl_qlimit = qlimit;
for (i = 0; i < cl->cl_nbuckets; ++i) {
qlimit(&cl->cl_buckets[i].queue) = qlimit;
}
cl->cl_bandwidth = bandwidth / 8;
cl->cl_qtype = Q_DROPTAIL;
cl->cl_flags = flags & FARF_USERFLAGS;
cl->cl_pri = pri;
if (pri > pif->pif_maxpri)
pif->pif_maxpri = pri;
cl->cl_pif = pif;
cl->cl_handle = qid;
cl->cl_hogs_m1 = opts->hogs_m1 / 8;
cl->cl_lssc_m1 = opts->lssc_m1 / 8; /* NOT YET USED */
#ifdef ALTQ_RED
if (flags & (FARF_RED|FARF_RIO)) {
int red_flags, red_pkttime;
red_flags = 0;
if (flags & FARF_ECN)
red_flags |= REDF_ECN;
#ifdef ALTQ_RIO
if (flags & FARF_CLEARDSCP)
red_flags |= RIOF_CLEARDSCP;
#endif
if (pif->pif_bandwidth < 8)
red_pkttime = 1000 * 1000 * 1000; /* 1 sec */
else
red_pkttime = (int64_t)pif->pif_ifq->altq_ifp->if_mtu
* 1000 * 1000 * 1000 / (pif->pif_bandwidth / 8);
#ifdef ALTQ_RIO
if (flags & FARF_RIO) {
cl->cl_red = (red_t *)rio_alloc(0, NULL,
red_flags, red_pkttime);
if (cl->cl_red != NULL)
cl->cl_qtype = Q_RIO;
} else
#endif
if (flags & FARF_RED) {
cl->cl_red = red_alloc(0, 0,
cl->cl_qlimit * 10/100,
cl->cl_qlimit * 30/100,
red_flags, red_pkttime);
if (cl->cl_red != NULL)
cl->cl_qtype = Q_RED;
}
}
#endif /* ALTQ_RED */
return (cl);
err_buckets:
if (cl->cl_buckets != NULL)
free(cl->cl_buckets, M_DEVBUF);
err_ret:
if (cl->cl_red != NULL) {
#ifdef ALTQ_RIO
if (cl->cl_qtype == Q_RIO)
rio_destroy((rio_t *)cl->cl_red);
#endif
#ifdef ALTQ_RED
if (cl->cl_qtype == Q_RED)
red_destroy(cl->cl_red);
#endif
}
if (cl != NULL)
free(cl, M_DEVBUF);
return (NULL);
}
static int
fairq_class_destroy(struct fairq_class *cl)
{
struct fairq_if *pif;
int pri;
IFQ_LOCK(cl->cl_pif->pif_ifq);
if (cl->cl_head)
fairq_purgeq(cl);
pif = cl->cl_pif;
pif->pif_classes[cl->cl_pri] = NULL;
if (pif->pif_poll_cache == cl)
pif->pif_poll_cache = NULL;
if (pif->pif_maxpri == cl->cl_pri) {
for (pri = cl->cl_pri; pri >= 0; pri--)
if (pif->pif_classes[pri] != NULL) {
pif->pif_maxpri = pri;
break;
}
if (pri < 0)
pif->pif_maxpri = -1;
}
IFQ_UNLOCK(cl->cl_pif->pif_ifq);
if (cl->cl_red != NULL) {
#ifdef ALTQ_RIO
if (cl->cl_qtype == Q_RIO)
rio_destroy((rio_t *)cl->cl_red);
#endif
#ifdef ALTQ_RED
if (cl->cl_qtype == Q_RED)
red_destroy(cl->cl_red);
#endif
}
free(cl->cl_buckets, M_DEVBUF);
free(cl, M_DEVBUF);
return (0);
}
/*
* fairq_enqueue is an enqueue function to be registered to
* (*altq_enqueue) in struct ifaltq.
*/
static int
fairq_enqueue(struct ifaltq *ifq, struct mbuf *m, struct altq_pktattr *pktattr)
{
struct fairq_if *pif = (struct fairq_if *)ifq->altq_disc;
struct fairq_class *cl = NULL; /* Make compiler happy */
struct pf_mtag *t;
u_int32_t qid_hash = 0;
int len;
IFQ_LOCK_ASSERT(ifq);
/* grab class set by classifier */
if ((m->m_flags & M_PKTHDR) == 0) {
/* should not happen */
printf("altq: packet for %s does not have pkthdr\n",
ifq->altq_ifp->if_xname);
m_freem(m);
return (ENOBUFS);
}
if ((t = pf_find_mtag(m)) != NULL) {
cl = clh_to_clp(pif, t->qid);
qid_hash = t->qid_hash;
}
if (cl == NULL) {
cl = pif->pif_default;
if (cl == NULL) {
m_freem(m);
return (ENOBUFS);
}
}
cl->cl_flags |= FARF_HAS_PACKETS;
cl->cl_pktattr = NULL;
len = m_pktlen(m);
if (fairq_addq(cl, m, qid_hash) != 0) {
/* drop occurred. mbuf was freed in fairq_addq. */
PKTCNTR_ADD(&cl->cl_dropcnt, len);
return (ENOBUFS);
}
IFQ_INC_LEN(ifq);
return (0);
}
/*
* fairq_dequeue is a dequeue function to be registered to
* (*altq_dequeue) in struct ifaltq.
*
* note: ALTDQ_POLL returns the next packet without removing the packet
* from the queue. ALTDQ_REMOVE is a normal dequeue operation.
* ALTDQ_REMOVE must return the same packet if called immediately
* after ALTDQ_POLL.
*/
static struct mbuf *
fairq_dequeue(struct ifaltq *ifq, int op)
{
struct fairq_if *pif = (struct fairq_if *)ifq->altq_disc;
struct fairq_class *cl;
struct fairq_class *best_cl;
struct mbuf *best_m;
struct mbuf *m = NULL;
uint64_t cur_time = read_machclk();
int pri;
int hit_limit;
IFQ_LOCK_ASSERT(ifq);
if (IFQ_IS_EMPTY(ifq)) {
return (NULL);
}
if (pif->pif_poll_cache && op == ALTDQ_REMOVE) {
best_cl = pif->pif_poll_cache;
m = fairq_getq(best_cl, cur_time);
pif->pif_poll_cache = NULL;
if (m) {
IFQ_DEC_LEN(ifq);
PKTCNTR_ADD(&best_cl->cl_xmitcnt, m_pktlen(m));
return (m);
}
} else {
best_cl = NULL;
best_m = NULL;
for (pri = pif->pif_maxpri; pri >= 0; pri--) {
if ((cl = pif->pif_classes[pri]) == NULL)
continue;
if ((cl->cl_flags & FARF_HAS_PACKETS) == 0)
continue;
m = fairq_pollq(cl, cur_time, &hit_limit);
if (m == NULL) {
cl->cl_flags &= ~FARF_HAS_PACKETS;
continue;
}
/*
* Only override the best choice if we are under
* the BW limit.
*/
if (hit_limit == 0 || best_cl == NULL) {
best_cl = cl;
best_m = m;
}
/*
* Remember the highest priority mbuf in case we
* do not find any lower priority mbufs.
*/
if (hit_limit)
continue;
break;
}
if (op == ALTDQ_POLL) {
pif->pif_poll_cache = best_cl;
m = best_m;
} else if (best_cl) {
m = fairq_getq(best_cl, cur_time);
if (m != NULL) {
IFQ_DEC_LEN(ifq);
PKTCNTR_ADD(&best_cl->cl_xmitcnt, m_pktlen(m));
}
}
return (m);
}
return (NULL);
}
static int
fairq_addq(struct fairq_class *cl, struct mbuf *m, u_int32_t bucketid)
{
fairq_bucket_t *b;
u_int hindex;
uint64_t bw;
/*
* If the packet doesn't have any keep state put it on the end of
* our queue. XXX this can result in out of order delivery.
*/
if (bucketid == 0) {
if (cl->cl_head)
b = cl->cl_head->prev;
else
b = &cl->cl_buckets[0];
} else {
hindex = bucketid & cl->cl_nbucket_mask;
b = &cl->cl_buckets[hindex];
}
/*
* Add the bucket to the end of the circular list of active buckets.
*
* As a special case we add the bucket to the beginning of the list
* instead of the end if it was not previously on the list and if
* its traffic is less then the hog level.
*/
if (b->in_use == 0) {
b->in_use = 1;
if (cl->cl_head == NULL) {
cl->cl_head = b;
b->next = b;
b->prev = b;
} else {
b->next = cl->cl_head;
b->prev = cl->cl_head->prev;
b->prev->next = b;
b->next->prev = b;
if (b->bw_delta && cl->cl_hogs_m1) {
bw = b->bw_bytes * machclk_freq / b->bw_delta;
if (bw < cl->cl_hogs_m1)
cl->cl_head = b;
}
}
}
#ifdef ALTQ_RIO
if (cl->cl_qtype == Q_RIO)
return rio_addq((rio_t *)cl->cl_red, &b->queue, m, cl->cl_pktattr);
#endif
#ifdef ALTQ_RED
if (cl->cl_qtype == Q_RED)
return red_addq(cl->cl_red, &b->queue, m, cl->cl_pktattr);
#endif
if (qlen(&b->queue) >= qlimit(&b->queue)) {
m_freem(m);
return (-1);
}
if (cl->cl_flags & FARF_CLEARDSCP)
write_dsfield(m, cl->cl_pktattr, 0);
_addq(&b->queue, m);
return (0);
}
static struct mbuf *
fairq_getq(struct fairq_class *cl, uint64_t cur_time)
{
fairq_bucket_t *b;
struct mbuf *m;
b = fairq_selectq(cl, 0);
if (b == NULL)
m = NULL;
#ifdef ALTQ_RIO
else if (cl->cl_qtype == Q_RIO)
m = rio_getq((rio_t *)cl->cl_red, &b->queue);
#endif
#ifdef ALTQ_RED
else if (cl->cl_qtype == Q_RED)
m = red_getq(cl->cl_red, &b->queue);
#endif
else
m = _getq(&b->queue);
/*
* Calculate the BW change
*/
if (m != NULL) {
uint64_t delta;
/*
* Per-class bandwidth calculation
*/
delta = (cur_time - cl->cl_last_time);
if (delta > machclk_freq * 8)
delta = machclk_freq * 8;
cl->cl_bw_delta += delta;
cl->cl_bw_bytes += m->m_pkthdr.len;
cl->cl_last_time = cur_time;
cl->cl_bw_delta -= cl->cl_bw_delta >> 3;
cl->cl_bw_bytes -= cl->cl_bw_bytes >> 3;
/*
* Per-bucket bandwidth calculation
*/
delta = (cur_time - b->last_time);
if (delta > machclk_freq * 8)
delta = machclk_freq * 8;
b->bw_delta += delta;
b->bw_bytes += m->m_pkthdr.len;
b->last_time = cur_time;
b->bw_delta -= b->bw_delta >> 3;
b->bw_bytes -= b->bw_bytes >> 3;
}
return(m);
}
/*
* Figure out what the next packet would be if there were no limits. If
* this class hits its bandwidth limit *hit_limit is set to no-zero, otherwise
* it is set to 0. A non-NULL mbuf is returned either way.
*/
static struct mbuf *
fairq_pollq(struct fairq_class *cl, uint64_t cur_time, int *hit_limit)
{
fairq_bucket_t *b;
struct mbuf *m;
uint64_t delta;
uint64_t bw;
*hit_limit = 0;
b = fairq_selectq(cl, 1);
if (b == NULL)
return(NULL);
m = qhead(&b->queue);
/*
* Did this packet exceed the class bandwidth? Calculate the
* bandwidth component of the packet.
*
* - Calculate bytes per second
*/
delta = cur_time - cl->cl_last_time;
if (delta > machclk_freq * 8)
delta = machclk_freq * 8;
cl->cl_bw_delta += delta;
cl->cl_last_time = cur_time;
if (cl->cl_bw_delta) {
bw = cl->cl_bw_bytes * machclk_freq / cl->cl_bw_delta;
if (bw > cl->cl_bandwidth)
*hit_limit = 1;
#ifdef ALTQ_DEBUG
printf("BW %6lld relative to %6u %d queue %p\n",
bw, cl->cl_bandwidth, *hit_limit, b);
#endif
}
return(m);
}
/*
* Locate the next queue we want to pull a packet out of. This code
* is also responsible for removing empty buckets from the circular list.
*/
static
fairq_bucket_t *
fairq_selectq(struct fairq_class *cl, int ispoll)
{
fairq_bucket_t *b;
uint64_t bw;
if (ispoll == 0 && cl->cl_polled) {
b = cl->cl_polled;
cl->cl_polled = NULL;
return(b);
}
while ((b = cl->cl_head) != NULL) {
/*
* Remove empty queues from consideration
*/
if (qempty(&b->queue)) {
b->in_use = 0;
cl->cl_head = b->next;
if (cl->cl_head == b) {
cl->cl_head = NULL;
} else {
b->next->prev = b->prev;
b->prev->next = b->next;
}
continue;
}
/*
* Advance the round robin. Queues with bandwidths less
* then the hog bandwidth are allowed to burst.
*/
if (cl->cl_hogs_m1 == 0) {
cl->cl_head = b->next;
} else if (b->bw_delta) {
bw = b->bw_bytes * machclk_freq / b->bw_delta;
if (bw >= cl->cl_hogs_m1) {
cl->cl_head = b->next;
}
/*
* XXX TODO -
*/
}
/*
* Return bucket b.
*/
break;
}
if (ispoll)
cl->cl_polled = b;
return(b);
}
static void
fairq_purgeq(struct fairq_class *cl)
{
fairq_bucket_t *b;
struct mbuf *m;
while ((b = fairq_selectq(cl, 0)) != NULL) {
while ((m = _getq(&b->queue)) != NULL) {
PKTCNTR_ADD(&cl->cl_dropcnt, m_pktlen(m));
m_freem(m);
}
ASSERT(qlen(&b->queue) == 0);
}
}
static void
get_class_stats(struct fairq_classstats *sp, struct fairq_class *cl)
{
fairq_bucket_t *b;
sp->class_handle = cl->cl_handle;
sp->qlimit = cl->cl_qlimit;
sp->xmit_cnt = cl->cl_xmitcnt;
sp->drop_cnt = cl->cl_dropcnt;
sp->qtype = cl->cl_qtype;
sp->qlength = 0;
if (cl->cl_head) {
b = cl->cl_head;
do {
sp->qlength += qlen(&b->queue);
b = b->next;
} while (b != cl->cl_head);
}
#ifdef ALTQ_RED
if (cl->cl_qtype == Q_RED)
red_getstats(cl->cl_red, &sp->red[0]);
#endif
#ifdef ALTQ_RIO
if (cl->cl_qtype == Q_RIO)
rio_getstats((rio_t *)cl->cl_red, &sp->red[0]);
#endif
}
/* convert a class handle to the corresponding class pointer */
static struct fairq_class *
clh_to_clp(struct fairq_if *pif, uint32_t chandle)
{
struct fairq_class *cl;
int idx;
if (chandle == 0)
return (NULL);
for (idx = pif->pif_maxpri; idx >= 0; idx--)
if ((cl = pif->pif_classes[idx]) != NULL &&
cl->cl_handle == chandle)
return (cl);
return (NULL);
}
#endif /* ALTQ_FAIRQ */

137
sys/net/altq/altq_fairq.h Normal file
View File

@ -0,0 +1,137 @@
/*
* Copyright (c) 2008 The DragonFly Project. All rights reserved.
*
* This code is derived from software contributed to The DragonFly Project
* by Matthew Dillon <dillon@backplane.com>
*
* 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.
* 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. Neither the name of The DragonFly Project nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific, prior written permission.
*
* 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 HOLDERS 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.
*
* $DragonFly: src/sys/net/altq/altq_fairq.h,v 1.1 2008/04/06 18:58:15 dillon Exp $
* $FreeBSD$
*/
#ifndef _ALTQ_ALTQ_FAIRQ_H_
#define _ALTQ_ALTQ_FAIRQ_H_
#include <net/altq/altq.h>
#include <net/altq/altq_classq.h>
#include <net/altq/altq_red.h>
#include <net/altq/altq_rio.h>
#include <net/altq/altq_rmclass.h>
#define FAIRQ_MAX_BUCKETS 2048 /* maximum number of sorting buckets */
#define FAIRQ_MAXPRI RM_MAXPRIO
#define FAIRQ_BITMAP_WIDTH (sizeof(fairq_bitmap_t)*8)
#define FAIRQ_BITMAP_MASK (FAIRQ_BITMAP_WIDTH - 1)
/* fairq class flags */
#define FARF_RED 0x0001 /* use RED */
#define FARF_ECN 0x0002 /* use RED/ECN */
#define FARF_RIO 0x0004 /* use RIO */
#define FARF_CLEARDSCP 0x0010 /* clear diffserv codepoint */
#define FARF_DEFAULTCLASS 0x1000 /* default class */
#define FARF_HAS_PACKETS 0x2000 /* might have queued packets */
#define FARF_USERFLAGS (FARF_RED|FARF_ECN|FARF_RIO|FARF_CLEARDSCP| \
FARF_DEFAULTCLASS)
/* special class handles */
#define FAIRQ_NULLCLASS_HANDLE 0
typedef u_int fairq_bitmap_t;
struct fairq_classstats {
uint32_t class_handle;
u_int qlength;
u_int qlimit;
struct pktcntr xmit_cnt; /* transmitted packet counter */
struct pktcntr drop_cnt; /* dropped packet counter */
/* red and rio related info */
int qtype;
struct redstats red[3]; /* rio has 3 red stats */
};
#ifdef _KERNEL
typedef struct fairq_bucket {
struct fairq_bucket *next; /* circular list */
struct fairq_bucket *prev; /* circular list */
class_queue_t queue; /* the actual queue */
uint64_t bw_bytes; /* statistics used to calculate bw */
uint64_t bw_delta; /* statistics used to calculate bw */
uint64_t last_time;
int in_use;
} fairq_bucket_t;
struct fairq_class {
uint32_t cl_handle; /* class handle */
u_int cl_nbuckets; /* (power of 2) */
u_int cl_nbucket_mask; /* bucket mask */
fairq_bucket_t *cl_buckets;
fairq_bucket_t *cl_head; /* head of circular bucket list */
fairq_bucket_t *cl_polled;
struct red *cl_red; /* RED state */
u_int cl_hogs_m1;
u_int cl_lssc_m1;
u_int cl_bandwidth;
uint64_t cl_bw_bytes;
uint64_t cl_bw_delta;
uint64_t cl_last_time;
int cl_qtype; /* rollup */
int cl_qlimit;
int cl_pri; /* priority */
int cl_flags; /* class flags */
struct fairq_if *cl_pif; /* back pointer to pif */
struct altq_pktattr *cl_pktattr; /* saved header used by ECN */
/* round robin index */
/* statistics */
struct pktcntr cl_xmitcnt; /* transmitted packet counter */
struct pktcntr cl_dropcnt; /* dropped packet counter */
};
/*
* fairq interface state
*/
struct fairq_if {
struct fairq_if *pif_next; /* interface state list */
struct ifaltq *pif_ifq; /* backpointer to ifaltq */
u_int pif_bandwidth; /* link bandwidth in bps */
int pif_maxpri; /* max priority in use */
struct fairq_class *pif_poll_cache;/* cached poll */
struct fairq_class *pif_default; /* default class */
struct fairq_class *pif_classes[FAIRQ_MAXPRI]; /* classes */
};
#endif /* _KERNEL */
#endif /* _ALTQ_ALTQ_FAIRQ_H_ */

30
sys/net/altq/altq_subr.c
View File

@ -506,6 +506,11 @@ altq_pfattach(struct pf_altq *a)
case ALTQT_HFSC:
error = hfsc_pfattach(a);
break;
#endif
#ifdef ALTQ_FAIRQ
case ALTQT_FAIRQ:
error = fairq_pfattach(a);
break;
#endif
default:
error = ENXIO;
@ -577,6 +582,11 @@ altq_add(struct pf_altq *a)
case ALTQT_HFSC:
error = hfsc_add_altq(a);
break;
#endif
#ifdef ALTQ_FAIRQ
case ALTQT_FAIRQ:
error = fairq_add_altq(a);
break;
#endif
default:
error = ENXIO;
@ -613,6 +623,11 @@ altq_remove(struct pf_altq *a)
case ALTQT_HFSC:
error = hfsc_remove_altq(a);
break;
#endif
#ifdef ALTQ_FAIRQ
case ALTQT_FAIRQ:
error = fairq_remove_altq(a);
break;
#endif
default:
error = ENXIO;
@ -646,6 +661,11 @@ altq_add_queue(struct pf_altq *a)
case ALTQT_HFSC:
error = hfsc_add_queue(a);
break;
#endif
#ifdef ALTQ_FAIRQ
case ALTQT_FAIRQ:
error = fairq_add_queue(a);
break;
#endif
default:
error = ENXIO;
@ -679,6 +699,11 @@ altq_remove_queue(struct pf_altq *a)
case ALTQT_HFSC:
error = hfsc_remove_queue(a);
break;
#endif
#ifdef ALTQ_FAIRQ
case ALTQT_FAIRQ:
error = fairq_remove_queue(a);
break;
#endif
default:
error = ENXIO;
@ -712,6 +737,11 @@ altq_getqstats(struct pf_altq *a, void *ubuf, int *nbytes)
case ALTQT_HFSC:
error = hfsc_getqstats(a, ubuf, nbytes);
break;
#endif
#ifdef ALTQ_FAIRQ
case ALTQT_FAIRQ:
error = fairq_getqstats(a, ubuf, nbytes);
break;
#endif
default:
error = ENXIO;

7
sys/net/altq/altq_var.h
View File

@ -227,5 +227,12 @@ int hfsc_add_queue(struct pf_altq *);
int hfsc_remove_queue(struct pf_altq *);
int hfsc_getqstats(struct pf_altq *, void *, int *);
int fairq_pfattach(struct pf_altq *);
int fairq_add_altq(struct pf_altq *);
int fairq_remove_altq(struct pf_altq *);
int fairq_add_queue(struct pf_altq *);
int fairq_remove_queue(struct pf_altq *);
int fairq_getqstats(struct pf_altq *, void *, int *);
#endif /* _KERNEL */
#endif /* _ALTQ_ALTQ_VAR_H_ */

18
sys/netpfil/pf/pf.c
View File

@ -439,6 +439,20 @@ pf_hashsrc(struct pf_addr *addr, sa_family_t af)
return (h & pf_srchashmask);
}
#ifdef ALTQ
static int
pf_state_hash(struct pf_state *s)
{
u_int32_t hv = (intptr_t)s / sizeof(*s);
hv ^= crc32(&s->src, sizeof(s->src));
hv ^= crc32(&s->dst, sizeof(s->dst));
if (hv == 0)
hv = 1;
return (hv);
}
#endif
#ifdef INET6
void
pf_addrcpy(struct pf_addr *dst, struct pf_addr *src, sa_family_t af)
@ -5900,6 +5914,8 @@ pf_test(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp)
action = PF_DROP;
REASON_SET(&reason, PFRES_MEMORY);
} else {
if (s != NULL)
pd.pf_mtag->qid_hash = pf_state_hash(s);
if (pqid || (pd.tos & IPTOS_LOWDELAY))
pd.pf_mtag->qid = r->pqid;
else
@ -6332,6 +6348,8 @@ pf_test6(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp)
action = PF_DROP;
REASON_SET(&reason, PFRES_MEMORY);
} else {
if (s != NULL)
pd.pf_mtag->qid_hash = pf_state_hash(s);
if (pd.tos & IPTOS_LOWDELAY)
pd.pf_mtag->qid = r->pqid;
else

15
sys/netpfil/pf/pf_altq.h
View File

@ -65,6 +65,20 @@ struct hfsc_opts {
int flags;
};
/*
* XXX this needs some work
*/
struct fairq_opts {
u_int nbuckets;
u_int hogs_m1;
int flags;
/* link sharing service curve */
u_int lssc_m1;
u_int lssc_d;
u_int lssc_m2;
};
struct pf_altq {
char ifname[IFNAMSIZ];
@ -91,6 +105,7 @@ struct pf_altq {
struct cbq_opts cbq_opts;
struct priq_opts priq_opts;
struct hfsc_opts hfsc_opts;
struct fairq_opts fairq_opts;
} pq_u;
uint32_t qid; /* return value */

1
sys/netpfil/pf/pf_mtag.h
View File

@ -44,6 +44,7 @@
struct pf_mtag {
void *hdr; /* saved hdr pos in mbuf, for ECN */
u_int32_t qid; /* queue id */
u_int32_t qid_hash; /* queue hashid used by WFQ like algos */
u_int16_t tag; /* tag id */
u_int8_t flags;
u_int8_t routed;