FD.io VPP  v21.10.1-2-g0a485f517
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  {
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;
104  {
105 #if DEBUG > 2
106  clib_warning ("Invalid index %d\n", index);
107 #endif
108  return 0;
109  }
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);
122  msgbuf_t *mb = (msgbuf_t *) (elem - offsetof (msgbuf_t, data));
123  vl_api_registration_t *sock_rp;
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);
150 
151  /* If we didn't finish sending everything, wait for tx space */
152  if (vec_len (sock_rp->output_vector) > 0
154  {
156  fm->file_update (cf, UNIX_FILE_UPDATE_MODIFY);
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 
176  {
177  clib_warning ("main pool index %d already free", pool_index);
178  return;
179  }
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);
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);
205 }
206 
207 int
209 {
211  ALWAYS_ASSERT (rp != 0);
212  return (rp->is_being_removed);
213 }
214 
215 static void
217 {
220  u32 pending_remove_file_index = vl_api_registration_file_index (rp);
221 
222  clib_file_t *zf = fm->file_pool + pending_remove_file_index;
223 
224  clib_file_del (fm, zf);
226 }
227 
228 static void
230 {
232  ALWAYS_ASSERT (rp != 0);
233  if (rp->is_being_removed)
234  {
235  return;
236  }
237  rp->is_being_removed = 1;
240  sizeof (u32));
241 }
242 
243 /*
244  * Read function for API socket.
245  *
246  * Read data from socket, invoke SOCKET_READ_EVENT
247  * for each fully read API message, return 0.
248  * Store incomplete data for next invocation to continue.
249  *
250  * On severe read error, the file is closed.
251  *
252  * As reading is single threaded,
253  * socket_main.input_buffer is used temporarily.
254  * Even its length is modified, but always restored before return.
255  *
256  * Incomplete data is copied into a vector,
257  * pointer saved in registration's unprocessed_input.
258  */
259 clib_error_t *
261 {
264  /* n is the size of data read to input_buffer */
265  int n;
266  /* msg_buffer vector can point to input_buffer or unprocessed_input */
267  i8 *msg_buffer = 0;
268  /* data_for_process is a vector containing one full message, incl msgbuf_t */
269  u8 *data_for_process;
270  /* msgbuf_len is the size of one message, including sizeof (msgbuf_t) */
271  u32 msgbuf_len;
272  u32 save_input_buffer_length = vec_len (socket_main.input_buffer);
274  u32 reg_index = uf->private_data;
275  if (is_being_removed_reg_index (reg_index))
276  {
277  return 0;
278  }
279 
280  rp = vl_socket_get_registration (reg_index);
281 
282  /* Ignore unprocessed_input for now, n describes input_buffer for now. */
285 
286  if (n <= 0)
287  {
288  if (errno != EAGAIN)
289  {
290  /* Severe error, close the file. */
292  }
293  /* EAGAIN means we do not close the file, but no data to process anyway. */
294  return 0;
295  }
296 
297  /* Fake smaller length teporarily, so input_buffer can be used as msg_buffer. */
299 
300  /*
301  * Look for bugs here. This code is tricky because
302  * data read from a stream socket does not honor message
303  * boundaries. In the case of a long message (>4K bytes)
304  * we have to do (at least) 2 reads, etc.
305  */
306  /* Determine msg_buffer. */
307  if (vec_len (rp->unprocessed_input))
308  {
310  msg_buffer = rp->unprocessed_input;
311  }
312  else
313  {
314  msg_buffer = socket_main.input_buffer;
315  }
316  /* Loop to process any full messages. */
317  ASSERT (vec_len (msg_buffer) > 0);
318  do
319  {
320  /* Here, we are not sure how big a chunk of message we have left. */
321  /* Do we at least know how big the full message will be? */
322  if (vec_len (msg_buffer) <= sizeof (msgbuf_t))
323  /* No, so fragment is not a full message. */
324  goto save_and_split;
325 
326  /* Now we know how big the full message will be. */
327  msgbuf_len =
328  ntohl (((msgbuf_t *) msg_buffer)->data_len) + sizeof (msgbuf_t);
329 
330  /* But do we have a full message? */
331  if (msgbuf_len > vec_len (msg_buffer))
332  {
333  save_and_split:
334  /* We don't have the entire message yet. */
335  /* If msg_buffer is unprocessed_input, nothing needs to be done. */
336  if (msg_buffer == socket_main.input_buffer)
337  /* But if we were using the input buffer, save the fragment. */
338  {
339  ASSERT (vec_len (rp->unprocessed_input) == 0);
340  vec_validate (rp->unprocessed_input, vec_len (msg_buffer) - 1);
341  clib_memcpy_fast (rp->unprocessed_input, msg_buffer,
342  vec_len (msg_buffer));
343  vec_set_len (rp->unprocessed_input, vec_len (msg_buffer));
344  }
345  /* No more full messages, restore original input_buffer length. */
346  vec_set_len (socket_main.input_buffer, save_input_buffer_length);
347  return 0;
348  }
349 
350  /*
351  * We have at least one full message.
352  * But msg_buffer can contain more data, so copy one message data
353  * so we can overwrite its length to what single message has.
354  */
355  data_for_process = (u8 *) vec_dup (msg_buffer);
356  vec_set_len (data_for_process, msgbuf_len);
357  /* Everything is ready to signal the SOCKET_READ_EVENT. */
359  a->reg_index = reg_index;
360  a->data = data_for_process;
361 
365  if (vec_len (msg_buffer) > msgbuf_len)
366  /* There are some fragments left. Shrink the msg_buffer to simplify logic. */
367  vec_delete (msg_buffer, msgbuf_len, 0);
368  else
369  /* We are done with msg_buffer. */
370  vec_set_len (msg_buffer, 0);
371  }
372  while (vec_len (msg_buffer) > 0);
373 
374  /* Restore input_buffer, it could have been msg_buffer. */
375  vec_set_len (socket_main.input_buffer, save_input_buffer_length);
376  return 0;
377 }
378 
379 clib_error_t *
381 {
384  int n;
385 
386  u32 reg_index = uf->private_data;
387  if (is_being_removed_reg_index (reg_index))
388  {
389  return 0;
390  }
391 
393 
394  /* Flush output vector. */
395  size_t total_bytes = vec_len (rp->output_vector);
396  size_t bytes_to_send, remaining_bytes = total_bytes;
397  void *p = rp->output_vector;
398  while (remaining_bytes > 0)
399  {
400  bytes_to_send = remaining_bytes > 4096 ? 4096 : remaining_bytes;
401  n = write (uf->file_descriptor, p, bytes_to_send);
402  if (n < 0)
403  {
404  if (errno == EAGAIN)
405  {
406  break;
407  }
408 #if DEBUG > 2
409  clib_warning ("write error, close the file...\n");
410 #endif
412  return 0;
413  }
414  remaining_bytes -= bytes_to_send;
415  p += bytes_to_send;
416  }
417 
418  vec_delete (rp->output_vector, total_bytes - remaining_bytes, 0);
419  if (vec_len (rp->output_vector) <= 0
421  {
423  fm->file_update (uf, UNIX_FILE_UPDATE_MODIFY);
424  }
425 
426  return 0;
427 }
428 
429 clib_error_t *
431 {
432  u32 reg_index = uf->private_data;
434  return 0;
435 }
436 
437 void
439 {
441  clib_file_t template = { 0 };
442 
444  clib_memset (rp, 0, sizeof (*rp));
445 
446  template.read_function = vl_socket_read_ready;
447  template.write_function = vl_socket_write_ready;
448  template.error_function = vl_socket_error_ready;
449  template.file_descriptor = fd;
450  template.description = format (0, "socksrv");
451  template.private_data = rp - socket_main.registration_pool;
452 
455  rp->clib_file_index = clib_file_add (fm, &template);
456 }
457 
458 static clib_error_t *
460 {
462  socket_main_t *sm = &socket_main;
464  clib_socket_t client;
466 
467  error = clib_socket_accept (sock, &client);
468  if (error)
469  return error;
470 
471  socksvr_file_add (fm, client.fd);
472  return 0;
473 }
474 
475 static clib_error_t *
477 {
478  clib_warning ("why am I here?");
479  return 0;
480 }
481 
482 /*
483  * vl_api_sockclnt_create_t_handler
484  */
485 void
487 {
488  vl_api_registration_t *regp;
491  hash_pair_t *hp;
492  int rv = 0;
493  u32 nmsg = hash_elts (am->msg_index_by_name_and_crc);
494  u32 i = 0;
495 
496  regp = socket_main.current_rp;
497 
499 
500  regp->name = format (0, "%s%c", mp->name, 0);
501 
502  u32 size = sizeof (*rp) + (nmsg * sizeof (vl_api_message_table_entry_t));
504  rp->_vl_msg_id = htons (VL_API_SOCKCLNT_CREATE_REPLY);
505  rp->index = htonl (sock_api_registration_handle (regp));
506  rp->context = mp->context;
507  rp->response = htonl (rv);
508  rp->count = htons (nmsg);
509 
510  /* *INDENT-OFF* */
511  hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
512  ({
513  rp->message_table[i].index = htons(hp->value[0]);
514  (void) strncpy_s((char *)rp->message_table[i].name,
515  64 /* bytes of space at dst */,
516  (char *)hp->key,
517  64-1 /* chars to copy, without zero byte. */);
518  i++;
519  }));
520  /* *INDENT-ON* */
521  vl_api_send_msg (regp, (u8 *) rp);
522 }
523 
524 /*
525  * vl_api_sockclnt_delete_t_handler
526  */
527 void
529 {
530  vl_api_registration_t *regp;
532 
534  if (!regp)
535  return;
536 
537  u32 reg_index = socket_api_registration_handle_to_index (ntohl (mp->index));
538  rp = vl_msg_api_alloc (sizeof (*rp));
539  rp->_vl_msg_id = htons (VL_API_SOCKCLNT_DELETE_REPLY);
540  rp->context = mp->context;
541 
543  {
544  rp->response = htonl (1);
545  vl_api_send_msg (regp, (u8 *) rp);
546 
549  }
550  else
551  {
552  clib_warning ("unknown client ID %d", reg_index);
553  rp->response = htonl (-1);
554  vl_api_send_msg (regp, (u8 *) rp);
555  }
556 }
557 
558 clib_error_t *
559 vl_sock_api_send_fd_msg (int socket_fd, int fds[], int n_fds)
560 {
561  struct msghdr mh = { 0 };
562  struct iovec iov[1];
563  char ctl[CMSG_SPACE (sizeof (int) * n_fds)];
564  struct cmsghdr *cmsg;
565  char *msg = "fdmsg";
566  int rv;
567 
568  iov[0].iov_base = msg;
569  iov[0].iov_len = strlen (msg);
570  mh.msg_iov = iov;
571  mh.msg_iovlen = 1;
572 
573  clib_memset (&ctl, 0, sizeof (ctl));
574  mh.msg_control = ctl;
575  mh.msg_controllen = sizeof (ctl);
576  cmsg = CMSG_FIRSTHDR (&mh);
577  cmsg->cmsg_len = CMSG_LEN (sizeof (int) * n_fds);
578  cmsg->cmsg_level = SOL_SOCKET;
579  cmsg->cmsg_type = SCM_RIGHTS;
580  clib_memcpy_fast (CMSG_DATA (cmsg), fds, sizeof (int) * n_fds);
581 
582  while ((rv = sendmsg (socket_fd, &mh, 0)) < 0 && errno == EAGAIN)
583  ;
584  if (rv < 0)
585  return clib_error_return_unix (0, "sendmsg");
586  return 0;
587 }
588 
591 {
592  vl_api_shm_elem_config_t *config = 0, *c;
593  u64 cfg;
594  int i;
595 
596  if (!mp->nitems)
597  {
598  vec_validate (config, 6);
599  config[0].type = VL_API_VLIB_RING;
600  config[0].size = 256;
601  config[0].count = 32;
602 
603  config[1].type = VL_API_VLIB_RING;
604  config[1].size = 1024;
605  config[1].count = 16;
606 
607  config[2].type = VL_API_VLIB_RING;
608  config[2].size = 4096;
609  config[2].count = 2;
610 
611  config[3].type = VL_API_CLIENT_RING;
612  config[3].size = 256;
613  config[3].count = 32;
614 
615  config[4].type = VL_API_CLIENT_RING;
616  config[4].size = 1024;
617  config[4].count = 16;
618 
619  config[5].type = VL_API_CLIENT_RING;
620  config[5].size = 4096;
621  config[5].count = 2;
622 
623  config[6].type = VL_API_QUEUE;
624  config[6].count = 128;
625  config[6].size = sizeof (uword);
626  }
627  else
628  {
629  vec_validate (config, mp->nitems - 1);
630  for (i = 0; i < mp->nitems; i++)
631  {
632  cfg = mp->configs[i];
633  /* Pretty much a hack but it avoids defining our own api type
634  * in memclnt.api */
635  c = (vl_api_shm_elem_config_t *) & cfg;
636  config[i].type = c->type;
637  config[i].count = c->count;
638  config[i].size = c->size;
639  }
640  }
641  return config;
642 }
643 
644 /*
645  * Bootstrap shm api using the socket api
646  */
647 void
649 {
651  ssvm_private_t _memfd_private, *memfd = &_memfd_private;
652  svm_map_region_args_t _args, *a = &_args;
653  vl_api_registration_t *regp;
655  svm_region_t *vlib_rp;
656  clib_file_t *cf;
657  vl_api_shm_elem_config_t *config = 0;
658  vl_shmem_hdr_t *shmem_hdr;
659  int rv, tries = 1000;
660 
662  if (regp == 0)
663  {
664  clib_warning ("API client disconnected");
665  return;
666  }
668  {
669  clib_warning ("Invalid registration");
670  return;
671  }
672 
673  /*
674  * Set up a memfd segment of the requested size wherein the
675  * shmem data structures will be initialized
676  */
677  clib_memset (memfd, 0, sizeof (*memfd));
678  memfd->ssvm_size = mp->requested_size;
679  memfd->requested_va = 0ULL;
680  memfd->is_server = 1;
681  memfd->name = format (0, "%s%c", regp->name, 0);
682 
683  if ((rv = ssvm_server_init_memfd (memfd)))
684  goto reply;
685 
686  /* delete the unused heap created in ssvm_server_init_memfd and mark it
687  * accessible again for ASAN */
688  clib_mem_destroy_heap (memfd->sh->heap);
689  CLIB_MEM_UNPOISON ((void *) memfd->sh->ssvm_va, memfd->ssvm_size);
690 
691  /* Remember to close this fd when the socket connection goes away */
692  vec_add1 (regp->additional_fds_to_close, memfd->fd);
693 
694  /*
695  * Create a plausible svm_region in the memfd backed segment
696  */
697  clib_memset (a, 0, sizeof (*a));
698  a->baseva = memfd->sh->ssvm_va + MMAP_PAGESIZE;
699  a->size = memfd->ssvm_size - MMAP_PAGESIZE;
700  /* $$$$ might want a different config parameter */
701  a->pvt_heap_size = am->api_pvt_heap_size;
702  a->flags = SVM_FLAGS_MHEAP;
704 
705  /*
706  * Part deux, initialize the svm_region_t shared-memory header
707  * api allocation rings, and so on.
708  */
709  config = vl_api_make_shm_config (mp);
710  vlib_rp = (svm_region_t *) a->baseva;
711  vl_init_shmem (vlib_rp, config, 1 /* is_vlib (dont-care) */ ,
712  1 /* is_private */ );
713 
714  /* Remember who created this. Needs to be post vl_init_shmem */
715  shmem_hdr = (vl_shmem_hdr_t *) vlib_rp->user_ctx;
717 
718  vec_add1 (am->vlib_private_rps, vlib_rp);
719  memfd->sh->ready = 1;
720  vec_free (config);
721 
722  /* Recompute the set of input queues to poll in memclnt_process */
724 
725 reply:
726 
727  rmp = vl_msg_api_alloc (sizeof (*rmp));
728  rmp->_vl_msg_id = htons (VL_API_SOCK_INIT_SHM_REPLY);
729  rmp->context = mp->context;
730  rmp->retval = htonl (rv);
731 
732  /*
733  * Note: The reply message needs to make it out the back door
734  * before we send the magic fd message. That's taken care of by
735  * the send function.
736  */
737  vl_socket_api_send (regp, (u8 *) rmp);
738 
739  if (rv != 0)
740  return;
741 
742  /* Send the magic "here's your sign (aka fd)" socket message */
743  cf = vl_api_registration_file (regp);
744  if (!cf)
745  {
746  clib_warning ("cf removed");
747  return;
748  }
749 
750  /* Wait for reply to be consumed before sending the fd */
751  while (tries-- > 0)
752  {
753  int bytes;
754  rv = ioctl (cf->file_descriptor, TIOCOUTQ, &bytes);
755  if (rv < 0)
756  {
757  clib_unix_warning ("ioctl returned");
758  break;
759  }
760  if (bytes == 0)
761  break;
762  usleep (1e3);
763  }
764 
765  vl_sock_api_send_fd_msg (cf->file_descriptor, &memfd->fd, 1);
766 }
767 
768 #define foreach_vlib_api_msg \
769  _(SOCKCLNT_CREATE, sockclnt_create, 1) \
770  _(SOCKCLNT_DELETE, sockclnt_delete, 1) \
771  _(SOCK_INIT_SHM, sock_init_shm, 1)
772 
773 clib_error_t *
775 {
777  clib_file_t template = { 0 };
779  socket_main_t *sm = &socket_main;
782 
783  /* If not explicitly configured, do not bind/enable, etc. */
784  if (sm->socket_name == 0)
785  return 0;
786 
787 #define _(N,n,t) \
788  vl_msg_api_set_handlers(VL_API_##N, #n, \
789  vl_api_##n##_t_handler, \
790  vl_noop_handler, \
791  vl_api_##n##_t_endian, \
792  vl_api_##n##_t_print, \
793  sizeof(vl_api_##n##_t), t);
795 #undef _
796 
797  vec_resize (sm->input_buffer, 4096);
798 
799  sock->config = (char *) sm->socket_name;
801  error = clib_socket_init (sock);
802  if (error)
803  return error;
804 
805  pool_get (sm->registration_pool, rp);
806  clib_memset (rp, 0, sizeof (*rp));
807 
809 
810  template.read_function = socksvr_accept_ready;
811  template.write_function = socksvr_bogus_write;
812  template.file_descriptor = sock->fd;
813  template.description = format (0, "socksvr %s", sock->config);
814  template.private_data = rp - sm->registration_pool;
815 
816  rp->clib_file_index = clib_file_add (fm, &template);
817  return 0;
818 }
819 
820 static clib_error_t *
822 {
823  socket_main_t *sm = &socket_main;
825 
826  /* Defensive driving in case something wipes out early */
827  if (sm->registration_pool)
828  {
829  u32 index;
830  /* *INDENT-OFF* */
831  pool_foreach (rp, sm->registration_pool) {
835  }
836 /* *INDENT-ON* */
837  }
838 
839  return 0;
840 }
841 
843 
844 static clib_error_t *
846 {
847  socket_main_t *sm = &socket_main;
848 
850  {
851  if (unformat (input, "socket-name %s", &sm->socket_name))
852  ;
853  /* DEPRECATE: default keyword is ignored */
854  else if (unformat (input, "default"))
855  ;
856  else
857  {
858  return clib_error_return (0, "unknown input '%U'",
859  format_unformat_error, input);
860  }
861  }
862 
863  if (!vec_len (sm->socket_name))
864  sm->socket_name = format (0, "%s/%s", vlib_unix_get_runtime_dir (),
867 
868  return 0;
869 }
870 
872 
873 void
875 {
876 }
877 
878 /*
879  * fd.io coding-style-patch-verification: ON
880  *
881  * Local Variables:
882  * eval: (c-set-style "gnu")
883  * End:
884  */
vec_reset_length
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
Definition: vec_bootstrap.h:194
ssvm_private_t::requested_va
uword requested_va
Definition: ssvm.h:85
vl_api_sockclnt_create_reply_t::response
i32 response
Definition: memclnt.api:166
clib_file::file_descriptor
u32 file_descriptor
Definition: file.h:54
CLIB_SOCKET_F_IS_SERVER
#define CLIB_SOCKET_F_IS_SERVER
Definition: socket.h:58
socket_main_t::process_args
vl_socket_args_for_process_t * process_args
Definition: socket_api.h:59
vl_api_queue_cursizes
volatile int ** vl_api_queue_cursizes
Definition: memory_api.c:61
vl_api_client_index_to_registration
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
Definition: api.h:79
msgbuf_t
struct msgbuf_ msgbuf_t
Message header structure.
socket_api_registration_handle_to_index
static u32 socket_api_registration_handle_to_index(u32 reg_index)
Definition: socket_api.c:60
api.h
file_main
clib_file_main_t file_main
Definition: main.c:63
vl_api_registration_file_index
static u32 vl_api_registration_file_index(vl_api_registration_t *reg)
Definition: api.h:87
clib_file_write
static clib_error_t * clib_file_write(clib_file_t *f)
Definition: file.h:160
vec_add
#define vec_add(V, E, N)
Add N elements to end of vector V (no header, unspecified alignment)
Definition: vec.h:688
vl_socket_process_api_msg
void vl_socket_process_api_msg(vl_api_registration_t *rp, i8 *input_v)
Definition: socket_api.c:197
ntohs
#define ntohs(x)
Definition: af_xdp.bpf.c:29
vl_api_sock_init_shm_t
Definition: memclnt.api:189
SOCK_API_REG_HANDLE_BIT
#define SOCK_API_REG_HANDLE_BIT
Definition: socket_api.c:50
VL_API_CLIENT_RING
@ VL_API_CLIENT_RING
Definition: memory_shared.h:47
vl_api_sock_init_shm_reply_t
Definition: memclnt.api:197
vl_api_shm_elem_config_::type
u8 type
Definition: memory_shared.h:53
vl_api_send_msg
static void vl_api_send_msg(vl_api_registration_t *rp, u8 *elem)
Definition: api.h:35
f
vlib_frame_t * f
Definition: interface_output.c:1098
vl_api_registration_::is_being_removed
int is_being_removed
Definition: api_common.h:60
hash_foreach_pair
#define hash_foreach_pair(p, v, body)
Iterate over hash pairs.
Definition: hash.h:373
pool_elt_at_index
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:549
ssvm_private_t::ssvm_size
uword ssvm_size
Definition: ssvm.h:84
socket_main_t::socket_name
u8 * socket_name
Definition: socket_api.h:39
unix_main
unix_main_t unix_main
Definition: main.c:62
vl_api_sock_init_shm_reply_t::retval
i32 retval
Definition: memclnt.api:200
REGISTRATION_TYPE_SOCKET_LISTEN
@ REGISTRATION_TYPE_SOCKET_LISTEN
Socket listener
Definition: api_common.h:40
vl_api_sock_init_shm_t::configs
u64 configs[nitems]
Definition: memclnt.api:194
vl_msg_api_socket_handler
void vl_msg_api_socket_handler(void *the_msg)
Definition: api_shared.c:800
ssvm_shared_header_t::heap
void * heap
Definition: ssvm.h:64
clib_error_return
#define clib_error_return(e, args...)
Definition: error.h:99
ssvm_server_init_memfd
int ssvm_server_init_memfd(ssvm_private_t *memfd)
Initialize memfd segment server.
Definition: ssvm.c:217
socket_main_t
Definition: socket_api.h:36
REGISTRATION_TYPE_FREE
@ REGISTRATION_TYPE_FREE
Definition: api_common.h:38
vec_append
#define vec_append(v1, v2)
Append v2 after v1.
Definition: vec.h:911
vl_api_registration_::registration_type
vl_registration_type_t registration_type
type
Definition: api_common.h:49
hash_elts
static uword hash_elts(void *v)
Definition: hash.h:118
u16
unsigned short u16
Definition: types.h:57
clib_file::private_data
u64 private_data
Definition: file.h:64
am
app_main_t * am
Definition: application.c:489
pool_put
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:305
vl_api_sock_init_shm_t::nitems
u8 nitems
Definition: memclnt.api:193
vm
vlib_main_t * vm
X-connect all packets from the HOST to the PHY.
Definition: nat44_ei.c:3047
vec_delete
#define vec_delete(V, N, M)
Delete N elements starting at element M.
Definition: vec.h:875
fm
vnet_feature_main_t * fm
Definition: nat44_ei_hairpinning.c:592
vl_socket_api_client_handle_to_registration
vl_api_registration_t * vl_socket_api_client_handle_to_registration(u32 handle)
Definition: socket_api.c:99
byte_order.h
VL_API_VLIB_RING
@ VL_API_VLIB_RING
Definition: memory_shared.h:46
socksvr_accept_ready
static clib_error_t * socksvr_accept_ready(clib_file_t *uf)
Definition: socket_api.c:459
ssvm_private_t::sh
ssvm_shared_header_t * sh
Definition: ssvm.h:83
ssvm_shared_header_t::ssvm_va
uword ssvm_va
Definition: ssvm.h:67
clib_file_main_t
Definition: file.h:85
unformat_input_t
struct _unformat_input_t unformat_input_t
vl_msg_api_alloc_zero
void * vl_msg_api_alloc_zero(int nbytes)
Definition: memory_shared.c:214
vl_socket_read_ready
clib_error_t * vl_socket_read_ready(clib_file_t *uf)
Definition: socket_api.c:260
sock_api_registration_handle
static u32 sock_api_registration_handle(vl_api_registration_t *regp)
Definition: socket_api.c:53
vlib_process_signal_event
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
Definition: node_funcs.h:1019
socket_main_t::current_rp
vl_api_registration_t * current_rp
Definition: socket_api.h:54
clib_memcpy_fast
static_always_inline void * clib_memcpy_fast(void *restrict dst, const void *restrict src, size_t n)
Definition: string.h:92
unix_save_error
static void unix_save_error(unix_main_t *um, clib_error_t *error)
Definition: unix.h:127
vl_shmem_hdr_
Definition: memory_shared.h:76
clib_unix_warning
#define clib_unix_warning(format, args...)
Definition: error.h:68
error
Definition: cJSON.c:88
socket_cleanup_pending_remove_registration_cb
static void socket_cleanup_pending_remove_registration_cb(u32 *preg_index)
Definition: socket_api.c:216
VLIB_CONFIG_FUNCTION
#define VLIB_CONFIG_FUNCTION(x, n,...)
Definition: init.h:181
unformat
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
pool_is_free_index
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:302
vl_api_sock_init_shm_t::context
u32 context
Definition: memclnt.api:191
svm_region_init_mapped_region
void svm_region_init_mapped_region(svm_map_region_args_t *a, svm_region_t *rp)
Definition: svm.c:445
vl_api_sockclnt_delete_reply_t::response
i32 response
Definition: memclnt.api:183
pool_foreach
#define pool_foreach(VAR, POOL)
Iterate through pool.
Definition: pool.h:534
vl_api_sockclnt_delete_t::context
u32 context
Definition: memclnt.api:177
socket_main
socket_main_t socket_main
Definition: socket_api.c:48
socksvr_bogus_write
static clib_error_t * socksvr_bogus_write(clib_file_t *uf)
Definition: socket_api.c:476
vec_len
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
Definition: vec_bootstrap.h:142
UNIX_FILE_DATA_AVAILABLE_TO_WRITE
#define UNIX_FILE_DATA_AVAILABLE_TO_WRITE
Definition: file.h:57
vec_add1
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:606
is_being_removed_reg_index
int is_being_removed_reg_index(u32 reg_index)
Definition: socket_api.c:208
vec_dup
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:444
vl_socket_api_send
void vl_socket_api_send(vl_api_registration_t *rp, u8 *elem)
Definition: socket_api.c:114
clib_file
Definition: file.h:51
vl_api_registration_::additional_fds_to_close
int * additional_fds_to_close
Definition: api_common.h:72
vl_api_shm_elem_config_::count
u16 count
Definition: memory_shared.h:55
vl_api_force_rpc_call_main_thread
void vl_api_force_rpc_call_main_thread(void *fp, u8 *data, u32 data_length)
Definition: vlib_api.c:631
vl_api_registration_
An API client registration, only in vpp/vlib.
Definition: api_common.h:47
unformat_check_input
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:163
vlib_config_function_runtime_t
Definition: init.h:68
vl_api_sockclnt_create_t_handler
void vl_api_sockclnt_create_t_handler(vl_api_sockclnt_create_t *mp)
Definition: socket_api.c:486
vl_api_sockclnt_create_reply_t::count
u16 count
Definition: memclnt.api:168
c
svmdb_client_t * c
Definition: vpp_get_metrics.c:48
clib_mem_destroy_heap
void clib_mem_destroy_heap(clib_mem_heap_t *heap)
Definition: mem_dlmalloc.c:566
vl_api_sock_init_shm_t_handler
void vl_api_sock_init_shm_t_handler(vl_api_sock_init_shm_t *mp)
Definition: socket_api.c:648
uword
u64 uword
Definition: types.h:112
msgbuf_::data
u8 data[0]
actual message begins here
Definition: api_common.h:145
vlib_unix_get_runtime_dir
static char * vlib_unix_get_runtime_dir(void)
Definition: unix.h:151
socket_main_t::socksvr_listen_socket
clib_socket_t socksvr_listen_socket
Definition: socket_api.h:62
vl_api_registration_::clib_file_index
u32 clib_file_index
Socket only: file index.
Definition: api_common.h:68
vlibsocket_reference
void vlibsocket_reference()
Definition: socket_api.c:874
vlibapi_get_main
static api_main_t * vlibapi_get_main(void)
Definition: api_common.h:390
vl_sock_api_dump_clients
void vl_sock_api_dump_clients(vlib_main_t *vm, api_main_t *am)
Definition: socket_api.c:72
SOCKET_READ_EVENT
@ SOCKET_READ_EVENT
Definition: api.h:134
format_unformat_error
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
pool_get
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:255
vl_shmem_hdr_::clib_file_index
u32 clib_file_index
Definition: memory_shared.h:104
vl_socket_error_ready
clib_error_t * vl_socket_error_ready(clib_file_t *uf)
Definition: socket_api.c:430
vec_validate
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment)
Definition: vec.h:523
vl_init_shmem
void vl_init_shmem(svm_region_t *vlib_rp, vl_api_shm_elem_config_t *config, int is_vlib, int is_private_region)
Definition: memory_shared.c:492
clib_file::flags
u32 flags
Definition: file.h:56
ALWAYS_ASSERT
#define ALWAYS_ASSERT(truth)
Definition: error_bootstrap.h:89
vlib_cli_output
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:716
vl_api_make_shm_config
vl_api_shm_elem_config_t * vl_api_make_shm_config(vl_api_sock_init_shm_t *mp)
Definition: socket_api.c:590
vl_sock_api_init
clib_error_t * vl_sock_api_init(vlib_main_t *vm)
Definition: socket_api.c:774
vl_api_sockclnt_delete_t_handler
void vl_api_sockclnt_delete_t_handler(vl_api_sockclnt_delete_t *mp)
Definition: socket_api.c:528
MMAP_PAGESIZE
#define MMAP_PAGESIZE
Definition: ssvm.h:42
api_main_t
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:228
data
u8 data[128]
Definition: ipsec_types.api:95
vl_api_sock_init_shm_t::requested_size
u32 requested_size
Definition: memclnt.api:192
vec_set_len
#define vec_set_len(v, l)
Set vector length to a user-defined value.
Definition: vec_bootstrap.h:179
vl_sock_api_send_fd_msg
clib_error_t * vl_sock_api_send_fd_msg(int socket_fd, int fds[], int n_fds)
Definition: socket_api.c:559
vec_free
#define vec_free(V)
Free vector's memory (no header).
Definition: vec.h:395
size
u32 size
Definition: vhost_user.h:125
index
u32 index
Definition: flow_types.api:221
vl_socket_args_for_process_t
Definition: socket_api.h:30
vl_msg_api_free
void vl_msg_api_free(void *)
Definition: memory_shared.c:311
vl_api_sock_init_shm_t::client_index
u32 client_index
Definition: memclnt.api:190
u64
unsigned long u64
Definition: types.h:89
vl_api_registration_file
static clib_file_t * vl_api_registration_file(vl_api_registration_t *reg)
Definition: api.h:93
i8
signed char i8
Definition: types.h:45
format
description fragment has unexpected format
Definition: map.api:433
ASSERT
#define ASSERT(truth)
Definition: error_bootstrap.h:69
vl_api_sockclnt_create_reply_t
Definition: memclnt.api:163
clib_socket_init
__clib_export clib_error_t * clib_socket_init(clib_socket_t *s)
Definition: socket.c:403
data_len
u8 data_len
Definition: ikev2_types.api:24
clib_file_del
static void clib_file_del(clib_file_main_t *um, clib_file_t *f)
Definition: file.h:109
vl_socket_request_remove_reg_index
static void vl_socket_request_remove_reg_index(u32 reg_index)
Definition: socket_api.c:229
vl_socket_free_registration_index
void vl_socket_free_registration_index(u32 pool_index)
Definition: socket_api.c:169
u32
unsigned int u32
Definition: types.h:88
svm_region_::user_ctx
volatile void * user_ctx
Definition: svm_common.h:48
vl_api_sockclnt_create_t::context
u32 context
Definition: memclnt.api:159
CLIB_MEM_UNPOISON
#define CLIB_MEM_UNPOISON(a, s)
Definition: sanitizer.h:114
vl_api_sockclnt_delete_reply_t
Definition: memclnt.api:181
CLIB_SOCKET_F_ALLOW_GROUP_WRITE
#define CLIB_SOCKET_F_ALLOW_GROUP_WRITE
Definition: socket.h:62
ssvm_private_t::is_server
int is_server
Definition: ssvm.h:89
vl_api_sockclnt_delete_t::client_index
u32 client_index
Definition: memclnt.api:176
socksvr_file_add
void socksvr_file_add(clib_file_main_t *fm, int fd)
Definition: socket_api.c:438
vl_socket_get_registration
static vl_api_registration_t * vl_socket_get_registration(u32 reg_index)
Definition: socket_api.h:68
UNIX_FILE_UPDATE_MODIFY
@ UNIX_FILE_UPDATE_MODIFY
Definition: file.h:81
clib_error_return_unix
#define clib_error_return_unix(e, args...)
Definition: error.h:102
pool_elts
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:127
vl_socket_write_ready
clib_error_t * vl_socket_write_ready(clib_file_t *uf)
Definition: socket_api.c:380
clib_file_add
static uword clib_file_add(clib_file_main_t *um, clib_file_t *template)
Definition: file.h:96
vec_resize
#define vec_resize(V, N)
Resize a vector (no header, unspecified alignment) Add N elements to end of given vector V,...
Definition: vec.h:296
msgbuf_
Message header structure.
Definition: api_common.h:140
socket_exit
static clib_error_t * socket_exit(vlib_main_t *vm)
Definition: socket_api.c:821
vl_api_registration_::output_vector
u8 * output_vector
Socket only: output vector.
Definition: api_common.h:71
socket_main_t::input_buffer
i8 * input_buffer
Definition: socket_api.h:56
vl_api_sock_init_shm_reply_t::context
u32 context
Definition: memclnt.api:199
clib_memset
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
vlib_main_t
Definition: main.h:102
ssvm_shared_header_t::ready
volatile u32 ready
Definition: ssvm.h:76
vlib_get_main
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:38
svm_region_
Definition: svm_common.h:35
vl_socket_api_registration_handle_is_valid
u8 vl_socket_api_registration_handle_is_valid(u32 reg_handle)
Definition: socket_api.c:66
u8
unsigned char u8
Definition: types.h:56
ssvm_private_t::name
u8 * name
Definition: ssvm.h:87
vl_api_call_reaper_functions
void vl_api_call_reaper_functions(u32 client_index)
Definition: memory_api.c:241
clib_error_t
Definition: clib_error.h:21
vl_api_sockclnt_delete_t
Definition: memclnt.api:175
a
a
Definition: bitmap.h:525
ssvm_private_t::fd
int fd
memfd segments
Definition: ssvm.h:93
vec_terminate_c_string
#define vec_terminate_c_string(V)
(If necessary) NULL terminate a vector containing a c-string.
Definition: vec.h:1132
vl_api_registration_del_file
static void vl_api_registration_del_file(vl_api_registration_t *reg)
Definition: api.h:99
vl_api_sockclnt_create_reply_t::context
u32 context
Definition: memclnt.api:165
vl_api_sockclnt_delete_t::index
u32 index
Definition: memclnt.api:178
i
int i
Definition: flowhash_template.h:376
clib_warning
#define clib_warning(format, args...)
Definition: error.h:59
foreach_vlib_api_msg
#define foreach_vlib_api_msg
Definition: socket_api.c:768
rv
int __clib_unused rv
Definition: application.c:491
vl_memory_api_h.h
REGISTRATION_TYPE_SHMEM
@ REGISTRATION_TYPE_SHMEM
Shared memory connection.
Definition: api_common.h:39
SVM_FLAGS_MHEAP
#define SVM_FLAGS_MHEAP
Definition: svm_common.h:28
vl_api_registration_::name
u8 * name
Client name.
Definition: api_common.h:54
ssvm.h
vl_api_registration_::unprocessed_input
i8 * unprocessed_input
Socket only: pending input.
Definition: api_common.h:69
VLIB_MAIN_LOOP_EXIT_FUNCTION
#define VLIB_MAIN_LOOP_EXIT_FUNCTION(x)
Definition: init.h:177
vl_api_sockclnt_create_reply_t::index
u32 index
Definition: memclnt.api:167
ssvm_private_t
Definition: ssvm.h:81
clib_socket_t
struct _socket_t clib_socket_t
VL_API_QUEUE
@ VL_API_QUEUE
Definition: memory_shared.h:48
vl_api_shm_elem_config_::size
u32 size
Definition: memory_shared.h:56
vl_api_clnt_node
vlib_node_registration_t vl_api_clnt_node
(constructor) VLIB_REGISTER_NODE (vl_api_clnt_node)
Definition: vlib_api.c:434
vl_api_sockclnt_create_t::name
string name[64]
Definition: memclnt.api:160
vl_api_shm_elem_config_
Definition: memory_shared.h:51
REGISTRATION_TYPE_SOCKET_SERVER
@ REGISTRATION_TYPE_SOCKET_SERVER
Socket server.
Definition: api_common.h:41
vl_api_sockclnt_delete_reply_t::context
u32 context
Definition: memclnt.api:182
vl_memory_msg_enum.h
socket_main_t::registration_pool
vl_api_registration_t * registration_pool
Definition: socket_api.h:48
API_SOCKET_FILENAME
#define API_SOCKET_FILENAME
Definition: socket_api.h:28
vl_api_sockclnt_create_t
Definition: memclnt.api:158
UNFORMAT_END_OF_INPUT
#define UNFORMAT_END_OF_INPUT
Definition: format.h:137
hash_pair_t
Definition: hash.h:159
clib_socket_accept
__clib_export clib_error_t * clib_socket_accept(clib_socket_t *server, clib_socket_t *client)
Definition: socket.c:593
vl_api_registration_::vl_api_registration_pool_index
u32 vl_api_registration_pool_index
Index in VLIB's brain (not shared memory).
Definition: api_common.h:52
vl_msg_api_alloc
void * vl_msg_api_alloc(int nbytes)
Definition: memory_shared.c:199
svm_map_region_args_
Definition: svm_common.h:66
socksvr_config
static clib_error_t * socksvr_config(vlib_main_t *vm, unformat_input_t *input)
Definition: socket_api.c:845