NAT44: endpoint dependent mode (VPP-1273) - vpp

diff options

author	Matus Fabian <matfabia@cisco.com>	2018-06-13 05:39:07 -0700
committer	Ole Trøan <otroan@employees.org>	2018-06-15 06:53:24 +0000
commit	a6110b6ea5a066b64005347850f61df9a2000fe9 (patch)
tree	e8c836dadfe7238592ef5baaabc9cf520c5e813f /gmod/configure.ac
parent	e43832c7e77b8b008ab452386b143bb3f7f5be40 (diff)

NAT44: endpoint dependent mode (VPP-1273)

To enable NAT plugin endpoint dependent mode add following to statrup config: nat { endpoint-dependent } Enable endpoint dependent filtering and mapping for all sessions. Move some existing functionality such as service load balancing, twice nat, out2in-only static mappings and unknown protocol dynamic translations, which use endpoint dependent lookup hash tables before. Basically split to vanilla NAT44 and extra features NAT44. Change-Id: I3925eb5ddcc8f1ec4cf6af4e2a618a7ec7aa9735 Signed-off-by: Matus Fabian <matfabia@cisco.com>

Diffstat (limited to 'gmod/configure.ac')

0 files changed, 0 insertions, 0 deletions

/* * Copyright (c) 2015 Cisco and/or its affiliates. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include <vppinfra/bitmap.h> #include <vppinfra/hash.h> #include <vppinfra/pool.h> #include <vppinfra/timing_wheel.h> void timing_wheel_init (timing_wheel_t * w, u64 current_cpu_time, f64 cpu_clocks_per_second) { if (w->max_sched_time <= w->min_sched_time) { w->min_sched_time = 1e-6; w->max_sched_time = 1e-3; } w->cpu_clocks_per_second = cpu_clocks_per_second; w->log2_clocks_per_bin = max_log2 (w->cpu_clocks_per_second * w->min_sched_time); w->log2_bins_per_wheel = max_log2 (w->cpu_clocks_per_second * w->max_sched_time); w->log2_bins_per_wheel -= w->log2_clocks_per_bin; w->log2_clocks_per_wheel = w->log2_bins_per_wheel + w->log2_clocks_per_bin; w->bins_per_wheel = 1 << w->log2_bins_per_wheel; w->bins_per_wheel_mask = w->bins_per_wheel - 1; w->current_time_index = current_cpu_time >> w->log2_clocks_per_bin; if (w->n_wheel_elt_time_bits <= 0 || w->n_wheel_elt_time_bits >= STRUCT_BITS_OF (timing_wheel_elt_t, cpu_time_relative_to_base)) w->n_wheel_elt_time_bits = STRUCT_BITS_OF (timing_wheel_elt_t, cpu_time_relative_to_base) - 1; w->cpu_time_base = current_cpu_time; w->time_index_next_cpu_time_base_update = w->current_time_index + ((u64) 1 << (w->n_wheel_elt_time_bits - w->log2_clocks_per_bin)); } always_inline uword get_level_and_relative_time (timing_wheel_t * w, u64 cpu_time, uword * rtime_result) { u64 dt, rtime; uword level_index; dt = (cpu_time >> w->log2_clocks_per_bin); /* Time should always move forward. */ ASSERT (dt >= w->current_time_index); dt -= w->current_time_index; /* Find level and offset within level. Level i has bins of size 2^((i+1)*M) */ rtime = dt; for (level_index = 0; (rtime >> w->log2_bins_per_wheel) != 0; level_index++) rtime = (rtime >> w->log2_bins_per_wheel) - 1; /* Return offset within level and level index. */ ASSERT (rtime < w->bins_per_wheel); *rtime_result = rtime; return level_index; } always_inline uword time_index_to_wheel_index (timing_wheel_t * w, uword level_index, u64 ti) { return (ti >> (level_index * w->log2_bins_per_wheel)) & w->bins_per_wheel_mask; } /* Find current time on this level. */ always_inline uword current_time_wheel_index (timing_wheel_t * w, uword level_index) { return time_index_to_wheel_index (w, level_index, w->current_time_index); } /* Circular wheel indexing. */ always_inline uword wheel_add (timing_wheel_t * w, word x) { return x & w->bins_per_wheel_mask; } always_inline uword rtime_to_wheel_index (timing_wheel_t * w, uword level_index, uword rtime) { uword t = current_time_wheel_index (w, level_index); return wheel_add (w, t + rtime); } static clib_error_t * validate_level (timing_wheel_t * w, uword level_index, uword * n_elts) { timing_wheel_level_t *level; timing_wheel_elt_t *e; uword wi; clib_error_t *error = 0; #define _(x) \ do { \ error = CLIB_ERROR_ASSERT (x); \ ASSERT (! error); \ if (error) return error; \ } while (0) level = vec_elt_at_index (w->levels, level_index); for (wi = 0; wi < vec_len (level->elts); wi++) { /* Validate occupancy bitmap. */ _(clib_bitmap_get_no_check (level->occupancy_bitmap, wi) == (vec_len (level->elts[wi]) > 0)); *n_elts += vec_len (level->elts[wi]); vec_foreach (e, level->elts[wi]) { /* Validate time bin and level. */ u64 e_time; uword e_ti, e_li, e_wi; e_time = e->cpu_time_relative_to_base + w->cpu_time_base; e_li = get_level_and_relative_time (w, e_time, &e_ti); e_wi = rtime_to_wheel_index (w, level_index, e_ti); if (e_li == level_index - 1) /* If this element was scheduled on the previous level it must be wrapped. */ _(e_ti + current_time_wheel_index (w, level_index - 1) >= w->bins_per_wheel); else { _(e_li == level_index); if (e_li == 0) _(e_wi == wi); else _(e_wi == wi || e_wi + 1 == wi || e_wi - 1 == wi); } } } #undef _ return error; } void timing_wheel_validate (timing_wheel_t * w) { uword l; clib_error_t *error = 0; uword n_elts; if (!w->validate) return; n_elts = pool_elts (w->overflow_pool); for (l = 0; l < vec_len (w->levels); l++) { error = validate_level (w, l, &n_elts); if (error) clib_error_report (error); } } always_inline void free_elt_vector (timing_wheel_t * w, timing_wheel_elt_t * ev) { /* Poison free elements so we never use them by mistake. */ if (CLIB_DEBUG > 0) clib_memset (ev, ~0, vec_len (ev) * sizeof (ev[0])); _vec_len (ev) = 0; vec_add1 (w->free_elt_vectors, ev); } static timing_wheel_elt_t * insert_helper (timing_wheel_t * w, uword level_index, uword rtime) { timing_wheel_level_t *level; timing_wheel_elt_t *e; uword wheel_index; /* Circular buffer. */ vec_validate (w->levels, level_index); level = vec_elt_at_index (w->levels, level_index); if (PREDICT_FALSE (!level->elts)) { uword max = w->bins_per_wheel - 1; clib_bitmap_validate (level->occupancy_bitmap, max); vec_validate (level->elts, max); } wheel_index = rtime_to_wheel_index (w, level_index, rtime); level->occupancy_bitmap = clib_bitmap_ori (level->occupancy_bitmap, wheel_index); /* Allocate an elt vector from free list if there is one. */ if (!level->elts[wheel_index] && vec_len (w->free_elt_vectors)) level->elts[wheel_index] = vec_pop (w->free_elt_vectors); /* Add element to vector for this time bin. */ vec_add2 (level->elts[wheel_index], e, 1); return e; } /* Insert user data on wheel at given CPU time stamp. */ static void timing_wheel_insert_helper (timing_wheel_t * w, u64 insert_cpu_time, u32 user_data) { timing_wheel_elt_t *e; u64 dt; uword rtime, level_index; level_index = get_level_and_relative_time (w, insert_cpu_time, &rtime); dt = insert_cpu_time - w->cpu_time_base; if (PREDICT_TRUE (0 == (dt >> BITS (e->cpu_time_relative_to_base)))) { e = insert_helper (w, level_index, rtime); e->user_data = user_data; e->cpu_time_relative_to_base = dt; if (insert_cpu_time < w->cached_min_cpu_time_on_wheel) w->cached_min_cpu_time_on_wheel = insert_cpu_time; } else { /* Time too far in the future: add to overflow vector. */ timing_wheel_overflow_elt_t *oe; pool_get (w->overflow_pool, oe); oe->user_data = user_data; oe->cpu_time = insert_cpu_time; } } always_inline uword elt_is_deleted (timing_wheel_t * w, u32 user_data) { return (hash_elts (w->deleted_user_data_hash) > 0 && hash_get (w->deleted_user_data_hash, user_data)); } static timing_wheel_elt_t * delete_user_data (timing_wheel_elt_t * elts, u32 user_data) { uword found_match; timing_wheel_elt_t *e, *new_elts; /* Quickly scan to see if there are any elements to delete in this bucket. */ found_match = 0; vec_foreach (e, elts) { found_match = e->user_data == user_data; if (found_match) break; } if (!found_match) return elts; /* Re-scan to build vector of new elts with matching user_data deleted. */ new_elts = 0; vec_foreach (e, elts) { if (e->user_data != user_data) vec_add1 (new_elts, e[0]); } vec_free (elts); return new_elts; } /* Insert user data on wheel at given CPU time stamp. */ void timing_wheel_insert (timing_wheel_t * w, u64 insert_cpu_time, u32 user_data) { /* Remove previously deleted elements. */ if (elt_is_deleted (w, user_data)) { timing_wheel_level_t *l; uword wi; /* Delete elts with given user data so that stale events don't expire. */ vec_foreach (l, w->levels) { /* *INDENT-OFF* */ clib_bitmap_foreach (wi, l->occupancy_bitmap, ({ l->elts[wi] = delete_user_data (l->elts[wi], user_data); if (vec_len (l->elts[wi]) == 0) l->occupancy_bitmap = clib_bitmap_andnoti (l->occupancy_bitmap, wi); })); /* *INDENT-ON* */ } { timing_wheel_overflow_elt_t *oe; /* *INDENT-OFF* */ pool_foreach (oe, w->overflow_pool, ({ if (oe->user_data == user_data) pool_put (w->overflow_pool, oe); })); /* *INDENT-ON* */ } hash_unset (w->deleted_user_data_hash, user_data); } timing_wheel_insert_helper (w, insert_cpu_time, user_data); } void timing_wheel_delete (timing_wheel_t * w, u32 user_data) { if (!w->deleted_user_data_hash) w->deleted_user_data_hash = hash_create ( /* capacity */ 0, /* value bytes */ 0); hash_set1 (w->deleted_user_data_hash, user_data); } /* Returns time of next expiring element. */ u64 timing_wheel_next_expiring_elt_time (timing_wheel_t * w) { timing_wheel_level_t *l; timing_wheel_elt_t *e; uword li, wi, wi0; u32 min_dt; u64 min_t; uword wrapped = 0; min_dt = ~0; min_t = ~0ULL; vec_foreach (l, w->levels) { if (!l->occupancy_bitmap) continue; li = l - w->levels; wi0 = wi = current_time_wheel_index (w, li); wrapped = 0; while (1) { if (clib_bitmap_get_no_check (l->occupancy_bitmap, wi)) { vec_foreach (e, l->elts[wi]) min_dt = clib_min (min_dt, e->cpu_time_relative_to_base); if (wrapped && li + 1 < vec_len (w->levels)) { uword wi1 = current_time_wheel_index (w, li + 1); if (l[1].occupancy_bitmap && clib_bitmap_get_no_check (l[1].occupancy_bitmap, wi1)) { vec_foreach (e, l[1].elts[wi1]) { min_dt = clib_min (min_dt, e->cpu_time_relative_to_base); } } } min_t = w->cpu_time_base + min_dt; goto done; } wi = wheel_add (w, wi + 1); if (wi == wi0) break; wrapped = wi != wi + 1; } } { timing_wheel_overflow_elt_t *oe; if (min_dt != ~0) min_t = w->cpu_time_base + min_dt; /* *INDENT-OFF* */ pool_foreach (oe, w->overflow_pool, ({ min_t = clib_min (min_t, oe->cpu_time); })); /* *INDENT-ON* */ done: return min_t; } } static inline void insert_elt (timing_wheel_t * w, timing_wheel_elt_t * e) { u64 t = w->cpu_time_base + e->cpu_time_relative_to_base; timing_wheel_insert_helper (w, t, e->user_data); } always_inline u64 elt_cpu_time (timing_wheel_t * w, timing_wheel_elt_t * e) { return w->cpu_time_base + e->cpu_time_relative_to_base; } always_inline void validate_expired_elt (timing_wheel_t * w, timing_wheel_elt_t * e, u64 current_cpu_time) { if (CLIB_DEBUG > 0) { u64 e_time = elt_cpu_time (w, e); /* Verify that element is actually expired. */ ASSERT ((e_time >> w->log2_clocks_per_bin) <= (current_cpu_time >> w->log2_clocks_per_bin)); } } static u32 * expire_bin (timing_wheel_t * w, uword level_index, uword wheel_index, u64 advance_cpu_time, u32 * expired_user_data) { timing_wheel_level_t *level = vec_elt_at_index (w->levels, level_index); timing_wheel_elt_t *e; u32 *x; uword i, j, e_len; e = vec_elt (level->elts, wheel_index); e_len = vec_len (e); vec_add2 (expired_user_data, x, e_len); for (i = j = 0; i < e_len; i++) { validate_expired_elt (w, &e[i], advance_cpu_time); x[j] = e[i].user_data; /* Only advance if elt is not to be deleted. */ j += !elt_is_deleted (w, e[i].user_data); } /* Adjust for deleted elts. */ if (j < e_len) _vec_len (expired_user_data) -= e_len - j; free_elt_vector (w, e); level->elts[wheel_index] = 0; clib_bitmap_set_no_check (level->occupancy_bitmap, wheel_index, 0); return expired_user_data; } /* Called rarely. 32 bit times should only overflow every 4 seconds or so on a fast machine. */ static u32 * advance_cpu_time_base (timing_wheel_t * w, u32 * expired_user_data) { timing_wheel_level_t *l; timing_wheel_elt_t *e; u64 delta; w->stats.cpu_time_base_advances++; delta = ((u64) 1 << w->n_wheel_elt_time_bits); w->cpu_time_base += delta; w->time_index_next_cpu_time_base_update += delta >> w->log2_clocks_per_bin; vec_foreach (l, w->levels) { uword wi; /* *INDENT-OFF* */ clib_bitmap_foreach (wi, l->occupancy_bitmap, ({ vec_foreach (e, l->elts[wi]) { /* This should always be true since otherwise we would have already expired this element. Note that in the second half of this function we need to take care not to place the expired elements ourselves. */ ASSERT (e->cpu_time_relative_to_base >= delta); e->cpu_time_relative_to_base -= delta; } })); /* *INDENT-ON* */ } /* See which overflow elements fit now. */ { timing_wheel_overflow_elt_t *oe; /* *INDENT-OFF* */ pool_foreach (oe, w->overflow_pool, ({ /* It fits now into 32 bits. */ if (0 == ((oe->cpu_time - w->cpu_time_base) >> BITS (e->cpu_time_relative_to_base))) { u64 ti = oe->cpu_time >> w->log2_clocks_per_bin; if (ti <= w->current_time_index) { /* This can happen when timing wheel is not advanced for a long time (for example when at a gdb breakpoint for a while). */ /* Note: the ti == w->current_time_index means it is also an expired timer */ if (! elt_is_deleted (w, oe->user_data)) vec_add1 (expired_user_data, oe->user_data); } else timing_wheel_insert_helper (w, oe->cpu_time, oe->user_data); pool_put (w->overflow_pool, oe); } })); /* *INDENT-ON* */ } return expired_user_data; } static u32 * refill_level (timing_wheel_t * w, uword level_index, u64 advance_cpu_time, uword from_wheel_index, uword to_wheel_index, u32 * expired_user_data) { timing_wheel_level_t *level; timing_wheel_elt_t *to_insert = w->unexpired_elts_pending_insert; u64 advance_time_index = advance_cpu_time >> w->log2_clocks_per_bin; vec_validate (w->stats.refills, level_index); w->stats.refills[level_index] += 1; if (level_index + 1 >= vec_len (w->levels)) goto done; level = vec_elt_at_index (w->levels, level_index + 1); if (!level->occupancy_bitmap) goto done; while (1) { timing_wheel_elt_t *e, *es; if (clib_bitmap_get_no_check (level->occupancy_bitmap, from_wheel_index)) { es = level->elts[from_wheel_index]; level->elts[from_wheel_index] = 0; clib_bitmap_set_no_check (level->occupancy_bitmap, from_wheel_index, 0); vec_foreach (e, es) { u64 e_time = elt_cpu_time (w, e); u64 ti = e_time >> w->log2_clocks_per_bin; if (ti <= advance_time_index) { validate_expired_elt (w, e, advance_cpu_time); if (!elt_is_deleted (w, e->user_data)) vec_add1 (expired_user_data, e->user_data); } else vec_add1 (to_insert, e[0]); } free_elt_vector (w, es); } if (from_wheel_index == to_wheel_index) break; from_wheel_index = wheel_add (w, from_wheel_index + 1); } timing_wheel_validate (w); done: w->unexpired_elts_pending_insert = to_insert; return expired_user_data; } /* Advance wheel and return any expired user data in vector. */ u32 * timing_wheel_advance (timing_wheel_t * w, u64 advance_cpu_time, u32 * expired_user_data, u64 * next_expiring_element_cpu_time) { timing_wheel_level_t *level; uword level_index, advance_rtime, advance_level_index, advance_wheel_index; uword n_expired_user_data_before; u64 current_time_index, advance_time_index; n_expired_user_data_before = vec_len (expired_user_data); /* Re-fill lower levels when time wraps. */ current_time_index = w->current_time_index; advance_time_index = advance_cpu_time >> w->log2_clocks_per_bin; { u64 current_ti, advance_ti; current_ti = current_time_index >> w->log2_bins_per_wheel; advance_ti = advance_time_index >> w->log2_bins_per_wheel; if (PREDICT_FALSE (current_ti != advance_ti)) { if (w->unexpired_elts_pending_insert) _vec_len (w->unexpired_elts_pending_insert) = 0; level_index = 0; while (current_ti != advance_ti) { uword c, a; c = current_ti & (w->bins_per_wheel - 1); a = advance_ti & (w->bins_per_wheel - 1); if (c != a) expired_user_data = refill_level (w, level_index, advance_cpu_time, c, a, expired_user_data); current_ti >>= w->log2_bins_per_wheel; advance_ti >>= w->log2_bins_per_wheel; level_index++; } } } advance_level_index = get_level_and_relative_time (w, advance_cpu_time, &advance_rtime); advance_wheel_index = rtime_to_wheel_index (w, advance_level_index, advance_rtime); /* Empty all occupied bins for entire levels that we advance past. */ for (level_index = 0; level_index < advance_level_index; level_index++) { uword wi; if (level_index >= vec_len (w->levels)) break; level = vec_elt_at_index (w->levels, level_index); /* *INDENT-OFF* */ clib_bitmap_foreach (wi, level->occupancy_bitmap, ({ expired_user_data = expire_bin (w, level_index, wi, advance_cpu_time, expired_user_data); })); /* *INDENT-ON* */ } if (PREDICT_TRUE (level_index < vec_len (w->levels))) { uword wi; level = vec_elt_at_index (w->levels, level_index); wi = current_time_wheel_index (w, level_index); if (level->occupancy_bitmap) while (1) { if (clib_bitmap_get_no_check (level->occupancy_bitmap, wi)) expired_user_data = expire_bin (w, advance_level_index, wi, advance_cpu_time, expired_user_data); /* When we jump out, we have already just expired the bin, corresponding to advance_wheel_index */ if (wi == advance_wheel_index) break; wi = wheel_add (w, wi + 1); } } /* Advance current time index. */ w->current_time_index = advance_time_index; if (vec_len (w->unexpired_elts_pending_insert) > 0) { timing_wheel_elt_t *e; vec_foreach (e, w->unexpired_elts_pending_insert) insert_elt (w, e); _vec_len (w->unexpired_elts_pending_insert) = 0; } /* Don't advance until necessary. */ /* However, if the timing_wheel_advance() hasn't been called for some time, the while() loop will ensure multiple calls to advance_cpu_time_base() in a row until the w->cpu_time_base is fresh enough. */ while (PREDICT_FALSE (advance_time_index >= w->time_index_next_cpu_time_base_update)) expired_user_data = advance_cpu_time_base (w, expired_user_data); if (next_expiring_element_cpu_time) { u64 min_t; /* Anything expired? If so we need to recompute next expiring elt time. */ if (vec_len (expired_user_data) == n_expired_user_data_before && w->cached_min_cpu_time_on_wheel != 0ULL) min_t = w->cached_min_cpu_time_on_wheel; else { min_t = timing_wheel_next_expiring_elt_time (w); w->cached_min_cpu_time_on_wheel = min_t; } *next_expiring_element_cpu_time = min_t; } return expired_user_data; } u8 * format_timing_wheel (u8 * s, va_list * va) { timing_wheel_t *w = va_arg (*va, timing_wheel_t *); int verbose = va_arg (*va, int); u32 indent = format_get_indent (s); s = format (s, "level 0: %.4e - %.4e secs, 2^%d - 2^%d clocks", (f64) (1 << w->log2_clocks_per_bin) / w->cpu_clocks_per_second, (f64) (1 << w->log2_clocks_per_wheel) / w->cpu_clocks_per_second, w->log2_clocks_per_bin, w->log2_clocks_per_wheel); if (verbose) { int l; s = format (s, "\n%Utime base advances %Ld, every %.4e secs", format_white_space, indent + 2, w->stats.cpu_time_base_advances, (f64) ((u64) 1 << w->n_wheel_elt_time_bits) / w->cpu_clocks_per_second); for (l = 0; l < vec_len (w->levels); l++) s = format (s, "\n%Ulevel %d: refills %Ld", format_white_space, indent + 2, l, l < vec_len (w->stats.refills) ? w->stats. refills[l] : (u64) 0); } return s; } /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */


context:
space:
mode: