Changeset a438de4 in mainline for uspace/srv/net/tl/tcp/conn.c

Timestamp:

2011-12-19T18:50:17Z (12 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

1440eae, d9cf684a

Parents:

58f6229 (diff), 522a4f9 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge TCP improvements.

File:

• uspace/srv/net/tl/tcp/conn.c (modified) (18 diffs)

uspace/srv/net/tl/tcp/conn.c

@@ -56 +56 @@
 
 LIST_INITIALIZE(conn_list);
+FIBRIL_MUTEX_INITIALIZE(conn_list_lock);
 
 static void tcp_conn_seg_process(tcp_conn_t *conn, tcp_segment_t *seg);
@@ -61 +62 @@
 static void tcp_conn_tw_timer_clear(tcp_conn_t *conn);
 
-/** Create new segment structure.
+/** Create new connection structure.
  *
  * @param lsock         Local socket (will be deeply copied)
  * @param fsock         Foreign socket (will be deeply copied)
- * @return              New segment or NULL
+ * @return              New connection or NULL
  */
 tcp_conn_t *tcp_conn_new(tcp_sock_t *lsock, tcp_sock_t *fsock)
@@ -81 +82 @@
                 goto error;
 
+        fibril_mutex_initialize(&conn->lock);
+
+        /* One for the user, one for not being in closed state */
+        atomic_set(&conn->refcnt, 2);
+
         /* Allocate receive buffer */
-        fibril_mutex_initialize(&conn->rcv_buf_lock);
         fibril_condvar_initialize(&conn->rcv_buf_cv);
         conn->rcv_buf_size = RCV_BUF_SIZE;
@@ -93 +98 @@
 
         /** Allocate send buffer */
+        fibril_condvar_initialize(&conn->snd_buf_cv);
         conn->snd_buf_size = SND_BUF_SIZE;
         conn->snd_buf_used = 0;
@@ -113 +119 @@
 
         /* Connection state change signalling */
-        fibril_mutex_initialize(&conn->cstate_lock);
         fibril_condvar_initialize(&conn->cstate_cv);
 
         conn->cstate = st_listen;
         conn->reset = false;
+        conn->deleted = false;
         conn->ap = ap_passive;
         conn->fin_is_acked = false;
@@ -141 +147 @@
 }
 
+/** Destroy connection structure.
+ *
+ * Connection structure should be destroyed when the folowing condtitions
+ * are met:
+ * (1) user has deleted the connection
+ * (2) the connection has entered closed state
+ * (3) nobody is holding references to the connection
+ *
+ * This happens when @a conn->refcnt is zero as we count (1) and (2)
+ * as special references.
+ *
+ * @param conn          Connection
+ */
+static void tcp_conn_free(tcp_conn_t *conn)
+{
+        log_msg(LVL_DEBUG, "%s: tcp_conn_free(%p)", conn->name, conn);
+        tcp_tqueue_fini(&conn->retransmit);
+
+        if (conn->rcv_buf != NULL)
+                free(conn->rcv_buf);
+        if (conn->snd_buf != NULL)
+                free(conn->snd_buf);
+        if (conn->tw_timer != NULL)
+                fibril_timer_destroy(conn->tw_timer);
+        free(conn);
+}
+
+/** Add reference to connection.
+ *
+ * Increase connection reference count by one.
+ *
+ * @param conn          Connection
+ */
+void tcp_conn_addref(tcp_conn_t *conn)
+{
+        log_msg(LVL_DEBUG, "%s: tcp_conn_addref(%p)", conn->name, conn);
+        atomic_inc(&conn->refcnt);
+}
+
+/** Remove reference from connection.
+ *
+ * Decrease connection reference count by one.
+ *
+ * @param conn          Connection
+ */
+void tcp_conn_delref(tcp_conn_t *conn)
+{
+        log_msg(LVL_DEBUG, "%s: tcp_conn_delref(%p)", conn->name, conn);
+
+        if (atomic_predec(&conn->refcnt) == 0)
+                tcp_conn_free(conn);
+}
+
+/** Delete connection.
+ *
+ * The caller promises not make no further references to @a conn.
+ * TCP will free @a conn eventually.
+ *
+ * @param conn          Connection
+ */
+void tcp_conn_delete(tcp_conn_t *conn)
+{
+        log_msg(LVL_DEBUG, "%s: tcp_conn_delete(%p)", conn->name, conn);
+
+        assert(conn->deleted == false);
+        tcp_conn_delref(conn);
+}
+
 /** Enlist connection.
  *
@@ -147 +221 @@
 void tcp_conn_add(tcp_conn_t *conn)
 {
+        tcp_conn_addref(conn);
+        fibril_mutex_lock(&conn_list_lock);
         list_append(&conn->link, &conn_list);
+        fibril_mutex_unlock(&conn_list_lock);
 }
 
@@ -156 +233 @@
 void tcp_conn_remove(tcp_conn_t *conn)
 {
+        fibril_mutex_lock(&conn_list_lock);
         list_remove(&conn->link);
+        fibril_mutex_unlock(&conn_list_lock);
+        tcp_conn_delref(conn);
 }
 
 static void tcp_conn_state_set(tcp_conn_t *conn, tcp_cstate_t nstate)
 {
-        fibril_mutex_lock(&conn->cstate_lock);
+        tcp_cstate_t old_state;
+
+        old_state = conn->cstate;
         conn->cstate = nstate;
         fibril_condvar_broadcast(&conn->cstate_cv);
-        fibril_mutex_unlock(&conn->cstate_lock);
+
+        assert(old_state != st_closed);
+        if (nstate == st_closed) {
+                /* Drop one reference for now being in closed state */
+                tcp_conn_delref(conn);
+        }
 }
 
@@ -251 +338 @@
  * A connection is uniquely identified by a socket pair. Look up our
  * connection map and return connection structure based on socket pair.
+ * The connection reference count is bumped by one.
  *
  * @param sp    Socket pair
  * @return      Connection structure or NULL if not found.
  */
-tcp_conn_t *tcp_conn_find(tcp_sockpair_t *sp)
+tcp_conn_t *tcp_conn_find_ref(tcp_sockpair_t *sp)
 {
         log_msg(LVL_DEBUG, "tcp_conn_find(%p)", sp);
+
+        fibril_mutex_lock(&conn_list_lock);
 
         list_foreach(conn_list, link) {
@@ -266 +356 @@
                     csp->local.addr.ipv4, csp->local.port);
                 if (tcp_sockpair_match(sp, csp)) {
+                        tcp_conn_addref(conn);
+                        fibril_mutex_unlock(&conn_list_lock);
                         return conn;
                 }
         }
 
+        fibril_mutex_unlock(&conn_list_lock);
         return NULL;
 }
@@ -287 +380 @@
 
         fibril_condvar_broadcast(&conn->rcv_buf_cv);
+        fibril_condvar_broadcast(&conn->snd_buf_cv);
 }
 
@@ -858 +952 @@
         tcp_conn_trim_seg_to_wnd(conn, seg);
 
-        fibril_mutex_lock(&conn->rcv_buf_lock);
-
         /* Determine how many bytes to copy */
         text_size = tcp_segment_text_size(seg);
@@ -871 +963 @@
         /* Signal to the receive function that new data has arrived */
         fibril_condvar_broadcast(&conn->rcv_buf_cv);
-        fibril_mutex_unlock(&conn->rcv_buf_lock);
 
         log_msg(LVL_DEBUG, "Received %zu bytes of data.", xfer_size);
@@ -961 +1052 @@
 
                 /* Add FIN to the receive buffer */
-                fibril_mutex_lock(&conn->rcv_buf_lock);
                 conn->rcv_buf_fin = true;
                 fibril_condvar_broadcast(&conn->rcv_buf_cv);
-                fibril_mutex_unlock(&conn->rcv_buf_lock);
 
                 tcp_segment_delete(seg);
@@ -1073 +1162 @@
         log_msg(LVL_DEBUG, "tw_timeout_func(%p)", conn);
 
+        fibril_mutex_lock(&conn->lock);
+
         if (conn->cstate == st_closed) {
                 log_msg(LVL_DEBUG, "Connection already closed.");
+                fibril_mutex_unlock(&conn->lock);
+                tcp_conn_delref(conn);
                 return;
         }
@@ -1081 +1174 @@
         tcp_conn_remove(conn);
         tcp_conn_state_set(conn, st_closed);
+
+        fibril_mutex_unlock(&conn->lock);
+        tcp_conn_delref(conn);
 }
 
@@ -1089 +1185 @@
 void tcp_conn_tw_timer_set(tcp_conn_t *conn)
 {
+        tcp_conn_addref(conn);
         fibril_timer_set(conn->tw_timer, TIME_WAIT_TIMEOUT, tw_timeout_func,
             (void *)conn);
@@ -1099 +1196 @@
 void tcp_conn_tw_timer_clear(tcp_conn_t *conn)
 {
-        fibril_timer_clear(conn->tw_timer);
+        if (fibril_timer_clear(conn->tw_timer) == fts_active)
+                tcp_conn_delref(conn);
 }