1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2020 Alexander V. Chernikov 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28 #include <sys/cdefs.h> 29 __FBSDID("$FreeBSD$"); 30 #include "opt_inet.h" 31 32 #include <sys/param.h> 33 #include <sys/kernel.h> 34 #include <sys/lock.h> 35 #include <sys/rmlock.h> 36 #include <sys/malloc.h> 37 #include <sys/module.h> 38 #include <sys/kernel.h> 39 #include <sys/socket.h> 40 #include <sys/sysctl.h> 41 #include <sys/syslog.h> 42 #include <net/vnet.h> 43 44 #include <net/if.h> 45 #include <net/if_var.h> 46 47 #include <netinet/in.h> 48 #include <netinet/in_fib.h> 49 #include <netinet/ip.h> 50 51 #include <net/route.h> 52 #include <net/route/nhop.h> 53 #include <net/route/route_ctl.h> 54 #include <net/route/fib_algo.h> 55 56 #include "rte_shim.h" 57 #include "rte_lpm.h" 58 59 #define LPM_MIN_TBL8 8 /* 2 pages of memory */ 60 #define LPM_MAX_TBL8 65536 * 16 /* 256M */ 61 62 MALLOC_DECLARE(M_RTABLE); 63 64 struct dpdk_lpm_data { 65 struct rte_lpm *lpm; 66 uint64_t routes_added; 67 uint64_t routes_failed; 68 uint32_t number_tbl8s; 69 uint32_t fibnum; 70 uint8_t hit_tables; 71 uint8_t hit_records; 72 struct fib_data *fd; 73 }; 74 75 /* 76 * Main datapath routing 77 */ 78 static struct nhop_object * 79 lookup_ptr(void *algo_data, const struct flm_lookup_key key, uint32_t scopeid) 80 { 81 struct rte_lpm *lpm; 82 const struct rte_lpm_external *rte_ext; 83 uint32_t nhidx = 0; 84 int ret; 85 86 lpm = (struct rte_lpm *)algo_data; 87 rte_ext = (const struct rte_lpm_external *)lpm; 88 89 ret = rte_lpm_lookup(lpm, ntohl(key.addr4.s_addr), &nhidx); 90 if (ret == 0) { 91 /* Success! */ 92 return (rte_ext->nh_idx[nhidx]); 93 } else { 94 /* Not found. Check default route */ 95 return (rte_ext->nh_idx[rte_ext->default_idx]); 96 } 97 98 return (NULL); 99 } 100 101 static uint8_t 102 rte_get_pref(const struct rib_rtable_info *rinfo) 103 { 104 105 if (rinfo->num_prefixes < 10) 106 return (1); 107 else if (rinfo->num_prefixes < 1000) 108 return (rinfo->num_prefixes / 10); 109 else if (rinfo->num_prefixes < 500000) 110 return (100 + rinfo->num_prefixes / 3334); 111 else 112 return (250); 113 } 114 115 static enum flm_op_result 116 handle_default_change(struct dpdk_lpm_data *dd, struct rib_cmd_info *rc) 117 { 118 struct rte_lpm_external *rte_ext; 119 rte_ext = (struct rte_lpm_external *)dd->lpm; 120 121 if (rc->rc_cmd != RTM_DELETE) { 122 /* Reference new */ 123 uint32_t nhidx = fib_get_nhop_idx(dd->fd, rc->rc_nh_new); 124 125 if (nhidx == 0) 126 return (FLM_REBUILD); 127 rte_ext->default_idx = nhidx; 128 } else { 129 /* No default route */ 130 rte_ext->default_idx = 0; 131 } 132 133 return (FLM_SUCCESS); 134 } 135 136 static void 137 get_parent_rule(struct dpdk_lpm_data *dd, struct in_addr addr, int plen, 138 uint8_t *pplen, uint32_t *nhop_idx) 139 { 140 struct rtentry *rt; 141 142 rt = rt_get_inet_parent(dd->fibnum, addr, plen); 143 if (rt != NULL) { 144 struct in_addr addr4; 145 uint32_t scopeid; 146 int parent_plen; 147 148 rt_get_inet_prefix_plen(rt, &addr4, &parent_plen, &scopeid); 149 if (parent_plen > 0) { 150 *pplen = parent_plen; 151 *nhop_idx = fib_get_nhop_idx(dd->fd, rt_get_raw_nhop(rt)); 152 return; 153 } 154 } 155 156 *nhop_idx = 0; 157 *pplen = 0; 158 } 159 160 static enum flm_op_result 161 handle_gu_change(struct dpdk_lpm_data *dd, const struct rib_cmd_info *rc, 162 const struct in_addr addr, int plen) 163 { 164 uint32_t nhidx = 0; 165 int ret; 166 char abuf[INET_ADDRSTRLEN]; 167 uint32_t ip; 168 169 ip = ntohl(addr.s_addr); 170 inet_ntop(AF_INET, &addr, abuf, sizeof(abuf)); 171 172 /* So we get sin, plen and nhidx */ 173 if (rc->rc_cmd != RTM_DELETE) { 174 /* 175 * Addition or change. Save nhop in the internal table 176 * and get index. 177 */ 178 nhidx = fib_get_nhop_idx(dd->fd, rc->rc_nh_new); 179 if (nhidx == 0) { 180 FIB_PRINTF(LOG_INFO, dd->fd, "nhop limit reached, need rebuild"); 181 return (FLM_REBUILD); 182 } 183 184 ret = rte_lpm_add(dd->lpm, ip, plen, nhidx); 185 FIB_PRINTF(LOG_DEBUG, dd->fd, "DPDK GU: %s %s/%d nhop %u -> %u ret: %d", 186 (rc->rc_cmd == RTM_ADD) ? "ADD" : "UPDATE", 187 abuf, plen, 188 rc->rc_nh_old != NULL ? fib_get_nhop_idx(dd->fd, rc->rc_nh_old) : 0, 189 nhidx, ret); 190 } else { 191 /* 192 * Need to lookup parent. Assume deletion happened already 193 */ 194 uint8_t parent_plen; 195 uint32_t parent_nhop_idx; 196 get_parent_rule(dd, addr, plen, &parent_plen, &parent_nhop_idx); 197 198 ret = rte_lpm_delete(dd->lpm, ip, plen, parent_plen, parent_nhop_idx); 199 FIB_PRINTF(LOG_DEBUG, dd->fd, "DPDK: %s %s/%d -> /%d nhop %u -> %u ret: %d", 200 "DEL", abuf, plen, parent_plen, fib_get_nhop_idx(dd->fd, rc->rc_nh_old), 201 parent_nhop_idx, ret); 202 } 203 204 if (ret != 0) { 205 FIB_PRINTF(LOG_INFO, dd->fd, "error: %d", ret); 206 if (ret == -ENOSPC) 207 return (FLM_REBUILD); 208 return (FLM_ERROR); 209 } 210 return (FLM_SUCCESS); 211 } 212 213 static enum flm_op_result 214 handle_rtable_change_cb(struct rib_head *rnh, struct rib_cmd_info *rc, 215 void *_data) 216 { 217 struct dpdk_lpm_data *dd; 218 enum flm_op_result ret; 219 struct in_addr addr4; 220 uint32_t scopeid; 221 int plen; 222 223 dd = (struct dpdk_lpm_data *)_data; 224 rt_get_inet_prefix_plen(rc->rc_rt, &addr4, &plen, &scopeid); 225 226 if (plen != 0) 227 ret = handle_gu_change(dd, rc, addr4, plen); 228 else 229 ret = handle_default_change(dd, rc); 230 231 if (ret != 0) 232 FIB_PRINTF(LOG_INFO, dd->fd, "error handling route"); 233 return (ret); 234 } 235 236 static void 237 destroy_table(void *_data) 238 { 239 struct dpdk_lpm_data *dd = (struct dpdk_lpm_data *)_data; 240 241 if (dd->lpm != NULL) 242 rte_lpm_free(dd->lpm); 243 free(dd, M_RTABLE); 244 } 245 246 static enum flm_op_result 247 add_route_cb(struct rtentry *rt, void *_data) 248 { 249 struct dpdk_lpm_data *dd = (struct dpdk_lpm_data *)_data; 250 struct nhop_object *nh; 251 int plen, ret; 252 struct in_addr addr4; 253 uint32_t scopeid; 254 255 nh = rt_get_raw_nhop(rt); 256 rt_get_inet_prefix_plen(rt, &addr4, &plen, &scopeid); 257 258 char abuf[INET_ADDRSTRLEN]; 259 inet_ntop(AF_INET, &addr4, abuf, sizeof(abuf)); 260 261 FIB_PRINTF(LOG_DEBUG, dd->fd, "Operating on %s/%d", abuf, plen); 262 263 if (plen == 0) { 264 struct rib_cmd_info rc = { 265 .rc_cmd = RTM_ADD, 266 .rc_nh_new = nh, 267 }; 268 269 FIB_PRINTF(LOG_DEBUG, dd->fd, "Adding default route"); 270 return (handle_default_change(dd, &rc)); 271 } 272 273 uint32_t nhidx = fib_get_nhop_idx(dd->fd, nh); 274 if (nhidx == 0) { 275 FIB_PRINTF(LOG_INFO, dd->fd, "unable to get nhop index"); 276 return (FLM_REBUILD); 277 } 278 ret = rte_lpm_add(dd->lpm, ntohl(addr4.s_addr), plen, nhidx); 279 FIB_PRINTF(LOG_DEBUG, dd->fd, "ADD %p %s/%d nh %u = %d", 280 dd->lpm, abuf, plen, nhidx, ret); 281 282 if (ret != 0) { 283 FIB_PRINTF(LOG_INFO, dd->fd, "rte_lpm_add() returned %d", ret); 284 if (ret == -ENOSPC) { 285 dd->hit_tables = 1; 286 return (FLM_REBUILD); 287 } 288 dd->routes_failed++; 289 return (FLM_ERROR); 290 } else 291 dd->routes_added++; 292 293 return (FLM_SUCCESS); 294 } 295 296 static enum flm_op_result 297 check_dump_success(void *_data, struct fib_dp *dp) 298 { 299 struct dpdk_lpm_data *dd; 300 301 dd = (struct dpdk_lpm_data *)_data; 302 303 FIB_PRINTF(LOG_INFO, dd->fd, "scan completed. added: %zu failed: %zu", 304 dd->routes_added, dd->routes_failed); 305 if (dd->hit_tables || dd->routes_failed > 0) 306 return (FLM_REBUILD); 307 308 FIB_PRINTF(LOG_INFO, dd->fd, 309 "DPDK lookup engine synced with IPv4 RIB id %u, %zu routes", 310 dd->fibnum, dd->routes_added); 311 312 dp->f = lookup_ptr; 313 dp->arg = dd->lpm; 314 315 return (FLM_SUCCESS); 316 } 317 318 static void 319 estimate_scale(const struct dpdk_lpm_data *dd_src, struct dpdk_lpm_data *dd) 320 { 321 322 /* XXX: update at 75% capacity */ 323 if (dd_src->hit_tables) 324 dd->number_tbl8s = dd_src->number_tbl8s * 2; 325 else 326 dd->number_tbl8s = dd_src->number_tbl8s; 327 328 /* TODO: look into the appropriate RIB to adjust */ 329 } 330 331 static struct dpdk_lpm_data * 332 build_table(struct dpdk_lpm_data *dd_prev, struct fib_data *fd) 333 { 334 struct dpdk_lpm_data *dd; 335 struct rte_lpm *lpm; 336 337 dd = malloc(sizeof(struct dpdk_lpm_data), M_RTABLE, M_NOWAIT | M_ZERO); 338 if (dd == NULL) { 339 FIB_PRINTF(LOG_INFO, fd, "Unable to allocate base datastructure"); 340 return (NULL); 341 } 342 dd->fibnum = dd_prev->fibnum; 343 dd->fd = fd; 344 345 estimate_scale(dd_prev, dd); 346 347 struct rte_lpm_config cfg = {.number_tbl8s = dd->number_tbl8s}; 348 lpm = rte_lpm_create("test", 0, &cfg); 349 if (lpm == NULL) { 350 FIB_PRINTF(LOG_INFO, fd, "unable to create lpm"); 351 free(dd, M_RTABLE); 352 return (NULL); 353 } 354 dd->lpm = lpm; 355 struct rte_lpm_external *ext = (struct rte_lpm_external *)lpm; 356 ext->nh_idx = fib_get_nhop_array(dd->fd); 357 358 FIB_PRINTF(LOG_INFO, fd, "allocated %u tbl8s", dd->number_tbl8s); 359 360 return (dd); 361 } 362 363 static enum flm_op_result 364 init_table(uint32_t fibnum, struct fib_data *fd, void *_old_data, void **data) 365 { 366 struct dpdk_lpm_data *dd, dd_base; 367 368 if (_old_data == NULL) { 369 bzero(&dd_base, sizeof(struct dpdk_lpm_data)); 370 dd_base.fibnum = fibnum; 371 /* TODO: get rib statistics */ 372 dd_base.number_tbl8s = LPM_MIN_TBL8; 373 dd = &dd_base; 374 } else { 375 FIB_PRINTF(LOG_DEBUG, fd, "Starting with old data"); 376 dd = (struct dpdk_lpm_data *)_old_data; 377 } 378 379 /* Guaranteed to be in epoch */ 380 dd = build_table(dd, fd); 381 if (dd == NULL) { 382 FIB_PRINTF(LOG_NOTICE, fd, "table creation failed"); 383 return (FLM_REBUILD); 384 } 385 386 *data = dd; 387 return (FLM_SUCCESS); 388 } 389 390 static struct fib_lookup_module dpdk_lpm4 = { 391 .flm_name = "dpdk_lpm4", 392 .flm_family = AF_INET, 393 .flm_init_cb = init_table, 394 .flm_destroy_cb = destroy_table, 395 .flm_dump_rib_item_cb = add_route_cb, 396 .flm_dump_end_cb = check_dump_success, 397 .flm_change_rib_item_cb = handle_rtable_change_cb, 398 .flm_get_pref = rte_get_pref, 399 }; 400 401 static int 402 lpm4_modevent(module_t mod, int type, void *unused) 403 { 404 int error = 0; 405 406 switch (type) { 407 case MOD_LOAD: 408 fib_module_register(&dpdk_lpm4); 409 break; 410 case MOD_UNLOAD: 411 error = fib_module_unregister(&dpdk_lpm4); 412 break; 413 default: 414 error = EOPNOTSUPP; 415 break; 416 } 417 return (error); 418 } 419 420 static moduledata_t lpm4mod = { 421 "dpdk_lpm4", 422 lpm4_modevent, 423 0 424 }; 425 426 DECLARE_MODULE(lpm4mod, lpm4mod, SI_SUB_PSEUDO, SI_ORDER_ANY); 427 MODULE_VERSION(lpm4mod, 1); 428