FD.io VPP  v19.04.4-rc0-5-ge88582fac
Vector Packet Processing
nat44_handoff.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2018 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  * @file
17  * @brief NAT44 worker handoff
18  */
19 
20 #include <vlib/vlib.h>
21 #include <vnet/vnet.h>
22 #include <vnet/handoff.h>
23 #include <vnet/fib/ip4_fib.h>
24 #include <vppinfra/error.h>
25 #include <nat/nat.h>
26 
27 typedef struct
28 {
32 
33 #define foreach_nat44_handoff_error \
34 _(CONGESTION_DROP, "congestion drop") \
35 _(SAME_WORKER, "same worker") \
36 _(DO_HANDOFF, "do handoff")
37 
38 typedef enum
39 {
40 #define _(sym,str) NAT44_HANDOFF_ERROR_##sym,
42 #undef _
45 
46 static char *nat44_handoff_error_strings[] = {
47 #define _(sym,string) string,
49 #undef _
50 };
51 
52 
53 static u8 *
54 format_nat44_handoff_trace (u8 * s, va_list * args)
55 {
56  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
57  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
58  nat44_handoff_trace_t *t = va_arg (*args, nat44_handoff_trace_t *);
59  char *tag;
60 
61  tag = t->in2out ? "IN2OUT" : "OUT2IN";
62  s =
63  format (s, "NAT44_%s_WORKER_HANDOFF: next-worker %d", tag,
65 
66  return s;
67 }
68 
69 static inline uword
71  vlib_frame_t * frame, u8 is_output,
72  u8 is_in2out)
73 {
74  snat_main_t *sm = &snat_main;
75  vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
76  u32 n_enq, n_left_from, *from;
77  u16 thread_indices[VLIB_FRAME_SIZE], *ti;
78  u32 fq_index;
79  snat_get_worker_function_t *get_worker;
80  u32 thread_index = vm->thread_index;
81  u32 do_handoff = 0, same_worker = 0;
82 
83  from = vlib_frame_vector_args (frame);
84  n_left_from = frame->n_vectors;
85  vlib_get_buffers (vm, from, bufs, n_left_from);
86 
87  b = bufs;
88  ti = thread_indices;
89 
90  ASSERT (vec_len (sm->workers));
91 
92  if (is_in2out)
93  {
94  get_worker = sm->worker_in2out_cb;
95  if (is_output)
96  fq_index = sm->fq_in2out_output_index;
97  else
98  fq_index = sm->fq_in2out_index;
99  }
100  else
101  {
102  fq_index = sm->fq_out2in_index;
103  get_worker = sm->worker_out2in_cb;
104  }
105 
106  while (n_left_from > 0)
107  {
108  u32 sw_if_index0;
109  u32 rx_fib_index0;
110  ip4_header_t *ip0;
111 
112  sw_if_index0 = vnet_buffer (b[0])->sw_if_index[VLIB_RX];
113  rx_fib_index0 = ip4_fib_table_get_index_for_sw_if_index (sw_if_index0);
114  ip0 = vlib_buffer_get_current (b[0]);
115  ti[0] = get_worker (ip0, rx_fib_index0);
116 
117  if (ti[0] != thread_index)
118  do_handoff++;
119  else
120  same_worker++;
121 
123  && (b[0]->flags & VLIB_BUFFER_IS_TRACED)))
124  {
126  vlib_add_trace (vm, node, b[0], sizeof (*t));
127  t->next_worker_index = ti[0];
128  t->in2out = is_in2out;
129  }
130 
131  n_left_from -= 1;
132  ti += 1;
133  b += 1;
134  }
135 
136  n_enq =
137  vlib_buffer_enqueue_to_thread (vm, fq_index, from, thread_indices,
138  frame->n_vectors, 1);
139 
140  if (n_enq < frame->n_vectors)
142  NAT44_HANDOFF_ERROR_CONGESTION_DROP,
143  frame->n_vectors - n_enq);
145  NAT44_HANDOFF_ERROR_SAME_WORKER, same_worker);
147  NAT44_HANDOFF_ERROR_DO_HANDOFF, do_handoff);
148  return frame->n_vectors;
149 }
150 
152  vlib_node_runtime_t * node,
153  vlib_frame_t * frame)
154 {
155  return nat44_worker_handoff_fn_inline (vm, node, frame, 0, 1);
156 }
157 
158 /* *INDENT-OFF* */
160  .name = "nat44-in2out-worker-handoff",
161  .vector_size = sizeof (u32),
162  .format_trace = format_nat44_handoff_trace,
163  .type = VLIB_NODE_TYPE_INTERNAL,
165  .error_strings = nat44_handoff_error_strings,
166  .n_next_nodes = 1,
167  .next_nodes = {
168  [0] = "error-drop",
169  },
170 };
171 /* *INDENT-ON* */
172 
175  node,
176  vlib_frame_t * frame)
177 {
178  return nat44_worker_handoff_fn_inline (vm, node, frame, 1, 1);
179 }
180 
181 /* *INDENT-OFF* */
183  .name = "nat44-in2out-output-worker-handoff",
184  .vector_size = sizeof (u32),
185  .format_trace = format_nat44_handoff_trace,
186  .type = VLIB_NODE_TYPE_INTERNAL,
188  .error_strings = nat44_handoff_error_strings,
189  .n_next_nodes = 1,
190  .next_nodes = {
191  [0] = "error-drop",
192  },
193 };
194 /* *INDENT-ON* */
195 
197  vlib_node_runtime_t * node,
198  vlib_frame_t * frame)
199 {
200  return nat44_worker_handoff_fn_inline (vm, node, frame, 0, 0);
201 }
202 
203 /* *INDENT-OFF* */
205  .name = "nat44-out2in-worker-handoff",
206  .vector_size = sizeof (u32),
207  .format_trace = format_nat44_handoff_trace,
208  .type = VLIB_NODE_TYPE_INTERNAL,
210  .error_strings = nat44_handoff_error_strings,
211  .n_next_nodes = 1,
212  .next_nodes = {
213  [0] = "error-drop",
214  },
215 };
216 /* *INDENT-ON* */
217 
218 /*
219  * fd.io coding-style-patch-verification: ON
220  *
221  * Local Variables:
222  * eval: (c-set-style "gnu")
223  * End:
224  */
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:124
#define CLIB_UNUSED(x)
Definition: clib.h:82
static char * nat44_handoff_error_strings[]
Definition: nat44_handoff.c:46
#define foreach_nat44_handoff_error
Definition: nat44_handoff.c:33
u32 fq_in2out_output_index
Definition: nat.h:496
u32 thread_index
Definition: main.h:197
vlib_node_registration_t snat_in2out_worker_handoff_node
(constructor) VLIB_REGISTER_NODE (snat_in2out_worker_handoff_node)
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
#define VLIB_NODE_FN(node)
Definition: node.h:201
unsigned char u8
Definition: types.h:56
u32 ip4_fib_table_get_index_for_sw_if_index(u32 sw_if_index)
Definition: ip4_fib.c:224
unsigned int u32
Definition: types.h:88
#define VLIB_FRAME_SIZE
Definition: node.h:376
unsigned short u16
Definition: types.h:57
nat44_handoff_error_t
Definition: nat44_handoff.c:38
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:229
#define PREDICT_FALSE(x)
Definition: clib.h:111
u32() snat_get_worker_function_t(ip4_header_t *ip, u32 rx_fib_index)
Definition: nat.h:421
u32 node_index
Node index.
Definition: node.h:494
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
Definition: node_funcs.h:1150
u32 fq_out2in_index
Definition: nat.h:497
snat_main_t snat_main
Definition: nat.c:39
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
u16 n_vectors
Definition: node.h:395
vlib_main_t * vm
Definition: buffer.c:312
snat_get_worker_function_t * worker_in2out_cb
Definition: nat.h:443
#define ARRAY_LEN(x)
Definition: clib.h:62
#define ASSERT(truth)
snat_get_worker_function_t * worker_out2in_cb
Definition: nat.h:444
u32 fq_in2out_index
Definition: nat.h:495
static uword nat44_worker_handoff_fn_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, u8 is_output, u8 is_in2out)
Definition: nat44_handoff.c:70
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace_funcs.h:57
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
VLIB buffer representation.
Definition: buffer.h:102
u32 * workers
Definition: nat.h:442
u64 uword
Definition: types.h:112
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:244
vlib_node_registration_t snat_out2in_worker_handoff_node
(constructor) VLIB_REGISTER_NODE (snat_out2in_worker_handoff_node)
static_always_inline u32 vlib_buffer_enqueue_to_thread(vlib_main_t *vm, u32 frame_queue_index, u32 *buffer_indices, u16 *thread_indices, u32 n_packets, int drop_on_congestion)
Definition: buffer_node.h:487
#define vnet_buffer(b)
Definition: buffer.h:369
vlib_node_registration_t snat_in2out_output_worker_handoff_node
(constructor) VLIB_REGISTER_NODE (snat_in2out_output_worker_handoff_node)
u16 flags
Copy of main node flags.
Definition: node.h:507
static u8 * format_nat44_handoff_trace(u8 *s, va_list *args)
Definition: nat44_handoff.c:54
static_always_inline void vlib_get_buffers(vlib_main_t *vm, u32 *bi, vlib_buffer_t **b, int count)
Translate array of buffer indices into buffer pointers.
Definition: buffer_funcs.h:244
#define VLIB_NODE_FLAG_TRACE
Definition: node.h:301
Definition: defs.h:46