FD.io VPP  v20.09-64-g4f7b92f0a
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 = vlibapi_get_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  void vl_api_call_reaper_functions (u32 client_index);
174 
175  if (pool_is_free_index (socket_main.registration_pool, pool_index))
176  {
177  clib_warning ("main pool index %d already free", pool_index);
178  return;
179  }
180  rp = pool_elt_at_index (socket_main.registration_pool, pool_index);
181 
182  vl_api_call_reaper_functions (pool_index);
183 
185  for (i = 0; i < vec_len (rp->additional_fds_to_close); i++)
186  if (close (rp->additional_fds_to_close[i]) < 0)
187  clib_unix_warning ("close");
189  vec_free (rp->name);
191  vec_free (rp->output_vector);
193  pool_put (socket_main.registration_pool, rp);
194 }
195 
196 void
198 {
199  msgbuf_t *mbp = (msgbuf_t *) input_v;
200 
201  u8 *the_msg = (u8 *) (mbp->data);
202  socket_main.current_rp = rp;
203  vl_msg_api_socket_handler (the_msg);
204  socket_main.current_rp = 0;
205 }
206 
207 /*
208  * Read function for API socket.
209  *
210  * Read data from socket, invoke SOCKET_READ_EVENT
211  * for each fully read API message, return 0.
212  * Store incomplete data for next invocation to continue.
213  *
214  * On severe read error, the file is closed.
215  *
216  * As reading is single threaded,
217  * socket_main.input_buffer is used temporarily.
218  * Even its length is modified, but always restored before return.
219  *
220  * Incomplete data is copied into a vector,
221  * pointer saved in registration's unprocessed_input.
222  */
223 clib_error_t *
225 {
229  /* n is the size of data read to input_buffer */
230  int n;
231  /* msg_buffer vector can point to input_buffer or unprocessed_input */
232  i8 *msg_buffer = 0;
233  /* data_for_process is a vector containing one full message, incl msgbuf_t */
234  u8 *data_for_process;
235  /* msgbuf_len is the size of one message, including sizeof (msgbuf_t) */
236  u32 msgbuf_len;
237  u32 save_input_buffer_length = vec_len (socket_main.input_buffer);
239  u32 reg_index = uf->private_data;
240 
241  rp = vl_socket_get_registration (reg_index);
242 
243  /* Ignore unprocessed_input for now, n describes input_buffer for now. */
244  n = read (uf->file_descriptor, socket_main.input_buffer,
245  vec_len (socket_main.input_buffer));
246 
247  if (n <= 0)
248  {
249  if (errno != EAGAIN)
250  {
251  /* Severe error, close the file. */
252  clib_file_del (fm, uf);
254  }
255  /* EAGAIN means we do not close the file, but no data to process anyway. */
256  return 0;
257  }
258 
259  /* Fake smaller length teporarily, so input_buffer can be used as msg_buffer. */
260  _vec_len (socket_main.input_buffer) = n;
261 
262  /*
263  * Look for bugs here. This code is tricky because
264  * data read from a stream socket does not honor message
265  * boundaries. In the case of a long message (>4K bytes)
266  * we have to do (at least) 2 reads, etc.
267  */
268  /* Determine msg_buffer. */
269  if (vec_len (rp->unprocessed_input))
270  {
271  vec_append (rp->unprocessed_input, socket_main.input_buffer);
272  msg_buffer = rp->unprocessed_input;
273  }
274  else
275  {
276  msg_buffer = socket_main.input_buffer;
277  }
278  /* Loop to process any full messages. */
279  ASSERT (vec_len (msg_buffer) > 0);
280  do
281  {
282  /* Here, we are not sure how big a chunk of message we have left. */
283  /* Do we at least know how big the full message will be? */
284  if (vec_len (msg_buffer) <= sizeof (msgbuf_t))
285  /* No, so fragment is not a full message. */
286  goto save_and_split;
287 
288  /* Now we know how big the full message will be. */
289  msgbuf_len =
290  ntohl (((msgbuf_t *) msg_buffer)->data_len) + sizeof (msgbuf_t);
291 
292  /* But do we have a full message? */
293  if (msgbuf_len > vec_len (msg_buffer))
294  {
295  save_and_split:
296  /* We don't have the entire message yet. */
297  /* If msg_buffer is unprocessed_input, nothing needs to be done. */
298  if (msg_buffer == socket_main.input_buffer)
299  /* But if we were using the input buffer, save the fragment. */
300  {
301  ASSERT (vec_len (rp->unprocessed_input) == 0);
302  vec_validate (rp->unprocessed_input, vec_len (msg_buffer) - 1);
303  clib_memcpy_fast (rp->unprocessed_input, msg_buffer,
304  vec_len (msg_buffer));
305  _vec_len (rp->unprocessed_input) = vec_len (msg_buffer);
306  }
307  /* No more full messages, restore original input_buffer length. */
308  _vec_len (socket_main.input_buffer) = save_input_buffer_length;
309  return 0;
310  }
311 
312  /*
313  * We have at least one full message.
314  * But msg_buffer can contain more data, so copy one message data
315  * so we can overwrite its length to what single message has.
316  */
317  data_for_process = (u8 *) vec_dup (msg_buffer);
318  _vec_len (data_for_process) = msgbuf_len;
319  /* Everything is ready to signal the SOCKET_READ_EVENT. */
320  pool_get (socket_main.process_args, a);
321  a->reg_index = reg_index;
322  a->data = data_for_process;
323 
326  a - socket_main.process_args);
327  if (vec_len (msg_buffer) > msgbuf_len)
328  /* There are some fragments left. Shrink the msg_buffer to simplify logic. */
329  vec_delete (msg_buffer, msgbuf_len, 0);
330  else
331  /* We are done with msg_buffer. */
332  _vec_len (msg_buffer) = 0;
333  }
334  while (vec_len (msg_buffer) > 0);
335 
336  /* Restore input_buffer, it could have been msg_buffer. */
337  _vec_len (socket_main.input_buffer) = save_input_buffer_length;
338  return 0;
339 }
340 
341 clib_error_t *
343 {
346  int n;
347 
348  rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data);
349 
350  /* Flush output vector. */
351  size_t total_bytes = vec_len (rp->output_vector);
352  size_t bytes_to_send, remaining_bytes = total_bytes;
353  void *p = rp->output_vector;
354  while (remaining_bytes > 0)
355  {
356  bytes_to_send = remaining_bytes > 4096 ? 4096 : remaining_bytes;
357  n = write (uf->file_descriptor, p, bytes_to_send);
358  if (n < 0)
359  {
360  if (errno == EAGAIN)
361  {
362  break;
363  }
364 #if DEBUG > 2
365  clib_warning ("write error, close the file...\n");
366 #endif
367  clib_file_del (fm, uf);
369  socket_main.registration_pool);
370  return 0;
371  }
372  remaining_bytes -= bytes_to_send;
373  p += bytes_to_send;
374  }
375 
376  vec_delete (rp->output_vector, total_bytes - remaining_bytes, 0);
377  if (vec_len (rp->output_vector) <= 0
379  {
382  }
383 
384  return 0;
385 }
386 
387 clib_error_t *
389 {
392 
393  rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data);
394  clib_file_del (fm, uf);
396 
397  return 0;
398 }
399 
400 void
402 {
404  clib_file_t template = { 0 };
405 
406  pool_get (socket_main.registration_pool, rp);
407  clib_memset (rp, 0, sizeof (*rp));
408 
409  template.read_function = vl_socket_read_ready;
410  template.write_function = vl_socket_write_ready;
411  template.error_function = vl_socket_error_ready;
412  template.file_descriptor = fd;
413  template.private_data = rp - socket_main.registration_pool;
414 
416  rp->vl_api_registration_pool_index = rp - socket_main.registration_pool;
417  rp->clib_file_index = clib_file_add (fm, &template);
418 }
419 
420 static clib_error_t *
422 {
424  socket_main_t *sm = &socket_main;
426  clib_socket_t client;
427  clib_error_t *error;
428 
429  error = clib_socket_accept (sock, &client);
430  if (error)
431  return error;
432 
433  socksvr_file_add (fm, client.fd);
434  return 0;
435 }
436 
437 static clib_error_t *
439 {
440  clib_warning ("why am I here?");
441  return 0;
442 }
443 
444 /*
445  * vl_api_sockclnt_create_t_handler
446  */
447 void
449 {
450  vl_api_registration_t *regp;
452  api_main_t *am = vlibapi_get_main ();
453  hash_pair_t *hp;
454  int rv = 0;
456  u32 i = 0;
457 
458  regp = socket_main.current_rp;
459 
461 
462  regp->name = format (0, "%s%c", mp->name, 0);
463 
464  u32 size = sizeof (*rp) + (nmsg * sizeof (vl_api_message_table_entry_t));
465  rp = vl_msg_api_alloc_zero (size);
466  rp->_vl_msg_id = htons (VL_API_SOCKCLNT_CREATE_REPLY);
467  rp->index = htonl (sock_api_registration_handle (regp));
468  rp->context = mp->context;
469  rp->response = htonl (rv);
470  rp->count = htons (nmsg);
471 
472  /* *INDENT-OFF* */
474  ({
475  rp->message_table[i].index = htons(hp->value[0]);
476  (void) strncpy_s((char *)rp->message_table[i].name,
477  64 /* bytes of space at dst */,
478  (char *)hp->key,
479  64-1 /* chars to copy, without zero byte. */);
480  i++;
481  }));
482  /* *INDENT-ON* */
483  vl_api_send_msg (regp, (u8 *) rp);
484 }
485 
486 /*
487  * vl_api_sockclnt_delete_t_handler
488  */
489 void
491 {
492  vl_api_registration_t *regp;
494 
496  if (!regp)
497  return;
498 
499  u32 reg_index = socket_api_registration_handle_to_index (ntohl (mp->index));
500  rp = vl_msg_api_alloc (sizeof (*rp));
501  rp->_vl_msg_id = htons (VL_API_SOCKCLNT_DELETE_REPLY);
502  rp->context = mp->context;
503 
504  if (!pool_is_free_index (socket_main.registration_pool, reg_index))
505  {
506  rp->response = htonl (1);
507  vl_api_send_msg (regp, (u8 *) rp);
508 
511  }
512  else
513  {
514  clib_warning ("unknown client ID %d", reg_index);
515  rp->response = htonl (-1);
516  vl_api_send_msg (regp, (u8 *) rp);
517  }
518 }
519 
520 clib_error_t *
521 vl_sock_api_send_fd_msg (int socket_fd, int fds[], int n_fds)
522 {
523  struct msghdr mh = { 0 };
524  struct iovec iov[1];
525  char ctl[CMSG_SPACE (sizeof (int) * n_fds)];
526  struct cmsghdr *cmsg;
527  char *msg = "fdmsg";
528  int rv;
529 
530  iov[0].iov_base = msg;
531  iov[0].iov_len = strlen (msg);
532  mh.msg_iov = iov;
533  mh.msg_iovlen = 1;
534 
535  clib_memset (&ctl, 0, sizeof (ctl));
536  mh.msg_control = ctl;
537  mh.msg_controllen = sizeof (ctl);
538  cmsg = CMSG_FIRSTHDR (&mh);
539  cmsg->cmsg_len = CMSG_LEN (sizeof (int) * n_fds);
540  cmsg->cmsg_level = SOL_SOCKET;
541  cmsg->cmsg_type = SCM_RIGHTS;
542  clib_memcpy_fast (CMSG_DATA (cmsg), fds, sizeof (int) * n_fds);
543 
544  while ((rv = sendmsg (socket_fd, &mh, 0)) < 0 && errno == EAGAIN)
545  ;
546  if (rv < 0)
547  return clib_error_return_unix (0, "sendmsg");
548  return 0;
549 }
550 
553 {
554  vl_api_shm_elem_config_t *config = 0, *c;
555  u64 cfg;
556  int i;
557 
558  if (!mp->nitems)
559  {
560  vec_validate (config, 6);
561  config[0].type = VL_API_VLIB_RING;
562  config[0].size = 256;
563  config[0].count = 32;
564 
565  config[1].type = VL_API_VLIB_RING;
566  config[1].size = 1024;
567  config[1].count = 16;
568 
569  config[2].type = VL_API_VLIB_RING;
570  config[2].size = 4096;
571  config[2].count = 2;
572 
573  config[3].type = VL_API_CLIENT_RING;
574  config[3].size = 256;
575  config[3].count = 32;
576 
577  config[4].type = VL_API_CLIENT_RING;
578  config[4].size = 1024;
579  config[4].count = 16;
580 
581  config[5].type = VL_API_CLIENT_RING;
582  config[5].size = 4096;
583  config[5].count = 2;
584 
585  config[6].type = VL_API_QUEUE;
586  config[6].count = 128;
587  config[6].size = sizeof (uword);
588  }
589  else
590  {
591  vec_validate (config, mp->nitems - 1);
592  for (i = 0; i < mp->nitems; i++)
593  {
594  cfg = mp->configs[i];
595  /* Pretty much a hack but it avoids defining our own api type
596  * in memclnt.api */
597  c = (vl_api_shm_elem_config_t *) & cfg;
598  config[i].type = c->type;
599  config[i].count = c->count;
600  config[i].size = c->size;
601  }
602  }
603  return config;
604 }
605 
606 /*
607  * Bootstrap shm api using the socket api
608  */
609 void
611 {
613  ssvm_private_t _memfd_private, *memfd = &_memfd_private;
614  svm_map_region_args_t _args, *a = &_args;
615  vl_api_registration_t *regp;
616  api_main_t *am = vlibapi_get_main ();
617  svm_region_t *vlib_rp;
618  clib_file_t *cf;
619  vl_api_shm_elem_config_t *config = 0;
620  vl_shmem_hdr_t *shmem_hdr;
621  int rv, tries = 1000;
622 
624  if (regp == 0)
625  {
626  clib_warning ("API client disconnected");
627  return;
628  }
630  {
631  rv = -31; /* VNET_API_ERROR_INVALID_REGISTRATION */
632  goto reply;
633  }
634 
635  /*
636  * Set up a memfd segment of the requested size wherein the
637  * shmem data structures will be initialized
638  */
639  clib_memset (memfd, 0, sizeof (*memfd));
640  memfd->ssvm_size = mp->requested_size;
641  memfd->requested_va = 0ULL;
642  memfd->i_am_master = 1;
643  memfd->name = format (0, "%s%c", regp->name, 0);
644 
645  if ((rv = ssvm_master_init_memfd (memfd)))
646  goto reply;
647 
648  /* delete the unused heap created in ssvm_server_init_memfd and mark it
649  * accessible again for ASAN */
650  clib_mem_destroy_mspace (memfd->sh->heap);
651  CLIB_MEM_UNPOISON ((void *) memfd->sh->ssvm_va, memfd->ssvm_size);
652 
653  /* Remember to close this fd when the socket connection goes away */
654  vec_add1 (regp->additional_fds_to_close, memfd->fd);
655 
656  /*
657  * Create a plausible svm_region in the memfd backed segment
658  */
659  clib_memset (a, 0, sizeof (*a));
660  a->baseva = memfd->sh->ssvm_va + MMAP_PAGESIZE;
661  a->size = memfd->ssvm_size - MMAP_PAGESIZE;
662  /* $$$$ might want a different config parameter */
664  a->flags = SVM_FLAGS_MHEAP;
666 
667  /*
668  * Part deux, initialize the svm_region_t shared-memory header
669  * api allocation rings, and so on.
670  */
671  config = vl_api_make_shm_config (mp);
672  vlib_rp = (svm_region_t *) a->baseva;
673  vl_init_shmem (vlib_rp, config, 1 /* is_vlib (dont-care) */ ,
674  1 /* is_private */ );
675 
676  /* Remember who created this. Needs to be post vl_init_shmem */
677  shmem_hdr = (vl_shmem_hdr_t *) vlib_rp->user_ctx;
679 
680  vec_add1 (am->vlib_private_rps, vlib_rp);
681  memfd->sh->ready = 1;
682  vec_free (config);
683 
684  /* Recompute the set of input queues to poll in memclnt_process */
686 
687 reply:
688 
689  rmp = vl_msg_api_alloc (sizeof (*rmp));
690  rmp->_vl_msg_id = htons (VL_API_SOCK_INIT_SHM_REPLY);
691  rmp->context = mp->context;
692  rmp->retval = htonl (rv);
693 
694  /*
695  * Note: The reply message needs to make it out the back door
696  * before we send the magic fd message. That's taken care of by
697  * the send function.
698  */
699  vl_socket_api_send (regp, (u8 *) rmp);
700 
701  if (rv != 0)
702  return;
703 
704  /* Send the magic "here's your sign (aka fd)" socket message */
705  cf = vl_api_registration_file (regp);
706 
707  /* Wait for reply to be consumed before sending the fd */
708  while (tries-- > 0)
709  {
710  int bytes;
711  rv = ioctl (cf->file_descriptor, TIOCOUTQ, &bytes);
712  if (rv < 0)
713  {
714  clib_unix_warning ("ioctl returned");
715  break;
716  }
717  if (bytes == 0)
718  break;
719  usleep (1e3);
720  }
721 
722  vl_sock_api_send_fd_msg (cf->file_descriptor, &memfd->fd, 1);
723 }
724 
725 #define foreach_vlib_api_msg \
726  _(SOCKCLNT_CREATE, sockclnt_create, 1) \
727  _(SOCKCLNT_DELETE, sockclnt_delete, 1) \
728  _(SOCK_INIT_SHM, sock_init_shm, 1)
729 
730 clib_error_t *
732 {
734  clib_file_t template = { 0 };
736  socket_main_t *sm = &socket_main;
738  clib_error_t *error;
739 
740  /* If not explicitly configured, do not bind/enable, etc. */
741  if (sm->socket_name == 0)
742  return 0;
743 
744 #define _(N,n,t) \
745  vl_msg_api_set_handlers(VL_API_##N, #n, \
746  vl_api_##n##_t_handler, \
747  vl_noop_handler, \
748  vl_api_##n##_t_endian, \
749  vl_api_##n##_t_print, \
750  sizeof(vl_api_##n##_t), t);
752 #undef _
753 
754  vec_resize (sm->input_buffer, 4096);
755 
756  sock->config = (char *) sm->socket_name;
758  error = clib_socket_init (sock);
759  if (error)
760  return error;
761 
762  pool_get (sm->registration_pool, rp);
763  clib_memset (rp, 0, sizeof (*rp));
764 
766 
767  template.read_function = socksvr_accept_ready;
768  template.write_function = socksvr_bogus_write;
769  template.file_descriptor = sock->fd;
770  template.private_data = rp - sm->registration_pool;
771 
772  rp->clib_file_index = clib_file_add (fm, &template);
773  return 0;
774 }
775 
776 static clib_error_t *
778 {
779  socket_main_t *sm = &socket_main;
781 
782  /* Defensive driving in case something wipes out early */
783  if (sm->registration_pool)
784  {
785  u32 index;
786  /* *INDENT-OFF* */
787  pool_foreach (rp, sm->registration_pool, ({
788  vl_api_registration_del_file (rp);
789  index = rp->vl_api_registration_pool_index;
790  vl_socket_free_registration_index (index);
791  }));
792 /* *INDENT-ON* */
793  }
794 
795  return 0;
796 }
797 
799 
800 static clib_error_t *
802 {
803  socket_main_t *sm = &socket_main;
804 
806  {
807  if (unformat (input, "socket-name %s", &sm->socket_name))
808  ;
809  /* DEPRECATE: default keyword is ignored */
810  else if (unformat (input, "default"))
811  ;
812  else
813  {
814  return clib_error_return (0, "unknown input '%U'",
815  format_unformat_error, input);
816  }
817  }
818 
819  if (!vec_len (sm->socket_name))
820  sm->socket_name = format (0, "%s/%s", vlib_unix_get_runtime_dir (),
823 
824  return 0;
825 }
826 
828 
829 void
831 {
832 }
833 
834 /*
835  * fd.io coding-style-patch-verification: ON
836  *
837  * Local Variables:
838  * eval: (c-set-style "gnu")
839  * End:
840  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:509
unix_main_t unix_main
Definition: main.c:62
void vlibsocket_reference()
Definition: socket_api.c:830
u64 api_pvt_heap_size
size of the api private mheap
Definition: api_common.h:329
#define API_SOCKET_FILENAME
Definition: socket_api.h:28
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:54
#define CLIB_MEM_UNPOISON(a, s)
Definition: sanitizer.h:47
clib_error_t * vl_sock_api_init(vlib_main_t *vm)
Definition: socket_api.c:731
void vl_msg_api_socket_handler(void *the_msg)
Definition: api_shared.c:786
static void vl_api_registration_del_file(vl_api_registration_t *reg)
Definition: api.h:99
uword requested_va
Definition: ssvm.h:86
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:401
static clib_file_t * vl_api_registration_file(vl_api_registration_t *reg)
Definition: api.h:93
uword ssvm_size
Definition: ssvm.h:85
vl_api_registration_t * registration_pool
Definition: socket_api.h:48
#define ntohs(x)
Definition: af_xdp.bpf.c:29
volatile u32 ready
Definition: ssvm.h:77
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:490
static void vl_api_send_msg(vl_api_registration_t *rp, u8 *elem)
Definition: api.h:35
vl_api_registration_t * current_rp
Definition: socket_api.h:54
vl_socket_args_for_process_t * process_args
Definition: socket_api.h:59
socket_main_t socket_main
Definition: socket_api.c:48
u32 file_descriptor
Definition: file.h:54
#define vec_terminate_c_string(V)
(If necessary) NULL terminate a vector containing a c-string.
Definition: vec.h:1090
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:592
void vl_sock_api_dump_clients(vlib_main_t *vm, api_main_t *am)
Definition: socket_api.c:72
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:144
vlib_main_t * vm
Definition: in2out_ed.c:1582
static clib_error_t * clib_file_write(clib_file_t *f)
Definition: file.h:160
ssvm_shared_header_t * sh
Definition: ssvm.h:84
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
clib_error_t * vl_socket_write_ready(clib_file_t *uf)
Definition: socket_api.c:342
struct msgbuf_ msgbuf_t
Message header structure.
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:252
void * vl_msg_api_alloc_zero(int nbytes)
void * vl_msg_api_alloc(int nbytes)
void vl_api_sockclnt_create_t_handler(vl_api_sockclnt_create_t *mp)
Definition: socket_api.c:448
unsigned char u8
Definition: types.h:56
trace_cfg_t * api_trace_cfg
Current trace configuration.
Definition: api_common.h:277
u8 data[128]
Definition: ipsec_types.api:89
#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:668
#define CLIB_SOCKET_F_IS_SERVER
Definition: socket.h:58
u32 clib_file_index
Socket only: file index.
Definition: api_common.h:67
static vl_api_registration_t * vl_socket_get_registration(u32 reg_index)
Definition: socket_api.h:68
clib_error_t * vl_socket_error_ready(clib_file_t *uf)
Definition: socket_api.c:388
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:513
void vl_api_sock_init_shm_t_handler(vl_api_sock_init_shm_t *mp)
Definition: socket_api.c:610
int ssvm_master_init_memfd(ssvm_private_t *memfd)
Initialize memfd segment master.
Definition: ssvm.c:217
static char * vlib_unix_get_runtime_dir(void)
Definition: unix.h:141
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:433
#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:281
unsigned int u32
Definition: types.h:88
u8 * socket_name
Definition: socket_api.h:39
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:421
vl_registration_type_t registration_type
type
Definition: api_common.h:49
#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:801
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:534
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:1015
clib_error_t * clib_socket_accept(clib_socket_t *server, clib_socket_t *client)
Definition: socket.c:526
struct _unformat_input_t unformat_input_t
unsigned short u16
Definition: types.h:57
u8 data_len
Definition: ikev2_types.api:24
#define clib_error_return_unix(e, args...)
Definition: error.h:102
u32 size
Definition: vhost_user.h:106
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:302
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:429
svm_region_t ** vlib_private_rps
Vector of all mapped shared-VM segments.
Definition: api_common.h:289
u32 flags
Definition: file.h:56
#define VLIB_CONFIG_FUNCTION(x, n,...)
Definition: init.h:182
signed char i8
Definition: types.h:45
clib_error_t * vl_socket_read_ready(clib_file_t *uf)
Definition: socket_api.c:224
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:448
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:227
An API client registration, only in vpp/vlib.
Definition: api_common.h:47
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
Shared memory connection.
Definition: api_common.h:39
svmdb_client_t * c
clib_socket_t socksvr_listen_socket
Definition: socket_api.h:62
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:317
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:380
#define VLIB_MAIN_LOOP_EXIT_FUNCTION(x)
Definition: init.h:178
vl_api_registration_t * vl_socket_api_client_handle_to_registration(u32 handle)
Definition: socket_api.c:99
void vl_api_call_reaper_functions(u32 client_index)
Definition: memory_api.c:235
#define clib_warning(format, args...)
Definition: error.h:59
u8 * output_vector
Socket only: output vector.
Definition: api_common.h:70
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:299
int * additional_fds_to_close
Definition: api_common.h:71
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
Definition: api.h:79
static u32 vl_api_registration_file_index(vl_api_registration_t *reg)
Definition: api.h:87
int fd
memfd segments
Definition: ssvm.h:94
void clib_mem_destroy_mspace(void *mspace)
Definition: mem_dlmalloc.c:241
static uword hash_elts(void *v)
Definition: hash.h:118
#define ASSERT(truth)
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:696
#define vec_delete(V, N, M)
Delete N elements starting at element M.
Definition: vec.h:854
static uword clib_file_add(clib_file_main_t *um, clib_file_t *template)
Definition: file.h:96
Message header structure.
Definition: api_common.h:139
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:890
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:68
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
u8 * name
Definition: ssvm.h:88
void vl_msg_api_free(void *)
#define MMAP_PAGESIZE
Definition: ssvm.h:43
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:552
clib_error_t * vl_sock_api_send_fd_msg(int socket_fd, int fds[], int n_fds)
Definition: socket_api.c:521
#define foreach_vlib_api_msg
Definition: socket_api.c:725
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:52
u32 index
Definition: flow_types.api:221
i8 * input_buffer
Definition: socket_api.h:56
static api_main_t * vlibapi_get_main(void)
Definition: api_common.h:389
#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:117
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:350
#define CLIB_SOCKET_F_ALLOW_GROUP_WRITE
Definition: socket.h:62
int i_am_master
Definition: ssvm.h:90
void vl_socket_process_api_msg(vl_api_registration_t *rp, i8 *input_v)
Definition: socket_api.c:197
static clib_error_t * socksvr_bogus_write(clib_file_t *uf)
Definition: socket_api.c:438
static clib_error_t * socket_exit(vlib_main_t *vm)
Definition: socket_api.c:777
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:171
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128