1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018 Vladimir Medvedkin <[email protected]>
3 * Copyright(c) 2019 Intel Corporation
4 */
5
6 #include <stdint.h>
7 #include <stdio.h>
8
9 #include <rte_debug.h>
10 #include <rte_malloc.h>
11 #include <rte_errno.h>
12 #include <rte_vect.h>
13
14 #include <rte_rib.h>
15 #include <rte_fib.h>
16 #include "dir24_8.h"
17
18 #ifdef CC_DIR24_8_AVX512_SUPPORT
19
20 #include "dir24_8_avx512.h"
21
22 #endif /* CC_DIR24_8_AVX512_SUPPORT */
23
24 #define DIR24_8_NAMESIZE 64
25
26 #define ROUNDUP(x, y) RTE_ALIGN_CEIL(x, (1 << (32 - y)))
27
28 static inline rte_fib_lookup_fn_t
get_scalar_fn(enum rte_fib_dir24_8_nh_sz nh_sz)29 get_scalar_fn(enum rte_fib_dir24_8_nh_sz nh_sz)
30 {
31 switch (nh_sz) {
32 case RTE_FIB_DIR24_8_1B:
33 return dir24_8_lookup_bulk_1b;
34 case RTE_FIB_DIR24_8_2B:
35 return dir24_8_lookup_bulk_2b;
36 case RTE_FIB_DIR24_8_4B:
37 return dir24_8_lookup_bulk_4b;
38 case RTE_FIB_DIR24_8_8B:
39 return dir24_8_lookup_bulk_8b;
40 default:
41 return NULL;
42 }
43 }
44
45 static inline rte_fib_lookup_fn_t
get_scalar_fn_inlined(enum rte_fib_dir24_8_nh_sz nh_sz)46 get_scalar_fn_inlined(enum rte_fib_dir24_8_nh_sz nh_sz)
47 {
48 switch (nh_sz) {
49 case RTE_FIB_DIR24_8_1B:
50 return dir24_8_lookup_bulk_0;
51 case RTE_FIB_DIR24_8_2B:
52 return dir24_8_lookup_bulk_1;
53 case RTE_FIB_DIR24_8_4B:
54 return dir24_8_lookup_bulk_2;
55 case RTE_FIB_DIR24_8_8B:
56 return dir24_8_lookup_bulk_3;
57 default:
58 return NULL;
59 }
60 }
61
62 static inline rte_fib_lookup_fn_t
get_vector_fn(enum rte_fib_dir24_8_nh_sz nh_sz)63 get_vector_fn(enum rte_fib_dir24_8_nh_sz nh_sz)
64 {
65 #ifdef CC_DIR24_8_AVX512_SUPPORT
66 if ((rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512F) <= 0) ||
67 (rte_vect_get_max_simd_bitwidth() < RTE_VECT_SIMD_512))
68 return NULL;
69
70 switch (nh_sz) {
71 case RTE_FIB_DIR24_8_1B:
72 return rte_dir24_8_vec_lookup_bulk_1b;
73 case RTE_FIB_DIR24_8_2B:
74 return rte_dir24_8_vec_lookup_bulk_2b;
75 case RTE_FIB_DIR24_8_4B:
76 return rte_dir24_8_vec_lookup_bulk_4b;
77 case RTE_FIB_DIR24_8_8B:
78 return rte_dir24_8_vec_lookup_bulk_8b;
79 default:
80 return NULL;
81 }
82 #else
83 RTE_SET_USED(nh_sz);
84 #endif
85 return NULL;
86 }
87
88 rte_fib_lookup_fn_t
dir24_8_get_lookup_fn(void * p,enum rte_fib_lookup_type type)89 dir24_8_get_lookup_fn(void *p, enum rte_fib_lookup_type type)
90 {
91 enum rte_fib_dir24_8_nh_sz nh_sz;
92 rte_fib_lookup_fn_t ret_fn;
93 struct dir24_8_tbl *dp = p;
94
95 if (dp == NULL)
96 return NULL;
97
98 nh_sz = dp->nh_sz;
99
100 switch (type) {
101 case RTE_FIB_LOOKUP_DIR24_8_SCALAR_MACRO:
102 return get_scalar_fn(nh_sz);
103 case RTE_FIB_LOOKUP_DIR24_8_SCALAR_INLINE:
104 return get_scalar_fn_inlined(nh_sz);
105 case RTE_FIB_LOOKUP_DIR24_8_SCALAR_UNI:
106 return dir24_8_lookup_bulk_uni;
107 case RTE_FIB_LOOKUP_DIR24_8_VECTOR_AVX512:
108 return get_vector_fn(nh_sz);
109 case RTE_FIB_LOOKUP_DEFAULT:
110 ret_fn = get_vector_fn(nh_sz);
111 return (ret_fn != NULL) ? ret_fn : get_scalar_fn(nh_sz);
112 default:
113 return NULL;
114 }
115
116 return NULL;
117 }
118
119 static void
write_to_fib(void * ptr,uint64_t val,enum rte_fib_dir24_8_nh_sz size,int n)120 write_to_fib(void *ptr, uint64_t val, enum rte_fib_dir24_8_nh_sz size, int n)
121 {
122 int i;
123 uint8_t *ptr8 = (uint8_t *)ptr;
124 uint16_t *ptr16 = (uint16_t *)ptr;
125 uint32_t *ptr32 = (uint32_t *)ptr;
126 uint64_t *ptr64 = (uint64_t *)ptr;
127
128 switch (size) {
129 case RTE_FIB_DIR24_8_1B:
130 for (i = 0; i < n; i++)
131 ptr8[i] = (uint8_t)val;
132 break;
133 case RTE_FIB_DIR24_8_2B:
134 for (i = 0; i < n; i++)
135 ptr16[i] = (uint16_t)val;
136 break;
137 case RTE_FIB_DIR24_8_4B:
138 for (i = 0; i < n; i++)
139 ptr32[i] = (uint32_t)val;
140 break;
141 case RTE_FIB_DIR24_8_8B:
142 for (i = 0; i < n; i++)
143 ptr64[i] = (uint64_t)val;
144 break;
145 }
146 }
147
148 static int
tbl8_get_idx(struct dir24_8_tbl * dp)149 tbl8_get_idx(struct dir24_8_tbl *dp)
150 {
151 uint32_t i;
152 int bit_idx;
153
154 for (i = 0; (i < (dp->number_tbl8s >> BITMAP_SLAB_BIT_SIZE_LOG2)) &&
155 (dp->tbl8_idxes[i] == UINT64_MAX); i++)
156 ;
157 if (i < (dp->number_tbl8s >> BITMAP_SLAB_BIT_SIZE_LOG2)) {
158 bit_idx = __builtin_ctzll(~dp->tbl8_idxes[i]);
159 dp->tbl8_idxes[i] |= (1ULL << bit_idx);
160 return (i << BITMAP_SLAB_BIT_SIZE_LOG2) + bit_idx;
161 }
162 return -ENOSPC;
163 }
164
165 static inline void
tbl8_free_idx(struct dir24_8_tbl * dp,int idx)166 tbl8_free_idx(struct dir24_8_tbl *dp, int idx)
167 {
168 dp->tbl8_idxes[idx >> BITMAP_SLAB_BIT_SIZE_LOG2] &=
169 ~(1ULL << (idx & BITMAP_SLAB_BITMASK));
170 }
171
172 static int
tbl8_alloc(struct dir24_8_tbl * dp,uint64_t nh)173 tbl8_alloc(struct dir24_8_tbl *dp, uint64_t nh)
174 {
175 int64_t tbl8_idx;
176 uint8_t *tbl8_ptr;
177
178 tbl8_idx = tbl8_get_idx(dp);
179 if (tbl8_idx < 0)
180 return tbl8_idx;
181 tbl8_ptr = (uint8_t *)dp->tbl8 +
182 ((tbl8_idx * DIR24_8_TBL8_GRP_NUM_ENT) <<
183 dp->nh_sz);
184 /*Init tbl8 entries with nexthop from tbl24*/
185 write_to_fib((void *)tbl8_ptr, nh|
186 DIR24_8_EXT_ENT, dp->nh_sz,
187 DIR24_8_TBL8_GRP_NUM_ENT);
188 dp->cur_tbl8s++;
189 return tbl8_idx;
190 }
191
192 static void
tbl8_recycle(struct dir24_8_tbl * dp,uint32_t ip,uint64_t tbl8_idx)193 tbl8_recycle(struct dir24_8_tbl *dp, uint32_t ip, uint64_t tbl8_idx)
194 {
195 uint32_t i;
196 uint64_t nh;
197 uint8_t *ptr8;
198 uint16_t *ptr16;
199 uint32_t *ptr32;
200 uint64_t *ptr64;
201
202 switch (dp->nh_sz) {
203 case RTE_FIB_DIR24_8_1B:
204 ptr8 = &((uint8_t *)dp->tbl8)[tbl8_idx *
205 DIR24_8_TBL8_GRP_NUM_ENT];
206 nh = *ptr8;
207 for (i = 1; i < DIR24_8_TBL8_GRP_NUM_ENT; i++) {
208 if (nh != ptr8[i])
209 return;
210 }
211 ((uint8_t *)dp->tbl24)[ip >> 8] =
212 nh & ~DIR24_8_EXT_ENT;
213 for (i = 0; i < DIR24_8_TBL8_GRP_NUM_ENT; i++)
214 ptr8[i] = 0;
215 break;
216 case RTE_FIB_DIR24_8_2B:
217 ptr16 = &((uint16_t *)dp->tbl8)[tbl8_idx *
218 DIR24_8_TBL8_GRP_NUM_ENT];
219 nh = *ptr16;
220 for (i = 1; i < DIR24_8_TBL8_GRP_NUM_ENT; i++) {
221 if (nh != ptr16[i])
222 return;
223 }
224 ((uint16_t *)dp->tbl24)[ip >> 8] =
225 nh & ~DIR24_8_EXT_ENT;
226 for (i = 0; i < DIR24_8_TBL8_GRP_NUM_ENT; i++)
227 ptr16[i] = 0;
228 break;
229 case RTE_FIB_DIR24_8_4B:
230 ptr32 = &((uint32_t *)dp->tbl8)[tbl8_idx *
231 DIR24_8_TBL8_GRP_NUM_ENT];
232 nh = *ptr32;
233 for (i = 1; i < DIR24_8_TBL8_GRP_NUM_ENT; i++) {
234 if (nh != ptr32[i])
235 return;
236 }
237 ((uint32_t *)dp->tbl24)[ip >> 8] =
238 nh & ~DIR24_8_EXT_ENT;
239 for (i = 0; i < DIR24_8_TBL8_GRP_NUM_ENT; i++)
240 ptr32[i] = 0;
241 break;
242 case RTE_FIB_DIR24_8_8B:
243 ptr64 = &((uint64_t *)dp->tbl8)[tbl8_idx *
244 DIR24_8_TBL8_GRP_NUM_ENT];
245 nh = *ptr64;
246 for (i = 1; i < DIR24_8_TBL8_GRP_NUM_ENT; i++) {
247 if (nh != ptr64[i])
248 return;
249 }
250 ((uint64_t *)dp->tbl24)[ip >> 8] =
251 nh & ~DIR24_8_EXT_ENT;
252 for (i = 0; i < DIR24_8_TBL8_GRP_NUM_ENT; i++)
253 ptr64[i] = 0;
254 break;
255 }
256 tbl8_free_idx(dp, tbl8_idx);
257 dp->cur_tbl8s--;
258 }
259
260 static int
install_to_fib(struct dir24_8_tbl * dp,uint32_t ledge,uint32_t redge,uint64_t next_hop)261 install_to_fib(struct dir24_8_tbl *dp, uint32_t ledge, uint32_t redge,
262 uint64_t next_hop)
263 {
264 uint64_t tbl24_tmp;
265 int tbl8_idx;
266 int tmp_tbl8_idx;
267 uint8_t *tbl8_ptr;
268 uint32_t len;
269
270 len = ((ledge == 0) && (redge == 0)) ? 1 << 24 :
271 ((redge & DIR24_8_TBL24_MASK) - ROUNDUP(ledge, 24)) >> 8;
272
273 if (((ledge >> 8) != (redge >> 8)) || (len == 1 << 24)) {
274 if ((ROUNDUP(ledge, 24) - ledge) != 0) {
275 tbl24_tmp = get_tbl24(dp, ledge, dp->nh_sz);
276 if ((tbl24_tmp & DIR24_8_EXT_ENT) !=
277 DIR24_8_EXT_ENT) {
278 /**
279 * Make sure there is space for two TBL8.
280 * This is necessary when installing range that
281 * needs tbl8 for ledge and redge.
282 */
283 tbl8_idx = tbl8_alloc(dp, tbl24_tmp);
284 tmp_tbl8_idx = tbl8_get_idx(dp);
285 if (tbl8_idx < 0)
286 return -ENOSPC;
287 else if (tmp_tbl8_idx < 0) {
288 tbl8_free_idx(dp, tbl8_idx);
289 return -ENOSPC;
290 }
291 tbl8_free_idx(dp, tmp_tbl8_idx);
292 /*update dir24 entry with tbl8 index*/
293 write_to_fib(get_tbl24_p(dp, ledge,
294 dp->nh_sz), (tbl8_idx << 1)|
295 DIR24_8_EXT_ENT,
296 dp->nh_sz, 1);
297 } else
298 tbl8_idx = tbl24_tmp >> 1;
299 tbl8_ptr = (uint8_t *)dp->tbl8 +
300 (((tbl8_idx * DIR24_8_TBL8_GRP_NUM_ENT) +
301 (ledge & ~DIR24_8_TBL24_MASK)) <<
302 dp->nh_sz);
303 /*update tbl8 with new next hop*/
304 write_to_fib((void *)tbl8_ptr, (next_hop << 1)|
305 DIR24_8_EXT_ENT,
306 dp->nh_sz, ROUNDUP(ledge, 24) - ledge);
307 tbl8_recycle(dp, ledge, tbl8_idx);
308 }
309 write_to_fib(get_tbl24_p(dp, ROUNDUP(ledge, 24), dp->nh_sz),
310 next_hop << 1, dp->nh_sz, len);
311 if (redge & ~DIR24_8_TBL24_MASK) {
312 tbl24_tmp = get_tbl24(dp, redge, dp->nh_sz);
313 if ((tbl24_tmp & DIR24_8_EXT_ENT) !=
314 DIR24_8_EXT_ENT) {
315 tbl8_idx = tbl8_alloc(dp, tbl24_tmp);
316 if (tbl8_idx < 0)
317 return -ENOSPC;
318 /*update dir24 entry with tbl8 index*/
319 write_to_fib(get_tbl24_p(dp, redge,
320 dp->nh_sz), (tbl8_idx << 1)|
321 DIR24_8_EXT_ENT,
322 dp->nh_sz, 1);
323 } else
324 tbl8_idx = tbl24_tmp >> 1;
325 tbl8_ptr = (uint8_t *)dp->tbl8 +
326 ((tbl8_idx * DIR24_8_TBL8_GRP_NUM_ENT) <<
327 dp->nh_sz);
328 /*update tbl8 with new next hop*/
329 write_to_fib((void *)tbl8_ptr, (next_hop << 1)|
330 DIR24_8_EXT_ENT,
331 dp->nh_sz, redge & ~DIR24_8_TBL24_MASK);
332 tbl8_recycle(dp, redge, tbl8_idx);
333 }
334 } else if ((redge - ledge) != 0) {
335 tbl24_tmp = get_tbl24(dp, ledge, dp->nh_sz);
336 if ((tbl24_tmp & DIR24_8_EXT_ENT) !=
337 DIR24_8_EXT_ENT) {
338 tbl8_idx = tbl8_alloc(dp, tbl24_tmp);
339 if (tbl8_idx < 0)
340 return -ENOSPC;
341 /*update dir24 entry with tbl8 index*/
342 write_to_fib(get_tbl24_p(dp, ledge, dp->nh_sz),
343 (tbl8_idx << 1)|
344 DIR24_8_EXT_ENT,
345 dp->nh_sz, 1);
346 } else
347 tbl8_idx = tbl24_tmp >> 1;
348 tbl8_ptr = (uint8_t *)dp->tbl8 +
349 (((tbl8_idx * DIR24_8_TBL8_GRP_NUM_ENT) +
350 (ledge & ~DIR24_8_TBL24_MASK)) <<
351 dp->nh_sz);
352 /*update tbl8 with new next hop*/
353 write_to_fib((void *)tbl8_ptr, (next_hop << 1)|
354 DIR24_8_EXT_ENT,
355 dp->nh_sz, redge - ledge);
356 tbl8_recycle(dp, ledge, tbl8_idx);
357 }
358 return 0;
359 }
360
361 static int
modify_fib(struct dir24_8_tbl * dp,struct rte_rib * rib,uint32_t ip,uint8_t depth,uint64_t next_hop)362 modify_fib(struct dir24_8_tbl *dp, struct rte_rib *rib, uint32_t ip,
363 uint8_t depth, uint64_t next_hop)
364 {
365 struct rte_rib_node *tmp = NULL;
366 uint32_t ledge, redge, tmp_ip;
367 int ret;
368 uint8_t tmp_depth;
369
370 ledge = ip;
371 do {
372 tmp = rte_rib_get_nxt(rib, ip, depth, tmp,
373 RTE_RIB_GET_NXT_COVER);
374 if (tmp != NULL) {
375 rte_rib_get_depth(tmp, &tmp_depth);
376 if (tmp_depth == depth)
377 continue;
378 rte_rib_get_ip(tmp, &tmp_ip);
379 redge = tmp_ip & rte_rib_depth_to_mask(tmp_depth);
380 if (ledge == redge) {
381 ledge = redge +
382 (uint32_t)(1ULL << (32 - tmp_depth));
383 continue;
384 }
385 ret = install_to_fib(dp, ledge, redge,
386 next_hop);
387 if (ret != 0)
388 return ret;
389 ledge = redge +
390 (uint32_t)(1ULL << (32 - tmp_depth));
391 } else {
392 redge = ip + (uint32_t)(1ULL << (32 - depth));
393 if (ledge == redge)
394 break;
395 ret = install_to_fib(dp, ledge, redge,
396 next_hop);
397 if (ret != 0)
398 return ret;
399 }
400 } while (tmp);
401
402 return 0;
403 }
404
405 int
dir24_8_modify(struct rte_fib * fib,uint32_t ip,uint8_t depth,uint64_t next_hop,int op)406 dir24_8_modify(struct rte_fib *fib, uint32_t ip, uint8_t depth,
407 uint64_t next_hop, int op)
408 {
409 struct dir24_8_tbl *dp;
410 struct rte_rib *rib;
411 struct rte_rib_node *tmp = NULL;
412 struct rte_rib_node *node;
413 struct rte_rib_node *parent;
414 int ret = 0;
415 uint64_t par_nh, node_nh;
416
417 if ((fib == NULL) || (depth > RTE_FIB_MAXDEPTH))
418 return -EINVAL;
419
420 dp = rte_fib_get_dp(fib);
421 rib = rte_fib_get_rib(fib);
422 RTE_ASSERT((dp != NULL) && (rib != NULL));
423
424 if (next_hop > get_max_nh(dp->nh_sz))
425 return -EINVAL;
426
427 ip &= rte_rib_depth_to_mask(depth);
428
429 node = rte_rib_lookup_exact(rib, ip, depth);
430 switch (op) {
431 case RTE_FIB_ADD:
432 if (node != NULL) {
433 rte_rib_get_nh(node, &node_nh);
434 if (node_nh == next_hop)
435 return 0;
436 ret = modify_fib(dp, rib, ip, depth, next_hop);
437 if (ret == 0)
438 rte_rib_set_nh(node, next_hop);
439 return 0;
440 }
441 if (depth > 24) {
442 tmp = rte_rib_get_nxt(rib, ip, 24, NULL,
443 RTE_RIB_GET_NXT_COVER);
444 if ((tmp == NULL) &&
445 (dp->rsvd_tbl8s >= dp->number_tbl8s))
446 return -ENOSPC;
447
448 }
449 node = rte_rib_insert(rib, ip, depth);
450 if (node == NULL)
451 return -rte_errno;
452 rte_rib_set_nh(node, next_hop);
453 parent = rte_rib_lookup_parent(node);
454 if (parent != NULL) {
455 rte_rib_get_nh(parent, &par_nh);
456 if (par_nh == next_hop)
457 return 0;
458 }
459 ret = modify_fib(dp, rib, ip, depth, next_hop);
460 if (ret != 0) {
461 rte_rib_remove(rib, ip, depth);
462 return ret;
463 }
464 if ((depth > 24) && (tmp == NULL))
465 dp->rsvd_tbl8s++;
466 return 0;
467 case RTE_FIB_DEL:
468 if (node == NULL)
469 return -ENOENT;
470
471 parent = rte_rib_lookup_parent(node);
472 if (parent != NULL) {
473 rte_rib_get_nh(parent, &par_nh);
474 rte_rib_get_nh(node, &node_nh);
475 if (par_nh != node_nh)
476 ret = modify_fib(dp, rib, ip, depth, par_nh);
477 } else
478 ret = modify_fib(dp, rib, ip, depth, dp->def_nh);
479 if (ret == 0) {
480 rte_rib_remove(rib, ip, depth);
481 if (depth > 24) {
482 tmp = rte_rib_get_nxt(rib, ip, 24, NULL,
483 RTE_RIB_GET_NXT_COVER);
484 if (tmp == NULL)
485 dp->rsvd_tbl8s--;
486 }
487 }
488 return ret;
489 default:
490 break;
491 }
492 return -EINVAL;
493 }
494
495 void *
dir24_8_create(const char * name,int socket_id,struct rte_fib_conf * fib_conf)496 dir24_8_create(const char *name, int socket_id, struct rte_fib_conf *fib_conf)
497 {
498 char mem_name[DIR24_8_NAMESIZE];
499 struct dir24_8_tbl *dp;
500 uint64_t def_nh;
501 uint32_t num_tbl8;
502 enum rte_fib_dir24_8_nh_sz nh_sz;
503
504 if ((name == NULL) || (fib_conf == NULL) ||
505 (fib_conf->dir24_8.nh_sz < RTE_FIB_DIR24_8_1B) ||
506 (fib_conf->dir24_8.nh_sz > RTE_FIB_DIR24_8_8B) ||
507 (fib_conf->dir24_8.num_tbl8 >
508 get_max_nh(fib_conf->dir24_8.nh_sz)) ||
509 (fib_conf->dir24_8.num_tbl8 == 0) ||
510 (fib_conf->default_nh >
511 get_max_nh(fib_conf->dir24_8.nh_sz))) {
512 rte_errno = EINVAL;
513 return NULL;
514 }
515
516 def_nh = fib_conf->default_nh;
517 nh_sz = fib_conf->dir24_8.nh_sz;
518 num_tbl8 = RTE_ALIGN_CEIL(fib_conf->dir24_8.num_tbl8,
519 BITMAP_SLAB_BIT_SIZE);
520
521 snprintf(mem_name, sizeof(mem_name), "DP_%s", name);
522 dp = rte_zmalloc_socket(name, sizeof(struct dir24_8_tbl) +
523 DIR24_8_TBL24_NUM_ENT * (1 << nh_sz), RTE_CACHE_LINE_SIZE,
524 socket_id);
525 if (dp == NULL) {
526 rte_errno = ENOMEM;
527 return NULL;
528 }
529
530 /* Init table with default value */
531 write_to_fib(dp->tbl24, (def_nh << 1), nh_sz, 1 << 24);
532
533 snprintf(mem_name, sizeof(mem_name), "TBL8_%p", dp);
534 uint64_t tbl8_sz = DIR24_8_TBL8_GRP_NUM_ENT * (1ULL << nh_sz) *
535 (num_tbl8 + 1);
536 dp->tbl8 = rte_zmalloc_socket(mem_name, tbl8_sz,
537 RTE_CACHE_LINE_SIZE, socket_id);
538 if (dp->tbl8 == NULL) {
539 rte_errno = ENOMEM;
540 rte_free(dp);
541 return NULL;
542 }
543 dp->def_nh = def_nh;
544 dp->nh_sz = nh_sz;
545 dp->number_tbl8s = num_tbl8;
546
547 snprintf(mem_name, sizeof(mem_name), "TBL8_idxes_%p", dp);
548 dp->tbl8_idxes = rte_zmalloc_socket(mem_name,
549 RTE_ALIGN_CEIL(dp->number_tbl8s, 64) >> 3,
550 RTE_CACHE_LINE_SIZE, socket_id);
551 if (dp->tbl8_idxes == NULL) {
552 rte_errno = ENOMEM;
553 rte_free(dp->tbl8);
554 rte_free(dp);
555 return NULL;
556 }
557
558 return dp;
559 }
560
561 void
dir24_8_free(void * p)562 dir24_8_free(void *p)
563 {
564 struct dir24_8_tbl *dp = (struct dir24_8_tbl *)p;
565
566 rte_free(dp->tbl8_idxes);
567 rte_free(dp->tbl8);
568 rte_free(dp);
569 }
570