FD.io VPP  v20.01-rc0-847-g4c6b1b6da
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  strncpy_s((char *)rp->message_table[i].name, 64 /* bytes of space at dst */,
473  (char *)hp->key, 64-1 /* chars to copy, without zero byte. */);
474  i++;
475  }));
476  /* *INDENT-ON* */
477  vl_api_send_msg (regp, (u8 *) rp);
478 }
479 
480 /*
481  * vl_api_sockclnt_delete_t_handler
482  */
483 void
485 {
486  vl_api_registration_t *regp;
488 
490  if (!regp)
491  return;
492 
493  u32 reg_index = socket_api_registration_handle_to_index (ntohl (mp->index));
494  rp = vl_msg_api_alloc (sizeof (*rp));
495  rp->_vl_msg_id = htons (VL_API_SOCKCLNT_DELETE_REPLY);
496  rp->context = mp->context;
497 
498  if (!pool_is_free_index (socket_main.registration_pool, reg_index))
499  {
500  rp->response = htonl (1);
501  vl_api_send_msg (regp, (u8 *) rp);
502 
505  }
506  else
507  {
508  clib_warning ("unknown client ID %d", reg_index);
509  rp->response = htonl (-1);
510  vl_api_send_msg (regp, (u8 *) rp);
511  }
512 }
513 
514 clib_error_t *
515 vl_sock_api_send_fd_msg (int socket_fd, int fds[], int n_fds)
516 {
517  struct msghdr mh = { 0 };
518  struct iovec iov[1];
519  char ctl[CMSG_SPACE (sizeof (int) * n_fds)];
520  struct cmsghdr *cmsg;
521  char *msg = "fdmsg";
522  int rv;
523 
524  iov[0].iov_base = msg;
525  iov[0].iov_len = strlen (msg);
526  mh.msg_iov = iov;
527  mh.msg_iovlen = 1;
528 
529  clib_memset (&ctl, 0, sizeof (ctl));
530  mh.msg_control = ctl;
531  mh.msg_controllen = sizeof (ctl);
532  cmsg = CMSG_FIRSTHDR (&mh);
533  cmsg->cmsg_len = CMSG_LEN (sizeof (int) * n_fds);
534  cmsg->cmsg_level = SOL_SOCKET;
535  cmsg->cmsg_type = SCM_RIGHTS;
536  clib_memcpy_fast (CMSG_DATA (cmsg), fds, sizeof (int) * n_fds);
537 
538  rv = sendmsg (socket_fd, &mh, 0);
539  if (rv < 0)
540  return clib_error_return_unix (0, "sendmsg");
541  return 0;
542 }
543 
546 {
547  vl_api_shm_elem_config_t *config = 0, *c;
548  u64 cfg;
549  int i;
550 
551  if (!mp->nitems)
552  {
553  vec_validate (config, 6);
554  config[0].type = VL_API_VLIB_RING;
555  config[0].size = 256;
556  config[0].count = 32;
557 
558  config[1].type = VL_API_VLIB_RING;
559  config[1].size = 1024;
560  config[1].count = 16;
561 
562  config[2].type = VL_API_VLIB_RING;
563  config[2].size = 4096;
564  config[2].count = 2;
565 
566  config[3].type = VL_API_CLIENT_RING;
567  config[3].size = 256;
568  config[3].count = 32;
569 
570  config[4].type = VL_API_CLIENT_RING;
571  config[4].size = 1024;
572  config[4].count = 16;
573 
574  config[5].type = VL_API_CLIENT_RING;
575  config[5].size = 4096;
576  config[5].count = 2;
577 
578  config[6].type = VL_API_QUEUE;
579  config[6].count = 128;
580  config[6].size = sizeof (uword);
581  }
582  else
583  {
584  vec_validate (config, mp->nitems - 1);
585  for (i = 0; i < mp->nitems; i++)
586  {
587  cfg = mp->configs[i];
588  /* Pretty much a hack but it avoids defining our own api type
589  * in memclnt.api */
590  c = (vl_api_shm_elem_config_t *) & cfg;
591  config[i].type = c->type;
592  config[i].count = c->count;
593  config[i].size = c->size;
594  }
595  }
596  return config;
597 }
598 
599 /*
600  * Bootstrap shm api using the socket api
601  */
602 void
604 {
606  ssvm_private_t _memfd_private, *memfd = &_memfd_private;
607  svm_map_region_args_t _args, *a = &_args;
608  vl_api_registration_t *regp;
609  api_main_t *am = vlibapi_get_main ();
610  svm_region_t *vlib_rp;
611  clib_file_t *cf;
612  vl_api_shm_elem_config_t *config = 0;
613  vl_shmem_hdr_t *shmem_hdr;
614  int rv, tries = 1000;
615 
617  if (regp == 0)
618  {
619  clib_warning ("API client disconnected");
620  return;
621  }
623  {
624  rv = -31; /* VNET_API_ERROR_INVALID_REGISTRATION */
625  goto reply;
626  }
627 
628  /*
629  * Set up a memfd segment of the requested size wherein the
630  * shmem data structures will be initialized
631  */
632  clib_memset (memfd, 0, sizeof (*memfd));
633  memfd->ssvm_size = mp->requested_size;
634  memfd->requested_va = 0ULL;
635  memfd->i_am_master = 1;
636  memfd->name = format (0, "%s%c", regp->name, 0);
637 
638  if ((rv = ssvm_master_init_memfd (memfd)))
639  goto reply;
640 
641  /* Remember to close this fd when the socket connection goes away */
642  vec_add1 (regp->additional_fds_to_close, memfd->fd);
643 
644  /*
645  * Create a plausible svm_region in the memfd backed segment
646  */
647  clib_memset (a, 0, sizeof (*a));
648  a->baseva = memfd->sh->ssvm_va + MMAP_PAGESIZE;
649  a->size = memfd->ssvm_size - MMAP_PAGESIZE;
650  /* $$$$ might want a different config parameter */
652  a->flags = SVM_FLAGS_MHEAP;
654 
655  /*
656  * Part deux, initialize the svm_region_t shared-memory header
657  * api allocation rings, and so on.
658  */
659  config = vl_api_make_shm_config (mp);
660  vlib_rp = (svm_region_t *) a->baseva;
661  vl_init_shmem (vlib_rp, config, 1 /* is_vlib (dont-care) */ ,
662  1 /* is_private */ );
663 
664  /* Remember who created this. Needs to be post vl_init_shmem */
665  shmem_hdr = (vl_shmem_hdr_t *) vlib_rp->user_ctx;
667 
668  vec_add1 (am->vlib_private_rps, vlib_rp);
669  memfd->sh->ready = 1;
670  vec_free (config);
671 
672  /* Recompute the set of input queues to poll in memclnt_process */
674 
675 reply:
676 
677  rmp = vl_msg_api_alloc (sizeof (*rmp));
678  rmp->_vl_msg_id = htons (VL_API_SOCK_INIT_SHM_REPLY);
679  rmp->context = mp->context;
680  rmp->retval = htonl (rv);
681 
682  /*
683  * Note: The reply message needs to make it out the back door
684  * before we send the magic fd message. That's taken care of by
685  * the send function.
686  */
687  vl_socket_api_send (regp, (u8 *) rmp);
688 
689  if (rv != 0)
690  return;
691 
692  /* Send the magic "here's your sign (aka fd)" socket message */
693  cf = vl_api_registration_file (regp);
694 
695  /* Wait for reply to be consumed before sending the fd */
696  while (tries-- > 0)
697  {
698  int bytes;
699  rv = ioctl (cf->file_descriptor, TIOCOUTQ, &bytes);
700  if (rv < 0)
701  {
702  clib_unix_warning ("ioctl returned");
703  break;
704  }
705  if (bytes == 0)
706  break;
707  usleep (1e3);
708  }
709 
710  vl_sock_api_send_fd_msg (cf->file_descriptor, &memfd->fd, 1);
711 }
712 
713 #define foreach_vlib_api_msg \
714  _(SOCKCLNT_CREATE, sockclnt_create, 1) \
715  _(SOCKCLNT_DELETE, sockclnt_delete, 1) \
716  _(SOCK_INIT_SHM, sock_init_shm, 1)
717 
718 clib_error_t *
720 {
722  clib_file_t template = { 0 };
724  socket_main_t *sm = &socket_main;
726  clib_error_t *error;
727 
728  /* If not explicitly configured, do not bind/enable, etc. */
729  if (sm->socket_name == 0)
730  return 0;
731 
732 #define _(N,n,t) \
733  vl_msg_api_set_handlers(VL_API_##N, #n, \
734  vl_api_##n##_t_handler, \
735  vl_noop_handler, \
736  vl_api_##n##_t_endian, \
737  vl_api_##n##_t_print, \
738  sizeof(vl_api_##n##_t), t);
740 #undef _
741 
742  vec_resize (sm->input_buffer, 4096);
743 
744  sock->config = (char *) sm->socket_name;
746  error = clib_socket_init (sock);
747  if (error)
748  return error;
749 
750  pool_get (sm->registration_pool, rp);
751  clib_memset (rp, 0, sizeof (*rp));
752 
754 
755  template.read_function = socksvr_accept_ready;
756  template.write_function = socksvr_bogus_write;
757  template.file_descriptor = sock->fd;
758  template.private_data = rp - sm->registration_pool;
759 
760  rp->clib_file_index = clib_file_add (fm, &template);
761  return 0;
762 }
763 
764 static clib_error_t *
766 {
767  socket_main_t *sm = &socket_main;
769 
770  /* Defensive driving in case something wipes out early */
771  if (sm->registration_pool)
772  {
773  u32 index;
774  /* *INDENT-OFF* */
775  pool_foreach (rp, sm->registration_pool, ({
776  vl_api_registration_del_file (rp);
777  index = rp->vl_api_registration_pool_index;
778  vl_socket_free_registration_index (index);
779  }));
780 /* *INDENT-ON* */
781  }
782 
783  return 0;
784 }
785 
787 
788 static clib_error_t *
790 {
791  socket_main_t *sm = &socket_main;
792 
794  {
795  if (unformat (input, "socket-name %s", &sm->socket_name))
796  ;
797  /* DEPRECATE: default keyword is ignored */
798  else if (unformat (input, "default"))
799  ;
800  else
801  {
802  return clib_error_return (0, "unknown input '%U'",
803  format_unformat_error, input);
804  }
805  }
806 
807  if (!vec_len (sm->socket_name))
808  sm->socket_name = format (0, "%s/%s", vlib_unix_get_runtime_dir (),
811 
812  return 0;
813 }
814 
816 
817 void
819 {
820 }
821 
822 /*
823  * fd.io coding-style-patch-verification: ON
824  *
825  * Local Variables:
826  * eval: (c-set-style "gnu")
827  * End:
828  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:440
unix_main_t unix_main
Definition: main.c:62
void vlibsocket_reference()
Definition: socket_api.c:818
u64 api_pvt_heap_size
size of the api private mheap
Definition: api_common.h:324
#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:53
clib_error_t * vl_sock_api_init(vlib_main_t *vm)
Definition: socket_api.c:719
void vl_msg_api_socket_handler(void *the_msg)
Definition: api_shared.c:751
static void vl_api_registration_del_file(vl_api_registration_t *reg)
Definition: api.h:77
uword requested_va
Definition: ssvm.h:88
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:484
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:1017
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:523
void vl_sock_api_dump_clients(vlib_main_t *vm, api_main_t *am)
Definition: socket_api.c:72
int i
clib_error_t * clib_socket_init(clib_socket_t *s)
Definition: socket.c:384
u8 data[0]
actual message begins here
Definition: api_common.h:142
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:237
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:272
#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:599
#define CLIB_SOCKET_F_IS_SERVER
Definition: socket.h:58
u32 clib_file_index
Socket only: file index.
Definition: api_common.h:66
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:498
void vl_api_sock_init_shm_t_handler(vl_api_sock_init_shm_t *mp)
Definition: socket_api.c:603
int ssvm_master_init_memfd(ssvm_private_t *memfd)
Initialize memfd segment master.
Definition: ssvm.c:223
static char * vlib_unix_get_runtime_dir(void)
Definition: unix.h:139
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:243
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:48
#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:789
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:519
void vl_init_shmem(svm_region_t *vlib_rp, vl_api_shm_elem_config_t *config, int is_vlib, int is_private_region)
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
Definition: node_funcs.h:934
clib_error_t * clib_socket_accept(clib_socket_t *server, clib_socket_t *client)
Definition: socket.c:524
struct _unformat_input_t unformat_input_t
unsigned short u16
Definition: types.h:57
#define clib_error_return_unix(e, args...)
Definition: error.h:102
u64 size
Definition: vhost_user.h:140
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:287
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:376
svm_region_t ** vlib_private_rps
Vector of all mapped shared-VM segments.
Definition: api_common.h:284
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:465
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:225
An API client registration, only in vpp/vlib.
Definition: api_common.h:46
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
Shared memory connection.
Definition: api_common.h:38
svmdb_client_t * c
vlib_main_t * vm
Definition: buffer.c:323
clib_socket_t socksvr_listen_socket
Definition: socket_api.h:62
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:342
#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:69
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:284
int * additional_fds_to_close
Definition: api_common.h:70
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:93
static uword hash_elts(void *v)
Definition: hash.h:118
#define ASSERT(truth)
#define vec_delete(V, N, M)
Delete N elements starting at element M.
Definition: vec.h:785
u8 data[128]
Definition: ipsec_types.api:87
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:137
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:821
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:67
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
u8 * name
Definition: ssvm.h:87
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:545
clib_error_t * vl_sock_api_send_fd_msg(int socket_fd, int fds[], int n_fds)
Definition: socket_api.c:515
#define foreach_vlib_api_msg
Definition: socket_api.c:713
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:51
i8 * input_buffer
Definition: socket_api.h:56
static api_main_t * vlibapi_get_main(void)
Definition: api_common.h:378
#define SOCK_API_REG_HANDLE_BIT
Definition: socket_api.c:50
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
static void unix_save_error(unix_main_t *um, clib_error_t *error)
Definition: unix.h:115
uword private_data
Definition: file.h:64
Definition: file.h:51
uword * msg_index_by_name_and_crc
client message index hash table
Definition: api_common.h:345
#define CLIB_SOCKET_F_ALLOW_GROUP_WRITE
Definition: socket.h:62
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:689
int i_am_master
Definition: ssvm.h:89
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:765
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