blob: 5953517ec059aabf3613979d06b52ba81c38c483 [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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
WANG Conga5b5c952014-02-11 17:07:32 -080035static void tcf_mirred_release(struct tc_action *a, int bind)
Linus Torvalds1da177e2005-04-16 15:20:36 -070036{
WANG Cong86062032014-02-11 17:07:31 -080037 struct tcf_mirred *m = to_mirred(a);
WANG Conga5b5c952014-02-11 17:07:32 -080038 list_del(&m->tcfm_list);
39 if (m->tcfm_dev)
40 dev_put(m->tcfm_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070041}
42
Patrick McHardy53b2bf32008-01-23 20:36:30 -080043static const struct nla_policy mirred_policy[TCA_MIRRED_MAX + 1] = {
44 [TCA_MIRRED_PARMS] = { .len = sizeof(struct tc_mirred) },
45};
46
Benjamin LaHaisec1b52732013-01-14 05:15:39 +000047static int tcf_mirred_init(struct net *net, struct nlattr *nla,
48 struct nlattr *est, struct tc_action *a, int ovr,
49 int bind)
Linus Torvalds1da177e2005-04-16 15:20:36 -070050{
Patrick McHardy7ba699c2008-01-22 22:11:50 -080051 struct nlattr *tb[TCA_MIRRED_MAX + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 struct tc_mirred *parm;
David S. Millere9ce1cd2006-08-21 23:54:55 -070053 struct tcf_mirred *m;
Changli Gaob76965e2009-11-17 04:15:16 -080054 struct net_device *dev;
55 int ret, ok_push = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Patrick McHardycee63722008-01-23 20:33:32 -080057 if (nla == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 return -EINVAL;
Changli Gaob76965e2009-11-17 04:15:16 -080059 ret = nla_parse_nested(tb, TCA_MIRRED_MAX, nla, mirred_policy);
60 if (ret < 0)
61 return ret;
Patrick McHardy53b2bf32008-01-23 20:36:30 -080062 if (tb[TCA_MIRRED_PARMS] == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 return -EINVAL;
Patrick McHardy7ba699c2008-01-22 22:11:50 -080064 parm = nla_data(tb[TCA_MIRRED_PARMS]);
Changli Gaob76965e2009-11-17 04:15:16 -080065 switch (parm->eaction) {
66 case TCA_EGRESS_MIRROR:
67 case TCA_EGRESS_REDIR:
68 break;
69 default:
70 return -EINVAL;
71 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 if (parm->ifindex) {
Benjamin LaHaisec1b52732013-01-14 05:15:39 +000073 dev = __dev_get_by_index(net, parm->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 if (dev == NULL)
75 return -ENODEV;
76 switch (dev->type) {
Changli Gaob76965e2009-11-17 04:15:16 -080077 case ARPHRD_TUNNEL:
78 case ARPHRD_TUNNEL6:
79 case ARPHRD_SIT:
80 case ARPHRD_IPGRE:
81 case ARPHRD_VOID:
82 case ARPHRD_NONE:
83 ok_push = 0;
84 break;
85 default:
86 ok_push = 1;
87 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 }
Changli Gaob76965e2009-11-17 04:15:16 -080089 } else {
90 dev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 }
92
WANG Cong86062032014-02-11 17:07:31 -080093 if (!tcf_hash_check(parm->index, a, bind)) {
Changli Gaob76965e2009-11-17 04:15:16 -080094 if (dev == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 return -EINVAL;
WANG Cong86062032014-02-11 17:07:31 -080096 ret = tcf_hash_create(parm->index, est, a, sizeof(*m), bind);
97 if (ret)
98 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 ret = ACT_P_CREATED;
100 } else {
101 if (!ovr) {
WANG Conga5b5c952014-02-11 17:07:32 -0800102 tcf_hash_release(a, bind);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 return -EEXIST;
104 }
105 }
WANG Cong86062032014-02-11 17:07:31 -0800106 m = to_mirred(a);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
David S. Millere9ce1cd2006-08-21 23:54:55 -0700108 spin_lock_bh(&m->tcf_lock);
109 m->tcf_action = parm->action;
110 m->tcfm_eaction = parm->eaction;
Changli Gaob76965e2009-11-17 04:15:16 -0800111 if (dev != NULL) {
David S. Millere9ce1cd2006-08-21 23:54:55 -0700112 m->tcfm_ifindex = parm->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 if (ret != ACT_P_CREATED)
David S. Millere9ce1cd2006-08-21 23:54:55 -0700114 dev_put(m->tcfm_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 dev_hold(dev);
Changli Gaob76965e2009-11-17 04:15:16 -0800116 m->tcfm_dev = dev;
David S. Millere9ce1cd2006-08-21 23:54:55 -0700117 m->tcfm_ok_push = ok_push;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 }
David S. Millere9ce1cd2006-08-21 23:54:55 -0700119 spin_unlock_bh(&m->tcf_lock);
stephen hemminger3b879562010-07-22 18:45:04 +0000120 if (ret == ACT_P_CREATED) {
121 list_add(&m->tcfm_list, &mirred_list);
WANG Cong86062032014-02-11 17:07:31 -0800122 tcf_hash_insert(a);
stephen hemminger3b879562010-07-22 18:45:04 +0000123 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 return ret;
126}
127
Eric Dumazetdc7f9f62011-07-05 23:25:42 +0000128static int tcf_mirred(struct sk_buff *skb, const struct tc_action *a,
David S. Millere9ce1cd2006-08-21 23:54:55 -0700129 struct tcf_result *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130{
David S. Millere9ce1cd2006-08-21 23:54:55 -0700131 struct tcf_mirred *m = a->priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 struct net_device *dev;
Changli Gaofeed1f12009-11-17 04:14:00 -0800133 struct sk_buff *skb2;
134 u32 at;
135 int retval, err = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
David S. Millere9ce1cd2006-08-21 23:54:55 -0700137 spin_lock(&m->tcf_lock);
David S. Millere9ce1cd2006-08-21 23:54:55 -0700138 m->tcf_tm.lastuse = jiffies;
Eric Dumazetbfe0d022011-01-09 08:30:54 +0000139 bstats_update(&m->tcf_bstats, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
Changli Gaofeed1f12009-11-17 04:14:00 -0800141 dev = m->tcfm_dev;
stephen hemminger3b879562010-07-22 18:45:04 +0000142 if (!dev) {
143 printk_once(KERN_NOTICE "tc mirred: target device is gone\n");
144 goto out;
145 }
146
Changli Gaofeed1f12009-11-17 04:14:00 -0800147 if (!(dev->flags & IFF_UP)) {
Joe Perchese87cc472012-05-13 21:56:26 +0000148 net_notice_ratelimited("tc mirred to Houston: device %s is down\n",
149 dev->name);
Changli Gaofeed1f12009-11-17 04:14:00 -0800150 goto out;
151 }
152
Changli Gao210d6de2010-06-24 16:25:12 +0000153 at = G_TC_AT(skb->tc_verd);
154 skb2 = skb_act_clone(skb, GFP_ATOMIC, m->tcf_action);
Changli Gaofeed1f12009-11-17 04:14:00 -0800155 if (skb2 == NULL)
156 goto out;
157
Changli Gaofeed1f12009-11-17 04:14:00 -0800158 if (!(at & AT_EGRESS)) {
David S. Millere9ce1cd2006-08-21 23:54:55 -0700159 if (m->tcfm_ok_push)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 skb_push(skb2, skb2->dev->hard_header_len);
Changli Gaofeed1f12009-11-17 04:14:00 -0800161 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
163 /* mirror is always swallowed */
David S. Millere9ce1cd2006-08-21 23:54:55 -0700164 if (m->tcfm_eaction != TCA_EGRESS_MIRROR)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 skb2->tc_verd = SET_TC_FROM(skb2->tc_verd, at);
166
Eric Dumazet8964be42009-11-20 15:35:04 -0800167 skb2->skb_iif = skb->dev->ifindex;
Changli Gao210d6de2010-06-24 16:25:12 +0000168 skb2->dev = dev;
Jamal Hadi Salim8919bc12011-08-15 05:25:40 +0000169 err = dev_queue_xmit(skb2);
Changli Gaofeed1f12009-11-17 04:14:00 -0800170
171out:
172 if (err) {
173 m->tcf_qstats.overlimits++;
Jason Wang16c0b162012-08-15 20:44:27 +0000174 if (m->tcfm_eaction != TCA_EGRESS_MIRROR)
175 retval = TC_ACT_SHOT;
176 else
177 retval = m->tcf_action;
178 } else
Changli Gaofeed1f12009-11-17 04:14:00 -0800179 retval = m->tcf_action;
David S. Millere9ce1cd2006-08-21 23:54:55 -0700180 spin_unlock(&m->tcf_lock);
Changli Gaofeed1f12009-11-17 04:14:00 -0800181
182 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183}
184
David S. Millere9ce1cd2006-08-21 23:54:55 -0700185static int tcf_mirred_dump(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700187 unsigned char *b = skb_tail_pointer(skb);
David S. Millere9ce1cd2006-08-21 23:54:55 -0700188 struct tcf_mirred *m = a->priv;
Eric Dumazet1c40be12010-08-16 20:04:22 +0000189 struct tc_mirred opt = {
190 .index = m->tcf_index,
191 .action = m->tcf_action,
192 .refcnt = m->tcf_refcnt - ref,
193 .bindcnt = m->tcf_bindcnt - bind,
194 .eaction = m->tcfm_eaction,
195 .ifindex = m->tcfm_ifindex,
196 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 struct tcf_t t;
198
David S. Miller1b34ec42012-03-29 05:11:39 -0400199 if (nla_put(skb, TCA_MIRRED_PARMS, sizeof(opt), &opt))
200 goto nla_put_failure;
David S. Millere9ce1cd2006-08-21 23:54:55 -0700201 t.install = jiffies_to_clock_t(jiffies - m->tcf_tm.install);
202 t.lastuse = jiffies_to_clock_t(jiffies - m->tcf_tm.lastuse);
203 t.expires = jiffies_to_clock_t(m->tcf_tm.expires);
David S. Miller1b34ec42012-03-29 05:11:39 -0400204 if (nla_put(skb, TCA_MIRRED_TM, sizeof(t), &t))
205 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 return skb->len;
207
Patrick McHardy7ba699c2008-01-22 22:11:50 -0800208nla_put_failure:
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -0700209 nlmsg_trim(skb, b);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 return -1;
211}
212
stephen hemminger3b879562010-07-22 18:45:04 +0000213static int mirred_device_event(struct notifier_block *unused,
214 unsigned long event, void *ptr)
215{
Jiri Pirko351638e2013-05-28 01:30:21 +0000216 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
stephen hemminger3b879562010-07-22 18:45:04 +0000217 struct tcf_mirred *m;
218
219 if (event == NETDEV_UNREGISTER)
220 list_for_each_entry(m, &mirred_list, tcfm_list) {
Cong Wang224e9232014-07-16 14:25:31 -0700221 spin_lock_bh(&m->tcf_lock);
stephen hemminger3b879562010-07-22 18:45:04 +0000222 if (m->tcfm_dev == dev) {
223 dev_put(dev);
224 m->tcfm_dev = NULL;
225 }
Cong Wang224e9232014-07-16 14:25:31 -0700226 spin_unlock_bh(&m->tcf_lock);
stephen hemminger3b879562010-07-22 18:45:04 +0000227 }
228
229 return NOTIFY_DONE;
230}
231
232static struct notifier_block mirred_device_notifier = {
233 .notifier_call = mirred_device_event,
234};
235
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236static struct tc_action_ops act_mirred_ops = {
237 .kind = "mirred",
238 .type = TCA_ACT_MIRRED,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 .owner = THIS_MODULE,
240 .act = tcf_mirred,
241 .dump = tcf_mirred_dump,
WANG Cong86062032014-02-11 17:07:31 -0800242 .cleanup = tcf_mirred_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 .init = tcf_mirred_init,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244};
245
246MODULE_AUTHOR("Jamal Hadi Salim(2002)");
247MODULE_DESCRIPTION("Device Mirror/redirect actions");
248MODULE_LICENSE("GPL");
249
David S. Millere9ce1cd2006-08-21 23:54:55 -0700250static int __init mirred_init_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251{
stephen hemminger3b879562010-07-22 18:45:04 +0000252 int err = register_netdevice_notifier(&mirred_device_notifier);
253 if (err)
254 return err;
255
stephen hemminger6ff9c362010-05-12 06:37:05 +0000256 pr_info("Mirror/redirect action on\n");
WANG Cong4f1e9d82014-02-11 17:07:33 -0800257 return tcf_register_action(&act_mirred_ops, MIRRED_TAB_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258}
259
David S. Millere9ce1cd2006-08-21 23:54:55 -0700260static void __exit mirred_cleanup_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 tcf_unregister_action(&act_mirred_ops);
WANG Cong568a1532013-12-20 00:08:51 -0800263 unregister_netdevice_notifier(&mirred_device_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264}
265
266module_init(mirred_init_module);
267module_exit(mirred_cleanup_module);