Changeset 90478727 in mainline for uspace/srv


Ignore:
Timestamp:
2012-08-12T11:46:44Z (13 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
41b764b7
Parents:
e1e4192 (diff), 371cb6c (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

Location:
uspace/srv
Files:
4 added
1 deleted
19 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/bd/ata_bd/ata_bd.c

    re1e4192 r90478727  
    308308
    309309        (void) async_share_out_finalize(callid, &fs_va);
    310         if (fs_va == (void *) -1) {
     310        if (fs_va == AS_MAP_FAILED) {
    311311                async_answer_0(callid, EHANGUP);
    312312                return;

  • uspace/srv/bd/file_bd/file_bd.c

    re1e4192 r90478727  
    189189
    190190        (void) async_share_out_finalize(callid, &fs_va);
    191         if (fs_va == (void *) -1) {
     191        if (fs_va == AS_MAP_FAILED) {
    192192                async_answer_0(callid, EHANGUP);
    193193                return;

  • uspace/srv/bd/gxe_bd/gxe_bd.c

    re1e4192 r90478727  
    196196
    197197        (void) async_share_out_finalize(callid, &fs_va);
    198         if (fs_va == (void *) -1) {
     198        if (fs_va == AS_MAP_FAILED) {
    199199                async_answer_0(callid, EHANGUP);
    200200                return;

  • uspace/srv/bd/part/guid_part/guid_part.c

    re1e4192 r90478727  
    350350
    351351        (void) async_share_out_finalize(callid, &fs_va);
    352         if (fs_va == (void *) -1) {
     352        if (fs_va == AS_MAP_FAILED) {
    353353                async_answer_0(callid, EHANGUP);
    354354                return;

  • uspace/srv/bd/part/mbr_part/mbr_part.c

    re1e4192 r90478727  
    427427
    428428        (void) async_share_out_finalize(callid, &fs_va);
    429         if (fs_va == (void *) -1) {
     429        if (fs_va == AS_MAP_FAILED) {
    430430                async_answer_0(callid, EHANGUP);
    431431                return;

  • uspace/srv/bd/rd/rd.c

    re1e4192 r90478727  
    106106        if (async_share_out_receive(&callid, &comm_size, &flags)) {
    107107                (void) async_share_out_finalize(callid, &fs_va);
    108                 if (fs_va == (void *) -1) {
     108                if (fs_va == AS_MAP_FAILED) {
    109109                        async_answer_0(callid, EHANGUP);
    110110                        return;

  • uspace/srv/devman/main.c

    re1e4192 r90478727  
    419419       
    420420        /* Check that function with same name is not there already. */
    421         if (find_fun_node_in_device(tree, pdev, fun_name) != NULL) {
     421        fun_node_t *tfun = find_fun_node_in_device(tree, pdev, fun_name);
     422        if (tfun) {
     423                fun_del_ref(tfun);      /* drop the new unwanted reference */
    422424                fibril_rwlock_write_unlock(&tree->rwlock);
    423425                dev_del_ref(pdev);
    … …  
    855857}
    856858
     859/** Get function driver name. */
     860static void devman_fun_get_driver_name(ipc_callid_t iid, ipc_call_t *icall)
     861{
     862        devman_handle_t handle = IPC_GET_ARG1(*icall);
     863
     864        fun_node_t *fun = find_fun_node(&device_tree, handle);
     865        if (fun == NULL) {
     866                async_answer_0(iid, ENOMEM);
     867                return;
     868        }
     869
     870        ipc_callid_t data_callid;
     871        size_t data_len;
     872        if (!async_data_read_receive(&data_callid, &data_len)) {
     873                async_answer_0(iid, EINVAL);
     874                fun_del_ref(fun);
     875                return;
     876        }
     877
     878        void *buffer = malloc(data_len);
     879        if (buffer == NULL) {
     880                async_answer_0(data_callid, ENOMEM);
     881                async_answer_0(iid, ENOMEM);
     882                fun_del_ref(fun);
     883                return;
     884        }
     885
     886        fibril_rwlock_read_lock(&device_tree.rwlock);
     887
     888        /* Check function state */
     889        if (fun->state == FUN_REMOVED) {
     890                fibril_rwlock_read_unlock(&device_tree.rwlock);
     891                free(buffer);
     892
     893                async_answer_0(data_callid, ENOENT);
     894                async_answer_0(iid, ENOENT);
     895                fun_del_ref(fun);
     896                return;
     897        }
     898
     899        /* Check whether function has a driver */
     900        if (fun->child == NULL || fun->child->drv == NULL) {
     901                fibril_rwlock_read_unlock(&device_tree.rwlock);
     902                free(buffer);
     903
     904                async_answer_0(data_callid, EINVAL);
     905                async_answer_0(iid, EINVAL);
     906                fun_del_ref(fun);
     907                return;
     908        }
     909
     910        size_t sent_length = str_size(fun->child->drv->name);
     911        if (sent_length > data_len) {
     912                sent_length = data_len;
     913        }
     914
     915        async_data_read_finalize(data_callid, fun->child->drv->name,
     916            sent_length);
     917        async_answer_0(iid, EOK);
     918
     919        fibril_rwlock_read_unlock(&device_tree.rwlock);
     920        fun_del_ref(fun);
     921        free(buffer);
     922}
    857923
    858924/** Get device path. */
    … …  
    10821148                case DEVMAN_FUN_GET_NAME:
    10831149                        devman_fun_get_name(callid, &call);
     1150                        break;
     1151                case DEVMAN_FUN_GET_DRIVER_NAME:
     1152                        devman_fun_get_driver_name(callid, &call);
    10841153                        break;
    10851154                case DEVMAN_FUN_GET_PATH:

  • uspace/srv/hid/console/console.c

    re1e4192 r90478727  
    7676} console_state_t;
    7777
     78#define UTF8_CHAR_BUFFER_SIZE (STR_BOUNDS(1) + 1)
     79
    7880typedef struct {
    7981        atomic_t refcnt;           /**< Connection reference count */
    8082        prodcons_t input_pc;       /**< Incoming keyboard events */
     83        char char_remains[UTF8_CHAR_BUFFER_SIZE]; /**< Not yet sent bytes of last char event. */
     84        size_t char_remains_len;   /**< Number of not yet sent bytes. */
    8185       
    8286        fibril_mutex_t mtx;        /**< Lock protecting mutable fields */
    … …  
    613617       
    614618        size_t pos = 0;
     619       
     620        /*
     621         * Read input from keyboard and copy it to the buffer.
     622         * We need to handle situation when wchar is split by 2 following
     623         * reads.
     624         */
    615625        while (pos < size) {
    616                 link_t *link = prodcons_consume(&cons->input_pc);
    617                 kbd_event_t *event = list_get_instance(link, kbd_event_t, link);
    618                
    619                 if (event->type == KEY_PRESS) {
    620                         buf[pos] = event->c;
     626                /* Copy to the buffer remaining characters. */
     627                while ((pos < size) && (cons->char_remains_len > 0)) {
     628                        buf[pos] = cons->char_remains[0];
    621629                        pos++;
    622                 }
    623                
    624                 free(event);
     630                       
     631                        /* Unshift the array. */
     632                        for (size_t i = 1; i < cons->char_remains_len; i++)
     633                                cons->char_remains[i - 1] = cons->char_remains[i];
     634                       
     635                        cons->char_remains_len--;
     636                }
     637               
     638                /* Still not enough? Then get another key from the queue. */
     639                if (pos < size) {
     640                        link_t *link = prodcons_consume(&cons->input_pc);
     641                        kbd_event_t *event = list_get_instance(link, kbd_event_t, link);
     642                       
     643                        /* Accept key presses of printable chars only. */
     644                        if ((event->type == KEY_PRESS) && (event->c != 0)) {
     645                                wchar_t tmp[2] = { event->c, 0 };
     646                                wstr_to_str(cons->char_remains, UTF8_CHAR_BUFFER_SIZE, tmp);
     647                                cons->char_remains_len = str_size(cons->char_remains);
     648                        }
     649                       
     650                        free(event);
     651                }
    625652        }
    626653       
    … …  
    930957                fibril_mutex_initialize(&consoles[i].mtx);
    931958                prodcons_initialize(&consoles[i].input_pc);
     959                consoles[i].char_remains_len = 0;
    932960               
    933961                if (graphics_state == GRAPHICS_FULL) {

  • uspace/srv/hid/fb/fb.c

    re1e4192 r90478727  
    305305       
    306306        int rc = async_share_out_finalize(callid, &frontbuf->data);
    307         if ((rc != EOK) || (frontbuf->data == (void *) -1)) {
     307        if ((rc != EOK) || (frontbuf->data == AS_MAP_FAILED)) {
    308308                free(frontbuf);
    309309                async_answer_0(iid, ENOMEM);
    … …  
    348348       
    349349        int rc = async_share_out_finalize(callid, &imagemap->data);
    350         if ((rc != EOK) || (imagemap->data == (void *) -1)) {
     350        if ((rc != EOK) || (imagemap->data == AS_MAP_FAILED)) {
    351351                free(imagemap);
    352352                async_answer_0(iid, ENOMEM);

  • uspace/srv/hid/input/port/ns16550.c

    re1e4192 r90478727  
    8484        },
    8585        {
    86                 .cmd = CMD_BTEST,
     86                .cmd = CMD_AND,
    8787                .value = LSR_DATA_READY,
    8888                .srcarg = 1,

  • uspace/srv/hid/input/port/pl050.c

    re1e4192 r90478727  
    8080        },
    8181        {
    82                 .cmd = CMD_BTEST,
     82                .cmd = CMD_AND,
    8383                .value = PL050_STAT_RXFULL,
    8484                .srcarg = 1,

  • uspace/srv/hw/bus/cuda_adb/cuda_adb.c

    re1e4192 r90478727  
    116116        {
    117117                .cmd = CMD_PIO_READ_8,
    118                 .addr = NULL,   /* will be patched in run-time */
     118                .addr = NULL,
    119119                .dstarg = 1
    120120        },
    121121        {
    122                 .cmd = CMD_BTEST,
     122                .cmd = CMD_AND,
    123123                .value = SR_INT,
    124124                .srcarg = 1,

  • uspace/srv/loader/Makefile

    re1e4192 r90478727  
    4444GENERIC_SOURCES = \
    4545        main.c \
    46         interp.s
     46        interp.S
    4747
    4848SOURCES = \

  • uspace/srv/locsrv/locsrv.c

    re1e4192 r90478727  
    656656}
    657657
     658static void loc_service_get_server_name(ipc_callid_t iid, ipc_call_t *icall)
     659{
     660        ipc_callid_t callid;
     661        size_t size;
     662        size_t act_size;
     663        loc_service_t *svc;
     664       
     665        if (!async_data_read_receive(&callid, &size)) {
     666                async_answer_0(callid, EREFUSED);
     667                async_answer_0(iid, EREFUSED);
     668                return;
     669        }
     670       
     671        fibril_mutex_lock(&services_list_mutex);
     672       
     673        svc = loc_service_find_id(IPC_GET_ARG1(*icall));
     674        if (svc == NULL) {
     675                fibril_mutex_unlock(&services_list_mutex);
     676                async_answer_0(callid, ENOENT);
     677                async_answer_0(iid, ENOENT);
     678                return;
     679        }
     680       
     681        if (svc->server == NULL) {
     682                fibril_mutex_unlock(&services_list_mutex);
     683                async_answer_0(callid, EINVAL);
     684                async_answer_0(iid, EINVAL);
     685                return;
     686        }
     687       
     688        act_size = str_size(svc->server->name);
     689        if (act_size > size) {
     690                fibril_mutex_unlock(&services_list_mutex);
     691                async_answer_0(callid, EOVERFLOW);
     692                async_answer_0(iid, EOVERFLOW);
     693                return;
     694        }
     695       
     696        sysarg_t retval = async_data_read_finalize(callid, svc->server->name,
     697            min(size, act_size));
     698       
     699        fibril_mutex_unlock(&services_list_mutex);
     700       
     701        async_answer_0(iid, retval);
     702}
     703
    658704/** Connect client to the service.
    659705 *
    … …  
    14071453                case LOC_SERVICE_GET_NAME:
    14081454                        loc_service_get_name(callid, &call);
     1455                        break;
     1456                case LOC_SERVICE_GET_SERVER_NAME:
     1457                        loc_service_get_server_name(callid, &call);
    14091458                        break;
    14101459                case LOC_NAMESPACE_GET_ID:

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

    re1e4192 r90478727  
    151151            sock, sock_id);
    152152
    153         if (rc != EOK)
     153        if (rc != EOK) {
     154                fibril_destroy(sock->recv_fibril);
     155                sock->recv_fibril = 0;
    154156                return rc;
     157        }
    155158
    156159        sock_core = socket_cores_find(&sock->client->sockets, *sock_id);
    … …  
    776779        }
    777780
     781        /* Grab recv_buffer_lock because of CV wait in tcp_sock_recv_fibril() */
     782        fibril_mutex_lock(&socket->recv_buffer_lock);
     783        socket->sock_core = NULL;
     784        fibril_mutex_unlock(&socket->recv_buffer_lock);
     785
    778786        rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
    779787            tcp_free_sock_data);
    … …  
    836844        log_msg(LVL_DEBUG, "tcp_sock_recv_fibril()");
    837845
     846        fibril_mutex_lock(&sock->recv_buffer_lock);
     847
    838848        while (true) {
    839849                log_msg(LVL_DEBUG, "call tcp_uc_receive()");
    840                 fibril_mutex_lock(&sock->recv_buffer_lock);
    841                 while (sock->recv_buffer_used != 0)
     850                while (sock->recv_buffer_used != 0 && sock->sock_core != NULL)
    842851                        fibril_condvar_wait(&sock->recv_buffer_cv,
    843852                            &sock->recv_buffer_lock);
    … …  
    849858                        sock->recv_error = trc;
    850859                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
    851                         fibril_mutex_unlock(&sock->recv_buffer_lock);
    852                         tcp_sock_notify_data(sock->sock_core);
     860                        if (sock->sock_core != NULL)
     861                                tcp_sock_notify_data(sock->sock_core);
    853862                        break;
    854863                }
    … …  
    858867                sock->recv_buffer_used = data_len;
    859868                fibril_condvar_broadcast(&sock->recv_buffer_cv);
    860                 fibril_mutex_unlock(&sock->recv_buffer_lock);
    861                 tcp_sock_notify_data(sock->sock_core);
    862         }
     869                if (sock->sock_core != NULL)
     870                        tcp_sock_notify_data(sock->sock_core);
     871        }
     872
     873        fibril_mutex_unlock(&sock->recv_buffer_lock);
    863874
    864875        tcp_uc_delete(sock->conn);

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

    re1e4192 r90478727  
    5151#include "ucall.h"
    5252
    53 #define FRAGMENT_SIZE 1024
    54 
    5553/** Free ports pool start. */
    5654#define UDP_FREE_PORTS_START            1025
    … …  
    6361
    6462static void udp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
     63static int udp_sock_recv_fibril(void *arg);
    6564
    6665int udp_sock_init(void)
    … …  
    8281
    8382        socket = (udp_sockdata_t *)sock_core->specific_data;
    84         assert(socket->assoc != NULL);
    85         udp_uc_destroy(socket->assoc);
     83        (void)socket;
     84
     85        /* XXX We need to force the receive fibril to quit */
    8686}
    8787
    … …  
    9191        async_exch_t *exch = async_exchange_begin(sock_core->sess);
    9292        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
    93             FRAGMENT_SIZE, 0, 0, 1);
     93            UDP_FRAGMENT_SIZE, 0, 0, 1);
    9494        async_exchange_end(exch);
    9595}
    … …  
    113113        sock->client = client;
    114114
     115        sock->recv_buffer_used = 0;
     116        sock->recv_error = UDP_EOK;
     117        fibril_mutex_initialize(&sock->recv_buffer_lock);
     118        fibril_condvar_initialize(&sock->recv_buffer_cv);
     119
    115120        rc = udp_uc_create(&sock->assoc);
    116121        if (rc != EOK) {
     122                free(sock);
     123                async_answer_0(callid, rc);
     124                return;
     125        }
     126
     127        sock->recv_fibril = fibril_create(udp_sock_recv_fibril, sock);
     128        if (sock->recv_fibril == 0) {
     129                udp_uc_destroy(sock->assoc);
     130                free(sock);
     131                async_answer_0(callid, ENOMEM);
     132                return;
     133        }
     134
     135        sock_id = SOCKET_GET_SOCKET_ID(call);
     136        rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
     137        if (rc != EOK) {
     138                fibril_destroy(sock->recv_fibril);
    117139                udp_uc_destroy(sock->assoc);
    118140                free(sock);
    … …  
    121143        }
    122144
    123         sock_id = SOCKET_GET_SOCKET_ID(call);
    124         rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
    125         if (rc != EOK) {
    126                 async_answer_0(callid, rc);
    127                 return;
    128         }
     145        fibril_add_ready(sock->recv_fibril);
    129146
    130147        sock_core = socket_cores_find(&client->sockets, sock_id);
    … …  
    134151        SOCKET_SET_SOCKET_ID(answer, sock_id);
    135152
    136         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
     153        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, UDP_FRAGMENT_SIZE);
    137154        SOCKET_SET_HEADER_SIZE(answer, sizeof(udp_header_t));
    138155        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    … …  
    205222        }
    206223
    207         udp_sock_notify_data(sock_core);
    208 
    209224        log_msg(LVL_DEBUG, " - success");
    210225        async_answer_0(callid, rc);
    … …  
    245260        ipc_callid_t wcallid;
    246261        size_t length;
    247         uint8_t buffer[FRAGMENT_SIZE];
     262        uint8_t buffer[UDP_FRAGMENT_SIZE];
    248263        udp_error_t urc;
    249264        int rc;
    … …  
    292307                        goto out;
    293308                }
    294 
    295                 udp_sock_notify_data(sock_core);
    296309        }
    297310
    … …  
    330343                }
    331344
    332                 if (length > FRAGMENT_SIZE)
    333                         length = FRAGMENT_SIZE;
     345                if (length > UDP_FRAGMENT_SIZE)
     346                        length = UDP_FRAGMENT_SIZE;
    334347
    335348                rc = async_data_write_finalize(wcallid, buffer, length);
    … …  
    367380       
    368381        IPC_SET_ARG1(answer, 0);
    369         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
     382        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, UDP_FRAGMENT_SIZE);
    370383        async_answer_2(callid, EOK, IPC_GET_ARG1(answer),
    371384            IPC_GET_ARG2(answer));
    … …  
    386399        ipc_call_t answer;
    387400        ipc_callid_t rcallid;
    388         uint8_t buffer[FRAGMENT_SIZE];
    389401        size_t data_len;
    390         xflags_t xflags;
    391402        udp_error_t urc;
     403        udp_sock_t rsock;
    392404        struct sockaddr_in addr;
    393         udp_sock_t rsock;
    394405        int rc;
    395406
    … …  
    416427        (void)flags;
    417428
    418         urc = udp_uc_receive(socket->assoc, buffer, FRAGMENT_SIZE, &data_len,
    419             &xflags, &rsock);
    420         log_msg(LVL_DEBUG, "**** udp_uc_receive done, data_len=%zu", data_len);
     429        log_msg(LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock");
     430        fibril_mutex_lock(&socket->recv_buffer_lock);
     431        while (socket->recv_buffer_used == 0 && socket->recv_error == UDP_EOK) {
     432                log_msg(LVL_DEBUG, "udp_sock_recvfrom(): wait for cv");
     433                fibril_condvar_wait(&socket->recv_buffer_cv,
     434                    &socket->recv_buffer_lock);
     435        }
     436
     437        log_msg(LVL_DEBUG, "Got data in sock recv_buffer");
     438
     439        rsock = socket->recv_fsock;
     440        data_len = socket->recv_buffer_used;
     441        urc = socket->recv_error;
     442
     443        log_msg(LVL_DEBUG, "**** recv data_len=%zu", data_len);
    421444
    422445        switch (urc) {
    … …  
    437460        log_msg(LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
    438461        if (rc != EOK) {
     462                fibril_mutex_unlock(&socket->recv_buffer_lock);
    439463                fibril_mutex_unlock(&socket->lock);
    440464                async_answer_0(callid, rc);
    … …  
    450474                log_msg(LVL_DEBUG, "addr read receive");
    451475                if (!async_data_read_receive(&rcallid, &addr_length)) {
     476                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    452477                        fibril_mutex_unlock(&socket->lock);
    453478                        async_answer_0(callid, EINVAL);
    … …  
    461486                rc = async_data_read_finalize(rcallid, &addr, addr_length);
    462487                if (rc != EOK) {
     488                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    463489                        fibril_mutex_unlock(&socket->lock);
    464490                        async_answer_0(callid, EINVAL);
    … …  
    469495        log_msg(LVL_DEBUG, "data read receive");
    470496        if (!async_data_read_receive(&rcallid, &length)) {
     497                fibril_mutex_unlock(&socket->recv_buffer_lock);
    471498                fibril_mutex_unlock(&socket->lock);
    472499                async_answer_0(callid, EINVAL);
    … …  
    478505
    479506        log_msg(LVL_DEBUG, "data read finalize");
    480         rc = async_data_read_finalize(rcallid, buffer, length);
     507        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
    481508
    482509        if (length < data_len && rc == EOK)
    … …  
    489516        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    490517            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    491        
    492         /* Push one fragment notification to client's queue */
    493         udp_sock_notify_data(sock_core);
     518
     519        socket->recv_buffer_used = 0;
     520
     521        fibril_condvar_broadcast(&socket->recv_buffer_cv);
     522        fibril_mutex_unlock(&socket->recv_buffer_lock);
    494523        fibril_mutex_unlock(&socket->lock);
    495524}
    … …  
    538567}
    539568
     569static int udp_sock_recv_fibril(void *arg)
     570{
     571        udp_sockdata_t *sock = (udp_sockdata_t *)arg;
     572        udp_error_t urc;
     573        xflags_t xflags;
     574        size_t rcvd;
     575
     576        log_msg(LVL_DEBUG, "udp_sock_recv_fibril()");
     577
     578        while (true) {
     579                log_msg(LVL_DEBUG, "[] wait for rcv buffer empty()");
     580                fibril_mutex_lock(&sock->recv_buffer_lock);
     581                while (sock->recv_buffer_used != 0) {
     582                        fibril_condvar_wait(&sock->recv_buffer_cv,
     583                            &sock->recv_buffer_lock);
     584                }
     585
     586                log_msg(LVL_DEBUG, "[] call udp_uc_receive()");
     587                urc = udp_uc_receive(sock->assoc, sock->recv_buffer,
     588                    UDP_FRAGMENT_SIZE, &rcvd, &xflags, &sock->recv_fsock);
     589                sock->recv_error = urc;
     590
     591                udp_sock_notify_data(sock->sock_core);
     592
     593                if (urc != UDP_EOK) {
     594                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
     595                        fibril_mutex_unlock(&sock->recv_buffer_lock);
     596                        break;
     597                }
     598
     599                log_msg(LVL_DEBUG, "[] got data - broadcast recv_buffer_cv");
     600
     601                sock->recv_buffer_used = rcvd;
     602                fibril_mutex_unlock(&sock->recv_buffer_lock);
     603                fibril_condvar_broadcast(&sock->recv_buffer_cv);
     604        }
     605
     606        udp_uc_destroy(sock->assoc);
     607
     608        return 0;
     609}
     610
    540611static void udp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    541612{

  • uspace/srv/net/udp/udp.c

    re1e4192 r90478727  
    7373        printf(NAME ": UDP (User Datagram Protocol) service\n");
    7474
    75         rc = log_init(NAME, LVL_WARN);
     75        rc = log_init(NAME, LVL_DEBUG);
    7676        if (rc != EOK) {
    7777                printf(NAME ": Failed to initialize log.\n");

  • uspace/srv/net/udp/udp_type.h

    re1e4192 r90478727  
    3636#define UDP_TYPE_H
    3737
     38#include <fibril.h>
    3839#include <fibril_synch.h>
    3940#include <socket_core.h>
    4041#include <sys/types.h>
     42
     43#define UDP_FRAGMENT_SIZE 4096
     44
    4145
    4246typedef enum {
    … …  
    141145        /** Connection */
    142146        udp_assoc_t *assoc;
     147        /** Receiving fibril */
     148        fid_t recv_fibril;
     149        uint8_t recv_buffer[UDP_FRAGMENT_SIZE];
     150        size_t recv_buffer_used;
     151        udp_sock_t recv_fsock;
     152        fibril_mutex_t recv_buffer_lock;
     153        fibril_condvar_t recv_buffer_cv;
     154        udp_error_t recv_error;
    143155} udp_sockdata_t;
    144156

  • uspace/srv/vfs/vfs.c

    re1e4192 r90478727  
    173173         * Allocate and initialize the Path Lookup Buffer.
    174174         */
    175         plb = as_area_create((void *) -1, PLB_SIZE,
     175        plb = as_area_create(AS_AREA_ANY, PLB_SIZE,
    176176            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
    177         if (plb == (void *) -1) {
     177        if (plb == AS_MAP_FAILED) {
    178178                printf("%s: Cannot create address space area\n", NAME);
    179179                return ENOMEM;
Note: See TracChangeset for help on using the changeset viewer.