1 /*
2 * Copyright (c) 2008, Intel Corporation.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, see <http://www.gnu.org/licenses/>.
15 *
16 * Author: Alexander Duyck <alexander.h.duyck@intel.com>
17 */
18
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/kernel.h>
22 #include <linux/skbuff.h>
23 #include <linux/rtnetlink.h>
24 #include <net/netlink.h>
25 #include <net/pkt_sched.h>
26
27 #include <linux/tc_act/tc_skbedit.h>
28 #include <net/tc_act/tc_skbedit.h>
29
30 #define SKBEDIT_TAB_MASK 15
31
tcf_skbedit(struct sk_buff * skb,const struct tc_action * a,struct tcf_result * res)32 static int tcf_skbedit(struct sk_buff *skb, const struct tc_action *a,
33 struct tcf_result *res)
34 {
35 struct tcf_skbedit *d = a->priv;
36
37 spin_lock(&d->tcf_lock);
38 d->tcf_tm.lastuse = jiffies;
39 bstats_update(&d->tcf_bstats, skb);
40
41 if (d->flags & SKBEDIT_F_PRIORITY)
42 skb->priority = d->priority;
43 if (d->flags & SKBEDIT_F_QUEUE_MAPPING &&
44 skb->dev->real_num_tx_queues > d->queue_mapping)
45 skb_set_queue_mapping(skb, d->queue_mapping);
46 if (d->flags & SKBEDIT_F_MARK)
47 skb->mark = d->mark;
48
49 spin_unlock(&d->tcf_lock);
50 return d->tcf_action;
51 }
52
53 static const struct nla_policy skbedit_policy[TCA_SKBEDIT_MAX + 1] = {
54 [TCA_SKBEDIT_PARMS] = { .len = sizeof(struct tc_skbedit) },
55 [TCA_SKBEDIT_PRIORITY] = { .len = sizeof(u32) },
56 [TCA_SKBEDIT_QUEUE_MAPPING] = { .len = sizeof(u16) },
57 [TCA_SKBEDIT_MARK] = { .len = sizeof(u32) },
58 };
59
tcf_skbedit_init(struct net * net,struct nlattr * nla,struct nlattr * est,struct tc_action * a,int ovr,int bind)60 static int tcf_skbedit_init(struct net *net, struct nlattr *nla,
61 struct nlattr *est, struct tc_action *a,
62 int ovr, int bind)
63 {
64 struct nlattr *tb[TCA_SKBEDIT_MAX + 1];
65 struct tc_skbedit *parm;
66 struct tcf_skbedit *d;
67 u32 flags = 0, *priority = NULL, *mark = NULL;
68 u16 *queue_mapping = NULL;
69 int ret = 0, err;
70
71 if (nla == NULL)
72 return -EINVAL;
73
74 err = nla_parse_nested(tb, TCA_SKBEDIT_MAX, nla, skbedit_policy);
75 if (err < 0)
76 return err;
77
78 if (tb[TCA_SKBEDIT_PARMS] == NULL)
79 return -EINVAL;
80
81 if (tb[TCA_SKBEDIT_PRIORITY] != NULL) {
82 flags |= SKBEDIT_F_PRIORITY;
83 priority = nla_data(tb[TCA_SKBEDIT_PRIORITY]);
84 }
85
86 if (tb[TCA_SKBEDIT_QUEUE_MAPPING] != NULL) {
87 flags |= SKBEDIT_F_QUEUE_MAPPING;
88 queue_mapping = nla_data(tb[TCA_SKBEDIT_QUEUE_MAPPING]);
89 }
90
91 if (tb[TCA_SKBEDIT_MARK] != NULL) {
92 flags |= SKBEDIT_F_MARK;
93 mark = nla_data(tb[TCA_SKBEDIT_MARK]);
94 }
95
96 if (!flags)
97 return -EINVAL;
98
99 parm = nla_data(tb[TCA_SKBEDIT_PARMS]);
100
101 if (!tcf_hash_check(parm->index, a, bind)) {
102 ret = tcf_hash_create(parm->index, est, a, sizeof(*d),
103 bind, false);
104 if (ret)
105 return ret;
106
107 d = to_skbedit(a);
108 ret = ACT_P_CREATED;
109 } else {
110 d = to_skbedit(a);
111 if (bind)
112 return 0;
113 tcf_hash_release(a, bind);
114 if (!ovr)
115 return -EEXIST;
116 }
117
118 spin_lock_bh(&d->tcf_lock);
119
120 d->flags = flags;
121 if (flags & SKBEDIT_F_PRIORITY)
122 d->priority = *priority;
123 if (flags & SKBEDIT_F_QUEUE_MAPPING)
124 d->queue_mapping = *queue_mapping;
125 if (flags & SKBEDIT_F_MARK)
126 d->mark = *mark;
127
128 d->tcf_action = parm->action;
129
130 spin_unlock_bh(&d->tcf_lock);
131
132 if (ret == ACT_P_CREATED)
133 tcf_hash_insert(a);
134 return ret;
135 }
136
tcf_skbedit_dump(struct sk_buff * skb,struct tc_action * a,int bind,int ref)137 static int tcf_skbedit_dump(struct sk_buff *skb, struct tc_action *a,
138 int bind, int ref)
139 {
140 unsigned char *b = skb_tail_pointer(skb);
141 struct tcf_skbedit *d = a->priv;
142 struct tc_skbedit opt = {
143 .index = d->tcf_index,
144 .refcnt = d->tcf_refcnt - ref,
145 .bindcnt = d->tcf_bindcnt - bind,
146 .action = d->tcf_action,
147 };
148 struct tcf_t t;
149
150 if (nla_put(skb, TCA_SKBEDIT_PARMS, sizeof(opt), &opt))
151 goto nla_put_failure;
152 if ((d->flags & SKBEDIT_F_PRIORITY) &&
153 nla_put(skb, TCA_SKBEDIT_PRIORITY, sizeof(d->priority),
154 &d->priority))
155 goto nla_put_failure;
156 if ((d->flags & SKBEDIT_F_QUEUE_MAPPING) &&
157 nla_put(skb, TCA_SKBEDIT_QUEUE_MAPPING,
158 sizeof(d->queue_mapping), &d->queue_mapping))
159 goto nla_put_failure;
160 if ((d->flags & SKBEDIT_F_MARK) &&
161 nla_put(skb, TCA_SKBEDIT_MARK, sizeof(d->mark),
162 &d->mark))
163 goto nla_put_failure;
164 t.install = jiffies_to_clock_t(jiffies - d->tcf_tm.install);
165 t.lastuse = jiffies_to_clock_t(jiffies - d->tcf_tm.lastuse);
166 t.expires = jiffies_to_clock_t(d->tcf_tm.expires);
167 if (nla_put(skb, TCA_SKBEDIT_TM, sizeof(t), &t))
168 goto nla_put_failure;
169 return skb->len;
170
171 nla_put_failure:
172 nlmsg_trim(skb, b);
173 return -1;
174 }
175
176 static struct tc_action_ops act_skbedit_ops = {
177 .kind = "skbedit",
178 .type = TCA_ACT_SKBEDIT,
179 .owner = THIS_MODULE,
180 .act = tcf_skbedit,
181 .dump = tcf_skbedit_dump,
182 .init = tcf_skbedit_init,
183 };
184
185 MODULE_AUTHOR("Alexander Duyck, <alexander.h.duyck@intel.com>");
186 MODULE_DESCRIPTION("SKB Editing");
187 MODULE_LICENSE("GPL");
188
skbedit_init_module(void)189 static int __init skbedit_init_module(void)
190 {
191 return tcf_register_action(&act_skbedit_ops, SKBEDIT_TAB_MASK);
192 }
193
skbedit_cleanup_module(void)194 static void __exit skbedit_cleanup_module(void)
195 {
196 tcf_unregister_action(&act_skbedit_ops);
197 }
198
199 module_init(skbedit_init_module);
200 module_exit(skbedit_cleanup_module);
201