1 #include <linux/jhash.h>
2 #include <linux/netfilter.h>
3 #include <linux/rcupdate.h>
4 #include <linux/rhashtable.h>
5 #include <linux/vmalloc.h>
6 #include <net/genetlink.h>
8 #include <net/netns/generic.h>
9 #include <uapi/linux/genetlink.h>
12 struct ila_xlat_params {
18 struct ila_xlat_params xp;
19 struct rhash_head node;
20 struct ila_map __rcu *next;
24 static unsigned int ila_net_id;
27 struct rhashtable rhash_table;
28 spinlock_t *locks; /* Bucket locks for entry manipulation */
29 unsigned int locks_mask;
30 bool hooks_registered;
33 #define LOCKS_PER_CPU 10
35 static int alloc_ila_locks(struct ila_net *ilan)
38 unsigned int nr_pcpus = num_possible_cpus();
40 nr_pcpus = min_t(unsigned int, nr_pcpus, 32UL);
41 size = roundup_pow_of_two(nr_pcpus * LOCKS_PER_CPU);
43 if (sizeof(spinlock_t) != 0) {
45 if (size * sizeof(spinlock_t) > PAGE_SIZE)
46 ilan->locks = vmalloc(size * sizeof(spinlock_t));
49 ilan->locks = kmalloc_array(size, sizeof(spinlock_t),
53 for (i = 0; i < size; i++)
54 spin_lock_init(&ilan->locks[i]);
56 ilan->locks_mask = size - 1;
61 static u32 hashrnd __read_mostly;
62 static __always_inline void __ila_hash_secret_init(void)
64 net_get_random_once(&hashrnd, sizeof(hashrnd));
67 static inline u32 ila_locator_hash(struct ila_locator loc)
69 u32 *v = (u32 *)loc.v32;
71 return jhash_2words(v[0], v[1], hashrnd);
74 static inline spinlock_t *ila_get_lock(struct ila_net *ilan,
75 struct ila_locator loc)
77 return &ilan->locks[ila_locator_hash(loc) & ilan->locks_mask];
80 static inline int ila_cmp_wildcards(struct ila_map *ila,
81 struct ila_addr *iaddr, int ifindex)
83 return (ila->xp.ifindex && ila->xp.ifindex != ifindex);
86 static inline int ila_cmp_params(struct ila_map *ila,
87 struct ila_xlat_params *xp)
89 return (ila->xp.ifindex != xp->ifindex);
92 static int ila_cmpfn(struct rhashtable_compare_arg *arg,
95 const struct ila_map *ila = obj;
97 return (ila->xp.ip.locator_match.v64 != *(__be64 *)arg->key);
100 static inline int ila_order(struct ila_map *ila)
110 static const struct rhashtable_params rht_params = {
112 .head_offset = offsetof(struct ila_map, node),
113 .key_offset = offsetof(struct ila_map, xp.ip.locator_match),
114 .key_len = sizeof(u64), /* identifier */
117 .automatic_shrinking = true,
118 .obj_cmpfn = ila_cmpfn,
121 static struct genl_family ila_nl_family = {
123 .name = ILA_GENL_NAME,
124 .version = ILA_GENL_VERSION,
125 .maxattr = ILA_ATTR_MAX,
127 .parallel_ops = true,
130 static const struct nla_policy ila_nl_policy[ILA_ATTR_MAX + 1] = {
131 [ILA_ATTR_LOCATOR] = { .type = NLA_U64, },
132 [ILA_ATTR_LOCATOR_MATCH] = { .type = NLA_U64, },
133 [ILA_ATTR_IFINDEX] = { .type = NLA_U32, },
134 [ILA_ATTR_CSUM_MODE] = { .type = NLA_U8, },
137 static int parse_nl_config(struct genl_info *info,
138 struct ila_xlat_params *xp)
140 memset(xp, 0, sizeof(*xp));
142 if (info->attrs[ILA_ATTR_LOCATOR])
143 xp->ip.locator.v64 = (__force __be64)nla_get_u64(
144 info->attrs[ILA_ATTR_LOCATOR]);
146 if (info->attrs[ILA_ATTR_LOCATOR_MATCH])
147 xp->ip.locator_match.v64 = (__force __be64)nla_get_u64(
148 info->attrs[ILA_ATTR_LOCATOR_MATCH]);
150 if (info->attrs[ILA_ATTR_CSUM_MODE])
151 xp->ip.csum_mode = nla_get_u8(info->attrs[ILA_ATTR_CSUM_MODE]);
153 if (info->attrs[ILA_ATTR_IFINDEX])
154 xp->ifindex = nla_get_s32(info->attrs[ILA_ATTR_IFINDEX]);
159 /* Must be called with rcu readlock */
160 static inline struct ila_map *ila_lookup_wildcards(struct ila_addr *iaddr,
162 struct ila_net *ilan)
166 ila = rhashtable_lookup_fast(&ilan->rhash_table, &iaddr->loc,
169 if (!ila_cmp_wildcards(ila, iaddr, ifindex))
171 ila = rcu_access_pointer(ila->next);
177 /* Must be called with rcu readlock */
178 static inline struct ila_map *ila_lookup_by_params(struct ila_xlat_params *xp,
179 struct ila_net *ilan)
183 ila = rhashtable_lookup_fast(&ilan->rhash_table,
184 &xp->ip.locator_match,
187 if (!ila_cmp_params(ila, xp))
189 ila = rcu_access_pointer(ila->next);
195 static inline void ila_release(struct ila_map *ila)
200 static void ila_free_cb(void *ptr, void *arg)
202 struct ila_map *ila = (struct ila_map *)ptr, *next;
204 /* Assume rcu_readlock held */
206 next = rcu_access_pointer(ila->next);
212 static int ila_xlat_addr(struct sk_buff *skb, bool set_csum_neutral);
215 ila_nf_input(void *priv,
217 const struct nf_hook_state *state)
219 ila_xlat_addr(skb, false);
223 static struct nf_hook_ops ila_nf_hook_ops[] __read_mostly = {
225 .hook = ila_nf_input,
227 .hooknum = NF_INET_PRE_ROUTING,
232 static int ila_add_mapping(struct net *net, struct ila_xlat_params *xp)
234 struct ila_net *ilan = net_generic(net, ila_net_id);
235 struct ila_map *ila, *head;
236 spinlock_t *lock = ila_get_lock(ilan, xp->ip.locator_match);
239 if (!ilan->hooks_registered) {
240 /* We defer registering net hooks in the namespace until the
241 * first mapping is added.
243 err = nf_register_net_hooks(net, ila_nf_hook_ops,
244 ARRAY_SIZE(ila_nf_hook_ops));
248 ilan->hooks_registered = true;
251 ila = kzalloc(sizeof(*ila), GFP_KERNEL);
255 ila_init_saved_csum(&xp->ip);
259 order = ila_order(ila);
263 head = rhashtable_lookup_fast(&ilan->rhash_table,
264 &xp->ip.locator_match,
267 /* New entry for the rhash_table */
268 err = rhashtable_lookup_insert_fast(&ilan->rhash_table,
269 &ila->node, rht_params);
271 struct ila_map *tila = head, *prev = NULL;
274 if (!ila_cmp_params(tila, xp)) {
279 if (order > ila_order(tila))
283 tila = rcu_dereference_protected(tila->next,
284 lockdep_is_held(lock));
288 /* Insert in sub list of head */
289 RCU_INIT_POINTER(ila->next, tila);
290 rcu_assign_pointer(prev->next, ila);
292 /* Make this ila new head */
293 RCU_INIT_POINTER(ila->next, head);
294 err = rhashtable_replace_fast(&ilan->rhash_table,
296 &ila->node, rht_params);
311 static int ila_del_mapping(struct net *net, struct ila_xlat_params *xp)
313 struct ila_net *ilan = net_generic(net, ila_net_id);
314 struct ila_map *ila, *head, *prev;
315 spinlock_t *lock = ila_get_lock(ilan, xp->ip.locator_match);
320 head = rhashtable_lookup_fast(&ilan->rhash_table,
321 &xp->ip.locator_match, rht_params);
327 if (ila_cmp_params(ila, xp)) {
329 ila = rcu_dereference_protected(ila->next,
330 lockdep_is_held(lock));
337 /* Not head, just delete from list */
338 rcu_assign_pointer(prev->next, ila->next);
340 /* It is the head. If there is something in the
341 * sublist we need to make a new head.
343 head = rcu_dereference_protected(ila->next,
344 lockdep_is_held(lock));
346 /* Put first entry in the sublist into the
349 err = rhashtable_replace_fast(
350 &ilan->rhash_table, &ila->node,
351 &head->node, rht_params);
355 /* Entry no longer used */
356 err = rhashtable_remove_fast(&ilan->rhash_table,
373 static int ila_nl_cmd_add_mapping(struct sk_buff *skb, struct genl_info *info)
375 struct net *net = genl_info_net(info);
376 struct ila_xlat_params p;
379 err = parse_nl_config(info, &p);
383 return ila_add_mapping(net, &p);
386 static int ila_nl_cmd_del_mapping(struct sk_buff *skb, struct genl_info *info)
388 struct net *net = genl_info_net(info);
389 struct ila_xlat_params xp;
392 err = parse_nl_config(info, &xp);
396 ila_del_mapping(net, &xp);
401 static int ila_fill_info(struct ila_map *ila, struct sk_buff *msg)
403 if (nla_put_u64_64bit(msg, ILA_ATTR_LOCATOR,
404 (__force u64)ila->xp.ip.locator.v64,
406 nla_put_u64_64bit(msg, ILA_ATTR_LOCATOR_MATCH,
407 (__force u64)ila->xp.ip.locator_match.v64,
409 nla_put_s32(msg, ILA_ATTR_IFINDEX, ila->xp.ifindex) ||
410 nla_put_u32(msg, ILA_ATTR_CSUM_MODE, ila->xp.ip.csum_mode))
416 static int ila_dump_info(struct ila_map *ila,
417 u32 portid, u32 seq, u32 flags,
418 struct sk_buff *skb, u8 cmd)
422 hdr = genlmsg_put(skb, portid, seq, &ila_nl_family, flags, cmd);
426 if (ila_fill_info(ila, skb) < 0)
427 goto nla_put_failure;
429 genlmsg_end(skb, hdr);
433 genlmsg_cancel(skb, hdr);
437 static int ila_nl_cmd_get_mapping(struct sk_buff *skb, struct genl_info *info)
439 struct net *net = genl_info_net(info);
440 struct ila_net *ilan = net_generic(net, ila_net_id);
442 struct ila_xlat_params xp;
446 ret = parse_nl_config(info, &xp);
450 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
456 ila = ila_lookup_by_params(&xp, ilan);
458 ret = ila_dump_info(ila,
460 info->snd_seq, 0, msg,
469 return genlmsg_reply(msg, info);
476 struct ila_dump_iter {
477 struct rhashtable_iter rhiter;
480 static int ila_nl_dump_start(struct netlink_callback *cb)
482 struct net *net = sock_net(cb->skb->sk);
483 struct ila_net *ilan = net_generic(net, ila_net_id);
484 struct ila_dump_iter *iter = (struct ila_dump_iter *)cb->args;
486 return rhashtable_walk_init(&ilan->rhash_table, &iter->rhiter,
490 static int ila_nl_dump_done(struct netlink_callback *cb)
492 struct ila_dump_iter *iter = (struct ila_dump_iter *)cb->args;
494 rhashtable_walk_exit(&iter->rhiter);
499 static int ila_nl_dump(struct sk_buff *skb, struct netlink_callback *cb)
501 struct ila_dump_iter *iter = (struct ila_dump_iter *)cb->args;
502 struct rhashtable_iter *rhiter = &iter->rhiter;
506 ret = rhashtable_walk_start(rhiter);
507 if (ret && ret != -EAGAIN)
511 ila = rhashtable_walk_next(rhiter);
514 if (PTR_ERR(ila) == -EAGAIN)
523 ret = ila_dump_info(ila, NETLINK_CB(cb->skb).portid,
524 cb->nlh->nlmsg_seq, NLM_F_MULTI,
529 ila = rcu_access_pointer(ila->next);
536 rhashtable_walk_stop(rhiter);
540 static const struct genl_ops ila_nl_ops[] = {
543 .doit = ila_nl_cmd_add_mapping,
544 .policy = ila_nl_policy,
545 .flags = GENL_ADMIN_PERM,
549 .doit = ila_nl_cmd_del_mapping,
550 .policy = ila_nl_policy,
551 .flags = GENL_ADMIN_PERM,
555 .doit = ila_nl_cmd_get_mapping,
556 .start = ila_nl_dump_start,
557 .dumpit = ila_nl_dump,
558 .done = ila_nl_dump_done,
559 .policy = ila_nl_policy,
563 #define ILA_HASH_TABLE_SIZE 1024
565 static __net_init int ila_init_net(struct net *net)
568 struct ila_net *ilan = net_generic(net, ila_net_id);
570 err = alloc_ila_locks(ilan);
574 rhashtable_init(&ilan->rhash_table, &rht_params);
579 static __net_exit void ila_exit_net(struct net *net)
581 struct ila_net *ilan = net_generic(net, ila_net_id);
583 rhashtable_free_and_destroy(&ilan->rhash_table, ila_free_cb, NULL);
587 if (ilan->hooks_registered)
588 nf_unregister_net_hooks(net, ila_nf_hook_ops,
589 ARRAY_SIZE(ila_nf_hook_ops));
592 static struct pernet_operations ila_net_ops = {
593 .init = ila_init_net,
594 .exit = ila_exit_net,
596 .size = sizeof(struct ila_net),
599 static int ila_xlat_addr(struct sk_buff *skb, bool set_csum_neutral)
602 struct ipv6hdr *ip6h = ipv6_hdr(skb);
603 struct net *net = dev_net(skb->dev);
604 struct ila_net *ilan = net_generic(net, ila_net_id);
605 struct ila_addr *iaddr = ila_a2i(&ip6h->daddr);
607 /* Assumes skb contains a valid IPv6 header that is pulled */
609 if (!ila_addr_is_ila(iaddr)) {
610 /* Type indicates this is not an ILA address */
616 ila = ila_lookup_wildcards(iaddr, skb->dev->ifindex, ilan);
618 ila_update_ipv6_locator(skb, &ila->xp.ip, set_csum_neutral);
625 int ila_xlat_init(void)
629 ret = register_pernet_device(&ila_net_ops);
633 ret = genl_register_family_with_ops(&ila_nl_family,
641 unregister_pernet_device(&ila_net_ops);
646 void ila_xlat_fini(void)
648 genl_unregister_family(&ila_nl_family);
649 unregister_pernet_device(&ila_net_ops);