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

Last change on this file since ca48672 was b7fd2a0, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 7 years ago

Use errno_t in all uspace and kernel code.

Change type of every variable, parameter and return value that holds an
<errno.h> constant to either errno_t (the usual case), or sys_errno_t
(some places in kernel). This is for the purpose of self-documentation,
as well as for type-checking with a bit of type definition hackery.

Although this is a massive commit, it is a simple text replacement, and thus
is very easy to verify. Simply do the following:

`
git checkout <this commit's hash>
git reset HEAD
git add .
tools/srepl '\berrno_t\b' int
git add .
tools/srepl '\bsys_errno_t\b' sysarg_t
git reset
git diff
`

While this doesn't ensure that the replacements are correct, it does ensure
that the commit doesn't do anything except those replacements. Since errno_t
is typedef'd to int in the usual case (and sys_errno_t to sysarg_t), even if
incorrect, this commit cannot change behavior.
  • Property mode set to 100644
File size: 10.4 KB
Line 
1/*
2 * Copyright (c) 2015 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
46#include "conn.h"
47#include "inet.h"
48#include "ncsim.h"
49#include "rqueue.h"
50#include "segment.h"
51#include "seq_no.h"
52#include "tqueue.h"
53#include "tcp_type.h"
54
55#define RETRANSMIT_TIMEOUT (2*1000*1000)
56
57static void retransmit_timeout_func(void *);
58static void tcp_tqueue_timer_set(tcp_conn_t *);
59static void tcp_tqueue_timer_clear(tcp_conn_t *);
60static void tcp_tqueue_seg(tcp_conn_t *, tcp_segment_t *);
61static void tcp_conn_transmit_segment(tcp_conn_t *, tcp_segment_t *);
62static void tcp_prepare_transmit_segment(tcp_conn_t *, tcp_segment_t *);
63static void tcp_tqueue_send_immed(tcp_conn_t *, tcp_segment_t *);
64
65errno_t tcp_tqueue_init(tcp_tqueue_t *tqueue, tcp_conn_t *conn,
66 tcp_tqueue_cb_t *cb)
67{
68 tqueue->conn = conn;
69 tqueue->timer = fibril_timer_create(&conn->lock);
70 tqueue->cb = cb;
71 if (tqueue->timer == NULL)
72 return ENOMEM;
73
74 list_initialize(&tqueue->list);
75
76 return EOK;
77}
78
79void tcp_tqueue_clear(tcp_tqueue_t *tqueue)
80{
81 tcp_tqueue_timer_clear(tqueue->conn);
82}
83
84void tcp_tqueue_fini(tcp_tqueue_t *tqueue)
85{
86 link_t *link;
87 tcp_tqueue_entry_t *tqe;
88
89 if (tqueue->timer != NULL) {
90 fibril_timer_destroy(tqueue->timer);
91 tqueue->timer = NULL;
92 }
93
94 while (!list_empty(&tqueue->list)) {
95 link = list_first(&tqueue->list);
96 tqe = list_get_instance(link, tcp_tqueue_entry_t, link);
97 list_remove(link);
98
99 tcp_segment_delete(tqe->seg);
100 free(tqe);
101 }
102}
103
104void tcp_tqueue_ctrl_seg(tcp_conn_t *conn, tcp_control_t ctrl)
105{
106 tcp_segment_t *seg;
107
108 assert(fibril_mutex_is_locked(&conn->lock));
109
110 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_tqueue_ctrl_seg(%p, %u)", conn, ctrl);
111
112 seg = tcp_segment_make_ctrl(ctrl);
113 tcp_tqueue_seg(conn, seg);
114 tcp_segment_delete(seg);
115}
116
117static void tcp_tqueue_seg(tcp_conn_t *conn, tcp_segment_t *seg)
118{
119 tcp_segment_t *rt_seg;
120 tcp_tqueue_entry_t *tqe;
121
122 assert(fibril_mutex_is_locked(&conn->lock));
123
124 log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_tqueue_seg(%p, %p)", conn->name, conn,
125 seg);
126
127 /*
128 * Add segment to retransmission queue
129 */
130
131 if (seg->len > 0) {
132 rt_seg = tcp_segment_dup(seg);
133 if (rt_seg == NULL) {
134 log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed.");
135 /* XXX Handle properly */
136 return;
137 }
138
139 tqe = calloc(1, sizeof(tcp_tqueue_entry_t));
140 if (tqe == NULL) {
141 log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed.");
142 /* XXX Handle properly */
143 return;
144 }
145
146 tqe->conn = conn;
147 tqe->seg = rt_seg;
148 rt_seg->seq = conn->snd_nxt;
149
150 list_append(&tqe->link, &conn->retransmit.list);
151
152 /* Set retransmission timer */
153 tcp_tqueue_timer_set(conn);
154 }
155
156 tcp_prepare_transmit_segment(conn, seg);
157}
158
159static void tcp_prepare_transmit_segment(tcp_conn_t *conn, tcp_segment_t *seg)
160{
161 /*
162 * Always send ACK once we have received SYN, except for RST segments.
163 * (Spec says we should always send ACK once connection has been
164 * established.)
165 */
166 if (tcp_conn_got_syn(conn) && (seg->ctrl & CTL_RST) == 0)
167 seg->ctrl |= CTL_ACK;
168
169 seg->seq = conn->snd_nxt;
170 conn->snd_nxt += seg->len;
171
172 tcp_conn_transmit_segment(conn, seg);
173}
174
175/** Transmit data from the send buffer.
176 *
177 * @param conn Connection
178 */
179void tcp_tqueue_new_data(tcp_conn_t *conn)
180{
181 size_t avail_wnd;
182 size_t xfer_seqlen;
183 size_t snd_buf_seqlen;
184 size_t data_size;
185 tcp_control_t ctrl;
186 bool send_fin;
187
188 tcp_segment_t *seg;
189
190 log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_tqueue_new_data()", conn->name);
191
192 /* Number of free sequence numbers in send window */
193 avail_wnd = (conn->snd_una + conn->snd_wnd) - conn->snd_nxt;
194 snd_buf_seqlen = conn->snd_buf_used + (conn->snd_buf_fin ? 1 : 0);
195
196 xfer_seqlen = min(snd_buf_seqlen, avail_wnd);
197 log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: snd_buf_seqlen = %zu, SND.WND = %" PRIu32 ", "
198 "xfer_seqlen = %zu", conn->name, snd_buf_seqlen, conn->snd_wnd,
199 xfer_seqlen);
200
201 if (xfer_seqlen == 0)
202 return;
203
204 /* XXX Do not always send immediately */
205
206 send_fin = conn->snd_buf_fin && xfer_seqlen == snd_buf_seqlen;
207 data_size = xfer_seqlen - (send_fin ? 1 : 0);
208
209 if (send_fin) {
210 log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: Sending out FIN.", conn->name);
211 /* We are sending out FIN */
212 ctrl = CTL_FIN;
213 } else {
214 ctrl = 0;
215 }
216
217 seg = tcp_segment_make_data(ctrl, conn->snd_buf, data_size);
218 if (seg == NULL) {
219 log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failure.");
220 return;
221 }
222
223 /* Remove data from send buffer */
224 memmove(conn->snd_buf, conn->snd_buf + data_size,
225 conn->snd_buf_used - data_size);
226 conn->snd_buf_used -= data_size;
227
228 if (send_fin)
229 conn->snd_buf_fin = false;
230
231 fibril_condvar_broadcast(&conn->snd_buf_cv);
232
233 if (send_fin)
234 tcp_conn_fin_sent(conn);
235
236 tcp_tqueue_seg(conn, seg);
237 tcp_segment_delete(seg);
238}
239
240/** Remove ACKed segments from retransmission queue and possibly transmit
241 * more data.
242 *
243 * This should be called when SND.UNA is updated due to incoming ACK.
244 */
245void tcp_tqueue_ack_received(tcp_conn_t *conn)
246{
247 link_t *cur, *next;
248
249 log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_tqueue_ack_received(%p)", conn->name,
250 conn);
251
252 cur = conn->retransmit.list.head.next;
253
254 while (cur != &conn->retransmit.list.head) {
255 next = cur->next;
256
257 tcp_tqueue_entry_t *tqe = list_get_instance(cur,
258 tcp_tqueue_entry_t, link);
259
260 if (seq_no_segment_acked(conn, tqe->seg, conn->snd_una)) {
261 /* Remove acknowledged segment */
262 list_remove(cur);
263
264 if ((tqe->seg->ctrl & CTL_FIN) != 0) {
265 log_msg(LOG_DEFAULT, LVL_DEBUG, "Fin has been acked");
266 log_msg(LOG_DEFAULT, LVL_DEBUG, "SND.UNA=%" PRIu32
267 " SEG.SEQ=%" PRIu32 " SEG.LEN=%" PRIu32,
268 conn->snd_una, tqe->seg->seq, tqe->seg->len);
269 /* Our FIN has been acked */
270 conn->fin_is_acked = true;
271 }
272
273 tcp_segment_delete(tqe->seg);
274 free(tqe);
275
276 /* Reset retransmission timer */
277 tcp_tqueue_timer_set(conn);
278 }
279
280 cur = next;
281 }
282
283 /* Clear retransmission timer if the queue is empty. */
284 if (list_empty(&conn->retransmit.list))
285 tcp_tqueue_timer_clear(conn);
286
287 /* Possibly transmit more data */
288 tcp_tqueue_new_data(conn);
289}
290
291static void tcp_conn_transmit_segment(tcp_conn_t *conn, tcp_segment_t *seg)
292{
293 log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_transmit_segment(%p, %p)",
294 conn->name, conn, seg);
295
296 seg->wnd = conn->rcv_wnd;
297
298 if ((seg->ctrl & CTL_ACK) != 0)
299 seg->ack = conn->rcv_nxt;
300 else
301 seg->ack = 0;
302
303 tcp_tqueue_send_immed(conn, seg);
304}
305
306void tcp_tqueue_send_immed(tcp_conn_t *conn, tcp_segment_t *seg)
307{
308 log_msg(LOG_DEFAULT, LVL_DEBUG,
309 "tcp_tqueue_send_immed(l:(%u),f:(%u), %p)",
310 conn->ident.local.port, conn->ident.remote.port, seg);
311
312 log_msg(LOG_DEFAULT, LVL_DEBUG, "SEG.SEQ=%" PRIu32 ", SEG.WND=%" PRIu32,
313 seg->seq, seg->wnd);
314
315 tcp_segment_dump(seg);
316
317 conn->retransmit.cb->transmit_seg(&conn->ident, seg);
318}
319
320static void retransmit_timeout_func(void *arg)
321{
322 tcp_conn_t *conn = (tcp_conn_t *) arg;
323 tcp_tqueue_entry_t *tqe;
324 tcp_segment_t *rt_seg;
325 link_t *link;
326
327 log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: retransmit_timeout_func(%p)", conn->name, conn);
328
329 tcp_conn_lock(conn);
330
331 if (conn->cstate == st_closed) {
332 log_msg(LOG_DEFAULT, LVL_DEBUG, "Connection already closed.");
333 tcp_conn_unlock(conn);
334 tcp_conn_delref(conn);
335 return;
336 }
337
338 link = list_first(&conn->retransmit.list);
339 if (link == NULL) {
340 log_msg(LOG_DEFAULT, LVL_DEBUG, "Nothing to retransmit");
341 tcp_conn_unlock(conn);
342 tcp_conn_delref(conn);
343 return;
344 }
345
346 tqe = list_get_instance(link, tcp_tqueue_entry_t, link);
347
348 rt_seg = tcp_segment_dup(tqe->seg);
349 if (rt_seg == NULL) {
350 log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed.");
351 tcp_conn_unlock(conn);
352 tcp_conn_delref(conn);
353 /* XXX Handle properly */
354 return;
355 }
356
357 log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: retransmitting segment", conn->name);
358 tcp_conn_transmit_segment(tqe->conn, rt_seg);
359
360 /* Reset retransmission timer */
361 fibril_timer_set_locked(conn->retransmit.timer, RETRANSMIT_TIMEOUT,
362 retransmit_timeout_func, (void *) conn);
363
364 tcp_conn_unlock(conn);
365
366 log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: retransmit_timeout_func(%p) end", conn->name, conn);
367}
368
369/** Set or re-set retransmission timer */
370static void tcp_tqueue_timer_set(tcp_conn_t *conn)
371{
372 assert(fibril_mutex_is_locked(&conn->lock));
373
374 log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_set() begin", conn->name);
375
376 /* Clear first to make sure we update refcnt correctly */
377 tcp_tqueue_timer_clear(conn);
378
379 tcp_conn_addref(conn);
380 fibril_timer_set_locked(conn->retransmit.timer, RETRANSMIT_TIMEOUT,
381 retransmit_timeout_func, (void *) conn);
382
383 log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_set() end", conn->name);
384}
385
386/** Clear retransmission timer */
387static void tcp_tqueue_timer_clear(tcp_conn_t *conn)
388{
389 assert(fibril_mutex_is_locked(&conn->lock));
390
391 log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_clear() begin", conn->name);
392
393 if (fibril_timer_clear_locked(conn->retransmit.timer) == fts_active)
394 tcp_conn_delref(conn);
395
396 log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_clear() end", conn->name);
397}
398
399/**
400 * @}
401 */
Note: See TracBrowser for help on using the repository browser.