FD.io VPP  v18.10-34-gcce845e
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 
36 typedef enum
37 {
38 #define _(sym,str) NAT44_HANDOFF_ERROR_##sym,
40 #undef _
43 
44 static char *nat44_handoff_error_strings[] = {
45 #define _(sym,string) string,
47 #undef _
48 };
49 
50 
54 
55 static u8 *
56 format_nat44_handoff_trace (u8 * s, va_list * args)
57 {
58  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
59  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
60  nat44_handoff_trace_t *t = va_arg (*args, nat44_handoff_trace_t *);
61  char *tag;
62 
63  tag = t->in2out ? "IN2OUT" : "OUT2IN";
64  s =
65  format (s, "NAT44_%s_WORKER_HANDOFF: next-worker %d", tag,
67 
68  return s;
69 }
70 
71 static inline uword
73  vlib_frame_t * frame, u8 is_output,
74  u8 is_in2out)
75 {
76  snat_main_t *sm = &snat_main;
77  vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
78  u32 n_enq, n_left_from, *from;
79  u16 thread_indices[VLIB_FRAME_SIZE], *ti;
80  u32 fq_index;
81  snat_get_worker_function_t *get_worker;
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 
118  && (b[0]->flags & VLIB_BUFFER_IS_TRACED)))
119  {
121  vlib_add_trace (vm, node, b[0], sizeof (*t));
122  t->next_worker_index = ti[0];
123  t->in2out = is_in2out;
124  }
125 
126  n_left_from -= 1;
127  ti += 1;
128  b += 1;
129  }
130 
131  n_enq =
132  vlib_buffer_enqueue_to_thread (vm, fq_index, from, thread_indices,
133  frame->n_vectors, 1);
134 
135  if (n_enq < frame->n_vectors)
137  NAT44_HANDOFF_ERROR_CONGESTION_DROP,
138  frame->n_vectors - n_enq);
139  return frame->n_vectors;
140 }
141 
142 static uword
144  vlib_node_runtime_t * node,
145  vlib_frame_t * frame)
146 {
147  return nat44_worker_handoff_fn_inline (vm, node, frame, 0, 1);
148 }
149 
150 /* *INDENT-OFF* */
152  .function = snat_in2out_worker_handoff_fn,
153  .name = "nat44-in2out-worker-handoff",
154  .vector_size = sizeof (u32),
155  .format_trace = format_nat44_handoff_trace,
156  .type = VLIB_NODE_TYPE_INTERNAL,
158  .error_strings = nat44_handoff_error_strings,
159  .n_next_nodes = 1,
160  .next_nodes = {
161  [0] = "error-drop",
162  },
163 };
164 /* *INDENT-ON* */
165 
168 
169 static uword
171  vlib_node_runtime_t * node,
172  vlib_frame_t * frame)
173 {
174  return nat44_worker_handoff_fn_inline (vm, node, frame, 1, 1);
175 }
176 
177 /* *INDENT-OFF* */
180  .name = "nat44-in2out-output-worker-handoff",
181  .vector_size = sizeof (u32),
182  .format_trace = format_nat44_handoff_trace,
183  .type = VLIB_NODE_TYPE_INTERNAL,
185  .error_strings = nat44_handoff_error_strings,
186  .n_next_nodes = 1,
187  .next_nodes = {
188  [0] = "error-drop",
189  },
190 };
191 /* *INDENT-ON* */
192 
195 
196 static uword
198  vlib_node_runtime_t * node,
199  vlib_frame_t * frame)
200 {
201  return nat44_worker_handoff_fn_inline (vm, node, frame, 0, 0);
202 }
203 
204 /* *INDENT-OFF* */
206  .function = snat_out2in_worker_handoff_fn,
207  .name = "nat44-out2in-worker-handoff",
208  .vector_size = sizeof (u32),
209  .format_trace = format_nat44_handoff_trace,
210  .type = VLIB_NODE_TYPE_INTERNAL,
212  .error_strings = nat44_handoff_error_strings,
213  .n_next_nodes = 1,
214  .next_nodes = {
215  [0] = "error-drop",
216  },
217 };
218 /* *INDENT-ON* */
219 
222 
223 /*
224  * fd.io coding-style-patch-verification: ON
225  *
226  * Local Variables:
227  * eval: (c-set-style "gnu")
228  * End:
229  */
#define CLIB_UNUSED(x)
Definition: clib.h:81
static char * nat44_handoff_error_strings[]
Definition: nat44_handoff.c:44
#define foreach_nat44_handoff_error
Definition: nat44_handoff.c:33
static uword snat_in2out_worker_handoff_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
u32 fq_in2out_output_index
Definition: nat.h:490
vlib_node_registration_t snat_in2out_worker_handoff_node
(constructor) VLIB_REGISTER_NODE (snat_in2out_worker_handoff_node)
Definition: nat44_handoff.c:51
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
unsigned char u8
Definition: types.h:56
u32( snat_get_worker_function_t)(ip4_header_t *ip, u32 rx_fib_index)
Definition: nat.h:415
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:382
unsigned short u16
Definition: types.h:57
nat44_handoff_error_t
Definition: nat44_handoff.c:36
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:205
VLIB_NODE_FUNCTION_MULTIARCH(snat_in2out_worker_handoff_node, snat_in2out_worker_handoff_fn)
#define PREDICT_FALSE(x)
Definition: clib.h:107
u32 node_index
Node index.
Definition: node.h:494
static uword snat_in2out_output_worker_handoff_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
Definition: node_funcs.h:1176
u32 fq_out2in_index
Definition: nat.h:491
snat_main_t snat_main
Definition: nat.c:37
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:155
u16 n_vectors
Definition: node.h:401
vlib_main_t * vm
Definition: buffer.c:294
snat_get_worker_function_t * worker_in2out_cb
Definition: nat.h:437
#define ARRAY_LEN(x)
Definition: clib.h:61
#define ASSERT(truth)
snat_get_worker_function_t * worker_out2in_cb
Definition: nat.h:438
u32 fq_in2out_index
Definition: nat.h:489
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:72
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
struct _vlib_node_registration vlib_node_registration_t
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u32 * workers
Definition: nat.h:436
u64 uword
Definition: types.h:112
static uword snat_out2in_worker_handoff_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:267
vlib_node_registration_t snat_out2in_worker_handoff_node
(constructor) VLIB_REGISTER_NODE (snat_out2in_worker_handoff_node)
Definition: nat44_handoff.c:53
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:452
#define vnet_buffer(b)
Definition: buffer.h:344
vlib_node_registration_t snat_in2out_output_worker_handoff_node
(constructor) VLIB_REGISTER_NODE (snat_in2out_output_worker_handoff_node)
Definition: nat44_handoff.c:52
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:56
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:141
#define VLIB_NODE_FLAG_TRACE
Definition: node.h:310
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:116
Definition: defs.h:46