1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1980, 1986, 1991, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31 /************************************************************************
32 * Note: In this file a 'fib' is a "forwarding information base" *
33 * Which is the new name for an in kernel routing (next hop) table. *
34 ***********************************************************************/
35
36 #include <sys/cdefs.h>
37 __FBSDID("$FreeBSD$");
38 #include "opt_route.h"
39
40 #include <sys/param.h>
41 #include <sys/socket.h>
42 #include <sys/systm.h>
43 #include <sys/malloc.h>
44 #include <sys/jail.h>
45 #include <sys/proc.h>
46 #include <sys/sysctl.h>
47 #include <sys/syslog.h>
48 #include <sys/kernel.h>
49 #include <sys/lock.h>
50 #include <sys/sx.h>
51 #include <sys/domain.h>
52 #include <sys/sysproto.h>
53
54 #include <net/vnet.h>
55 #include <net/route.h>
56 #include <net/route/route_var.h>
57
58 /* Kernel config default option. */
59 #ifdef ROUTETABLES
60 #if ROUTETABLES <= 0
61 #error "ROUTETABLES defined too low"
62 #endif
63 #if ROUTETABLES > RT_MAXFIBS
64 #error "ROUTETABLES defined too big"
65 #endif
66 #define RT_NUMFIBS ROUTETABLES
67 #endif /* ROUTETABLES */
68 /* Initialize to default if not otherwise set. */
69 #ifndef RT_NUMFIBS
70 #define RT_NUMFIBS 1
71 #endif
72
73 static void grow_rtables(uint32_t num_fibs);
74
75 VNET_DEFINE_STATIC(struct sx, rtables_lock);
76 #define V_rtables_lock VNET(rtables_lock)
77 #define RTABLES_LOCK() sx_xlock(&V_rtables_lock)
78 #define RTABLES_UNLOCK() sx_xunlock(&V_rtables_lock)
79 #define RTABLES_LOCK_INIT() sx_init(&V_rtables_lock, "rtables lock")
80 #define RTABLES_LOCK_ASSERT() sx_assert(&V_rtables_lock, SA_LOCKED)
81
82 VNET_DEFINE_STATIC(struct rib_head **, rt_tables);
83 #define V_rt_tables VNET(rt_tables)
84
85 VNET_DEFINE(uint32_t, _rt_numfibs) = RT_NUMFIBS;
86
87 /*
88 * Handler for net.my_fibnum.
89 * Returns current fib of the process.
90 */
91 static int
sysctl_my_fibnum(SYSCTL_HANDLER_ARGS)92 sysctl_my_fibnum(SYSCTL_HANDLER_ARGS)
93 {
94 int fibnum;
95 int error;
96
97 fibnum = curthread->td_proc->p_fibnum;
98 error = sysctl_handle_int(oidp, &fibnum, 0, req);
99 return (error);
100 }
101 SYSCTL_PROC(_net, OID_AUTO, my_fibnum,
102 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 0,
103 &sysctl_my_fibnum, "I",
104 "default FIB of caller");
105
106 static uint32_t
normalize_num_rtables(uint32_t num_rtables)107 normalize_num_rtables(uint32_t num_rtables)
108 {
109
110 if (num_rtables > RT_MAXFIBS)
111 num_rtables = RT_MAXFIBS;
112 else if (num_rtables == 0)
113 num_rtables = 1;
114 return (num_rtables);
115 }
116
117 /*
118 * Sets the number of fibs in the current vnet.
119 * Function does not allow shrinking number of rtables.
120 */
121 static int
sysctl_fibs(SYSCTL_HANDLER_ARGS)122 sysctl_fibs(SYSCTL_HANDLER_ARGS)
123 {
124 uint32_t new_fibs;
125 int error;
126
127 RTABLES_LOCK();
128 new_fibs = V_rt_numfibs;
129 error = sysctl_handle_32(oidp, &new_fibs, 0, req);
130 if (error == 0) {
131 new_fibs = normalize_num_rtables(new_fibs);
132
133 if (new_fibs < V_rt_numfibs)
134 error = ENOTCAPABLE;
135 if (new_fibs > V_rt_numfibs)
136 grow_rtables(new_fibs);
137 }
138 RTABLES_UNLOCK();
139
140 return (error);
141 }
142 SYSCTL_PROC(_net, OID_AUTO, fibs,
143 CTLFLAG_VNET | CTLTYPE_U32 | CTLFLAG_RWTUN | CTLFLAG_NOFETCH | CTLFLAG_MPSAFE,
144 NULL, 0, &sysctl_fibs, "IU",
145 "set number of fibs");
146
147 /*
148 * Sets fib of a current process.
149 */
150 int
sys_setfib(struct thread * td,struct setfib_args * uap)151 sys_setfib(struct thread *td, struct setfib_args *uap)
152 {
153 int error = 0;
154
155 CURVNET_SET(TD_TO_VNET(td));
156 if (uap->fibnum >= 0 && uap->fibnum < V_rt_numfibs)
157 td->td_proc->p_fibnum = uap->fibnum;
158 else
159 error = EINVAL;
160 CURVNET_RESTORE();
161
162 return (error);
163 }
164
165 /*
166 * Grows up the number of routing tables in the current fib.
167 * Function creates new index array for all rtables and allocates
168 * remaining routing tables.
169 */
170 static void
grow_rtables(uint32_t num_tables)171 grow_rtables(uint32_t num_tables)
172 {
173 struct domain *dom;
174 struct rib_head **prnh, *rh;
175 struct rib_head **new_rt_tables, **old_rt_tables;
176 int family;
177
178 RTABLES_LOCK_ASSERT();
179
180 KASSERT(num_tables >= V_rt_numfibs, ("num_tables(%u) < rt_numfibs(%u)\n",
181 num_tables, V_rt_numfibs));
182
183 new_rt_tables = mallocarray(num_tables * (AF_MAX + 1), sizeof(void *),
184 M_RTABLE, M_WAITOK | M_ZERO);
185
186 if ((num_tables > 1) && (V_rt_add_addr_allfibs == 0))
187 printf("WARNING: Adding ifaddrs to all fibs has been turned off "
188 "by default. Consider tuning %s if needed\n",
189 "net.add_addr_allfibs");
190
191 #ifdef FIB_ALGO
192 fib_grow_rtables(num_tables);
193 #endif
194
195 /*
196 * Current rt_tables layout:
197 * fib0[af0, af1, af2, .., AF_MAX]fib1[af0, af1, af2, .., Af_MAX]..
198 * this allows to copy existing tables data by using memcpy()
199 */
200 if (V_rt_tables != NULL)
201 memcpy(new_rt_tables, V_rt_tables,
202 V_rt_numfibs * (AF_MAX + 1) * sizeof(void *));
203
204 /* Populate the remainders */
205 for (dom = domains; dom; dom = dom->dom_next) {
206 if (dom->dom_rtattach == NULL)
207 continue;
208 family = dom->dom_family;
209 for (int i = 0; i < num_tables; i++) {
210 prnh = &new_rt_tables[i * (AF_MAX + 1) + family];
211 if (*prnh != NULL)
212 continue;
213 rh = dom->dom_rtattach(i);
214 if (rh == NULL)
215 log(LOG_ERR, "unable to create routing table for %d.%d\n",
216 dom->dom_family, i);
217 #ifdef FIB_ALGO
218 if (fib_select_algo_initial(rh) != 0) {
219 log(LOG_ERR, "unable to select algo for table %d.%d\n",
220 dom->dom_family, i);
221 // TODO: detach table
222 }
223 #endif
224 *prnh = rh;
225 }
226 }
227
228 /*
229 * Update rtables pointer.
230 * Ensure all writes to new_rt_tables has been completed before
231 * switching pointer.
232 */
233 atomic_thread_fence_rel();
234 old_rt_tables = V_rt_tables;
235 V_rt_tables = new_rt_tables;
236
237 /* Wait till all cpus see new pointers */
238 atomic_thread_fence_rel();
239 epoch_wait_preempt(net_epoch_preempt);
240
241 /* Finally, set number of fibs to a new value */
242 V_rt_numfibs = num_tables;
243
244 if (old_rt_tables != NULL)
245 free(old_rt_tables, M_RTABLE);
246 }
247
248 static void
vnet_rtables_init(const void * unused __unused)249 vnet_rtables_init(const void *unused __unused)
250 {
251 int num_rtables_base;
252
253 if (IS_DEFAULT_VNET(curvnet)) {
254 num_rtables_base = RT_NUMFIBS;
255 TUNABLE_INT_FETCH("net.fibs", &num_rtables_base);
256 V_rt_numfibs = normalize_num_rtables(num_rtables_base);
257 } else
258 V_rt_numfibs = 1;
259
260 vnet_rtzone_init();
261 #ifdef FIB_ALGO
262 vnet_fib_init();
263 #endif
264 RTABLES_LOCK_INIT();
265
266 RTABLES_LOCK();
267 grow_rtables(V_rt_numfibs);
268 RTABLES_UNLOCK();
269 }
270 VNET_SYSINIT(vnet_rtables_init, SI_SUB_PROTO_DOMAIN, SI_ORDER_FOURTH,
271 vnet_rtables_init, 0);
272
273 #ifdef VIMAGE
274 static void
rtables_destroy(const void * unused __unused)275 rtables_destroy(const void *unused __unused)
276 {
277 struct rib_head *rnh;
278 struct domain *dom;
279 int family;
280
281 RTABLES_LOCK();
282 for (dom = domains; dom; dom = dom->dom_next) {
283 if (dom->dom_rtdetach == NULL)
284 continue;
285 family = dom->dom_family;
286 for (int i = 0; i < V_rt_numfibs; i++) {
287 rnh = rt_tables_get_rnh(i, family);
288 dom->dom_rtdetach(rnh);
289 }
290 }
291 RTABLES_UNLOCK();
292
293 /*
294 * dom_rtdetach calls rt_table_destroy(), which
295 * schedules deletion for all rtentries, nexthops and control
296 * structures. Wait for the destruction callbacks to fire.
297 * Note that this should result in freeing all rtentries, but
298 * nexthops deletions will be scheduled for the next epoch run
299 * and will be completed after vnet teardown.
300 */
301 epoch_drain_callbacks(net_epoch_preempt);
302
303 free(V_rt_tables, M_RTABLE);
304 vnet_rtzone_destroy();
305 #ifdef FIB_ALGO
306 vnet_fib_destroy();
307 #endif
308 }
309 VNET_SYSUNINIT(rtables_destroy, SI_SUB_PROTO_DOMAIN, SI_ORDER_FIRST,
310 rtables_destroy, 0);
311 #endif
312
313 static inline struct rib_head *
rt_tables_get_rnh_ptr(uint32_t table,sa_family_t family)314 rt_tables_get_rnh_ptr(uint32_t table, sa_family_t family)
315 {
316 struct rib_head **prnh;
317
318 KASSERT(table < V_rt_numfibs,
319 ("%s: table out of bounds (%d < %d)", __func__, table,
320 V_rt_numfibs));
321 KASSERT(family < (AF_MAX + 1),
322 ("%s: fam out of bounds (%d < %d)", __func__, family, AF_MAX + 1));
323
324 /* rnh is [fib=0][af=0]. */
325 prnh = V_rt_tables;
326 /* Get the offset to the requested table and fam. */
327 prnh += table * (AF_MAX + 1) + family;
328
329 return (*prnh);
330 }
331
332 struct rib_head *
rt_tables_get_rnh(uint32_t table,sa_family_t family)333 rt_tables_get_rnh(uint32_t table, sa_family_t family)
334 {
335
336 return (rt_tables_get_rnh_ptr(table, family));
337 }
338
339 u_int
rt_tables_get_gen(uint32_t table,sa_family_t family)340 rt_tables_get_gen(uint32_t table, sa_family_t family)
341 {
342 struct rib_head *rnh;
343
344 rnh = rt_tables_get_rnh_ptr(table, family);
345 KASSERT(rnh != NULL, ("%s: NULL rib_head pointer table %d family %d",
346 __func__, table, family));
347 return (rnh->rnh_gen);
348 }
349