License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 08:07:57 -06:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifndef __NET_PKT_CLS_H
|
|
|
|
#define __NET_PKT_CLS_H
|
|
|
|
|
|
|
|
#include <linux/pkt_cls.h>
|
2017-10-26 19:24:28 -06:00
|
|
|
#include <linux/workqueue.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <net/sch_generic.h>
|
|
|
|
#include <net/act_api.h>
|
|
|
|
|
|
|
|
/* Basic packet classifier frontend definitions. */
|
|
|
|
|
2009-11-02 20:26:03 -07:00
|
|
|
struct tcf_walker {
|
2005-04-16 16:20:36 -06:00
|
|
|
int stop;
|
|
|
|
int skip;
|
|
|
|
int count;
|
2017-08-04 22:31:43 -06:00
|
|
|
int (*fn)(struct tcf_proto *, void *node, struct tcf_walker *);
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2013-07-30 23:47:13 -06:00
|
|
|
int register_tcf_proto_ops(struct tcf_proto_ops *ops);
|
|
|
|
int unregister_tcf_proto_ops(struct tcf_proto_ops *ops);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-10-19 07:50:29 -06:00
|
|
|
enum tcf_block_binder_type {
|
|
|
|
TCF_BLOCK_BINDER_TYPE_UNSPEC,
|
2017-10-19 07:50:30 -06:00
|
|
|
TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS,
|
|
|
|
TCF_BLOCK_BINDER_TYPE_CLSACT_EGRESS,
|
2017-10-19 07:50:29 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct tcf_block_ext_info {
|
|
|
|
enum tcf_block_binder_type binder_type;
|
2017-11-03 04:46:24 -06:00
|
|
|
tcf_chain_head_change_t *chain_head_change;
|
|
|
|
void *chain_head_change_priv;
|
2018-01-17 03:46:46 -07:00
|
|
|
u32 block_index;
|
2017-10-19 07:50:29 -06:00
|
|
|
};
|
|
|
|
|
2017-10-19 07:50:31 -06:00
|
|
|
struct tcf_block_cb;
|
2017-10-26 19:24:28 -06:00
|
|
|
bool tcf_queue_work(struct work_struct *work);
|
2017-10-19 07:50:31 -06:00
|
|
|
|
2017-02-15 03:57:50 -07:00
|
|
|
#ifdef CONFIG_NET_CLS
|
2017-05-23 10:42:37 -06:00
|
|
|
struct tcf_chain *tcf_chain_get(struct tcf_block *block, u32 chain_index,
|
|
|
|
bool create);
|
2017-05-17 03:08:01 -06:00
|
|
|
void tcf_chain_put(struct tcf_chain *chain);
|
2018-01-17 03:46:48 -07:00
|
|
|
void tcf_block_netif_keep_dst(struct tcf_block *block);
|
2017-05-17 03:07:55 -06:00
|
|
|
int tcf_block_get(struct tcf_block **p_block,
|
2017-12-20 10:35:19 -07:00
|
|
|
struct tcf_proto __rcu **p_filter_chain, struct Qdisc *q,
|
|
|
|
struct netlink_ext_ack *extack);
|
2017-11-03 04:46:24 -06:00
|
|
|
int tcf_block_get_ext(struct tcf_block **p_block, struct Qdisc *q,
|
2017-12-20 10:35:19 -07:00
|
|
|
struct tcf_block_ext_info *ei,
|
|
|
|
struct netlink_ext_ack *extack);
|
2017-05-17 03:07:55 -06:00
|
|
|
void tcf_block_put(struct tcf_block *block);
|
2017-11-03 04:46:24 -06:00
|
|
|
void tcf_block_put_ext(struct tcf_block *block, struct Qdisc *q,
|
2017-10-19 07:50:29 -06:00
|
|
|
struct tcf_block_ext_info *ei);
|
2017-10-13 06:00:59 -06:00
|
|
|
|
2018-01-17 03:46:46 -07:00
|
|
|
static inline bool tcf_block_shared(struct tcf_block *block)
|
|
|
|
{
|
|
|
|
return block->index;
|
|
|
|
}
|
|
|
|
|
2017-10-13 06:00:59 -06:00
|
|
|
static inline struct Qdisc *tcf_block_q(struct tcf_block *block)
|
|
|
|
{
|
2018-01-17 03:46:46 -07:00
|
|
|
WARN_ON(tcf_block_shared(block));
|
2017-10-13 06:00:59 -06:00
|
|
|
return block->q;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct net_device *tcf_block_dev(struct tcf_block *block)
|
|
|
|
{
|
|
|
|
return tcf_block_q(block)->dev_queue->dev;
|
|
|
|
}
|
|
|
|
|
2017-10-19 07:50:31 -06:00
|
|
|
void *tcf_block_cb_priv(struct tcf_block_cb *block_cb);
|
|
|
|
struct tcf_block_cb *tcf_block_cb_lookup(struct tcf_block *block,
|
|
|
|
tc_setup_cb_t *cb, void *cb_ident);
|
|
|
|
void tcf_block_cb_incref(struct tcf_block_cb *block_cb);
|
|
|
|
unsigned int tcf_block_cb_decref(struct tcf_block_cb *block_cb);
|
|
|
|
struct tcf_block_cb *__tcf_block_cb_register(struct tcf_block *block,
|
|
|
|
tc_setup_cb_t *cb, void *cb_ident,
|
|
|
|
void *cb_priv);
|
|
|
|
int tcf_block_cb_register(struct tcf_block *block,
|
|
|
|
tc_setup_cb_t *cb, void *cb_ident,
|
|
|
|
void *cb_priv);
|
|
|
|
void __tcf_block_cb_unregister(struct tcf_block_cb *block_cb);
|
|
|
|
void tcf_block_cb_unregister(struct tcf_block *block,
|
|
|
|
tc_setup_cb_t *cb, void *cb_ident);
|
|
|
|
|
2017-05-17 03:07:54 -06:00
|
|
|
int tcf_classify(struct sk_buff *skb, const struct tcf_proto *tp,
|
|
|
|
struct tcf_result *res, bool compat_mode);
|
|
|
|
|
2017-02-15 03:57:50 -07:00
|
|
|
#else
|
2017-05-17 03:07:55 -06:00
|
|
|
static inline
|
|
|
|
int tcf_block_get(struct tcf_block **p_block,
|
2017-12-22 08:52:05 -07:00
|
|
|
struct tcf_proto __rcu **p_filter_chain, struct Qdisc *q,
|
|
|
|
struct netlink_ext_ack *extack)
|
2017-05-17 03:07:55 -06:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-10-19 07:50:29 -06:00
|
|
|
static inline
|
2017-11-03 04:46:24 -06:00
|
|
|
int tcf_block_get_ext(struct tcf_block **p_block, struct Qdisc *q,
|
2018-01-03 18:30:45 -07:00
|
|
|
struct tcf_block_ext_info *ei,
|
|
|
|
struct netlink_ext_ack *extack)
|
2017-10-19 07:50:29 -06:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-17 03:07:55 -06:00
|
|
|
static inline void tcf_block_put(struct tcf_block *block)
|
2017-02-15 03:57:50 -07:00
|
|
|
{
|
|
|
|
}
|
2017-05-17 03:07:54 -06:00
|
|
|
|
2017-10-19 07:50:29 -06:00
|
|
|
static inline
|
2017-11-03 04:46:24 -06:00
|
|
|
void tcf_block_put_ext(struct tcf_block *block, struct Qdisc *q,
|
2017-10-19 07:50:29 -06:00
|
|
|
struct tcf_block_ext_info *ei)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-10-13 06:00:59 -06:00
|
|
|
static inline struct Qdisc *tcf_block_q(struct tcf_block *block)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct net_device *tcf_block_dev(struct tcf_block *block)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-10-19 07:50:31 -06:00
|
|
|
static inline
|
|
|
|
int tc_setup_cb_block_register(struct tcf_block *block, tc_setup_cb_t *cb,
|
|
|
|
void *cb_priv)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
void tc_setup_cb_block_unregister(struct tcf_block *block, tc_setup_cb_t *cb,
|
|
|
|
void *cb_priv)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
void *tcf_block_cb_priv(struct tcf_block_cb *block_cb)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
struct tcf_block_cb *tcf_block_cb_lookup(struct tcf_block *block,
|
|
|
|
tc_setup_cb_t *cb, void *cb_ident)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
void tcf_block_cb_incref(struct tcf_block_cb *block_cb)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
unsigned int tcf_block_cb_decref(struct tcf_block_cb *block_cb)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
struct tcf_block_cb *__tcf_block_cb_register(struct tcf_block *block,
|
|
|
|
tc_setup_cb_t *cb, void *cb_ident,
|
|
|
|
void *cb_priv)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
int tcf_block_cb_register(struct tcf_block *block,
|
|
|
|
tc_setup_cb_t *cb, void *cb_ident,
|
|
|
|
void *cb_priv)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
void __tcf_block_cb_unregister(struct tcf_block_cb *block_cb)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
void tcf_block_cb_unregister(struct tcf_block *block,
|
|
|
|
tc_setup_cb_t *cb, void *cb_ident)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-05-17 03:07:54 -06:00
|
|
|
static inline int tcf_classify(struct sk_buff *skb, const struct tcf_proto *tp,
|
|
|
|
struct tcf_result *res, bool compat_mode)
|
|
|
|
{
|
|
|
|
return TC_ACT_UNSPEC;
|
|
|
|
}
|
2017-02-15 03:57:50 -07:00
|
|
|
#endif
|
2017-02-09 06:38:56 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline unsigned long
|
|
|
|
__cls_set_class(unsigned long *clp, unsigned long cl)
|
|
|
|
{
|
2014-09-30 17:07:24 -06:00
|
|
|
return xchg(clp, cl);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long
|
2017-10-13 06:01:00 -06:00
|
|
|
cls_set_class(struct Qdisc *q, unsigned long *clp, unsigned long cl)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
unsigned long old_cl;
|
2017-10-13 06:01:00 -06:00
|
|
|
|
|
|
|
sch_tree_lock(q);
|
2005-04-16 16:20:36 -06:00
|
|
|
old_cl = __cls_set_class(clp, cl);
|
2017-10-13 06:01:00 -06:00
|
|
|
sch_tree_unlock(q);
|
2005-04-16 16:20:36 -06:00
|
|
|
return old_cl;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
tcf_bind_filter(struct tcf_proto *tp, struct tcf_result *r, unsigned long base)
|
|
|
|
{
|
2017-10-13 06:01:00 -06:00
|
|
|
struct Qdisc *q = tp->chain->block->q;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long cl;
|
|
|
|
|
2017-10-13 06:01:00 -06:00
|
|
|
/* Check q as it is not set for shared blocks. In that case,
|
|
|
|
* setting class is not supported.
|
|
|
|
*/
|
|
|
|
if (!q)
|
|
|
|
return;
|
|
|
|
cl = q->ops->cl_ops->bind_tcf(q, base, r->classid);
|
|
|
|
cl = cls_set_class(q, &r->class, cl);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (cl)
|
2017-10-13 06:01:00 -06:00
|
|
|
q->ops->cl_ops->unbind_tcf(q, cl);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
tcf_unbind_filter(struct tcf_proto *tp, struct tcf_result *r)
|
|
|
|
{
|
2017-10-13 06:01:00 -06:00
|
|
|
struct Qdisc *q = tp->chain->block->q;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long cl;
|
|
|
|
|
2017-10-13 06:01:00 -06:00
|
|
|
if (!q)
|
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
if ((cl = __cls_set_class(&r->class, 0)) != 0)
|
2017-10-13 06:01:00 -06:00
|
|
|
q->ops->cl_ops->unbind_tcf(q, cl);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-11-02 20:26:03 -07:00
|
|
|
struct tcf_exts {
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_NET_CLS_ACT
|
2013-12-15 21:15:05 -07:00
|
|
|
__u32 type; /* for backward compat(TCA_OLD_COMPAT) */
|
2016-08-13 23:35:00 -06:00
|
|
|
int nr_actions;
|
|
|
|
struct tc_action **actions;
|
2017-11-06 14:47:19 -07:00
|
|
|
struct net *net;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2013-12-15 21:15:07 -07:00
|
|
|
/* Map to export classifier specific extension TLV types to the
|
|
|
|
* generic extensions API. Unsupported extensions must be set to 0.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
int action;
|
|
|
|
int police;
|
|
|
|
};
|
|
|
|
|
2016-08-19 13:36:54 -06:00
|
|
|
static inline int tcf_exts_init(struct tcf_exts *exts, int action, int police)
|
2013-12-15 21:15:05 -07:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_NET_CLS_ACT
|
2013-12-15 21:15:07 -07:00
|
|
|
exts->type = 0;
|
2016-08-13 23:35:00 -06:00
|
|
|
exts->nr_actions = 0;
|
2017-11-06 14:47:19 -07:00
|
|
|
exts->net = NULL;
|
2016-08-13 23:35:00 -06:00
|
|
|
exts->actions = kcalloc(TCA_ACT_MAX_PRIO, sizeof(struct tc_action *),
|
|
|
|
GFP_KERNEL);
|
2016-08-19 13:36:54 -06:00
|
|
|
if (!exts->actions)
|
|
|
|
return -ENOMEM;
|
2013-12-15 21:15:05 -07:00
|
|
|
#endif
|
2013-12-15 21:15:07 -07:00
|
|
|
exts->action = action;
|
|
|
|
exts->police = police;
|
2016-08-19 13:36:54 -06:00
|
|
|
return 0;
|
2013-12-15 21:15:05 -07:00
|
|
|
}
|
|
|
|
|
2017-11-06 14:47:19 -07:00
|
|
|
/* Return false if the netns is being destroyed in cleanup_net(). Callers
|
|
|
|
* need to do cleanup synchronously in this case, otherwise may race with
|
|
|
|
* tc_action_net_exit(). Return true for other cases.
|
|
|
|
*/
|
|
|
|
static inline bool tcf_exts_get_net(struct tcf_exts *exts)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_NET_CLS_ACT
|
|
|
|
exts->net = maybe_get_net(exts->net);
|
|
|
|
return exts->net != NULL;
|
|
|
|
#else
|
|
|
|
return true;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void tcf_exts_put_net(struct tcf_exts *exts)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_NET_CLS_ACT
|
|
|
|
if (exts->net)
|
|
|
|
put_net(exts->net);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-08-13 23:35:00 -06:00
|
|
|
static inline void tcf_exts_to_list(const struct tcf_exts *exts,
|
|
|
|
struct list_head *actions)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_NET_CLS_ACT
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < exts->nr_actions; i++) {
|
|
|
|
struct tc_action *a = exts->actions[i];
|
|
|
|
|
2016-09-27 02:09:51 -06:00
|
|
|
list_add_tail(&a->list, actions);
|
2016-08-13 23:35:00 -06:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2017-05-31 09:06:43 -06:00
|
|
|
static inline void
|
|
|
|
tcf_exts_stats_update(const struct tcf_exts *exts,
|
|
|
|
u64 bytes, u64 packets, u64 lastuse)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_NET_CLS_ACT
|
|
|
|
int i;
|
|
|
|
|
|
|
|
preempt_disable();
|
|
|
|
|
|
|
|
for (i = 0; i < exts->nr_actions; i++) {
|
|
|
|
struct tc_action *a = exts->actions[i];
|
|
|
|
|
|
|
|
tcf_action_stats_update(a, bytes, packets, lastuse);
|
|
|
|
}
|
|
|
|
|
|
|
|
preempt_enable();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2017-08-04 06:28:58 -06:00
|
|
|
/**
|
|
|
|
* tcf_exts_has_actions - check if at least one action is present
|
|
|
|
* @exts: tc filter extensions handle
|
|
|
|
*
|
|
|
|
* Returns true if at least one action is present.
|
|
|
|
*/
|
|
|
|
static inline bool tcf_exts_has_actions(struct tcf_exts *exts)
|
|
|
|
{
|
2016-08-13 23:34:59 -06:00
|
|
|
#ifdef CONFIG_NET_CLS_ACT
|
2017-08-04 06:28:58 -06:00
|
|
|
return exts->nr_actions;
|
|
|
|
#else
|
|
|
|
return false;
|
|
|
|
#endif
|
|
|
|
}
|
2016-08-13 23:34:59 -06:00
|
|
|
|
2017-08-04 06:28:58 -06:00
|
|
|
/**
|
|
|
|
* tcf_exts_has_one_action - check if exactly one action is present
|
|
|
|
* @exts: tc filter extensions handle
|
|
|
|
*
|
|
|
|
* Returns true if exactly one action is present.
|
|
|
|
*/
|
|
|
|
static inline bool tcf_exts_has_one_action(struct tcf_exts *exts)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_NET_CLS_ACT
|
|
|
|
return exts->nr_actions == 1;
|
|
|
|
#else
|
|
|
|
return false;
|
|
|
|
#endif
|
|
|
|
}
|
2016-08-13 23:34:59 -06:00
|
|
|
|
2017-08-04 06:28:59 -06:00
|
|
|
/**
|
|
|
|
* tcf_exts_exec - execute tc filter extensions
|
|
|
|
* @skb: socket buffer
|
|
|
|
* @exts: tc filter extensions handle
|
|
|
|
* @res: desired result
|
|
|
|
*
|
2017-08-04 06:29:01 -06:00
|
|
|
* Executes all configured extensions. Returns TC_ACT_OK on a normal execution,
|
2017-08-04 06:28:59 -06:00
|
|
|
* a negative number if the filter must be considered unmatched or
|
|
|
|
* a positive action code (TC_ACT_*) which must be returned to the
|
|
|
|
* underlying layer.
|
|
|
|
*/
|
|
|
|
static inline int
|
|
|
|
tcf_exts_exec(struct sk_buff *skb, struct tcf_exts *exts,
|
|
|
|
struct tcf_result *res)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_NET_CLS_ACT
|
2017-08-04 06:29:02 -06:00
|
|
|
return tcf_action_exec(skb, exts->actions, exts->nr_actions, res);
|
2017-08-04 06:28:59 -06:00
|
|
|
#endif
|
2017-08-04 06:29:01 -06:00
|
|
|
return TC_ACT_OK;
|
2017-08-04 06:28:59 -06:00
|
|
|
}
|
|
|
|
|
2013-07-30 23:47:13 -06:00
|
|
|
int tcf_exts_validate(struct net *net, struct tcf_proto *tp,
|
|
|
|
struct nlattr **tb, struct nlattr *rate_tlv,
|
2018-01-18 09:20:52 -07:00
|
|
|
struct tcf_exts *exts, bool ovr,
|
|
|
|
struct netlink_ext_ack *extack);
|
2014-09-25 11:26:37 -06:00
|
|
|
void tcf_exts_destroy(struct tcf_exts *exts);
|
2017-08-04 06:29:15 -06:00
|
|
|
void tcf_exts_change(struct tcf_exts *dst, struct tcf_exts *src);
|
2013-12-15 21:15:07 -07:00
|
|
|
int tcf_exts_dump(struct sk_buff *skb, struct tcf_exts *exts);
|
|
|
|
int tcf_exts_dump_stats(struct sk_buff *skb, struct tcf_exts *exts);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* struct tcf_pkt_info - packet information
|
|
|
|
*/
|
2009-11-02 20:26:03 -07:00
|
|
|
struct tcf_pkt_info {
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned char * ptr;
|
|
|
|
int nexthdr;
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_EMATCH
|
|
|
|
|
|
|
|
struct tcf_ematch_ops;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct tcf_ematch - extended match (ematch)
|
|
|
|
*
|
|
|
|
* @matchid: identifier to allow userspace to reidentify a match
|
|
|
|
* @flags: flags specifying attributes and the relation to other matches
|
|
|
|
* @ops: the operations lookup table of the corresponding ematch module
|
|
|
|
* @datalen: length of the ematch specific configuration data
|
|
|
|
* @data: ematch specific data
|
|
|
|
*/
|
2009-11-02 20:26:03 -07:00
|
|
|
struct tcf_ematch {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct tcf_ematch_ops * ops;
|
|
|
|
unsigned long data;
|
|
|
|
unsigned int datalen;
|
|
|
|
u16 matchid;
|
|
|
|
u16 flags;
|
2014-10-05 22:27:53 -06:00
|
|
|
struct net *net;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static inline int tcf_em_is_container(struct tcf_ematch *em)
|
|
|
|
{
|
|
|
|
return !em->ops;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int tcf_em_is_simple(struct tcf_ematch *em)
|
|
|
|
{
|
|
|
|
return em->flags & TCF_EM_SIMPLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int tcf_em_is_inverted(struct tcf_ematch *em)
|
|
|
|
{
|
|
|
|
return em->flags & TCF_EM_INVERT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int tcf_em_last_match(struct tcf_ematch *em)
|
|
|
|
{
|
|
|
|
return (em->flags & TCF_EM_REL_MASK) == TCF_EM_REL_END;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int tcf_em_early_end(struct tcf_ematch *em, int result)
|
|
|
|
{
|
|
|
|
if (tcf_em_last_match(em))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (result == 0 && em->flags & TCF_EM_REL_AND)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (result != 0 && em->flags & TCF_EM_REL_OR)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct tcf_ematch_tree - ematch tree handle
|
|
|
|
*
|
|
|
|
* @hdr: ematch tree header supplied by userspace
|
|
|
|
* @matches: array of ematches
|
|
|
|
*/
|
2009-11-02 20:26:03 -07:00
|
|
|
struct tcf_ematch_tree {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct tcf_ematch_tree_hdr hdr;
|
|
|
|
struct tcf_ematch * matches;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct tcf_ematch_ops - ematch module operations
|
|
|
|
*
|
|
|
|
* @kind: identifier (kind) of this ematch module
|
|
|
|
* @datalen: length of expected configuration data (optional)
|
|
|
|
* @change: called during validation (optional)
|
|
|
|
* @match: called during ematch tree evaluation, must return 1/0
|
|
|
|
* @destroy: called during destroyage (optional)
|
|
|
|
* @dump: called during dumping process (optional)
|
|
|
|
* @owner: owner, must be set to THIS_MODULE
|
|
|
|
* @link: link to previous/next ematch module (internal use)
|
|
|
|
*/
|
2009-11-02 20:26:03 -07:00
|
|
|
struct tcf_ematch_ops {
|
2005-04-16 16:20:36 -06:00
|
|
|
int kind;
|
|
|
|
int datalen;
|
2014-10-05 22:27:53 -06:00
|
|
|
int (*change)(struct net *net, void *,
|
2005-04-16 16:20:36 -06:00
|
|
|
int, struct tcf_ematch *);
|
|
|
|
int (*match)(struct sk_buff *, struct tcf_ematch *,
|
|
|
|
struct tcf_pkt_info *);
|
2014-10-05 22:27:53 -06:00
|
|
|
void (*destroy)(struct tcf_ematch *);
|
2005-04-16 16:20:36 -06:00
|
|
|
int (*dump)(struct sk_buff *, struct tcf_ematch *);
|
|
|
|
struct module *owner;
|
|
|
|
struct list_head link;
|
|
|
|
};
|
|
|
|
|
2013-07-30 23:47:13 -06:00
|
|
|
int tcf_em_register(struct tcf_ematch_ops *);
|
|
|
|
void tcf_em_unregister(struct tcf_ematch_ops *);
|
|
|
|
int tcf_em_tree_validate(struct tcf_proto *, struct nlattr *,
|
|
|
|
struct tcf_ematch_tree *);
|
2014-10-05 22:27:53 -06:00
|
|
|
void tcf_em_tree_destroy(struct tcf_ematch_tree *);
|
2013-07-30 23:47:13 -06:00
|
|
|
int tcf_em_tree_dump(struct sk_buff *, struct tcf_ematch_tree *, int);
|
|
|
|
int __tcf_em_tree_match(struct sk_buff *, struct tcf_ematch_tree *,
|
|
|
|
struct tcf_pkt_info *);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* tcf_em_tree_match - evaulate an ematch tree
|
|
|
|
*
|
|
|
|
* @skb: socket buffer of the packet in question
|
|
|
|
* @tree: ematch tree to be used for evaluation
|
|
|
|
* @info: packet information examined by classifier
|
|
|
|
*
|
|
|
|
* This function matches @skb against the ematch tree in @tree by going
|
|
|
|
* through all ematches respecting their logic relations returning
|
|
|
|
* as soon as the result is obvious.
|
|
|
|
*
|
|
|
|
* Returns 1 if the ematch tree as-one matches, no ematches are configured
|
|
|
|
* or ematch is not enabled in the kernel, otherwise 0 is returned.
|
|
|
|
*/
|
|
|
|
static inline int tcf_em_tree_match(struct sk_buff *skb,
|
|
|
|
struct tcf_ematch_tree *tree,
|
|
|
|
struct tcf_pkt_info *info)
|
|
|
|
{
|
|
|
|
if (tree->hdr.nmatches)
|
|
|
|
return __tcf_em_tree_match(skb, tree, info);
|
|
|
|
else
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-07-11 20:46:26 -06:00
|
|
|
#define MODULE_ALIAS_TCF_EMATCH(kind) MODULE_ALIAS("ematch-kind-" __stringify(kind))
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#else /* CONFIG_NET_EMATCH */
|
|
|
|
|
2009-11-02 20:26:03 -07:00
|
|
|
struct tcf_ematch_tree {
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
#define tcf_em_tree_validate(tp, tb, t) ((void)(t), 0)
|
2014-10-05 22:27:53 -06:00
|
|
|
#define tcf_em_tree_destroy(t) do { (void)(t); } while(0)
|
2005-04-16 16:20:36 -06:00
|
|
|
#define tcf_em_tree_dump(skb, t, tlv) (0)
|
|
|
|
#define tcf_em_tree_match(skb, t, info) ((void)(info), 1)
|
|
|
|
|
|
|
|
#endif /* CONFIG_NET_EMATCH */
|
|
|
|
|
|
|
|
static inline unsigned char * tcf_get_base_ptr(struct sk_buff *skb, int layer)
|
|
|
|
{
|
|
|
|
switch (layer) {
|
|
|
|
case TCF_LAYER_LINK:
|
2018-01-18 03:32:36 -07:00
|
|
|
return skb_mac_header(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
case TCF_LAYER_NETWORK:
|
2007-04-10 21:50:43 -06:00
|
|
|
return skb_network_header(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
case TCF_LAYER_TRANSPORT:
|
2007-04-25 19:04:18 -06:00
|
|
|
return skb_transport_header(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-04-20 23:47:35 -06:00
|
|
|
static inline int tcf_valid_offset(const struct sk_buff *skb,
|
|
|
|
const unsigned char *ptr, const int len)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-12-21 13:43:16 -07:00
|
|
|
return likely((ptr + len) <= skb_tail_pointer(skb) &&
|
|
|
|
ptr >= skb->head &&
|
|
|
|
(ptr <= (ptr + len)));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_CLS_IND
|
2007-12-04 02:15:45 -07:00
|
|
|
#include <net/net_namespace.h>
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline int
|
2018-01-18 09:20:54 -07:00
|
|
|
tcf_change_indev(struct net *net, struct nlattr *indev_tlv,
|
|
|
|
struct netlink_ext_ack *extack)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-01-09 17:14:02 -07:00
|
|
|
char indev[IFNAMSIZ];
|
|
|
|
struct net_device *dev;
|
|
|
|
|
2018-01-18 09:20:54 -07:00
|
|
|
if (nla_strlcpy(indev, indev_tlv, IFNAMSIZ) >= IFNAMSIZ) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Interface name too long");
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
2018-01-18 09:20:54 -07:00
|
|
|
}
|
2014-01-09 17:14:02 -07:00
|
|
|
dev = __dev_get_by_name(net, indev);
|
|
|
|
if (!dev)
|
|
|
|
return -ENODEV;
|
|
|
|
return dev->ifindex;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2014-01-09 17:14:02 -07:00
|
|
|
static inline bool
|
|
|
|
tcf_match_indev(struct sk_buff *skb, int ifindex)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-01-09 17:14:02 -07:00
|
|
|
if (!ifindex)
|
|
|
|
return true;
|
|
|
|
if (!skb->skb_iif)
|
|
|
|
return false;
|
|
|
|
return ifindex == skb->skb_iif;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_NET_CLS_IND */
|
|
|
|
|
2017-10-19 07:50:32 -06:00
|
|
|
int tc_setup_cb_call(struct tcf_block *block, struct tcf_exts *exts,
|
|
|
|
enum tc_setup_type type, void *type_data, bool err_stop);
|
2017-10-11 01:41:09 -06:00
|
|
|
|
2017-10-19 07:50:29 -06:00
|
|
|
enum tc_block_command {
|
|
|
|
TC_BLOCK_BIND,
|
|
|
|
TC_BLOCK_UNBIND,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct tc_block_offload {
|
|
|
|
enum tc_block_command command;
|
|
|
|
enum tcf_block_binder_type binder_type;
|
|
|
|
struct tcf_block *block;
|
|
|
|
};
|
|
|
|
|
2017-08-07 02:15:29 -06:00
|
|
|
struct tc_cls_common_offload {
|
|
|
|
u32 chain_index;
|
|
|
|
__be16 protocol;
|
2017-08-07 02:15:30 -06:00
|
|
|
u32 prio;
|
2018-01-19 18:44:47 -07:00
|
|
|
struct netlink_ext_ack *extack;
|
2017-08-07 02:15:29 -06:00
|
|
|
};
|
|
|
|
|
2016-02-16 22:17:09 -07:00
|
|
|
struct tc_cls_u32_knode {
|
|
|
|
struct tcf_exts *exts;
|
2016-02-17 15:59:30 -07:00
|
|
|
struct tc_u32_sel *sel;
|
2016-02-16 22:17:09 -07:00
|
|
|
u32 handle;
|
|
|
|
u32 val;
|
|
|
|
u32 mask;
|
|
|
|
u32 link_handle;
|
2016-02-17 15:59:30 -07:00
|
|
|
u8 fshift;
|
2016-02-16 22:17:09 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct tc_cls_u32_hnode {
|
|
|
|
u32 handle;
|
|
|
|
u32 prio;
|
|
|
|
unsigned int divisor;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum tc_clsu32_command {
|
|
|
|
TC_CLSU32_NEW_KNODE,
|
|
|
|
TC_CLSU32_REPLACE_KNODE,
|
|
|
|
TC_CLSU32_DELETE_KNODE,
|
|
|
|
TC_CLSU32_NEW_HNODE,
|
|
|
|
TC_CLSU32_REPLACE_HNODE,
|
|
|
|
TC_CLSU32_DELETE_HNODE,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct tc_cls_u32_offload {
|
2017-08-07 02:15:29 -06:00
|
|
|
struct tc_cls_common_offload common;
|
2016-02-16 22:17:09 -07:00
|
|
|
/* knode values */
|
|
|
|
enum tc_clsu32_command command;
|
|
|
|
union {
|
|
|
|
struct tc_cls_u32_knode knode;
|
|
|
|
struct tc_cls_u32_hnode hnode;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2017-08-09 06:30:35 -06:00
|
|
|
static inline bool tc_can_offload(const struct net_device *dev)
|
2016-02-26 08:53:49 -07:00
|
|
|
{
|
2017-11-01 04:47:41 -06:00
|
|
|
return dev->features & NETIF_F_HW_TC;
|
2016-02-26 08:53:49 -07:00
|
|
|
}
|
|
|
|
|
2018-01-19 18:44:48 -07:00
|
|
|
static inline bool tc_can_offload_extack(const struct net_device *dev,
|
|
|
|
struct netlink_ext_ack *extack)
|
|
|
|
{
|
|
|
|
bool can = tc_can_offload(dev);
|
|
|
|
|
|
|
|
if (!can)
|
|
|
|
NL_SET_ERR_MSG(extack, "TC offload is disabled on net device");
|
|
|
|
|
|
|
|
return can;
|
|
|
|
}
|
|
|
|
|
2018-01-25 15:00:43 -07:00
|
|
|
static inline bool
|
|
|
|
tc_cls_can_offload_and_chain0(const struct net_device *dev,
|
|
|
|
struct tc_cls_common_offload *common)
|
|
|
|
{
|
|
|
|
if (!tc_can_offload_extack(dev, common->extack))
|
|
|
|
return false;
|
|
|
|
if (common->chain_index) {
|
|
|
|
NL_SET_ERR_MSG(common->extack,
|
|
|
|
"Driver supports only offload of chain 0");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-12-01 05:06:33 -07:00
|
|
|
static inline bool tc_skip_hw(u32 flags)
|
|
|
|
{
|
|
|
|
return (flags & TCA_CLS_FLAGS_SKIP_HW) ? true : false;
|
|
|
|
}
|
|
|
|
|
2016-05-12 18:08:23 -06:00
|
|
|
static inline bool tc_skip_sw(u32 flags)
|
|
|
|
{
|
|
|
|
return (flags & TCA_CLS_FLAGS_SKIP_SW) ? true : false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* SKIP_HW and SKIP_SW are mutually exclusive flags. */
|
|
|
|
static inline bool tc_flags_valid(u32 flags)
|
|
|
|
{
|
|
|
|
if (flags & ~(TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!(flags ^ (TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW)))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-02-16 01:31:12 -07:00
|
|
|
static inline bool tc_in_hw(u32 flags)
|
|
|
|
{
|
|
|
|
return (flags & TCA_CLS_FLAGS_IN_HW) ? true : false;
|
|
|
|
}
|
|
|
|
|
2018-01-24 13:54:14 -07:00
|
|
|
static inline void
|
|
|
|
tc_cls_common_offload_init(struct tc_cls_common_offload *cls_common,
|
|
|
|
const struct tcf_proto *tp, u32 flags,
|
|
|
|
struct netlink_ext_ack *extack)
|
|
|
|
{
|
|
|
|
cls_common->chain_index = tp->chain->index;
|
|
|
|
cls_common->protocol = tp->protocol;
|
|
|
|
cls_common->prio = tp->prio;
|
|
|
|
if (tc_skip_sw(flags))
|
|
|
|
cls_common->extack = extack;
|
|
|
|
}
|
|
|
|
|
2016-03-08 03:42:29 -07:00
|
|
|
enum tc_fl_command {
|
|
|
|
TC_CLSFLOWER_REPLACE,
|
|
|
|
TC_CLSFLOWER_DESTROY,
|
2016-05-13 06:55:37 -06:00
|
|
|
TC_CLSFLOWER_STATS,
|
2016-03-08 03:42:29 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct tc_cls_flower_offload {
|
2017-08-07 02:15:29 -06:00
|
|
|
struct tc_cls_common_offload common;
|
2016-03-08 03:42:29 -07:00
|
|
|
enum tc_fl_command command;
|
2016-03-11 02:08:45 -07:00
|
|
|
unsigned long cookie;
|
2016-03-08 03:42:29 -07:00
|
|
|
struct flow_dissector *dissector;
|
|
|
|
struct fl_flow_key *mask;
|
|
|
|
struct fl_flow_key *key;
|
|
|
|
struct tcf_exts *exts;
|
2017-10-27 03:35:34 -06:00
|
|
|
u32 classid;
|
2016-03-08 03:42:29 -07:00
|
|
|
};
|
|
|
|
|
2016-07-21 04:03:12 -06:00
|
|
|
enum tc_matchall_command {
|
|
|
|
TC_CLSMATCHALL_REPLACE,
|
|
|
|
TC_CLSMATCHALL_DESTROY,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct tc_cls_matchall_offload {
|
2017-08-07 02:15:29 -06:00
|
|
|
struct tc_cls_common_offload common;
|
2016-07-21 04:03:12 -06:00
|
|
|
enum tc_matchall_command command;
|
|
|
|
struct tcf_exts *exts;
|
|
|
|
unsigned long cookie;
|
|
|
|
};
|
|
|
|
|
2016-09-21 04:43:53 -06:00
|
|
|
enum tc_clsbpf_command {
|
2017-12-19 14:32:13 -07:00
|
|
|
TC_CLSBPF_OFFLOAD,
|
2016-09-21 04:44:02 -06:00
|
|
|
TC_CLSBPF_STATS,
|
2016-09-21 04:43:53 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct tc_cls_bpf_offload {
|
2017-08-07 02:15:29 -06:00
|
|
|
struct tc_cls_common_offload common;
|
2016-09-21 04:43:53 -06:00
|
|
|
enum tc_clsbpf_command command;
|
|
|
|
struct tcf_exts *exts;
|
|
|
|
struct bpf_prog *prog;
|
2017-12-19 14:32:13 -07:00
|
|
|
struct bpf_prog *oldprog;
|
2016-09-21 04:43:53 -06:00
|
|
|
const char *name;
|
|
|
|
bool exts_integrated;
|
|
|
|
};
|
|
|
|
|
2017-09-07 05:00:06 -06:00
|
|
|
struct tc_mqprio_qopt_offload {
|
|
|
|
/* struct tc_mqprio_qopt must always be the first element */
|
|
|
|
struct tc_mqprio_qopt qopt;
|
|
|
|
u16 mode;
|
|
|
|
u16 shaper;
|
|
|
|
u32 flags;
|
|
|
|
u64 min_rate[TC_QOPT_MAX_QUEUE];
|
|
|
|
u64 max_rate[TC_QOPT_MAX_QUEUE];
|
|
|
|
};
|
2017-01-24 05:02:41 -07:00
|
|
|
|
|
|
|
/* This structure holds cookie structure that is passed from user
|
|
|
|
* to the kernel for actions and classifiers
|
|
|
|
*/
|
|
|
|
struct tc_cookie {
|
|
|
|
u8 *data;
|
|
|
|
u32 len;
|
|
|
|
};
|
2017-11-05 23:23:41 -07:00
|
|
|
|
2018-01-10 06:59:58 -07:00
|
|
|
struct tc_qopt_offload_stats {
|
|
|
|
struct gnet_stats_basic_packed *bstats;
|
|
|
|
struct gnet_stats_queue *qstats;
|
|
|
|
};
|
|
|
|
|
2017-11-05 23:23:41 -07:00
|
|
|
enum tc_red_command {
|
|
|
|
TC_RED_REPLACE,
|
|
|
|
TC_RED_DESTROY,
|
|
|
|
TC_RED_STATS,
|
|
|
|
TC_RED_XSTATS,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct tc_red_qopt_offload_params {
|
|
|
|
u32 min;
|
|
|
|
u32 max;
|
|
|
|
u32 probability;
|
|
|
|
bool is_ecn;
|
2018-01-14 21:01:26 -07:00
|
|
|
struct gnet_stats_queue *qstats;
|
2017-11-05 23:23:41 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct tc_red_qopt_offload {
|
|
|
|
enum tc_red_command command;
|
|
|
|
u32 handle;
|
|
|
|
u32 parent;
|
|
|
|
union {
|
|
|
|
struct tc_red_qopt_offload_params set;
|
2018-01-10 06:59:58 -07:00
|
|
|
struct tc_qopt_offload_stats stats;
|
2017-11-05 23:23:41 -07:00
|
|
|
struct red_stats *xstats;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2018-01-14 04:33:15 -07:00
|
|
|
enum tc_prio_command {
|
|
|
|
TC_PRIO_REPLACE,
|
|
|
|
TC_PRIO_DESTROY,
|
|
|
|
TC_PRIO_STATS,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct tc_prio_qopt_offload_params {
|
|
|
|
int bands;
|
|
|
|
u8 priomap[TC_PRIO_MAX + 1];
|
|
|
|
/* In case that a prio qdisc is offloaded and now is changed to a
|
|
|
|
* non-offloadedable config, it needs to update the backlog & qlen
|
|
|
|
* values to negate the HW backlog & qlen values (and only them).
|
|
|
|
*/
|
|
|
|
struct gnet_stats_queue *qstats;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct tc_prio_qopt_offload {
|
|
|
|
enum tc_prio_command command;
|
|
|
|
u32 handle;
|
|
|
|
u32 parent;
|
|
|
|
union {
|
|
|
|
struct tc_prio_qopt_offload_params replace_params;
|
|
|
|
struct tc_qopt_offload_stats stats;
|
|
|
|
};
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|