Merge branch 'net-sched-retire-some-tc-qdiscs-and-classifiers'

TC_INDIRECT_FILTER_DECLARE(fw_classify);

TC_INDIRECT_FILTER_DECLARE(mall_classify);

TC_INDIRECT_FILTER_DECLARE(route4_classify);

TC_INDIRECT_FILTER_DECLARE(rsvp_classify);

TC_INDIRECT_FILTER_DECLARE(rsvp6_classify);

TC_INDIRECT_FILTER_DECLARE(tcindex_classify);

TC_INDIRECT_FILTER_DECLARE(u32_classify);

static inline int tc_classify(struct sk_buff *skb, const struct tcf_proto *tp,

	if (tp->classify == route4_classify)

		return route4_classify(skb, tp, res);

#endif

#if IS_BUILTIN(CONFIG_NET_CLS_RSVP)

	if (tp->classify == rsvp_classify)

		return rsvp_classify(skb, tp, res);

#endif

#if IS_BUILTIN(CONFIG_NET_CLS_RSVP6)

	if (tp->classify == rsvp6_classify)

		return rsvp6_classify(skb, tp, res);

#endif

#if IS_BUILTIN(CONFIG_NET_CLS_TCINDEX)

	if (tp->classify == tcindex_classify)

		return tcindex_classify(skb, tp, res);

#endif

skip:

	return tp->classify(skb, tp, res);

comment "Queueing/Scheduling"

config NET_SCH_CBQ

	tristate "Class Based Queueing (CBQ)"

	help

	  Say Y here if you want to use the Class-Based Queueing (CBQ) packet

	  scheduling algorithm. This algorithm classifies the waiting packets

	  into a tree-like hierarchy of classes; the leaves of this tree are

	  in turn scheduled by separate algorithms.

	  See the top of <file:net/sched/sch_cbq.c> for more details.

	  CBQ is a commonly used scheduler, so if you're unsure, you should

	  say Y here. Then say Y to all the queueing algorithms below that you

	  want to use as leaf disciplines.

	  To compile this code as a module, choose M here: the

	  module will be called sch_cbq.

config NET_SCH_HTB

	tristate "Hierarchical Token Bucket (HTB)"

	help

	  To compile this code as a module, choose M here: the

	  module will be called sch_hfsc.

config NET_SCH_ATM

	tristate "ATM Virtual Circuits (ATM)"

	depends on ATM

	help

	  Say Y here if you want to use the ATM pseudo-scheduler.  This

	  provides a framework for invoking classifiers, which in turn

	  select classes of this queuing discipline.  Each class maps

	  the flow(s) it is handling to a given virtual circuit.

	  See the top of <file:net/sched/sch_atm.c> for more details.

	  To compile this code as a module, choose M here: the

	  module will be called sch_atm.

config NET_SCH_PRIO

	tristate "Multi Band Priority Queueing (PRIO)"

	help

	  To compile this code as a module, choose M here: the

	  module will be called sch_gred.

config NET_SCH_DSMARK

	tristate "Differentiated Services marker (DSMARK)"

	help

	  Say Y if you want to schedule packets according to the

	  Differentiated Services architecture proposed in RFC 2475.

	  Technical information on this method, with pointers to associated

	  RFCs, is available at <http://www.gta.ufrj.br/diffserv/>.

	  To compile this code as a module, choose M here: the

	  module will be called sch_dsmark.

config NET_SCH_NETEM

	tristate "Network emulator (NETEM)"

	help

	  To compile this code as a module, choose M here: the

	  module will be called cls_basic.

config NET_CLS_TCINDEX

	tristate "Traffic-Control Index (TCINDEX)"

	select NET_CLS

	help

	  Say Y here if you want to be able to classify packets based on

	  traffic control indices. You will want this feature if you want

	  to implement Differentiated Services together with DSMARK.

	  To compile this code as a module, choose M here: the

	  module will be called cls_tcindex.

config NET_CLS_ROUTE4

	tristate "Routing decision (ROUTE)"

	depends on INET

	help

	  Say Y here to be able to use netfilter marks as u32 key.

config NET_CLS_RSVP

	tristate "IPv4 Resource Reservation Protocol (RSVP)"

	select NET_CLS

	help

	  The Resource Reservation Protocol (RSVP) permits end systems to

	  request a minimum and maximum data flow rate for a connection; this

	  is important for real time data such as streaming sound or video.

	  Say Y here if you want to be able to classify outgoing packets based

	  on their RSVP requests.

	  To compile this code as a module, choose M here: the

	  module will be called cls_rsvp.

config NET_CLS_RSVP6

	tristate "IPv6 Resource Reservation Protocol (RSVP6)"

	select NET_CLS

	help

	  The Resource Reservation Protocol (RSVP) permits end systems to

	  request a minimum and maximum data flow rate for a connection; this

	  is important for real time data such as streaming sound or video.

	  Say Y here if you want to be able to classify outgoing packets based

	  on their RSVP requests and you are using the IPv6 protocol.

	  To compile this code as a module, choose M here: the

	  module will be called cls_rsvp6.

config NET_CLS_FLOW

	tristate "Flow classifier"

	select NET_CLS

obj-$(CONFIG_NET_ACT_CT)	+= act_ct.o

obj-$(CONFIG_NET_ACT_GATE)	+= act_gate.o

obj-$(CONFIG_NET_SCH_FIFO)	+= sch_fifo.o

obj-$(CONFIG_NET_SCH_CBQ)	+= sch_cbq.o

obj-$(CONFIG_NET_SCH_HTB)	+= sch_htb.o

obj-$(CONFIG_NET_SCH_HFSC)	+= sch_hfsc.o

obj-$(CONFIG_NET_SCH_RED)	+= sch_red.o

obj-$(CONFIG_NET_SCH_GRED)	+= sch_gred.o

obj-$(CONFIG_NET_SCH_INGRESS)	+= sch_ingress.o

obj-$(CONFIG_NET_SCH_DSMARK)	+= sch_dsmark.o

obj-$(CONFIG_NET_SCH_SFB)	+= sch_sfb.o

obj-$(CONFIG_NET_SCH_SFQ)	+= sch_sfq.o

obj-$(CONFIG_NET_SCH_TBF)	+= sch_tbf.o

obj-$(CONFIG_NET_SCH_TEQL)	+= sch_teql.o

obj-$(CONFIG_NET_SCH_PRIO)	+= sch_prio.o

obj-$(CONFIG_NET_SCH_MULTIQ)	+= sch_multiq.o

obj-$(CONFIG_NET_SCH_ATM)	+= sch_atm.o

obj-$(CONFIG_NET_SCH_NETEM)	+= sch_netem.o

obj-$(CONFIG_NET_SCH_DRR)	+= sch_drr.o

obj-$(CONFIG_NET_SCH_PLUG)	+= sch_plug.o

obj-$(CONFIG_NET_CLS_U32)	+= cls_u32.o

obj-$(CONFIG_NET_CLS_ROUTE4)	+= cls_route.o

obj-$(CONFIG_NET_CLS_FW)	+= cls_fw.o

obj-$(CONFIG_NET_CLS_RSVP)	+= cls_rsvp.o

obj-$(CONFIG_NET_CLS_TCINDEX)	+= cls_tcindex.o

obj-$(CONFIG_NET_CLS_RSVP6)	+= cls_rsvp6.o

obj-$(CONFIG_NET_CLS_BASIC)	+= cls_basic.o

obj-$(CONFIG_NET_CLS_FLOW)	+= cls_flow.o

obj-$(CONFIG_NET_CLS_CGROUP)	+= cls_cgroup.o

// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * net/sched/cls_rsvp.c	Special RSVP packet classifier for IPv4.

 *

 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>

 */

#include <linux/module.h>

#include <linux/types.h>

#include <linux/kernel.h>

#include <linux/string.h>

#include <linux/errno.h>

#include <linux/skbuff.h>

#include <net/ip.h>

#include <net/netlink.h>

#include <net/act_api.h>

#include <net/pkt_cls.h>

#include <net/tc_wrapper.h>

#define RSVP_DST_LEN	1

#define RSVP_ID		"rsvp"

#define RSVP_OPS	cls_rsvp_ops

#define RSVP_CLS	rsvp_classify

#include "cls_rsvp.h"

MODULE_LICENSE("GPL");

/* SPDX-License-Identifier: GPL-2.0-or-later */

/*

 * net/sched/cls_rsvp.h	Template file for RSVPv[46] classifiers.

 *

 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>

 */

/*

   Comparing to general packet classification problem,

   RSVP needs only several relatively simple rules:

   * (dst, protocol) are always specified,

     so that we are able to hash them.

   * src may be exact, or may be wildcard, so that

     we can keep a hash table plus one wildcard entry.

   * source port (or flow label) is important only if src is given.

   IMPLEMENTATION.

   We use a two level hash table: The top level is keyed by

   destination address and protocol ID, every bucket contains a list

   of "rsvp sessions", identified by destination address, protocol and

   DPI(="Destination Port ID"): triple (key, mask, offset).

   Every bucket has a smaller hash table keyed by source address

   (cf. RSVP flowspec) and one wildcard entry for wildcard reservations.

   Every bucket is again a list of "RSVP flows", selected by

   source address and SPI(="Source Port ID" here rather than

   "security parameter index"): triple (key, mask, offset).

   NOTE 1. All the packets with IPv6 extension headers (but AH and ESP)

   and all fragmented packets go to the best-effort traffic class.

   NOTE 2. Two "port id"'s seems to be redundant, rfc2207 requires

   only one "Generalized Port Identifier". So that for classic

   ah, esp (and udp,tcp) both *pi should coincide or one of them

   should be wildcard.

   At first sight, this redundancy is just a waste of CPU

   resources. But DPI and SPI add the possibility to assign different

   priorities to GPIs. Look also at note 4 about tunnels below.

   NOTE 3. One complication is the case of tunneled packets.

   We implement it as following: if the first lookup

   matches a special session with "tunnelhdr" value not zero,

   flowid doesn't contain the true flow ID, but the tunnel ID (1...255).

   In this case, we pull tunnelhdr bytes and restart lookup

   with tunnel ID added to the list of keys. Simple and stupid 8)8)

   It's enough for PIMREG and IPIP.

   NOTE 4. Two GPIs make it possible to parse even GRE packets.

   F.e. DPI can select ETH_P_IP (and necessary flags to make

   tunnelhdr correct) in GRE protocol field and SPI matches

   GRE key. Is it not nice? 8)8)

   Well, as result, despite its simplicity, we get a pretty

   powerful classification engine.  */

struct rsvp_head {

	u32			tmap[256/32];

	u32			hgenerator;

	u8			tgenerator;

	struct rsvp_session __rcu *ht[256];

	struct rcu_head		rcu;

};

struct rsvp_session {

	struct rsvp_session __rcu	*next;

	__be32				dst[RSVP_DST_LEN];

	struct tc_rsvp_gpi		dpi;

	u8				protocol;

	u8				tunnelid;

	/* 16 (src,sport) hash slots, and one wildcard source slot */

	struct rsvp_filter __rcu	*ht[16 + 1];

	struct rcu_head			rcu;

};

struct rsvp_filter {

	struct rsvp_filter __rcu	*next;

	__be32				src[RSVP_DST_LEN];

	struct tc_rsvp_gpi		spi;

	u8				tunnelhdr;

	struct tcf_result		res;

	struct tcf_exts			exts;

	u32				handle;

	struct rsvp_session		*sess;

	struct rcu_work			rwork;

};

static inline unsigned int hash_dst(__be32 *dst, u8 protocol, u8 tunnelid)

{

	unsigned int h = (__force __u32)dst[RSVP_DST_LEN - 1];

	h ^= h>>16;

	h ^= h>>8;

	return (h ^ protocol ^ tunnelid) & 0xFF;

}

static inline unsigned int hash_src(__be32 *src)

{

	unsigned int h = (__force __u32)src[RSVP_DST_LEN-1];

	h ^= h>>16;

	h ^= h>>8;

	h ^= h>>4;

	return h & 0xF;

}

#define RSVP_APPLY_RESULT()				\

{							\

	int r = tcf_exts_exec(skb, &f->exts, res);	\

	if (r < 0)					\

		continue;				\

	else if (r > 0)					\

		return r;				\

}

TC_INDIRECT_SCOPE int RSVP_CLS(struct sk_buff *skb, const struct tcf_proto *tp,

			       struct tcf_result *res)

{

	struct rsvp_head *head = rcu_dereference_bh(tp->root);

	struct rsvp_session *s;

	struct rsvp_filter *f;

	unsigned int h1, h2;

	__be32 *dst, *src;

	u8 protocol;

	u8 tunnelid = 0;

	u8 *xprt;

#if RSVP_DST_LEN == 4

	struct ipv6hdr *nhptr;

	if (!pskb_network_may_pull(skb, sizeof(*nhptr)))

		return -1;

	nhptr = ipv6_hdr(skb);

#else

	struct iphdr *nhptr;

	if (!pskb_network_may_pull(skb, sizeof(*nhptr)))

		return -1;

	nhptr = ip_hdr(skb);

#endif

restart:

#if RSVP_DST_LEN == 4

	src = &nhptr->saddr.s6_addr32[0];

	dst = &nhptr->daddr.s6_addr32[0];

	protocol = nhptr->nexthdr;

	xprt = ((u8 *)nhptr) + sizeof(struct ipv6hdr);

#else

	src = &nhptr->saddr;

	dst = &nhptr->daddr;

	protocol = nhptr->protocol;

	xprt = ((u8 *)nhptr) + (nhptr->ihl<<2);

	if (ip_is_fragment(nhptr))

		return -1;

#endif

	h1 = hash_dst(dst, protocol, tunnelid);

	h2 = hash_src(src);

	for (s = rcu_dereference_bh(head->ht[h1]); s;

	     s = rcu_dereference_bh(s->next)) {

		if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN - 1] &&

		    protocol == s->protocol &&

		    !(s->dpi.mask &

		      (*(u32 *)(xprt + s->dpi.offset) ^ s->dpi.key)) &&

#if RSVP_DST_LEN == 4

		    dst[0] == s->dst[0] &&

		    dst[1] == s->dst[1] &&

		    dst[2] == s->dst[2] &&

#endif

		    tunnelid == s->tunnelid) {

			for (f = rcu_dereference_bh(s->ht[h2]); f;

			     f = rcu_dereference_bh(f->next)) {

				if (src[RSVP_DST_LEN-1] == f->src[RSVP_DST_LEN - 1] &&

				    !(f->spi.mask & (*(u32 *)(xprt + f->spi.offset) ^ f->spi.key))

#if RSVP_DST_LEN == 4

				    &&

				    src[0] == f->src[0] &&

				    src[1] == f->src[1] &&

				    src[2] == f->src[2]

#endif

				    ) {

					*res = f->res;

					RSVP_APPLY_RESULT();

matched:

					if (f->tunnelhdr == 0)

						return 0;

					tunnelid = f->res.classid;

					nhptr = (void *)(xprt + f->tunnelhdr - sizeof(*nhptr));

					goto restart;

				}

			}

			/* And wildcard bucket... */

			for (f = rcu_dereference_bh(s->ht[16]); f;

			     f = rcu_dereference_bh(f->next)) {

				*res = f->res;

				RSVP_APPLY_RESULT();

				goto matched;

			}

			return -1;

		}

	}

	return -1;

}

static void rsvp_replace(struct tcf_proto *tp, struct rsvp_filter *n, u32 h)

{

	struct rsvp_head *head = rtnl_dereference(tp->root);

	struct rsvp_session *s;

	struct rsvp_filter __rcu **ins;

	struct rsvp_filter *pins;

	unsigned int h1 = h & 0xFF;

	unsigned int h2 = (h >> 8) & 0xFF;

	for (s = rtnl_dereference(head->ht[h1]); s;

	     s = rtnl_dereference(s->next)) {

		for (ins = &s->ht[h2], pins = rtnl_dereference(*ins); ;

		     ins = &pins->next, pins = rtnl_dereference(*ins)) {

			if (pins->handle == h) {

				RCU_INIT_POINTER(n->next, pins->next);

				rcu_assign_pointer(*ins, n);

				return;

			}

		}

	}

	/* Something went wrong if we are trying to replace a non-existent

	 * node. Mind as well halt instead of silently failing.

	 */

	BUG_ON(1);

}

static void *rsvp_get(struct tcf_proto *tp, u32 handle)

{

	struct rsvp_head *head = rtnl_dereference(tp->root);

	struct rsvp_session *s;

	struct rsvp_filter *f;

	unsigned int h1 = handle & 0xFF;

	unsigned int h2 = (handle >> 8) & 0xFF;

	if (h2 > 16)

		return NULL;

	for (s = rtnl_dereference(head->ht[h1]); s;

	     s = rtnl_dereference(s->next)) {

		for (f = rtnl_dereference(s->ht[h2]); f;

		     f = rtnl_dereference(f->next)) {

			if (f->handle == handle)

				return f;

		}

	}

	return NULL;

}

static int rsvp_init(struct tcf_proto *tp)

{

	struct rsvp_head *data;

	data = kzalloc(sizeof(struct rsvp_head), GFP_KERNEL);

	if (data) {

		rcu_assign_pointer(tp->root, data);

		return 0;

	}

	return -ENOBUFS;

}

static void __rsvp_delete_filter(struct rsvp_filter *f)

{

	tcf_exts_destroy(&f->exts);

	tcf_exts_put_net(&f->exts);

	kfree(f);

}

static void rsvp_delete_filter_work(struct work_struct *work)

{

	struct rsvp_filter *f = container_of(to_rcu_work(work),

					     struct rsvp_filter,

					     rwork);

	rtnl_lock();

	__rsvp_delete_filter(f);

	rtnl_unlock();

}

static void rsvp_delete_filter(struct tcf_proto *tp, struct rsvp_filter *f)

{

	tcf_unbind_filter(tp, &f->res);

	/* all classifiers are required to call tcf_exts_destroy() after rcu

	 * grace period, since converted-to-rcu actions are relying on that

	 * in cleanup() callback

	 */

	if (tcf_exts_get_net(&f->exts))

		tcf_queue_work(&f->rwork, rsvp_delete_filter_work);

	else

		__rsvp_delete_filter(f);

}

static void rsvp_destroy(struct tcf_proto *tp, bool rtnl_held,

			 struct netlink_ext_ack *extack)

{

	struct rsvp_head *data = rtnl_dereference(tp->root);

	int h1, h2;

	if (data == NULL)

		return;

	for (h1 = 0; h1 < 256; h1++) {

		struct rsvp_session *s;

		while ((s = rtnl_dereference(data->ht[h1])) != NULL) {

			RCU_INIT_POINTER(data->ht[h1], s->next);

			for (h2 = 0; h2 <= 16; h2++) {

				struct rsvp_filter *f;

				while ((f = rtnl_dereference(s->ht[h2])) != NULL) {

					rcu_assign_pointer(s->ht[h2], f->next);

					rsvp_delete_filter(tp, f);

				}

			}

			kfree_rcu(s, rcu);

		}

	}

	kfree_rcu(data, rcu);

}

static int rsvp_delete(struct tcf_proto *tp, void *arg, bool *last,

		       bool rtnl_held, struct netlink_ext_ack *extack)

{

	struct rsvp_head *head = rtnl_dereference(tp->root);

	struct rsvp_filter *nfp, *f = arg;

	struct rsvp_filter __rcu **fp;

	unsigned int h = f->handle;

	struct rsvp_session __rcu **sp;

	struct rsvp_session *nsp, *s = f->sess;

	int i, h1;

	fp = &s->ht[(h >> 8) & 0xFF];

	for (nfp = rtnl_dereference(*fp); nfp;

	     fp = &nfp->next, nfp = rtnl_dereference(*fp)) {

		if (nfp == f) {

			RCU_INIT_POINTER(*fp, f->next);

			rsvp_delete_filter(tp, f);

			/* Strip tree */

			for (i = 0; i <= 16; i++)

				if (s->ht[i])

					goto out;

			/* OK, session has no flows */

			sp = &head->ht[h & 0xFF];

			for (nsp = rtnl_dereference(*sp); nsp;

			     sp = &nsp->next, nsp = rtnl_dereference(*sp)) {

				if (nsp == s) {

					RCU_INIT_POINTER(*sp, s->next);

					kfree_rcu(s, rcu);

					goto out;

				}

			}

			break;

		}

	}

out:

	*last = true;

	for (h1 = 0; h1 < 256; h1++) {

		if (rcu_access_pointer(head->ht[h1])) {

			*last = false;

			break;

		}

	}

	return 0;

}

static unsigned int gen_handle(struct tcf_proto *tp, unsigned salt)

{

	struct rsvp_head *data = rtnl_dereference(tp->root);

	int i = 0xFFFF;

	while (i-- > 0) {

		u32 h;

		if ((data->hgenerator += 0x10000) == 0)

			data->hgenerator = 0x10000;

		h = data->hgenerator|salt;

		if (!rsvp_get(tp, h))

			return h;

	}

	return 0;

}

static int tunnel_bts(struct rsvp_head *data)

{

	int n = data->tgenerator >> 5;

	u32 b = 1 << (data->tgenerator & 0x1F);

	if (data->tmap[n] & b)

		return 0;

	data->tmap[n] |= b;

	return 1;

}

static void tunnel_recycle(struct rsvp_head *data)

{

	struct rsvp_session __rcu **sht = data->ht;

	u32 tmap[256/32];

	int h1, h2;

	memset(tmap, 0, sizeof(tmap));

	for (h1 = 0; h1 < 256; h1++) {

		struct rsvp_session *s;

		for (s = rtnl_dereference(sht[h1]); s;

		     s = rtnl_dereference(s->next)) {

			for (h2 = 0; h2 <= 16; h2++) {

				struct rsvp_filter *f;

				for (f = rtnl_dereference(s->ht[h2]); f;

				     f = rtnl_dereference(f->next)) {

					if (f->tunnelhdr == 0)

						continue;

					data->tgenerator = f->res.classid;

					tunnel_bts(data);

				}

			}

		}

	}

	memcpy(data->tmap, tmap, sizeof(tmap));

}

static u32 gen_tunnel(struct rsvp_head *data)

{

	int i, k;

	for (k = 0; k < 2; k++) {

		for (i = 255; i > 0; i--) {

			if (++data->tgenerator == 0)

				data->tgenerator = 1;

			if (tunnel_bts(data))

				return data->tgenerator;

		}

		tunnel_recycle(data);

	}

	return 0;

}

static const struct nla_policy rsvp_policy[TCA_RSVP_MAX + 1] = {

	[TCA_RSVP_CLASSID]	= { .type = NLA_U32 },

	[TCA_RSVP_DST]		= { .len = RSVP_DST_LEN * sizeof(u32) },

	[TCA_RSVP_SRC]		= { .len = RSVP_DST_LEN * sizeof(u32) },

	[TCA_RSVP_PINFO]	= { .len = sizeof(struct tc_rsvp_pinfo) },

};

static int rsvp_change(struct net *net, struct sk_buff *in_skb,

		       struct tcf_proto *tp, unsigned long base,

		       u32 handle, struct nlattr **tca,

		       void **arg, u32 flags,

		       struct netlink_ext_ack *extack)

{

	struct rsvp_head *data = rtnl_dereference(tp->root);

	struct rsvp_filter *f, *nfp;

	struct rsvp_filter __rcu **fp;

	struct rsvp_session *nsp, *s;

	struct rsvp_session __rcu **sp;

	struct tc_rsvp_pinfo *pinfo = NULL;

	struct nlattr *opt = tca[TCA_OPTIONS];

	struct nlattr *tb[TCA_RSVP_MAX + 1];

	struct tcf_exts e;

	unsigned int h1, h2;

	__be32 *dst;

	int err;

	if (opt == NULL)

		return handle ? -EINVAL : 0;

	err = nla_parse_nested_deprecated(tb, TCA_RSVP_MAX, opt, rsvp_policy,

					  NULL);

	if (err < 0)

		return err;

	err = tcf_exts_init(&e, net, TCA_RSVP_ACT, TCA_RSVP_POLICE);

	if (err < 0)

		return err;

	err = tcf_exts_validate(net, tp, tb, tca[TCA_RATE], &e, flags,

				extack);

	if (err < 0)