0001 #include <linux/rtnetlink.h>
0002 #include <linux/notifier.h>
0003 #include <linux/rcupdate.h>
0004 #include <linux/kernel.h>
0005 #include <linux/module.h>
0006 #include <linux/init.h>
0007 #include <net/net_namespace.h>
0008 #include <net/netns/generic.h>
0009 #include <net/fib_notifier.h>
0010
0011 static unsigned int fib_notifier_net_id;
0012
0013 struct fib_notifier_net {
0014 struct list_head fib_notifier_ops;
0015 struct atomic_notifier_head fib_chain;
0016 };
0017
0018 int call_fib_notifier(struct notifier_block *nb,
0019 enum fib_event_type event_type,
0020 struct fib_notifier_info *info)
0021 {
0022 int err;
0023
0024 err = nb->notifier_call(nb, event_type, info);
0025 return notifier_to_errno(err);
0026 }
0027 EXPORT_SYMBOL(call_fib_notifier);
0028
0029 int call_fib_notifiers(struct net *net, enum fib_event_type event_type,
0030 struct fib_notifier_info *info)
0031 {
0032 struct fib_notifier_net *fn_net = net_generic(net, fib_notifier_net_id);
0033 int err;
0034
0035 err = atomic_notifier_call_chain(&fn_net->fib_chain, event_type, info);
0036 return notifier_to_errno(err);
0037 }
0038 EXPORT_SYMBOL(call_fib_notifiers);
0039
0040 static unsigned int fib_seq_sum(struct net *net)
0041 {
0042 struct fib_notifier_net *fn_net = net_generic(net, fib_notifier_net_id);
0043 struct fib_notifier_ops *ops;
0044 unsigned int fib_seq = 0;
0045
0046 rtnl_lock();
0047 rcu_read_lock();
0048 list_for_each_entry_rcu(ops, &fn_net->fib_notifier_ops, list) {
0049 if (!try_module_get(ops->owner))
0050 continue;
0051 fib_seq += ops->fib_seq_read(net);
0052 module_put(ops->owner);
0053 }
0054 rcu_read_unlock();
0055 rtnl_unlock();
0056
0057 return fib_seq;
0058 }
0059
0060 static int fib_net_dump(struct net *net, struct notifier_block *nb,
0061 struct netlink_ext_ack *extack)
0062 {
0063 struct fib_notifier_net *fn_net = net_generic(net, fib_notifier_net_id);
0064 struct fib_notifier_ops *ops;
0065 int err = 0;
0066
0067 rcu_read_lock();
0068 list_for_each_entry_rcu(ops, &fn_net->fib_notifier_ops, list) {
0069 if (!try_module_get(ops->owner))
0070 continue;
0071 err = ops->fib_dump(net, nb, extack);
0072 module_put(ops->owner);
0073 if (err)
0074 goto unlock;
0075 }
0076
0077 unlock:
0078 rcu_read_unlock();
0079
0080 return err;
0081 }
0082
0083 static bool fib_dump_is_consistent(struct net *net, struct notifier_block *nb,
0084 void (*cb)(struct notifier_block *nb),
0085 unsigned int fib_seq)
0086 {
0087 struct fib_notifier_net *fn_net = net_generic(net, fib_notifier_net_id);
0088
0089 atomic_notifier_chain_register(&fn_net->fib_chain, nb);
0090 if (fib_seq == fib_seq_sum(net))
0091 return true;
0092 atomic_notifier_chain_unregister(&fn_net->fib_chain, nb);
0093 if (cb)
0094 cb(nb);
0095 return false;
0096 }
0097
0098 #define FIB_DUMP_MAX_RETRIES 5
0099 int register_fib_notifier(struct net *net, struct notifier_block *nb,
0100 void (*cb)(struct notifier_block *nb),
0101 struct netlink_ext_ack *extack)
0102 {
0103 int retries = 0;
0104 int err;
0105
0106 do {
0107 unsigned int fib_seq = fib_seq_sum(net);
0108
0109 err = fib_net_dump(net, nb, extack);
0110 if (err)
0111 return err;
0112
0113 if (fib_dump_is_consistent(net, nb, cb, fib_seq))
0114 return 0;
0115 } while (++retries < FIB_DUMP_MAX_RETRIES);
0116
0117 return -EBUSY;
0118 }
0119 EXPORT_SYMBOL(register_fib_notifier);
0120
0121 int unregister_fib_notifier(struct net *net, struct notifier_block *nb)
0122 {
0123 struct fib_notifier_net *fn_net = net_generic(net, fib_notifier_net_id);
0124
0125 return atomic_notifier_chain_unregister(&fn_net->fib_chain, nb);
0126 }
0127 EXPORT_SYMBOL(unregister_fib_notifier);
0128
0129 static int __fib_notifier_ops_register(struct fib_notifier_ops *ops,
0130 struct net *net)
0131 {
0132 struct fib_notifier_net *fn_net = net_generic(net, fib_notifier_net_id);
0133 struct fib_notifier_ops *o;
0134
0135 list_for_each_entry(o, &fn_net->fib_notifier_ops, list)
0136 if (ops->family == o->family)
0137 return -EEXIST;
0138 list_add_tail_rcu(&ops->list, &fn_net->fib_notifier_ops);
0139 return 0;
0140 }
0141
0142 struct fib_notifier_ops *
0143 fib_notifier_ops_register(const struct fib_notifier_ops *tmpl, struct net *net)
0144 {
0145 struct fib_notifier_ops *ops;
0146 int err;
0147
0148 ops = kmemdup(tmpl, sizeof(*ops), GFP_KERNEL);
0149 if (!ops)
0150 return ERR_PTR(-ENOMEM);
0151
0152 err = __fib_notifier_ops_register(ops, net);
0153 if (err)
0154 goto err_register;
0155
0156 return ops;
0157
0158 err_register:
0159 kfree(ops);
0160 return ERR_PTR(err);
0161 }
0162 EXPORT_SYMBOL(fib_notifier_ops_register);
0163
0164 void fib_notifier_ops_unregister(struct fib_notifier_ops *ops)
0165 {
0166 list_del_rcu(&ops->list);
0167 kfree_rcu(ops, rcu);
0168 }
0169 EXPORT_SYMBOL(fib_notifier_ops_unregister);
0170
0171 static int __net_init fib_notifier_net_init(struct net *net)
0172 {
0173 struct fib_notifier_net *fn_net = net_generic(net, fib_notifier_net_id);
0174
0175 INIT_LIST_HEAD(&fn_net->fib_notifier_ops);
0176 ATOMIC_INIT_NOTIFIER_HEAD(&fn_net->fib_chain);
0177 return 0;
0178 }
0179
0180 static void __net_exit fib_notifier_net_exit(struct net *net)
0181 {
0182 struct fib_notifier_net *fn_net = net_generic(net, fib_notifier_net_id);
0183
0184 WARN_ON_ONCE(!list_empty(&fn_net->fib_notifier_ops));
0185 }
0186
0187 static struct pernet_operations fib_notifier_net_ops = {
0188 .init = fib_notifier_net_init,
0189 .exit = fib_notifier_net_exit,
0190 .id = &fib_notifier_net_id,
0191 .size = sizeof(struct fib_notifier_net),
0192 };
0193
0194 static int __init fib_notifier_init(void)
0195 {
0196 return register_pernet_subsys(&fib_notifier_net_ops);
0197 }
0198
0199 subsys_initcall(fib_notifier_init);
