1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /* Copyright (c) 2019-2021 Marvell International Ltd. All rights reserved */
3 
4 #include <linux/rhashtable.h>
5 
6 #include "prestera.h"
7 #include "prestera_hw.h"
8 #include "prestera_router_hw.h"
9 #include "prestera_acl.h"
10 
11 /*                                Nexthop is pointed
12  *                                to port (not rif)
13  *                                +-------+
14  *                              +>|nexthop|
15  *                              | +-------+
16  *                              |
17  *            +--+        +-----++
18  *   +------->|vr|<-+   +>|nh_grp|
19  *   |        +--+  |   | +------+
20  *   |              |   |
21  * +-+-------+   +--+---+-+
22  * |rif_entry|   |fib_node|
23  * +---------+   +--------+
24  *  Rif is        Fib - is exit point
25  *  used as
26  *  entry point
27  *  for vr in hw
28  */
29 
30 #define PRESTERA_NHGR_UNUSED (0)
31 #define PRESTERA_NHGR_DROP (0xFFFFFFFF)
32 /* Need to merge it with router_manager */
33 #define PRESTERA_NH_ACTIVE_JIFFER_FILTER 3000 /* ms */
34 
35 static const struct rhashtable_params __prestera_fib_ht_params = {
36 	.key_offset  = offsetof(struct prestera_fib_node, key),
37 	.head_offset = offsetof(struct prestera_fib_node, ht_node),
38 	.key_len     = sizeof(struct prestera_fib_key),
39 	.automatic_shrinking = true,
40 };
41 
42 static const struct rhashtable_params __prestera_nh_neigh_ht_params = {
43 	.key_offset  = offsetof(struct prestera_nh_neigh, key),
44 	.key_len     = sizeof(struct prestera_nh_neigh_key),
45 	.head_offset = offsetof(struct prestera_nh_neigh, ht_node),
46 };
47 
48 static const struct rhashtable_params __prestera_nexthop_group_ht_params = {
49 	.key_offset  = offsetof(struct prestera_nexthop_group, key),
50 	.key_len     = sizeof(struct prestera_nexthop_group_key),
51 	.head_offset = offsetof(struct prestera_nexthop_group, ht_node),
52 };
53 
54 static int prestera_nexthop_group_set(struct prestera_switch *sw,
55 				      struct prestera_nexthop_group *nh_grp);
56 static bool
57 prestera_nexthop_group_util_hw_state(struct prestera_switch *sw,
58 				     struct prestera_nexthop_group *nh_grp);
59 static void prestera_fib_node_destroy_ht_cb(void *ptr, void *arg);
60 
61 /* TODO: move to router.h as macros */
62 static bool prestera_nh_neigh_key_is_valid(struct prestera_nh_neigh_key *key)
63 {
64 	return memchr_inv(key, 0, sizeof(*key)) ? true : false;
65 }
66 
67 int prestera_router_hw_init(struct prestera_switch *sw)
68 {
69 	int err;
70 
71 	err = rhashtable_init(&sw->router->nh_neigh_ht,
72 			      &__prestera_nh_neigh_ht_params);
73 	if (err)
74 		goto err_nh_neigh_ht_init;
75 
76 	err = rhashtable_init(&sw->router->nexthop_group_ht,
77 			      &__prestera_nexthop_group_ht_params);
78 	if (err)
79 		goto err_nexthop_grp_ht_init;
80 
81 	err = rhashtable_init(&sw->router->fib_ht,
82 			      &__prestera_fib_ht_params);
83 	if (err)
84 		goto err_fib_ht_init;
85 
86 	INIT_LIST_HEAD(&sw->router->vr_list);
87 	INIT_LIST_HEAD(&sw->router->rif_entry_list);
88 
89 	return 0;
90 
91 err_fib_ht_init:
92 	rhashtable_destroy(&sw->router->nexthop_group_ht);
93 err_nexthop_grp_ht_init:
94 	rhashtable_destroy(&sw->router->nh_neigh_ht);
95 err_nh_neigh_ht_init:
96 	return 0;
97 }
98 
99 void prestera_router_hw_fini(struct prestera_switch *sw)
100 {
101 	rhashtable_free_and_destroy(&sw->router->fib_ht,
102 				    prestera_fib_node_destroy_ht_cb, sw);
103 	WARN_ON(!list_empty(&sw->router->vr_list));
104 	WARN_ON(!list_empty(&sw->router->rif_entry_list));
105 	rhashtable_destroy(&sw->router->fib_ht);
106 	rhashtable_destroy(&sw->router->nexthop_group_ht);
107 	rhashtable_destroy(&sw->router->nh_neigh_ht);
108 }
109 
110 static struct prestera_vr *__prestera_vr_find(struct prestera_switch *sw,
111 					      u32 tb_id)
112 {
113 	struct prestera_vr *vr;
114 
115 	list_for_each_entry(vr, &sw->router->vr_list, router_node) {
116 		if (vr->tb_id == tb_id)
117 			return vr;
118 	}
119 
120 	return NULL;
121 }
122 
123 static struct prestera_vr *__prestera_vr_create(struct prestera_switch *sw,
124 						u32 tb_id,
125 						struct netlink_ext_ack *extack)
126 {
127 	struct prestera_vr *vr;
128 	int err;
129 
130 	vr = kzalloc(sizeof(*vr), GFP_KERNEL);
131 	if (!vr) {
132 		err = -ENOMEM;
133 		goto err_alloc_vr;
134 	}
135 
136 	vr->tb_id = tb_id;
137 
138 	err = prestera_hw_vr_create(sw, &vr->hw_vr_id);
139 	if (err)
140 		goto err_hw_create;
141 
142 	list_add(&vr->router_node, &sw->router->vr_list);
143 
144 	return vr;
145 
146 err_hw_create:
147 	kfree(vr);
148 err_alloc_vr:
149 	return ERR_PTR(err);
150 }
151 
152 static void __prestera_vr_destroy(struct prestera_switch *sw,
153 				  struct prestera_vr *vr)
154 {
155 	list_del(&vr->router_node);
156 	prestera_hw_vr_delete(sw, vr->hw_vr_id);
157 	kfree(vr);
158 }
159 
160 static struct prestera_vr *prestera_vr_get(struct prestera_switch *sw, u32 tb_id,
161 					   struct netlink_ext_ack *extack)
162 {
163 	struct prestera_vr *vr;
164 
165 	vr = __prestera_vr_find(sw, tb_id);
166 	if (vr) {
167 		refcount_inc(&vr->refcount);
168 	} else {
169 		vr = __prestera_vr_create(sw, tb_id, extack);
170 		if (IS_ERR(vr))
171 			return ERR_CAST(vr);
172 
173 		refcount_set(&vr->refcount, 1);
174 	}
175 
176 	return vr;
177 }
178 
179 static void prestera_vr_put(struct prestera_switch *sw, struct prestera_vr *vr)
180 {
181 	if (refcount_dec_and_test(&vr->refcount))
182 		__prestera_vr_destroy(sw, vr);
183 }
184 
185 /* iface is overhead struct. vr_id also can be removed. */
186 static int
187 __prestera_rif_entry_key_copy(const struct prestera_rif_entry_key *in,
188 			      struct prestera_rif_entry_key *out)
189 {
190 	memset(out, 0, sizeof(*out));
191 
192 	switch (in->iface.type) {
193 	case PRESTERA_IF_PORT_E:
194 		out->iface.dev_port.hw_dev_num = in->iface.dev_port.hw_dev_num;
195 		out->iface.dev_port.port_num = in->iface.dev_port.port_num;
196 		break;
197 	case PRESTERA_IF_LAG_E:
198 		out->iface.lag_id = in->iface.lag_id;
199 		break;
200 	case PRESTERA_IF_VID_E:
201 		out->iface.vlan_id = in->iface.vlan_id;
202 		break;
203 	default:
204 		WARN(1, "Unsupported iface type");
205 		return -EINVAL;
206 	}
207 
208 	out->iface.type = in->iface.type;
209 	return 0;
210 }
211 
212 struct prestera_rif_entry *
213 prestera_rif_entry_find(const struct prestera_switch *sw,
214 			const struct prestera_rif_entry_key *k)
215 {
216 	struct prestera_rif_entry *rif_entry;
217 	struct prestera_rif_entry_key lk; /* lookup key */
218 
219 	if (__prestera_rif_entry_key_copy(k, &lk))
220 		return NULL;
221 
222 	list_for_each_entry(rif_entry, &sw->router->rif_entry_list,
223 			    router_node) {
224 		if (!memcmp(k, &rif_entry->key, sizeof(*k)))
225 			return rif_entry;
226 	}
227 
228 	return NULL;
229 }
230 
231 void prestera_rif_entry_destroy(struct prestera_switch *sw,
232 				struct prestera_rif_entry *e)
233 {
234 	struct prestera_iface iface;
235 
236 	list_del(&e->router_node);
237 
238 	memcpy(&iface, &e->key.iface, sizeof(iface));
239 	iface.vr_id = e->vr->hw_vr_id;
240 	prestera_hw_rif_delete(sw, e->hw_id, &iface);
241 
242 	prestera_vr_put(sw, e->vr);
243 	kfree(e);
244 }
245 
246 struct prestera_rif_entry *
247 prestera_rif_entry_create(struct prestera_switch *sw,
248 			  struct prestera_rif_entry_key *k,
249 			  u32 tb_id, const unsigned char *addr)
250 {
251 	int err;
252 	struct prestera_rif_entry *e;
253 	struct prestera_iface iface;
254 
255 	e = kzalloc(sizeof(*e), GFP_KERNEL);
256 	if (!e)
257 		goto err_kzalloc;
258 
259 	if (__prestera_rif_entry_key_copy(k, &e->key))
260 		goto err_key_copy;
261 
262 	e->vr = prestera_vr_get(sw, tb_id, NULL);
263 	if (IS_ERR(e->vr))
264 		goto err_vr_get;
265 
266 	memcpy(&e->addr, addr, sizeof(e->addr));
267 
268 	/* HW */
269 	memcpy(&iface, &e->key.iface, sizeof(iface));
270 	iface.vr_id = e->vr->hw_vr_id;
271 	err = prestera_hw_rif_create(sw, &iface, e->addr, &e->hw_id);
272 	if (err)
273 		goto err_hw_create;
274 
275 	list_add(&e->router_node, &sw->router->rif_entry_list);
276 
277 	return e;
278 
279 err_hw_create:
280 	prestera_vr_put(sw, e->vr);
281 err_vr_get:
282 err_key_copy:
283 	kfree(e);
284 err_kzalloc:
285 	return NULL;
286 }
287 
288 static void __prestera_nh_neigh_destroy(struct prestera_switch *sw,
289 					struct prestera_nh_neigh *neigh)
290 {
291 	rhashtable_remove_fast(&sw->router->nh_neigh_ht,
292 			       &neigh->ht_node,
293 			       __prestera_nh_neigh_ht_params);
294 	kfree(neigh);
295 }
296 
297 static struct prestera_nh_neigh *
298 __prestera_nh_neigh_create(struct prestera_switch *sw,
299 			   struct prestera_nh_neigh_key *key)
300 {
301 	struct prestera_nh_neigh *neigh;
302 	int err;
303 
304 	neigh = kzalloc(sizeof(*neigh), GFP_KERNEL);
305 	if (!neigh)
306 		goto err_kzalloc;
307 
308 	memcpy(&neigh->key, key, sizeof(*key));
309 	neigh->info.connected = false;
310 	INIT_LIST_HEAD(&neigh->nexthop_group_list);
311 	err = rhashtable_insert_fast(&sw->router->nh_neigh_ht,
312 				     &neigh->ht_node,
313 				     __prestera_nh_neigh_ht_params);
314 	if (err)
315 		goto err_rhashtable_insert;
316 
317 	return neigh;
318 
319 err_rhashtable_insert:
320 	kfree(neigh);
321 err_kzalloc:
322 	return NULL;
323 }
324 
325 struct prestera_nh_neigh *
326 prestera_nh_neigh_find(struct prestera_switch *sw,
327 		       struct prestera_nh_neigh_key *key)
328 {
329 	struct prestera_nh_neigh *nh_neigh;
330 
331 	nh_neigh = rhashtable_lookup_fast(&sw->router->nh_neigh_ht,
332 					  key, __prestera_nh_neigh_ht_params);
333 	return nh_neigh;
334 }
335 
336 struct prestera_nh_neigh *
337 prestera_nh_neigh_get(struct prestera_switch *sw,
338 		      struct prestera_nh_neigh_key *key)
339 {
340 	struct prestera_nh_neigh *neigh;
341 
342 	neigh = prestera_nh_neigh_find(sw, key);
343 	if (!neigh)
344 		return __prestera_nh_neigh_create(sw, key);
345 
346 	return neigh;
347 }
348 
349 void prestera_nh_neigh_put(struct prestera_switch *sw,
350 			   struct prestera_nh_neigh *neigh)
351 {
352 	if (list_empty(&neigh->nexthop_group_list))
353 		__prestera_nh_neigh_destroy(sw, neigh);
354 }
355 
356 /* Updates new prestera_neigh_info */
357 int prestera_nh_neigh_set(struct prestera_switch *sw,
358 			  struct prestera_nh_neigh *neigh)
359 {
360 	struct prestera_nh_neigh_head *nh_head;
361 	struct prestera_nexthop_group *nh_grp;
362 	int err;
363 
364 	list_for_each_entry(nh_head, &neigh->nexthop_group_list, head) {
365 		nh_grp = nh_head->this;
366 		err = prestera_nexthop_group_set(sw, nh_grp);
367 		if (err)
368 			return err;
369 	}
370 
371 	return 0;
372 }
373 
374 bool prestera_nh_neigh_util_hw_state(struct prestera_switch *sw,
375 				     struct prestera_nh_neigh *nh_neigh)
376 {
377 	bool state;
378 	struct prestera_nh_neigh_head *nh_head, *tmp;
379 
380 	state = false;
381 	list_for_each_entry_safe(nh_head, tmp,
382 				 &nh_neigh->nexthop_group_list, head) {
383 		state = prestera_nexthop_group_util_hw_state(sw, nh_head->this);
384 		if (state)
385 			goto out;
386 	}
387 
388 out:
389 	return state;
390 }
391 
392 static struct prestera_nexthop_group *
393 __prestera_nexthop_group_create(struct prestera_switch *sw,
394 				struct prestera_nexthop_group_key *key)
395 {
396 	struct prestera_nexthop_group *nh_grp;
397 	struct prestera_nh_neigh *nh_neigh;
398 	int nh_cnt, err, gid;
399 
400 	nh_grp = kzalloc(sizeof(*nh_grp), GFP_KERNEL);
401 	if (!nh_grp)
402 		goto err_kzalloc;
403 
404 	memcpy(&nh_grp->key, key, sizeof(*key));
405 	for (nh_cnt = 0; nh_cnt < PRESTERA_NHGR_SIZE_MAX; nh_cnt++) {
406 		if (!prestera_nh_neigh_key_is_valid(&nh_grp->key.neigh[nh_cnt]))
407 			break;
408 
409 		nh_neigh = prestera_nh_neigh_get(sw,
410 						 &nh_grp->key.neigh[nh_cnt]);
411 		if (!nh_neigh)
412 			goto err_nh_neigh_get;
413 
414 		nh_grp->nh_neigh_head[nh_cnt].neigh = nh_neigh;
415 		nh_grp->nh_neigh_head[nh_cnt].this = nh_grp;
416 		list_add(&nh_grp->nh_neigh_head[nh_cnt].head,
417 			 &nh_neigh->nexthop_group_list);
418 	}
419 
420 	err = prestera_hw_nh_group_create(sw, nh_cnt, &nh_grp->grp_id);
421 	if (err)
422 		goto err_nh_group_create;
423 
424 	err = prestera_nexthop_group_set(sw, nh_grp);
425 	if (err)
426 		goto err_nexthop_group_set;
427 
428 	err = rhashtable_insert_fast(&sw->router->nexthop_group_ht,
429 				     &nh_grp->ht_node,
430 				     __prestera_nexthop_group_ht_params);
431 	if (err)
432 		goto err_ht_insert;
433 
434 	/* reset cache for created group */
435 	gid = nh_grp->grp_id;
436 	sw->router->nhgrp_hw_state_cache[gid / 8] &= ~BIT(gid % 8);
437 
438 	return nh_grp;
439 
440 err_ht_insert:
441 err_nexthop_group_set:
442 	prestera_hw_nh_group_delete(sw, nh_cnt, nh_grp->grp_id);
443 err_nh_group_create:
444 err_nh_neigh_get:
445 	for (nh_cnt--; nh_cnt >= 0; nh_cnt--) {
446 		list_del(&nh_grp->nh_neigh_head[nh_cnt].head);
447 		prestera_nh_neigh_put(sw, nh_grp->nh_neigh_head[nh_cnt].neigh);
448 	}
449 
450 	kfree(nh_grp);
451 err_kzalloc:
452 	return NULL;
453 }
454 
455 static void
456 __prestera_nexthop_group_destroy(struct prestera_switch *sw,
457 				 struct prestera_nexthop_group *nh_grp)
458 {
459 	struct prestera_nh_neigh *nh_neigh;
460 	int nh_cnt;
461 
462 	rhashtable_remove_fast(&sw->router->nexthop_group_ht,
463 			       &nh_grp->ht_node,
464 			       __prestera_nexthop_group_ht_params);
465 
466 	for (nh_cnt = 0; nh_cnt < PRESTERA_NHGR_SIZE_MAX; nh_cnt++) {
467 		nh_neigh = nh_grp->nh_neigh_head[nh_cnt].neigh;
468 		if (!nh_neigh)
469 			break;
470 
471 		list_del(&nh_grp->nh_neigh_head[nh_cnt].head);
472 		prestera_nh_neigh_put(sw, nh_neigh);
473 	}
474 
475 	prestera_hw_nh_group_delete(sw, nh_cnt, nh_grp->grp_id);
476 	kfree(nh_grp);
477 }
478 
479 static struct prestera_nexthop_group *
480 __prestera_nexthop_group_find(struct prestera_switch *sw,
481 			      struct prestera_nexthop_group_key *key)
482 {
483 	struct prestera_nexthop_group *nh_grp;
484 
485 	nh_grp = rhashtable_lookup_fast(&sw->router->nexthop_group_ht,
486 					key, __prestera_nexthop_group_ht_params);
487 	return nh_grp;
488 }
489 
490 static struct prestera_nexthop_group *
491 prestera_nexthop_group_get(struct prestera_switch *sw,
492 			   struct prestera_nexthop_group_key *key)
493 {
494 	struct prestera_nexthop_group *nh_grp;
495 
496 	nh_grp = __prestera_nexthop_group_find(sw, key);
497 	if (nh_grp) {
498 		refcount_inc(&nh_grp->refcount);
499 	} else {
500 		nh_grp = __prestera_nexthop_group_create(sw, key);
501 		if (!nh_grp)
502 			return ERR_PTR(-ENOMEM);
503 
504 		refcount_set(&nh_grp->refcount, 1);
505 	}
506 
507 	return nh_grp;
508 }
509 
510 static void prestera_nexthop_group_put(struct prestera_switch *sw,
511 				       struct prestera_nexthop_group *nh_grp)
512 {
513 	if (refcount_dec_and_test(&nh_grp->refcount))
514 		__prestera_nexthop_group_destroy(sw, nh_grp);
515 }
516 
517 /* Updates with new nh_neigh's info */
518 static int prestera_nexthop_group_set(struct prestera_switch *sw,
519 				      struct prestera_nexthop_group *nh_grp)
520 {
521 	struct prestera_neigh_info info[PRESTERA_NHGR_SIZE_MAX];
522 	struct prestera_nh_neigh *neigh;
523 	int nh_cnt;
524 
525 	memset(&info[0], 0, sizeof(info));
526 	for (nh_cnt = 0; nh_cnt < PRESTERA_NHGR_SIZE_MAX; nh_cnt++) {
527 		neigh = nh_grp->nh_neigh_head[nh_cnt].neigh;
528 		if (!neigh)
529 			break;
530 
531 		memcpy(&info[nh_cnt], &neigh->info, sizeof(neigh->info));
532 	}
533 
534 	return prestera_hw_nh_entries_set(sw, nh_cnt, &info[0], nh_grp->grp_id);
535 }
536 
537 static bool
538 prestera_nexthop_group_util_hw_state(struct prestera_switch *sw,
539 				     struct prestera_nexthop_group *nh_grp)
540 {
541 	int err;
542 	u32 buf_size = sw->size_tbl_router_nexthop / 8 + 1;
543 	u32 gid = nh_grp->grp_id;
544 	u8 *cache = sw->router->nhgrp_hw_state_cache;
545 
546 	/* Antijitter
547 	 * Prevent situation, when we read state of nh_grp twice in short time,
548 	 * and state bit is still cleared on second call. So just stuck active
549 	 * state for PRESTERA_NH_ACTIVE_JIFFER_FILTER, after last occurred.
550 	 */
551 	if (!time_before(jiffies, sw->router->nhgrp_hw_cache_kick +
552 			msecs_to_jiffies(PRESTERA_NH_ACTIVE_JIFFER_FILTER))) {
553 		err = prestera_hw_nhgrp_blk_get(sw, cache, buf_size);
554 		if (err) {
555 			pr_err("Failed to get hw state nh_grp's");
556 			return false;
557 		}
558 
559 		sw->router->nhgrp_hw_cache_kick = jiffies;
560 	}
561 
562 	if (cache[gid / 8] & BIT(gid % 8))
563 		return true;
564 
565 	return false;
566 }
567 
568 struct prestera_fib_node *
569 prestera_fib_node_find(struct prestera_switch *sw, struct prestera_fib_key *key)
570 {
571 	struct prestera_fib_node *fib_node;
572 
573 	fib_node = rhashtable_lookup_fast(&sw->router->fib_ht, key,
574 					  __prestera_fib_ht_params);
575 	return fib_node;
576 }
577 
578 static void __prestera_fib_node_destruct(struct prestera_switch *sw,
579 					 struct prestera_fib_node *fib_node)
580 {
581 	struct prestera_vr *vr;
582 
583 	vr = fib_node->info.vr;
584 	prestera_hw_lpm_del(sw, vr->hw_vr_id, fib_node->key.addr.u.ipv4,
585 			    fib_node->key.prefix_len);
586 	switch (fib_node->info.type) {
587 	case PRESTERA_FIB_TYPE_UC_NH:
588 		prestera_nexthop_group_put(sw, fib_node->info.nh_grp);
589 		break;
590 	case PRESTERA_FIB_TYPE_TRAP:
591 		break;
592 	case PRESTERA_FIB_TYPE_DROP:
593 		break;
594 	default:
595 	      pr_err("Unknown fib_node->info.type = %d",
596 		     fib_node->info.type);
597 	}
598 
599 	prestera_vr_put(sw, vr);
600 }
601 
602 void prestera_fib_node_destroy(struct prestera_switch *sw,
603 			       struct prestera_fib_node *fib_node)
604 {
605 	__prestera_fib_node_destruct(sw, fib_node);
606 	rhashtable_remove_fast(&sw->router->fib_ht, &fib_node->ht_node,
607 			       __prestera_fib_ht_params);
608 	kfree(fib_node);
609 }
610 
611 static void prestera_fib_node_destroy_ht_cb(void *ptr, void *arg)
612 {
613 	struct prestera_fib_node *node = ptr;
614 	struct prestera_switch *sw = arg;
615 
616 	__prestera_fib_node_destruct(sw, node);
617 	kfree(node);
618 }
619 
620 struct prestera_fib_node *
621 prestera_fib_node_create(struct prestera_switch *sw,
622 			 struct prestera_fib_key *key,
623 			 enum prestera_fib_type fib_type,
624 			 struct prestera_nexthop_group_key *nh_grp_key)
625 {
626 	struct prestera_fib_node *fib_node;
627 	u32 grp_id;
628 	struct prestera_vr *vr;
629 	int err;
630 
631 	fib_node = kzalloc(sizeof(*fib_node), GFP_KERNEL);
632 	if (!fib_node)
633 		goto err_kzalloc;
634 
635 	memcpy(&fib_node->key, key, sizeof(*key));
636 	fib_node->info.type = fib_type;
637 
638 	vr = prestera_vr_get(sw, key->tb_id, NULL);
639 	if (IS_ERR(vr))
640 		goto err_vr_get;
641 
642 	fib_node->info.vr = vr;
643 
644 	switch (fib_type) {
645 	case PRESTERA_FIB_TYPE_TRAP:
646 		grp_id = PRESTERA_NHGR_UNUSED;
647 		break;
648 	case PRESTERA_FIB_TYPE_DROP:
649 		grp_id = PRESTERA_NHGR_DROP;
650 		break;
651 	case PRESTERA_FIB_TYPE_UC_NH:
652 		fib_node->info.nh_grp = prestera_nexthop_group_get(sw,
653 								   nh_grp_key);
654 		if (IS_ERR(fib_node->info.nh_grp))
655 			goto err_nh_grp_get;
656 
657 		grp_id = fib_node->info.nh_grp->grp_id;
658 		break;
659 	default:
660 		pr_err("Unsupported fib_type %d", fib_type);
661 		goto err_nh_grp_get;
662 	}
663 
664 	err = prestera_hw_lpm_add(sw, vr->hw_vr_id, key->addr.u.ipv4,
665 				  key->prefix_len, grp_id);
666 	if (err)
667 		goto err_lpm_add;
668 
669 	err = rhashtable_insert_fast(&sw->router->fib_ht, &fib_node->ht_node,
670 				     __prestera_fib_ht_params);
671 	if (err)
672 		goto err_ht_insert;
673 
674 	return fib_node;
675 
676 err_ht_insert:
677 	prestera_hw_lpm_del(sw, vr->hw_vr_id, key->addr.u.ipv4,
678 			    key->prefix_len);
679 err_lpm_add:
680 	if (fib_type == PRESTERA_FIB_TYPE_UC_NH)
681 		prestera_nexthop_group_put(sw, fib_node->info.nh_grp);
682 err_nh_grp_get:
683 	prestera_vr_put(sw, vr);
684 err_vr_get:
685 	kfree(fib_node);
686 err_kzalloc:
687 	return NULL;
688 }
689