zebra/table_manager.c

   1 /* zebra table Manager for routing table identifier management
   2  * Copyright (C) 2018 6WIND
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License as published by the Free
   6  * Software Foundation; either version 2 of the License, or (at your option)
   7  * any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; see the file COPYING; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include "zebra.h"
  20
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <sys/types.h>
  24
  25 #include "lib/log.h"
  26 #include "lib/memory.h"
  27 #include "lib/table.h"
  28 #include "lib/network.h"
  29 #include "lib/stream.h"
  30 #include "lib/zclient.h"
  31 #include "lib/libfrr.h"
  32 #include "lib/vrf.h"
  33
  34 #include "zebra/zserv.h"
  35 #include "zebra/zebra_vrf.h"
  36 #include "zebra/label_manager.h" /* for NO_PROTO */
  37 #include "zebra/table_manager.h"
  38 #include "zebra/zebra_errors.h"
  39
  40 /* routing table identifiers
  41  *
  42  */
  43 #if !defined(GNU_LINUX)
  44 /* BSD systems
  45  */
  46 #else
  47 /* Linux Systems
  48  */
  49 #define RT_TABLE_ID_LOCAL                  255
  50 #define RT_TABLE_ID_MAIN                   254
  51 #define RT_TABLE_ID_DEFAULT                253
  52 #define RT_TABLE_ID_COMPAT                 252
  53 #define RT_TABLE_ID_UNSPEC                 0
  54 #endif /* !def(GNU_LINUX) */
  55 #define RT_TABLE_ID_UNRESERVED_MIN         1
  56 #define RT_TABLE_ID_UNRESERVED_MAX         0xffffffff
  57
  58 DEFINE_MGROUP(TABLE_MGR, "Table Manager");
  59 DEFINE_MTYPE_STATIC(TABLE_MGR, TM_CHUNK, "Table Manager Chunk");
  60 DEFINE_MTYPE_STATIC(TABLE_MGR, TM_TABLE, "Table Manager Context");
  61
  62 static void delete_table_chunk(void *val)
  63 {
  64         XFREE(MTYPE_TM_CHUNK, val);
  65 }
  66
  67 /**
  68  * Init table manager
  69  */
  70 void table_manager_enable(struct zebra_vrf *zvrf)
  71 {
  72
  73         if (zvrf->tbl_mgr)
  74                 return;
  75         if (!vrf_is_backend_netns() && zvrf_id(zvrf) != VRF_DEFAULT) {
  76                 struct zebra_vrf *def = zebra_vrf_lookup_by_id(VRF_DEFAULT);
  77
  78                 if (def)
  79                         zvrf->tbl_mgr = def->tbl_mgr;
  80                 return;
  81         }
  82         zvrf->tbl_mgr = XCALLOC(MTYPE_TM_TABLE, sizeof(struct table_manager));
  83         zvrf->tbl_mgr->lc_list = list_new();
  84         zvrf->tbl_mgr->lc_list->del = delete_table_chunk;
  85         hook_register(zserv_client_close, release_daemon_table_chunks);
  86 }
  87
  88 /**
  89  * Core function, assigns table chunks
  90  *
  91  * It first searches through the list to check if there's one available
  92  * (previously released). Otherwise it creates and assigns a new one
  93  *
  94  * @param proto Daemon protocol of client, to identify the owner
  95  * @param instance Instance, to identify the owner
  96  * @para size Size of the table chunk
  97  * @return Pointer to the assigned table chunk
  98  */
  99 struct table_manager_chunk *assign_table_chunk(uint8_t proto, uint16_t instance,
 100                                                uint32_t size,
 101                                                struct zebra_vrf *zvrf)
 102 {
 103         struct table_manager_chunk *tmc;
 104         struct listnode *node;
 105         uint32_t start;
 106         bool manual_conf = false;
 107
 108         if (!zvrf)
 109                 return NULL;
 110
 111         /* first check if there's one available */
 112         for (ALL_LIST_ELEMENTS_RO(zvrf->tbl_mgr->lc_list, node, tmc)) {
 113                 if (tmc->proto == NO_PROTO
 114                     && tmc->end - tmc->start + 1 == size) {
 115                         tmc->proto = proto;
 116                         tmc->instance = instance;
 117                         return tmc;
 118                 }
 119         }
 120         /* otherwise create a new one */
 121         tmc = XCALLOC(MTYPE_TM_CHUNK, sizeof(struct table_manager_chunk));
 122         if (!tmc)
 123                 return NULL;
 124
 125         if (zvrf->tbl_mgr->start || zvrf->tbl_mgr->end)
 126                 manual_conf = true;
 127         /* table RT IDs range are [1;252] and [256;0xffffffff]
 128          * - check if the requested range can be within the first range,
 129          * otherwise elect second one
 130          * - TODO : vrf-lites have their own table identifier.
 131          * In that case, table_id should be removed from the table range.
 132          */
 133         if (list_isempty(zvrf->tbl_mgr->lc_list)) {
 134                 if (!manual_conf)
 135                         start = RT_TABLE_ID_UNRESERVED_MIN;
 136                 else
 137                         start = zvrf->tbl_mgr->start;
 138         } else
 139                 start = ((struct table_manager_chunk *)listgetdata(
 140                                  listtail(zvrf->tbl_mgr->lc_list)))
 141                                 ->end
 142                         + 1;
 143
 144         if (!manual_conf) {
 145
 146 #if !defined(GNU_LINUX)
 147 /* BSD systems
 148  */
 149 #else
 150 /* Linux Systems
 151  */
 152                 /* if not enough room space between MIN and COMPAT,
 153                  * then begin after LOCAL
 154                  */
 155                 if (start < RT_TABLE_ID_COMPAT
 156                     && (size > RT_TABLE_ID_COMPAT - RT_TABLE_ID_UNRESERVED_MIN))
 157                         start = RT_TABLE_ID_LOCAL + 1;
 158 #endif /* !def(GNU_LINUX) */
 159                 tmc->start = start;
 160                 if (RT_TABLE_ID_UNRESERVED_MAX - size + 1 < start) {
 161                         flog_err(EC_ZEBRA_TM_EXHAUSTED_IDS,
 162                                  "Reached max table id. Start/Size %u/%u",
 163                                  start, size);
 164                         XFREE(MTYPE_TM_CHUNK, tmc);
 165                         return NULL;
 166                 }
 167         } else {
 168                 tmc->start = start;
 169                 if (zvrf->tbl_mgr->end - size + 1 < start) {
 170                         flog_err(EC_ZEBRA_TM_EXHAUSTED_IDS,
 171                                  "Reached max table id. Start/Size %u/%u",
 172                                  start, size);
 173                         XFREE(MTYPE_TM_CHUNK, tmc);
 174                         return NULL;
 175                 }
 176         }
 177         tmc->end = tmc->start + size - 1;
 178         tmc->proto = proto;
 179         tmc->instance = instance;
 180         listnode_add(zvrf->tbl_mgr->lc_list, tmc);
 181
 182         return tmc;
 183 }
 184
 185 /**
 186  * Core function, release no longer used table chunks
 187  *
 188  * @param proto Daemon protocol of client, to identify the owner
 189  * @param instance Instance, to identify the owner
 190  * @param start First table RT ID of the chunk
 191  * @param end Last table RT ID of the chunk
 192  * @return 0 on success, -1 otherwise
 193  */
 194 int release_table_chunk(uint8_t proto, uint16_t instance, uint32_t start,
 195                         uint32_t end, struct zebra_vrf *zvrf)
 196 {
 197         struct listnode *node;
 198         struct table_manager_chunk *tmc;
 199         int ret = -1;
 200         struct table_manager *tbl_mgr;
 201
 202         if (!zvrf)
 203                 return -1;
 204
 205         tbl_mgr = zvrf->tbl_mgr;
 206         if (!tbl_mgr)
 207                 return ret;
 208         /* check that size matches */
 209         zlog_debug("Releasing table chunk: %u - %u", start, end);
 210         /* find chunk and disown */
 211         for (ALL_LIST_ELEMENTS_RO(tbl_mgr->lc_list, node, tmc)) {
 212                 if (tmc->start != start)
 213                         continue;
 214                 if (tmc->end != end)
 215                         continue;
 216                 if (tmc->proto != proto || tmc->instance != instance) {
 217                         flog_err(EC_ZEBRA_TM_DAEMON_MISMATCH,
 218                                  "%s: Daemon mismatch!!", __func__);
 219                         continue;
 220                 }
 221                 tmc->proto = NO_PROTO;
 222                 tmc->instance = 0;
 223                 ret = 0;
 224                 break;
 225         }
 226         if (ret != 0)
 227                 flog_err(EC_ZEBRA_TM_UNRELEASED_CHUNK,
 228                          "%s: Table chunk not released!!", __func__);
 229
 230         return ret;
 231 }
 232
 233 /**
 234  * Release table chunks from a client.
 235  *
 236  * Called on client disconnection or reconnection. It only releases chunks
 237  * with empty keep value.
 238  *
 239  * @param client the client to release chunks from
 240  * @return Number of chunks released
 241  */
 242 int release_daemon_table_chunks(struct zserv *client)
 243 {
 244         uint8_t proto = client->proto;
 245         uint16_t instance = client->instance;
 246         struct listnode *node;
 247         struct table_manager_chunk *tmc;
 248         int count = 0;
 249         int ret;
 250         struct vrf *vrf;
 251         struct zebra_vrf *zvrf;
 252
 253         RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
 254                 zvrf = vrf->info;
 255
 256                 if (!zvrf)
 257                         continue;
 258                 if (!vrf_is_backend_netns() && vrf->vrf_id != VRF_DEFAULT)
 259                         continue;
 260                 for (ALL_LIST_ELEMENTS_RO(zvrf->tbl_mgr->lc_list, node, tmc)) {
 261                         if (tmc->proto == proto && tmc->instance == instance) {
 262                                 ret = release_table_chunk(
 263                                         tmc->proto, tmc->instance, tmc->start,
 264                                         tmc->end, zvrf);
 265                                 if (ret == 0)
 266                                         count++;
 267                         }
 268                 }
 269         }
 270         zlog_debug("%s: Released %d table chunks", __func__, count);
 271
 272         return count;
 273 }
 274
 275 static void table_range_add(struct zebra_vrf *zvrf, uint32_t start,
 276                             uint32_t end)
 277 {
 278         if (!zvrf->tbl_mgr)
 279                 return;
 280         zvrf->tbl_mgr->start = start;
 281         zvrf->tbl_mgr->end = end;
 282 }
 283
 284 void table_manager_disable(struct zebra_vrf *zvrf)
 285 {
 286         if (!zvrf->tbl_mgr)
 287                 return;
 288         if (!vrf_is_backend_netns() && zvrf_id(zvrf) != VRF_DEFAULT) {
 289                 zvrf->tbl_mgr = NULL;
 290                 return;
 291         }
 292         list_delete(&zvrf->tbl_mgr->lc_list);
 293         XFREE(MTYPE_TM_TABLE, zvrf->tbl_mgr);
 294         zvrf->tbl_mgr = NULL;
 295 }
 296
 297 int table_manager_range(struct vty *vty, bool add, struct zebra_vrf *zvrf,
 298                         const char *start_table_str, const char *end_table_str)
 299 {
 300         uint32_t start;
 301         uint32_t end;
 302
 303         if (add) {
 304                 if (!start_table_str || !end_table_str) {
 305                         vty_out(vty, "%% Labels not specified\n");
 306                         return CMD_WARNING_CONFIG_FAILED;
 307                 }
 308                 start = atoi(start_table_str);
 309                 end = atoi(end_table_str);
 310                 if (end < start) {
 311                         vty_out(vty, "%% End table is less than Start table\n");
 312                         return CMD_WARNING_CONFIG_FAILED;
 313                 }
 314
 315 #if !defined(GNU_LINUX)
 316 /* BSD systems
 317  */
 318 #else
 319                 /* Linux Systems
 320                  */
 321                 if ((start >= RT_TABLE_ID_COMPAT && start <= RT_TABLE_ID_LOCAL)
 322                     || (end >= RT_TABLE_ID_COMPAT
 323                         && end <= RT_TABLE_ID_LOCAL)) {
 324                         vty_out(vty, "%% Values forbidden in range [%u;%u]\n",
 325                                 RT_TABLE_ID_COMPAT, RT_TABLE_ID_LOCAL);
 326                         return CMD_WARNING_CONFIG_FAILED;
 327                 }
 328                 if (start < RT_TABLE_ID_COMPAT && end > RT_TABLE_ID_LOCAL) {
 329                         vty_out(vty,
 330                                 "%% Range overlaps range [%u;%u] forbidden\n",
 331                                 RT_TABLE_ID_COMPAT, RT_TABLE_ID_LOCAL);
 332                         return CMD_WARNING_CONFIG_FAILED;
 333                 }
 334 #endif
 335                 if (zvrf->tbl_mgr
 336                     && ((zvrf->tbl_mgr->start && zvrf->tbl_mgr->start != start)
 337                         || (zvrf->tbl_mgr->end && zvrf->tbl_mgr->end != end))) {
 338                         vty_out(vty,
 339                                 "%% New range will be taken into account at restart\n");
 340                 }
 341                 table_range_add(zvrf, start, end);
 342         } else
 343                 table_range_add(zvrf, 0, 0);
 344         return CMD_SUCCESS;
 345 }