FD.io VPP  v17.10-9-gd594711
Vector Packet Processing
input.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 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  * input.c: Unix file input
17  *
18  * Copyright (c) 2008 Eliot Dresselhaus
19  *
20  * Permission is hereby granted, free of charge, to any person obtaining
21  * a copy of this software and associated documentation files (the
22  * "Software"), to deal in the Software without restriction, including
23  * without limitation the rights to use, copy, modify, merge, publish,
24  * distribute, sublicense, and/or sell copies of the Software, and to
25  * permit persons to whom the Software is furnished to do so, subject to
26  * the following conditions:
27  *
28  * The above copyright notice and this permission notice shall be
29  * included in all copies or substantial portions of the Software.
30  *
31  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
32  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
33  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
34  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
35  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
36  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
37  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
38  */
39 
40 #include <vlib/vlib.h>
41 #include <vlib/unix/unix.h>
42 #include <signal.h>
44 
45 /* FIXME autoconf */
46 #define HAVE_LINUX_EPOLL
47 
48 #ifdef HAVE_LINUX_EPOLL
49 
50 #include <sys/epoll.h>
51 
52 typedef struct
53 {
54  int epoll_fd;
55  struct epoll_event *epoll_events;
56 
57  /* Statistics. */
61 
63 
64 static void
66 {
69  struct epoll_event e;
70  int op;
71 
72  memset (&e, 0, sizeof (e));
73 
74  e.events = EPOLLIN;
76  e.events |= EPOLLOUT;
78  e.events |= EPOLLET;
79  e.data.u32 = f - fm->file_pool;
80 
81  op = -1;
82 
83  switch (update_type)
84  {
86  op = EPOLL_CTL_ADD;
87  break;
88 
90  op = EPOLL_CTL_MOD;
91  break;
92 
94  op = EPOLL_CTL_DEL;
95  break;
96 
97  default:
98  clib_warning ("unknown update_type %d", update_type);
99  return;
100  }
101 
102  if (epoll_ctl (em->epoll_fd, op, f->file_descriptor, &e) < 0)
103  clib_unix_warning ("epoll_ctl");
104 }
105 
106 static uword
108  vlib_node_runtime_t * node, vlib_frame_t * frame)
109 {
110  unix_main_t *um = &unix_main;
113  struct epoll_event *e;
114  int n_fds_ready;
115 
116  {
117  vlib_node_main_t *nm = &vm->node_main;
118  u32 ticks_until_expiration;
119  f64 timeout;
120  int timeout_ms = 0, max_timeout_ms = 10;
121  f64 vector_rate = vlib_last_vectors_per_main_loop (vm);
122 
123  /* If we're not working very hard, decide how long to sleep */
124  if (vector_rate < 2 && vm->api_queue_nonempty == 0
125  && nm->input_node_counts_by_state[VLIB_NODE_STATE_POLLING] == 0)
126  {
127  ticks_until_expiration = TW (tw_timer_first_expires_in_ticks)
128  ((TWT (tw_timer_wheel) *) nm->timing_wheel);
129 
130  /* Nothing on the fast wheel, sleep 10ms */
131  if (ticks_until_expiration == TW_SLOTS_PER_RING)
132  {
133  timeout = 10e-3;
134  timeout_ms = max_timeout_ms;
135  }
136  else
137  {
138  timeout = (f64) ticks_until_expiration *1e-5;
139  if (timeout < 1e-3)
140  timeout_ms = 0;
141  else
142  {
143  timeout_ms = timeout * 1e3;
144  /* Must be between 1 and 10 ms. */
145  timeout_ms = clib_max (1, timeout_ms);
146  timeout_ms = clib_min (max_timeout_ms, timeout_ms);
147  }
148  }
149  node->input_main_loops_per_call = 0;
150  }
151  else /* busy */
152  {
153  /* Don't come back for a respectable number of dispatch cycles */
154  node->input_main_loops_per_call = 1024;
155  }
156 
157  /* Allow any signal to wakeup our sleep. */
158  {
159  static sigset_t unblock_all_signals;
160  n_fds_ready = epoll_pwait (em->epoll_fd,
161  em->epoll_events,
162  vec_len (em->epoll_events),
163  timeout_ms, &unblock_all_signals);
164 
165  /* This kludge is necessary to run over absurdly old kernels */
166  if (n_fds_ready < 0 && errno == ENOSYS)
167  {
168  n_fds_ready = epoll_wait (em->epoll_fd,
169  em->epoll_events,
170  vec_len (em->epoll_events), timeout_ms);
171  }
172  }
173  }
174 
175  if (n_fds_ready < 0)
176  {
177  if (unix_error_is_fatal (errno))
178  vlib_panic_with_error (vm, clib_error_return_unix (0, "epoll_wait"));
179 
180  /* non fatal error (e.g. EINTR). */
181  return 0;
182  }
183 
184  em->epoll_waits += 1;
185  em->epoll_files_ready += n_fds_ready;
186 
187  for (e = em->epoll_events; e < em->epoll_events + n_fds_ready; e++)
188  {
189  u32 i = e->data.u32;
191  clib_error_t *errors[4];
192  int n_errors = 0;
193 
194  if (PREDICT_TRUE (!(e->events & EPOLLERR)))
195  {
196  if (e->events & EPOLLIN)
197  {
198  errors[n_errors] = f->read_function (f);
199  n_errors += errors[n_errors] != 0;
200  }
201  if (e->events & EPOLLOUT)
202  {
203  errors[n_errors] = f->write_function (f);
204  n_errors += errors[n_errors] != 0;
205  }
206  }
207  else
208  {
209  if (f->error_function)
210  {
211  errors[n_errors] = f->error_function (f);
212  n_errors += errors[n_errors] != 0;
213  }
214  else
215  close (f->file_descriptor);
216  }
217 
218  ASSERT (n_errors < ARRAY_LEN (errors));
219  for (i = 0; i < n_errors; i++)
220  {
221  unix_save_error (um, errors[i]);
222  }
223  }
224 
225  return 0;
226 }
227 
228 /* *INDENT-OFF* */
230  .function = linux_epoll_input,
231  .type = VLIB_NODE_TYPE_PRE_INPUT,
232  .name = "unix-epoll-input",
233 };
234 /* *INDENT-ON* */
235 
236 clib_error_t *
238 {
241 
242  /* Allocate some events. */
244 
245  em->epoll_fd = epoll_create (vec_len (em->epoll_events));
246  if (em->epoll_fd < 0)
247  return clib_error_return_unix (0, "epoll_create");
248 
250 
251  return 0;
252 }
253 
255 
256 #endif /* HAVE_LINUX_EPOLL */
257 
258 static clib_error_t *
260 {
262 }
263 
265 
266 /*
267  * fd.io coding-style-patch-verification: ON
268  *
269  * Local Variables:
270  * eval: (c-set-style "gnu")
271  * End:
272  */
#define UNIX_FILE_EVENT_EDGE_TRIGGERED
Definition: file.h:57
unix_main_t unix_main
Definition: main.c:62
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:337
#define clib_min(x, y)
Definition: clib.h:332
static void vlib_panic_with_error(vlib_main_t *vm, clib_error_t *error)
Definition: main.h:266
static clib_error_t * unix_input_init(vlib_main_t *vm)
Definition: input.c:259
static linux_epoll_main_t linux_epoll_main
Definition: input.c:62
static vlib_node_registration_t linux_epoll_input_node
(constructor) VLIB_REGISTER_NODE (linux_epoll_input_node)
Definition: input.c:229
#define PREDICT_TRUE(x)
Definition: clib.h:98
u32 file_descriptor
Definition: file.h:53
static u32 vlib_last_vectors_per_main_loop(vlib_main_t *vm)
Definition: main.h:294
clib_file_function_t * read_function
Definition: file.h:63
u32 input_main_loops_per_call
For input nodes: decremented on each main loop interation until it reaches zero and function is calle...
Definition: node.h:439
clib_file_t * file_pool
Definition: file.h:76
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
static uword linux_epoll_input(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: input.c:107
clib_file_main_t file_main
Definition: main.c:63
unsigned long u64
Definition: types.h:89
#define vec_resize(V, N)
Resize a vector (no header, unspecified alignment) Add N elements to end of given vector V...
Definition: vec.h:237
#define vlib_call_init_function(vm, x)
Definition: init.h:162
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:458
unix_file_update_type_t
Definition: file.h:66
#define clib_error_return_unix(e, args...)
Definition: error.h:102
#define TW_SLOTS_PER_RING
#define TWT(a)
u32 flags
Definition: file.h:55
#define VLIB_FRAME_SIZE
Definition: node.h:328
void(* file_update)(clib_file_t *file, unix_file_update_type_t update_type)
Definition: file.h:78
vlib_main_t * vm
Definition: buffer.c:283
#define clib_warning(format, args...)
Definition: error.h:59
#define ARRAY_LEN(x)
Definition: clib.h:59
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
static word unix_error_is_fatal(word error)
Definition: error.h:118
clib_error_t * linux_epoll_input_init(vlib_main_t *vm)
Definition: input.c:237
#define UNIX_FILE_DATA_AVAILABLE_TO_WRITE
Definition: file.h:56
#define clib_max(x, y)
Definition: clib.h:325
u64 uword
Definition: types.h:112
struct epoll_event * epoll_events
Definition: input.c:55
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
double f64
Definition: types.h:142
u32 input_node_counts_by_state[VLIB_N_NODE_STATE]
Definition: node.h:693
vlib_node_main_t node_main
Definition: main.h:129
#define clib_unix_warning(format, args...)
Definition: error.h:68
u64 epoll_files_ready
Definition: input.c:58
clib_file_function_t * error_function
Definition: file.h:63
static void linux_epoll_file_update(clib_file_t *f, unix_file_update_type_t update_type)
Definition: input.c:65
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:143
static void unix_save_error(unix_main_t *um, clib_error_t *error)
Definition: unix.h:112
Definition: file.h:50
#define TW(a)
clib_file_function_t * write_function
Definition: file.h:63
void * timing_wheel
Definition: node.h:669