xref: /openbmc/linux/net/ipv6/ila/ila_xlat.c (revision 479965a2) 
1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/jhash.h>
3 #include <linux/netfilter.h>
4 #include <linux/rcupdate.h>
5 #include <linux/rhashtable.h>
6 #include <linux/vmalloc.h>
7 #include <net/genetlink.h>
8 #include <net/netns/generic.h>
9 #include <uapi/linux/genetlink.h>
10 #include "ila.h"
11 
12 struct ila_xlat_params {
13 	struct ila_params ip;
14 	int ifindex;
15 };
16 
17 struct ila_map {
18 	struct ila_xlat_params xp;
19 	struct rhash_head node;
20 	struct ila_map __rcu *next;
21 	struct rcu_head rcu;
22 };
23 
24 #define MAX_LOCKS 1024
25 #define	LOCKS_PER_CPU 10
26 
27 static int alloc_ila_locks(struct ila_net *ilan)
28 {
29 	return alloc_bucket_spinlocks(&ilan->xlat.locks, &ilan->xlat.locks_mask,
30 				      MAX_LOCKS, LOCKS_PER_CPU,
31 				      GFP_KERNEL);
32 }
33 
34 static u32 hashrnd __read_mostly;
35 static __always_inline void __ila_hash_secret_init(void)
36 {
37 	net_get_random_once(&hashrnd, sizeof(hashrnd));
38 }
39 
40 static inline u32 ila_locator_hash(struct ila_locator loc)
41 {
42 	u32 *v = (u32 *)loc.v32;
43 
44 	__ila_hash_secret_init();
45 	return jhash_2words(v[0], v[1], hashrnd);
46 }
47 
48 static inline spinlock_t *ila_get_lock(struct ila_net *ilan,
49 				       struct ila_locator loc)
50 {
51 	return &ilan->xlat.locks[ila_locator_hash(loc) & ilan->xlat.locks_mask];
52 }
53 
54 static inline int ila_cmp_wildcards(struct ila_map *ila,
55 				    struct ila_addr *iaddr, int ifindex)
56 {
57 	return (ila->xp.ifindex && ila->xp.ifindex != ifindex);
58 }
59 
60 static inline int ila_cmp_params(struct ila_map *ila,
61 				 struct ila_xlat_params *xp)
62 {
63 	return (ila->xp.ifindex != xp->ifindex);
64 }
65 
66 static int ila_cmpfn(struct rhashtable_compare_arg *arg,
67 		     const void *obj)
68 {
69 	const struct ila_map *ila = obj;
70 
71 	return (ila->xp.ip.locator_match.v64 != *(__be64 *)arg->key);
72 }
73 
74 static inline int ila_order(struct ila_map *ila)
75 {
76 	int score = 0;
77 
78 	if (ila->xp.ifindex)
79 		score += 1 << 1;
80 
81 	return score;
82 }
83 
84 static const struct rhashtable_params rht_params = {
85 	.nelem_hint = 1024,
86 	.head_offset = offsetof(struct ila_map, node),
87 	.key_offset = offsetof(struct ila_map, xp.ip.locator_match),
88 	.key_len = sizeof(u64), /* identifier */
89 	.max_size = 1048576,
90 	.min_size = 256,
91 	.automatic_shrinking = true,
92 	.obj_cmpfn = ila_cmpfn,
93 };
94 
95 static int parse_nl_config(struct genl_info *info,
96 			   struct ila_xlat_params *xp)
97 {
98 	memset(xp, 0, sizeof(*xp));
99 
100 	if (info->attrs[ILA_ATTR_LOCATOR])
101 		xp->ip.locator.v64 = (__force __be64)nla_get_u64(
102 			info->attrs[ILA_ATTR_LOCATOR]);
103 
104 	if (info->attrs[ILA_ATTR_LOCATOR_MATCH])
105 		xp->ip.locator_match.v64 = (__force __be64)nla_get_u64(
106 			info->attrs[ILA_ATTR_LOCATOR_MATCH]);
107 
108 	if (info->attrs[ILA_ATTR_CSUM_MODE])
109 		xp->ip.csum_mode = nla_get_u8(info->attrs[ILA_ATTR_CSUM_MODE]);
110 	else
111 		xp->ip.csum_mode = ILA_CSUM_NO_ACTION;
112 
113 	if (info->attrs[ILA_ATTR_IDENT_TYPE])
114 		xp->ip.ident_type = nla_get_u8(
115 				info->attrs[ILA_ATTR_IDENT_TYPE]);
116 	else
117 		xp->ip.ident_type = ILA_ATYPE_USE_FORMAT;
118 
119 	if (info->attrs[ILA_ATTR_IFINDEX])
120 		xp->ifindex = nla_get_s32(info->attrs[ILA_ATTR_IFINDEX]);
121 
122 	return 0;
123 }
124 
125 /* Must be called with rcu readlock */
126 static inline struct ila_map *ila_lookup_wildcards(struct ila_addr *iaddr,
127 						   int ifindex,
128 						   struct ila_net *ilan)
129 {
130 	struct ila_map *ila;
131 
132 	ila = rhashtable_lookup_fast(&ilan->xlat.rhash_table, &iaddr->loc,
133 				     rht_params);
134 	while (ila) {
135 		if (!ila_cmp_wildcards(ila, iaddr, ifindex))
136 			return ila;
137 		ila = rcu_access_pointer(ila->next);
138 	}
139 
140 	return NULL;
141 }
142 
143 /* Must be called with rcu readlock */
144 static inline struct ila_map *ila_lookup_by_params(struct ila_xlat_params *xp,
145 						   struct ila_net *ilan)
146 {
147 	struct ila_map *ila;
148 
149 	ila = rhashtable_lookup_fast(&ilan->xlat.rhash_table,
150 				     &xp->ip.locator_match,
151 				     rht_params);
152 	while (ila) {
153 		if (!ila_cmp_params(ila, xp))
154 			return ila;
155 		ila = rcu_access_pointer(ila->next);
156 	}
157 
158 	return NULL;
159 }
160 
161 static inline void ila_release(struct ila_map *ila)
162 {
163 	kfree_rcu(ila, rcu);
164 }
165 
166 static void ila_free_node(struct ila_map *ila)
167 {
168 	struct ila_map *next;
169 
170 	/* Assume rcu_readlock held */
171 	while (ila) {
172 		next = rcu_access_pointer(ila->next);
173 		ila_release(ila);
174 		ila = next;
175 	}
176 }
177 
178 static void ila_free_cb(void *ptr, void *arg)
179 {
180 	ila_free_node((struct ila_map *)ptr);
181 }
182 
183 static int ila_xlat_addr(struct sk_buff *skb, bool sir2ila);
184 
185 static unsigned int
186 ila_nf_input(void *priv,
187 	     struct sk_buff *skb,
188 	     const struct nf_hook_state *state)
189 {
190 	ila_xlat_addr(skb, false);
191 	return NF_ACCEPT;
192 }
193 
194 static const struct nf_hook_ops ila_nf_hook_ops[] = {
195 	{
196 		.hook = ila_nf_input,
197 		.pf = NFPROTO_IPV6,
198 		.hooknum = NF_INET_PRE_ROUTING,
199 		.priority = -1,
200 	},
201 };
202 
203 static int ila_add_mapping(struct net *net, struct ila_xlat_params *xp)
204 {
205 	struct ila_net *ilan = net_generic(net, ila_net_id);
206 	struct ila_map *ila, *head;
207 	spinlock_t *lock = ila_get_lock(ilan, xp->ip.locator_match);
208 	int err = 0, order;
209 
210 	if (!ilan->xlat.hooks_registered) {
211 		/* We defer registering net hooks in the namespace until the
212 		 * first mapping is added.
213 		 */
214 		err = nf_register_net_hooks(net, ila_nf_hook_ops,
215 					    ARRAY_SIZE(ila_nf_hook_ops));
216 		if (err)
217 			return err;
218 
219 		ilan->xlat.hooks_registered = true;
220 	}
221 
222 	ila = kzalloc(sizeof(*ila), GFP_KERNEL);
223 	if (!ila)
224 		return -ENOMEM;
225 
226 	ila_init_saved_csum(&xp->ip);
227 
228 	ila->xp = *xp;
229 
230 	order = ila_order(ila);
231 
232 	spin_lock(lock);
233 
234 	head = rhashtable_lookup_fast(&ilan->xlat.rhash_table,
235 				      &xp->ip.locator_match,
236 				      rht_params);
237 	if (!head) {
238 		/* New entry for the rhash_table */
239 		err = rhashtable_lookup_insert_fast(&ilan->xlat.rhash_table,
240 						    &ila->node, rht_params);
241 	} else {
242 		struct ila_map *tila = head, *prev = NULL;
243 
244 		do {
245 			if (!ila_cmp_params(tila, xp)) {
246 				err = -EEXIST;
247 				goto out;
248 			}
249 
250 			if (order > ila_order(tila))
251 				break;
252 
253 			prev = tila;
254 			tila = rcu_dereference_protected(tila->next,
255 				lockdep_is_held(lock));
256 		} while (tila);
257 
258 		if (prev) {
259 			/* Insert in sub list of head */
260 			RCU_INIT_POINTER(ila->next, tila);
261 			rcu_assign_pointer(prev->next, ila);
262 		} else {
263 			/* Make this ila new head */
264 			RCU_INIT_POINTER(ila->next, head);
265 			err = rhashtable_replace_fast(&ilan->xlat.rhash_table,
266 						      &head->node,
267 						      &ila->node, rht_params);
268 			if (err)
269 				goto out;
270 		}
271 	}
272 
273 out:
274 	spin_unlock(lock);
275 
276 	if (err)
277 		kfree(ila);
278 
279 	return err;
280 }
281 
282 static int ila_del_mapping(struct net *net, struct ila_xlat_params *xp)
283 {
284 	struct ila_net *ilan = net_generic(net, ila_net_id);
285 	struct ila_map *ila, *head, *prev;
286 	spinlock_t *lock = ila_get_lock(ilan, xp->ip.locator_match);
287 	int err = -ENOENT;
288 
289 	spin_lock(lock);
290 
291 	head = rhashtable_lookup_fast(&ilan->xlat.rhash_table,
292 				      &xp->ip.locator_match, rht_params);
293 	ila = head;
294 
295 	prev = NULL;
296 
297 	while (ila) {
298 		if (ila_cmp_params(ila, xp)) {
299 			prev = ila;
300 			ila = rcu_dereference_protected(ila->next,
301 							lockdep_is_held(lock));
302 			continue;
303 		}
304 
305 		err = 0;
306 
307 		if (prev) {
308 			/* Not head, just delete from list */
309 			rcu_assign_pointer(prev->next, ila->next);
310 		} else {
311 			/* It is the head. If there is something in the
312 			 * sublist we need to make a new head.
313 			 */
314 			head = rcu_dereference_protected(ila->next,
315 							 lockdep_is_held(lock));
316 			if (head) {
317 				/* Put first entry in the sublist into the
318 				 * table
319 				 */
320 				err = rhashtable_replace_fast(
321 					&ilan->xlat.rhash_table, &ila->node,
322 					&head->node, rht_params);
323 				if (err)
324 					goto out;
325 			} else {
326 				/* Entry no longer used */
327 				err = rhashtable_remove_fast(
328 						&ilan->xlat.rhash_table,
329 						&ila->node, rht_params);
330 			}
331 		}
332 
333 		ila_release(ila);
334 
335 		break;
336 	}
337 
338 out:
339 	spin_unlock(lock);
340 
341 	return err;
342 }
343 
344 int ila_xlat_nl_cmd_add_mapping(struct sk_buff *skb, struct genl_info *info)
345 {
346 	struct net *net = genl_info_net(info);
347 	struct ila_xlat_params p;
348 	int err;
349 
350 	err = parse_nl_config(info, &p);
351 	if (err)
352 		return err;
353 
354 	return ila_add_mapping(net, &p);
355 }
356 
357 int ila_xlat_nl_cmd_del_mapping(struct sk_buff *skb, struct genl_info *info)
358 {
359 	struct net *net = genl_info_net(info);
360 	struct ila_xlat_params xp;
361 	int err;
362 
363 	err = parse_nl_config(info, &xp);
364 	if (err)
365 		return err;
366 
367 	ila_del_mapping(net, &xp);
368 
369 	return 0;
370 }
371 
372 static inline spinlock_t *lock_from_ila_map(struct ila_net *ilan,
373 					    struct ila_map *ila)
374 {
375 	return ila_get_lock(ilan, ila->xp.ip.locator_match);
376 }
377 
378 int ila_xlat_nl_cmd_flush(struct sk_buff *skb, struct genl_info *info)
379 {
380 	struct net *net = genl_info_net(info);
381 	struct ila_net *ilan = net_generic(net, ila_net_id);
382 	struct rhashtable_iter iter;
383 	struct ila_map *ila;
384 	spinlock_t *lock;
385 	int ret = 0;
386 
387 	rhashtable_walk_enter(&ilan->xlat.rhash_table, &iter);
388 	rhashtable_walk_start(&iter);
389 
390 	for (;;) {
391 		ila = rhashtable_walk_next(&iter);
392 
393 		if (IS_ERR(ila)) {
394 			if (PTR_ERR(ila) == -EAGAIN)
395 				continue;
396 			ret = PTR_ERR(ila);
397 			goto done;
398 		} else if (!ila) {
399 			break;
400 		}
401 
402 		lock = lock_from_ila_map(ilan, ila);
403 
404 		spin_lock(lock);
405 
406 		ret = rhashtable_remove_fast(&ilan->xlat.rhash_table,
407 					     &ila->node, rht_params);
408 		if (!ret)
409 			ila_free_node(ila);
410 
411 		spin_unlock(lock);
412 
413 		if (ret)
414 			break;
415 	}
416 
417 done:
418 	rhashtable_walk_stop(&iter);
419 	rhashtable_walk_exit(&iter);
420 	return ret;
421 }
422 
423 static int ila_fill_info(struct ila_map *ila, struct sk_buff *msg)
424 {
425 	if (nla_put_u64_64bit(msg, ILA_ATTR_LOCATOR,
426 			      (__force u64)ila->xp.ip.locator.v64,
427 			      ILA_ATTR_PAD) ||
428 	    nla_put_u64_64bit(msg, ILA_ATTR_LOCATOR_MATCH,
429 			      (__force u64)ila->xp.ip.locator_match.v64,
430 			      ILA_ATTR_PAD) ||
431 	    nla_put_s32(msg, ILA_ATTR_IFINDEX, ila->xp.ifindex) ||
432 	    nla_put_u8(msg, ILA_ATTR_CSUM_MODE, ila->xp.ip.csum_mode) ||
433 	    nla_put_u8(msg, ILA_ATTR_IDENT_TYPE, ila->xp.ip.ident_type))
434 		return -1;
435 
436 	return 0;
437 }
438 
439 static int ila_dump_info(struct ila_map *ila,
440 			 u32 portid, u32 seq, u32 flags,
441 			 struct sk_buff *skb, u8 cmd)
442 {
443 	void *hdr;
444 
445 	hdr = genlmsg_put(skb, portid, seq, &ila_nl_family, flags, cmd);
446 	if (!hdr)
447 		return -ENOMEM;
448 
449 	if (ila_fill_info(ila, skb) < 0)
450 		goto nla_put_failure;
451 
452 	genlmsg_end(skb, hdr);
453 	return 0;
454 
455 nla_put_failure:
456 	genlmsg_cancel(skb, hdr);
457 	return -EMSGSIZE;
458 }
459 
460 int ila_xlat_nl_cmd_get_mapping(struct sk_buff *skb, struct genl_info *info)
461 {
462 	struct net *net = genl_info_net(info);
463 	struct ila_net *ilan = net_generic(net, ila_net_id);
464 	struct sk_buff *msg;
465 	struct ila_xlat_params xp;
466 	struct ila_map *ila;
467 	int ret;
468 
469 	ret = parse_nl_config(info, &xp);
470 	if (ret)
471 		return ret;
472 
473 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
474 	if (!msg)
475 		return -ENOMEM;
476 
477 	rcu_read_lock();
478 
479 	ret = -ESRCH;
480 	ila = ila_lookup_by_params(&xp, ilan);
481 	if (ila) {
482 		ret = ila_dump_info(ila,
483 				    info->snd_portid,
484 				    info->snd_seq, 0, msg,
485 				    info->genlhdr->cmd);
486 	}
487 
488 	rcu_read_unlock();
489 
490 	if (ret < 0)
491 		goto out_free;
492 
493 	return genlmsg_reply(msg, info);
494 
495 out_free:
496 	nlmsg_free(msg);
497 	return ret;
498 }
499 
500 struct ila_dump_iter {
501 	struct rhashtable_iter rhiter;
502 	int skip;
503 };
504 
505 int ila_xlat_nl_dump_start(struct netlink_callback *cb)
506 {
507 	struct net *net = sock_net(cb->skb->sk);
508 	struct ila_net *ilan = net_generic(net, ila_net_id);
509 	struct ila_dump_iter *iter;
510 
511 	iter = kmalloc(sizeof(*iter), GFP_KERNEL);
512 	if (!iter)
513 		return -ENOMEM;
514 
515 	rhashtable_walk_enter(&ilan->xlat.rhash_table, &iter->rhiter);
516 
517 	iter->skip = 0;
518 	cb->args[0] = (long)iter;
519 
520 	return 0;
521 }
522 
523 int ila_xlat_nl_dump_done(struct netlink_callback *cb)
524 {
525 	struct ila_dump_iter *iter = (struct ila_dump_iter *)cb->args[0];
526 
527 	rhashtable_walk_exit(&iter->rhiter);
528 
529 	kfree(iter);
530 
531 	return 0;
532 }
533 
534 int ila_xlat_nl_dump(struct sk_buff *skb, struct netlink_callback *cb)
535 {
536 	struct ila_dump_iter *iter = (struct ila_dump_iter *)cb->args[0];
537 	struct rhashtable_iter *rhiter = &iter->rhiter;
538 	int skip = iter->skip;
539 	struct ila_map *ila;
540 	int ret;
541 
542 	rhashtable_walk_start(rhiter);
543 
544 	/* Get first entry */
545 	ila = rhashtable_walk_peek(rhiter);
546 
547 	if (ila && !IS_ERR(ila) && skip) {
548 		/* Skip over visited entries */
549 
550 		while (ila && skip) {
551 			/* Skip over any ila entries in this list that we
552 			 * have already dumped.
553 			 */
554 			ila = rcu_access_pointer(ila->next);
555 			skip--;
556 		}
557 	}
558 
559 	skip = 0;
560 
561 	for (;;) {
562 		if (IS_ERR(ila)) {
563 			ret = PTR_ERR(ila);
564 			if (ret == -EAGAIN) {
565 				/* Table has changed and iter has reset. Return
566 				 * -EAGAIN to the application even if we have
567 				 * written data to the skb. The application
568 				 * needs to deal with this.
569 				 */
570 
571 				goto out_ret;
572 			} else {
573 				break;
574 			}
575 		} else if (!ila) {
576 			ret = 0;
577 			break;
578 		}
579 
580 		while (ila) {
581 			ret =  ila_dump_info(ila, NETLINK_CB(cb->skb).portid,
582 					     cb->nlh->nlmsg_seq, NLM_F_MULTI,
583 					     skb, ILA_CMD_GET);
584 			if (ret)
585 				goto out;
586 
587 			skip++;
588 			ila = rcu_access_pointer(ila->next);
589 		}
590 
591 		skip = 0;
592 		ila = rhashtable_walk_next(rhiter);
593 	}
594 
595 out:
596 	iter->skip = skip;
597 	ret = (skb->len ? : ret);
598 
599 out_ret:
600 	rhashtable_walk_stop(rhiter);
601 	return ret;
602 }
603 
604 int ila_xlat_init_net(struct net *net)
605 {
606 	struct ila_net *ilan = net_generic(net, ila_net_id);
607 	int err;
608 
609 	err = alloc_ila_locks(ilan);
610 	if (err)
611 		return err;
612 
613 	err = rhashtable_init(&ilan->xlat.rhash_table, &rht_params);
614 	if (err) {
615 		free_bucket_spinlocks(ilan->xlat.locks);
616 		return err;
617 	}
618 
619 	return 0;
620 }
621 
622 void ila_xlat_exit_net(struct net *net)
623 {
624 	struct ila_net *ilan = net_generic(net, ila_net_id);
625 
626 	rhashtable_free_and_destroy(&ilan->xlat.rhash_table, ila_free_cb, NULL);
627 
628 	free_bucket_spinlocks(ilan->xlat.locks);
629 
630 	if (ilan->xlat.hooks_registered)
631 		nf_unregister_net_hooks(net, ila_nf_hook_ops,
632 					ARRAY_SIZE(ila_nf_hook_ops));
633 }
634 
635 static int ila_xlat_addr(struct sk_buff *skb, bool sir2ila)
636 {
637 	struct ila_map *ila;
638 	struct ipv6hdr *ip6h = ipv6_hdr(skb);
639 	struct net *net = dev_net(skb->dev);
640 	struct ila_net *ilan = net_generic(net, ila_net_id);
641 	struct ila_addr *iaddr = ila_a2i(&ip6h->daddr);
642 
643 	/* Assumes skb contains a valid IPv6 header that is pulled */
644 
645 	/* No check here that ILA type in the mapping matches what is in the
646 	 * address. We assume that whatever sender gaves us can be translated.
647 	 * The checksum mode however is relevant.
648 	 */
649 
650 	rcu_read_lock();
651 
652 	ila = ila_lookup_wildcards(iaddr, skb->dev->ifindex, ilan);
653 	if (ila)
654 		ila_update_ipv6_locator(skb, &ila->xp.ip, sir2ila);
655 
656 	rcu_read_unlock();
657 
658 	return 0;
659 }
660