Enable mutil-thread VPP API calling support.

- Lock/Unlock before and after invoke VPP API;
- Introduce sc_vpp_main_t for warpping VPP API context, mode and pid;

Change-Id: If1b1c040cb4723ecc4e88c5060c0380de7c715c0
Signed-off-by: jackiechen1985 <xiaobo.chen@tieto.com>

8 files changed, 155 insertions, 138 deletions

diff --git a/src/plugins/sc_plugins.c b/src/plugins/sc_plugins.c
index 7fc5975..8ed2c12 100644
--- a/src/plugins/sc_plugins.c
+++ b/src/plugins/sc_plugins.c
@@ -20,67 +20,23 @@
 #include <vpp-api/client/stat_client.h>
 
 sc_plugin_main_t sc_plugin_main;
-static int vpp_pid_start;
 
 sc_plugin_main_t *sc_get_plugin_main()
 {
     return &sc_plugin_main;
 }
 
-/* get vpp pid in system */
-int get_vpp_pid()
-{
-    DIR *dir;
-    struct dirent *ptr;
-    FILE *fp;
-    char filepath[50];
-    char filetext[20];
-
-    dir = opendir("/proc");
-    int vpp_pid = 0;
-    /* read vpp pid file in proc, return pid of vpp */
-    if (NULL != dir)
-    {
-        while (NULL != (ptr =readdir(dir)))
-        {
-            if ((0 == strcmp(ptr->d_name, ".")) || (0 == strcmp(ptr->d_name, "..")))
-                continue;
-
-            if (DT_DIR != ptr->d_type)
-                continue;
-
-            sprintf(filepath, "/proc/%s/cmdline",ptr->d_name);
-            fp = fopen(filepath, "r");
-
-            if (NULL != fp)
-            {
-                fread(filetext, 1, 13, fp);
-                filetext[12] = '\0';
-
-                if (filetext == strstr(filetext, "/usr/bin/vpp"))
-                    vpp_pid = atoi(ptr->d_name);
-
-                fclose(fp);
-            }
-        }
-        closedir(dir);
-    }
-    return vpp_pid;
-}
-
-
 int sr_plugin_init_cb(sr_session_ctx_t *session, void **private_ctx)
 {
-    int rc;
+    int rc = SR_ERR_OK;;
 
     sc_plugin_main.session = session;
 
     /* Connect to VAPI */
-    rc = sc_connect_vpp();
-    if (0 != rc) {
-        SRP_LOG_ERR("vpp vapi connect error , with return %d.", rc);
-        return SR_ERR_INTERNAL;
-    }
+	if (!(sc_plugin_main.vpp_main = sc_connect_vpp())) {
+		SRP_LOG_ERR("VPP connect error: %d", rc);
+		return SR_ERR_INTERNAL;
+	}
 
     /* Connect to STAT API */
     rc = stat_segment_connect(STAT_SEGMENT_SOCKET_FILE);
@@ -97,9 +53,8 @@ int sr_plugin_init_cb(sr_session_ctx_t *session, void **private_ctx)
 
     /* set subscription as our private context */
     *private_ctx = sc_plugin_main.subscription;
-    /* get the vpp pid sweetcomb connected, we assumed that only one vpp is run in system */
-    vpp_pid_start = get_vpp_pid();
-    return SR_ERR_OK;
+
+    return rc;
 }
 
 void sr_plugin_cleanup_cb(sr_session_ctx_t *session, void *private_ctx)
@@ -119,18 +74,11 @@ void sr_plugin_cleanup_cb(sr_session_ctx_t *session, void *private_ctx)
     SRP_LOG_DBG_MSG("plugin disconnect vpp ok.");
 }
 
-int sr_plugin_health_check_cb(sr_session_ctx_t *session, void *private_ctx)
+int sr_plugin_health_check_cb( __attribute__ ((unused)) sr_session_ctx_t *session,
+	__attribute__ ((unused)) void *private_ctx)
 {
-   /* health check, will use shell to detect vpp when plugin is loaded */
-   /* health_check will run every 10 seconds in loop*/
-   int vpp_pid_now = get_vpp_pid();
-
-   if(vpp_pid_now == vpp_pid_start)
-       {
-       return SR_ERR_OK;
-       }
-   else
-   {
-       return -1;
-   }
+	/* health check, will use shell to detect vpp when plugin is loaded */
+	/* health_check will run every 10 seconds in loop*/
+	pid_t pid = sc_get_vpp_pid();
+	return sc_plugin_main.vpp_main->pid == pid && pid != 0 ? SR_ERR_OK : SR_ERR_INTERNAL;
 }
diff --git a/src/plugins/sc_plugins.h b/src/plugins/sc_plugins.h
index 681be6b..1ac3f44 100644
--- a/src/plugins/sc_plugins.h
+++ b/src/plugins/sc_plugins.h
@@ -33,6 +33,9 @@ typedef struct sc_plugin_main_t {
     /* List of init/exit functions to call, setup by constructors */
     _sc_init_function_list_elt_t *init_function_registrations;
     _sc_exit_function_list_elt_t *exit_function_registrations;
+
+	/* VPP main structure */
+	sc_vpp_main_t *vpp_main;
 } sc_plugin_main_t;
 
 sc_plugin_main_t *sc_get_plugin_main();
diff --git a/src/scvpp/inc/scvpp/comm.h b/src/scvpp/inc/scvpp/comm.h
index 687db5d..a7bac5d 100644
--- a/src/scvpp/inc/scvpp/comm.h
+++ b/src/scvpp/inc/scvpp/comm.h
@@ -112,6 +112,7 @@ api_name##_cb (struct vapi_ctx_s *ctx, void *callback_ctx, vapi_error_e rv, \
 #define VAPI_CALL_MODE(call_code, vapi_mode) \
     do \
     { \
+        pthread_mutex_lock (&sc_vpp_main.vapi_lock); \
         if (VAPI_MODE_BLOCKING == (vapi_mode)) \
         { \
             rv = call_code; \
@@ -120,13 +121,14 @@ api_name##_cb (struct vapi_ctx_s *ctx, void *callback_ctx, vapi_error_e rv, \
         { \
             while (VAPI_EAGAIN == (rv = call_code)); \
             if (rv != VAPI_OK) { /* try once more to get reply */ \
-                rv = vapi_dispatch (g_vapi_ctx); \
+                rv = vapi_dispatch (sc_vpp_main.vapi_ctx); \
             } \
         } \
+        pthread_mutex_unlock (&sc_vpp_main.vapi_lock); \
     } \
     while (0)
 
-#define VAPI_CALL(call_code) VAPI_CALL_MODE(call_code, g_vapi_mode)
+#define VAPI_CALL(call_code) VAPI_CALL_MODE(call_code, sc_vpp_main.vapi_mode)
 
 struct elt {
     void *data; //vapi_payload structure
@@ -200,7 +202,7 @@ api_name##_all_cb(vapi_ctx_t ctx, void *caller_ctx, vapi_error_e rv, bool is_las
 
 #define foreach_stack_elt(stack)  \
     for(void *data = pop(&stack); data != NULL ; data = pop(&stack))
-//for(void *data = pop(&stack); stack != NULL ; data = pop(&stack)) // No!!
+
 
 int sc_aton(const char *cp, u8 * buf, size_t length);
 char * sc_ntoa(const u8 * buf);
@@ -219,11 +221,25 @@ uint32_t hardntohlu32(uint8_t host[4]);
  * VPP
  */
 
-extern vapi_ctx_t g_vapi_ctx;
-extern vapi_mode_e g_vapi_mode;
+typedef struct sc_vpp_main_t {
+	/* VAPI context */
+	vapi_ctx_t vapi_ctx;
+
+	/* VAPI calling mode: VAPI_MODE_BLOCKING, VAPI_MODE_NONBLOCKING */
+	vapi_mode_e vapi_mode;
+
+	/* Mutex for keeping atomicity when calling VAPI */
+	pthread_mutex_t vapi_lock;
+
+	/* pid of VPP */
+	pid_t pid;
+} sc_vpp_main_t;
+
+extern sc_vpp_main_t sc_vpp_main;
 
-int sc_connect_vpp();
-int sc_disconnect_vpp();
+sc_vpp_main_t *sc_connect_vpp();
+void sc_disconnect_vpp();
+pid_t sc_get_vpp_pid();
 int sc_end_with(const char* str, const char* end);
 
 #endif //__SC_VPP_COMMM_H__
diff --git a/src/scvpp/src/comm.c b/src/scvpp/src/comm.c
index b679880..11ed8a9 100644
--- a/src/scvpp/src/comm.c
+++ b/src/scvpp/src/comm.c
@@ -14,51 +14,97 @@
  */
 #include <scvpp/comm.h>
 
-#include <assert.h>
-#include <string.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
+#include <stdio.h>
+#include <dirent.h>
 
 #define APP_NAME "sweetcomb_vpp"
 #define MAX_OUTSTANDING_REQUESTS 4
 #define RESPONSE_QUEUE_SIZE 2
 
-vapi_ctx_t g_vapi_ctx = NULL;
-vapi_mode_e g_vapi_mode = VAPI_MODE_NONBLOCKING;
+sc_vpp_main_t sc_vpp_main = {
+	.vapi_ctx = NULL,
+	.vapi_mode = VAPI_MODE_BLOCKING,
+	.pid = 0
+};
 
-int sc_connect_vpp()
+sc_vpp_main_t *sc_connect_vpp()
 {
-    if (g_vapi_ctx == NULL)
-    {
-        vapi_error_e rv = vapi_ctx_alloc(&g_vapi_ctx);
-        if (rv != VAPI_OK) {
-            g_vapi_ctx = NULL;
-            return -1;
-        }
-        rv = vapi_connect(g_vapi_ctx, APP_NAME, NULL,
-                          MAX_OUTSTANDING_REQUESTS, RESPONSE_QUEUE_SIZE,
-                          VAPI_MODE_BLOCKING, true);
-        if (rv != VAPI_OK)
-        {
-            vapi_ctx_free(g_vapi_ctx);
-            g_vapi_ctx = NULL;
-            return -1;
-        }
-    }
+	vapi_error_e rv;
+
+	if (sc_vpp_main.vapi_ctx == NULL) {
+		if ((rv = vapi_ctx_alloc(&sc_vpp_main.vapi_ctx)) != VAPI_OK) {
+			return NULL;
+		}
+
+		if ((rv =
+		     vapi_connect(sc_vpp_main.vapi_ctx, APP_NAME, NULL,
+				  MAX_OUTSTANDING_REQUESTS, RESPONSE_QUEUE_SIZE,
+				  sc_vpp_main.vapi_mode, true)) != VAPI_OK) {
+			vapi_ctx_free(sc_vpp_main.vapi_ctx);
+			sc_vpp_main.vapi_ctx = NULL;
+			return NULL;
+		}
+	}
+
+	sc_vpp_main.pid = sc_get_vpp_pid();
+	pthread_mutex_init(&sc_vpp_main.vapi_lock, NULL);
+	return &sc_vpp_main;
+}
 
-    return 0;
+void sc_disconnect_vpp()
+{
+	if (NULL != sc_vpp_main.vapi_ctx) {
+		pthread_mutex_destroy(&sc_vpp_main.vapi_lock);
+		sc_vpp_main.pid = 0;
+		vapi_disconnect(sc_vpp_main.vapi_ctx);
+		vapi_ctx_free(sc_vpp_main.vapi_ctx);
+		sc_vpp_main.vapi_ctx = NULL;
+	}
 }
 
-int sc_disconnect_vpp()
+/* get vpp pid in system */
+pid_t sc_get_vpp_pid()
 {
-    if (NULL != g_vapi_ctx)
-    {
-        vapi_disconnect(g_vapi_ctx);
-        vapi_ctx_free(g_vapi_ctx);
-        g_vapi_ctx = NULL;
-    }
-    return 0;
+	DIR *dir;
+	struct dirent *ptr;
+	FILE *fp;
+	char cmdline_path[PATH_MAX];
+	char cmdline_data[PATH_MAX];
+	const char vpp_path[] = "/usr/bin/vpp";
+
+	dir = opendir("/proc");
+	pid_t pid = 0;
+	/* read vpp pid file in proc, return pid of vpp */
+	if (NULL != dir) {
+		while (NULL != (ptr = readdir(dir))) {
+			if ((0 == strcmp(ptr->d_name, "."))
+			    || (0 == strcmp(ptr->d_name, ".."))) {
+				continue;
+			}
+
+			if (DT_DIR != ptr->d_type) {
+				continue;
+			}
+
+			sprintf(cmdline_path, "/proc/%s/cmdline", ptr->d_name);
+			fp = fopen(cmdline_path, "r");
+
+			if (NULL != fp) {
+				fread(cmdline_data, 1, sizeof(vpp_path), fp);
+				cmdline_data[sizeof(vpp_path) - 1] = '\0';
+
+				if (cmdline_data ==
+				    strstr(cmdline_data, "/usr/bin/vpp")) {
+					pid = atoi(ptr->d_name);
+				}
+
+				fclose(fp);
+			}
+		}
+		closedir(dir);
+	}
+
+	return pid;
 }
 
 int sc_end_with(const char* str, const char* end)
diff --git a/src/scvpp/src/interface.c b/src/scvpp/src/interface.c
index 3a30dc5..b6b1216 100644
--- a/src/scvpp/src/interface.c
+++ b/src/scvpp/src/interface.c
@@ -34,6 +34,10 @@ sw_interface_dump_cb(struct vapi_ctx_s *ctx, void *callback_ctx,
 
     vapi_payload_sw_interface_details *passed;
 
+	if (is_last) {
+		return VAPI_OK;
+	}
+
     ARG_CHECK2(VAPI_EINVAL, callback_ctx, reply);
 
     //copy
@@ -50,14 +54,14 @@ bin_api_sw_interface_dump(vapi_payload_sw_interface_details *details,
     vapi_msg_sw_interface_dump *mp;
     vapi_error_e rv;
 
-    mp = vapi_alloc_sw_interface_dump(g_vapi_ctx);
+    mp = vapi_alloc_sw_interface_dump(sc_vpp_main.vapi_ctx);
     assert(NULL != mp);
 
     /* Dump a specific interfaces */
     mp->payload.name_filter_valid = true;
     strncpy((char *)mp->payload.name_filter, iface_name, IFACE_SUBSTR);
 
-    VAPI_CALL(vapi_sw_interface_dump(g_vapi_ctx, mp,
+    VAPI_CALL(vapi_sw_interface_dump(sc_vpp_main.vapi_ctx, mp,
                                      sw_interface_dump_cb, details));
     if (rv != VAPI_OK)
         return -SCVPP_EINVAL;
@@ -111,13 +115,13 @@ struct elt* interface_dump_all()
     vapi_msg_sw_interface_dump *mp;
     vapi_error_e rv;
 
-    mp = vapi_alloc_sw_interface_dump(g_vapi_ctx);
+    mp = vapi_alloc_sw_interface_dump(sc_vpp_main.vapi_ctx);
 
     /* Dump all */
     mp->payload.name_filter_valid = false;
     memset(mp->payload.name_filter, 0, sizeof(mp->payload.name_filter));
 
-    VAPI_CALL(vapi_sw_interface_dump(g_vapi_ctx, mp, sw_interface_all_cb,
+    VAPI_CALL(vapi_sw_interface_dump(sc_vpp_main.vapi_ctx, mp, sw_interface_all_cb,
                                      &stack));
     if (VAPI_OK != rv)
         return NULL;
@@ -140,12 +144,12 @@ int interface_enable(const char *interface_name, const bool enable)
     if (rc != 0)
         return -SCVPP_NOT_FOUND;
 
-    mp = vapi_alloc_sw_interface_set_flags(g_vapi_ctx);
+    mp = vapi_alloc_sw_interface_set_flags(sc_vpp_main.vapi_ctx);
     assert(NULL != mp);
     mp->payload.sw_if_index = sw_if_index;
     mp->payload.admin_up_down = enable;
 
-    VAPI_CALL(vapi_sw_interface_set_flags(g_vapi_ctx, mp,
+    VAPI_CALL(vapi_sw_interface_set_flags(sc_vpp_main.vapi_ctx, mp,
                                           sw_interface_set_flags_cb, NULL));
     if (VAPI_OK != rv)
         return -SCVPP_EINVAL;
diff --git a/src/scvpp/src/ip.c b/src/scvpp/src/ip.c
index f2234f2..ec44f64 100644
--- a/src/scvpp/src/ip.c
+++ b/src/scvpp/src/ip.c
@@ -36,7 +36,7 @@ bin_api_sw_interface_add_del_address(u32 sw_if_index, bool is_add, bool is_ipv6,
 
     ARG_CHECK(VAPI_EINVAL, ip_address);
 
-    mp = vapi_alloc_sw_interface_add_del_address(g_vapi_ctx);
+    mp = vapi_alloc_sw_interface_add_del_address(sc_vpp_main.vapi_ctx);
     assert(NULL != mp);
 
     mp->payload.sw_if_index = sw_if_index;
@@ -47,7 +47,7 @@ bin_api_sw_interface_add_del_address(u32 sw_if_index, bool is_add, bool is_ipv6,
     if (sc_aton(ip_address, mp->payload.address, VPP_IP4_ADDRESS_LEN))
         return VAPI_EINVAL;
 
-    VAPI_CALL(vapi_sw_interface_add_del_address(g_vapi_ctx, mp,
+    VAPI_CALL(vapi_sw_interface_add_del_address(sc_vpp_main.vapi_ctx, mp,
                                         sw_interface_add_del_address_cb, NULL));
 
     return rv;
@@ -72,7 +72,7 @@ bin_api_ip_add_del_route(vapi_payload_ip_add_del_route_reply * reply,
     if (!next_interface && !next_hop)
         return VAPI_EINVAL;
 
-    mp = vapi_alloc_ip_add_del_route(g_vapi_ctx, 1);
+    mp = vapi_alloc_ip_add_del_route(sc_vpp_main.vapi_ctx, 1);
     assert(NULL != mp);
 
     if (next_interface) {
@@ -92,7 +92,7 @@ bin_api_ip_add_del_route(vapi_payload_ip_add_del_route_reply * reply,
     if (next_hop) //next hop ip is not mandatory
         sc_aton(next_hop, mp->payload.next_hop_address, VPP_IP4_ADDRESS_LEN);
 
-    VAPI_CALL(vapi_ip_add_del_route(g_vapi_ctx, mp,
+    VAPI_CALL(vapi_ip_add_del_route(sc_vpp_main.vapi_ctx, mp,
                                     ip_add_del_route_cb, reply));
 
     return rv;
@@ -123,13 +123,13 @@ bin_api_ip_address_dump(u32 sw_if_index, bool is_ipv6,
     vapi_msg_ip_address_dump *mp;
     vapi_error_e rv;
 
-    mp = vapi_alloc_ip_address_dump(g_vapi_ctx);
+    mp = vapi_alloc_ip_address_dump(sc_vpp_main.vapi_ctx);
     assert(mp != NULL);
 
     mp->payload.sw_if_index = sw_if_index;
     mp->payload.is_ipv6 = is_ipv6;
 
-    VAPI_CALL(vapi_ip_address_dump(g_vapi_ctx, mp, ip_address_dump_cb,
+    VAPI_CALL(vapi_ip_address_dump(sc_vpp_main.vapi_ctx, mp, ip_address_dump_cb,
                                    dctx));
     if (rv != VAPI_OK)
         return rv;
@@ -159,10 +159,10 @@ struct elt* ipv4_fib_dump_all()
     vapi_msg_ip_fib_dump *mp;
     vapi_error_e rv;
 
-    mp = vapi_alloc_ip_fib_dump(g_vapi_ctx);
+    mp = vapi_alloc_ip_fib_dump(sc_vpp_main.vapi_ctx);
     assert(mp != NULL);
 
-    VAPI_CALL(vapi_ip_fib_dump(g_vapi_ctx, mp, ip_fib_all_cb, &stack));
+    VAPI_CALL(vapi_ip_fib_dump(sc_vpp_main.vapi_ctx, mp, ip_fib_all_cb, &stack));
     if(VAPI_OK != rv)
         return NULL;
 
diff --git a/src/scvpp/src/nat.c b/src/scvpp/src/nat.c
index 1ff59f3..4519c3e 100644
--- a/src/scvpp/src/nat.c
+++ b/src/scvpp/src/nat.c
@@ -55,10 +55,10 @@ bin_api_nat44_interface_dump(vapi_payload_nat44_interface_details *reply)
 
     ARG_CHECK(VAPI_EINVAL, reply);
 
-    mp = vapi_alloc_nat44_interface_dump(g_vapi_ctx);
+    mp = vapi_alloc_nat44_interface_dump(sc_vpp_main.vapi_ctx);
     assert(NULL != mp);
 
-    VAPI_CALL(vapi_nat44_interface_dump(g_vapi_ctx, mp,
+    VAPI_CALL(vapi_nat44_interface_dump(sc_vpp_main.vapi_ctx, mp,
                                         nat44_interface_dump_cb, reply));
 
     return rv;
@@ -75,12 +75,12 @@ bin_api_nat44_add_del_interface_addr(
 
     ARG_CHECK(VAPI_EINVAL, msg);
 
-    mp = vapi_alloc_nat44_add_del_interface_addr(g_vapi_ctx);
+    mp = vapi_alloc_nat44_add_del_interface_addr(sc_vpp_main.vapi_ctx);
     assert(NULL != mp);
 
     mp->payload = *msg;
 
-    VAPI_CALL(vapi_nat44_add_del_interface_addr(g_vapi_ctx, mp,
+    VAPI_CALL(vapi_nat44_add_del_interface_addr(sc_vpp_main.vapi_ctx, mp,
                                                 nat44_add_del_interface_addr_cb,
                                                 NULL));
 
@@ -98,13 +98,13 @@ bin_api_nat44_add_del_addr_range(
 
     ARG_CHECK(VAPI_EINVAL, range);
 
-    mp = vapi_alloc_nat44_add_del_address_range(g_vapi_ctx);
+    mp = vapi_alloc_nat44_add_del_address_range(sc_vpp_main.vapi_ctx);
 
     assert(NULL != mp);
 
     mp->payload = *range;
 
-    VAPI_CALL(vapi_nat44_add_del_address_range(g_vapi_ctx, mp,
+    VAPI_CALL(vapi_nat44_add_del_address_range(sc_vpp_main.vapi_ctx, mp,
                                                nat44_add_del_address_range_cb,
                                                NULL));
 
@@ -122,12 +122,12 @@ bin_api_nat44_add_del_static_mapping(
 
     ARG_CHECK(VAPI_EINVAL, msg);
 
-    mp = vapi_alloc_nat44_add_del_static_mapping(g_vapi_ctx);
+    mp = vapi_alloc_nat44_add_del_static_mapping(sc_vpp_main.vapi_ctx);
     assert(NULL != mp);
 
     mp->payload = *msg;
 
-    VAPI_CALL(vapi_nat44_add_del_static_mapping(g_vapi_ctx, mp,
+    VAPI_CALL(vapi_nat44_add_del_static_mapping(sc_vpp_main.vapi_ctx, mp,
                                                 nat44_add_del_static_mapping_cb,
                                                 NULL));
 
@@ -163,10 +163,10 @@ bin_api_nat44_static_mapping_dump(
 
     ARG_CHECK(VAPI_EINVAL, reply);
 
-    msg = vapi_alloc_nat44_static_mapping_dump(g_vapi_ctx);
+    msg = vapi_alloc_nat44_static_mapping_dump(sc_vpp_main.vapi_ctx);
     assert(NULL != msg);
 
-    VAPI_CALL(vapi_nat44_static_mapping_dump(g_vapi_ctx, msg,
+    VAPI_CALL(vapi_nat44_static_mapping_dump(sc_vpp_main.vapi_ctx, msg,
                                              nat44_static_mapping_dump_cb,
                                              reply));
 
@@ -183,13 +183,13 @@ static vapi_error_e bin_api_nat44_forwarding_enable_disable(
 
     ARG_CHECK(VAPI_EINVAL, msg);
 
-    mp = vapi_alloc_nat44_forwarding_enable_disable(g_vapi_ctx);
+    mp = vapi_alloc_nat44_forwarding_enable_disable(sc_vpp_main.vapi_ctx);
     assert(NULL != mp);
 
     mp->payload = *msg;
 
     VAPI_CALL(vapi_nat44_forwarding_enable_disable(
-        g_vapi_ctx, mp, nat44_forwarding_enable_disable_cb, NULL));
+        sc_vpp_main.vapi_ctx, mp, nat44_forwarding_enable_disable_cb, NULL));
 
     return rv;
 }
@@ -204,12 +204,12 @@ bin_api_nat_set_workers(const vapi_payload_nat_set_workers *msg)
 
     ARG_CHECK(VAPI_EINVAL, msg);
 
-    mp = vapi_alloc_nat_set_workers(g_vapi_ctx);
+    mp = vapi_alloc_nat_set_workers(sc_vpp_main.vapi_ctx);
     assert(NULL != mp);
 
     mp->payload = *msg;
 
-    VAPI_CALL(vapi_nat_set_workers(g_vapi_ctx, mp, nat_set_workers_cb, NULL));
+    VAPI_CALL(vapi_nat_set_workers(sc_vpp_main.vapi_ctx, mp, nat_set_workers_cb, NULL));
 
     return rv;
 }
diff --git a/src/scvpp/src/v3po.c b/src/scvpp/src/v3po.c
index bdb15e1..8fd83ba 100644
--- a/src/scvpp/src/v3po.c
+++ b/src/scvpp/src/v3po.c
@@ -38,12 +38,12 @@ static vapi_error_e bin_api_delete_tapv2(u32 sw_if_index)
     vapi_msg_tap_delete_v2 *mp;
     vapi_error_e rv;
 
-    mp = vapi_alloc_tap_delete_v2(g_vapi_ctx);
+    mp = vapi_alloc_tap_delete_v2(sc_vpp_main.vapi_ctx);
     assert(NULL != mp);
 
     mp->payload.sw_if_index = sw_if_index;
 
-    VAPI_CALL(vapi_tap_delete_v2(g_vapi_ctx, mp, tap_delete_v2_cb, NULL));
+    VAPI_CALL(vapi_tap_delete_v2(sc_vpp_main.vapi_ctx, mp, tap_delete_v2_cb, NULL));
     if (rv != VAPI_OK)
         return -rv;
 
@@ -76,12 +76,12 @@ int create_tapv2(tapv2_create_t *query)
     vapi_msg_tap_create_v2 *mp;
     vapi_error_e rv;
 
-    mp = vapi_alloc_tap_create_v2(g_vapi_ctx);
+    mp = vapi_alloc_tap_create_v2(sc_vpp_main.vapi_ctx);
     assert(NULL != mp);
 
     memcpy(&mp->payload, query, sizeof(tapv2_create_t));
 
-    VAPI_CALL(vapi_tap_create_v2(g_vapi_ctx, mp, tap_create_v2_cb, NULL));
+    VAPI_CALL(vapi_tap_create_v2(sc_vpp_main.vapi_ctx, mp, tap_create_v2_cb, NULL));
     if (rv != VAPI_OK)
         return -EAGAIN;