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