Changeset 1d4024cf in mainline for uspace

Timestamp:

2012-06-13T16:19:01Z (14 years ago)

Author:

Frantisek Princ <frantisek.princ@…>

Branches:

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

Children:

49c94a3

Parents:

33f9670 (diff), 2902e1bb (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 with mainline

Location:

uspace

Files:

• app/tester/mm/common.c (modified) (1 diff)
• app/tester/mm/mapping1.c (modified) (1 diff)
• drv/bus/usb/uhci/utils/malloc32.h (modified) (1 diff)
• drv/bus/usb/usbmast/main.c (modified) (1 diff)
• lib/c/arch/ia64/include/fibril.h (modified) (2 diffs)
• lib/c/arch/ia64/include/thread.h (modified) (2 diffs)
• lib/c/generic/as.c (modified) (1 diff)
• lib/c/generic/elf/elf_load.c (modified) (1 diff)
• lib/c/generic/fibril.c (modified) (1 diff)
• lib/c/generic/malloc.c (modified) (1 diff)
• lib/c/generic/mman.c (modified) (1 diff)
• lib/c/generic/thread.c (modified) (3 diffs)
• lib/c/include/as.h (modified) (1 diff)
• lib/c/include/fibril.h (modified) (1 diff)
• lib/c/include/sys/mman.h (modified) (1 diff)
• lib/fb/imgmap.c (modified) (1 diff)
• lib/fb/screenbuffer.c (modified) (1 diff)
• lib/fs/libfs.c (modified) (1 diff)
• srv/bd/ata_bd/ata_bd.c (modified) (1 diff)
• srv/bd/file_bd/file_bd.c (modified) (1 diff)
• srv/bd/gxe_bd/gxe_bd.c (modified) (1 diff)
• srv/bd/part/guid_part/guid_part.c (modified) (1 diff)
• srv/bd/part/mbr_part/mbr_part.c (modified) (1 diff)
• srv/bd/rd/rd.c (modified) (1 diff)
• srv/hid/fb/fb.c (modified) (2 diffs)
• srv/net/tcp/sock.c (modified) (1 diff)
• srv/net/udp/sock.c (modified) (21 diffs)
• srv/net/udp/udp.c (modified) (1 diff)
• srv/net/udp/udp_type.h (modified) (2 diffs)
• srv/vfs/vfs.c (modified) (1 diff)

uspace/app/tester/mm/common.c

@@ -342 +342 @@
         link_initialize(&area->link);
         
-        area->addr = as_area_create((void *) -1, size,
+        area->addr = as_area_create(AS_AREA_ANY, size,
             AS_AREA_WRITE | AS_AREA_READ);
-        if (area->addr == (void *) -1) {
+        if (area->addr == AS_MAP_FAILED) {
                 free(area);
                 check_consistency("map_area (a)");

uspace/app/tester/mm/mapping1.c

@@ -42 +42 @@
         TPRINTF("Creating AS area...\n");
         
-        void *result = as_area_create((void *) -1, size,
+        void *result = as_area_create(AS_AREA_ANY, size,
             AS_AREA_READ | AS_AREA_WRITE);
-        if (result == (void *) -1)
+        if (result == AS_MAP_FAILED)
                 return NULL;
         

uspace/drv/bus/usb/uhci/utils/malloc32.h

@@ -99 +99 @@
 static inline void * get_page(void)
 {
-        void *address = as_area_create((void *) -1, UHCI_REQUIRED_PAGE_SIZE,
+        void *address = as_area_create(AS_AREA_ANY, UHCI_REQUIRED_PAGE_SIZE,
             AS_AREA_READ | AS_AREA_WRITE);
-        if (address == (void *) -1)
+        if (address == AS_MAP_FAILED)
                 return NULL;
         

uspace/drv/bus/usb/usbmast/main.c

@@ -302 +302 @@
         
         (void) async_share_out_finalize(callid, &comm_buf);
-        if (comm_buf == (void *) -1) {
+        if (comm_buf == AS_MAP_FAILED) {
                 async_answer_0(callid, EHANGUP);
                 return;

uspace/lib/c/arch/ia64/include/fibril.h

@@ -49 +49 @@
 #define PFM_MASK  (~0x3fffffffff)
 
-#define PSTHREAD_INITIAL_STACK_PAGES_NO  2
-
 /* Stack is divided into two equal parts (for memory stack and register stack). */
-#define PSTHREAD_INITIAL_STACK_DIVISION  2
+#define FIBRIL_INITIAL_STACK_DIVISION  2
 
 #define context_set(c, _pc, stack, size, tls) \
@@ -58 +56 @@
                 (c)->pc = (uint64_t) _pc; \
                 (c)->bsp = ((uint64_t) stack) + \
-                    size / PSTHREAD_INITIAL_STACK_DIVISION; \
+                    size / FIBRIL_INITIAL_STACK_DIVISION; \
                 (c)->ar_pfs &= PFM_MASK; \
                 (c)->sp = ((uint64_t) stack) + \
-                    ALIGN_UP((size / PSTHREAD_INITIAL_STACK_DIVISION), STACK_ALIGNMENT) - \
+                    ALIGN_UP((size / FIBRIL_INITIAL_STACK_DIVISION), STACK_ALIGNMENT) - \
                     SP_DELTA; \
                 (c)->tp = (uint64_t) tls; \

uspace/lib/c/arch/ia64/include/thread.h

@@ -27 +27 @@
  */
 
-/** @addtogroup libcia64        
+/** @addtogroup libcia64
  * @{
  */
@@ -36 +36 @@
 #define LIBC_ia64_THREAD_H_
 
-#define THREAD_INITIAL_STACK_PAGES_NO 2
-
 #endif
 

uspace/lib/c/generic/as.c

@@ -46 +46 @@
  *
  * @param base  Starting virtual address of the area.
- *              If set to (void *) -1, the kernel finds
- *              a mappable area.
+ *              If set to AS_AREA_ANY ((void *) -1),
+ *              the kernel finds a mappable area.
  * @param size  Size of the area.
  * @param flags Flags describing type of the area.
  *
  * @return Starting virtual address of the created area on success.
- * @return (void *) -1 otherwise.
+ * @return AS_MAP_FAILED ((void *) -1) otherwise.
  *
  */

uspace/lib/c/generic/elf/elf_load.c

@@ -366 +366 @@
         a = as_area_create((uint8_t *) base + bias, mem_sz,
             AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
-        if (a == (void *) -1) {
+        if (a == AS_MAP_FAILED) {
                 DPRINTF("memory mapping failed (0x%x, %d)\n",
                     base + bias, mem_sz);

uspace/lib/c/generic/fibril.c

@@ -286 +286 @@
 }
 
+/** Delete a fibril that has never run.
+ *
+ * Free resources of a fibril that has been created with fibril_create()
+ * but never readied using fibril_add_ready().
+ *
+ * @param fid Pointer to the fibril structure of the fibril to be
+ *            added.
+ */
+void fibril_destroy(fid_t fid)
+{
+        fibril_t *fibril = (fibril_t *) fid;
+        
+        free(fibril->stack);
+        fibril_teardown(fibril);
+}
+
 /** Add a fibril to the ready list.
  *

uspace/lib/c/generic/malloc.c

@@ -285 +285 @@
         /* Align the heap area size on page boundary */
         size_t asize = ALIGN_UP(size, PAGE_SIZE);
-        void *astart = as_area_create((void *) -1, asize,
+        void *astart = as_area_create(AS_AREA_ANY, asize,
             AS_AREA_WRITE | AS_AREA_READ);
-        if (astart == (void *) -1)
+        if (astart == AS_MAP_FAILED)
                 return false;
         

uspace/lib/c/generic/mman.c

@@ -42 +42 @@
 {
         if (!start)
-                start = (void *) -1;
+                start = AS_AREA_ANY;
         
 //      if (!((flags & MAP_SHARED) ^ (flags & MAP_PRIVATE)))

uspace/lib/c/generic/thread.c

@@ -41 +41 @@
 #include <str.h>
 #include <async.h>
+#include <errno.h>
+#include <as.h>
 #include "private/thread.h"
 
-#ifndef THREAD_INITIAL_STACK_PAGES_NO
-#define THREAD_INITIAL_STACK_PAGES_NO   2 
+#ifndef THREAD_INITIAL_STACK_PAGES
+        #define THREAD_INITIAL_STACK_PAGES  2
 #endif
 
@@ -65 +67 @@
         
         uarg->uspace_thread_function(uarg->uspace_thread_arg);
-        /* XXX: we cannot free the userspace stack while running on it
-                free(uarg->uspace_stack);
-                free(uarg);
-        */
+        /*
+         * XXX: we cannot free the userspace stack while running on it
+         *
+         * free(uarg->uspace_stack);
+         * free(uarg);
+         */
         
         /* If there is a manager, destroy it */
@@ -92 +96 @@
     thread_id_t *tid)
 {
-        char *stack;
-        uspace_arg_t *uarg;
-        int rc;
-
-        stack = (char *) malloc(getpagesize() * THREAD_INITIAL_STACK_PAGES_NO);
-        if (!stack)
-                return -1;
-                
-        uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t));
-        if (!uarg) {
-                free(stack);
-                return -1;
+        uspace_arg_t *uarg =
+            (uspace_arg_t *) malloc(sizeof(uspace_arg_t));
+        if (!uarg)
+                return ENOMEM;
+        
+        size_t stack_size = getpagesize() * THREAD_INITIAL_STACK_PAGES;
+        void *stack = as_area_create(AS_AREA_ANY, stack_size,
+            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
+        if (stack == AS_MAP_FAILED) {
+                free(uarg);
+                return ENOMEM;
         }
         
         uarg->uspace_entry = (void *) FADDR(__thread_entry);
-        uarg->uspace_stack = (void *) stack;
+        uarg->uspace_stack = stack;
+        uarg->uspace_stack_size = stack_size;
         uarg->uspace_thread_function = function;
         uarg->uspace_thread_arg = arg;
         uarg->uspace_uarg = uarg;
         
-        rc = __SYSCALL4(SYS_THREAD_CREATE, (sysarg_t) uarg, (sysarg_t) name,
-            (sysarg_t) str_size(name), (sysarg_t) tid);
+        int rc = __SYSCALL4(SYS_THREAD_CREATE, (sysarg_t) uarg,
+            (sysarg_t) name, (sysarg_t) str_size(name), (sysarg_t) tid);
         
-        if (rc) {
+        if (rc != EOK) {
                 /*
                  * Failed to create a new thread.
-                 * Free up the allocated structures.
+                 * Free up the allocated data.
                  */
+                as_area_destroy(stack);
                 free(uarg);
-                free(stack);
         }
-
+        
         return rc;
 }

uspace/lib/c/include/as.h

@@ -41 +41 @@
 #include <libarch/config.h>
 
+#define AS_AREA_ANY    ((void *) -1)
+#define AS_MAP_FAILED  ((void *) -1)
+
 static inline size_t SIZE2PAGES(size_t size)
 {

uspace/lib/c/include/fibril.h

@@ -87 +87 @@
 
 extern fid_t fibril_create(int (*func)(void *), void *arg);
+extern void fibril_destroy(fid_t fid);
 extern fibril_t *fibril_setup(void);
 extern void fibril_teardown(fibril_t *f);

uspace/lib/c/include/sys/mman.h

@@ -39 +39 @@
 #include <sys/types.h>
 
-#define MAP_FAILED  ((void *) -1)
+#define MAP_FAILED  AS_MAP_FAILED
 
 #define MAP_SHARED     (1 << 0)

uspace/lib/fb/imgmap.c

@@ -420 +420 @@
         
         if ((flags & IMGMAP_FLAG_SHARED) == IMGMAP_FLAG_SHARED) {
-                imgmap = (imgmap_t *) as_area_create((void *) -1, size,
+                imgmap = (imgmap_t *) as_area_create(AS_AREA_ANY, size,
                     AS_AREA_READ | AS_AREA_WRITE);
-                if (imgmap == (void *) -1)
+                if (imgmap == AS_MAP_FAILED)
                         return NULL;
         } else {

uspace/lib/fb/screenbuffer.c

@@ -79 +79 @@
         
         if ((flags & SCREENBUFFER_FLAG_SHARED) == SCREENBUFFER_FLAG_SHARED) {
-                scrbuf = (screenbuffer_t *) as_area_create((void *) -1, size,
+                scrbuf = (screenbuffer_t *) as_area_create(AS_AREA_ANY, size,
                     AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
-                if (scrbuf == (void *) -1)
+                if (scrbuf == AS_MAP_FAILED)
                         return NULL;
         } else {

uspace/lib/fs/libfs.c

@@ -339 +339 @@
          */
         rc = async_share_in_start_0_0(exch, PLB_SIZE, (void *) &reg.plb_ro);
-        if (reg.plb_ro == (void *) -1) {
+        if (reg.plb_ro == AS_MAP_FAILED) {
                 async_exchange_end(exch);
                 async_forget(req);

uspace/srv/bd/ata_bd/ata_bd.c

@@ -308 +308 @@
 
         (void) async_share_out_finalize(callid, &fs_va);
-        if (fs_va == (void *) -1) {
+        if (fs_va == AS_MAP_FAILED) {
                 async_answer_0(callid, EHANGUP);
                 return;

uspace/srv/bd/file_bd/file_bd.c

@@ -189 +189 @@
 
         (void) async_share_out_finalize(callid, &fs_va);
-        if (fs_va == (void *) -1) {
+        if (fs_va == AS_MAP_FAILED) {
                 async_answer_0(callid, EHANGUP);
                 return;

uspace/srv/bd/gxe_bd/gxe_bd.c

@@ -196 +196 @@
 
         (void) async_share_out_finalize(callid, &fs_va);
-        if (fs_va == (void *) -1) {
+        if (fs_va == AS_MAP_FAILED) {
                 async_answer_0(callid, EHANGUP);
                 return;

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

@@ -350 +350 @@
 
         (void) async_share_out_finalize(callid, &fs_va);
-        if (fs_va == (void *) -1) {
+        if (fs_va == AS_MAP_FAILED) {
                 async_answer_0(callid, EHANGUP);
                 return;

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

@@ -427 +427 @@
 
         (void) async_share_out_finalize(callid, &fs_va);
-        if (fs_va == (void *) -1) {
+        if (fs_va == AS_MAP_FAILED) {
                 async_answer_0(callid, EHANGUP);
                 return;

uspace/srv/bd/rd/rd.c

@@ -106 +106 @@
         if (async_share_out_receive(&callid, &comm_size, &flags)) {
                 (void) async_share_out_finalize(callid, &fs_va);
-                if (fs_va == (void *) -1) {
+                if (fs_va == AS_MAP_FAILED) {
                         async_answer_0(callid, EHANGUP);
                         return;

uspace/srv/hid/fb/fb.c

@@ -305 +305 @@
         
         int rc = async_share_out_finalize(callid, &frontbuf->data);
-        if ((rc != EOK) || (frontbuf->data == (void *) -1)) {
+        if ((rc != EOK) || (frontbuf->data == AS_MAP_FAILED)) {
                 free(frontbuf);
                 async_answer_0(iid, ENOMEM);
@@ -348 +348 @@
         
         int rc = async_share_out_finalize(callid, &imagemap->data);
-        if ((rc != EOK) || (imagemap->data == (void *) -1)) {
+        if ((rc != EOK) || (imagemap->data == AS_MAP_FAILED)) {
                 free(imagemap);
                 async_answer_0(iid, ENOMEM);

uspace/srv/net/tcp/sock.c

@@ -151 +151 @@
             sock, sock_id);
 
-        if (rc != EOK)
+        if (rc != EOK) {
+                fibril_destroy(sock->recv_fibril);
+                sock->recv_fibril = 0;
                 return rc;
+        }
 
         sock_core = socket_cores_find(&sock->client->sockets, *sock_id);

uspace/srv/net/udp/sock.c

@@ -51 +51 @@
 #include "ucall.h"
 
-#define FRAGMENT_SIZE 1024
-
 /** Free ports pool start. */
 #define UDP_FREE_PORTS_START            1025
@@ -63 +61 @@
 
 static void udp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
+static int udp_sock_recv_fibril(void *arg);
 
 int udp_sock_init(void)
@@ -82 +81 @@
 
         socket = (udp_sockdata_t *)sock_core->specific_data;
-        assert(socket->assoc != NULL);
-        udp_uc_destroy(socket->assoc);
+        (void)socket;
+
+        /* XXX We need to force the receive fibril to quit */
 }
 
@@ -91 +91 @@
         async_exch_t *exch = async_exchange_begin(sock_core->sess);
         async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
-            FRAGMENT_SIZE, 0, 0, 1);
+            UDP_FRAGMENT_SIZE, 0, 0, 1);
         async_exchange_end(exch);
 }
@@ -113 +113 @@
         sock->client = client;
 
+        sock->recv_buffer_used = 0;
+        sock->recv_error = UDP_EOK;
+        fibril_mutex_initialize(&sock->recv_buffer_lock);
+        fibril_condvar_initialize(&sock->recv_buffer_cv);
+
         rc = udp_uc_create(&sock->assoc);
         if (rc != EOK) {
+                free(sock);
+                async_answer_0(callid, rc);
+                return;
+        }
+
+        sock->recv_fibril = fibril_create(udp_sock_recv_fibril, sock);
+        if (sock->recv_fibril == 0) {
+                udp_uc_destroy(sock->assoc);
+                free(sock);
+                async_answer_0(callid, ENOMEM);
+                return;
+        }
+
+        sock_id = SOCKET_GET_SOCKET_ID(call);
+        rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
+        if (rc != EOK) {
+                fibril_destroy(sock->recv_fibril);
                 udp_uc_destroy(sock->assoc);
                 free(sock);
@@ -121 +143 @@
         }
 
-        sock_id = SOCKET_GET_SOCKET_ID(call);
-        rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
-        if (rc != EOK) {
-                async_answer_0(callid, rc);
-                return;
-        }
+        fibril_add_ready(sock->recv_fibril);
 
         sock_core = socket_cores_find(&client->sockets, sock_id);
@@ -134 +151 @@
         SOCKET_SET_SOCKET_ID(answer, sock_id);
 
-        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
+        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, UDP_FRAGMENT_SIZE);
         SOCKET_SET_HEADER_SIZE(answer, sizeof(udp_header_t));
         async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
@@ -205 +222 @@
         }
 
-        udp_sock_notify_data(sock_core);
-
         log_msg(LVL_DEBUG, " - success");
         async_answer_0(callid, rc);
@@ -245 +260 @@
         ipc_callid_t wcallid;
         size_t length;
-        uint8_t buffer[FRAGMENT_SIZE];
+        uint8_t buffer[UDP_FRAGMENT_SIZE];
         udp_error_t urc;
         int rc;
@@ -292 +307 @@
                         goto out;
                 }
-
-                udp_sock_notify_data(sock_core);
         }
 
@@ -330 +343 @@
                 }
 
-                if (length > FRAGMENT_SIZE)
-                        length = FRAGMENT_SIZE;
+                if (length > UDP_FRAGMENT_SIZE)
+                        length = UDP_FRAGMENT_SIZE;
 
                 rc = async_data_write_finalize(wcallid, buffer, length);
@@ -367 +380 @@
         
         IPC_SET_ARG1(answer, 0);
-        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
+        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, UDP_FRAGMENT_SIZE);
         async_answer_2(callid, EOK, IPC_GET_ARG1(answer),
             IPC_GET_ARG2(answer));
@@ -386 +399 @@
         ipc_call_t answer;
         ipc_callid_t rcallid;
-        uint8_t buffer[FRAGMENT_SIZE];
         size_t data_len;
-        xflags_t xflags;
         udp_error_t urc;
+        udp_sock_t rsock;
         struct sockaddr_in addr;
-        udp_sock_t rsock;
         int rc;
 
@@ -416 +427 @@
         (void)flags;
 
-        urc = udp_uc_receive(socket->assoc, buffer, FRAGMENT_SIZE, &data_len,
-            &xflags, &rsock);
-        log_msg(LVL_DEBUG, "**** udp_uc_receive done, data_len=%zu", data_len);
+        log_msg(LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock");
+        fibril_mutex_lock(&socket->recv_buffer_lock);
+        while (socket->recv_buffer_used == 0 && socket->recv_error == UDP_EOK) {
+                log_msg(LVL_DEBUG, "udp_sock_recvfrom(): wait for cv");
+                fibril_condvar_wait(&socket->recv_buffer_cv,
+                    &socket->recv_buffer_lock);
+        }
+
+        log_msg(LVL_DEBUG, "Got data in sock recv_buffer");
+
+        rsock = socket->recv_fsock;
+        data_len = socket->recv_buffer_used;
+        urc = socket->recv_error;
+
+        log_msg(LVL_DEBUG, "**** recv data_len=%zu", data_len);
 
         switch (urc) {
@@ -437 +460 @@
         log_msg(LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
         if (rc != EOK) {
+                fibril_mutex_unlock(&socket->recv_buffer_lock);
                 fibril_mutex_unlock(&socket->lock);
                 async_answer_0(callid, rc);
@@ -450 +474 @@
                 log_msg(LVL_DEBUG, "addr read receive");
                 if (!async_data_read_receive(&rcallid, &addr_length)) {
+                        fibril_mutex_unlock(&socket->recv_buffer_lock);
                         fibril_mutex_unlock(&socket->lock);
                         async_answer_0(callid, EINVAL);
@@ -461 +486 @@
                 rc = async_data_read_finalize(rcallid, &addr, addr_length);
                 if (rc != EOK) {
+                        fibril_mutex_unlock(&socket->recv_buffer_lock);
                         fibril_mutex_unlock(&socket->lock);
                         async_answer_0(callid, EINVAL);
@@ -469 +495 @@
         log_msg(LVL_DEBUG, "data read receive");
         if (!async_data_read_receive(&rcallid, &length)) {
+                fibril_mutex_unlock(&socket->recv_buffer_lock);
                 fibril_mutex_unlock(&socket->lock);
                 async_answer_0(callid, EINVAL);
@@ -478 +505 @@
 
         log_msg(LVL_DEBUG, "data read finalize");
-        rc = async_data_read_finalize(rcallid, buffer, length);
+        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
 
         if (length < data_len && rc == EOK)
@@ -489 +516 @@
         async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
             IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
-        
-        /* Push one fragment notification to client's queue */
-        udp_sock_notify_data(sock_core);
+
+        socket->recv_buffer_used = 0;
+
+        fibril_condvar_broadcast(&socket->recv_buffer_cv);
+        fibril_mutex_unlock(&socket->recv_buffer_lock);
         fibril_mutex_unlock(&socket->lock);
 }
@@ -538 +567 @@
 }
 
+static int udp_sock_recv_fibril(void *arg)
+{
+        udp_sockdata_t *sock = (udp_sockdata_t *)arg;
+        udp_error_t urc;
+        xflags_t xflags;
+        size_t rcvd;
+
+        log_msg(LVL_DEBUG, "udp_sock_recv_fibril()");
+
+        while (true) {
+                log_msg(LVL_DEBUG, "[] wait for rcv buffer empty()");
+                fibril_mutex_lock(&sock->recv_buffer_lock);
+                while (sock->recv_buffer_used != 0) {
+                        fibril_condvar_wait(&sock->recv_buffer_cv,
+                            &sock->recv_buffer_lock);
+                }
+
+                log_msg(LVL_DEBUG, "[] call udp_uc_receive()");
+                urc = udp_uc_receive(sock->assoc, sock->recv_buffer,
+                    UDP_FRAGMENT_SIZE, &rcvd, &xflags, &sock->recv_fsock);
+                sock->recv_error = urc;
+
+                udp_sock_notify_data(sock->sock_core);
+
+                if (urc != UDP_EOK) {
+                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
+                        fibril_mutex_unlock(&sock->recv_buffer_lock);
+                        break;
+                }
+
+                log_msg(LVL_DEBUG, "[] got data - broadcast recv_buffer_cv");
+
+                sock->recv_buffer_used = rcvd;
+                fibril_mutex_unlock(&sock->recv_buffer_lock);
+                fibril_condvar_broadcast(&sock->recv_buffer_cv);
+        }
+
+        udp_uc_destroy(sock->assoc);
+
+        return 0;
+}
+
 static void udp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {

uspace/srv/net/udp/udp.c

@@ -73 +73 @@
         printf(NAME ": UDP (User Datagram Protocol) service\n");
 
-        rc = log_init(NAME, LVL_WARN);
+        rc = log_init(NAME, LVL_DEBUG);
         if (rc != EOK) {
                 printf(NAME ": Failed to initialize log.\n");

uspace/srv/net/udp/udp_type.h

@@ -36 +36 @@
 #define UDP_TYPE_H
 
+#include <fibril.h>
 #include <fibril_synch.h>
 #include <socket_core.h>
 #include <sys/types.h>
+
+#define UDP_FRAGMENT_SIZE 4096
+
 
 typedef enum {
@@ -141 +145 @@
         /** Connection */
         udp_assoc_t *assoc;
+        /** Receiving fibril */
+        fid_t recv_fibril;
+        uint8_t recv_buffer[UDP_FRAGMENT_SIZE];
+        size_t recv_buffer_used;
+        udp_sock_t recv_fsock;
+        fibril_mutex_t recv_buffer_lock;
+        fibril_condvar_t recv_buffer_cv;
+        udp_error_t recv_error;
 } udp_sockdata_t;
 

uspace/srv/vfs/vfs.c

@@ -173 +173 @@
          * Allocate and initialize the Path Lookup Buffer.
          */
-        plb = as_area_create((void *) -1, PLB_SIZE,
+        plb = as_area_create(AS_AREA_ANY, PLB_SIZE,
             AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
-        if (plb == (void *) -1) {
+        if (plb == AS_MAP_FAILED) {
                 printf("%s: Cannot create address space area\n", NAME);
                 return ENOMEM;