Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2017-2019 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/session/session_table.h>
      17             : #include <vnet/session/session.h>
      18             : 
      19             : /**
      20             :  * Pool of session tables
      21             :  */
      22             : static session_table_t *lookup_tables;
      23             : 
      24             : session_table_t *
      25           0 : _get_session_tables (void)
      26             : {
      27           0 :   return lookup_tables;
      28             : }
      29             : 
      30             : session_table_t *
      31         228 : session_table_alloc (void)
      32             : {
      33             :   session_table_t *slt;
      34         228 :   pool_get_aligned (lookup_tables, slt, CLIB_CACHE_LINE_BYTES);
      35         228 :   clib_memset (slt, 0, sizeof (*slt));
      36         228 :   return slt;
      37             : }
      38             : 
      39             : u32
      40         282 : session_table_index (session_table_t * slt)
      41             : {
      42         282 :   return (slt - lookup_tables);
      43             : }
      44             : 
      45             : session_table_t *
      46     1080980 : session_table_get (u32 table_index)
      47             : {
      48     1080980 :   if (pool_is_free_index (lookup_tables, table_index))
      49           1 :     return 0;
      50     1080980 :   return pool_elt_at_index (lookup_tables, table_index);
      51             : }
      52             : 
      53             : #define foreach_hash_table_parameter            \
      54             :   _(v4,session,buckets,20000)                   \
      55             :   _(v4,session,memory,(64<<20))                 \
      56             :   _(v6,session,buckets,20000)                   \
      57             :   _(v6,session,memory,(64<<20))                 \
      58             :   _(v4,halfopen,buckets,20000)                  \
      59             :   _(v4,halfopen,memory,(64<<20))                \
      60             :   _(v6,halfopen,buckets,20000)                  \
      61             :   _(v6,halfopen,memory,(64<<20))
      62             : 
      63             : void
      64           3 : session_table_free (session_table_t *slt, u8 fib_proto)
      65             : {
      66           3 :   u8 all = fib_proto > FIB_PROTOCOL_IP6 ? 1 : 0;
      67             :   int i;
      68             : 
      69          27 :   for (i = 0; i < TRANSPORT_N_PROTOS; i++)
      70          24 :     session_rules_table_free (&slt->session_rules[i]);
      71             : 
      72           3 :   vec_free (slt->session_rules);
      73             : 
      74           3 :   if (fib_proto == FIB_PROTOCOL_IP4 || all)
      75             :     {
      76           3 :       clib_bihash_free_16_8 (&slt->v4_session_hash);
      77           3 :       clib_bihash_free_16_8 (&slt->v4_half_open_hash);
      78             :     }
      79           3 :   if (fib_proto == FIB_PROTOCOL_IP6 || all)
      80             :     {
      81           3 :       clib_bihash_free_48_8 (&slt->v6_session_hash);
      82           3 :       clib_bihash_free_48_8 (&slt->v6_half_open_hash);
      83             :     }
      84             : 
      85           3 :   pool_put (lookup_tables, slt);
      86           3 : }
      87             : 
      88             : /**
      89             :  * Initialize session table hash tables
      90             :  *
      91             :  * If vpp configured with set of table parameters it uses them,
      92             :  * otherwise it uses defaults above.
      93             :  */
      94             : void
      95         228 : session_table_init (session_table_t * slt, u8 fib_proto)
      96             : {
      97         228 :   u8 all = fib_proto > FIB_PROTOCOL_IP6 ? 1 : 0;
      98             :   int i;
      99             : 
     100             : #define _(af,table,parm,value)                                          \
     101             :   u32 configured_##af##_##table##_table_##parm = value;
     102         228 :   foreach_hash_table_parameter;
     103             : #undef _
     104             : 
     105             : #define _(af,table,parm,value)                                          \
     106             :   if (session_main.configured_##af##_##table##_table_##parm)    \
     107             :     configured_##af##_##table##_table_##parm =                          \
     108             :       session_main.configured_##af##_##table##_table_##parm;
     109         228 :   foreach_hash_table_parameter;
     110             : #undef _
     111             : 
     112         228 :   if (fib_proto == FIB_PROTOCOL_IP4 || all)
     113             :     {
     114         177 :       clib_bihash_init2_args_16_8_t _a, *a = &_a;
     115             : 
     116         177 :       memset (a, 0, sizeof (*a));
     117         177 :       a->h = &slt->v4_session_hash;
     118         177 :       a->name = "v4 session table";
     119         177 :       a->nbuckets = configured_v4_session_table_buckets;
     120         177 :       a->memory_size = configured_v4_session_table_memory;
     121         177 :       a->dont_add_to_all_bihash_list = 1;
     122         177 :       a->instantiate_immediately = 1;
     123         177 :       clib_bihash_init2_16_8 (a);
     124             : 
     125         177 :       memset (a, 0, sizeof (*a));
     126         177 :       a->h = &slt->v4_half_open_hash;
     127         177 :       a->name = "v4 half-open table";
     128         177 :       a->nbuckets = configured_v4_halfopen_table_buckets;
     129         177 :       a->memory_size = configured_v4_halfopen_table_memory;
     130         177 :       a->dont_add_to_all_bihash_list = 1;
     131         177 :       a->instantiate_immediately = 1;
     132         177 :       clib_bihash_init2_16_8 (a);
     133             :     }
     134         228 :   if (fib_proto == FIB_PROTOCOL_IP6 || all)
     135             :     {
     136         143 :       clib_bihash_init2_args_48_8_t _a, *a = &_a;
     137             : 
     138         143 :       memset (a, 0, sizeof (*a));
     139         143 :       a->h = &slt->v6_session_hash;
     140         143 :       a->name = "v6 session table";
     141         143 :       a->nbuckets = configured_v6_session_table_buckets;
     142         143 :       a->memory_size = configured_v6_session_table_memory;
     143         143 :       a->dont_add_to_all_bihash_list = 1;
     144         143 :       a->instantiate_immediately = 1;
     145         143 :       clib_bihash_init2_48_8 (a);
     146             : 
     147         143 :       memset (a, 0, sizeof (*a));
     148         143 :       a->h = &slt->v6_half_open_hash;
     149         143 :       a->name = "v6 half-open table";
     150         143 :       a->nbuckets = configured_v6_halfopen_table_buckets;
     151         143 :       a->memory_size = configured_v6_halfopen_table_memory;
     152         143 :       a->dont_add_to_all_bihash_list = 1;
     153         143 :       a->instantiate_immediately = 1;
     154         143 :       clib_bihash_init2_48_8 (a);
     155             :     }
     156             : 
     157         228 :   vec_validate (slt->session_rules, TRANSPORT_N_PROTOS - 1);
     158        2052 :   for (i = 0; i < TRANSPORT_N_PROTOS; i++)
     159        1824 :     session_rules_table_init (&slt->session_rules[i]);
     160         228 : }
     161             : 
     162             : typedef struct _ip4_session_table_walk_ctx_t
     163             : {
     164             :   ip4_session_table_walk_fn_t fn;
     165             :   void *ctx;
     166             : } ip4_session_table_walk_ctx_t;
     167             : 
     168             : static int
     169           0 : ip4_session_table_walk_cb (clib_bihash_kv_16_8_t * kvp, void *arg)
     170             : {
     171           0 :   ip4_session_table_walk_ctx_t *ctx = arg;
     172           0 :   ctx->fn (kvp, ctx->ctx);
     173           0 :   return (BIHASH_WALK_CONTINUE);
     174             : }
     175             : 
     176             : void
     177           0 : ip4_session_table_walk (clib_bihash_16_8_t * hash,
     178             :                         ip4_session_table_walk_fn_t fn, void *arg)
     179             : {
     180           0 :   ip4_session_table_walk_ctx_t ctx = {
     181             :     .fn = fn,
     182             :     .ctx = arg,
     183             :   };
     184           0 :   clib_bihash_foreach_key_value_pair_16_8 (hash, ip4_session_table_walk_cb,
     185             :                                            &ctx);
     186           0 : }
     187             : 
     188             : /* *INDENT-ON* */
     189             : /*
     190             :  * fd.io coding-style-patch-verification: ON
     191             :  *
     192             :  * Local Variables:
     193             :  * eval: (c-set-style "gnu")
     194             :  * End:
     195             :  */