FD.io VPP  v16.06
Vector Packet Processing
pneum.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <stddef.h>
18 #include <sys/types.h>
19 #include <sys/socket.h>
20 #include <sys/mman.h>
21 #include <sys/stat.h>
22 #include <netinet/in.h>
23 #include <netdb.h>
24 #include <signal.h>
25 #include <setjmp.h>
26 #include <stdbool.h>
27 
28 #include <vnet/vnet.h>
29 #include <vlib/vlib.h>
30 #include <vlib/unix/unix.h>
31 #include <vlibapi/api.h>
32 #include <vlibmemory/api.h>
33 
34 #include <api/vpe_msg_enum.h>
35 
36 #include "pneum.h"
37 
38 #define vl_typedefs /* define message structures */
39 #include <api/vpe_all_api_h.h>
40 #undef vl_typedefs
41 
42 #define vl_endianfun /* define message structures */
43 #include <api/vpe_all_api_h.h>
44 #undef vl_endianfun
45 
46 typedef struct {
50  pthread_t rx_thread_handle;
51 } pneum_main_t;
52 
54 
55 extern int wrap_pneum_callback(char *data, int len);
56 
57 /*
58  * Satisfy external references when -lvlib is not available.
59  */
60 void vlib_cli_output (struct vlib_main_t * vm, char * fmt, ...)
61 {
62  clib_warning ("vlib_cli_output callled...");
63 }
64 
65 #define vl_api_version(n,v) static u32 vpe_api_version = v;
66 #include <api/vpe.api.h>
67 #undef vl_api_version
68 void
70 {
71  /*
72  * Send the main API signature in slot 0. This bit of code must
73  * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
74  */
75  mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);
76 }
77 
78 static void
79 pneum_api_handler (void *msg)
80 {
81  u16 id = ntohs(*((u16 *)msg));
82 
83  if (id == VL_API_RX_THREAD_EXIT) {
84  pneum_main_t *pm = &pneum_main;
85  vl_msg_api_free(msg);
86  longjmp(pm->rx_thread_jmpbuf, 1);
87  }
88  msgbuf_t *msgbuf = (msgbuf_t *)(((u8 *)msg) - offsetof(msgbuf_t, data));
89  int l = ntohl(msgbuf->data_len);
90  if (l == 0)
91  clib_warning("Message ID %d has wrong length: %d\n", id, l);
92 
93  /* Call Python callback */
94  (void)wrap_pneum_callback(msg, l);
95  vl_msg_api_free(msg);
96 }
97 
98 static void *
99 pneum_rx_thread_fn (void *arg)
100 {
102  pneum_main_t *pm = &pneum_main;
103  api_main_t *am = &api_main;
104  uword msg;
105 
106  q = am->vl_input_queue;
107 
108  /* So we can make the rx thread terminate cleanly */
109  if (setjmp(pm->rx_thread_jmpbuf) == 0) {
110  pm->rx_thread_jmpbuf_valid = 1;
111  while (1)
112  while (!unix_shared_memory_queue_sub(q, (u8 *)&msg, 0))
113  pneum_api_handler((void *)msg);
114  }
115  pthread_exit(0);
116 }
117 
118 int
119 pneum_connect (char *name)
120 {
121  int rv = 0;
122  pneum_main_t *pm = &pneum_main;
123 
124  /*
125  * Bail out now if we're not running as root
126  */
127  if (geteuid() != 0)
128  return (-1);
129 
130  if ((rv = vl_client_api_map("/vpe-api"))) {
131  clib_warning ("vl_client_api map rv %d", rv);
132  return rv;
133  }
134 
135  if (vl_client_connect(name, 0, 32) < 0) {
137  return (-1);
138  }
139 
140  /* Start the rx queue thread */
141  rv = pthread_create(&pm->rx_thread_handle, NULL, pneum_rx_thread_fn, 0);
142  if (rv) {
143  clib_warning("pthread_create returned %d", rv);
145  return (-1);
146  }
147 
148  pm->connected_to_vlib = 1;
149 
150  return (0);
151 }
152 
153 int
155 {
156  api_main_t *am = &api_main;
157  pneum_main_t *pm = &pneum_main;
158 
159  fformat (stdout,"disconnecting from vpe \n");
160 
161  if (pm->rx_thread_jmpbuf_valid) {
163  uword junk;
164  ep = vl_msg_api_alloc (sizeof (*ep));
165  ep->_vl_msg_id = ntohs(VL_API_RX_THREAD_EXIT);
167  pthread_join(pm->rx_thread_handle, (void **) &junk);
168  }
169  if (pm->connected_to_vlib) {
172  }
173  memset (pm, 0, sizeof (*pm));
174 
175  return (0);
176 }
177 
178 int
179 pneum_read (char **p, int *l)
180 {
182  api_main_t *am = &api_main;
183  uword msg;
184 
185  *l = 0;
186 
187  if (am->our_pid == 0) return (-1);
188 
189  q = am->vl_input_queue;
190  int rv = unix_shared_memory_queue_sub(q, (u8 *)&msg, 0);
191  if (rv == 0) {
192  u16 msg_id = ntohs(*((u16 *)msg));
193  msgbuf_t *msgbuf = (msgbuf_t *)(((u8 *)msg) - offsetof(msgbuf_t, data));
194  *l = ntohl(msgbuf->data_len);
195  if (*l == 0) {
196  printf("Unregistered API message: %d\n", msg_id);
197  return (-1);
198  }
199  *p = (char *)msg;
200  } else {
201  printf("Read failed with %d\n", rv);
202  }
203  return (rv);
204 }
205 
206 /*
207  * XXX: Makes the assumption that client_index is the first member
208  */
209 typedef VL_API_PACKED(struct _vl_api_header {
210  u16 _vl_msg_id;
211  u32 client_index;
212 }) vl_api_header_t;
213 
214 static unsigned int
215 pneum_client_index (void)
216 {
217  return (api_main.my_client_index);
218 }
219 
220 int
221 pneum_write (char *p, int l)
222 {
223  int rv = -1;
224  api_main_t *am = &api_main;
225  vl_api_header_t *mp = vl_msg_api_alloc(l);
227 
228  if (!mp) return (-1);
229  memcpy(mp, p, l);
230  mp->client_index = pneum_client_index();
231  q = am->shmem_hdr->vl_input_queue;
232  rv = unix_shared_memory_queue_add(q, (u8 *)&mp, 0);
233  if (rv != 0) {
234  printf("vpe_api_write fails: %d\n", rv);
235  /* Clear message */
236  vl_msg_api_free(mp);
237  }
238  return (rv);
239 }
jmp_buf rx_thread_jmpbuf
Definition: pneum.c:49
u8 rx_thread_jmpbuf_valid
Definition: pneum.c:47
pthread_t rx_thread_handle
Definition: pneum.c:50
void vl_msg_api_send_shmem(unix_shared_memory_queue_t *q, u8 *elem)
static void(BVT(clib_bihash)*h, BVT(clib_bihash_value)*v)
u8 connected_to_vlib
Definition: pneum.c:48
unix_shared_memory_queue_t * vl_input_queue
Definition: api.h:71
int my_client_index
Definition: api.h:148
#define NULL
Definition: clib.h:55
void vl_client_add_api_signatures(vl_api_memclnt_create_t *mp)
Definition: pneum.c:69
int pneum_read(char **p, int *l)
Definition: pneum.c:179
unix_shared_memory_queue_t * vl_input_queue
Definition: api.h:142
api_main_t api_main
Definition: api.h:162
int our_pid
Definition: api.h:122
static void * pneum_rx_thread_fn(void *arg)
Definition: pneum.c:99
pneum_main_t pneum_main
Definition: pneum.c:53
void vl_msg_api_free(void *)
#define clib_warning(format, args...)
Definition: error.h:59
struct vl_shmem_hdr_ * shmem_hdr
Definition: api.h:125
int unix_shared_memory_queue_add(unix_shared_memory_queue_t *q, u8 *elem, int nowait)
int vl_client_api_map(char *region_name)
int pneum_disconnect(void)
Definition: pneum.c:154
int unix_shared_memory_queue_sub(unix_shared_memory_queue_t *q, u8 *elem, int nowait)
void * vl_msg_api_alloc(int nbytes)
static void pneum_api_handler(void *msg)
Definition: pneum.c:79
void vlib_cli_output(struct vlib_main_t *vm, char *fmt,...)
Definition: pneum.c:60
int vl_client_connect(char *name, int ctx_quota, int input_queue_size)
unsigned int u32
Definition: types.h:88
u32 data_len
Definition: api.h:92
Definition: api.h:90
u64 uword
Definition: types.h:112
void vl_client_disconnect(void)
void vl_client_api_unmap(void)
typedef VL_API_PACKED(struct _vl_api_header{u16 _vl_msg_id;u32 client_index;})
Definition: pneum.c:209
unsigned short u16
Definition: types.h:57
int pneum_connect(char *name)
Definition: pneum.c:119
unsigned char u8
Definition: types.h:56
word fformat(FILE *f, char *fmt,...)
Definition: format.c:437
int wrap_pneum_callback(char *data, int len)
Definition: pneum_wrap.c:7
int pneum_write(char *p, int l)
Definition: pneum.c:221
struct _unix_shared_memory_queue unix_shared_memory_queue_t