uspace/srv/net/tcp/tqueue.c

   1 /*
   2  * Copyright (c) 2011 Jiri Svoboda
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @addtogroup tcp
  30  * @{
  31  */
  32
  33 /**
  34  * @file TCP transmission queue
  35  */
  36
  37 #include <adt/list.h>
  38 #include <errno.h>
  39 #include <fibril_synch.h>
  40 #include <byteorder.h>
  41 #include <io/log.h>
  42 #include <macros.h>
  43 #include <mem.h>
  44 #include <stdlib.h>
  45 #include "conn.h"
  46 #include "ncsim.h"
  47 #include "pdu.h"
  48 #include "rqueue.h"
  49 #include "segment.h"
  50 #include "seq_no.h"
  51 #include "tqueue.h"
  52 #include "tcp.h"
  53 #include "tcp_type.h"
  54
  55 #define RETRANSMIT_TIMEOUT      (2*1000*1000)
  56
  57 static void retransmit_timeout_func(void *arg);
  58 static void tcp_tqueue_timer_set(tcp_conn_t *conn);
  59 static void tcp_tqueue_timer_clear(tcp_conn_t *conn);
  60
  61 int tcp_tqueue_init(tcp_tqueue_t *tqueue, tcp_conn_t *conn)
  62 {
  63         tqueue->conn = conn;
  64         tqueue->timer = fibril_timer_create();
  65         if (tqueue->timer == NULL)
  66                 return ENOMEM;
  67
  68         list_initialize(&tqueue->list);
  69
  70         return EOK;
  71 }
  72
  73 void tcp_tqueue_clear(tcp_tqueue_t *tqueue)
  74 {
  75         tcp_tqueue_timer_clear(tqueue->conn);
  76 }
  77
  78 void tcp_tqueue_fini(tcp_tqueue_t *tqueue)
  79 {
  80         if (tqueue->timer != NULL) {
  81                 fibril_timer_destroy(tqueue->timer);
  82                 tqueue->timer = NULL;
  83         }
  84 }
  85
  86 void tcp_tqueue_ctrl_seg(tcp_conn_t *conn, tcp_control_t ctrl)
  87 {
  88         tcp_segment_t *seg;
  89
  90         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_tqueue_ctrl_seg(%p, %u)", conn, ctrl);
  91
  92         seg = tcp_segment_make_ctrl(ctrl);
  93         tcp_tqueue_seg(conn, seg);
  94 }
  95
  96 void tcp_tqueue_seg(tcp_conn_t *conn, tcp_segment_t *seg)
  97 {
  98         tcp_segment_t *rt_seg;
  99         tcp_tqueue_entry_t *tqe;
 100
 101         log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_tqueue_seg(%p, %p)", conn->name, conn,
 102             seg);
 103
 104         /*
 105          * Add segment to retransmission queue
 106          */
 107
 108         if (seg->len > 0) {
 109                 rt_seg = tcp_segment_dup(seg);
 110                 if (rt_seg == NULL) {
 111                         log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed.");
 112                         /* XXX Handle properly */
 113                         return;
 114                 }
 115
 116                 tqe = calloc(1, sizeof(tcp_tqueue_entry_t));
 117                 if (tqe == NULL) {
 118                         log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed.");
 119                         /* XXX Handle properly */
 120                         return;
 121                 }
 122
 123                 tqe->conn = conn;
 124                 tqe->seg = rt_seg;
 125                 rt_seg->seq = conn->snd_nxt;
 126
 127                 list_append(&tqe->link, &conn->retransmit.list);
 128
 129                 /* Set retransmission timer */
 130                 tcp_tqueue_timer_set(conn);
 131         }
 132
 133         tcp_prepare_transmit_segment(conn, seg);
 134 }
 135
 136 void tcp_prepare_transmit_segment(tcp_conn_t *conn, tcp_segment_t *seg)
 137 {
 138         /*
 139          * Always send ACK once we have received SYN, except for RST segments.
 140          * (Spec says we should always send ACK once connection has been
 141          * established.)
 142          */
 143         if (tcp_conn_got_syn(conn) && (seg->ctrl & CTL_RST) == 0)
 144                 seg->ctrl |= CTL_ACK;
 145
 146         seg->seq = conn->snd_nxt;
 147         conn->snd_nxt += seg->len;
 148
 149         tcp_conn_transmit_segment(conn, seg);
 150 }
 151
 152 /** Transmit data from the send buffer.
 153  *
 154  * @param conn  Connection
 155  */
 156 void tcp_tqueue_new_data(tcp_conn_t *conn)
 157 {
 158         size_t avail_wnd;
 159         size_t xfer_seqlen;
 160         size_t snd_buf_seqlen;
 161         size_t data_size;
 162         tcp_control_t ctrl;
 163         bool send_fin;
 164
 165         tcp_segment_t *seg;
 166
 167         log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_tqueue_new_data()", conn->name);
 168
 169         /* Number of free sequence numbers in send window */
 170         avail_wnd = (conn->snd_una + conn->snd_wnd) - conn->snd_nxt;
 171         snd_buf_seqlen = conn->snd_buf_used + (conn->snd_buf_fin ? 1 : 0);
 172
 173         xfer_seqlen = min(snd_buf_seqlen, avail_wnd);
 174         log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: snd_buf_seqlen = %zu, SND.WND = %zu, "
 175             "xfer_seqlen = %zu", conn->name, snd_buf_seqlen, conn->snd_wnd,
 176             xfer_seqlen);
 177
 178         if (xfer_seqlen == 0)
 179                 return;
 180
 181         /* XXX Do not always send immediately */
 182
 183         send_fin = conn->snd_buf_fin && xfer_seqlen == snd_buf_seqlen;
 184         data_size = xfer_seqlen - (send_fin ? 1 : 0);
 185
 186         if (send_fin) {
 187                 log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: Sending out FIN.", conn->name);
 188                 /* We are sending out FIN */
 189                 ctrl = CTL_FIN;
 190         } else {
 191                 ctrl = 0;
 192         }
 193
 194         seg = tcp_segment_make_data(ctrl, conn->snd_buf, data_size);
 195         if (seg == NULL) {
 196                 log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failure.");
 197                 return;
 198         }
 199
 200         /* Remove data from send buffer */
 201         memmove(conn->snd_buf, conn->snd_buf + data_size,
 202             conn->snd_buf_used - data_size);
 203         conn->snd_buf_used -= data_size;
 204
 205         if (send_fin)
 206                 conn->snd_buf_fin = false;
 207
 208         fibril_condvar_broadcast(&conn->snd_buf_cv);
 209
 210         if (send_fin)
 211                 tcp_conn_fin_sent(conn);
 212
 213         tcp_tqueue_seg(conn, seg);
 214 }
 215
 216 /** Remove ACKed segments from retransmission queue and possibly transmit
 217  * more data.
 218  *
 219  * This should be called when SND.UNA is updated due to incoming ACK.
 220  */
 221 void tcp_tqueue_ack_received(tcp_conn_t *conn)
 222 {
 223         link_t *cur, *next;
 224
 225         log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_tqueue_ack_received(%p)", conn->name,
 226             conn);
 227
 228         cur = conn->retransmit.list.head.next;
 229
 230         while (cur != &conn->retransmit.list.head) {
 231                 next = cur->next;
 232
 233                 tcp_tqueue_entry_t *tqe = list_get_instance(cur,
 234                     tcp_tqueue_entry_t, link);
 235
 236                 if (seq_no_segment_acked(conn, tqe->seg, conn->snd_una)) {
 237                         /* Remove acknowledged segment */
 238                         list_remove(cur);
 239
 240                         if ((tqe->seg->ctrl & CTL_FIN) != 0) {
 241                                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Fin has been acked");
 242                                 log_msg(LOG_DEFAULT, LVL_DEBUG, "SND.UNA=%" PRIu32
 243                                     " SEG.SEQ=%" PRIu32 " SEG.LEN=%" PRIu32,
 244                                     conn->snd_una, tqe->seg->seq, tqe->seg->len);
 245                                 /* Our FIN has been acked */
 246                                 conn->fin_is_acked = true;
 247                         }
 248
 249                         tcp_segment_delete(tqe->seg);
 250                         free(tqe);
 251
 252                         /* Reset retransmission timer */
 253                         tcp_tqueue_timer_set(conn);
 254                 }
 255
 256                 cur = next;
 257         }
 258
 259         /* Clear retransmission timer if the queue is empty. */
 260         if (list_empty(&conn->retransmit.list))
 261                 tcp_tqueue_timer_clear(conn);
 262
 263         /* Possibly transmit more data */
 264         tcp_tqueue_new_data(conn);
 265 }
 266
 267 void tcp_conn_transmit_segment(tcp_conn_t *conn, tcp_segment_t *seg)
 268 {
 269         log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_transmit_segment(%p, %p)",
 270             conn->name, conn, seg);
 271
 272         seg->wnd = conn->rcv_wnd;
 273
 274         if ((seg->ctrl & CTL_ACK) != 0)
 275                 seg->ack = conn->rcv_nxt;
 276         else
 277                 seg->ack = 0;
 278
 279         tcp_transmit_segment(&conn->ident, seg);
 280 }
 281
 282 void tcp_transmit_segment(tcp_sockpair_t *sp, tcp_segment_t *seg)
 283 {
 284         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_transmit_segment(f:(%x,%u),l:(%x,%u), %p)",
 285             sp->foreign.addr.ipv4, sp->foreign.port,
 286             sp->local.addr.ipv4, sp->local.port, seg);
 287
 288         log_msg(LOG_DEFAULT, LVL_DEBUG, "SEG.SEQ=%" PRIu32 ", SEG.WND=%" PRIu32,
 289             seg->seq, seg->wnd);
 290
 291         tcp_segment_dump(seg);
 292 /*
 293         tcp_pdu_prepare(conn, seg, &data, &len);
 294         tcp_pdu_transmit(data, len);
 295 */
 296 //      tcp_rqueue_bounce_seg(sp, seg);
 297 //      tcp_ncsim_bounce_seg(sp, seg);
 298
 299         tcp_pdu_t *pdu;
 300
 301         if (tcp_pdu_encode(sp, seg, &pdu) != EOK) {
 302                 log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. Segment dropped.");
 303                 return;
 304         }
 305
 306         tcp_transmit_pdu(pdu);
 307         tcp_pdu_delete(pdu);
 308 }
 309
 310 static void retransmit_timeout_func(void *arg)
 311 {
 312         tcp_conn_t *conn = (tcp_conn_t *) arg;
 313         tcp_tqueue_entry_t *tqe;
 314         tcp_segment_t *rt_seg;
 315         link_t *link;
 316
 317         log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: retransmit_timeout_func(%p)", conn->name, conn);
 318
 319         fibril_mutex_lock(&conn->lock);
 320
 321         if (conn->cstate == st_closed) {
 322                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Connection already closed.");
 323                 fibril_mutex_unlock(&conn->lock);
 324                 tcp_conn_delref(conn);
 325                 return;
 326         }
 327
 328         link = list_first(&conn->retransmit.list);
 329         if (link == NULL) {
 330                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Nothing to retransmit");
 331                 fibril_mutex_unlock(&conn->lock);
 332                 tcp_conn_delref(conn);
 333                 return;
 334         }
 335
 336         tqe = list_get_instance(link, tcp_tqueue_entry_t, link);
 337
 338         rt_seg = tcp_segment_dup(tqe->seg);
 339         if (rt_seg == NULL) {
 340                 log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed.");
 341                 fibril_mutex_unlock(&conn->lock);
 342                 tcp_conn_delref(conn);
 343                 /* XXX Handle properly */
 344                 return;
 345         }
 346
 347         log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: retransmitting segment", conn->name);
 348         tcp_conn_transmit_segment(tqe->conn, rt_seg);
 349
 350         /* Reset retransmission timer */
 351         tcp_tqueue_timer_set(tqe->conn);
 352
 353         fibril_mutex_unlock(&conn->lock);
 354         tcp_conn_delref(conn);
 355 }
 356
 357 /** Set or re-set retransmission timer */
 358 static void tcp_tqueue_timer_set(tcp_conn_t *conn)
 359 {
 360         log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_set()", conn->name);
 361
 362         /* Clear first to make sure we update refcnt correctly */
 363         tcp_tqueue_timer_clear(conn);
 364
 365         tcp_conn_addref(conn);
 366         fibril_timer_set(conn->retransmit.timer, RETRANSMIT_TIMEOUT,
 367             retransmit_timeout_func, (void *) conn);
 368 }
 369
 370 /** Clear retransmission timer */
 371 static void tcp_tqueue_timer_clear(tcp_conn_t *conn)
 372 {
 373         log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_clear()", conn->name);
 374
 375         if (fibril_timer_clear(conn->retransmit.timer) == fts_active)
 376                 tcp_conn_delref(conn);
 377 }
 378
 379 /**
 380  * @}
 381  */