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