blob: fc3650b0619242d8aed6a51604087ec8d4f8b57b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Jiri Pirko0c6965d2014-11-05 20:51:51 +01002 * net/sched/act_mirred.c packet mirroring and redirect actions
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
8 *
9 * Authors: Jamal Hadi Salim (2002-4)
10 *
11 * TODO: Add ingress support (and socket redirect support)
12 *
13 */
14
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/types.h>
16#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/skbuff.h>
20#include <linux/rtnetlink.h>
21#include <linux/module.h>
22#include <linux/init.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090023#include <linux/gfp.h>
Eric W. Biederman881d9662007-09-17 11:56:21 -070024#include <net/net_namespace.h>
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -070025#include <net/netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <net/pkt_sched.h>
27#include <linux/tc_act/tc_mirred.h>
28#include <net/tc_act/tc_mirred.h>
29
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/if_arp.h>
31
David S. Millere9ce1cd2006-08-21 23:54:55 -070032#define MIRRED_TAB_MASK 7
stephen hemminger3b879562010-07-22 18:45:04 +000033static LIST_HEAD(mirred_list);
WANG Cong6bd00b82015-10-01 11:37:42 -070034static DEFINE_SPINLOCK(mirred_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
WANG Conga5b5c952014-02-11 17:07:32 -080036static void tcf_mirred_release(struct tc_action *a, int bind)
Linus Torvalds1da177e2005-04-16 15:20:36 -070037{
WANG Cong86062032014-02-11 17:07:31 -080038 struct tcf_mirred *m = to_mirred(a);
WANG Congdc327f82016-05-16 15:11:18 -070039 struct net_device *dev;
Eric Dumazet2ee22a92015-07-06 05:18:09 -070040
WANG Cong6bd00b82015-10-01 11:37:42 -070041 /* We could be called either in a RCU callback or with RTNL lock held. */
42 spin_lock_bh(&mirred_list_lock);
WANG Conga5b5c952014-02-11 17:07:32 -080043 list_del(&m->tcfm_list);
WANG Congdc327f82016-05-16 15:11:18 -070044 dev = rcu_dereference_protected(m->tcfm_dev, 1);
Eric Dumazet2ee22a92015-07-06 05:18:09 -070045 if (dev)
46 dev_put(dev);
WANG Congdc327f82016-05-16 15:11:18 -070047 spin_unlock_bh(&mirred_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070048}
49
Patrick McHardy53b2bf32008-01-23 20:36:30 -080050static const struct nla_policy mirred_policy[TCA_MIRRED_MAX + 1] = {
51 [TCA_MIRRED_PARMS] = { .len = sizeof(struct tc_mirred) },
52};
53
WANG Congddf97cc2016-02-22 15:57:53 -080054static int mirred_net_id;
WANG Conga85a9702016-07-25 16:09:41 -070055static struct tc_action_ops act_mirred_ops;
WANG Congddf97cc2016-02-22 15:57:53 -080056
Benjamin LaHaisec1b52732013-01-14 05:15:39 +000057static int tcf_mirred_init(struct net *net, struct nlattr *nla,
WANG Conga85a9702016-07-25 16:09:41 -070058 struct nlattr *est, struct tc_action **a, int ovr,
Benjamin LaHaisec1b52732013-01-14 05:15:39 +000059 int bind)
Linus Torvalds1da177e2005-04-16 15:20:36 -070060{
WANG Congddf97cc2016-02-22 15:57:53 -080061 struct tc_action_net *tn = net_generic(net, mirred_net_id);
Patrick McHardy7ba699c2008-01-22 22:11:50 -080062 struct nlattr *tb[TCA_MIRRED_MAX + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 struct tc_mirred *parm;
David S. Millere9ce1cd2006-08-21 23:54:55 -070064 struct tcf_mirred *m;
Changli Gaob76965e2009-11-17 04:15:16 -080065 struct net_device *dev;
WANG Congb2313072016-06-13 13:46:28 -070066 int ret, ok_push = 0;
67 bool exists = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
Patrick McHardycee63722008-01-23 20:33:32 -080069 if (nla == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 return -EINVAL;
Changli Gaob76965e2009-11-17 04:15:16 -080071 ret = nla_parse_nested(tb, TCA_MIRRED_MAX, nla, mirred_policy);
72 if (ret < 0)
73 return ret;
Patrick McHardy53b2bf32008-01-23 20:36:30 -080074 if (tb[TCA_MIRRED_PARMS] == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 return -EINVAL;
Patrick McHardy7ba699c2008-01-22 22:11:50 -080076 parm = nla_data(tb[TCA_MIRRED_PARMS]);
Jamal Hadi Salim87dfbdc2016-05-10 16:49:28 -040077
78 exists = tcf_hash_check(tn, parm->index, a, bind);
79 if (exists && bind)
80 return 0;
81
Changli Gaob76965e2009-11-17 04:15:16 -080082 switch (parm->eaction) {
83 case TCA_EGRESS_MIRROR:
84 case TCA_EGRESS_REDIR:
85 break;
86 default:
Jamal Hadi Salim87dfbdc2016-05-10 16:49:28 -040087 if (exists)
WANG Conga85a9702016-07-25 16:09:41 -070088 tcf_hash_release(*a, bind);
Changli Gaob76965e2009-11-17 04:15:16 -080089 return -EINVAL;
90 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 if (parm->ifindex) {
Benjamin LaHaisec1b52732013-01-14 05:15:39 +000092 dev = __dev_get_by_index(net, parm->ifindex);
Jamal Hadi Salim87dfbdc2016-05-10 16:49:28 -040093 if (dev == NULL) {
94 if (exists)
WANG Conga85a9702016-07-25 16:09:41 -070095 tcf_hash_release(*a, bind);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 return -ENODEV;
Jamal Hadi Salim87dfbdc2016-05-10 16:49:28 -040097 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 switch (dev->type) {
Changli Gaob76965e2009-11-17 04:15:16 -080099 case ARPHRD_TUNNEL:
100 case ARPHRD_TUNNEL6:
101 case ARPHRD_SIT:
102 case ARPHRD_IPGRE:
103 case ARPHRD_VOID:
104 case ARPHRD_NONE:
105 ok_push = 0;
106 break;
107 default:
108 ok_push = 1;
109 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 }
Changli Gaob76965e2009-11-17 04:15:16 -0800111 } else {
112 dev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 }
114
Jamal Hadi Salim87dfbdc2016-05-10 16:49:28 -0400115 if (!exists) {
Changli Gaob76965e2009-11-17 04:15:16 -0800116 if (dev == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 return -EINVAL;
WANG Congddf97cc2016-02-22 15:57:53 -0800118 ret = tcf_hash_create(tn, parm->index, est, a,
WANG Conga85a9702016-07-25 16:09:41 -0700119 &act_mirred_ops, bind, true);
WANG Cong86062032014-02-11 17:07:31 -0800120 if (ret)
121 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 ret = ACT_P_CREATED;
123 } else {
WANG Conga85a9702016-07-25 16:09:41 -0700124 tcf_hash_release(*a, bind);
WANG Cong215c90a2015-10-01 11:37:43 -0700125 if (!ovr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 return -EEXIST;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 }
WANG Conga85a9702016-07-25 16:09:41 -0700128 m = to_mirred(*a);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129
Eric Dumazet2ee22a92015-07-06 05:18:09 -0700130 ASSERT_RTNL();
David S. Millere9ce1cd2006-08-21 23:54:55 -0700131 m->tcf_action = parm->action;
132 m->tcfm_eaction = parm->eaction;
Changli Gaob76965e2009-11-17 04:15:16 -0800133 if (dev != NULL) {
David S. Millere9ce1cd2006-08-21 23:54:55 -0700134 m->tcfm_ifindex = parm->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 if (ret != ACT_P_CREATED)
Eric Dumazet2ee22a92015-07-06 05:18:09 -0700136 dev_put(rcu_dereference_protected(m->tcfm_dev, 1));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 dev_hold(dev);
Eric Dumazet2ee22a92015-07-06 05:18:09 -0700138 rcu_assign_pointer(m->tcfm_dev, dev);
David S. Millere9ce1cd2006-08-21 23:54:55 -0700139 m->tcfm_ok_push = ok_push;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 }
Eric Dumazet2ee22a92015-07-06 05:18:09 -0700141
stephen hemminger3b879562010-07-22 18:45:04 +0000142 if (ret == ACT_P_CREATED) {
WANG Cong6bd00b82015-10-01 11:37:42 -0700143 spin_lock_bh(&mirred_list_lock);
stephen hemminger3b879562010-07-22 18:45:04 +0000144 list_add(&m->tcfm_list, &mirred_list);
WANG Cong6bd00b82015-10-01 11:37:42 -0700145 spin_unlock_bh(&mirred_list_lock);
WANG Conga85a9702016-07-25 16:09:41 -0700146 tcf_hash_insert(tn, *a);
stephen hemminger3b879562010-07-22 18:45:04 +0000147 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 return ret;
150}
151
Eric Dumazetdc7f9f62011-07-05 23:25:42 +0000152static int tcf_mirred(struct sk_buff *skb, const struct tc_action *a,
David S. Millere9ce1cd2006-08-21 23:54:55 -0700153 struct tcf_result *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154{
WANG Conga85a9702016-07-25 16:09:41 -0700155 struct tcf_mirred *m = to_mirred(a);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 struct net_device *dev;
Changli Gaofeed1f12009-11-17 04:14:00 -0800157 struct sk_buff *skb2;
Eric Dumazet2ee22a92015-07-06 05:18:09 -0700158 int retval, err;
Changli Gaofeed1f12009-11-17 04:14:00 -0800159 u32 at;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
Eric Dumazet2ee22a92015-07-06 05:18:09 -0700161 tcf_lastuse_update(&m->tcf_tm);
Eric Dumazet2ee22a92015-07-06 05:18:09 -0700162 bstats_cpu_update(this_cpu_ptr(m->common.cpu_bstats), skb);
163
164 rcu_read_lock();
165 retval = READ_ONCE(m->tcf_action);
166 dev = rcu_dereference(m->tcfm_dev);
167 if (unlikely(!dev)) {
168 pr_notice_once("tc mirred: target device is gone\n");
stephen hemminger3b879562010-07-22 18:45:04 +0000169 goto out;
170 }
171
Eric Dumazet2ee22a92015-07-06 05:18:09 -0700172 if (unlikely(!(dev->flags & IFF_UP))) {
Joe Perchese87cc472012-05-13 21:56:26 +0000173 net_notice_ratelimited("tc mirred to Houston: device %s is down\n",
174 dev->name);
Changli Gaofeed1f12009-11-17 04:14:00 -0800175 goto out;
176 }
177
Changli Gao210d6de2010-06-24 16:25:12 +0000178 at = G_TC_AT(skb->tc_verd);
Florian Westphale578d9c2015-05-11 19:50:41 +0200179 skb2 = skb_clone(skb, GFP_ATOMIC);
Eric Dumazet2ee22a92015-07-06 05:18:09 -0700180 if (!skb2)
Changli Gaofeed1f12009-11-17 04:14:00 -0800181 goto out;
182
Changli Gaofeed1f12009-11-17 04:14:00 -0800183 if (!(at & AT_EGRESS)) {
David S. Millere9ce1cd2006-08-21 23:54:55 -0700184 if (m->tcfm_ok_push)
WANG Cong82a31b92016-06-30 10:15:22 -0700185 skb_push_rcsum(skb2, skb->mac_len);
Changli Gaofeed1f12009-11-17 04:14:00 -0800186 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
188 /* mirror is always swallowed */
David S. Millere9ce1cd2006-08-21 23:54:55 -0700189 if (m->tcfm_eaction != TCA_EGRESS_MIRROR)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 skb2->tc_verd = SET_TC_FROM(skb2->tc_verd, at);
191
Eric Dumazet8964be42009-11-20 15:35:04 -0800192 skb2->skb_iif = skb->dev->ifindex;
Changli Gao210d6de2010-06-24 16:25:12 +0000193 skb2->dev = dev;
Jamal Hadi Salim8919bc12011-08-15 05:25:40 +0000194 err = dev_queue_xmit(skb2);
Changli Gaofeed1f12009-11-17 04:14:00 -0800195
Changli Gaofeed1f12009-11-17 04:14:00 -0800196 if (err) {
Eric Dumazet2ee22a92015-07-06 05:18:09 -0700197out:
198 qstats_overlimit_inc(this_cpu_ptr(m->common.cpu_qstats));
Jason Wang16c0b162012-08-15 20:44:27 +0000199 if (m->tcfm_eaction != TCA_EGRESS_MIRROR)
200 retval = TC_ACT_SHOT;
Eric Dumazet2ee22a92015-07-06 05:18:09 -0700201 }
202 rcu_read_unlock();
Changli Gaofeed1f12009-11-17 04:14:00 -0800203
204 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205}
206
Jakub Kicinski9798e6f2016-09-21 11:44:05 +0100207static void tcf_stats_update(struct tc_action *a, u64 bytes, u32 packets,
208 u64 lastuse)
209{
Paul Blakey5712bf92016-10-19 17:42:39 +0300210 struct tcf_mirred *m = to_mirred(a);
211 struct tcf_t *tm = &m->tcf_tm;
212
Jakub Kicinski9798e6f2016-09-21 11:44:05 +0100213 _bstats_cpu_update(this_cpu_ptr(a->cpu_bstats), bytes, packets);
Roi Dayanb28394c2017-12-26 07:48:51 +0200214 tm->lastuse = max_t(u64, tm->lastuse, lastuse);
Jakub Kicinski9798e6f2016-09-21 11:44:05 +0100215}
216
Jamal Hadi Salim5a7a5552016-09-18 08:45:33 -0400217static int tcf_mirred_dump(struct sk_buff *skb, struct tc_action *a, int bind,
218 int ref)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700220 unsigned char *b = skb_tail_pointer(skb);
WANG Conga85a9702016-07-25 16:09:41 -0700221 struct tcf_mirred *m = to_mirred(a);
Eric Dumazet1c40be12010-08-16 20:04:22 +0000222 struct tc_mirred opt = {
223 .index = m->tcf_index,
224 .action = m->tcf_action,
225 .refcnt = m->tcf_refcnt - ref,
226 .bindcnt = m->tcf_bindcnt - bind,
227 .eaction = m->tcfm_eaction,
228 .ifindex = m->tcfm_ifindex,
229 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 struct tcf_t t;
231
David S. Miller1b34ec42012-03-29 05:11:39 -0400232 if (nla_put(skb, TCA_MIRRED_PARMS, sizeof(opt), &opt))
233 goto nla_put_failure;
Jamal Hadi Salim48d8ee12016-06-06 06:32:55 -0400234
235 tcf_tm_dump(&t, &m->tcf_tm);
Nicolas Dichtel98545182016-04-26 10:06:18 +0200236 if (nla_put_64bit(skb, TCA_MIRRED_TM, sizeof(t), &t, TCA_MIRRED_PAD))
David S. Miller1b34ec42012-03-29 05:11:39 -0400237 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 return skb->len;
239
Patrick McHardy7ba699c2008-01-22 22:11:50 -0800240nla_put_failure:
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -0700241 nlmsg_trim(skb, b);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 return -1;
243}
244
WANG Congddf97cc2016-02-22 15:57:53 -0800245static int tcf_mirred_walker(struct net *net, struct sk_buff *skb,
246 struct netlink_callback *cb, int type,
WANG Conga85a9702016-07-25 16:09:41 -0700247 const struct tc_action_ops *ops)
WANG Congddf97cc2016-02-22 15:57:53 -0800248{
249 struct tc_action_net *tn = net_generic(net, mirred_net_id);
250
WANG Conga85a9702016-07-25 16:09:41 -0700251 return tcf_generic_walker(tn, skb, cb, type, ops);
WANG Congddf97cc2016-02-22 15:57:53 -0800252}
253
WANG Conga85a9702016-07-25 16:09:41 -0700254static int tcf_mirred_search(struct net *net, struct tc_action **a, u32 index)
WANG Congddf97cc2016-02-22 15:57:53 -0800255{
256 struct tc_action_net *tn = net_generic(net, mirred_net_id);
257
258 return tcf_hash_search(tn, a, index);
259}
260
stephen hemminger3b879562010-07-22 18:45:04 +0000261static int mirred_device_event(struct notifier_block *unused,
262 unsigned long event, void *ptr)
263{
Jiri Pirko351638e2013-05-28 01:30:21 +0000264 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
stephen hemminger3b879562010-07-22 18:45:04 +0000265 struct tcf_mirred *m;
266
Eric Dumazet2ee22a92015-07-06 05:18:09 -0700267 ASSERT_RTNL();
WANG Cong6bd00b82015-10-01 11:37:42 -0700268 if (event == NETDEV_UNREGISTER) {
269 spin_lock_bh(&mirred_list_lock);
stephen hemminger3b879562010-07-22 18:45:04 +0000270 list_for_each_entry(m, &mirred_list, tcfm_list) {
Eric Dumazet2ee22a92015-07-06 05:18:09 -0700271 if (rcu_access_pointer(m->tcfm_dev) == dev) {
stephen hemminger3b879562010-07-22 18:45:04 +0000272 dev_put(dev);
Eric Dumazet2ee22a92015-07-06 05:18:09 -0700273 /* Note : no rcu grace period necessary, as
274 * net_device are already rcu protected.
275 */
276 RCU_INIT_POINTER(m->tcfm_dev, NULL);
stephen hemminger3b879562010-07-22 18:45:04 +0000277 }
278 }
WANG Cong6bd00b82015-10-01 11:37:42 -0700279 spin_unlock_bh(&mirred_list_lock);
280 }
stephen hemminger3b879562010-07-22 18:45:04 +0000281
282 return NOTIFY_DONE;
283}
284
285static struct notifier_block mirred_device_notifier = {
286 .notifier_call = mirred_device_event,
287};
288
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289static struct tc_action_ops act_mirred_ops = {
290 .kind = "mirred",
291 .type = TCA_ACT_MIRRED,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 .owner = THIS_MODULE,
293 .act = tcf_mirred,
Jakub Kicinski9798e6f2016-09-21 11:44:05 +0100294 .stats_update = tcf_stats_update,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 .dump = tcf_mirred_dump,
WANG Cong86062032014-02-11 17:07:31 -0800296 .cleanup = tcf_mirred_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 .init = tcf_mirred_init,
WANG Congddf97cc2016-02-22 15:57:53 -0800298 .walk = tcf_mirred_walker,
299 .lookup = tcf_mirred_search,
WANG Conga85a9702016-07-25 16:09:41 -0700300 .size = sizeof(struct tcf_mirred),
WANG Congddf97cc2016-02-22 15:57:53 -0800301};
302
303static __net_init int mirred_init_net(struct net *net)
304{
305 struct tc_action_net *tn = net_generic(net, mirred_net_id);
306
307 return tc_action_net_init(tn, &act_mirred_ops, MIRRED_TAB_MASK);
308}
309
310static void __net_exit mirred_exit_net(struct net *net)
311{
312 struct tc_action_net *tn = net_generic(net, mirred_net_id);
313
314 tc_action_net_exit(tn);
315}
316
317static struct pernet_operations mirred_net_ops = {
318 .init = mirred_init_net,
319 .exit = mirred_exit_net,
320 .id = &mirred_net_id,
321 .size = sizeof(struct tc_action_net),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322};
323
324MODULE_AUTHOR("Jamal Hadi Salim(2002)");
325MODULE_DESCRIPTION("Device Mirror/redirect actions");
326MODULE_LICENSE("GPL");
327
David S. Millere9ce1cd2006-08-21 23:54:55 -0700328static int __init mirred_init_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329{
stephen hemminger3b879562010-07-22 18:45:04 +0000330 int err = register_netdevice_notifier(&mirred_device_notifier);
331 if (err)
332 return err;
333
stephen hemminger6ff9c362010-05-12 06:37:05 +0000334 pr_info("Mirror/redirect action on\n");
WANG Congddf97cc2016-02-22 15:57:53 -0800335 return tcf_register_action(&act_mirred_ops, &mirred_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336}
337
David S. Millere9ce1cd2006-08-21 23:54:55 -0700338static void __exit mirred_cleanup_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339{
WANG Congddf97cc2016-02-22 15:57:53 -0800340 tcf_unregister_action(&act_mirred_ops, &mirred_net_ops);
WANG Cong568a1532013-12-20 00:08:51 -0800341 unregister_netdevice_notifier(&mirred_device_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342}
343
344module_init(mirred_init_module);
345module_exit(mirred_cleanup_module);