session: free session after transport and app confirm

[vpp.git] / src / plugins / unittest / tcp_test.c

diff --git a/src/plugins/unittest/tcp_test.c b/src/plugins/unittest/tcp_test.c
index c19d0f0..66260df 100644 (file)
--- a/src/plugins/unittest/tcp_test.c
+++ b/src/plugins/unittest/tcp_test.c
@@ -83,12 +83,13 @@ tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input)
        return tcp_test_scoreboard_replay (vm, input);
     }
 
-  memset (tc, 0, sizeof (*tc));
+  clib_memset (tc, 0, sizeof (*tc));
 
   tc->snd_una = 0;
   tc->snd_una_max = 1000;
   tc->snd_nxt = 1000;
   tc->rcv_opts.flags |= TCP_OPTS_FLAG_SACK;
+  tc->snd_mss = 150;
   scoreboard_init (&tc->sack_sb);
 
   for (i = 0; i < 1000 / 100; i++)
@@ -110,8 +111,8 @@ tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input)
   tcp_rcv_sacks (tc, 0);
 
   if (verbose)
-    vlib_cli_output (vm, "sb after even blocks:\n%U", format_tcp_scoreboard,
-                    sb);
+    vlib_cli_output (vm, "sb after even blocks (mss %u):\n%U",
+                    tc->snd_mss, format_tcp_scoreboard, sb, tc);
 
   TCP_TEST ((pool_elts (sb->holes) == 5),
            "scoreboard has %d elements", pool_elts (sb->holes));
@@ -127,7 +128,9 @@ tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input)
   TCP_TEST ((sb->snd_una_adv == 0), "snd_una_adv %u", sb->snd_una_adv);
   TCP_TEST ((sb->last_sacked_bytes == 400),
            "last sacked bytes %d", sb->last_sacked_bytes);
-  TCP_TEST ((sb->high_sacked == 900), "max byte sacked %u", sb->high_sacked);
+  TCP_TEST ((sb->high_sacked == 900), "high sacked %u", sb->high_sacked);
+  TCP_TEST ((sb->lost_bytes == 300), "lost bytes %u", sb->lost_bytes);
+
   /*
    * Inject odd blocks
    */
@@ -141,8 +144,8 @@ tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input)
   tcp_rcv_sacks (tc, 0);
 
   if (verbose)
-    vlib_cli_output (vm, "sb after odd blocks:\n%U", format_tcp_scoreboard,
-                    sb);
+    vlib_cli_output (vm, "\nsb after odd blocks:\n%U", format_tcp_scoreboard,
+                    sb, tc);
 
   hole = scoreboard_first_hole (sb);
   TCP_TEST ((pool_elts (sb->holes) == 1),
@@ -151,17 +154,18 @@ tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input)
            "first hole start %u end %u", hole->start, hole->end);
   TCP_TEST ((sb->sacked_bytes == 900), "sacked bytes %d", sb->sacked_bytes);
   TCP_TEST ((sb->snd_una_adv == 0), "snd_una_adv %u", sb->snd_una_adv);
-  TCP_TEST ((sb->high_sacked == 1000), "max sacked byte %u", sb->high_sacked);
+  TCP_TEST ((sb->high_sacked == 1000), "high sacked %u", sb->high_sacked);
   TCP_TEST ((sb->last_sacked_bytes == 500),
            "last sacked bytes %d", sb->last_sacked_bytes);
+  TCP_TEST ((sb->lost_bytes == 100), "lost bytes %u", sb->lost_bytes);
 
   /*
    *  Ack until byte 100, all bytes are now acked + sacked
    */
   tcp_rcv_sacks (tc, 100);
   if (verbose)
-    vlib_cli_output (vm, "ack until byte 100:\n%U", format_tcp_scoreboard,
-                    sb);
+    vlib_cli_output (vm, "\nack until byte 100:\n%U", format_tcp_scoreboard,
+                    sb, tc);
 
   TCP_TEST ((pool_elts (sb->holes) == 0),
            "scoreboard has %d elements", pool_elts (sb->holes));
@@ -171,6 +175,7 @@ tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input)
   TCP_TEST ((sb->sacked_bytes == 0), "sacked bytes %d", sb->sacked_bytes);
   TCP_TEST ((sb->last_sacked_bytes == 0),
            "last sacked bytes %d", sb->last_sacked_bytes);
+  TCP_TEST ((sb->lost_bytes == 0), "lost bytes %u", sb->lost_bytes);
 
   /*
    * Add new block
@@ -182,16 +187,14 @@ tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input)
   block.end = 1300;
   vec_add1 (tc->rcv_opts.sacks, block);
 
-  if (verbose)
-    vlib_cli_output (vm, "add [1200, 1300]:\n%U", format_tcp_scoreboard, sb);
   tc->snd_una_max = 1500;
   tc->snd_una = 1000;
   tc->snd_nxt = 1500;
   tcp_rcv_sacks (tc, 1000);
 
   if (verbose)
-    vlib_cli_output (vm, "sb snd_una_max 1500, snd_una 1000:\n%U",
-                    format_tcp_scoreboard, sb);
+    vlib_cli_output (vm, "\nadd [1200, 1300] snd_una_max 1500, snd_una 1000:"
+                    " \n%U", format_tcp_scoreboard, sb, tc);
 
   TCP_TEST ((sb->snd_una_adv == 0),
            "snd_una_adv after ack %u", sb->snd_una_adv);
@@ -207,6 +210,7 @@ tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input)
   TCP_TEST ((hole->start == 1300 && hole->end == 1500),
            "last hole start %u end %u", hole->start, hole->end);
   TCP_TEST ((sb->sacked_bytes == 100), "sacked bytes %d", sb->sacked_bytes);
+  TCP_TEST ((sb->lost_bytes == 0), "lost bytes %u", sb->lost_bytes);
 
   /*
    * Ack first hole
@@ -216,19 +220,19 @@ tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input)
   tcp_rcv_sacks (tc, 1200);
 
   if (verbose)
-    vlib_cli_output (vm, "sb ack up to byte 1200:\n%U", format_tcp_scoreboard,
-                    sb);
+    vlib_cli_output (vm, "\nsb ack up to byte 1200:\n%U",
+                    format_tcp_scoreboard, sb, tc);
 
   TCP_TEST ((sb->snd_una_adv == 100),
            "snd_una_adv after ack %u", sb->snd_una_adv);
   TCP_TEST ((sb->sacked_bytes == 0), "sacked bytes %d", sb->sacked_bytes);
-  TCP_TEST ((pool_elts (sb->holes) == 1),
+  TCP_TEST ((pool_elts (sb->holes) == 0),
            "scoreboard has %d elements", pool_elts (sb->holes));
-  hole = scoreboard_first_hole (sb);
-  TCP_TEST ((hole->prev == TCP_INVALID_SACK_HOLE_INDEX
-            && hole->next == TCP_INVALID_SACK_HOLE_INDEX), "hole is valid");
   TCP_TEST ((sb->last_bytes_delivered == 100), "last bytes delivered %d",
            sb->last_bytes_delivered);
+  TCP_TEST ((sb->lost_bytes == 0), "lost bytes %u", sb->lost_bytes);
+  TCP_TEST ((sb->head == TCP_INVALID_SACK_HOLE_INDEX), "head %u", sb->head);
+  TCP_TEST ((sb->tail == TCP_INVALID_SACK_HOLE_INDEX), "tail %u", sb->tail);
 
   /*
    * Add some more blocks and then remove all
@@ -246,7 +250,8 @@ tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input)
 
   scoreboard_clear (sb);
   if (verbose)
-    vlib_cli_output (vm, "sb cleared all:\n%U", format_tcp_scoreboard, sb);
+    vlib_cli_output (vm, "\nsb cleared all:\n%U", format_tcp_scoreboard, sb,
+                    tc);
 
   TCP_TEST ((pool_elts (sb->holes) == 0),
            "number of holes %d", pool_elts (sb->holes));
@@ -267,14 +272,17 @@ tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input)
   tc->rcv_opts.n_sack_blocks = vec_len (tc->rcv_opts.sacks);
   tcp_rcv_sacks (tc, 0);
   if (verbose)
-    vlib_cli_output (vm, "sb added odd blocks and ack [0, 950]:\n%U",
-                    format_tcp_scoreboard, sb);
+    vlib_cli_output (vm, "\nsb added odd blocks snd_una 0 snd_una_max 1500:"
+                    "\n%U", format_tcp_scoreboard, sb, tc);
+  TCP_TEST ((pool_elts (sb->holes) == 5),
+           "scoreboard has %d elements", pool_elts (sb->holes));
+  TCP_TEST ((sb->lost_bytes == 300), "lost bytes %u", sb->lost_bytes);
 
   tcp_rcv_sacks (tc, 950);
 
   if (verbose)
-    vlib_cli_output (vm, "sb added odd blocks and ack [0, 950]:\n%U",
-                    format_tcp_scoreboard, sb);
+    vlib_cli_output (vm, "\nack [0, 950]:\n%U", format_tcp_scoreboard, sb,
+                    tc);
 
   TCP_TEST ((pool_elts (sb->holes) == 0),
            "scoreboard has %d elements", pool_elts (sb->holes));
@@ -282,6 +290,7 @@ tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input)
   TCP_TEST ((sb->sacked_bytes == 0), "sacked bytes %d", sb->sacked_bytes);
   TCP_TEST ((sb->last_sacked_bytes == 0),
            "last sacked bytes %d", sb->last_sacked_bytes);
+  TCP_TEST ((sb->lost_bytes == 0), "lost bytes %u", sb->lost_bytes);
 
   /*
    * Inject one block, ack it and overlap hole
@@ -299,22 +308,26 @@ tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input)
   tcp_rcv_sacks (tc, 0);
 
   if (verbose)
-    vlib_cli_output (vm, "sb added [100, 500]:\n%U",
-                    format_tcp_scoreboard, sb);
+    vlib_cli_output (vm, "\nsb added [100, 500] snd_una 0 snd_una_max 1000:"
+                    "\n%U", format_tcp_scoreboard, sb, tc);
 
   tcp_rcv_sacks (tc, 800);
 
   if (verbose)
-    vlib_cli_output (vm, "sb ack [0, 800]:\n%U", format_tcp_scoreboard, sb);
+    vlib_cli_output (vm, "\nsb ack [0, 800]:\n%U", format_tcp_scoreboard, sb,
+                    tc);
 
-  TCP_TEST ((pool_elts (sb->holes) == 1),
+  TCP_TEST ((pool_elts (sb->holes) == 0),
            "scoreboard has %d elements", pool_elts (sb->holes));
   TCP_TEST ((sb->snd_una_adv == 0), "snd_una_adv %u", sb->snd_una_adv);
   TCP_TEST ((sb->sacked_bytes == 0), "sacked bytes %d", sb->sacked_bytes);
-  TCP_TEST ((sb->last_sacked_bytes == 0),
-           "last sacked bytes %d", sb->last_sacked_bytes);
+  TCP_TEST ((sb->last_sacked_bytes == 0), "last sacked bytes %d",
+           sb->last_sacked_bytes);
   TCP_TEST ((sb->last_bytes_delivered == 400),
            "last bytes delivered %d", sb->last_bytes_delivered);
+  TCP_TEST ((sb->lost_bytes == 0), "lost bytes %u", sb->lost_bytes);
+  TCP_TEST ((sb->head == TCP_INVALID_SACK_HOLE_INDEX), "head %u", sb->head);
+  TCP_TEST ((sb->tail == TCP_INVALID_SACK_HOLE_INDEX), "tail %u", sb->tail);
 
   /*
    * One hole close to head, patch head, split in two and start acking
@@ -332,8 +345,12 @@ tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input)
 
   tcp_rcv_sacks (tc, 0);
   if (verbose)
-    vlib_cli_output (vm, "sb added [500, 1000]:\n%U",
-                    format_tcp_scoreboard, sb);
+    vlib_cli_output (vm, "\nsb added [500, 1000]:\n%U",
+                    format_tcp_scoreboard, sb, tc);
+  TCP_TEST ((sb->sacked_bytes == 500), "sacked bytes %d", sb->sacked_bytes);
+  TCP_TEST ((sb->last_sacked_bytes == 500), "last sacked bytes %d",
+           sb->last_sacked_bytes);
+  TCP_TEST ((sb->lost_bytes == 500), "lost bytes %u", sb->lost_bytes);
 
   vec_reset_length (tc->rcv_opts.sacks);
   block.start = 300;
@@ -342,17 +359,82 @@ tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input)
   tc->rcv_opts.n_sack_blocks = vec_len (tc->rcv_opts.sacks);
   tcp_rcv_sacks (tc, 100);
   if (verbose)
-    vlib_cli_output (vm, "sb added [0, 100] [300, 400]:\n%U",
-                    format_tcp_scoreboard, sb);
+    vlib_cli_output (vm, "\nsb added [0, 100] [300, 400]:\n%U",
+                    format_tcp_scoreboard, sb, tc);
   TCP_TEST ((pool_elts (sb->holes) == 2),
            "scoreboard has %d elements", pool_elts (sb->holes));
+  TCP_TEST ((sb->sacked_bytes == 600), "sacked bytes %d", sb->sacked_bytes);
+  TCP_TEST ((sb->last_sacked_bytes == 100), "last sacked bytes %d",
+           sb->last_sacked_bytes);
+  TCP_TEST ((sb->last_bytes_delivered == 0), "last bytes delivered %d",
+           sb->last_bytes_delivered);
+  TCP_TEST ((sb->lost_bytes == 300), "lost bytes %u", sb->lost_bytes);
 
   tc->snd_una = 100;
   tcp_rcv_sacks (tc, 200);
+  tc->snd_una = 200;
   tcp_rcv_sacks (tc, 300);
   if (verbose)
-    vlib_cli_output (vm, "sb added [0, 300]:\n%U", format_tcp_scoreboard, sb);
+    vlib_cli_output (vm, "\nacked [0, 300] in two steps:\n%U",
+                    format_tcp_scoreboard, sb, tc);
   TCP_TEST ((sb->sacked_bytes == 500), "sacked bytes %d", sb->sacked_bytes);
+  TCP_TEST ((sb->lost_bytes == 100), "lost bytes %u", sb->lost_bytes);
+  TCP_TEST ((sb->last_bytes_delivered == 100), "last bytes delivered %d",
+           sb->last_bytes_delivered);
+
+  tc->snd_una = 400;
+  tcp_rcv_sacks (tc, 500);
+  if (verbose)
+    vlib_cli_output (vm, "\nacked [400, 500]:\n%U", format_tcp_scoreboard, sb,
+                    tc);
+  TCP_TEST ((pool_elts (sb->holes) == 0),
+           "scoreboard has %d elements", pool_elts (sb->holes));
+  TCP_TEST ((sb->sacked_bytes == 0), "sacked bytes %d", sb->sacked_bytes);
+  TCP_TEST ((sb->last_sacked_bytes == 0), "last sacked bytes %d",
+           sb->last_sacked_bytes);
+  TCP_TEST ((sb->last_bytes_delivered == 500), "last bytes delivered %d",
+           sb->last_bytes_delivered);
+  TCP_TEST ((sb->lost_bytes == 0), "lost bytes %u", sb->lost_bytes);
+  TCP_TEST ((sb->snd_una_adv == 500), "snd_una_adv %u", sb->snd_una_adv);
+  TCP_TEST ((sb->head == TCP_INVALID_SACK_HOLE_INDEX), "head %u", sb->head);
+  TCP_TEST ((sb->tail == TCP_INVALID_SACK_HOLE_INDEX), "tail %u", sb->tail);
+
+  /*
+   * Re-ack high sacked, to make sure last_bytes_delivered and
+   * snd_una_adv are 0-ed
+   */
+  tcp_rcv_sacks (tc, 1000);
+  if (verbose)
+    vlib_cli_output (vm, "\nAck high sacked:\n%U", format_tcp_scoreboard, sb,
+                    tc);
+  TCP_TEST ((sb->last_bytes_delivered == 0), "last bytes delivered %d",
+           sb->last_bytes_delivered);
+  TCP_TEST ((sb->snd_una_adv == 0), "snd_una_adv %u", sb->snd_una_adv);
+
+  /*
+   * Add [1200, 1500] and test that [1000, 1200] is lost (bytes condition)
+   * snd_una = 1000 and snd_una_max = 1600
+   */
+  tc->snd_una = 1000;
+  tc->snd_una_max = 1600;
+  vec_reset_length (tc->rcv_opts.sacks);
+  block.start = 1200;
+  block.end = 1500;
+  vec_add1 (tc->rcv_opts.sacks, block);
+  tc->rcv_opts.n_sack_blocks = vec_len (tc->rcv_opts.sacks);
+  tcp_rcv_sacks (tc, 1000);
+  if (verbose)
+    vlib_cli_output (vm, "\nacked [1200, 1500] test first hole is lost:\n%U",
+                    format_tcp_scoreboard, sb, tc);
+  TCP_TEST ((pool_elts (sb->holes) == 2), "scoreboard has %d elements",
+           pool_elts (sb->holes));
+  TCP_TEST ((sb->sacked_bytes == 300), "sacked bytes %d", sb->sacked_bytes);
+  TCP_TEST ((sb->last_sacked_bytes == 300), "last sacked bytes %d",
+           sb->last_sacked_bytes);
+  TCP_TEST ((sb->last_bytes_delivered == 0), "last bytes delivered %d",
+           sb->last_bytes_delivered);
+  TCP_TEST ((sb->lost_bytes == 200), "lost bytes %u", sb->lost_bytes);
+  TCP_TEST ((sb->snd_una_adv == 0), "snd_una_adv %u", sb->snd_una_adv);
 
   return 0;
 }
@@ -376,7 +458,7 @@ tcp_test_sack_tx (vlib_main_t * vm, unformat_input_t * input)
        }
     }
 
-  memset (tc, 0, sizeof (*tc));
+  clib_memset (tc, 0, sizeof (*tc));
 
   /*
    * Add odd sack block pairs
@@ -658,7 +740,7 @@ fifo_prepare (u32 fifo_size)
   f = svm_fifo_create (fifo_size);
 
   /* Paint fifo data vector with -1's */
-  memset (f->data, 0xFF, fifo_size);
+  clib_memset (f->data, 0xFF, fifo_size);
 
   return f;
 }
@@ -1564,12 +1646,12 @@ tcp_test_lookup (vlib_main_t * vm, unformat_input_t * input)
   /*
    * Allocate fake session and connection 1
    */
-  pool_get (smm->sessions[0], s);
-  memset (s, 0, sizeof (*s));
-  s->session_index = sidx = s - smm->sessions[0];
+  pool_get (smm->wrk[0].sessions, s);
+  clib_memset (s, 0, sizeof (*s));
+  s->session_index = sidx = s - smm->wrk[0].sessions;
 
   pool_get (tm->connections[0], tc);
-  memset (tc, 0, sizeof (*tc));
+  clib_memset (tc, 0, sizeof (*tc));
   tc->connection.c_index = tc - tm->connections[0];
   tc->connection.s_index = s->session_index;
   s->connection_index = tc->connection.c_index;
@@ -1580,17 +1662,17 @@ tcp_test_lookup (vlib_main_t * vm, unformat_input_t * input)
   tc->connection.rmt_port = 53764;
   tc->connection.proto = TRANSPORT_PROTO_TCP;
   tc->connection.is_ip4 = 1;
-  clib_memcpy (tc1, &tc->connection, sizeof (*tc1));
+  clib_memcpy_fast (tc1, &tc->connection, sizeof (*tc1));
 
   /*
    * Allocate fake session and connection 2
    */
-  pool_get (session_manager_main.sessions[0], s);
-  memset (s, 0, sizeof (*s));
-  s->session_index = s - smm->sessions[0];
+  pool_get (smm->wrk[0].sessions, s);
+  clib_memset (s, 0, sizeof (*s));
+  s->session_index = s - smm->wrk[0].sessions;
 
   pool_get (tm->connections[0], tc);
-  memset (tc, 0, sizeof (*tc));
+  clib_memset (tc, 0, sizeof (*tc));
   tc->connection.c_index = tc - tm->connections[0];
   tc->connection.s_index = s->session_index;
   s->connection_index = tc->connection.c_index;
@@ -1601,13 +1683,13 @@ tcp_test_lookup (vlib_main_t * vm, unformat_input_t * input)
   tc->connection.rmt_port = 53764;
   tc->connection.proto = TRANSPORT_PROTO_TCP;
   tc->connection.is_ip4 = 1;
-  clib_memcpy (tc2, &tc->connection, sizeof (*tc2));
+  clib_memcpy_fast (tc2, &tc->connection, sizeof (*tc2));
 
   /*
    * Confirm that connection lookup works
    */
 
-  s1 = pool_elt_at_index (smm->sessions[0], sidx);
+  s1 = pool_elt_at_index (smm->wrk[0].sessions, sidx);
   session_lookup_add_connection (tc1, session_handle (s1));
   tconn = session_lookup_connection_wt4 (0, &tc1->lcl_ip.ip4,
                                         &tc1->rmt_ip.ip4,
@@ -1687,7 +1769,7 @@ tcp_test_session (vlib_main_t * vm, unformat_input_t * input)
       remote_port = clib_host_to_net_u16 (11234);
 
       pool_get (tm->connections[0], tc0);
-      memset (tc0, 0, sizeof (*tc0));
+      clib_memset (tc0, 0, sizeof (*tc0));
 
       tc0->state = TCP_STATE_ESTABLISHED;
       tc0->rcv_las = 1;
@@ -1713,7 +1795,7 @@ tcp_test_session (vlib_main_t * vm, unformat_input_t * input)
     {
       tc0 = tcp_connection_get (0 /* connection index */ , 0 /* thread */ );
       tc0->state = TCP_STATE_CLOSED;
-      stream_session_disconnect_notify (&tc0->connection);
+      session_transport_closing_notify (&tc0->connection);
     }
 
   return rv;