xref: /openbmc/linux/net/sched/act_mirred.c (revision 8684014d)
1 /*
2  * net/sched/act_mirred.c	packet mirroring and redirect actions
3  *
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 
15 #include <linux/types.h>
16 #include <linux/kernel.h>
17 #include <linux/string.h>
18 #include <linux/errno.h>
19 #include <linux/skbuff.h>
20 #include <linux/rtnetlink.h>
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/gfp.h>
24 #include <net/net_namespace.h>
25 #include <net/netlink.h>
26 #include <net/pkt_sched.h>
27 #include <linux/tc_act/tc_mirred.h>
28 #include <net/tc_act/tc_mirred.h>
29 
30 #include <linux/if_arp.h>
31 
32 #define MIRRED_TAB_MASK     7
33 static LIST_HEAD(mirred_list);
34 
35 static void tcf_mirred_release(struct tc_action *a, int bind)
36 {
37 	struct tcf_mirred *m = to_mirred(a);
38 	list_del(&m->tcfm_list);
39 	if (m->tcfm_dev)
40 		dev_put(m->tcfm_dev);
41 }
42 
43 static const struct nla_policy mirred_policy[TCA_MIRRED_MAX + 1] = {
44 	[TCA_MIRRED_PARMS]	= { .len = sizeof(struct tc_mirred) },
45 };
46 
47 static int tcf_mirred_init(struct net *net, struct nlattr *nla,
48 			   struct nlattr *est, struct tc_action *a, int ovr,
49 			   int bind)
50 {
51 	struct nlattr *tb[TCA_MIRRED_MAX + 1];
52 	struct tc_mirred *parm;
53 	struct tcf_mirred *m;
54 	struct net_device *dev;
55 	int ret, ok_push = 0;
56 
57 	if (nla == NULL)
58 		return -EINVAL;
59 	ret = nla_parse_nested(tb, TCA_MIRRED_MAX, nla, mirred_policy);
60 	if (ret < 0)
61 		return ret;
62 	if (tb[TCA_MIRRED_PARMS] == NULL)
63 		return -EINVAL;
64 	parm = nla_data(tb[TCA_MIRRED_PARMS]);
65 	switch (parm->eaction) {
66 	case TCA_EGRESS_MIRROR:
67 	case TCA_EGRESS_REDIR:
68 		break;
69 	default:
70 		return -EINVAL;
71 	}
72 	if (parm->ifindex) {
73 		dev = __dev_get_by_index(net, parm->ifindex);
74 		if (dev == NULL)
75 			return -ENODEV;
76 		switch (dev->type) {
77 		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;
88 		}
89 	} else {
90 		dev = NULL;
91 	}
92 
93 	if (!tcf_hash_check(parm->index, a, bind)) {
94 		if (dev == NULL)
95 			return -EINVAL;
96 		ret = tcf_hash_create(parm->index, est, a, sizeof(*m), bind);
97 		if (ret)
98 			return ret;
99 		ret = ACT_P_CREATED;
100 	} else {
101 		if (!ovr) {
102 			tcf_hash_release(a, bind);
103 			return -EEXIST;
104 		}
105 	}
106 	m = to_mirred(a);
107 
108 	spin_lock_bh(&m->tcf_lock);
109 	m->tcf_action = parm->action;
110 	m->tcfm_eaction = parm->eaction;
111 	if (dev != NULL) {
112 		m->tcfm_ifindex = parm->ifindex;
113 		if (ret != ACT_P_CREATED)
114 			dev_put(m->tcfm_dev);
115 		dev_hold(dev);
116 		m->tcfm_dev = dev;
117 		m->tcfm_ok_push = ok_push;
118 	}
119 	spin_unlock_bh(&m->tcf_lock);
120 	if (ret == ACT_P_CREATED) {
121 		list_add(&m->tcfm_list, &mirred_list);
122 		tcf_hash_insert(a);
123 	}
124 
125 	return ret;
126 }
127 
128 static int tcf_mirred(struct sk_buff *skb, const struct tc_action *a,
129 		      struct tcf_result *res)
130 {
131 	struct tcf_mirred *m = a->priv;
132 	struct net_device *dev;
133 	struct sk_buff *skb2;
134 	u32 at;
135 	int retval, err = 1;
136 
137 	spin_lock(&m->tcf_lock);
138 	m->tcf_tm.lastuse = jiffies;
139 	bstats_update(&m->tcf_bstats, skb);
140 
141 	dev = m->tcfm_dev;
142 	if (!dev) {
143 		printk_once(KERN_NOTICE "tc mirred: target device is gone\n");
144 		goto out;
145 	}
146 
147 	if (!(dev->flags & IFF_UP)) {
148 		net_notice_ratelimited("tc mirred to Houston: device %s is down\n",
149 				       dev->name);
150 		goto out;
151 	}
152 
153 	at = G_TC_AT(skb->tc_verd);
154 	skb2 = skb_act_clone(skb, GFP_ATOMIC, m->tcf_action);
155 	if (skb2 == NULL)
156 		goto out;
157 
158 	if (!(at & AT_EGRESS)) {
159 		if (m->tcfm_ok_push)
160 			skb_push(skb2, skb2->dev->hard_header_len);
161 	}
162 
163 	/* mirror is always swallowed */
164 	if (m->tcfm_eaction != TCA_EGRESS_MIRROR)
165 		skb2->tc_verd = SET_TC_FROM(skb2->tc_verd, at);
166 
167 	skb2->skb_iif = skb->dev->ifindex;
168 	skb2->dev = dev;
169 	err = dev_queue_xmit(skb2);
170 
171 out:
172 	if (err) {
173 		m->tcf_qstats.overlimits++;
174 		if (m->tcfm_eaction != TCA_EGRESS_MIRROR)
175 			retval = TC_ACT_SHOT;
176 		else
177 			retval = m->tcf_action;
178 	} else
179 		retval = m->tcf_action;
180 	spin_unlock(&m->tcf_lock);
181 
182 	return retval;
183 }
184 
185 static int tcf_mirred_dump(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
186 {
187 	unsigned char *b = skb_tail_pointer(skb);
188 	struct tcf_mirred *m = a->priv;
189 	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 	};
197 	struct tcf_t t;
198 
199 	if (nla_put(skb, TCA_MIRRED_PARMS, sizeof(opt), &opt))
200 		goto nla_put_failure;
201 	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);
204 	if (nla_put(skb, TCA_MIRRED_TM, sizeof(t), &t))
205 		goto nla_put_failure;
206 	return skb->len;
207 
208 nla_put_failure:
209 	nlmsg_trim(skb, b);
210 	return -1;
211 }
212 
213 static int mirred_device_event(struct notifier_block *unused,
214 			       unsigned long event, void *ptr)
215 {
216 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
217 	struct tcf_mirred *m;
218 
219 	if (event == NETDEV_UNREGISTER)
220 		list_for_each_entry(m, &mirred_list, tcfm_list) {
221 			spin_lock_bh(&m->tcf_lock);
222 			if (m->tcfm_dev == dev) {
223 				dev_put(dev);
224 				m->tcfm_dev = NULL;
225 			}
226 			spin_unlock_bh(&m->tcf_lock);
227 		}
228 
229 	return NOTIFY_DONE;
230 }
231 
232 static struct notifier_block mirred_device_notifier = {
233 	.notifier_call = mirred_device_event,
234 };
235 
236 static struct tc_action_ops act_mirred_ops = {
237 	.kind		=	"mirred",
238 	.type		=	TCA_ACT_MIRRED,
239 	.owner		=	THIS_MODULE,
240 	.act		=	tcf_mirred,
241 	.dump		=	tcf_mirred_dump,
242 	.cleanup	=	tcf_mirred_release,
243 	.init		=	tcf_mirred_init,
244 };
245 
246 MODULE_AUTHOR("Jamal Hadi Salim(2002)");
247 MODULE_DESCRIPTION("Device Mirror/redirect actions");
248 MODULE_LICENSE("GPL");
249 
250 static int __init mirred_init_module(void)
251 {
252 	int err = register_netdevice_notifier(&mirred_device_notifier);
253 	if (err)
254 		return err;
255 
256 	pr_info("Mirror/redirect action on\n");
257 	return tcf_register_action(&act_mirred_ops, MIRRED_TAB_MASK);
258 }
259 
260 static void __exit mirred_cleanup_module(void)
261 {
262 	tcf_unregister_action(&act_mirred_ops);
263 	unregister_netdevice_notifier(&mirred_device_notifier);
264 }
265 
266 module_init(mirred_init_module);
267 module_exit(mirred_cleanup_module);
268