blob: 796785e0bf96b0e65f598d3b2dad8256485d034a [file] [log] [blame]
Jiri Pirkoc7e2b962014-11-19 14:05:03 +01001/*
2 * Copyright (c) 2014 Jiri Pirko <jiri@resnulli.us>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 */
9
10#include <linux/module.h>
11#include <linux/init.h>
12#include <linux/kernel.h>
13#include <linux/skbuff.h>
14#include <linux/rtnetlink.h>
15#include <linux/if_vlan.h>
16#include <net/netlink.h>
17#include <net/pkt_sched.h>
18
19#include <linux/tc_act/tc_vlan.h>
20#include <net/tc_act/tc_vlan.h>
21
22#define VLAN_TAB_MASK 15
23
24static int tcf_vlan(struct sk_buff *skb, const struct tc_action *a,
25 struct tcf_result *res)
26{
27 struct tcf_vlan *v = a->priv;
28 int action;
29 int err;
30
31 spin_lock(&v->tcf_lock);
32 v->tcf_tm.lastuse = jiffies;
33 bstats_update(&v->tcf_bstats, skb);
34 action = v->tcf_action;
35
36 switch (v->tcfv_action) {
37 case TCA_VLAN_ACT_POP:
38 err = skb_vlan_pop(skb);
39 if (err)
40 goto drop;
41 break;
42 case TCA_VLAN_ACT_PUSH:
43 err = skb_vlan_push(skb, v->tcfv_push_proto, v->tcfv_push_vid);
44 if (err)
45 goto drop;
46 break;
47 default:
48 BUG();
49 }
50
51 goto unlock;
52
53drop:
54 action = TC_ACT_SHOT;
55 v->tcf_qstats.drops++;
56unlock:
57 spin_unlock(&v->tcf_lock);
58 return action;
59}
60
61static const struct nla_policy vlan_policy[TCA_VLAN_MAX + 1] = {
62 [TCA_VLAN_PARMS] = { .len = sizeof(struct tc_vlan) },
63 [TCA_VLAN_PUSH_VLAN_ID] = { .type = NLA_U16 },
64 [TCA_VLAN_PUSH_VLAN_PROTOCOL] = { .type = NLA_U16 },
65};
66
67static int tcf_vlan_init(struct net *net, struct nlattr *nla,
68 struct nlattr *est, struct tc_action *a,
69 int ovr, int bind)
70{
71 struct nlattr *tb[TCA_VLAN_MAX + 1];
72 struct tc_vlan *parm;
73 struct tcf_vlan *v;
74 int action;
75 __be16 push_vid = 0;
76 __be16 push_proto = 0;
77 int ret = 0;
78 int err;
79
80 if (!nla)
81 return -EINVAL;
82
83 err = nla_parse_nested(tb, TCA_VLAN_MAX, nla, vlan_policy);
84 if (err < 0)
85 return err;
86
87 if (!tb[TCA_VLAN_PARMS])
88 return -EINVAL;
89 parm = nla_data(tb[TCA_VLAN_PARMS]);
90 switch (parm->v_action) {
91 case TCA_VLAN_ACT_POP:
92 break;
93 case TCA_VLAN_ACT_PUSH:
94 if (!tb[TCA_VLAN_PUSH_VLAN_ID])
95 return -EINVAL;
96 push_vid = nla_get_u16(tb[TCA_VLAN_PUSH_VLAN_ID]);
97 if (push_vid >= VLAN_VID_MASK)
98 return -ERANGE;
99
100 if (tb[TCA_VLAN_PUSH_VLAN_PROTOCOL]) {
101 push_proto = nla_get_be16(tb[TCA_VLAN_PUSH_VLAN_PROTOCOL]);
102 switch (push_proto) {
103 case htons(ETH_P_8021Q):
104 case htons(ETH_P_8021AD):
105 break;
106 default:
107 return -EPROTONOSUPPORT;
108 }
109 } else {
110 push_proto = htons(ETH_P_8021Q);
111 }
112 break;
113 default:
114 return -EINVAL;
115 }
116 action = parm->v_action;
117
118 if (!tcf_hash_check(parm->index, a, bind)) {
Eric Dumazet519c8182015-07-06 05:18:04 -0700119 ret = tcf_hash_create(parm->index, est, a, sizeof(*v),
120 bind, false);
Jiri Pirkoc7e2b962014-11-19 14:05:03 +0100121 if (ret)
122 return ret;
123
124 ret = ACT_P_CREATED;
125 } else {
126 if (bind)
127 return 0;
128 tcf_hash_release(a, bind);
129 if (!ovr)
130 return -EEXIST;
131 }
132
133 v = to_vlan(a);
134
135 spin_lock_bh(&v->tcf_lock);
136
137 v->tcfv_action = action;
138 v->tcfv_push_vid = push_vid;
139 v->tcfv_push_proto = push_proto;
140
141 v->tcf_action = parm->action;
142
143 spin_unlock_bh(&v->tcf_lock);
144
145 if (ret == ACT_P_CREATED)
146 tcf_hash_insert(a);
147 return ret;
148}
149
150static int tcf_vlan_dump(struct sk_buff *skb, struct tc_action *a,
151 int bind, int ref)
152{
153 unsigned char *b = skb_tail_pointer(skb);
154 struct tcf_vlan *v = a->priv;
155 struct tc_vlan opt = {
156 .index = v->tcf_index,
157 .refcnt = v->tcf_refcnt - ref,
158 .bindcnt = v->tcf_bindcnt - bind,
159 .action = v->tcf_action,
160 .v_action = v->tcfv_action,
161 };
162 struct tcf_t t;
163
164 if (nla_put(skb, TCA_VLAN_PARMS, sizeof(opt), &opt))
165 goto nla_put_failure;
166
167 if (v->tcfv_action == TCA_VLAN_ACT_PUSH &&
168 (nla_put_u16(skb, TCA_VLAN_PUSH_VLAN_ID, v->tcfv_push_vid) ||
169 nla_put_be16(skb, TCA_VLAN_PUSH_VLAN_PROTOCOL, v->tcfv_push_proto)))
170 goto nla_put_failure;
171
172 t.install = jiffies_to_clock_t(jiffies - v->tcf_tm.install);
173 t.lastuse = jiffies_to_clock_t(jiffies - v->tcf_tm.lastuse);
174 t.expires = jiffies_to_clock_t(v->tcf_tm.expires);
175 if (nla_put(skb, TCA_VLAN_TM, sizeof(t), &t))
176 goto nla_put_failure;
177 return skb->len;
178
179nla_put_failure:
180 nlmsg_trim(skb, b);
181 return -1;
182}
183
184static struct tc_action_ops act_vlan_ops = {
185 .kind = "vlan",
186 .type = TCA_ACT_VLAN,
187 .owner = THIS_MODULE,
188 .act = tcf_vlan,
189 .dump = tcf_vlan_dump,
190 .init = tcf_vlan_init,
191};
192
193static int __init vlan_init_module(void)
194{
195 return tcf_register_action(&act_vlan_ops, VLAN_TAB_MASK);
196}
197
198static void __exit vlan_cleanup_module(void)
199{
200 tcf_unregister_action(&act_vlan_ops);
201}
202
203module_init(vlan_init_module);
204module_exit(vlan_cleanup_module);
205
206MODULE_AUTHOR("Jiri Pirko <jiri@resnulli.us>");
207MODULE_DESCRIPTION("vlan manipulation actions");
208MODULE_LICENSE("GPL v2");