1/* Linux multicast routing support
2 * Common logic shared by IPv4 [ipmr] and IPv6 [ip6mr] implementation
3 */
4
5#include <linux/rhashtable.h>
6#include <linux/mroute_base.h>
7
8/* Sets everything common except 'dev', since that is done under locking */
9void vif_device_init(struct vif_device *v,
10		     struct net_device *dev,
11		     unsigned long rate_limit,
12		     unsigned char threshold,
13		     unsigned short flags,
14		     unsigned short get_iflink_mask)
15{
16	RCU_INIT_POINTER(v->dev, NULL);
17	v->bytes_in = 0;
18	v->bytes_out = 0;
19	v->pkt_in = 0;
20	v->pkt_out = 0;
21	v->rate_limit = rate_limit;
22	v->flags = flags;
23	v->threshold = threshold;
24	if (v->flags & get_iflink_mask)
25		v->link = dev_get_iflink(dev);
26	else
27		v->link = dev->ifindex;
28}
29EXPORT_SYMBOL(vif_device_init);
30
31struct mr_table *
32mr_table_alloc(struct net *net, u32 id,
33	       struct mr_table_ops *ops,
34	       void (*expire_func)(struct timer_list *t),
35	       void (*table_set)(struct mr_table *mrt,
36				 struct net *net))
37{
38	struct mr_table *mrt;
39	int err;
40
41	mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
42	if (!mrt)
43		return ERR_PTR(-ENOMEM);
44	mrt->id = id;
45	write_pnet(&mrt->net, net);
46
47	mrt->ops = *ops;
48	err = rhltable_init(&mrt->mfc_hash, mrt->ops.rht_params);
49	if (err) {
50		kfree(mrt);
51		return ERR_PTR(err);
52	}
53	INIT_LIST_HEAD(&mrt->mfc_cache_list);
54	INIT_LIST_HEAD(&mrt->mfc_unres_queue);
55
56	timer_setup(&mrt->ipmr_expire_timer, expire_func, 0);
57
58	mrt->mroute_reg_vif_num = -1;
59	table_set(mrt, net);
60	return mrt;
61}
62EXPORT_SYMBOL(mr_table_alloc);
63
64void *mr_mfc_find_parent(struct mr_table *mrt, void *hasharg, int parent)
65{
66	struct rhlist_head *tmp, *list;
67	struct mr_mfc *c;
68
69	list = rhltable_lookup(&mrt->mfc_hash, hasharg, *mrt->ops.rht_params);
70	rhl_for_each_entry_rcu(c, tmp, list, mnode)
71		if (parent == -1 || parent == c->mfc_parent)
72			return c;
73
74	return NULL;
75}
76EXPORT_SYMBOL(mr_mfc_find_parent);
77
78void *mr_mfc_find_any_parent(struct mr_table *mrt, int vifi)
79{
80	struct rhlist_head *tmp, *list;
81	struct mr_mfc *c;
82
83	list = rhltable_lookup(&mrt->mfc_hash, mrt->ops.cmparg_any,
84			       *mrt->ops.rht_params);
85	rhl_for_each_entry_rcu(c, tmp, list, mnode)
86		if (c->mfc_un.res.ttls[vifi] < 255)
87			return c;
88
89	return NULL;
90}
91EXPORT_SYMBOL(mr_mfc_find_any_parent);
92
93void *mr_mfc_find_any(struct mr_table *mrt, int vifi, void *hasharg)
94{
95	struct rhlist_head *tmp, *list;
96	struct mr_mfc *c, *proxy;
97
98	list = rhltable_lookup(&mrt->mfc_hash, hasharg, *mrt->ops.rht_params);
99	rhl_for_each_entry_rcu(c, tmp, list, mnode) {
100		if (c->mfc_un.res.ttls[vifi] < 255)
101			return c;
102
103		/* It's ok if the vifi is part of the static tree */
104		proxy = mr_mfc_find_any_parent(mrt, c->mfc_parent);
105		if (proxy && proxy->mfc_un.res.ttls[vifi] < 255)
106			return c;
107	}
108
109	return mr_mfc_find_any_parent(mrt, vifi);
110}
111EXPORT_SYMBOL(mr_mfc_find_any);
112
113#ifdef CONFIG_PROC_FS
114void *mr_vif_seq_idx(struct net *net, struct mr_vif_iter *iter, loff_t pos)
115{
116	struct mr_table *mrt = iter->mrt;
117
118	for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
119		if (!VIF_EXISTS(mrt, iter->ct))
120			continue;
121		if (pos-- == 0)
122			return &mrt->vif_table[iter->ct];
123	}
124	return NULL;
125}
126EXPORT_SYMBOL(mr_vif_seq_idx);
127
128void *mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
129{
130	struct mr_vif_iter *iter = seq->private;
131	struct net *net = seq_file_net(seq);
132	struct mr_table *mrt = iter->mrt;
133
134	++*pos;
135	if (v == SEQ_START_TOKEN)
136		return mr_vif_seq_idx(net, iter, 0);
137
138	while (++iter->ct < mrt->maxvif) {
139		if (!VIF_EXISTS(mrt, iter->ct))
140			continue;
141		return &mrt->vif_table[iter->ct];
142	}
143	return NULL;
144}
145EXPORT_SYMBOL(mr_vif_seq_next);
146
147void *mr_mfc_seq_idx(struct net *net,
148		     struct mr_mfc_iter *it, loff_t pos)
149{
150	struct mr_table *mrt = it->mrt;
151	struct mr_mfc *mfc;
152
153	rcu_read_lock();
154	it->cache = &mrt->mfc_cache_list;
155	list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list)
156		if (pos-- == 0)
157			return mfc;
158	rcu_read_unlock();
159
160	spin_lock_bh(it->lock);
161	it->cache = &mrt->mfc_unres_queue;
162	list_for_each_entry(mfc, it->cache, list)
163		if (pos-- == 0)
164			return mfc;
165	spin_unlock_bh(it->lock);
166
167	it->cache = NULL;
168	return NULL;
169}
170EXPORT_SYMBOL(mr_mfc_seq_idx);
171
172void *mr_mfc_seq_next(struct seq_file *seq, void *v,
173		      loff_t *pos)
174{
175	struct mr_mfc_iter *it = seq->private;
176	struct net *net = seq_file_net(seq);
177	struct mr_table *mrt = it->mrt;
178	struct mr_mfc *c = v;
179
180	++*pos;
181
182	if (v == SEQ_START_TOKEN)
183		return mr_mfc_seq_idx(net, seq->private, 0);
184
185	if (c->list.next != it->cache)
186		return list_entry(c->list.next, struct mr_mfc, list);
187
188	if (it->cache == &mrt->mfc_unres_queue)
189		goto end_of_list;
190
191	/* exhausted cache_array, show unresolved */
192	rcu_read_unlock();
193	it->cache = &mrt->mfc_unres_queue;
194
195	spin_lock_bh(it->lock);
196	if (!list_empty(it->cache))
197		return list_first_entry(it->cache, struct mr_mfc, list);
198
199end_of_list:
200	spin_unlock_bh(it->lock);
201	it->cache = NULL;
202
203	return NULL;
204}
205EXPORT_SYMBOL(mr_mfc_seq_next);
206#endif
207
208int mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
209		   struct mr_mfc *c, struct rtmsg *rtm)
210{
211	struct net_device *vif_dev;
212	struct rta_mfc_stats mfcs;
213	struct nlattr *mp_attr;
214	struct rtnexthop *nhp;
215	unsigned long lastuse;
216	int ct;
217
218	/* If cache is unresolved, don't try to parse IIF and OIF */
219	if (c->mfc_parent >= MAXVIFS) {
220		rtm->rtm_flags |= RTNH_F_UNRESOLVED;
221		return -ENOENT;
222	}
223
224	rcu_read_lock();
225	vif_dev = rcu_dereference(mrt->vif_table[c->mfc_parent].dev);
226	if (vif_dev && nla_put_u32(skb, RTA_IIF, vif_dev->ifindex) < 0) {
227		rcu_read_unlock();
228		return -EMSGSIZE;
229	}
230	rcu_read_unlock();
231
232	if (c->mfc_flags & MFC_OFFLOAD)
233		rtm->rtm_flags |= RTNH_F_OFFLOAD;
234
235	mp_attr = nla_nest_start_noflag(skb, RTA_MULTIPATH);
236	if (!mp_attr)
237		return -EMSGSIZE;
238
239	rcu_read_lock();
240	for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
241		struct vif_device *vif = &mrt->vif_table[ct];
242
243		vif_dev = rcu_dereference(vif->dev);
244		if (vif_dev && c->mfc_un.res.ttls[ct] < 255) {
245
246			nhp = nla_reserve_nohdr(skb, sizeof(*nhp));
247			if (!nhp) {
248				rcu_read_unlock();
249				nla_nest_cancel(skb, mp_attr);
250				return -EMSGSIZE;
251			}
252
253			nhp->rtnh_flags = 0;
254			nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
255			nhp->rtnh_ifindex = vif_dev->ifindex;
256			nhp->rtnh_len = sizeof(*nhp);
257		}
258	}
259	rcu_read_unlock();
260
261	nla_nest_end(skb, mp_attr);
262
263	lastuse = READ_ONCE(c->mfc_un.res.lastuse);
264	lastuse = time_after_eq(jiffies, lastuse) ? jiffies - lastuse : 0;
265
266	mfcs.mfcs_packets = c->mfc_un.res.pkt;
267	mfcs.mfcs_bytes = c->mfc_un.res.bytes;
268	mfcs.mfcs_wrong_if = c->mfc_un.res.wrong_if;
269	if (nla_put_64bit(skb, RTA_MFC_STATS, sizeof(mfcs), &mfcs, RTA_PAD) ||
270	    nla_put_u64_64bit(skb, RTA_EXPIRES, jiffies_to_clock_t(lastuse),
271			      RTA_PAD))
272		return -EMSGSIZE;
273
274	rtm->rtm_type = RTN_MULTICAST;
275	return 1;
276}
277EXPORT_SYMBOL(mr_fill_mroute);
278
279static bool mr_mfc_uses_dev(const struct mr_table *mrt,
280			    const struct mr_mfc *c,
281			    const struct net_device *dev)
282{
283	int ct;
284
285	for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
286		const struct net_device *vif_dev;
287		const struct vif_device *vif;
288
289		vif = &mrt->vif_table[ct];
290		vif_dev = rcu_access_pointer(vif->dev);
291		if (vif_dev && c->mfc_un.res.ttls[ct] < 255 &&
292		    vif_dev == dev)
293			return true;
294	}
295	return false;
296}
297
298int mr_table_dump(struct mr_table *mrt, struct sk_buff *skb,
299		  struct netlink_callback *cb,
300		  int (*fill)(struct mr_table *mrt, struct sk_buff *skb,
301			      u32 portid, u32 seq, struct mr_mfc *c,
302			      int cmd, int flags),
303		  spinlock_t *lock, struct fib_dump_filter *filter)
304{
305	unsigned int e = 0, s_e = cb->args[1];
306	unsigned int flags = NLM_F_MULTI;
307	struct mr_mfc *mfc;
308	int err;
309
310	if (filter->filter_set)
311		flags |= NLM_F_DUMP_FILTERED;
312
313	list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) {
314		if (e < s_e)
315			goto next_entry;
316		if (filter->dev &&
317		    !mr_mfc_uses_dev(mrt, mfc, filter->dev))
318			goto next_entry;
319
320		err = fill(mrt, skb, NETLINK_CB(cb->skb).portid,
321			   cb->nlh->nlmsg_seq, mfc, RTM_NEWROUTE, flags);
322		if (err < 0)
323			goto out;
324next_entry:
325		e++;
326	}
327
328	spin_lock_bh(lock);
329	list_for_each_entry(mfc, &mrt->mfc_unres_queue, list) {
330		if (e < s_e)
331			goto next_entry2;
332		if (filter->dev &&
333		    !mr_mfc_uses_dev(mrt, mfc, filter->dev))
334			goto next_entry2;
335
336		err = fill(mrt, skb, NETLINK_CB(cb->skb).portid,
337			   cb->nlh->nlmsg_seq, mfc, RTM_NEWROUTE, flags);
338		if (err < 0) {
339			spin_unlock_bh(lock);
340			goto out;
341		}
342next_entry2:
343		e++;
344	}
345	spin_unlock_bh(lock);
346	err = 0;
347out:
348	cb->args[1] = e;
349	return err;
350}
351EXPORT_SYMBOL(mr_table_dump);
352
353int mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb,
354		     struct mr_table *(*iter)(struct net *net,
355					      struct mr_table *mrt),
356		     int (*fill)(struct mr_table *mrt,
357				 struct sk_buff *skb,
358				 u32 portid, u32 seq, struct mr_mfc *c,
359				 int cmd, int flags),
360		     spinlock_t *lock, struct fib_dump_filter *filter)
361{
362	unsigned int t = 0, s_t = cb->args[0];
363	struct net *net = sock_net(skb->sk);
364	struct mr_table *mrt;
365	int err;
366
367	/* multicast does not track protocol or have route type other
368	 * than RTN_MULTICAST
369	 */
370	if (filter->filter_set) {
371		if (filter->protocol || filter->flags ||
372		    (filter->rt_type && filter->rt_type != RTN_MULTICAST))
373			return skb->len;
374	}
375
376	rcu_read_lock();
377	for (mrt = iter(net, NULL); mrt; mrt = iter(net, mrt)) {
378		if (t < s_t)
379			goto next_table;
380
381		err = mr_table_dump(mrt, skb, cb, fill, lock, filter);
382		if (err < 0)
383			break;
384		cb->args[1] = 0;
385next_table:
386		t++;
387	}
388	rcu_read_unlock();
389
390	cb->args[0] = t;
391
392	return skb->len;
393}
394EXPORT_SYMBOL(mr_rtm_dumproute);
395
396int mr_dump(struct net *net, struct notifier_block *nb, unsigned short family,
397	    int (*rules_dump)(struct net *net,
398			      struct notifier_block *nb,
399			      struct netlink_ext_ack *extack),
400	    struct mr_table *(*mr_iter)(struct net *net,
401					struct mr_table *mrt),
402	    struct netlink_ext_ack *extack)
403{
404	struct mr_table *mrt;
405	int err;
406
407	err = rules_dump(net, nb, extack);
408	if (err)
409		return err;
410
411	for (mrt = mr_iter(net, NULL); mrt; mrt = mr_iter(net, mrt)) {
412		struct vif_device *v = &mrt->vif_table[0];
413		struct net_device *vif_dev;
414		struct mr_mfc *mfc;
415		int vifi;
416
417		/* Notifiy on table VIF entries */
418		rcu_read_lock();
419		for (vifi = 0; vifi < mrt->maxvif; vifi++, v++) {
420			vif_dev = rcu_dereference(v->dev);
421			if (!vif_dev)
422				continue;
423
424			err = mr_call_vif_notifier(nb, family,
425						   FIB_EVENT_VIF_ADD, v,
426						   vif_dev, vifi,
427						   mrt->id, extack);
428			if (err)
429				break;
430		}
431		rcu_read_unlock();
432
433		if (err)
434			return err;
435
436		/* Notify on table MFC entries */
437		list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) {
438			err = mr_call_mfc_notifier(nb, family,
439						   FIB_EVENT_ENTRY_ADD,
440						   mfc, mrt->id, extack);
441			if (err)
442				return err;
443		}
444	}
445
446	return 0;
447}
448EXPORT_SYMBOL(mr_dump);
449