2 * Copyright (c) 2014 Jiri Pirko <jiri@resnulli.us>
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.
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>
19 #include <linux/tc_act/tc_vlan.h>
20 #include <net/tc_act/tc_vlan.h>
22 static unsigned int vlan_net_id
;
23 static struct tc_action_ops act_vlan_ops
;
25 static int tcf_vlan(struct sk_buff
*skb
, const struct tc_action
*a
,
26 struct tcf_result
*res
)
28 struct tcf_vlan
*v
= to_vlan(a
);
33 spin_lock(&v
->tcf_lock
);
34 tcf_lastuse_update(&v
->tcf_tm
);
35 bstats_update(&v
->tcf_bstats
, skb
);
36 action
= v
->tcf_action
;
38 /* Ensure 'data' points at mac_header prior calling vlan manipulating
41 if (skb_at_tc_ingress(skb
))
42 skb_push_rcsum(skb
, skb
->mac_len
);
44 switch (v
->tcfv_action
) {
45 case TCA_VLAN_ACT_POP
:
46 err
= skb_vlan_pop(skb
);
50 case TCA_VLAN_ACT_PUSH
:
51 err
= skb_vlan_push(skb
, v
->tcfv_push_proto
, v
->tcfv_push_vid
|
52 (v
->tcfv_push_prio
<< VLAN_PRIO_SHIFT
));
56 case TCA_VLAN_ACT_MODIFY
:
57 /* No-op if no vlan tag (either hw-accel or in-payload) */
58 if (!skb_vlan_tagged(skb
))
60 /* extract existing tag (and guarantee no hw-accel tag) */
61 if (skb_vlan_tag_present(skb
)) {
62 tci
= skb_vlan_tag_get(skb
);
65 /* in-payload vlan tag, pop it */
66 err
= __skb_vlan_pop(skb
, &tci
);
71 tci
= (tci
& ~VLAN_VID_MASK
) | v
->tcfv_push_vid
;
72 /* replace prio bits, if tcfv_push_prio specified */
73 if (v
->tcfv_push_prio
) {
74 tci
&= ~VLAN_PRIO_MASK
;
75 tci
|= v
->tcfv_push_prio
<< VLAN_PRIO_SHIFT
;
77 /* put updated tci as hwaccel tag */
78 __vlan_hwaccel_put_tag(skb
, v
->tcfv_push_proto
, tci
);
88 v
->tcf_qstats
.drops
++;
90 if (skb_at_tc_ingress(skb
))
91 skb_pull_rcsum(skb
, skb
->mac_len
);
93 spin_unlock(&v
->tcf_lock
);
97 static const struct nla_policy vlan_policy
[TCA_VLAN_MAX
+ 1] = {
98 [TCA_VLAN_PARMS
] = { .len
= sizeof(struct tc_vlan
) },
99 [TCA_VLAN_PUSH_VLAN_ID
] = { .type
= NLA_U16
},
100 [TCA_VLAN_PUSH_VLAN_PROTOCOL
] = { .type
= NLA_U16
},
101 [TCA_VLAN_PUSH_VLAN_PRIORITY
] = { .type
= NLA_U8
},
104 static int tcf_vlan_init(struct net
*net
, struct nlattr
*nla
,
105 struct nlattr
*est
, struct tc_action
**a
,
108 struct tc_action_net
*tn
= net_generic(net
, vlan_net_id
);
109 struct nlattr
*tb
[TCA_VLAN_MAX
+ 1];
110 struct tc_vlan
*parm
;
114 __be16 push_proto
= 0;
122 err
= nla_parse_nested(tb
, TCA_VLAN_MAX
, nla
, vlan_policy
, NULL
);
126 if (!tb
[TCA_VLAN_PARMS
])
128 parm
= nla_data(tb
[TCA_VLAN_PARMS
]);
129 exists
= tcf_idr_check(tn
, parm
->index
, a
, bind
);
133 switch (parm
->v_action
) {
134 case TCA_VLAN_ACT_POP
:
136 case TCA_VLAN_ACT_PUSH
:
137 case TCA_VLAN_ACT_MODIFY
:
138 if (!tb
[TCA_VLAN_PUSH_VLAN_ID
]) {
140 tcf_idr_release(*a
, bind
);
143 push_vid
= nla_get_u16(tb
[TCA_VLAN_PUSH_VLAN_ID
]);
144 if (push_vid
>= VLAN_VID_MASK
) {
146 tcf_idr_release(*a
, bind
);
150 if (tb
[TCA_VLAN_PUSH_VLAN_PROTOCOL
]) {
151 push_proto
= nla_get_be16(tb
[TCA_VLAN_PUSH_VLAN_PROTOCOL
]);
152 switch (push_proto
) {
153 case htons(ETH_P_8021Q
):
154 case htons(ETH_P_8021AD
):
157 return -EPROTONOSUPPORT
;
160 push_proto
= htons(ETH_P_8021Q
);
163 if (tb
[TCA_VLAN_PUSH_VLAN_PRIORITY
])
164 push_prio
= nla_get_u8(tb
[TCA_VLAN_PUSH_VLAN_PRIORITY
]);
168 tcf_idr_release(*a
, bind
);
171 action
= parm
->v_action
;
174 ret
= tcf_idr_create(tn
, parm
->index
, est
, a
,
175 &act_vlan_ops
, bind
, false);
181 tcf_idr_release(*a
, bind
);
188 spin_lock_bh(&v
->tcf_lock
);
190 v
->tcfv_action
= action
;
191 v
->tcfv_push_vid
= push_vid
;
192 v
->tcfv_push_prio
= push_prio
;
193 v
->tcfv_push_proto
= push_proto
;
195 v
->tcf_action
= parm
->action
;
197 spin_unlock_bh(&v
->tcf_lock
);
199 if (ret
== ACT_P_CREATED
)
200 tcf_idr_insert(tn
, *a
);
204 static int tcf_vlan_dump(struct sk_buff
*skb
, struct tc_action
*a
,
207 unsigned char *b
= skb_tail_pointer(skb
);
208 struct tcf_vlan
*v
= to_vlan(a
);
209 struct tc_vlan opt
= {
210 .index
= v
->tcf_index
,
211 .refcnt
= v
->tcf_refcnt
- ref
,
212 .bindcnt
= v
->tcf_bindcnt
- bind
,
213 .action
= v
->tcf_action
,
214 .v_action
= v
->tcfv_action
,
218 if (nla_put(skb
, TCA_VLAN_PARMS
, sizeof(opt
), &opt
))
219 goto nla_put_failure
;
221 if ((v
->tcfv_action
== TCA_VLAN_ACT_PUSH
||
222 v
->tcfv_action
== TCA_VLAN_ACT_MODIFY
) &&
223 (nla_put_u16(skb
, TCA_VLAN_PUSH_VLAN_ID
, v
->tcfv_push_vid
) ||
224 nla_put_be16(skb
, TCA_VLAN_PUSH_VLAN_PROTOCOL
,
225 v
->tcfv_push_proto
) ||
226 (nla_put_u8(skb
, TCA_VLAN_PUSH_VLAN_PRIORITY
,
227 v
->tcfv_push_prio
))))
228 goto nla_put_failure
;
230 tcf_tm_dump(&t
, &v
->tcf_tm
);
231 if (nla_put_64bit(skb
, TCA_VLAN_TM
, sizeof(t
), &t
, TCA_VLAN_PAD
))
232 goto nla_put_failure
;
240 static int tcf_vlan_walker(struct net
*net
, struct sk_buff
*skb
,
241 struct netlink_callback
*cb
, int type
,
242 const struct tc_action_ops
*ops
)
244 struct tc_action_net
*tn
= net_generic(net
, vlan_net_id
);
246 return tcf_generic_walker(tn
, skb
, cb
, type
, ops
);
249 static int tcf_vlan_search(struct net
*net
, struct tc_action
**a
, u32 index
)
251 struct tc_action_net
*tn
= net_generic(net
, vlan_net_id
);
253 return tcf_idr_search(tn
, a
, index
);
256 static struct tc_action_ops act_vlan_ops
= {
258 .type
= TCA_ACT_VLAN
,
259 .owner
= THIS_MODULE
,
261 .dump
= tcf_vlan_dump
,
262 .init
= tcf_vlan_init
,
263 .walk
= tcf_vlan_walker
,
264 .lookup
= tcf_vlan_search
,
265 .size
= sizeof(struct tcf_vlan
),
268 static __net_init
int vlan_init_net(struct net
*net
)
270 struct tc_action_net
*tn
= net_generic(net
, vlan_net_id
);
272 return tc_action_net_init(tn
, &act_vlan_ops
);
275 static void __net_exit
vlan_exit_net(struct net
*net
)
277 struct tc_action_net
*tn
= net_generic(net
, vlan_net_id
);
279 tc_action_net_exit(tn
);
282 static struct pernet_operations vlan_net_ops
= {
283 .init
= vlan_init_net
,
284 .exit
= vlan_exit_net
,
286 .size
= sizeof(struct tc_action_net
),
289 static int __init
vlan_init_module(void)
291 return tcf_register_action(&act_vlan_ops
, &vlan_net_ops
);
294 static void __exit
vlan_cleanup_module(void)
296 tcf_unregister_action(&act_vlan_ops
, &vlan_net_ops
);
299 module_init(vlan_init_module
);
300 module_exit(vlan_cleanup_module
);
302 MODULE_AUTHOR("Jiri Pirko <jiri@resnulli.us>");
303 MODULE_DESCRIPTION("vlan manipulation actions");
304 MODULE_LICENSE("GPL v2");