Loading...
1/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * Definitions for the Forwarding Information Base.
7 *
8 * Authors: A.N.Kuznetsov, <kuznet@ms2.inr.ac.ru>
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
14 */
15
16#ifndef _NET_IP_FIB_H
17#define _NET_IP_FIB_H
18
19#include <net/flow.h>
20#include <linux/seq_file.h>
21#include <net/fib_rules.h>
22
23struct fib_config {
24 u8 fc_dst_len;
25 u8 fc_tos;
26 u8 fc_protocol;
27 u8 fc_scope;
28 u8 fc_type;
29 /* 3 bytes unused */
30 u32 fc_table;
31 __be32 fc_dst;
32 __be32 fc_gw;
33 int fc_oif;
34 u32 fc_flags;
35 u32 fc_priority;
36 __be32 fc_prefsrc;
37 struct nlattr *fc_mx;
38 struct rtnexthop *fc_mp;
39 int fc_mx_len;
40 int fc_mp_len;
41 u32 fc_flow;
42 u32 fc_nlflags;
43 struct nl_info fc_nlinfo;
44 };
45
46struct fib_info;
47
48struct fib_nh {
49 struct net_device *nh_dev;
50 struct hlist_node nh_hash;
51 struct fib_info *nh_parent;
52 unsigned nh_flags;
53 unsigned char nh_scope;
54#ifdef CONFIG_IP_ROUTE_MULTIPATH
55 int nh_weight;
56 int nh_power;
57#endif
58#ifdef CONFIG_IP_ROUTE_CLASSID
59 __u32 nh_tclassid;
60#endif
61 int nh_oif;
62 __be32 nh_gw;
63 __be32 nh_saddr;
64 int nh_saddr_genid;
65};
66
67/*
68 * This structure contains data shared by many of routes.
69 */
70
71struct fib_info {
72 struct hlist_node fib_hash;
73 struct hlist_node fib_lhash;
74 struct net *fib_net;
75 int fib_treeref;
76 atomic_t fib_clntref;
77 unsigned fib_flags;
78 unsigned char fib_dead;
79 unsigned char fib_protocol;
80 unsigned char fib_scope;
81 __be32 fib_prefsrc;
82 u32 fib_priority;
83 u32 *fib_metrics;
84#define fib_mtu fib_metrics[RTAX_MTU-1]
85#define fib_window fib_metrics[RTAX_WINDOW-1]
86#define fib_rtt fib_metrics[RTAX_RTT-1]
87#define fib_advmss fib_metrics[RTAX_ADVMSS-1]
88 int fib_nhs;
89#ifdef CONFIG_IP_ROUTE_MULTIPATH
90 int fib_power;
91#endif
92 struct rcu_head rcu;
93 struct fib_nh fib_nh[0];
94#define fib_dev fib_nh[0].nh_dev
95};
96
97
98#ifdef CONFIG_IP_MULTIPLE_TABLES
99struct fib_rule;
100#endif
101
102struct fib_table;
103struct fib_result {
104 unsigned char prefixlen;
105 unsigned char nh_sel;
106 unsigned char type;
107 unsigned char scope;
108 struct fib_info *fi;
109 struct fib_table *table;
110 struct list_head *fa_head;
111#ifdef CONFIG_IP_MULTIPLE_TABLES
112 struct fib_rule *r;
113#endif
114};
115
116struct fib_result_nl {
117 __be32 fl_addr; /* To be looked up*/
118 u32 fl_mark;
119 unsigned char fl_tos;
120 unsigned char fl_scope;
121 unsigned char tb_id_in;
122
123 unsigned char tb_id; /* Results */
124 unsigned char prefixlen;
125 unsigned char nh_sel;
126 unsigned char type;
127 unsigned char scope;
128 int err;
129};
130
131#ifdef CONFIG_IP_ROUTE_MULTIPATH
132
133#define FIB_RES_NH(res) ((res).fi->fib_nh[(res).nh_sel])
134
135#define FIB_TABLE_HASHSZ 2
136
137#else /* CONFIG_IP_ROUTE_MULTIPATH */
138
139#define FIB_RES_NH(res) ((res).fi->fib_nh[0])
140
141#define FIB_TABLE_HASHSZ 256
142
143#endif /* CONFIG_IP_ROUTE_MULTIPATH */
144
145extern __be32 fib_info_update_nh_saddr(struct net *net, struct fib_nh *nh);
146
147#define FIB_RES_SADDR(net, res) \
148 ((FIB_RES_NH(res).nh_saddr_genid == \
149 atomic_read(&(net)->ipv4.dev_addr_genid)) ? \
150 FIB_RES_NH(res).nh_saddr : \
151 fib_info_update_nh_saddr((net), &FIB_RES_NH(res)))
152#define FIB_RES_GW(res) (FIB_RES_NH(res).nh_gw)
153#define FIB_RES_DEV(res) (FIB_RES_NH(res).nh_dev)
154#define FIB_RES_OIF(res) (FIB_RES_NH(res).nh_oif)
155
156#define FIB_RES_PREFSRC(net, res) ((res).fi->fib_prefsrc ? : \
157 FIB_RES_SADDR(net, res))
158
159struct fib_table {
160 struct hlist_node tb_hlist;
161 u32 tb_id;
162 int tb_default;
163 int tb_num_default;
164 unsigned long tb_data[0];
165};
166
167extern int fib_table_lookup(struct fib_table *tb, const struct flowi4 *flp,
168 struct fib_result *res, int fib_flags);
169extern int fib_table_insert(struct fib_table *, struct fib_config *);
170extern int fib_table_delete(struct fib_table *, struct fib_config *);
171extern int fib_table_dump(struct fib_table *table, struct sk_buff *skb,
172 struct netlink_callback *cb);
173extern int fib_table_flush(struct fib_table *table);
174extern void fib_free_table(struct fib_table *tb);
175
176
177
178#ifndef CONFIG_IP_MULTIPLE_TABLES
179
180#define TABLE_LOCAL_INDEX 0
181#define TABLE_MAIN_INDEX 1
182
183static inline struct fib_table *fib_get_table(struct net *net, u32 id)
184{
185 struct hlist_head *ptr;
186
187 ptr = id == RT_TABLE_LOCAL ?
188 &net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX] :
189 &net->ipv4.fib_table_hash[TABLE_MAIN_INDEX];
190 return hlist_entry(ptr->first, struct fib_table, tb_hlist);
191}
192
193static inline struct fib_table *fib_new_table(struct net *net, u32 id)
194{
195 return fib_get_table(net, id);
196}
197
198static inline int fib_lookup(struct net *net, const struct flowi4 *flp,
199 struct fib_result *res)
200{
201 struct fib_table *table;
202
203 table = fib_get_table(net, RT_TABLE_LOCAL);
204 if (!fib_table_lookup(table, flp, res, FIB_LOOKUP_NOREF))
205 return 0;
206
207 table = fib_get_table(net, RT_TABLE_MAIN);
208 if (!fib_table_lookup(table, flp, res, FIB_LOOKUP_NOREF))
209 return 0;
210 return -ENETUNREACH;
211}
212
213#else /* CONFIG_IP_MULTIPLE_TABLES */
214extern int __net_init fib4_rules_init(struct net *net);
215extern void __net_exit fib4_rules_exit(struct net *net);
216
217#ifdef CONFIG_IP_ROUTE_CLASSID
218extern u32 fib_rules_tclass(const struct fib_result *res);
219#endif
220
221extern int fib_lookup(struct net *n, struct flowi4 *flp, struct fib_result *res);
222
223extern struct fib_table *fib_new_table(struct net *net, u32 id);
224extern struct fib_table *fib_get_table(struct net *net, u32 id);
225
226#endif /* CONFIG_IP_MULTIPLE_TABLES */
227
228/* Exported by fib_frontend.c */
229extern const struct nla_policy rtm_ipv4_policy[];
230extern void ip_fib_init(void);
231extern int fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst,
232 u8 tos, int oif, struct net_device *dev,
233 __be32 *spec_dst, u32 *itag);
234extern void fib_select_default(struct fib_result *res);
235
236/* Exported by fib_semantics.c */
237extern int ip_fib_check_default(__be32 gw, struct net_device *dev);
238extern int fib_sync_down_dev(struct net_device *dev, int force);
239extern int fib_sync_down_addr(struct net *net, __be32 local);
240extern void fib_update_nh_saddrs(struct net_device *dev);
241extern int fib_sync_up(struct net_device *dev);
242extern void fib_select_multipath(struct fib_result *res);
243
244/* Exported by fib_trie.c */
245extern void fib_trie_init(void);
246extern struct fib_table *fib_trie_table(u32 id);
247
248static inline void fib_combine_itag(u32 *itag, const struct fib_result *res)
249{
250#ifdef CONFIG_IP_ROUTE_CLASSID
251#ifdef CONFIG_IP_MULTIPLE_TABLES
252 u32 rtag;
253#endif
254 *itag = FIB_RES_NH(*res).nh_tclassid<<16;
255#ifdef CONFIG_IP_MULTIPLE_TABLES
256 rtag = fib_rules_tclass(res);
257 if (*itag == 0)
258 *itag = (rtag<<16);
259 *itag |= (rtag>>16);
260#endif
261#endif
262}
263
264extern void free_fib_info(struct fib_info *fi);
265
266static inline void fib_info_put(struct fib_info *fi)
267{
268 if (atomic_dec_and_test(&fi->fib_clntref))
269 free_fib_info(fi);
270}
271
272#ifdef CONFIG_PROC_FS
273extern int __net_init fib_proc_init(struct net *net);
274extern void __net_exit fib_proc_exit(struct net *net);
275#else
276static inline int fib_proc_init(struct net *net)
277{
278 return 0;
279}
280static inline void fib_proc_exit(struct net *net)
281{
282}
283#endif
284
285#endif /* _NET_FIB_H */
1/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * Definitions for the Forwarding Information Base.
7 *
8 * Authors: A.N.Kuznetsov, <kuznet@ms2.inr.ac.ru>
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
14 */
15
16#ifndef _NET_IP_FIB_H
17#define _NET_IP_FIB_H
18
19#include <net/flow.h>
20#include <linux/seq_file.h>
21#include <linux/rcupdate.h>
22#include <net/fib_rules.h>
23#include <net/inetpeer.h>
24#include <linux/percpu.h>
25#include <linux/notifier.h>
26
27struct fib_config {
28 u8 fc_dst_len;
29 u8 fc_tos;
30 u8 fc_protocol;
31 u8 fc_scope;
32 u8 fc_type;
33 /* 3 bytes unused */
34 u32 fc_table;
35 __be32 fc_dst;
36 __be32 fc_gw;
37 int fc_oif;
38 u32 fc_flags;
39 u32 fc_priority;
40 __be32 fc_prefsrc;
41 struct nlattr *fc_mx;
42 struct rtnexthop *fc_mp;
43 int fc_mx_len;
44 int fc_mp_len;
45 u32 fc_flow;
46 u32 fc_nlflags;
47 struct nl_info fc_nlinfo;
48 struct nlattr *fc_encap;
49 u16 fc_encap_type;
50};
51
52struct fib_info;
53struct rtable;
54
55struct fib_nh_exception {
56 struct fib_nh_exception __rcu *fnhe_next;
57 int fnhe_genid;
58 __be32 fnhe_daddr;
59 u32 fnhe_pmtu;
60 __be32 fnhe_gw;
61 unsigned long fnhe_expires;
62 struct rtable __rcu *fnhe_rth_input;
63 struct rtable __rcu *fnhe_rth_output;
64 unsigned long fnhe_stamp;
65 struct rcu_head rcu;
66};
67
68struct fnhe_hash_bucket {
69 struct fib_nh_exception __rcu *chain;
70};
71
72#define FNHE_HASH_SHIFT 11
73#define FNHE_HASH_SIZE (1 << FNHE_HASH_SHIFT)
74#define FNHE_RECLAIM_DEPTH 5
75
76struct fib_nh {
77 struct net_device *nh_dev;
78 struct hlist_node nh_hash;
79 struct fib_info *nh_parent;
80 unsigned int nh_flags;
81 unsigned char nh_scope;
82#ifdef CONFIG_IP_ROUTE_MULTIPATH
83 int nh_weight;
84 atomic_t nh_upper_bound;
85#endif
86#ifdef CONFIG_IP_ROUTE_CLASSID
87 __u32 nh_tclassid;
88#endif
89 int nh_oif;
90 __be32 nh_gw;
91 __be32 nh_saddr;
92 int nh_saddr_genid;
93 struct rtable __rcu * __percpu *nh_pcpu_rth_output;
94 struct rtable __rcu *nh_rth_input;
95 struct fnhe_hash_bucket __rcu *nh_exceptions;
96 struct lwtunnel_state *nh_lwtstate;
97};
98
99/*
100 * This structure contains data shared by many of routes.
101 */
102
103struct fib_info {
104 struct hlist_node fib_hash;
105 struct hlist_node fib_lhash;
106 struct net *fib_net;
107 int fib_treeref;
108 atomic_t fib_clntref;
109 unsigned int fib_flags;
110 unsigned char fib_dead;
111 unsigned char fib_protocol;
112 unsigned char fib_scope;
113 unsigned char fib_type;
114 __be32 fib_prefsrc;
115 u32 fib_tb_id;
116 u32 fib_priority;
117 u32 *fib_metrics;
118#define fib_mtu fib_metrics[RTAX_MTU-1]
119#define fib_window fib_metrics[RTAX_WINDOW-1]
120#define fib_rtt fib_metrics[RTAX_RTT-1]
121#define fib_advmss fib_metrics[RTAX_ADVMSS-1]
122 int fib_nhs;
123#ifdef CONFIG_IP_ROUTE_MULTIPATH
124 int fib_weight;
125#endif
126 unsigned int fib_offload_cnt;
127 struct rcu_head rcu;
128 struct fib_nh fib_nh[0];
129#define fib_dev fib_nh[0].nh_dev
130};
131
132
133#ifdef CONFIG_IP_MULTIPLE_TABLES
134struct fib_rule;
135#endif
136
137struct fib_table;
138struct fib_result {
139 unsigned char prefixlen;
140 unsigned char nh_sel;
141 unsigned char type;
142 unsigned char scope;
143 u32 tclassid;
144 struct fib_info *fi;
145 struct fib_table *table;
146 struct hlist_head *fa_head;
147};
148
149struct fib_result_nl {
150 __be32 fl_addr; /* To be looked up*/
151 u32 fl_mark;
152 unsigned char fl_tos;
153 unsigned char fl_scope;
154 unsigned char tb_id_in;
155
156 unsigned char tb_id; /* Results */
157 unsigned char prefixlen;
158 unsigned char nh_sel;
159 unsigned char type;
160 unsigned char scope;
161 int err;
162};
163
164#ifdef CONFIG_IP_ROUTE_MULTIPATH
165#define FIB_RES_NH(res) ((res).fi->fib_nh[(res).nh_sel])
166#else /* CONFIG_IP_ROUTE_MULTIPATH */
167#define FIB_RES_NH(res) ((res).fi->fib_nh[0])
168#endif /* CONFIG_IP_ROUTE_MULTIPATH */
169
170#ifdef CONFIG_IP_MULTIPLE_TABLES
171#define FIB_TABLE_HASHSZ 256
172#else
173#define FIB_TABLE_HASHSZ 2
174#endif
175
176__be32 fib_info_update_nh_saddr(struct net *net, struct fib_nh *nh);
177
178static inline void fib_info_offload_inc(struct fib_info *fi)
179{
180 fi->fib_offload_cnt++;
181 fi->fib_flags |= RTNH_F_OFFLOAD;
182}
183
184static inline void fib_info_offload_dec(struct fib_info *fi)
185{
186 if (--fi->fib_offload_cnt == 0)
187 fi->fib_flags &= ~RTNH_F_OFFLOAD;
188}
189
190#define FIB_RES_SADDR(net, res) \
191 ((FIB_RES_NH(res).nh_saddr_genid == \
192 atomic_read(&(net)->ipv4.dev_addr_genid)) ? \
193 FIB_RES_NH(res).nh_saddr : \
194 fib_info_update_nh_saddr((net), &FIB_RES_NH(res)))
195#define FIB_RES_GW(res) (FIB_RES_NH(res).nh_gw)
196#define FIB_RES_DEV(res) (FIB_RES_NH(res).nh_dev)
197#define FIB_RES_OIF(res) (FIB_RES_NH(res).nh_oif)
198
199#define FIB_RES_PREFSRC(net, res) ((res).fi->fib_prefsrc ? : \
200 FIB_RES_SADDR(net, res))
201
202struct fib_notifier_info {
203 struct net *net;
204};
205
206struct fib_entry_notifier_info {
207 struct fib_notifier_info info; /* must be first */
208 u32 dst;
209 int dst_len;
210 struct fib_info *fi;
211 u8 tos;
212 u8 type;
213 u32 tb_id;
214 u32 nlflags;
215};
216
217enum fib_event_type {
218 FIB_EVENT_ENTRY_ADD,
219 FIB_EVENT_ENTRY_DEL,
220 FIB_EVENT_RULE_ADD,
221 FIB_EVENT_RULE_DEL,
222};
223
224int register_fib_notifier(struct notifier_block *nb,
225 void (*cb)(struct notifier_block *nb));
226int unregister_fib_notifier(struct notifier_block *nb);
227int call_fib_notifiers(struct net *net, enum fib_event_type event_type,
228 struct fib_notifier_info *info);
229
230struct fib_table {
231 struct hlist_node tb_hlist;
232 u32 tb_id;
233 int tb_num_default;
234 struct rcu_head rcu;
235 unsigned long *tb_data;
236 unsigned long __data[0];
237};
238
239int fib_table_lookup(struct fib_table *tb, const struct flowi4 *flp,
240 struct fib_result *res, int fib_flags);
241int fib_table_insert(struct net *, struct fib_table *, struct fib_config *);
242int fib_table_delete(struct net *, struct fib_table *, struct fib_config *);
243int fib_table_dump(struct fib_table *table, struct sk_buff *skb,
244 struct netlink_callback *cb);
245int fib_table_flush(struct net *net, struct fib_table *table);
246struct fib_table *fib_trie_unmerge(struct fib_table *main_tb);
247void fib_table_flush_external(struct fib_table *table);
248void fib_free_table(struct fib_table *tb);
249
250#ifndef CONFIG_IP_MULTIPLE_TABLES
251
252#define TABLE_LOCAL_INDEX (RT_TABLE_LOCAL & (FIB_TABLE_HASHSZ - 1))
253#define TABLE_MAIN_INDEX (RT_TABLE_MAIN & (FIB_TABLE_HASHSZ - 1))
254
255static inline struct fib_table *fib_get_table(struct net *net, u32 id)
256{
257 struct hlist_node *tb_hlist;
258 struct hlist_head *ptr;
259
260 ptr = id == RT_TABLE_LOCAL ?
261 &net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX] :
262 &net->ipv4.fib_table_hash[TABLE_MAIN_INDEX];
263
264 tb_hlist = rcu_dereference_rtnl(hlist_first_rcu(ptr));
265
266 return hlist_entry(tb_hlist, struct fib_table, tb_hlist);
267}
268
269static inline struct fib_table *fib_new_table(struct net *net, u32 id)
270{
271 return fib_get_table(net, id);
272}
273
274static inline int fib_lookup(struct net *net, const struct flowi4 *flp,
275 struct fib_result *res, unsigned int flags)
276{
277 struct fib_table *tb;
278 int err = -ENETUNREACH;
279
280 rcu_read_lock();
281
282 tb = fib_get_table(net, RT_TABLE_MAIN);
283 if (tb)
284 err = fib_table_lookup(tb, flp, res, flags | FIB_LOOKUP_NOREF);
285
286 if (err == -EAGAIN)
287 err = -ENETUNREACH;
288
289 rcu_read_unlock();
290
291 return err;
292}
293
294#else /* CONFIG_IP_MULTIPLE_TABLES */
295int __net_init fib4_rules_init(struct net *net);
296void __net_exit fib4_rules_exit(struct net *net);
297
298struct fib_table *fib_new_table(struct net *net, u32 id);
299struct fib_table *fib_get_table(struct net *net, u32 id);
300
301int __fib_lookup(struct net *net, struct flowi4 *flp,
302 struct fib_result *res, unsigned int flags);
303
304static inline int fib_lookup(struct net *net, struct flowi4 *flp,
305 struct fib_result *res, unsigned int flags)
306{
307 struct fib_table *tb;
308 int err = -ENETUNREACH;
309
310 flags |= FIB_LOOKUP_NOREF;
311 if (net->ipv4.fib_has_custom_rules)
312 return __fib_lookup(net, flp, res, flags);
313
314 rcu_read_lock();
315
316 res->tclassid = 0;
317
318 tb = rcu_dereference_rtnl(net->ipv4.fib_main);
319 if (tb)
320 err = fib_table_lookup(tb, flp, res, flags);
321
322 if (!err)
323 goto out;
324
325 tb = rcu_dereference_rtnl(net->ipv4.fib_default);
326 if (tb)
327 err = fib_table_lookup(tb, flp, res, flags);
328
329out:
330 if (err == -EAGAIN)
331 err = -ENETUNREACH;
332
333 rcu_read_unlock();
334
335 return err;
336}
337
338#endif /* CONFIG_IP_MULTIPLE_TABLES */
339
340/* Exported by fib_frontend.c */
341extern const struct nla_policy rtm_ipv4_policy[];
342void ip_fib_init(void);
343__be32 fib_compute_spec_dst(struct sk_buff *skb);
344int fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst,
345 u8 tos, int oif, struct net_device *dev,
346 struct in_device *idev, u32 *itag);
347void fib_select_default(const struct flowi4 *flp, struct fib_result *res);
348#ifdef CONFIG_IP_ROUTE_CLASSID
349static inline int fib_num_tclassid_users(struct net *net)
350{
351 return net->ipv4.fib_num_tclassid_users;
352}
353#else
354static inline int fib_num_tclassid_users(struct net *net)
355{
356 return 0;
357}
358#endif
359int fib_unmerge(struct net *net);
360
361/* Exported by fib_semantics.c */
362int ip_fib_check_default(__be32 gw, struct net_device *dev);
363int fib_sync_down_dev(struct net_device *dev, unsigned long event, bool force);
364int fib_sync_down_addr(struct net_device *dev, __be32 local);
365int fib_sync_up(struct net_device *dev, unsigned int nh_flags);
366
367extern u32 fib_multipath_secret __read_mostly;
368
369static inline int fib_multipath_hash(__be32 saddr, __be32 daddr)
370{
371 return jhash_2words((__force u32)saddr, (__force u32)daddr,
372 fib_multipath_secret) >> 1;
373}
374
375void fib_select_multipath(struct fib_result *res, int hash);
376void fib_select_path(struct net *net, struct fib_result *res,
377 struct flowi4 *fl4, int mp_hash);
378
379/* Exported by fib_trie.c */
380void fib_trie_init(void);
381struct fib_table *fib_trie_table(u32 id, struct fib_table *alias);
382
383static inline void fib_combine_itag(u32 *itag, const struct fib_result *res)
384{
385#ifdef CONFIG_IP_ROUTE_CLASSID
386#ifdef CONFIG_IP_MULTIPLE_TABLES
387 u32 rtag;
388#endif
389 *itag = FIB_RES_NH(*res).nh_tclassid<<16;
390#ifdef CONFIG_IP_MULTIPLE_TABLES
391 rtag = res->tclassid;
392 if (*itag == 0)
393 *itag = (rtag<<16);
394 *itag |= (rtag>>16);
395#endif
396#endif
397}
398
399void free_fib_info(struct fib_info *fi);
400
401static inline void fib_info_hold(struct fib_info *fi)
402{
403 atomic_inc(&fi->fib_clntref);
404}
405
406static inline void fib_info_put(struct fib_info *fi)
407{
408 if (atomic_dec_and_test(&fi->fib_clntref))
409 free_fib_info(fi);
410}
411
412#ifdef CONFIG_PROC_FS
413int __net_init fib_proc_init(struct net *net);
414void __net_exit fib_proc_exit(struct net *net);
415#else
416static inline int fib_proc_init(struct net *net)
417{
418 return 0;
419}
420static inline void fib_proc_exit(struct net *net)
421{
422}
423#endif
424
425#endif /* _NET_FIB_H */