Changeset eb083ad in mainline for uspace/srv/net/tcp/sock.c


Ignore:
Timestamp:
2012-05-17T21:09:06Z (12 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
8fde078
Parents:
a8b8086 (diff), 3e67ab1 (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 mainline changes

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/tcp/sock.c

    ra8b8086 reb083ad  
    4242#include <ipc/services.h>
    4343#include <ipc/socket.h>
    44 #include <net/modules.h>
    4544#include <net/socket.h>
    4645#include <ns.h>
    … …  
    5251#include "ucall.h"
    5352
    54 #define FRAGMENT_SIZE 1024
    55 
    5653#define MAX_BACKLOG 128
    5754
    … …  
    6764static void tcp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    6865static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg);
     66static int tcp_sock_recv_fibril(void *arg);
    6967
    7068int tcp_sock_init(void)
    … …  
    9896        async_exch_t *exch = async_exchange_begin(sock_core->sess);
    9997        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
    100             FRAGMENT_SIZE, 0, 0, 1);
     98            TCP_SOCK_FRAGMENT_SIZE, 0, 0, 1);
    10199        async_exchange_end(exch);
    102100}
    … …  
    107105        async_exch_t *exch = async_exchange_begin(lsock_core->sess);
    108106        async_msg_5(exch, NET_SOCKET_ACCEPTED, (sysarg_t)lsock_core->socket_id,
    109             FRAGMENT_SIZE, 0, 0, 0);
     107            TCP_SOCK_FRAGMENT_SIZE, 0, 0, 0);
    110108        async_exchange_end(exch);
    111109}
    112110
     111static int tcp_sock_create(tcp_client_t *client, tcp_sockdata_t **rsock)
     112{
     113        tcp_sockdata_t *sock;
     114
     115        log_msg(LVL_DEBUG, "tcp_sock_create()");
     116        *rsock = NULL;
     117
     118        sock = calloc(sizeof(tcp_sockdata_t), 1);
     119        if (sock == NULL)
     120                return ENOMEM;
     121
     122        fibril_mutex_initialize(&sock->lock);
     123        sock->client = client;
     124
     125        sock->recv_buffer_used = 0;
     126        sock->recv_error = TCP_EOK;
     127        fibril_mutex_initialize(&sock->recv_buffer_lock);
     128        fibril_condvar_initialize(&sock->recv_buffer_cv);
     129        list_initialize(&sock->ready);
     130
     131        *rsock = sock;
     132        return EOK;
     133}
     134
     135static void tcp_sock_uncreate(tcp_sockdata_t *sock)
     136{
     137        log_msg(LVL_DEBUG, "tcp_sock_uncreate()");
     138        free(sock);
     139}
     140
     141static int tcp_sock_finish_setup(tcp_sockdata_t *sock, int *sock_id)
     142{
     143        socket_core_t *sock_core;
     144        int rc;
     145
     146        log_msg(LVL_DEBUG, "tcp_sock_finish_setup()");
     147
     148        sock->recv_fibril = fibril_create(tcp_sock_recv_fibril, sock);
     149        if (sock->recv_fibril == 0)
     150                return ENOMEM;
     151
     152        rc = socket_create(&sock->client->sockets, sock->client->sess,
     153            sock, sock_id);
     154
     155        if (rc != EOK)
     156                return rc;
     157
     158        sock_core = socket_cores_find(&sock->client->sockets, *sock_id);
     159        assert(sock_core != NULL);
     160        sock->sock_core = sock_core;
     161
     162        return EOK;
     163}
     164
    113165static void tcp_sock_socket(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    114166{
    115167        tcp_sockdata_t *sock;
    116         socket_core_t *sock_core;
    117168        int sock_id;
    118169        int rc;
    … …  
    120171
    121172        log_msg(LVL_DEBUG, "tcp_sock_socket()");
    122         sock = calloc(sizeof(tcp_sockdata_t), 1);
    123         if (sock == NULL) {
    124                 async_answer_0(callid, ENOMEM);
    125                 return;
    126         }
    127 
    128         fibril_mutex_initialize(&sock->lock);
    129         sock->client = client;
     173
     174        rc = tcp_sock_create(client, &sock);
     175        if (rc != EOK) {
     176                async_answer_0(callid, rc);
     177                return;
     178        }
     179
    130180        sock->laddr.ipv4 = TCP_IPV4_ANY;
    131181        sock->lconn = NULL;
    132182        sock->backlog = 0;
    133         list_initialize(&sock->ready);
    134183
    135184        sock_id = SOCKET_GET_SOCKET_ID(call);
    136         rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
     185        rc = tcp_sock_finish_setup(sock, &sock_id);
    137186        if (rc != EOK) {
     187                tcp_sock_uncreate(sock);
    138188                async_answer_0(callid, rc);
    139189                return;
    140190        }
    141191
    142         sock_core = socket_cores_find(&client->sockets, sock_id);
    143         assert(sock_core != NULL);
    144         sock->sock_core = sock_core;
    145 
    146         refresh_answer(&answer, NULL);
    147192        SOCKET_SET_SOCKET_ID(answer, sock_id);
    148193
    149         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
     194        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
    150195        SOCKET_SET_HEADER_SIZE(answer, sizeof(tcp_header_t));
    151         answer_call(callid, EOK, &answer, 3);
     196       
     197        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
     198            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    152199}
    153200
    … …  
    361408        }
    362409
     410        if (rc == EOK)
     411                fibril_add_ready(socket->recv_fibril);
     412
    363413        async_answer_0(callid, rc);
    364 
    365         /* Push one fragment notification to client's queue */
    366         tcp_sock_notify_data(sock_core);
    367         log_msg(LVL_DEBUG, "tcp_sock_connect(): notify conn\n");
    368414}
    369415
    … …  
    374420        int asock_id;
    375421        socket_core_t *sock_core;
    376         socket_core_t *asock_core;
    377422        tcp_sockdata_t *socket;
    378423        tcp_sockdata_t *asocket;
    … …  
    444489        /* Allocate socket for accepted connection */
    445490
    446         log_msg(LVL_DEBUG, "tcp_sock_accept(): allocate asocket\n");
    447         asocket = calloc(sizeof(tcp_sockdata_t), 1);
    448         if (asocket == NULL) {
    449                 fibril_mutex_unlock(&socket->lock);
    450                 async_answer_0(callid, ENOMEM);
    451                 return;
    452         }
    453 
    454         fibril_mutex_initialize(&asocket->lock);
    455         asocket->client = client;
     491        rc = tcp_sock_create(client, &asocket);
     492        if (rc != EOK) {
     493                fibril_mutex_unlock(&socket->lock);
     494                async_answer_0(callid, rc);
     495                return;
     496        }
     497
    456498        asocket->conn = conn;
    457499        log_msg(LVL_DEBUG, "tcp_sock_accept():create asocket\n");
    458500
    459         rc = socket_create(&client->sockets, client->sess, asocket, &asock_id);
     501        rc = tcp_sock_finish_setup(asocket, &asock_id);
    460502        if (rc != EOK) {
     503                tcp_sock_uncreate(asocket);
    461504                fibril_mutex_unlock(&socket->lock);
    462505                async_answer_0(callid, rc);
    463506                return;
    464507        }
     508
     509        fibril_add_ready(asocket->recv_fibril);
     510
    465511        log_msg(LVL_DEBUG, "tcp_sock_accept(): find acore\n");
    466512
    467         asock_core = socket_cores_find(&client->sockets, asock_id);
    468         assert(asock_core != NULL);
    469 
    470         refresh_answer(&answer, NULL);
    471 
    472         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
     513        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
    473514        SOCKET_SET_SOCKET_ID(answer, asock_id);
    474515        SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(struct sockaddr_in));
    475 
    476         answer_call(callid, asock_core->socket_id, &answer, 3);
    477 
     516       
     517        async_answer_3(callid, asocket->sock_core->socket_id,
     518            IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
     519            IPC_GET_ARG3(answer));
     520       
    478521        /* Push one fragment notification to client's queue */
    479522        log_msg(LVL_DEBUG, "tcp_sock_accept(): notify data\n");
    480         tcp_sock_notify_data(asock_core);
    481523        fibril_mutex_unlock(&socket->lock);
    482524}
    … …  
    492534        ipc_callid_t wcallid;
    493535        size_t length;
    494         uint8_t buffer[FRAGMENT_SIZE];
     536        uint8_t buffer[TCP_SOCK_FRAGMENT_SIZE];
    495537        tcp_error_t trc;
    496538        int rc;
    … …  
    523565                }
    524566
    525                 if (length > FRAGMENT_SIZE)
    526                         length = FRAGMENT_SIZE;
     567                if (length > TCP_SOCK_FRAGMENT_SIZE)
     568                        length = TCP_SOCK_FRAGMENT_SIZE;
    527569
    528570                rc = async_data_write_finalize(wcallid, buffer, length);
    … …  
    559601        }
    560602
    561         refresh_answer(&answer, NULL);
    562         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    563         answer_call(callid, EOK, &answer, 2);
     603        IPC_SET_ARG1(answer, 0);
     604        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
     605        async_answer_2(callid, EOK, IPC_GET_ARG1(answer),
     606            IPC_GET_ARG2(answer));
    564607        fibril_mutex_unlock(&socket->lock);
    565608}
    … …  
    580623        ipc_call_t answer;
    581624        ipc_callid_t rcallid;
    582         uint8_t buffer[FRAGMENT_SIZE];
    583625        size_t data_len;
    584         xflags_t xflags;
    585         tcp_error_t trc;
    586626        struct sockaddr_in addr;
    587627        tcp_sock_t *rsock;
    … …  
    610650        (void)flags;
    611651
    612         trc = tcp_uc_receive(socket->conn, buffer, FRAGMENT_SIZE, &data_len,
    613             &xflags);
    614         log_msg(LVL_DEBUG, "**** tcp_uc_receive done");
    615 
    616         switch (trc) {
     652        log_msg(LVL_DEBUG, "tcp_sock_recvfrom(): lock recv_buffer_lock");
     653        fibril_mutex_lock(&socket->recv_buffer_lock);
     654        while (socket->recv_buffer_used == 0 && socket->recv_error == TCP_EOK) {
     655                log_msg(LVL_DEBUG, "wait for recv_buffer_cv + recv_buffer_used != 0");
     656                fibril_condvar_wait(&socket->recv_buffer_cv,
     657                    &socket->recv_buffer_lock);
     658        }
     659
     660        log_msg(LVL_DEBUG, "Got data in sock recv_buffer");
     661
     662        data_len = socket->recv_buffer_used;
     663        rc = socket->recv_error;
     664
     665        switch (socket->recv_error) {
    617666        case TCP_EOK:
    618667                rc = EOK;
    … …  
    629678        }
    630679
    631         log_msg(LVL_DEBUG, "**** tcp_uc_receive -> %d", rc);
     680        log_msg(LVL_DEBUG, "**** recv result -> %d", rc);
    632681        if (rc != EOK) {
     682                fibril_mutex_unlock(&socket->recv_buffer_lock);
    633683                fibril_mutex_unlock(&socket->lock);
    634684                async_answer_0(callid, rc);
    … …  
    645695                log_msg(LVL_DEBUG, "addr read receive");
    646696                if (!async_data_read_receive(&rcallid, &addr_length)) {
     697                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    647698                        fibril_mutex_unlock(&socket->lock);
    648699                        async_answer_0(callid, EINVAL);
    … …  
    656707                rc = async_data_read_finalize(rcallid, &addr, addr_length);
    657708                if (rc != EOK) {
     709                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    658710                        fibril_mutex_unlock(&socket->lock);
    659711                        async_answer_0(callid, EINVAL);
    … …  
    664716        log_msg(LVL_DEBUG, "data read receive");
    665717        if (!async_data_read_receive(&rcallid, &length)) {
     718                fibril_mutex_unlock(&socket->recv_buffer_lock);
    666719                fibril_mutex_unlock(&socket->lock);
    667720                async_answer_0(callid, EINVAL);
    … …  
    673726
    674727        log_msg(LVL_DEBUG, "data read finalize");
    675         rc = async_data_read_finalize(rcallid, buffer, length);
     728        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
     729
     730        socket->recv_buffer_used -= length;
     731        log_msg(LVL_DEBUG, "tcp_sock_recvfrom: %zu left in buffer",
     732            socket->recv_buffer_used);
     733        if (socket->recv_buffer_used > 0) {
     734                memmove(socket->recv_buffer, socket->recv_buffer + length,
     735                    socket->recv_buffer_used);
     736                tcp_sock_notify_data(socket->sock_core);
     737        }
     738
     739        fibril_condvar_broadcast(&socket->recv_buffer_cv);
    676740
    677741        if (length < data_len && rc == EOK)
    … …  
    679743
    680744        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    681         answer_call(callid, EOK, &answer, 1);
    682 
    683         /* Push one fragment notification to client's queue */
    684         tcp_sock_notify_data(sock_core);
     745        async_answer_1(callid, EOK, IPC_GET_ARG1(answer));
     746
     747        fibril_mutex_unlock(&socket->recv_buffer_lock);
    685748        fibril_mutex_unlock(&socket->lock);
    686749}
    … …  
    693756        tcp_error_t trc;
    694757        int rc;
    695         uint8_t buffer[FRAGMENT_SIZE];
    696         size_t data_len;
    697         xflags_t xflags;
    698758
    699759        log_msg(LVL_DEBUG, "tcp_sock_close()");
    … …  
    716776                        return;
    717777                }
    718 
    719                 /* Drain incoming data. This should really be done in the background. */
    720                 do {
    721                         trc = tcp_uc_receive(socket->conn, buffer,
    722                             FRAGMENT_SIZE, &data_len, &xflags);
    723                 } while (trc == TCP_EOK);
    724 
    725                 tcp_uc_delete(socket->conn);
    726778        }
    727779
    … …  
    775827        tcp_sock_notify_aconn(socket->sock_core);
    776828        fibril_mutex_unlock(&socket->lock);
     829}
     830
     831static int tcp_sock_recv_fibril(void *arg)
     832{
     833        tcp_sockdata_t *sock = (tcp_sockdata_t *)arg;
     834        size_t data_len;
     835        xflags_t xflags;
     836        tcp_error_t trc;
     837
     838        log_msg(LVL_DEBUG, "tcp_sock_recv_fibril()");
     839
     840        while (true) {
     841                log_msg(LVL_DEBUG, "call tcp_uc_receive()");
     842                fibril_mutex_lock(&sock->recv_buffer_lock);
     843                while (sock->recv_buffer_used != 0)
     844                        fibril_condvar_wait(&sock->recv_buffer_cv,
     845                            &sock->recv_buffer_lock);
     846
     847                trc = tcp_uc_receive(sock->conn, sock->recv_buffer,
     848                    TCP_SOCK_FRAGMENT_SIZE, &data_len, &xflags);
     849
     850                if (trc != TCP_EOK) {
     851                        sock->recv_error = trc;
     852                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
     853                        fibril_mutex_unlock(&sock->recv_buffer_lock);
     854                        tcp_sock_notify_data(sock->sock_core);
     855                        break;
     856                }
     857
     858                log_msg(LVL_DEBUG, "got data - broadcast recv_buffer_cv");
     859
     860                sock->recv_buffer_used = data_len;
     861                fibril_condvar_broadcast(&sock->recv_buffer_cv);
     862                fibril_mutex_unlock(&sock->recv_buffer_lock);
     863                tcp_sock_notify_data(sock->sock_core);
     864        }
     865
     866        tcp_uc_delete(sock->conn);
     867
     868        return 0;
    777869}
    778870
Note: See TracChangeset for help on using the changeset viewer.