summaryrefslogtreecommitdiffstats
path: root/src/plugins/lb/util.c
blob: d969d168dce589e54c6d57ce50627c295400efa1 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
/*
 * Copyright (c) 2016 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 <lb/util.h>

void ip46_prefix_normalize(ip46_address_t *prefix, u8 plen)
{
  if (plen == 0) {
    prefix->as_u64[0] = 0;
    prefix->as_u64[1] = 0;
  } else if (plen <= 64) {
    prefix->as_u64[0] &= clib_host_to_net_u64(0xffffffffffffffffL << (64 - plen));
    prefix->as_u64[1] = 0;
  } else {
    prefix->as_u64[1] &= clib_host_to_net_u64(0xffffffffffffffffL << (128 - plen));
  }

}

uword unformat_ip46_prefix (unformat_input_t * input, va_list * args)
{
  ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
  u8 *len = va_arg (*args, u8 *);
  ip46_type_t type = va_arg (*args, ip46_type_t);

  u32 l;
  if ((type != IP46_TYPE_IP6) && unformat(input, "%U/%u", unformat_ip4_address, &ip46->ip4, &l)) {
    if (l > 32)
      return 0;
    *len = l + 96;
    ip46->pad[0] = ip46->pad[1] = ip46->pad[2] = 0;
  } else if ((type != IP46_TYPE_IP4) && unformat(input, "%U/%u", unformat_ip6_address, &ip46->ip6, &l)) {
    if (l > 128)
      return 0;
    *len = l;
  } else {
    return 0;
  }
  return 1;
}

u8 *format_ip46_prefix (u8 * s, va_list * args)
{
  ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
  u32 len = va_arg (*args, u32); //va_arg cannot use u8 or u16
  ip46_type_t type = va_arg (*args, ip46_type_t);

  int is_ip4 = 0;
  if (type == IP46_TYPE_IP4)
    is_ip4 = 1;
  else if (type == IP46_TYPE_IP6)
    is_ip4 = 0;
  else
    is_ip4 = (len >= 96) && ip46_address_is_ip4(ip46);

  return is_ip4 ?
      format(s, "%U/%d", format_ip4_address, &ip46->ip4, len - 96):
      format(s, "%U/%d", format_ip6_address, &ip46->ip6, len);
}
>counter_t **counters; /**< Per-thread u64 non-atomic counters */ counter_t *value_at_last_serialize; /**< Values as of last serialize. */ u32 last_incremental_serialize_index; /**< Last counter index serialized incrementally. */ char *name; /**< The counter collection's name. */ char *stat_segment_name; /**< Name in stat segment directory */ } vlib_simple_counter_main_t; /** The number of counters (not the number of per-thread counters) */ u32 vlib_simple_counter_n_counters (const vlib_simple_counter_main_t * cm); /** Increment a simple counter @param cm - (vlib_simple_counter_main_t *) simple counter main pointer @param thread_index - (u32) the current cpu index @param index - (u32) index of the counter to increment @param increment - (u64) quantitiy to add to the counter */ always_inline void vlib_increment_simple_counter (vlib_simple_counter_main_t * cm, u32 thread_index, u32 index, u64 increment) { counter_t *my_counters; my_counters = cm->counters[thread_index]; my_counters[index] += increment; } /** Set a simple counter @param cm - (vlib_simple_counter_main_t *) simple counter main pointer @param thread_index - (u32) the current cpu index @param index - (u32) index of the counter to increment @param value - (u64) quantitiy to set to the counter */ always_inline void vlib_set_simple_counter (vlib_simple_counter_main_t * cm, u32 thread_index, u32 index, u64 value) { counter_t *my_counters; my_counters = cm->counters[thread_index]; my_counters[index] = value; } /** Get the value of a simple counter Scrapes the entire set of per-thread counters. Innacurate unless worker threads which might increment the counter are barrier-synchronized @param cm - (vlib_simple_counter_main_t *) simple counter main pointer @param index - (u32) index of the counter to fetch @returns - (u64) current counter value */ always_inline counter_t vlib_get_simple_counter (vlib_simple_counter_main_t * cm, u32 index) { counter_t *my_counters; counter_t v; int i; ASSERT (index < vlib_simple_counter_n_counters (cm)); v = 0; for (i = 0; i < vec_len (cm->counters); i++) { my_counters = cm->counters[i]; v += my_counters[index]; } return v; } /** Clear a simple counter Clears the set of per-thread u16 counters, and the u64 counter @param cm - (vlib_simple_counter_main_t *) simple counter main pointer @param index - (u32) index of the counter to clear */ always_inline void vlib_zero_simple_counter (vlib_simple_counter_main_t * cm, u32 index) { counter_t *my_counters; int i; ASSERT (index < vlib_simple_counter_n_counters (cm)); for (i = 0; i < vec_len (cm->counters); i++) { my_counters = cm->counters[i]; my_counters[index] = 0; } } /** Add two combined counters, results in the first counter @param [in,out] a - (vlib_counter_t *) dst counter @param b - (vlib_counter_t *) src counter */ always_inline void vlib_counter_add (vlib_counter_t * a, vlib_counter_t * b) { a->packets += b->packets; a->bytes += b->bytes; } /** Subtract combined counters, results in the first counter @param [in,out] a - (vlib_counter_t *) dst counter @param b - (vlib_counter_t *) src counter */ always_inline void vlib_counter_sub (vlib_counter_t * a, vlib_counter_t * b) { ASSERT (a->packets >= b->packets); ASSERT (a->bytes >= b->bytes); a->packets -= b->packets; a->bytes -= b->bytes; } /** Clear a combined counter @param a - (vlib_counter_t *) counter to clear */ always_inline void vlib_counter_zero (vlib_counter_t * a) { a->packets = a->bytes = 0; } /** A collection of combined counters */ typedef struct { vlib_counter_t **counters; /**< Per-thread u64 non-atomic counter pairs */ vlib_counter_t *value_at_last_serialize; /**< Counter values as of last serialize. */ u32 last_incremental_serialize_index; /**< Last counter index serialized incrementally. */ char *name; /**< The counter collection's name. */ char *stat_segment_name; /**< Name in stat segment directory */ } vlib_combined_counter_main_t; /** The number of counters (not the number of per-thread counters) */ u32 vlib_combined_counter_n_counters (const vlib_combined_counter_main_t * cm); /** Clear a collection of simple counters @param cm - (vlib_simple_counter_main_t *) collection to clear */ void vlib_clear_simple_counters (vlib_simple_counter_main_t * cm); /** Clear a collection of combined counters @param cm - (vlib_combined_counter_main_t *) collection to clear */ void vlib_clear_combined_counters (vlib_combined_counter_main_t * cm); /** Increment a combined counter @param cm - (vlib_combined_counter_main_t *) comined counter main pointer @param thread_index - (u32) the current cpu index @param index - (u32) index of the counter to increment @param packet_increment - (u64) number of packets to add to the counter @param byte_increment - (u64) number of bytes to add to the counter */ always_inline void vlib_increment_combined_counter (vlib_combined_counter_main_t * cm, u32 thread_index, u32 index, u64 n_packets, u64 n_bytes) { vlib_counter_t *my_counters; /* Use this CPU's counter array */ my_counters = cm->counters[thread_index]; my_counters[index].packets += n_packets; my_counters[index].bytes += n_bytes; } /** Pre-fetch a per-thread combined counter for the given object index */ always_inline void vlib_prefetch_combined_counter (const vlib_combined_counter_main_t * cm, u32 thread_index, u32 index) { vlib_counter_t *cpu_counters; /* * This CPU's index is assumed to already be in cache */ cpu_counters = cm->counters[thread_index]; CLIB_PREFETCH (cpu_counters + index, CLIB_CACHE_LINE_BYTES, STORE); } /** Get the value of a combined counter, never called in the speed path Scrapes the entire set of per-thread counters. Innacurate unless worker threads which might increment the counter are barrier-synchronized @param cm - (vlib_combined_counter_main_t *) combined counter main pointer @param index - (u32) index of the combined counter to fetch @param result [out] - (vlib_counter_t *) result stored here */ static inline void vlib_get_combined_counter (const vlib_combined_counter_main_t * cm, u32 index, vlib_counter_t * result) { vlib_counter_t *my_counters, *counter; int i; result->packets = 0; result->bytes = 0; for (i = 0; i < vec_len (cm->counters); i++) { my_counters = cm->counters[i]; counter = vec_elt_at_index (my_counters, index); result->packets += counter->packets; result->bytes += counter->bytes; } } /** Clear a combined counter Clears the set of per-thread counters. @param cm - (vlib_combined_counter_main_t *) combined counter main pointer @param index - (u32) index of the counter to clear */ always_inline void vlib_zero_combined_counter (vlib_combined_counter_main_t * cm, u32 index) { vlib_counter_t *my_counters, *counter; int i; for (i = 0; i < vec_len (cm->counters); i++) { my_counters = cm->counters[i]; counter = vec_elt_at_index (my_counters, index); counter->packets = 0; counter->bytes = 0; } } /** validate a simple counter @param cm - (vlib_simple_counter_main_t *) pointer to the counter collection @param index - (u32) index of the counter to validate */ void vlib_validate_simple_counter (vlib_simple_counter_main_t * cm, u32 index); /** validate a combined counter @param cm - (vlib_combined_counter_main_t *) pointer to the counter collection @param index - (u32) index of the counter to validate */ void vlib_validate_combined_counter (vlib_combined_counter_main_t * cm, u32 index); /** Obtain the number of simple or combined counters allocated. A macro which reduces to to vec_len(cm->maxi), the answer in either case. @param cm - (vlib_simple_counter_main_t) or (vlib_combined_counter_main_t) the counter collection to interrogate @returns vec_len(cm->maxi) */ #define vlib_counter_len(cm) vec_len((cm)->maxi) serialize_function_t serialize_vlib_simple_counter_main, unserialize_vlib_simple_counter_main; serialize_function_t serialize_vlib_combined_counter_main, unserialize_vlib_combined_counter_main; #endif /* included_vlib_counter_h */ /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */