source: mainline/uspace/srv/net/tcp/tqueue.c@ 69c1995

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 69c1995 was 70253688, checked in by Vojtech Horky <vojtechhorky@…>, 13 years ago

Merge mainline changes
  • Property mode set to 100644
File size: 9.6 KB
Line 
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
57static void retransmit_timeout_func(void *arg);
58static void tcp_tqueue_timer_set(tcp_conn_t *conn);
59static void tcp_tqueue_timer_clear(tcp_conn_t *conn);
60
61int 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
73void tcp_tqueue_clear(tcp_tqueue_t *tqueue)
74{
75 tcp_tqueue_timer_clear(tqueue->conn);
76}
77
78void 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
86void 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
96void 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
136void 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 */
156void 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 = %" PRIu32 ", "
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 */
221void 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
267void 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
282void 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
310static 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 */
358static 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 */
371static 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 */
Note: See TracBrowser for help on using the repository browser.