2 * net/core/fib_rules.c Generic Routing Rules
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation, version 2.
8 * Authors: Thomas Graf <tgraf@suug.ch>
11 #include <linux/types.h>
12 #include <linux/kernel.h>
13 #include <linux/slab.h>
14 #include <linux/list.h>
15 #include <linux/module.h>
16 #include <net/net_namespace.h>
18 #include <net/fib_rules.h>
19 #include <net/ip_tunnels.h>
21 int fib_default_rule_add(struct fib_rules_ops
*ops
,
22 u32 pref
, u32 table
, u32 flags
)
26 r
= kzalloc(ops
->rule_size
, GFP_KERNEL
);
30 atomic_set(&r
->refcnt
, 1);
31 r
->action
= FR_ACT_TO_TBL
;
35 r
->fr_net
= ops
->fro_net
;
37 r
->suppress_prefixlen
= -1;
38 r
->suppress_ifgroup
= -1;
40 /* The lock is not required here, the list in unreacheable
41 * at the moment this function is called */
42 list_add_tail(&r
->list
, &ops
->rules_list
);
45 EXPORT_SYMBOL(fib_default_rule_add
);
47 static u32
fib_default_rule_pref(struct fib_rules_ops
*ops
)
49 struct list_head
*pos
;
50 struct fib_rule
*rule
;
52 if (!list_empty(&ops
->rules_list
)) {
53 pos
= ops
->rules_list
.next
;
54 if (pos
->next
!= &ops
->rules_list
) {
55 rule
= list_entry(pos
->next
, struct fib_rule
, list
);
57 return rule
->pref
- 1;
64 static void notify_rule_change(int event
, struct fib_rule
*rule
,
65 struct fib_rules_ops
*ops
, struct nlmsghdr
*nlh
,
68 static struct fib_rules_ops
*lookup_rules_ops(struct net
*net
, int family
)
70 struct fib_rules_ops
*ops
;
73 list_for_each_entry_rcu(ops
, &net
->rules_ops
, list
) {
74 if (ops
->family
== family
) {
75 if (!try_module_get(ops
->owner
))
86 static void rules_ops_put(struct fib_rules_ops
*ops
)
89 module_put(ops
->owner
);
92 static void flush_route_cache(struct fib_rules_ops
*ops
)
95 ops
->flush_cache(ops
);
98 static int __fib_rules_register(struct fib_rules_ops
*ops
)
101 struct fib_rules_ops
*o
;
106 if (ops
->rule_size
< sizeof(struct fib_rule
))
109 if (ops
->match
== NULL
|| ops
->configure
== NULL
||
110 ops
->compare
== NULL
|| ops
->fill
== NULL
||
114 spin_lock(&net
->rules_mod_lock
);
115 list_for_each_entry(o
, &net
->rules_ops
, list
)
116 if (ops
->family
== o
->family
)
119 list_add_tail_rcu(&ops
->list
, &net
->rules_ops
);
122 spin_unlock(&net
->rules_mod_lock
);
127 struct fib_rules_ops
*
128 fib_rules_register(const struct fib_rules_ops
*tmpl
, struct net
*net
)
130 struct fib_rules_ops
*ops
;
133 ops
= kmemdup(tmpl
, sizeof(*ops
), GFP_KERNEL
);
135 return ERR_PTR(-ENOMEM
);
137 INIT_LIST_HEAD(&ops
->rules_list
);
140 err
= __fib_rules_register(ops
);
148 EXPORT_SYMBOL_GPL(fib_rules_register
);
150 static void fib_rules_cleanup_ops(struct fib_rules_ops
*ops
)
152 struct fib_rule
*rule
, *tmp
;
154 list_for_each_entry_safe(rule
, tmp
, &ops
->rules_list
, list
) {
155 list_del_rcu(&rule
->list
);
162 void fib_rules_unregister(struct fib_rules_ops
*ops
)
164 struct net
*net
= ops
->fro_net
;
166 spin_lock(&net
->rules_mod_lock
);
167 list_del_rcu(&ops
->list
);
168 spin_unlock(&net
->rules_mod_lock
);
170 fib_rules_cleanup_ops(ops
);
173 EXPORT_SYMBOL_GPL(fib_rules_unregister
);
175 static int fib_rule_match(struct fib_rule
*rule
, struct fib_rules_ops
*ops
,
176 struct flowi
*fl
, int flags
,
177 struct fib_lookup_arg
*arg
)
181 if (rule
->iifindex
&& (rule
->iifindex
!= fl
->flowi_iif
))
184 if (rule
->oifindex
&& (rule
->oifindex
!= fl
->flowi_oif
))
187 if ((rule
->mark
^ fl
->flowi_mark
) & rule
->mark_mask
)
190 if (rule
->tun_id
&& (rule
->tun_id
!= fl
->flowi_tun_key
.tun_id
))
193 if (rule
->l3mdev
&& !l3mdev_fib_rule_match(rule
->fr_net
, fl
, arg
))
196 ret
= ops
->match(rule
, fl
, flags
);
198 return (rule
->flags
& FIB_RULE_INVERT
) ? !ret
: ret
;
201 int fib_rules_lookup(struct fib_rules_ops
*ops
, struct flowi
*fl
,
202 int flags
, struct fib_lookup_arg
*arg
)
204 struct fib_rule
*rule
;
209 list_for_each_entry_rcu(rule
, &ops
->rules_list
, list
) {
211 if (!fib_rule_match(rule
, ops
, fl
, flags
, arg
))
214 if (rule
->action
== FR_ACT_GOTO
) {
215 struct fib_rule
*target
;
217 target
= rcu_dereference(rule
->ctarget
);
218 if (target
== NULL
) {
224 } else if (rule
->action
== FR_ACT_NOP
)
227 err
= ops
->action(rule
, fl
, flags
, arg
);
229 if (!err
&& ops
->suppress
&& ops
->suppress(rule
, arg
))
232 if (err
!= -EAGAIN
) {
233 if ((arg
->flags
& FIB_LOOKUP_NOREF
) ||
234 likely(atomic_inc_not_zero(&rule
->refcnt
))) {
248 EXPORT_SYMBOL_GPL(fib_rules_lookup
);
250 static int validate_rulemsg(struct fib_rule_hdr
*frh
, struct nlattr
**tb
,
251 struct fib_rules_ops
*ops
)
256 if (tb
[FRA_SRC
] == NULL
||
257 frh
->src_len
> (ops
->addr_size
* 8) ||
258 nla_len(tb
[FRA_SRC
]) != ops
->addr_size
)
262 if (tb
[FRA_DST
] == NULL
||
263 frh
->dst_len
> (ops
->addr_size
* 8) ||
264 nla_len(tb
[FRA_DST
]) != ops
->addr_size
)
272 int fib_nl_newrule(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
274 struct net
*net
= sock_net(skb
->sk
);
275 struct fib_rule_hdr
*frh
= nlmsg_data(nlh
);
276 struct fib_rules_ops
*ops
= NULL
;
277 struct fib_rule
*rule
, *r
, *last
= NULL
;
278 struct nlattr
*tb
[FRA_MAX
+1];
279 int err
= -EINVAL
, unresolved
= 0;
281 if (nlh
->nlmsg_len
< nlmsg_msg_size(sizeof(*frh
)))
284 ops
= lookup_rules_ops(net
, frh
->family
);
290 err
= nlmsg_parse(nlh
, sizeof(*frh
), tb
, FRA_MAX
, ops
->policy
);
294 err
= validate_rulemsg(frh
, tb
, ops
);
298 rule
= kzalloc(ops
->rule_size
, GFP_KERNEL
);
305 rule
->pref
= tb
[FRA_PRIORITY
] ? nla_get_u32(tb
[FRA_PRIORITY
])
306 : fib_default_rule_pref(ops
);
308 if (tb
[FRA_IIFNAME
]) {
309 struct net_device
*dev
;
312 nla_strlcpy(rule
->iifname
, tb
[FRA_IIFNAME
], IFNAMSIZ
);
313 dev
= __dev_get_by_name(net
, rule
->iifname
);
315 rule
->iifindex
= dev
->ifindex
;
318 if (tb
[FRA_OIFNAME
]) {
319 struct net_device
*dev
;
322 nla_strlcpy(rule
->oifname
, tb
[FRA_OIFNAME
], IFNAMSIZ
);
323 dev
= __dev_get_by_name(net
, rule
->oifname
);
325 rule
->oifindex
= dev
->ifindex
;
328 if (tb
[FRA_FWMARK
]) {
329 rule
->mark
= nla_get_u32(tb
[FRA_FWMARK
]);
331 /* compatibility: if the mark value is non-zero all bits
332 * are compared unless a mask is explicitly specified.
334 rule
->mark_mask
= 0xFFFFFFFF;
338 rule
->mark_mask
= nla_get_u32(tb
[FRA_FWMASK
]);
341 rule
->tun_id
= nla_get_be64(tb
[FRA_TUN_ID
]);
343 if (tb
[FRA_L3MDEV
]) {
344 #ifdef CONFIG_NET_L3_MASTER_DEV
345 rule
->l3mdev
= nla_get_u8(tb
[FRA_L3MDEV
]);
346 if (rule
->l3mdev
!= 1)
351 rule
->action
= frh
->action
;
352 rule
->flags
= frh
->flags
;
353 rule
->table
= frh_get_table(frh
, tb
);
354 if (tb
[FRA_SUPPRESS_PREFIXLEN
])
355 rule
->suppress_prefixlen
= nla_get_u32(tb
[FRA_SUPPRESS_PREFIXLEN
]);
357 rule
->suppress_prefixlen
= -1;
359 if (tb
[FRA_SUPPRESS_IFGROUP
])
360 rule
->suppress_ifgroup
= nla_get_u32(tb
[FRA_SUPPRESS_IFGROUP
]);
362 rule
->suppress_ifgroup
= -1;
366 if (rule
->action
!= FR_ACT_GOTO
)
369 rule
->target
= nla_get_u32(tb
[FRA_GOTO
]);
370 /* Backward jumps are prohibited to avoid endless loops */
371 if (rule
->target
<= rule
->pref
)
374 list_for_each_entry(r
, &ops
->rules_list
, list
) {
375 if (r
->pref
== rule
->target
) {
376 RCU_INIT_POINTER(rule
->ctarget
, r
);
381 if (rcu_dereference_protected(rule
->ctarget
, 1) == NULL
)
383 } else if (rule
->action
== FR_ACT_GOTO
)
386 if (rule
->l3mdev
&& rule
->table
)
389 err
= ops
->configure(rule
, skb
, frh
, tb
);
393 list_for_each_entry(r
, &ops
->rules_list
, list
) {
394 if (r
->pref
> rule
->pref
)
402 list_add_rcu(&rule
->list
, &last
->list
);
404 list_add_rcu(&rule
->list
, &ops
->rules_list
);
406 if (ops
->unresolved_rules
) {
408 * There are unresolved goto rules in the list, check if
409 * any of them are pointing to this new rule.
411 list_for_each_entry(r
, &ops
->rules_list
, list
) {
412 if (r
->action
== FR_ACT_GOTO
&&
413 r
->target
== rule
->pref
&&
414 rtnl_dereference(r
->ctarget
) == NULL
) {
415 rcu_assign_pointer(r
->ctarget
, rule
);
416 if (--ops
->unresolved_rules
== 0)
422 if (rule
->action
== FR_ACT_GOTO
)
423 ops
->nr_goto_rules
++;
426 ops
->unresolved_rules
++;
429 ip_tunnel_need_metadata();
431 notify_rule_change(RTM_NEWRULE
, rule
, ops
, nlh
, NETLINK_CB(skb
).portid
);
432 flush_route_cache(ops
);
442 EXPORT_SYMBOL_GPL(fib_nl_newrule
);
444 int fib_nl_delrule(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
446 struct net
*net
= sock_net(skb
->sk
);
447 struct fib_rule_hdr
*frh
= nlmsg_data(nlh
);
448 struct fib_rules_ops
*ops
= NULL
;
449 struct fib_rule
*rule
, *tmp
;
450 struct nlattr
*tb
[FRA_MAX
+1];
453 if (nlh
->nlmsg_len
< nlmsg_msg_size(sizeof(*frh
)))
456 ops
= lookup_rules_ops(net
, frh
->family
);
462 err
= nlmsg_parse(nlh
, sizeof(*frh
), tb
, FRA_MAX
, ops
->policy
);
466 err
= validate_rulemsg(frh
, tb
, ops
);
470 list_for_each_entry(rule
, &ops
->rules_list
, list
) {
471 if (frh
->action
&& (frh
->action
!= rule
->action
))
474 if (frh_get_table(frh
, tb
) &&
475 (frh_get_table(frh
, tb
) != rule
->table
))
478 if (tb
[FRA_PRIORITY
] &&
479 (rule
->pref
!= nla_get_u32(tb
[FRA_PRIORITY
])))
482 if (tb
[FRA_IIFNAME
] &&
483 nla_strcmp(tb
[FRA_IIFNAME
], rule
->iifname
))
486 if (tb
[FRA_OIFNAME
] &&
487 nla_strcmp(tb
[FRA_OIFNAME
], rule
->oifname
))
490 if (tb
[FRA_FWMARK
] &&
491 (rule
->mark
!= nla_get_u32(tb
[FRA_FWMARK
])))
494 if (tb
[FRA_FWMASK
] &&
495 (rule
->mark_mask
!= nla_get_u32(tb
[FRA_FWMASK
])))
498 if (tb
[FRA_TUN_ID
] &&
499 (rule
->tun_id
!= nla_get_be64(tb
[FRA_TUN_ID
])))
502 if (tb
[FRA_L3MDEV
] &&
503 (rule
->l3mdev
!= nla_get_u8(tb
[FRA_L3MDEV
])))
506 if (!ops
->compare(rule
, frh
, tb
))
509 if (rule
->flags
& FIB_RULE_PERMANENT
) {
515 err
= ops
->delete(rule
);
521 ip_tunnel_unneed_metadata();
523 list_del_rcu(&rule
->list
);
525 if (rule
->action
== FR_ACT_GOTO
) {
526 ops
->nr_goto_rules
--;
527 if (rtnl_dereference(rule
->ctarget
) == NULL
)
528 ops
->unresolved_rules
--;
532 * Check if this rule is a target to any of them. If so,
533 * disable them. As this operation is eventually very
534 * expensive, it is only performed if goto rules have
535 * actually been added.
537 if (ops
->nr_goto_rules
> 0) {
538 list_for_each_entry(tmp
, &ops
->rules_list
, list
) {
539 if (rtnl_dereference(tmp
->ctarget
) == rule
) {
540 RCU_INIT_POINTER(tmp
->ctarget
, NULL
);
541 ops
->unresolved_rules
++;
546 notify_rule_change(RTM_DELRULE
, rule
, ops
, nlh
,
547 NETLINK_CB(skb
).portid
);
549 flush_route_cache(ops
);
559 EXPORT_SYMBOL_GPL(fib_nl_delrule
);
561 static inline size_t fib_rule_nlmsg_size(struct fib_rules_ops
*ops
,
562 struct fib_rule
*rule
)
564 size_t payload
= NLMSG_ALIGN(sizeof(struct fib_rule_hdr
))
565 + nla_total_size(IFNAMSIZ
) /* FRA_IIFNAME */
566 + nla_total_size(IFNAMSIZ
) /* FRA_OIFNAME */
567 + nla_total_size(4) /* FRA_PRIORITY */
568 + nla_total_size(4) /* FRA_TABLE */
569 + nla_total_size(4) /* FRA_SUPPRESS_PREFIXLEN */
570 + nla_total_size(4) /* FRA_SUPPRESS_IFGROUP */
571 + nla_total_size(4) /* FRA_FWMARK */
572 + nla_total_size(4) /* FRA_FWMASK */
573 + nla_total_size_64bit(8); /* FRA_TUN_ID */
575 if (ops
->nlmsg_payload
)
576 payload
+= ops
->nlmsg_payload(rule
);
581 static int fib_nl_fill_rule(struct sk_buff
*skb
, struct fib_rule
*rule
,
582 u32 pid
, u32 seq
, int type
, int flags
,
583 struct fib_rules_ops
*ops
)
585 struct nlmsghdr
*nlh
;
586 struct fib_rule_hdr
*frh
;
588 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*frh
), flags
);
592 frh
= nlmsg_data(nlh
);
593 frh
->family
= ops
->family
;
594 frh
->table
= rule
->table
;
595 if (nla_put_u32(skb
, FRA_TABLE
, rule
->table
))
596 goto nla_put_failure
;
597 if (nla_put_u32(skb
, FRA_SUPPRESS_PREFIXLEN
, rule
->suppress_prefixlen
))
598 goto nla_put_failure
;
601 frh
->action
= rule
->action
;
602 frh
->flags
= rule
->flags
;
604 if (rule
->action
== FR_ACT_GOTO
&&
605 rcu_access_pointer(rule
->ctarget
) == NULL
)
606 frh
->flags
|= FIB_RULE_UNRESOLVED
;
608 if (rule
->iifname
[0]) {
609 if (nla_put_string(skb
, FRA_IIFNAME
, rule
->iifname
))
610 goto nla_put_failure
;
611 if (rule
->iifindex
== -1)
612 frh
->flags
|= FIB_RULE_IIF_DETACHED
;
615 if (rule
->oifname
[0]) {
616 if (nla_put_string(skb
, FRA_OIFNAME
, rule
->oifname
))
617 goto nla_put_failure
;
618 if (rule
->oifindex
== -1)
619 frh
->flags
|= FIB_RULE_OIF_DETACHED
;
623 nla_put_u32(skb
, FRA_PRIORITY
, rule
->pref
)) ||
625 nla_put_u32(skb
, FRA_FWMARK
, rule
->mark
)) ||
626 ((rule
->mark_mask
|| rule
->mark
) &&
627 nla_put_u32(skb
, FRA_FWMASK
, rule
->mark_mask
)) ||
629 nla_put_u32(skb
, FRA_GOTO
, rule
->target
)) ||
631 nla_put_be64(skb
, FRA_TUN_ID
, rule
->tun_id
, FRA_PAD
)) ||
633 nla_put_u8(skb
, FRA_L3MDEV
, rule
->l3mdev
)))
634 goto nla_put_failure
;
636 if (rule
->suppress_ifgroup
!= -1) {
637 if (nla_put_u32(skb
, FRA_SUPPRESS_IFGROUP
, rule
->suppress_ifgroup
))
638 goto nla_put_failure
;
641 if (ops
->fill(rule
, skb
, frh
) < 0)
642 goto nla_put_failure
;
648 nlmsg_cancel(skb
, nlh
);
652 static int dump_rules(struct sk_buff
*skb
, struct netlink_callback
*cb
,
653 struct fib_rules_ops
*ops
)
656 struct fib_rule
*rule
;
660 list_for_each_entry_rcu(rule
, &ops
->rules_list
, list
) {
661 if (idx
< cb
->args
[1])
664 err
= fib_nl_fill_rule(skb
, rule
, NETLINK_CB(cb
->skb
).portid
,
665 cb
->nlh
->nlmsg_seq
, RTM_NEWRULE
,
679 static int fib_nl_dumprule(struct sk_buff
*skb
, struct netlink_callback
*cb
)
681 struct net
*net
= sock_net(skb
->sk
);
682 struct fib_rules_ops
*ops
;
685 family
= rtnl_msg_family(cb
->nlh
);
686 if (family
!= AF_UNSPEC
) {
687 /* Protocol specific dump request */
688 ops
= lookup_rules_ops(net
, family
);
690 return -EAFNOSUPPORT
;
692 dump_rules(skb
, cb
, ops
);
698 list_for_each_entry_rcu(ops
, &net
->rules_ops
, list
) {
699 if (idx
< cb
->args
[0] || !try_module_get(ops
->owner
))
702 if (dump_rules(skb
, cb
, ops
) < 0)
715 static void notify_rule_change(int event
, struct fib_rule
*rule
,
716 struct fib_rules_ops
*ops
, struct nlmsghdr
*nlh
,
724 skb
= nlmsg_new(fib_rule_nlmsg_size(ops
, rule
), GFP_KERNEL
);
728 err
= fib_nl_fill_rule(skb
, rule
, pid
, nlh
->nlmsg_seq
, event
, 0, ops
);
730 /* -EMSGSIZE implies BUG in fib_rule_nlmsg_size() */
731 WARN_ON(err
== -EMSGSIZE
);
736 rtnl_notify(skb
, net
, pid
, ops
->nlgroup
, nlh
, GFP_KERNEL
);
740 rtnl_set_sk_err(net
, ops
->nlgroup
, err
);
743 static void attach_rules(struct list_head
*rules
, struct net_device
*dev
)
745 struct fib_rule
*rule
;
747 list_for_each_entry(rule
, rules
, list
) {
748 if (rule
->iifindex
== -1 &&
749 strcmp(dev
->name
, rule
->iifname
) == 0)
750 rule
->iifindex
= dev
->ifindex
;
751 if (rule
->oifindex
== -1 &&
752 strcmp(dev
->name
, rule
->oifname
) == 0)
753 rule
->oifindex
= dev
->ifindex
;
757 static void detach_rules(struct list_head
*rules
, struct net_device
*dev
)
759 struct fib_rule
*rule
;
761 list_for_each_entry(rule
, rules
, list
) {
762 if (rule
->iifindex
== dev
->ifindex
)
764 if (rule
->oifindex
== dev
->ifindex
)
770 static int fib_rules_event(struct notifier_block
*this, unsigned long event
,
773 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
774 struct net
*net
= dev_net(dev
);
775 struct fib_rules_ops
*ops
;
780 case NETDEV_REGISTER
:
781 list_for_each_entry(ops
, &net
->rules_ops
, list
)
782 attach_rules(&ops
->rules_list
, dev
);
785 case NETDEV_CHANGENAME
:
786 list_for_each_entry(ops
, &net
->rules_ops
, list
) {
787 detach_rules(&ops
->rules_list
, dev
);
788 attach_rules(&ops
->rules_list
, dev
);
792 case NETDEV_UNREGISTER
:
793 list_for_each_entry(ops
, &net
->rules_ops
, list
)
794 detach_rules(&ops
->rules_list
, dev
);
801 static struct notifier_block fib_rules_notifier
= {
802 .notifier_call
= fib_rules_event
,
805 static int __net_init
fib_rules_net_init(struct net
*net
)
807 INIT_LIST_HEAD(&net
->rules_ops
);
808 spin_lock_init(&net
->rules_mod_lock
);
812 static struct pernet_operations fib_rules_net_ops
= {
813 .init
= fib_rules_net_init
,
816 static int __init
fib_rules_init(void)
819 rtnl_register(PF_UNSPEC
, RTM_NEWRULE
, fib_nl_newrule
, NULL
, NULL
);
820 rtnl_register(PF_UNSPEC
, RTM_DELRULE
, fib_nl_delrule
, NULL
, NULL
);
821 rtnl_register(PF_UNSPEC
, RTM_GETRULE
, NULL
, fib_nl_dumprule
, NULL
);
823 err
= register_pernet_subsys(&fib_rules_net_ops
);
827 err
= register_netdevice_notifier(&fib_rules_notifier
);
829 goto fail_unregister
;
834 unregister_pernet_subsys(&fib_rules_net_ops
);
836 rtnl_unregister(PF_UNSPEC
, RTM_NEWRULE
);
837 rtnl_unregister(PF_UNSPEC
, RTM_DELRULE
);
838 rtnl_unregister(PF_UNSPEC
, RTM_GETRULE
);
842 subsys_initcall(fib_rules_init
);