FD.io VPP  v19.04.4-rc0-5-ge88582fac
Vector Packet Processing
socket_api.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * socket_api.c
4  *
5  * Copyright (c) 2009 Cisco and/or its affiliates.
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at:
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  *------------------------------------------------------------------
18  */
19 
20 #include <sys/types.h>
21 #include <sys/socket.h>
22 #include <netinet/in.h>
23 #include <sys/ioctl.h>
24 #include <fcntl.h>
25 #include <sys/stat.h>
26 
27 #include <vppinfra/byte_order.h>
28 #include <svm/ssvm.h>
29 #include <vlibmemory/api.h>
30 
32 
33 #define vl_typedefs /* define message structures */
35 #undef vl_typedefs
36 
37 /* instantiate all the print functions we know about */
38 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
39 #define vl_printfun
41 #undef vl_printfun
42 
43 /* instantiate all the endian swap functions we know about */
44 #define vl_endianfun
46 #undef vl_endianfun
47 
49 
50 #define SOCK_API_REG_HANDLE_BIT (1<<31)
51 
52 static u32
54 {
57 }
58 
59 static u32
61 {
62  return (reg_index & ~SOCK_API_REG_HANDLE_BIT);
63 }
64 
65 u8
67 {
68  return ((reg_handle & SOCK_API_REG_HANDLE_BIT) != 0);
69 }
70 
71 void
73 {
76  clib_file_t *f;
77 
78  /*
79  * Must have at least one active client, not counting the
80  * REGISTRATION_TYPE_SOCKET_LISTEN bind/accept socket
81  */
82  if (pool_elts (sm->registration_pool) < 2)
83  return;
84 
85  vlib_cli_output (vm, "Socket clients");
86  vlib_cli_output (vm, "%20s %8s", "Name", "Fildesc");
87  /* *INDENT-OFF* */
89  ({
90  if (reg->registration_type == REGISTRATION_TYPE_SOCKET_SERVER) {
91  f = vl_api_registration_file (reg);
92  vlib_cli_output (vm, "%20s %8d", reg->name, f->file_descriptor);
93  }
94  }));
95 /* *INDENT-ON* */
96 }
97 
100 {
101  socket_main_t *sm = &socket_main;
103  if (pool_is_free_index (sm->registration_pool, index))
104  {
105 #if DEBUG > 2
106  clib_warning ("Invalid index %d\n", index);
107 #endif
108  return 0;
109  }
110  return pool_elt_at_index (sm->registration_pool, index);
111 }
112 
113 void
115 {
116 #if CLIB_DEBUG > 1
117  u32 output_length;
118 #endif
119  socket_main_t *sm = &socket_main;
120  u16 msg_id = ntohs (*(u16 *) elem);
121  api_main_t *am = &api_main;
122  msgbuf_t *mb = (msgbuf_t *) (elem - offsetof (msgbuf_t, data));
123  vl_api_registration_t *sock_rp;
125  clib_error_t *error;
126  clib_file_t *cf;
127 
128  cf = vl_api_registration_file (rp);
130 
131  if (msg_id >= vec_len (am->api_trace_cfg))
132  {
133  clib_warning ("id out of range: %d", msg_id);
134  vl_msg_api_free ((void *) elem);
135  return;
136  }
137 
138  sock_rp = pool_elt_at_index (sm->registration_pool,
140  ASSERT (sock_rp);
141 
142  /* Add the msgbuf_t to the output vector */
143  vec_add (sock_rp->output_vector, (u8 *) mb, sizeof (*mb));
144 
145  /* Try to send the message and save any error like
146  * we do in the input epoll loop */
147  vec_add (sock_rp->output_vector, elem, ntohl (mb->data_len));
148  error = clib_file_write (cf);
149  unix_save_error (&unix_main, error);
150 
151  /* If we didn't finish sending everything, wait for tx space */
152  if (vec_len (sock_rp->output_vector) > 0
154  {
157  }
158 
159 #if CLIB_DEBUG > 1
160  output_length = sizeof (*mb) + ntohl (mb->data_len);
161  clib_warning ("wrote %u bytes to fd %d", output_length,
162  cf->file_descriptor);
163 #endif
164 
165  vl_msg_api_free ((void *) elem);
166 }
167 
168 void
170 {
171  int i;
173  if (pool_is_free_index (socket_main.registration_pool, pool_index))
174  {
175  clib_warning ("main pool index %d already free", pool_index);
176  return;
177  }
178  rp = pool_elt_at_index (socket_main.registration_pool, pool_index);
179 
181  for (i = 0; i < vec_len (rp->additional_fds_to_close); i++)
182  if (close (rp->additional_fds_to_close[i]) < 0)
183  clib_unix_warning ("close");
185  vec_free (rp->name);
187  vec_free (rp->output_vector);
189  pool_put (socket_main.registration_pool, rp);
190 }
191 
192 void
194  i8 * input_v)
195 {
196  msgbuf_t *mbp = (msgbuf_t *) input_v;
197 
198  u8 *the_msg = (u8 *) (mbp->data);
199  socket_main.current_uf = uf;
200  socket_main.current_rp = rp;
201  vl_msg_api_socket_handler (the_msg);
202  socket_main.current_uf = 0;
203  socket_main.current_rp = 0;
204 }
205 
206 clib_error_t *
208 {
212  int n;
213  i8 *msg_buffer = 0;
214  u8 *data_for_process;
215  u32 msg_len;
216  u32 save_input_buffer_length = vec_len (socket_main.input_buffer);
218  msgbuf_t *mbp;
219  int mbp_set = 0;
220 
221  rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data);
222 
223  n = read (uf->file_descriptor, socket_main.input_buffer,
224  vec_len (socket_main.input_buffer));
225 
226  if (n <= 0 && errno != EAGAIN)
227  {
228  clib_file_del (fm, uf);
229 
230  if (!pool_is_free (socket_main.registration_pool, rp))
231  {
232  u32 index = rp - socket_main.registration_pool;
234  }
235  else
236  {
237  clib_warning ("client index %d already free?",
239  }
240  return 0;
241  }
242 
243  _vec_len (socket_main.input_buffer) = n;
244 
245  /*
246  * Look for bugs here. This code is tricky because
247  * data read from a stream socket does not honor message
248  * boundaries. In the case of a long message (>4K bytes)
249  * we have to do (at least) 2 reads, etc.
250  */
251  do
252  {
253  if (vec_len (rp->unprocessed_input))
254  {
255  vec_append (rp->unprocessed_input, socket_main.input_buffer);
256  msg_buffer = rp->unprocessed_input;
257  }
258  else
259  {
260  msg_buffer = socket_main.input_buffer;
261  mbp_set = 0;
262  }
263 
264  if (mbp_set == 0)
265  {
266  /* Any chance that we have a complete message? */
267  if (vec_len (msg_buffer) <= sizeof (msgbuf_t))
268  goto save_and_split;
269 
270  mbp = (msgbuf_t *) msg_buffer;
271  msg_len = ntohl (mbp->data_len);
272  mbp_set = 1;
273  }
274 
275  /* We don't have the entire message yet. */
276  if (mbp_set == 0
277  || (msg_len + sizeof (msgbuf_t)) > vec_len (msg_buffer))
278  {
279  save_and_split:
280  /* if we were using the input buffer save the fragment */
281  if (msg_buffer == socket_main.input_buffer)
282  {
283  ASSERT (vec_len (rp->unprocessed_input) == 0);
284  vec_validate (rp->unprocessed_input, vec_len (msg_buffer) - 1);
285  clib_memcpy_fast (rp->unprocessed_input, msg_buffer,
286  vec_len (msg_buffer));
287  _vec_len (rp->unprocessed_input) = vec_len (msg_buffer);
288  }
289  _vec_len (socket_main.input_buffer) = save_input_buffer_length;
290  return 0;
291  }
292 
293  data_for_process = (u8 *) vec_dup (msg_buffer);
294  _vec_len (data_for_process) = (msg_len + sizeof (msgbuf_t));
295  pool_get (socket_main.process_args, a);
296  a->clib_file = uf;
297  a->regp = rp;
298  a->data = data_for_process;
299 
302  a - socket_main.process_args);
303  if (n > (msg_len + sizeof (*mbp)))
304  vec_delete (msg_buffer, msg_len + sizeof (*mbp), 0);
305  else
306  _vec_len (msg_buffer) = 0;
307  n -= msg_len + sizeof (msgbuf_t);
308  msg_len = 0;
309  mbp_set = 0;
310  }
311  while (n > 0);
312 
313  _vec_len (socket_main.input_buffer) = save_input_buffer_length;
314 
315  return 0;
316 }
317 
318 clib_error_t *
320 {
323  int n;
324 
325  rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data);
326 
327  /* Flush output vector. */
328  size_t total_bytes = vec_len (rp->output_vector);
329  size_t bytes_to_send, remaining_bytes = total_bytes;
330  void *p = rp->output_vector;
331  while (remaining_bytes > 0)
332  {
333  bytes_to_send = remaining_bytes > 4096 ? 4096 : remaining_bytes;
334  n = write (uf->file_descriptor, p, bytes_to_send);
335  if (n < 0)
336  {
337  if (errno == EAGAIN)
338  {
339  break;
340  }
341 #if DEBUG > 2
342  clib_warning ("write error, close the file...\n");
343 #endif
344  clib_file_del (fm, uf);
346  socket_main.registration_pool);
347  return 0;
348  }
349  remaining_bytes -= bytes_to_send;
350  p += bytes_to_send;
351  }
352 
353  vec_delete (rp->output_vector, total_bytes - remaining_bytes, 0);
354  if (vec_len (rp->output_vector) <= 0
356  {
359  }
360 
361  return 0;
362 }
363 
364 clib_error_t *
366 {
369 
370  rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data);
371  clib_file_del (fm, uf);
373 
374  return 0;
375 }
376 
377 void
379 {
381  clib_file_t template = { 0 };
382 
383  pool_get (socket_main.registration_pool, rp);
384  clib_memset (rp, 0, sizeof (*rp));
385 
386  template.read_function = vl_socket_read_ready;
387  template.write_function = vl_socket_write_ready;
388  template.error_function = vl_socket_error_ready;
389  template.file_descriptor = fd;
390  template.private_data = rp - socket_main.registration_pool;
391 
393  rp->vl_api_registration_pool_index = rp - socket_main.registration_pool;
394  rp->clib_file_index = clib_file_add (fm, &template);
395 }
396 
397 static clib_error_t *
399 {
401  socket_main_t *sm = &socket_main;
403  clib_socket_t client;
404  clib_error_t *error;
405 
406  error = clib_socket_accept (sock, &client);
407  if (error)
408  return error;
409 
410  socksvr_file_add (fm, client.fd);
411  return 0;
412 }
413 
414 static clib_error_t *
416 {
417  clib_warning ("why am I here?");
418  return 0;
419 }
420 
421 /*
422  * vl_api_sockclnt_create_t_handler
423  */
424 void
426 {
427  vl_api_registration_t *regp;
429  api_main_t *am = &api_main;
430  hash_pair_t *hp;
431  int rv = 0;
433  u32 i = 0;
434 
435  regp = socket_main.current_rp;
436 
438 
439  regp->name = format (0, "%s%c", mp->name, 0);
440 
441  u32 size = sizeof (*rp) + (nmsg * sizeof (vl_api_message_table_entry_t));
442  rp = vl_msg_api_alloc (size);
443  rp->_vl_msg_id = htons (VL_API_SOCKCLNT_CREATE_REPLY);
444  rp->index = htonl (sock_api_registration_handle (regp));
445  rp->context = mp->context;
446  rp->response = htonl (rv);
447  rp->count = htons (nmsg);
448 
449  /* *INDENT-OFF* */
451  ({
452  rp->message_table[i].index = htons(hp->value[0]);
453  strncpy((char *)rp->message_table[i].name, (char *)hp->key, 64-1);
454  i++;
455  }));
456  /* *INDENT-ON* */
457  vl_api_send_msg (regp, (u8 *) rp);
458 }
459 
460 /*
461  * vl_api_sockclnt_delete_t_handler
462  */
463 void
465 {
466  vl_api_registration_t *regp;
468 
470  if (!regp)
471  return;
472 
473  u32 reg_index = socket_api_registration_handle_to_index (ntohl (mp->index));
474  rp = vl_msg_api_alloc (sizeof (*rp));
475  rp->_vl_msg_id = htons (VL_API_SOCKCLNT_DELETE_REPLY);
476  rp->context = mp->context;
477 
478  if (!pool_is_free_index (socket_main.registration_pool, reg_index))
479  {
480  rp->response = htonl (1);
481  vl_api_send_msg (regp, (u8 *) rp);
482 
485  }
486  else
487  {
488  clib_warning ("unknown client ID %d", reg_index);
489  rp->response = htonl (-1);
490  vl_api_send_msg (regp, (u8 *) rp);
491  }
492 }
493 
494 clib_error_t *
495 vl_sock_api_send_fd_msg (int socket_fd, int fds[], int n_fds)
496 {
497  struct msghdr mh = { 0 };
498  struct iovec iov[1];
499  char ctl[CMSG_SPACE (sizeof (int) * n_fds)];
500  struct cmsghdr *cmsg;
501  char *msg = "fdmsg";
502  int rv;
503 
504  iov[0].iov_base = msg;
505  iov[0].iov_len = strlen (msg);
506  mh.msg_iov = iov;
507  mh.msg_iovlen = 1;
508 
509  clib_memset (&ctl, 0, sizeof (ctl));
510  mh.msg_control = ctl;
511  mh.msg_controllen = sizeof (ctl);
512  cmsg = CMSG_FIRSTHDR (&mh);
513  cmsg->cmsg_len = CMSG_LEN (sizeof (int) * n_fds);
514  cmsg->cmsg_level = SOL_SOCKET;
515  cmsg->cmsg_type = SCM_RIGHTS;
516  clib_memcpy_fast (CMSG_DATA (cmsg), fds, sizeof (int) * n_fds);
517 
518  rv = sendmsg (socket_fd, &mh, 0);
519  if (rv < 0)
520  return clib_error_return_unix (0, "sendmsg");
521  return 0;
522 }
523 
526 {
527  vl_api_shm_elem_config_t *config = 0, *c;
528  u64 cfg;
529  int i;
530 
531  if (!mp->nitems)
532  {
533  vec_validate (config, 6);
534  config[0].type = VL_API_VLIB_RING;
535  config[0].size = 256;
536  config[0].count = 32;
537 
538  config[1].type = VL_API_VLIB_RING;
539  config[1].size = 1024;
540  config[1].count = 16;
541 
542  config[2].type = VL_API_VLIB_RING;
543  config[2].size = 4096;
544  config[2].count = 2;
545 
546  config[3].type = VL_API_CLIENT_RING;
547  config[3].size = 256;
548  config[3].count = 32;
549 
550  config[4].type = VL_API_CLIENT_RING;
551  config[4].size = 1024;
552  config[4].count = 16;
553 
554  config[5].type = VL_API_CLIENT_RING;
555  config[5].size = 4096;
556  config[5].count = 2;
557 
558  config[6].type = VL_API_QUEUE;
559  config[6].count = 128;
560  config[6].size = sizeof (uword);
561  }
562  else
563  {
564  vec_validate (config, mp->nitems - 1);
565  for (i = 0; i < mp->nitems; i++)
566  {
567  cfg = mp->configs[i];
568  /* Pretty much a hack but it avoids defining our own api type
569  * in memclnt.api */
570  c = (vl_api_shm_elem_config_t *) & cfg;
571  config[i].type = c->type;
572  config[i].count = c->count;
573  config[i].size = c->size;
574  }
575  }
576  return config;
577 }
578 
579 /*
580  * Bootstrap shm api using the socket api
581  */
582 void
584 {
586  ssvm_private_t _memfd_private, *memfd = &_memfd_private;
587  svm_map_region_args_t _args, *a = &_args;
588  vl_api_registration_t *regp;
589  api_main_t *am = &api_main;
590  svm_region_t *vlib_rp;
591  clib_file_t *cf;
592  vl_api_shm_elem_config_t *config = 0;
593  vl_shmem_hdr_t *shmem_hdr;
594  int rv;
595 
597  if (regp == 0)
598  {
599  clib_warning ("API client disconnected");
600  return;
601  }
603  {
604  rv = -31; /* VNET_API_ERROR_INVALID_REGISTRATION */
605  goto reply;
606  }
607 
608  /*
609  * Set up a memfd segment of the requested size wherein the
610  * shmem data structures will be initialized
611  */
612  clib_memset (memfd, 0, sizeof (*memfd));
613  memfd->ssvm_size = mp->requested_size;
614  memfd->requested_va = 0ULL;
615  memfd->i_am_master = 1;
616  memfd->name = format (0, "%s%c", regp->name, 0);
617 
618  if ((rv = ssvm_master_init_memfd (memfd)))
619  goto reply;
620 
621  /* Remember to close this fd when the socket connection goes away */
622  vec_add1 (regp->additional_fds_to_close, memfd->fd);
623 
624  /*
625  * Create a plausible svm_region in the memfd backed segment
626  */
627  clib_memset (a, 0, sizeof (*a));
628  a->baseva = memfd->sh->ssvm_va + MMAP_PAGESIZE;
629  a->size = memfd->ssvm_size - MMAP_PAGESIZE;
630  /* $$$$ might want a different config parameter */
632  a->flags = SVM_FLAGS_MHEAP;
634 
635  /*
636  * Part deux, initialize the svm_region_t shared-memory header
637  * api allocation rings, and so on.
638  */
639  config = vl_api_make_shm_config (mp);
640  vlib_rp = (svm_region_t *) a->baseva;
641  vl_init_shmem (vlib_rp, config, 1 /* is_vlib (dont-care) */ ,
642  1 /* is_private */ );
643 
644  /* Remember who created this. Needs to be post vl_init_shmem */
645  shmem_hdr = (vl_shmem_hdr_t *) vlib_rp->user_ctx;
647 
648  vec_add1 (am->vlib_private_rps, vlib_rp);
649  memfd->sh->ready = 1;
650  vec_free (config);
651 
652  /* Recompute the set of input queues to poll in memclnt_process */
654 
655 reply:
656 
657  rmp = vl_msg_api_alloc (sizeof (*rmp));
658  rmp->_vl_msg_id = htons (VL_API_SOCK_INIT_SHM_REPLY);
659  rmp->context = mp->context;
660  rmp->retval = htonl (rv);
661 
662  /*
663  * Note: The reply message needs to make it out the back door
664  * before we send the magic fd message. That's taken care of by
665  * the send function.
666  */
667  vl_socket_api_send (regp, (u8 *) rmp);
668 
669  if (rv != 0)
670  return;
671 
672  /* Send the magic "here's your sign (aka fd)" socket message */
673  cf = vl_api_registration_file (regp);
674  vl_sock_api_send_fd_msg (cf->file_descriptor, &memfd->fd, 1);
675 }
676 
677 #define foreach_vlib_api_msg \
678 _(SOCKCLNT_CREATE, sockclnt_create) \
679 _(SOCKCLNT_DELETE, sockclnt_delete) \
680 _(SOCK_INIT_SHM, sock_init_shm)
681 
682 clib_error_t *
684 {
686  clib_file_t template = { 0 };
688  socket_main_t *sm = &socket_main;
690  clib_error_t *error;
691 
692  /* If not explicitly configured, do not bind/enable, etc. */
693  if (sm->socket_name == 0)
694  return 0;
695 
696 #define _(N,n) \
697  vl_msg_api_set_handlers(VL_API_##N, #n, \
698  vl_api_##n##_t_handler, \
699  vl_noop_handler, \
700  vl_api_##n##_t_endian, \
701  vl_api_##n##_t_print, \
702  sizeof(vl_api_##n##_t), 1);
704 #undef _
705 
706  vec_resize (sm->input_buffer, 4096);
707 
708  sock->config = (char *) sm->socket_name;
709 
710  /* mkdir of file socket, only under /run */
711  if (strncmp (sock->config, "/run", 4) == 0)
712  {
713  u8 *tmp = format (0, "%s", sock->config);
714  int i = vec_len (tmp);
715  while (i && tmp[--i] != '/')
716  ;
717 
718  tmp[i] = 0;
719 
720  if (i)
721  vlib_unix_recursive_mkdir ((char *) tmp);
722  vec_free (tmp);
723  }
724 
727  error = clib_socket_init (sock);
728  if (error)
729  return error;
730 
731  pool_get (sm->registration_pool, rp);
732  clib_memset (rp, 0, sizeof (*rp));
733 
735 
736  template.read_function = socksvr_accept_ready;
737  template.write_function = socksvr_bogus_write;
738  template.file_descriptor = sock->fd;
739  template.private_data = rp - sm->registration_pool;
740 
741  rp->clib_file_index = clib_file_add (fm, &template);
742  return 0;
743 }
744 
745 static clib_error_t *
747 {
748  socket_main_t *sm = &socket_main;
750 
751  /* Defensive driving in case something wipes out early */
752  if (sm->registration_pool)
753  {
754  u32 index;
755  /* *INDENT-OFF* */
756  pool_foreach (rp, sm->registration_pool, ({
757  vl_api_registration_del_file (rp);
758  index = rp->vl_api_registration_pool_index;
759  vl_socket_free_registration_index (index);
760  }));
761 /* *INDENT-ON* */
762  }
763 
764  return 0;
765 }
766 
768 
769 static clib_error_t *
771 {
772  socket_main_t *sm = &socket_main;
773 
775  {
776  if (unformat (input, "socket-name %s", &sm->socket_name))
777  ;
778  else if (unformat (input, "default"))
779  {
780  sm->socket_name = format (0, "%s%c", API_SOCKET_FILE, 0);
781  }
782  else
783  {
784  return clib_error_return (0, "unknown input '%U'",
785  format_unformat_error, input);
786  }
787  }
788  return 0;
789 }
790 
792 
793 clib_error_t *
795 {
796  return 0;
797 }
798 
800 
801 /*
802  * fd.io coding-style-patch-verification: ON
803  *
804  * Local Variables:
805  * eval: (c-set-style "gnu")
806  * End:
807  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
vl_api_registration_t * regp
Definition: socket_api.h:30
u64 ssvm_size
Definition: ssvm.h:84
unix_main_t unix_main
Definition: main.c:62
u64 api_pvt_heap_size
size of the api private mheap
Definition: api_common.h:301
static void clib_file_del(clib_file_main_t *um, clib_file_t *f)
Definition: file.h:109
u8 * name
Client name.
Definition: api_common.h:52
clib_error_t * vl_sock_api_init(vlib_main_t *vm)
Definition: socket_api.c:683
void vl_msg_api_socket_handler(void *the_msg)
Definition: api_shared.c:651
static void vl_api_registration_del_file(vl_api_registration_t *reg)
Definition: api.h:76
uword requested_va
Definition: ssvm.h:87
void vl_socket_api_send(vl_api_registration_t *rp, u8 *elem)
Definition: socket_api.c:114
volatile int ** vl_api_queue_cursizes
Definition: memory_api.c:61
static u32 sock_api_registration_handle(vl_api_registration_t *regp)
Definition: socket_api.c:53
a
Definition: bitmap.h:538
void socksvr_file_add(clib_file_main_t *fm, int fd)
Definition: socket_api.c:378
static clib_file_t * vl_api_registration_file(vl_api_registration_t *reg)
Definition: api.h:70
vl_api_registration_t * registration_pool
Definition: socket_api.h:46
volatile u32 ready
Definition: ssvm.h:76
unsigned long u64
Definition: types.h:89
#define clib_memcpy_fast(a, b, c)
Definition: string.h:81
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
void vl_api_sockclnt_delete_t_handler(vl_api_sockclnt_delete_t *mp)
Definition: socket_api.c:464
static void vl_api_send_msg(vl_api_registration_t *rp, u8 *elem)
Definition: api.h:34
vl_api_registration_t * current_rp
Definition: socket_api.h:52
vl_socket_args_for_process_t * process_args
Definition: socket_api.h:58
socket_main_t socket_main
Definition: socket_api.c:48
u32 file_descriptor
Definition: file.h:54
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
void vl_sock_api_dump_clients(vlib_main_t *vm, api_main_t *am)
Definition: socket_api.c:72
int i
clib_error_t * clib_socket_init(clib_socket_t *s)
Definition: socket.c:384
u8 data[0]
actual message begins here
Definition: api_common.h:141
static clib_error_t * clib_file_write(clib_file_t *f)
Definition: file.h:160
ssvm_shared_header_t * sh
Definition: ssvm.h:83
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
u8 data[128]
Definition: ipsec.api:248
#define pool_is_free(P, E)
Use free bitmap to query whether given element is free.
Definition: pool.h:275
clib_error_t * vl_socket_write_ready(clib_file_t *uf)
Definition: socket_api.c:319
struct msgbuf_ msgbuf_t
Message header structure.
void vl_socket_process_api_msg(clib_file_t *uf, vl_api_registration_t *rp, i8 *input_v)
Definition: socket_api.c:193
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:236
void * vl_msg_api_alloc(int nbytes)
void vl_api_sockclnt_create_t_handler(vl_api_sockclnt_create_t *mp)
Definition: socket_api.c:425
unsigned char u8
Definition: types.h:56
trace_cfg_t * api_trace_cfg
Current trace configuration.
Definition: api_common.h:249
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
#define fm
#define vec_add(V, E, N)
Add N elements to end of vector V (no header, unspecified alignment)
Definition: vec.h:598
#define CLIB_SOCKET_F_IS_SERVER
Definition: socket.h:58
u32 clib_file_index
Socket only: file index.
Definition: api_common.h:65
clib_error_t * vl_socket_error_ready(clib_file_t *uf)
Definition: socket_api.c:365
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:493
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:163
void vl_api_sock_init_shm_t_handler(vl_api_sock_init_shm_t *mp)
Definition: socket_api.c:583
int ssvm_master_init_memfd(ssvm_private_t *memfd)
Initialize memfd segment master.
Definition: ssvm.c:223
volatile void * user_ctx
Definition: svm_common.h:47
vlib_node_registration_t vl_api_clnt_node
(constructor) VLIB_REGISTER_NODE (vl_api_clnt_node)
Definition: vlib_api.c:438
#define clib_error_return(e, args...)
Definition: error.h:99
clib_file_main_t file_main
Definition: main.c:63
#define vec_resize(V, N)
Resize a vector (no header, unspecified alignment) Add N elements to end of given vector V...
Definition: vec.h:242
unsigned int u32
Definition: types.h:88
u8 * socket_name
Definition: socket_api.h:37
static u32 socket_api_registration_handle_to_index(u32 reg_index)
Definition: socket_api.c:60
static clib_error_t * socksvr_accept_ready(clib_file_t *uf)
Definition: socket_api.c:398
vl_registration_type_t registration_type
type
Definition: api_common.h:47
#define SVM_FLAGS_MHEAP
Definition: svm_common.h:27
u64 configs[nitems]
Definition: memclnt.api:194
static clib_error_t * socksvr_config(vlib_main_t *vm, unformat_input_t *input)
Definition: socket_api.c:770
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:514
uword size
void vl_init_shmem(svm_region_t *vlib_rp, vl_api_shm_elem_config_t *config, int is_vlib, int is_private_region)
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
Definition: node_funcs.h:934
clib_error_t * clib_socket_accept(clib_socket_t *server, clib_socket_t *client)
Definition: socket.c:524
struct _unformat_input_t unformat_input_t
unsigned short u16
Definition: types.h:57
#define clib_error_return_unix(e, args...)
Definition: error.h:102
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:286
clib_file_t * current_uf
Definition: socket_api.h:53
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:375
svm_region_t ** vlib_private_rps
Vector of all mapped shared-VM segments.
Definition: api_common.h:261
u32 flags
Definition: file.h:56
#define VLIB_CONFIG_FUNCTION(x, n,...)
Definition: init.h:172
signed char i8
Definition: types.h:45
clib_error_t * vl_socket_read_ready(clib_file_t *uf)
Definition: socket_api.c:207
void(* file_update)(clib_file_t *file, clib_file_update_type_t update_type)
Definition: file.h:90
void svm_region_init_mapped_region(svm_map_region_args_t *a, svm_region_t *rp)
Definition: svm.c:487
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:202
An API client registration, only in vpp/vlib.
Definition: api_common.h:45
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
Shared memory connection.
Definition: api_common.h:37
svmdb_client_t * c
vlib_main_t * vm
Definition: buffer.c:312
clib_socket_t socksvr_listen_socket
Definition: socket_api.h:61
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
#define VLIB_MAIN_LOOP_EXIT_FUNCTION(x)
Definition: init.h:168
vl_api_registration_t * vl_socket_api_client_handle_to_registration(u32 handle)
Definition: socket_api.c:99
#define clib_warning(format, args...)
Definition: error.h:59
u8 * output_vector
Socket only: output vector.
Definition: api_common.h:68
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:283
int * additional_fds_to_close
Definition: api_common.h:69
clib_error_t * vlibsocket_init(vlib_main_t *vm)
Definition: socket_api.c:794
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
Definition: api.h:56
static u32 vl_api_registration_file_index(vl_api_registration_t *reg)
Definition: api.h:64
int fd
memfd segments
Definition: ssvm.h:92
static uword hash_elts(void *v)
Definition: hash.h:118
#define ASSERT(truth)
#define vec_delete(V, N, M)
Delete N elements starting at element M.
Definition: vec.h:784
static uword clib_file_add(clib_file_main_t *um, clib_file_t *template)
Definition: file.h:96
u32 data_len
message length not including header
Definition: api_common.h:139
Message header structure.
Definition: api_common.h:136
u8 vl_socket_api_registration_handle_is_valid(u32 reg_handle)
Definition: socket_api.c:66
#define vec_append(v1, v2)
Append v2 after v1.
Definition: vec.h:818
struct _socket_t clib_socket_t
#define UNIX_FILE_DATA_AVAILABLE_TO_WRITE
Definition: file.h:57
i8 * unprocessed_input
Socket only: pending input.
Definition: api_common.h:66
#define CLIB_SOCKET_F_SEQPACKET
Definition: socket.h:63
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
u8 * name
Definition: ssvm.h:86
void vl_msg_api_free(void *)
#define MMAP_PAGESIZE
Definition: ssvm.h:42
clib_error_t * vlib_unix_recursive_mkdir(char *path)
Definition: util.c:103
#define API_SOCKET_FILE
Definition: socket_api.h:25
void vl_socket_free_registration_index(u32 pool_index)
Definition: socket_api.c:169
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
#define hash_foreach_pair(p, v, body)
Iterate over hash pairs.
Definition: hash.h:373
vl_api_shm_elem_config_t * vl_api_make_shm_config(vl_api_sock_init_shm_t *mp)
Definition: socket_api.c:525
clib_error_t * vl_sock_api_send_fd_msg(int socket_fd, int fds[], int n_fds)
Definition: socket_api.c:495
#define foreach_vlib_api_msg
Definition: socket_api.c:677
u64 uword
Definition: types.h:112
#define clib_unix_warning(format, args...)
Definition: error.h:68
u32 vl_api_registration_pool_index
Index in VLIB&#39;s brain (not shared memory).
Definition: api_common.h:50
i8 * input_buffer
Definition: socket_api.h:55
#define SOCK_API_REG_HANDLE_BIT
Definition: socket_api.c:50
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
static void unix_save_error(unix_main_t *um, clib_error_t *error)
Definition: unix.h:115
uword private_data
Definition: file.h:64
Definition: file.h:51
uword * msg_index_by_name_and_crc
client message index hash table
Definition: api_common.h:322
#define CLIB_SOCKET_F_ALLOW_GROUP_WRITE
Definition: socket.h:62
api_main_t api_main
Definition: api_shared.c:35
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:762
int i_am_master
Definition: ssvm.h:88
static clib_error_t * socksvr_bogus_write(clib_file_t *uf)
Definition: socket_api.c:415
static clib_error_t * socket_exit(vlib_main_t *vm)
Definition: socket_api.c:746
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128