projects/linux·blob master · refs

450 lines · 10.5 KiB

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