net/core/fib_notifier.c

   1 #include <linux/rtnetlink.h>
   2 #include <linux/notifier.h>
   3 #include <linux/rcupdate.h>
   4 #include <linux/kernel.h>
   5 #include <linux/module.h>
   6 #include <linux/init.h>
   7 #include <net/net_namespace.h>
   8 #include <net/fib_notifier.h>
   9
  10 static ATOMIC_NOTIFIER_HEAD(fib_chain);
  11
  12 int call_fib_notifier(struct notifier_block *nb, struct net *net,
  13                       enum fib_event_type event_type,
  14                       struct fib_notifier_info *info)
  15 {
  16         int err;
  17
  18         info->net = net;
  19         err = nb->notifier_call(nb, event_type, info);
  20         return notifier_to_errno(err);
  21 }
  22 EXPORT_SYMBOL(call_fib_notifier);
  23
  24 int call_fib_notifiers(struct net *net, enum fib_event_type event_type,
  25                        struct fib_notifier_info *info)
  26 {
  27         int err;
  28
  29         info->net = net;
  30         err = atomic_notifier_call_chain(&fib_chain, event_type, info);
  31         return notifier_to_errno(err);
  32 }
  33 EXPORT_SYMBOL(call_fib_notifiers);
  34
  35 static unsigned int fib_seq_sum(void)
  36 {
  37         struct fib_notifier_ops *ops;
  38         unsigned int fib_seq = 0;
  39         struct net *net;
  40
  41         rtnl_lock();
  42         down_read(&net_rwsem);
  43         for_each_net(net) {
  44                 rcu_read_lock();
  45                 list_for_each_entry_rcu(ops, &net->fib_notifier_ops, list) {
  46                         if (!try_module_get(ops->owner))
  47                                 continue;
  48                         fib_seq += ops->fib_seq_read(net);
  49                         module_put(ops->owner);
  50                 }
  51                 rcu_read_unlock();
  52         }
  53         up_read(&net_rwsem);
  54         rtnl_unlock();
  55
  56         return fib_seq;
  57 }
  58
  59 static int fib_net_dump(struct net *net, struct notifier_block *nb)
  60 {
  61         struct fib_notifier_ops *ops;
  62
  63         list_for_each_entry_rcu(ops, &net->fib_notifier_ops, list) {
  64                 int err;
  65
  66                 if (!try_module_get(ops->owner))
  67                         continue;
  68                 err = ops->fib_dump(net, nb);
  69                 module_put(ops->owner);
  70                 if (err)
  71                         return err;
  72         }
  73
  74         return 0;
  75 }
  76
  77 static bool fib_dump_is_consistent(struct notifier_block *nb,
  78                                    void (*cb)(struct notifier_block *nb),
  79                                    unsigned int fib_seq)
  80 {
  81         atomic_notifier_chain_register(&fib_chain, nb);
  82         if (fib_seq == fib_seq_sum())
  83                 return true;
  84         atomic_notifier_chain_unregister(&fib_chain, nb);
  85         if (cb)
  86                 cb(nb);
  87         return false;
  88 }
  89
  90 #define FIB_DUMP_MAX_RETRIES 5
  91 int register_fib_notifier(struct notifier_block *nb,
  92                           void (*cb)(struct notifier_block *nb))
  93 {
  94         int retries = 0;
  95         int err;
  96
  97         do {
  98                 unsigned int fib_seq = fib_seq_sum();
  99                 struct net *net;
 100
 101                 rcu_read_lock();
 102                 for_each_net_rcu(net) {
 103                         err = fib_net_dump(net, nb);
 104                         if (err)
 105                                 goto err_fib_net_dump;
 106                 }
 107                 rcu_read_unlock();
 108
 109                 if (fib_dump_is_consistent(nb, cb, fib_seq))
 110                         return 0;
 111         } while (++retries < FIB_DUMP_MAX_RETRIES);
 112
 113         return -EBUSY;
 114
 115 err_fib_net_dump:
 116         rcu_read_unlock();
 117         return err;
 118 }
 119 EXPORT_SYMBOL(register_fib_notifier);
 120
 121 int unregister_fib_notifier(struct notifier_block *nb)
 122 {
 123         return atomic_notifier_chain_unregister(&fib_chain, nb);
 124 }
 125 EXPORT_SYMBOL(unregister_fib_notifier);
 126
 127 static int __fib_notifier_ops_register(struct fib_notifier_ops *ops,
 128                                        struct net *net)
 129 {
 130         struct fib_notifier_ops *o;
 131
 132         list_for_each_entry(o, &net->fib_notifier_ops, list)
 133                 if (ops->family == o->family)
 134                         return -EEXIST;
 135         list_add_tail_rcu(&ops->list, &net->fib_notifier_ops);
 136         return 0;
 137 }
 138
 139 struct fib_notifier_ops *
 140 fib_notifier_ops_register(const struct fib_notifier_ops *tmpl, struct net *net)
 141 {
 142         struct fib_notifier_ops *ops;
 143         int err;
 144
 145         ops = kmemdup(tmpl, sizeof(*ops), GFP_KERNEL);
 146         if (!ops)
 147                 return ERR_PTR(-ENOMEM);
 148
 149         err = __fib_notifier_ops_register(ops, net);
 150         if (err)
 151                 goto err_register;
 152
 153         return ops;
 154
 155 err_register:
 156         kfree(ops);
 157         return ERR_PTR(err);
 158 }
 159 EXPORT_SYMBOL(fib_notifier_ops_register);
 160
 161 void fib_notifier_ops_unregister(struct fib_notifier_ops *ops)
 162 {
 163         list_del_rcu(&ops->list);
 164         kfree_rcu(ops, rcu);
 165 }
 166 EXPORT_SYMBOL(fib_notifier_ops_unregister);
 167
 168 static int __net_init fib_notifier_net_init(struct net *net)
 169 {
 170         INIT_LIST_HEAD(&net->fib_notifier_ops);
 171         return 0;
 172 }
 173
 174 static void __net_exit fib_notifier_net_exit(struct net *net)
 175 {
 176         WARN_ON_ONCE(!list_empty(&net->fib_notifier_ops));
 177 }
 178
 179 static struct pernet_operations fib_notifier_net_ops = {
 180         .init = fib_notifier_net_init,
 181         .exit = fib_notifier_net_exit,
 182 };
 183
 184 static int __init fib_notifier_init(void)
 185 {
 186         return register_pernet_subsys(&fib_notifier_net_ops);
 187 }
 188
 189 subsys_initcall(fib_notifier_init);