X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fsession%2Fapplication.c;h=268816561a75a88734bd378126cf5d496a964ed6;hb=288eaab5964b9211350acad8d742fae4789577fe;hp=a70625a9bc5d80e33f21e1d69a42cc57ab49ffd1;hpb=c1f5a4336036e3f2d1f6746f39ce610312254272;p=vpp.git

diff --git a/src/vnet/session/application.c b/src/vnet/session/application.c
index a70625a9bc5..268816561a7 100644
--- a/src/vnet/session/application.c
+++ b/src/vnet/session/application.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Cisco and/or its affiliates.
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -94,6 +94,8 @@ app_worker_map_free (application_t * app, app_worker_map_t * map)
 static app_worker_map_t *
 app_worker_map_get (application_t * app, u32 map_index)
 {
+  if (pool_is_free_index (app->worker_maps, map_index))
+    return 0;
   return pool_elt_at_index (app->worker_maps, map_index);
 }
 
@@ -443,7 +445,7 @@ application_detach_process (application_t * app, u32 api_client_index)
   vec_foreach (wrk_index, wrks)
   {
     app_wrk = app_worker_get (wrk_index[0]);
-    args->wrk_index = app_wrk->wrk_map_index;
+    args->wrk_map_index = app_wrk->wrk_map_index;
     args->is_add = 0;
     vnet_app_worker_add_del (args);
   }
@@ -473,7 +475,7 @@ application_n_workers (application_t * app)
 }
 
 app_worker_t *
-application_listener_select_worker (stream_session_t * ls, u8 is_local)
+application_listener_select_worker (session_t * ls, u8 is_local)
 {
   app_listener_t *app_listener;
   application_t *app;
@@ -670,7 +672,7 @@ app_worker_alloc_segment_manager (app_worker_t * app_wrk)
 }
 
 int
-app_worker_start_listen (app_worker_t * app_wrk, stream_session_t * ls)
+app_worker_start_listen (app_worker_t * app_wrk, session_t * ls)
 {
   segment_manager_t *sm;
 
@@ -684,7 +686,7 @@ app_worker_start_listen (app_worker_t * app_wrk, stream_session_t * ls)
   hash_set (app_wrk->listeners_table, listen_session_get_handle (ls),
 	    segment_manager_index (sm));
 
-  if (!ls->server_rx_fifo
+  if (!ls->rx_fifo
       && session_transport_service_type (ls) == TRANSPORT_SERVICE_CL)
     {
       if (session_alloc_fifos (sm, ls))
@@ -722,6 +724,77 @@ app_worker_stop_listen (app_worker_t * app_wrk, session_handle_t handle)
   return 0;
 }
 
+int
+app_worker_own_session (app_worker_t * app_wrk, session_t * s)
+{
+  segment_manager_t *sm;
+  svm_fifo_t *rxf, *txf;
+
+  if (s->session_state == SESSION_STATE_LISTENING)
+    {
+      app_worker_t *old_wrk = app_worker_get (s->app_wrk_index);
+      u64 lsh = listen_session_get_handle (s);
+      app_listener_t *app_listener;
+      application_t *app;
+
+      if (!old_wrk)
+	return -1;
+
+      hash_unset (old_wrk->listeners_table, lsh);
+      if (!(sm = app_worker_alloc_segment_manager (app_wrk)))
+	return -1;
+
+      hash_set (app_wrk->listeners_table, lsh, segment_manager_index (sm));
+      s->app_wrk_index = app_wrk->wrk_index;
+
+      app = application_get (old_wrk->app_index);
+      if (!app)
+	return -1;
+
+      app_listener = app_listener_get (app, s->listener_db_index);
+      app_listener->workers = clib_bitmap_set (app_listener->workers,
+					       app_wrk->wrk_map_index, 1);
+      app_listener->workers = clib_bitmap_set (app_listener->workers,
+					       old_wrk->wrk_map_index, 0);
+      return 0;
+    }
+
+  s->app_wrk_index = app_wrk->wrk_index;
+
+  rxf = s->rx_fifo;
+  txf = s->tx_fifo;
+
+  if (!rxf || !txf)
+    return 0;
+
+  s->rx_fifo = 0;
+  s->tx_fifo = 0;
+
+  sm = app_worker_get_or_alloc_connect_segment_manager (app_wrk);
+  if (session_alloc_fifos (sm, s))
+    return -1;
+
+  if (!svm_fifo_is_empty (rxf))
+    {
+      clib_memcpy_fast (s->rx_fifo->data, rxf->data, rxf->nitems);
+      s->rx_fifo->head = rxf->head;
+      s->rx_fifo->tail = rxf->tail;
+      s->rx_fifo->cursize = rxf->cursize;
+    }
+
+  if (!svm_fifo_is_empty (txf))
+    {
+      clib_memcpy_fast (s->tx_fifo->data, txf->data, txf->nitems);
+      s->tx_fifo->head = txf->head;
+      s->tx_fifo->tail = txf->tail;
+      s->tx_fifo->cursize = txf->cursize;
+    }
+
+  segment_manager_dealloc_fifos (rxf->segment_index, rxf, txf);
+
+  return 0;
+}
+
 /**
  * Start listening local transport endpoint for requested transport.
  *
@@ -738,7 +811,7 @@ application_start_listen (application_t * app,
   u32 table_index, fib_proto;
   session_endpoint_t *sep;
   app_worker_t *app_wrk;
-  stream_session_t *ls;
+  session_t *ls;
   session_handle_t lh;
   session_type_t sst;
 
@@ -816,7 +889,7 @@ application_stop_listen (u32 app_index, u32 app_wrk_index,
 			 session_handle_t handle)
 {
   app_listener_t *app_listener;
-  stream_session_t *listener;
+  session_t *listener;
   app_worker_t *app_wrk;
   application_t *app;
 
@@ -887,9 +960,17 @@ app_worker_get_connect_segment_manager (app_worker_t * app)
   return segment_manager_get (app->connects_seg_manager);
 }
 
+segment_manager_t *
+app_worker_get_or_alloc_connect_segment_manager (app_worker_t * app_wrk)
+{
+  if (app_wrk->connects_seg_manager == (u32) ~ 0)
+    app_worker_alloc_connects_segment_manager (app_wrk);
+  return segment_manager_get (app_wrk->connects_seg_manager);
+}
+
 segment_manager_t *
 app_worker_get_listen_segment_manager (app_worker_t * app,
-				       stream_session_t * listener)
+				       session_t * listener)
 {
   uword *smp;
   smp = hash_get (app->listeners_table, listen_session_get_handle (listener));
@@ -924,21 +1005,22 @@ vnet_app_worker_add_del (vnet_app_worker_add_del_args_t * a)
       sm = segment_manager_get (app_wrk->first_segment_manager);
       fs = segment_manager_get_segment_w_lock (sm, 0);
       a->segment = &fs->ssvm;
+      a->segment_handle = segment_manager_segment_handle (sm, fs);
       segment_manager_segment_reader_unlock (sm);
       a->evt_q = app_wrk->event_queue;
-      a->wrk_index = app_wrk->wrk_map_index;
+      a->wrk_map_index = app_wrk->wrk_map_index;
     }
   else
     {
-      wrk_map = app_worker_map_get (app, a->wrk_index);
+      wrk_map = app_worker_map_get (app, a->wrk_map_index);
       if (!wrk_map)
 	return clib_error_return_code (0, VNET_API_ERROR_INVALID_VALUE, 0,
 				       "App %u does not have worker %u",
-				       app->app_index, a->wrk_index);
+				       app->app_index, a->wrk_map_index);
       app_wrk = app_worker_get (wrk_map->wrk_index);
       if (!app_wrk)
 	return clib_error_return_code (0, VNET_API_ERROR_INVALID_VALUE, 0,
-				       "No worker %u", a->wrk_index);
+				       "No worker %u", a->wrk_map_index);
       application_api_table_del (app_wrk->api_client_index);
       app_worker_free (app_wrk);
       app_worker_map_free (app, wrk_map);
@@ -958,7 +1040,7 @@ segment_manager_t *
 application_get_local_segment_manager_w_session (app_worker_t * app,
 						 local_session_t * ls)
 {
-  stream_session_t *listener;
+  session_t *listener;
   if (application_local_session_listener_has_transport (ls))
     {
       listener = listen_session_get (ls->listener_index);
@@ -1007,11 +1089,12 @@ application_use_mq_for_ctrl (application_t * app)
  * Send an API message to the external app, to map new segment
  */
 int
-app_worker_add_segment_notify (u32 app_wrk_index, ssvm_private_t * fs)
+app_worker_add_segment_notify (u32 app_wrk_index, u64 segment_handle)
 {
   app_worker_t *app_wrk = app_worker_get (app_wrk_index);
   application_t *app = application_get (app_wrk->app_index);
-  return app->cb_fns.add_segment_callback (app_wrk->api_client_index, fs);
+  return app->cb_fns.add_segment_callback (app_wrk->api_client_index,
+					   segment_handle);
 }
 
 u32
@@ -1020,11 +1103,11 @@ application_n_listeners (app_worker_t * app)
   return hash_elts (app->listeners_table);
 }
 
-stream_session_t *
+session_t *
 app_worker_first_listener (app_worker_t * app, u8 fib_proto,
 			   u8 transport_proto)
 {
-  stream_session_t *listener;
+  session_t *listener;
   u64 handle;
   u32 sm_index;
   u8 sst;
@@ -1050,11 +1133,11 @@ app_worker_application_is_builtin (app_worker_t * app_wrk)
   return app_wrk->app_is_builtin;
 }
 
-stream_session_t *
+session_t *
 application_proxy_listener (app_worker_t * app, u8 fib_proto,
 			    u8 transport_proto)
 {
-  stream_session_t *listener;
+  session_t *listener;
   u64 handle;
   u32 sm_index;
   u8 sst;
@@ -1083,7 +1166,7 @@ application_start_stop_proxy_fib_proto (application_t * app, u8 fib_proto,
   session_endpoint_cfg_t sep = SESSION_ENDPOINT_CFG_NULL;
   transport_connection_t *tc;
   app_worker_t *app_wrk;
-  stream_session_t *s;
+  session_t *s;
   u64 handle;
 
   /* TODO decide if we want proxy to be enabled for all workers */
@@ -1247,7 +1330,7 @@ app_enqueue_evt (svm_msg_q_t * mq, svm_msg_q_msg_t * msg, u8 lock)
 }
 
 static inline int
-app_send_io_evt_rx (app_worker_t * app_wrk, stream_session_t * s, u8 lock)
+app_send_io_evt_rx (app_worker_t * app_wrk, session_t * s, u8 lock)
 {
   session_event_t *evt;
   svm_msg_q_msg_t msg;
@@ -1258,7 +1341,7 @@ app_send_io_evt_rx (app_worker_t * app_wrk, stream_session_t * s, u8 lock)
     {
       /* Session is closed so app will never clean up. Flush rx fifo */
       if (s->session_state == SESSION_STATE_CLOSED)
-	svm_fifo_dequeue_drop_all (s->server_rx_fifo);
+	svm_fifo_dequeue_drop_all (s->rx_fifo);
       return 0;
     }
 
@@ -1268,8 +1351,7 @@ app_send_io_evt_rx (app_worker_t * app_wrk, stream_session_t * s, u8 lock)
       return app->cb_fns.builtin_app_rx_callback (s);
     }
 
-  if (svm_fifo_has_event (s->server_rx_fifo)
-      || svm_fifo_is_empty (s->server_rx_fifo))
+  if (svm_fifo_has_event (s->rx_fifo) || svm_fifo_is_empty (s->rx_fifo))
     return 0;
 
   mq = app_wrk->event_queue;
@@ -1288,10 +1370,10 @@ app_send_io_evt_rx (app_worker_t * app_wrk, stream_session_t * s, u8 lock)
   ASSERT (!svm_msg_q_msg_is_invalid (&msg));
 
   evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
-  evt->fifo = s->server_rx_fifo;
+  evt->fifo = s->rx_fifo;
   evt->event_type = FIFO_EVENT_APP_RX;
 
-  (void) svm_fifo_set_event (s->server_rx_fifo);
+  (void) svm_fifo_set_event (s->rx_fifo);
 
   if (app_enqueue_evt (mq, &msg, lock))
     return -1;
@@ -1299,7 +1381,7 @@ app_send_io_evt_rx (app_worker_t * app_wrk, stream_session_t * s, u8 lock)
 }
 
 static inline int
-app_send_io_evt_tx (app_worker_t * app_wrk, stream_session_t * s, u8 lock)
+app_send_io_evt_tx (app_worker_t * app_wrk, session_t * s, u8 lock)
 {
   svm_msg_q_t *mq;
   session_event_t *evt;
@@ -1325,14 +1407,14 @@ app_send_io_evt_tx (app_worker_t * app_wrk, stream_session_t * s, u8 lock)
 
   evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
   evt->event_type = FIFO_EVENT_APP_TX;
-  evt->fifo = s->server_tx_fifo;
+  evt->fifo = s->tx_fifo;
 
   return app_enqueue_evt (mq, &msg, lock);
 }
 
 /* *INDENT-OFF* */
 typedef int (app_send_evt_handler_fn) (app_worker_t *app,
-				       stream_session_t *s,
+				       session_t *s,
 				       u8 lock);
 static app_send_evt_handler_fn * const app_send_evt_handler_fns[3] = {
     app_send_io_evt_rx,
@@ -1348,7 +1430,7 @@ static app_send_evt_handler_fn * const app_send_evt_handler_fns[3] = {
  * not enough space to enqueue a message, we return.
  */
 int
-app_worker_send_event (app_worker_t * app, stream_session_t * s, u8 evt_type)
+app_worker_send_event (app_worker_t * app, session_t * s, u8 evt_type)
 {
   ASSERT (app && evt_type <= FIFO_EVENT_APP_TX);
   return app_send_evt_handler_fns[evt_type] (app, s, 0 /* lock */ );
@@ -1361,7 +1443,7 @@ app_worker_send_event (app_worker_t * app, stream_session_t * s, u8 evt_type)
  * we return.
  */
 int
-app_worker_lock_and_send_event (app_worker_t * app, stream_session_t * s,
+app_worker_lock_and_send_event (app_worker_t * app, session_t * s,
 				u8 evt_type)
 {
   return app_send_evt_handler_fns[evt_type] (app, s, 1 /* lock */ );
@@ -1501,7 +1583,7 @@ application_stop_local_listen (u32 app_index, u32 wrk_map_index,
   u32 table_index, ll_index, server_index;
   app_listener_t *app_listener;
   app_worker_t *server_wrk;
-  stream_session_t *sl = 0;
+  session_t *sl = 0;
   local_session_t *ll, *ls;
   application_t *server;
 
@@ -1589,14 +1671,15 @@ application_local_session_connect (app_worker_t * client_wrk,
 				   local_session_t * ll, u32 opaque)
 {
   u32 seg_size, evt_q_sz, evt_q_elts, margin = 16 << 10;
+  u32 round_rx_fifo_sz, round_tx_fifo_sz, sm_index;
   segment_manager_properties_t *props, *cprops;
-  u32 round_rx_fifo_sz, round_tx_fifo_sz;
   int rv, has_transport, seg_index;
   svm_fifo_segment_private_t *seg;
   application_t *server, *client;
   segment_manager_t *sm;
   local_session_t *ls;
   svm_msg_q_t *sq, *cq;
+  u64 segment_handle;
 
   ls = application_local_session_alloc (server_wrk);
   server = application_get (server_wrk->app_index);
@@ -1610,7 +1693,7 @@ application_local_session_connect (app_worker_t * client_wrk,
   round_tx_fifo_sz = 1 << max_log2 (props->tx_fifo_size);
   seg_size = round_rx_fifo_sz + round_tx_fifo_sz + evt_q_sz + margin;
 
-  has_transport = session_has_transport ((stream_session_t *) ll);
+  has_transport = session_has_transport ((session_t *) ll);
   if (!has_transport)
     {
       /* Local sessions don't have backing transport */
@@ -1619,7 +1702,7 @@ application_local_session_connect (app_worker_t * client_wrk,
     }
   else
     {
-      stream_session_t *sl = (stream_session_t *) ll;
+      session_t *sl = (session_t *) ll;
       transport_connection_t *tc;
       tc = listen_session_get_transport (sl);
       ls->port = tc->lcl_port;
@@ -1643,16 +1726,20 @@ application_local_session_connect (app_worker_t * client_wrk,
   ls->client_evt_q = pointer_to_uword (cq);
   rv = segment_manager_try_alloc_fifos (seg, props->rx_fifo_size,
 					props->tx_fifo_size,
-					&ls->server_rx_fifo,
-					&ls->server_tx_fifo);
+					&ls->rx_fifo, &ls->tx_fifo);
   if (rv)
     {
       clib_warning ("failed to add fifos in cut-through segment");
       segment_manager_segment_reader_unlock (sm);
       goto failed;
     }
-  ls->server_rx_fifo->ct_session_index = ls->session_index;
-  ls->server_tx_fifo->ct_session_index = ls->session_index;
+  sm_index = segment_manager_index (sm);
+  ls->rx_fifo->ct_session_index = ls->session_index;
+  ls->tx_fifo->ct_session_index = ls->session_index;
+  ls->rx_fifo->segment_manager = sm_index;
+  ls->tx_fifo->segment_manager = sm_index;
+  ls->rx_fifo->segment_index = seg_index;
+  ls->tx_fifo->segment_index = seg_index;
   ls->svm_segment_index = seg_index;
   ls->listener_index = ll->session_index;
   ls->client_wrk_index = client_wrk->wrk_index;
@@ -1660,15 +1747,16 @@ application_local_session_connect (app_worker_t * client_wrk,
   ls->listener_session_type = ll->session_type;
   ls->session_state = SESSION_STATE_READY;
 
+  segment_handle = segment_manager_segment_handle (sm, seg);
   if ((rv = server->cb_fns.add_segment_callback (server_wrk->api_client_index,
-						 &seg->ssvm)))
+						 segment_handle)))
     {
       clib_warning ("failed to notify server of new segment");
       segment_manager_segment_reader_unlock (sm);
       goto failed;
     }
   segment_manager_segment_reader_unlock (sm);
-  if ((rv = server->cb_fns.session_accept_callback ((stream_session_t *) ls)))
+  if ((rv = server->cb_fns.session_accept_callback ((session_t *) ls)))
     {
       clib_warning ("failed to send accept cut-through notify to server");
       goto failed;
@@ -1684,14 +1772,14 @@ failed:
   return rv;
 }
 
-static uword
+static u64
 application_client_local_connect_key (local_session_t * ls)
 {
-  return ((uword) ls->app_wrk_index << 32 | (uword) ls->session_index);
+  return (((u64) ls->app_wrk_index) << 32 | (u64) ls->session_index);
 }
 
 static void
-application_client_local_connect_key_parse (uword key, u32 * app_wrk_index,
+application_client_local_connect_key_parse (u64 key, u32 * app_wrk_index,
 					    u32 * session_index)
 {
   *app_wrk_index = key >> 32;
@@ -1706,7 +1794,8 @@ application_local_session_connect_notify (local_session_t * ls)
   segment_manager_t *sm;
   application_t *client;
   int rv, is_fail = 0;
-  uword client_key;
+  u64 segment_handle;
+  u64 client_key;
 
   client_wrk = app_worker_get (ls->client_wrk_index);
   server_wrk = app_worker_get (ls->app_wrk_index);
@@ -1714,8 +1803,9 @@ application_local_session_connect_notify (local_session_t * ls)
 
   sm = application_get_local_segment_manager_w_session (server_wrk, ls);
   seg = segment_manager_get_segment_w_lock (sm, ls->svm_segment_index);
+  segment_handle = segment_manager_segment_handle (sm, seg);
   if ((rv = client->cb_fns.add_segment_callback (client_wrk->api_client_index,
-						 &seg->ssvm)))
+						 segment_handle)))
     {
       clib_warning ("failed to notify client %u of new segment",
 		    ls->client_wrk_index);
@@ -1730,8 +1820,7 @@ application_local_session_connect_notify (local_session_t * ls)
 
   client->cb_fns.session_connected_callback (client_wrk->wrk_index,
 					     ls->client_opaque,
-					     (stream_session_t *) ls,
-					     is_fail);
+					     (session_t *) ls, is_fail);
 
   client_key = application_client_local_connect_key (ls);
   hash_set (client_wrk->local_connects, client_key, client_key);
@@ -1744,9 +1833,9 @@ application_local_session_cleanup (app_worker_t * client_wrk,
 				   local_session_t * ls)
 {
   svm_fifo_segment_private_t *seg;
-  stream_session_t *listener;
+  session_t *listener;
   segment_manager_t *sm;
-  uword client_key;
+  u64 client_key;
   u8 has_transport;
 
   /* Retrieve listener transport type as it is the one that decides where
@@ -1770,13 +1859,14 @@ application_local_session_cleanup (app_worker_t * client_wrk,
   if (!has_transport)
     {
       application_t *server = application_get (server_wrk->app_index);
+      u64 segment_handle = segment_manager_segment_handle (sm, seg);
       server->cb_fns.del_segment_callback (server_wrk->api_client_index,
-					   &seg->ssvm);
+					   segment_handle);
       if (client_wrk)
 	{
 	  application_t *client = application_get (client_wrk->app_index);
 	  client->cb_fns.del_segment_callback (client_wrk->api_client_index,
-					       &seg->ssvm);
+					       segment_handle);
 	}
       segment_manager_del_segment (sm, seg);
     }
@@ -1831,7 +1921,7 @@ application_local_session_disconnect (u32 app_index, local_session_t * ls)
 	  application_t *client = application_get (client_wrk->app_index);
 	  client->cb_fns.session_connected_callback (client_wrk->wrk_index,
 						     ls->client_opaque,
-						     (stream_session_t *) ls,
+						     (session_t *) ls,
 						     1 /* is_fail */ );
 	  ls->session_state = SESSION_STATE_CLOSED;
 	  return application_local_session_cleanup (client_wrk, server_wrk,
@@ -1939,7 +2029,7 @@ format_app_worker_listener (u8 * s, va_list * args)
   u64 handle = va_arg (*args, u64);
   u32 sm_index = va_arg (*args, u32);
   int verbose = va_arg (*args, int);
-  stream_session_t *listener;
+  session_t *listener;
   const u8 *app_name;
   u8 *str;
 
@@ -2037,7 +2127,7 @@ app_worker_format_connects (app_worker_t * app_wrk, int verbose)
     while (fifo)
       {
         u32 session_index, thread_index;
-        stream_session_t *session;
+        session_t *session;
 
         session_index = fifo->master_session_index;
         thread_index = fifo->master_thread_index;
@@ -2165,7 +2255,7 @@ app_worker_format_local_connects (app_worker_t * app, int verbose)
   u32 app_wrk_index, session_index;
   app_worker_t *server_wrk;
   local_session_t *ls;
-  uword client_key;
+  u64 client_key;
   u64 value;
 
   /* Header */
@@ -2215,6 +2305,19 @@ application_format_local_connects (application_t * app, int verbose)
   /* *INDENT-ON* */
 }
 
+u8 *
+format_application_worker (u8 * s, va_list * args)
+{
+  app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
+  u32 indent = 1;
+
+  s = format (s, "%U wrk-index %u app-index %u map-index %u "
+	      "api-client-index %d\n", format_white_space, indent,
+	      app_wrk->wrk_index, app_wrk->app_index, app_wrk->wrk_map_index,
+	      app_wrk->api_client_index);
+  return s;
+}
+
 u8 *
 format_application (u8 * s, va_list * args)
 {
@@ -2222,13 +2325,12 @@ format_application (u8 * s, va_list * args)
   CLIB_UNUSED (int verbose) = va_arg (*args, int);
   segment_manager_properties_t *props;
   const u8 *app_ns_name, *app_name;
+  app_worker_map_t *wrk_map;
+  app_worker_t *app_wrk;
 
   if (app == 0)
     {
-      if (verbose)
-	s = format (s, "%-10s%-20s%-15s%-15s%-15s%-15s", "Index", "Name",
-		    "Namespace", "Add seg size", "Rx-f size", "Tx-f size");
-      else
+      if (!verbose)
 	s = format (s, "%-10s%-20s%-40s", "Index", "Name", "Namespace");
       return s;
     }
@@ -2236,14 +2338,27 @@ format_application (u8 * s, va_list * args)
   app_name = app_get_name (app);
   app_ns_name = app_namespace_id_from_index (app->ns_index);
   props = application_segment_manager_properties (app);
-  if (verbose)
-    s = format (s, "%-10u%-20s%-15u%-15U%-15U%-15U", app->app_index,
-		app_name, app->ns_index,
-		format_memory_size, props->add_segment_size,
-		format_memory_size, props->rx_fifo_size, format_memory_size,
-		props->tx_fifo_size);
-  else
-    s = format (s, "%-10u%-20s%-40s", app->app_index, app_name, app_ns_name);
+  if (!verbose)
+    {
+      s = format (s, "%-10u%-20s%-40s", app->app_index, app_name,
+		  app_ns_name);
+      return s;
+    }
+
+  s = format (s, "app-name %s app-index %u ns-index %u seg-size %U\n",
+	      app_name, app->app_index, app->ns_index,
+	      format_memory_size, props->add_segment_size);
+  s = format (s, "rx-fifo-size %U tx-fifo-size %U workers:\n",
+	      format_memory_size, props->rx_fifo_size,
+	      format_memory_size, props->tx_fifo_size);
+
+  /* *INDENT-OFF* */
+  pool_foreach (wrk_map, app->worker_maps, ({
+      app_wrk = app_worker_get (wrk_map->wrk_index);
+      s = format (s, "%U", format_application_worker, app_wrk);
+  }));
+  /* *INDENT-ON* */
+
   return s;
 }
 
@@ -2318,6 +2433,7 @@ show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
 {
   int do_server = 0, do_client = 0, do_local = 0;
   application_t *app;
+  u32 app_index = ~0;
   int verbose = 0;
 
   session_cli_return_if_not_enabled ();
@@ -2330,25 +2446,44 @@ show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
 	do_client = 1;
       else if (unformat (input, "local"))
 	do_local = 1;
+      else if (unformat (input, "%u", &app_index))
+	;
       else if (unformat (input, "verbose"))
 	verbose = 1;
       else
-	break;
+	return clib_error_return (0, "unknown input `%U'",
+				  format_unformat_error, input);
     }
 
   if (do_server)
-    application_format_all_listeners (vm, do_local, verbose);
+    {
+      application_format_all_listeners (vm, do_local, verbose);
+      return 0;
+    }
 
   if (do_client)
-    application_format_all_clients (vm, do_local, verbose);
+    {
+      application_format_all_clients (vm, do_local, verbose);
+      return 0;
+    }
+
+  if (app_index != ~0)
+    {
+      app = application_get_if_valid (app_index);
+      if (!app)
+	return clib_error_return (0, "No app with index %u", app_index);
+
+      vlib_cli_output (vm, "%U", format_application, app, /* verbose */ 1);
+      return 0;
+    }
 
   /* Print app related info */
   if (!do_server && !do_client)
     {
-      vlib_cli_output (vm, "%U", format_application, 0, verbose);
+      vlib_cli_output (vm, "%U", format_application, 0, 0);
       /* *INDENT-OFF* */
       pool_foreach (app, app_main.app_pool, ({
-	vlib_cli_output (vm, "%U", format_application, app, verbose);
+	vlib_cli_output (vm, "%U", format_application, app, 0);
       }));
       /* *INDENT-ON* */
     }