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