2 * Copyright (C) 2016 CumulusNetworks
5 * This file is part of Quagga
7 * Quagga is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
12 * Quagga is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "srcdest_table.h"
30 #include "zebra/debug.h"
31 #include "zebra/zserv.h"
32 #include "zebra/rib.h"
33 #include "zebra/zebra_vrf.h"
34 #include "zebra/zebra_rnh.h"
35 #include "zebra/router-id.h"
36 #include "zebra/zebra_memory.h"
37 #include "zebra/zebra_static.h"
38 #include "zebra/interface.h"
39 #include "zebra/zebra_mpls.h"
40 #include "zebra/zebra_vxlan.h"
42 extern struct zebra_t zebrad
;
44 /* VRF information update. */
45 static void zebra_vrf_add_update(struct zebra_vrf
*zvrf
)
47 struct listnode
*node
, *nnode
;
50 if (IS_ZEBRA_DEBUG_EVENT
)
51 zlog_debug("MESSAGE: ZEBRA_VRF_ADD %s", zvrf_name(zvrf
));
53 for (ALL_LIST_ELEMENTS(zebrad
.client_list
, node
, nnode
, client
))
54 zsend_vrf_add(client
, zvrf
);
57 static void zebra_vrf_delete_update(struct zebra_vrf
*zvrf
)
59 struct listnode
*node
, *nnode
;
62 if (IS_ZEBRA_DEBUG_EVENT
)
63 zlog_debug("MESSAGE: ZEBRA_VRF_DELETE %s", zvrf_name(zvrf
));
65 for (ALL_LIST_ELEMENTS(zebrad
.client_list
, node
, nnode
, client
))
66 zsend_vrf_delete(client
, zvrf
);
69 void zebra_vrf_update_all(struct zserv
*client
)
73 RB_FOREACH(vrf
, vrf_id_head
, &vrfs_by_id
)
76 zsend_vrf_add(client
, vrf_info_lookup(vrf
->vrf_id
));
80 /* Callback upon creating a new VRF. */
81 static int zebra_vrf_new(struct vrf
*vrf
)
83 struct zebra_vrf
*zvrf
;
85 if (IS_ZEBRA_DEBUG_EVENT
)
86 zlog_info("ZVRF %s with id %u", vrf
->name
, vrf
->vrf_id
);
88 zvrf
= zebra_vrf_alloc();
89 zvrf
->zns
= zebra_ns_lookup(
90 NS_DEFAULT
); /* Point to the global (single) NS */
98 /* Callback upon enabling a VRF. */
99 static int zebra_vrf_enable(struct vrf
*vrf
)
101 struct zebra_vrf
*zvrf
= vrf
->info
;
102 struct route_table
*stable
;
103 struct route_node
*rn
;
104 struct static_route
*si
;
105 struct interface
*ifp
;
111 zebra_vrf_add_update(zvrf
);
113 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
114 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++) {
115 stable
= zvrf
->stable
[afi
][safi
];
119 for (rn
= route_top(stable
); rn
; rn
= route_next(rn
))
120 for (si
= rn
->info
; si
; si
= si
->next
) {
121 si
->vrf_id
= vrf
->vrf_id
;
123 ifp
= if_lookup_by_name(
124 si
->ifname
, si
->vrf_id
);
131 static_install_route(afi
, safi
, &rn
->p
,
139 /* Callback upon disabling a VRF. */
140 static int zebra_vrf_disable(struct vrf
*vrf
)
142 struct zebra_vrf
*zvrf
= vrf
->info
;
143 struct route_table
*stable
;
144 struct route_node
*rn
;
145 struct static_route
*si
;
149 if (IS_ZEBRA_DEBUG_KERNEL
)
150 zlog_debug("VRF %s id %u is now disabled.", zvrf_name(zvrf
),
153 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++)
154 for (safi
= SAFI_UNICAST
; safi
< SAFI_MAX
; safi
++) {
155 stable
= zvrf
->stable
[afi
][safi
];
159 for (rn
= route_top(stable
); rn
; rn
= route_next(rn
))
160 for (si
= rn
->info
; si
; si
= si
->next
)
161 static_uninstall_route(
162 afi
, safi
, &rn
->p
, NULL
, si
);
168 static int zebra_vrf_delete(struct vrf
*vrf
)
170 struct zebra_vrf
*zvrf
= vrf
->info
;
171 struct route_table
*table
;
179 zebra_vrf_delete_update(zvrf
);
181 /* uninstall everything */
182 if (!CHECK_FLAG(zvrf
->flags
, ZEBRA_VRF_RETAIN
)) {
183 struct listnode
*node
;
184 struct interface
*ifp
;
186 for (afi
= AFI_IP
; afi
<= AFI_IP6
; afi
++) {
187 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MULTICAST
;
189 rib_close_table(zvrf
->table
[afi
][safi
]);
191 if (vrf
->vrf_id
== VRF_DEFAULT
)
193 table_id
< ZEBRA_KERNEL_TABLE_MAX
;
195 if (zvrf
->other_table
[afi
][table_id
])
202 /* Cleanup Vxlan table and update kernel */
203 zebra_vxlan_close_tables(zvrf
);
205 zebra_mpls_close_tables(zvrf
);
208 for (ALL_LIST_ELEMENTS_RO(vrf
->iflist
, node
, ifp
))
209 if_nbr_ipv6ll_to_ipv4ll_neigh_del_all(ifp
);
212 /* clean-up work queues */
213 for (i
= 0; i
< MQ_SIZE
; i
++) {
214 struct listnode
*lnode
, *nnode
;
215 struct route_node
*rnode
;
218 for (ALL_LIST_ELEMENTS(zebrad
.mq
->subq
[i
], lnode
, nnode
,
220 dest
= rib_dest_from_rnode(rnode
);
221 if (dest
&& rib_dest_vrf(dest
) == zvrf
) {
222 route_unlock_node(rnode
);
223 list_delete_node(zebrad
.mq
->subq
[i
], lnode
);
229 /* release allocated memory */
230 for (afi
= AFI_IP
; afi
<= AFI_IP6
; afi
++) {
233 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MULTICAST
; safi
++) {
234 table
= zvrf
->table
[afi
][safi
];
235 table_info
= table
->info
;
236 route_table_finish(table
);
237 XFREE(MTYPE_RIB_TABLE_INFO
, table_info
);
239 table
= zvrf
->stable
[afi
][safi
];
240 route_table_finish(table
);
243 for (table_id
= 0; table_id
< ZEBRA_KERNEL_TABLE_MAX
;
245 if (zvrf
->other_table
[afi
][table_id
]) {
246 table
= zvrf
->other_table
[afi
][table_id
];
247 table_info
= table
->info
;
248 route_table_finish(table
);
249 XFREE(MTYPE_RIB_TABLE_INFO
, table_info
);
252 route_table_finish(zvrf
->rnh_table
[afi
]);
253 route_table_finish(zvrf
->import_check_table
[afi
]);
255 list_delete_all_node(zvrf
->rid_all_sorted_list
);
256 list_delete_all_node(zvrf
->rid_lo_sorted_list
);
257 XFREE(MTYPE_ZEBRA_VRF
, zvrf
);
263 /* Lookup the routing table in a VRF based on both VRF-Id and table-id.
264 * NOTE: Table-id is relevant only in the Default VRF.
266 struct route_table
*zebra_vrf_table_with_table_id(afi_t afi
, safi_t safi
,
270 struct route_table
*table
= NULL
;
272 if (afi
>= AFI_MAX
|| safi
>= SAFI_MAX
)
275 if (vrf_id
== VRF_DEFAULT
) {
276 if (table_id
== RT_TABLE_MAIN
277 || table_id
== zebrad
.rtm_table_default
)
278 table
= zebra_vrf_table(afi
, safi
, vrf_id
);
280 table
= zebra_vrf_other_route_table(afi
, table_id
,
283 table
= zebra_vrf_table(afi
, safi
, vrf_id
);
288 static void zebra_rtable_node_cleanup(struct route_table
*table
,
289 struct route_node
*node
)
291 struct route_entry
*re
, *next
;
293 RNODE_FOREACH_RE_SAFE(node
, re
, next
)
294 rib_unlink(node
, re
);
297 XFREE(MTYPE_RIB_DEST
, node
->info
);
300 static void zebra_stable_node_cleanup(struct route_table
*table
,
301 struct route_node
*node
)
303 struct static_route
*si
, *next
;
306 for (si
= node
->info
; si
; si
= next
) {
308 XFREE(MTYPE_STATIC_ROUTE
, si
);
312 static void zebra_rnhtable_node_cleanup(struct route_table
*table
,
313 struct route_node
*node
)
316 zebra_free_rnh(node
->info
);
320 * Create a routing table for the specific AFI/SAFI in the given VRF.
322 static void zebra_vrf_table_create(struct zebra_vrf
*zvrf
, afi_t afi
,
325 rib_table_info_t
*info
;
326 struct route_table
*table
;
328 assert(!zvrf
->table
[afi
][safi
]);
331 table
= srcdest_table_init();
333 table
= route_table_init();
334 table
->cleanup
= zebra_rtable_node_cleanup
;
335 zvrf
->table
[afi
][safi
] = table
;
337 info
= XCALLOC(MTYPE_RIB_TABLE_INFO
, sizeof(*info
));
344 /* Allocate new zebra VRF. */
345 struct zebra_vrf
*zebra_vrf_alloc(void)
347 struct zebra_vrf
*zvrf
;
350 struct route_table
*table
;
352 zvrf
= XCALLOC(MTYPE_ZEBRA_VRF
, sizeof(struct zebra_vrf
));
354 for (afi
= AFI_IP
; afi
<= AFI_IP6
; afi
++) {
355 for (safi
= SAFI_UNICAST
; safi
<= SAFI_MULTICAST
; safi
++) {
356 zebra_vrf_table_create(zvrf
, afi
, safi
);
358 table
= srcdest_table_init();
360 table
= route_table_init();
361 table
->cleanup
= zebra_stable_node_cleanup
;
362 zvrf
->stable
[afi
][safi
] = table
;
365 table
= route_table_init();
366 table
->cleanup
= zebra_rnhtable_node_cleanup
;
367 zvrf
->rnh_table
[afi
] = table
;
369 table
= route_table_init();
370 table
->cleanup
= zebra_rnhtable_node_cleanup
;
371 zvrf
->import_check_table
[afi
] = table
;
374 zebra_vxlan_init_tables(zvrf
);
375 zebra_mpls_init_tables(zvrf
);
381 /* Lookup VRF by identifier. */
382 struct zebra_vrf
*zebra_vrf_lookup_by_id(vrf_id_t vrf_id
)
384 return vrf_info_lookup(vrf_id
);
387 /* Lookup VRF by name. */
388 struct zebra_vrf
*zebra_vrf_lookup_by_name(const char *name
)
393 name
= VRF_DEFAULT_NAME
;
395 vrf
= vrf_lookup_by_name(name
);
397 return ((struct zebra_vrf
*)vrf
->info
);
402 /* Lookup the routing table in an enabled VRF. */
403 struct route_table
*zebra_vrf_table(afi_t afi
, safi_t safi
, vrf_id_t vrf_id
)
405 struct zebra_vrf
*zvrf
= vrf_info_lookup(vrf_id
);
410 if (afi
>= AFI_MAX
|| safi
>= SAFI_MAX
)
413 return zvrf
->table
[afi
][safi
];
416 /* Lookup the static routing table in a VRF. */
417 struct route_table
*zebra_vrf_static_table(afi_t afi
, safi_t safi
,
418 struct zebra_vrf
*zvrf
)
423 if (afi
>= AFI_MAX
|| safi
>= SAFI_MAX
)
426 return zvrf
->stable
[afi
][safi
];
429 struct route_table
*zebra_vrf_other_route_table(afi_t afi
, u_int32_t table_id
,
432 struct zebra_vrf
*zvrf
;
433 rib_table_info_t
*info
;
434 struct route_table
*table
;
436 zvrf
= vrf_info_lookup(vrf_id
);
443 if (table_id
>= ZEBRA_KERNEL_TABLE_MAX
)
446 if ((vrf_id
== VRF_DEFAULT
) && (table_id
!= RT_TABLE_MAIN
)
447 && (table_id
!= zebrad
.rtm_table_default
)) {
448 if (zvrf
->other_table
[afi
][table_id
] == NULL
) {
449 table
= (afi
== AFI_IP6
) ? srcdest_table_init()
450 : route_table_init();
451 info
= XCALLOC(MTYPE_RIB_TABLE_INFO
, sizeof(*info
));
454 info
->safi
= SAFI_UNICAST
;
456 zvrf
->other_table
[afi
][table_id
] = table
;
459 return (zvrf
->other_table
[afi
][table_id
]);
462 return zvrf
->table
[afi
][SAFI_UNICAST
];
465 static int vrf_config_write(struct vty
*vty
)
468 struct zebra_vrf
*zvrf
;
470 RB_FOREACH(vrf
, vrf_name_head
, &vrfs_by_name
)
473 if (!zvrf
|| strcmp(zvrf_name(zvrf
), VRF_DEFAULT_NAME
)) {
474 vty_out(vty
, "vrf %s\n", zvrf_name(zvrf
));
481 /* Zebra VRF initialization. */
482 void zebra_vrf_init(void)
484 vrf_init(zebra_vrf_new
, zebra_vrf_enable
, zebra_vrf_disable
,
487 vrf_cmd_init(vrf_config_write
);