src/plugins/cnat/cnat_session.c

   1 /*
   2  * Copyright (c) 2020 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vnet/ip/ip.h>
  17 #include <cnat/cnat_session.h>
  18
  19 #include <vppinfra/bihash_template.h>
  20 #include <vppinfra/bihash_template.c>
  21
  22
  23 clib_bihash_40_48_t cnat_session_db;
  24
  25
  26 typedef struct cnat_session_walk_ctx_t_
  27 {
  28   cnat_session_walk_cb_t cb;
  29   void *ctx;
  30 } cnat_session_walk_ctx_t;
  31
  32 static int
  33 cnat_session_walk_cb (BVT (clib_bihash_kv) * kv, void *arg)
  34 {
  35   cnat_session_t *session = (cnat_session_t *) kv;
  36   cnat_session_walk_ctx_t *ctx = arg;
  37
  38   ctx->cb (session, ctx->ctx);
  39
  40   return (BIHASH_WALK_CONTINUE);
  41 }
  42
  43 void
  44 cnat_session_walk (cnat_session_walk_cb_t cb, void *ctx)
  45 {
  46   cnat_session_walk_ctx_t wctx = {
  47     .cb = cb,
  48     .ctx = ctx,
  49   };
  50   BV (clib_bihash_foreach_key_value_pair) (&cnat_session_db,
  51                                            cnat_session_walk_cb, &wctx);
  52 }
  53
  54 typedef struct cnat_session_purge_walk_t_
  55 {
  56   clib_bihash_kv_40_48_t *keys;
  57 } cnat_session_purge_walk_ctx_t;
  58
  59 static int
  60 cnat_session_purge_walk (BVT (clib_bihash_kv) * key, void *arg)
  61 {
  62   cnat_session_purge_walk_ctx_t *ctx = arg;
  63
  64   vec_add1 (ctx->keys, *key);
  65
  66   return (BIHASH_WALK_CONTINUE);
  67 }
  68
  69 u8 *
  70 format_cnat_session (u8 * s, va_list * args)
  71 {
  72   cnat_session_t *sess = va_arg (*args, cnat_session_t *);
  73   CLIB_UNUSED (int verbose) = va_arg (*args, int);
  74   f64 ts = 0;
  75   if (!pool_is_free_index (cnat_timestamps, sess->value.cs_ts_index))
  76     ts = cnat_timestamp_exp (sess->value.cs_ts_index);
  77
  78   s =
  79     format (s,
  80             "session:[%U;%d -> %U;%d, %U] => %U;%d -> %U;%d lb:%d age:%f",
  81             format_ip46_address, &sess->key.cs_ip[VLIB_RX], IP46_TYPE_ANY,
  82             clib_host_to_net_u16 (sess->key.cs_port[VLIB_RX]),
  83             format_ip46_address, &sess->key.cs_ip[VLIB_TX], IP46_TYPE_ANY,
  84             clib_host_to_net_u16 (sess->key.cs_port[VLIB_TX]),
  85             format_ip_protocol, sess->key.cs_proto, format_ip46_address,
  86             &sess->value.cs_ip[VLIB_RX], IP46_TYPE_ANY,
  87             clib_host_to_net_u16 (sess->value.cs_port[VLIB_RX]),
  88             format_ip46_address, &sess->value.cs_ip[VLIB_TX], IP46_TYPE_ANY,
  89             clib_host_to_net_u16 (sess->value.cs_port[VLIB_TX]),
  90             sess->value.cs_lbi, ts);
  91
  92   return (s);
  93 }
  94
  95 static clib_error_t *
  96 cnat_session_show (vlib_main_t * vm,
  97                    unformat_input_t * input, vlib_cli_command_t * cmd)
  98 {
  99   u8 verbose = 0;
 100   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 101     {
 102       if (unformat (input, "verbose"))
 103         verbose = 1;
 104       else
 105         return (clib_error_return (0, "unknown input '%U'",
 106                                    format_unformat_error, input));
 107     }
 108
 109   vlib_cli_output (vm, "CNat Sessions: now:%f\n%U\n",
 110                    vlib_time_now (vm),
 111                    BV (format_bihash), &cnat_session_db, verbose);
 112
 113   return (NULL);
 114 }
 115
 116 /* *INDENT-OFF* */
 117 VLIB_CLI_COMMAND (cnat_session_show_cmd_node, static) = {
 118   .path = "show cnat session",
 119   .function = cnat_session_show,
 120   .short_help = "show cnat session",
 121   .is_mp_safe = 1,
 122 };
 123 /* *INDENT-ON* */
 124
 125 void
 126 cnat_session_free (cnat_session_t * session)
 127 {
 128   clib_bihash_kv_40_48_t *bkey = (clib_bihash_kv_40_48_t *) session;
 129   /* age it */
 130   if (session->value.flags & CNAT_SESSION_FLAG_ALLOC_PORT)
 131     cnat_free_port (session->value.cs_port[VLIB_RX]);
 132   if (!(session->value.flags & CNAT_SESSION_FLAG_NO_CLIENT))
 133     cnat_client_free_by_ip (&session->key.cs_ip[VLIB_TX], session->key.cs_af);
 134   cnat_timestamp_free (session->value.cs_ts_index);
 135
 136   clib_bihash_add_del_40_48 (&cnat_session_db, bkey, 0 /* is_add */ );
 137 }
 138
 139 int
 140 cnat_session_purge (void)
 141 {
 142   /* flush all the session from the DB */
 143   cnat_session_purge_walk_ctx_t ctx = { };
 144   clib_bihash_kv_40_48_t *key;
 145
 146   BV (clib_bihash_foreach_key_value_pair) (&cnat_session_db,
 147                                            cnat_session_purge_walk, &ctx);
 148
 149   vec_foreach (key, ctx.keys) cnat_session_free ((cnat_session_t *) key);
 150
 151   vec_free (ctx.keys);
 152
 153   return (0);
 154 }
 155
 156 u64
 157 cnat_session_scan (vlib_main_t * vm, f64 start_time, int i)
 158 {
 159   BVT (clib_bihash) * h = &cnat_session_db;
 160   int j, k;
 161
 162   /* Don't scan the l2 fib if it hasn't been instantiated yet */
 163   if (alloc_arena (h) == 0)
 164     return 0.0;
 165
 166   for (i = 0; i < h->nbuckets; i++)
 167     {
 168       /* allow no more than 100us without a pause */
 169       if ((vlib_time_now (vm) - start_time) > 10e-5)
 170         return (i);
 171
 172       if (i < (h->nbuckets - 3))
 173         {
 174           BVT (clib_bihash_bucket) * b =
 175             BV (clib_bihash_get_bucket) (h, i + 3);
 176           CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD);
 177           b = BV (clib_bihash_get_bucket) (h, i + 1);
 178           if (!BV (clib_bihash_bucket_is_empty) (b))
 179             {
 180               BVT (clib_bihash_value) * v =
 181                 BV (clib_bihash_get_value) (h, b->offset);
 182               CLIB_PREFETCH (v, CLIB_CACHE_LINE_BYTES, LOAD);
 183             }
 184         }
 185
 186       BVT (clib_bihash_bucket) * b = BV (clib_bihash_get_bucket) (h, i);
 187       if (BV (clib_bihash_bucket_is_empty) (b))
 188         continue;
 189       BVT (clib_bihash_value) * v = BV (clib_bihash_get_value) (h, b->offset);
 190       for (j = 0; j < (1 << b->log2_pages); j++)
 191         {
 192           for (k = 0; k < BIHASH_KVP_PER_PAGE; k++)
 193             {
 194               if (v->kvp[k].key[0] == ~0ULL && v->kvp[k].value[0] == ~0ULL)
 195                 continue;
 196
 197               cnat_session_t *session = (cnat_session_t *) & v->kvp[k];
 198
 199               if (start_time >
 200                   cnat_timestamp_exp (session->value.cs_ts_index))
 201                 {
 202                   /* age it */
 203                   cnat_session_free (session);
 204
 205                   /*
 206                    * Note: we may have just freed the bucket's backing
 207                    * storage, so check right here...
 208                    */
 209                   if (BV (clib_bihash_bucket_is_empty) (b))
 210                     goto doublebreak;
 211                 }
 212             }
 213           v++;
 214         }
 215     doublebreak:
 216       ;
 217     }
 218
 219   /* start again */
 220   return (0);
 221 }
 222
 223 static clib_error_t *
 224 cnat_session_init (vlib_main_t * vm)
 225 {
 226   cnat_main_t *cm = &cnat_main;
 227   BV (clib_bihash_init) (&cnat_session_db,
 228                          "CNat Session DB", cm->session_hash_buckets,
 229                          cm->session_hash_memory);
 230   BV (clib_bihash_set_kvp_format_fn) (&cnat_session_db, format_cnat_session);
 231
 232   return (NULL);
 233 }
 234
 235 VLIB_INIT_FUNCTION (cnat_session_init);
 236
 237 static clib_error_t *
 238 cnat_timestamp_show (vlib_main_t * vm,
 239                      unformat_input_t * input, vlib_cli_command_t * cmd)
 240 {
 241   cnat_timestamp_t *ts;
 242   clib_rwlock_reader_lock (&cnat_main.ts_lock);
 243     /* *INDENT-OFF* */
 244   pool_foreach (ts, cnat_timestamps, ({
 245     vlib_cli_output (vm, "[%d] last_seen:%f lifetime:%u ref:%u",
 246                      ts - cnat_timestamps,
 247                      ts->last_seen, ts->lifetime, ts->refcnt);
 248   }));
 249   /* *INDENT-ON* */
 250   clib_rwlock_reader_unlock (&cnat_main.ts_lock);
 251   return (NULL);
 252 }
 253
 254 /* *INDENT-OFF* */
 255 VLIB_CLI_COMMAND (cnat_timestamp_show_cmd, static) = {
 256   .path = "show cnat timestamp",
 257   .function = cnat_timestamp_show,
 258   .short_help = "show cnat timestamp",
 259   .is_mp_safe = 1,
 260 };
 261 /* *INDENT-ON* */
 262
 263 /*
 264  * fd.io coding-style-patch-verification: ON
 265  *
 266  * Local Variables:
 267  * eval: (c-set-style "gnu")
 268  * End:
 269  */