Changeset af2a76c in mainline

Timestamp:

2014-07-13T17:25:15Z (10 years ago)

Author:

Agnieszka Tabaka <nufcia@…>

Branches:

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

Children:

7493e7b

Parents:

b8e75319 (diff), 78192cc7 (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.

Files:

• .bzrignore (modified) (2 diffs)
• boot/Makefile.common (modified) (1 diff)
• kernel/arch/amd64/Makefile.inc (modified) (1 diff)
• kernel/arch/amd64/include/arch/mm/km.h (modified) (1 diff)
• kernel/arch/amd64/include/arch/mm/page.h (modified) (1 diff)
• kernel/arch/amd64/src/boot/multiboot.S (modified) (3 diffs)
• kernel/arch/amd64/src/boot/multiboot2.S (modified) (1 diff)
• kernel/arch/amd64/src/mm/km.c (modified) (1 diff)
• kernel/genarch/src/mm/page_pt.c (modified) (1 diff)
• uspace/Makefile (modified) (1 diff)
• uspace/app/mixerctl/mixerctl.c (modified) (4 diffs)
• uspace/app/nic/Makefile (added)
• uspace/app/nic/nic.c (added)
• uspace/app/taskdump/Makefile (modified) (1 diff)
• uspace/app/taskdump/fibrildump.c (added)
• uspace/app/taskdump/include/fibrildump.h (moved) (moved from uspace/lib/drv/include/graph_iface.h ) (2 diffs)
• uspace/app/taskdump/include/symtab.h (modified) (1 diff)
• uspace/app/taskdump/include/taskdump.h (moved) (moved from uspace/lib/drv/generic/private/remote_graph_dev.h ) (2 diffs)
• uspace/app/taskdump/symtab.c (modified) (1 diff)
• uspace/app/taskdump/taskdump.c (modified) (6 diffs)
• uspace/app/vlaunch/vlaunch.c (modified) (1 diff)
• uspace/drv/bus/isa/isa.c (modified) (1 diff)
• uspace/drv/fb/amdm37x_dispc/amdm37x_dispc.c (modified) (1 diff)
• uspace/drv/fb/amdm37x_dispc/main.c (modified) (3 diffs)
• uspace/drv/fb/kfb/kfb.c (modified) (2 diffs)
• uspace/drv/fb/kfb/port.c (modified) (2 diffs)
• uspace/lib/c/arch/amd64/src/stacktrace.c (modified) (1 diff)
• uspace/lib/c/arch/arm32/src/stacktrace.c (modified) (1 diff)
• uspace/lib/c/arch/ia32/src/stacktrace.c (modified) (1 diff)
• uspace/lib/c/arch/ppc32/src/stacktrace.c (modified) (1 diff)
• uspace/lib/c/arch/sparc32/src/stacktrace.c (modified) (2 diffs)
• uspace/lib/c/arch/sparc64/src/stacktrace.c (modified) (2 diffs)
• uspace/lib/c/generic/fibril.c (modified) (3 diffs)
• uspace/lib/c/generic/fibril_synch.c (modified) (8 diffs)
• uspace/lib/c/generic/inet.c (modified) (3 diffs)
• uspace/lib/c/generic/stacktrace.c (modified) (1 diff)
• uspace/lib/c/generic/str.c (modified) (1 diff)
• uspace/lib/c/include/fibril.h (modified) (1 diff)
• uspace/lib/c/include/fibril_synch.h (modified) (3 diffs)
• uspace/lib/c/include/ipc/dev_iface.h (modified) (1 diff)
• uspace/lib/c/include/stacktrace.h (modified) (1 diff)
• uspace/lib/c/include/str.h (modified) (2 diffs)
• uspace/lib/drv/Makefile (modified) (1 diff)
• uspace/lib/drv/generic/dev_iface.c (modified) (2 diffs)
• uspace/lib/drv/generic/remote_graph_dev.c (deleted)
• uspace/lib/drv/include/ops/graph_dev.h (deleted)
• uspace/lib/graph/graph.c (modified) (32 diffs)
• uspace/srv/devman/main.c (modified) (1 diff)
• uspace/srv/fs/fat/fat_ops.c (modified) (1 diff)
• uspace/srv/hid/compositor/compositor.c (modified) (7 diffs)
• uspace/srv/logger/initlvl.c (modified) (2 diffs)
• uspace/srv/net/dhcp/dhcp.c (modified) (2 diffs)
• uspace/srv/net/inetsrv/inetsrv.c (modified) (1 diff)
• uspace/srv/net/tcp/conn.c (modified) (6 diffs)
• uspace/srv/net/tcp/conn.h (modified) (1 diff)
• uspace/srv/net/tcp/iqueue.c (modified) (1 diff)
• uspace/srv/net/tcp/rqueue.c (modified) (1 diff)
• uspace/srv/net/tcp/segment.c (modified) (1 diff)
• uspace/srv/net/tcp/tcp.c (modified) (1 diff)
• uspace/srv/net/tcp/tqueue.c (modified) (11 diffs)
• uspace/srv/net/tcp/ucall.c (modified) (15 diffs)
• uspace/srv/net/udp/udp_inet.c (modified) (1 diff)

.bzrignore

@@ -45 +45 @@
 uspace/app/nettest2/nettest2
 uspace/app/nettest3/nettest3
+uspace/app/nic/nic
 uspace/app/nterm/nterm
 uspace/app/ping/ping
@@ -94 +95 @@
 uspace/dist/app/nettest2
 uspace/dist/app/nettest3
+uspace/dist/app/nic
 uspace/dist/app/nterm
 uspace/dist/app/ping

boot/Makefile.common

@@ -190 +190 @@
         $(USPACE_PATH)/app/mkexfat/mkexfat \
         $(USPACE_PATH)/app/mkmfs/mkmfs \
+        $(USPACE_PATH)/app/nic/nic \
         $(USPACE_PATH)/app/sbi/sbi \
         $(USPACE_PATH)/app/sportdmp/sportdmp \

kernel/arch/amd64/Makefile.inc

@@ -32 +32 @@
 
 FPU_NO_CFLAGS = -mno-sse -mno-sse2
-CMN1 = -m64 -mcmodel=large -mno-red-zone -fno-unwind-tables -fno-omit-frame-pointer
+CMN1 = -m64 -mcmodel=kernel -mno-red-zone -fno-unwind-tables -fno-omit-frame-pointer
 GCC_CFLAGS += $(CMN1)
 ICC_CFLAGS += $(CMN1)

kernel/arch/amd64/include/arch/mm/km.h

@@ -38 +38 @@
 #include <typedefs.h>
 
-#define KM_AMD64_IDENTITY_START         UINT64_C(0xffff800000000000)
-#define KM_AMD64_IDENTITY_SIZE          UINT64_C(0x0000400000000000)
+#define KM_AMD64_IDENTITY_START         UINT64_C(0xffffffff80000000)
+#define KM_AMD64_IDENTITY_SIZE          UINT64_C(0x0000000080000000)
 
-#define KM_AMD64_NON_IDENTITY_START     UINT64_C(0xffffc00000000000)
-#define KM_AMD64_NON_IDENTITY_SIZE      UINT64_C(0x0000400000000000)
+#define KM_AMD64_NON_IDENTITY_START     UINT64_C(0xffff800000000000)
+#define KM_AMD64_NON_IDENTITY_SIZE      UINT64_C(0x00007fff80000000)
 
 extern void km_identity_arch_init(void);

kernel/arch/amd64/include/arch/mm/page.h

@@ -44 +44 @@
 #ifndef __ASM__
 
-#define KA2PA(x)  (((uintptr_t) (x)) - UINT64_C(0xffff800000000000))
-#define PA2KA(x)  (((uintptr_t) (x)) + UINT64_C(0xffff800000000000))
+#define KA2PA(x)  (((uintptr_t) (x)) - UINT64_C(0xffffffff80000000))
+#define PA2KA(x)  (((uintptr_t) (x)) + UINT64_C(0xffffffff80000000))
 
 #else /* __ASM__ */
 
-#define KA2PA(x)  ((x) - 0xffff800000000000)
-#define PA2KA(x)  ((x) + 0xffff800000000000)
+#define KA2PA(x)  ((x) - 0xffffffff80000000)
+#define PA2KA(x)  ((x) + 0xffffffff80000000)
 
 #endif /* __ASM__ */

kernel/arch/amd64/src/boot/multiboot.S

@@ -428 +428 @@
         
         /* Call arch_pre_main(multiboot_eax, multiboot_ebx) */
-        xorq %rdi, %rdi
         movl multiboot_eax, %edi
-        xorq %rsi, %rsi
         movl multiboot_ebx, %esi
-        
-        movabsq $arch_pre_main, %rax
-        callq *%rax
-        
+        callq arch_pre_main
+
         long_status $status_main
         
         /* Call main_bsp() */
-        movabsq $main_bsp, %rax
-        call *%rax
+        callq main_bsp 
         
         /* Not reached */
@@ -638 +633 @@
         .quad ptl_2_6g + (PTL_WRITABLE | PTL_PRESENT)
         .quad ptl_2_7g + (PTL_WRITABLE | PTL_PRESENT)
-        .fill 504, 8, 0
+        .fill 502, 8, 0
+        /* Mapping of [0; 2G) at -2G */
+        .quad ptl_2_0g + (PTL_WRITABLE | PTL_PRESENT)
+        .quad ptl_2_1g + (PTL_WRITABLE | PTL_PRESENT)
+
 
 .align 4096
@@ -644 +643 @@
 ptl_0:
         .quad ptl_1 + (PTL_WRITABLE | PTL_PRESENT)
-        .fill 255, 8, 0
+        .fill 510, 8, 0
         .quad ptl_1 + (PTL_WRITABLE | PTL_PRESENT)
-        .fill 255, 8, 0
 
 .section K_DATA_START, "aw", @progbits

kernel/arch/amd64/src/boot/multiboot2.S

@@ -244 +244 @@
         
         /* Call arch_pre_main(multiboot_eax, multiboot_ebx) */
-        xorq %rdi, %rdi
         movl multiboot_eax, %edi
-        xorq %rsi, %rsi
         movl multiboot_ebx, %esi
-        
-        movabsq $arch_pre_main, %rax
-        callq *%rax
+        callq arch_pre_main 
         
         /* Call main_bsp() */
-        movabsq $main_bsp, %rax
-        call *%rax
+        callq main_bsp 
         
         /* Not reached */

kernel/arch/amd64/src/mm/km.c

@@ -40 +40 @@
 {
         config.identity_base = KM_AMD64_IDENTITY_START;
-        config.identity_size = KM_AMD64_IDENTITY_SIZE;  
+        config.identity_size = KM_AMD64_IDENTITY_SIZE;
 }
 

kernel/genarch/src/mm/page_pt.c

@@ -384 +384 @@
             addr - 1 < base + size - 1;
             addr += ptl0_step) {
+                if (GET_PTL1_ADDRESS(ptl0, PTL0_INDEX(addr))) {
+                        ASSERT(overlaps(addr, ptl0_step,
+                            config.identity_base, config.identity_size));
+
+                        /*
+                         * This PTL0 entry also maps the kernel identity region,
+                         * so it is already global and initialized.
+                         */
+                        continue;
+                }
+
                 uintptr_t l1 = PA2KA(frame_alloc(frames, FRAME_LOWMEM, 0));
                 memsetb((void *) l1, FRAMES2SIZE(frames), 0);

uspace/Makefile

@@ -77 +77 @@
         app/nettest2 \
         app/nettest3 \
+        app/nic \
         app/ping \
         app/sysinfo \

uspace/app/mixerctl/mixerctl.c

@@ -35 +35 @@
 #include <assert.h>
 #include <errno.h>
+#include <loc.h>
 #include <str_error.h>
 #include <str.h>
-#include <devman.h>
 #include <audio_mixer_iface.h>
 #include <stdio.h>
 
-#define DEFAULT_DEVICE "/hw/pci0/00:01.0/sb16/control"
+#define DEFAULT_SERVICE "devices/\\hw\\pci0\\00:01.0\\sb16\\control"
 
 /**
@@ -128 +128 @@
 int main(int argc, char *argv[])
 {
-        const char *device = DEFAULT_DEVICE;
+        const char *service = DEFAULT_SERVICE;
         void (*command)(async_exch_t *, int, char*[]) = NULL;
 
@@ -134 +134 @@
                 command = set_level;
                 if (argc == 5)
-                        device = argv[1];
+                        service = argv[1];
         }
 
@@ -140 +140 @@
                 command = get_level;
                 if (argc == 4)
-                        device = argv[1];
+                        service = argv[1];
         }
 
         if ((argc == 2 && command == NULL))
-                device = argv[1];
+                service = argv[1];
 
 
-        devman_handle_t mixer_handle;
-        int ret = devman_fun_get_handle(device, &mixer_handle, 0);
-        if (ret != EOK) {
-                printf("Failed to get device(%s) handle: %s.\n",
-                    device, str_error(ret));
+        service_id_t mixer_sid;
+        int rc = loc_service_get_id(service, &mixer_sid, 0);
+        if (rc != EOK) {
+                printf("Failed to resolve service '%s': %s.\n",
+                    service, str_error(rc));
                 return 1;
         }
 
-        async_sess_t *session = devman_device_connect(
-            EXCHANGE_ATOMIC, mixer_handle, IPC_FLAG_BLOCKING);
+        async_sess_t *session = loc_service_connect(
+            EXCHANGE_ATOMIC, mixer_sid, 0);
         if (!session) {
-                printf("Failed to connect to device.\n");
+                printf("Failed connecting mixer service '%s'.\n", service);
                 return 1;
         }

uspace/app/taskdump/Makefile

@@ -33 +33 @@
 SOURCES = \
         elf_core.c \
+        fibrildump.c \
         taskdump.c \
         symtab.c

uspace/app/taskdump/include/fibrildump.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Petr Koupy
+ * Copyright (c) 2014 Jiri Svoboda
  * All rights reserved.
  *
@@ -27 +27 @@
  */
 
-/** @addtogroup libc
+/** @addtogroup edit
  * @{
  */
-/** @file
+/**
+ * @file
  */
 
-#ifndef LIBC_DEVICE_GRAPH_DEV_H_
-#define LIBC_DEVICE_GRAPH_DEV_H_
+#ifndef FIBRILDUMP_H
+#define FIBRILDUMP_H
 
 #include <async.h>
+#include <symtab.h>
 
-extern int graph_dev_connect(async_sess_t *);
+extern int fibrils_dump(symtab_t *, async_sess_t *sess);
 
 #endif

uspace/app/taskdump/include/symtab.h

@@ -50 +50 @@
 extern int symtab_load(const char *file_name, symtab_t **symtab);
 extern void symtab_delete(symtab_t *st);
-extern int symtab_name_to_addr(symtab_t *st, char *name, uintptr_t *addr);
+extern int symtab_name_to_addr(symtab_t *st, const char *name, uintptr_t *addr);
 extern int symtab_addr_to_name(symtab_t *symtab, uintptr_t addr, char **name,
     size_t *offs);

uspace/app/taskdump/include/taskdump.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Petr Koupy
+ * Copyright (c) 2014 Jiri Svoboda
  * All rights reserved.
  *
@@ -27 +27 @@
  */
 
-/** @addtogroup libdrv
+/** @addtogroup edit
  * @{
  */
-/** @file
+/**
+ * @file
  */
 
-#ifndef LIBDRV_REMOTE_GRAPH_DEV_H_
-#define LIBDRV_REMOTE_GRAPH_DEV_H_
+#ifndef TASKDUMP_H
+#define TASKDUMP_H
 
-extern remote_iface_t remote_graph_dev_iface;
+#include <stdint.h>
+
+extern int td_stacktrace(uintptr_t, uintptr_t);
 
 #endif
 
-/**
- * @}
+/** @}
  */

uspace/app/taskdump/symtab.c

@@ -202 +202 @@
  * @return      EOK on success, ENOENT if no such symbol was found.
  */
-int symtab_name_to_addr(symtab_t *st, char *name, uintptr_t *addr)
+int symtab_name_to_addr(symtab_t *st, const char *name, uintptr_t *addr)
 {
         size_t i;

uspace/app/taskdump/taskdump.c

@@ -35 +35 @@
 #include <async.h>
 #include <elf/elf_linux.h>
+#include <fibrildump.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -52 +53 @@
 #include <elf_core.h>
 #include <stacktrace.h>
+#include <taskdump.h>
 
 #define LINE_BYTES 16
@@ -76 +78 @@
 static istate_t reg_state;
 
+static stacktrace_ops_t td_stacktrace_ops = {
+        .read_uintptr = td_read_uintptr
+}; 
+
 int main(int argc, char *argv[])
 {
@@ -106 +112 @@
         if (rc < 0)
                 printf("Failed dumping address space areas.\n");
+
+        rc = fibrils_dump(app_symtab, sess);
+        if (rc < 0)
+                printf("Failed dumping fibrils.\n");
 
         udebug_end(sess);
@@ -311 +321 @@
 }
 
+int td_stacktrace(uintptr_t fp, uintptr_t pc)
+{
+        uintptr_t nfp;
+        stacktrace_t st;
+        char *sym_pc;
+        int rc;
+
+        st.op_arg = NULL;
+        st.ops = &td_stacktrace_ops;
+
+        while (stacktrace_fp_valid(&st, fp)) {
+                sym_pc = fmt_sym_address(pc);
+                printf("  %p: %s\n", (void *) fp, sym_pc);
+                free(sym_pc);
+
+                rc = stacktrace_ra_get(&st, fp, &pc);
+                if (rc != EOK)
+                        return rc;
+
+                rc = stacktrace_fp_prev(&st, fp, &nfp);
+                if (rc != EOK)
+                        return rc;
+
+                fp = nfp;
+        }
+
+        return EOK;
+}
+
 static int thread_dump(uintptr_t thash)
 {
         istate_t istate;
-        uintptr_t pc, fp, nfp;
-        stacktrace_t st;
+        uintptr_t pc, fp;
         char *sym_pc;
         int rc;
@@ -336 +374 @@
         free(sym_pc);
 
-        st.op_arg = NULL;
-        st.read_uintptr = td_read_uintptr;
-
-        while (stacktrace_fp_valid(&st, fp)) {
-                sym_pc = fmt_sym_address(pc);
-                printf("  %p: %s\n", (void *) fp, sym_pc);
-                free(sym_pc);
-
-                rc = stacktrace_ra_get(&st, fp, &pc);
-                if (rc != EOK)
-                        return rc;
-
-                rc = stacktrace_fp_prev(&st, fp, &nfp);
-                if (rc != EOK)
-                        return rc;
-
-                fp = nfp;
-        }
+        (void) td_stacktrace(fp, pc);
 
         return EOK;

uspace/app/vlaunch/vlaunch.c

@@ -200 +200 @@
         }
         
-        timer = fibril_timer_create();
+        timer = fibril_timer_create(NULL);
         if (!timer) {
                 printf("Unable to create timer.\n");

uspace/drv/bus/isa/isa.c

@@ -355 +355 @@
 
         /* Get the name part of the rest of the line. */
-        strtok(line, ":");
+        str_tok(line, ":", NULL);
         return line;
 }

uspace/drv/fb/amdm37x_dispc/amdm37x_dispc.c

@@ -34 +34 @@
  */
 
+#include <align.h>
 #include <assert.h>
 #include <errno.h>

uspace/drv/fb/amdm37x_dispc/main.c

@@ -35 +35 @@
  */
 
+#include <ddf/driver.h>
 #include <ddf/log.h>
 #include <errno.h>
 #include <str_error.h>
 #include <stdio.h>
-#include <ops/graph_dev.h>
 #include <graph.h>
 
@@ -46 +46 @@
 #define NAME  "amdm37x_dispc"
 
-static graph_dev_ops_t graph_vsl_dev_ops = {
-        .connect = (connect_func) &graph_visualizer_connection
-};
+static void graph_vsl_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
+{
+        visualizer_t *vsl;
 
-static ddf_dev_ops_t graph_fun_ops = {
-        .interfaces[GRAPH_DEV_IFACE] = &graph_vsl_dev_ops
-};
+        vsl = (visualizer_t *) ddf_fun_data_get((ddf_fun_t *)arg);
+        graph_visualizer_connection(vsl, iid, icall, NULL);
+}
 
 static int amdm37x_dispc_dev_add(ddf_dev_t *dev)
@@ -74 +74 @@
         vis->reg_svc_handle = ddf_fun_get_handle(fun);
 
-        ddf_fun_set_ops(fun, &graph_fun_ops);
+        ddf_fun_set_conn_handler(fun, graph_vsl_connection);
         /* Hw part */
         amdm37x_dispc_t *dispc =

uspace/drv/fb/kfb/kfb.c

@@ -40 +40 @@
 #include <task.h>
 #include <graph.h>
-#include <ops/graph_dev.h>
 #include "port.h"
 #include "kfb.h"
@@ -60 +59 @@
 };
 
-static graph_dev_ops_t graph_vsl_dev_ops = {
-        .connect = (connect_func) &graph_visualizer_connection
-};
-
-ddf_dev_ops_t graph_vsl_device_ops = {
-        .interfaces[GRAPH_DEV_IFACE] = &graph_vsl_dev_ops
-};
-
-static graph_dev_ops_t graph_rnd_dev_ops = {
-        .connect = (connect_func) &graph_renderer_connection
-};
-
-ddf_dev_ops_t graph_rnd_device_ops = {
-        .interfaces[GRAPH_DEV_IFACE] = &graph_rnd_dev_ops
-};
-
 int main(int argc, char *argv[])
 {

uspace/drv/fb/kfb/port.c

@@ -207 +207 @@
 };
 
+static void graph_vsl_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
+{
+        visualizer_t *vsl;
+
+        vsl = (visualizer_t *) ddf_fun_data_get((ddf_fun_t *)arg);
+        graph_visualizer_connection(vsl, iid, icall, NULL);
+}
+
 int port_init(ddf_dev_t *dev)
 {
@@ -346 +354 @@
                 return ENOMEM;
         }
-        ddf_fun_set_ops(fun_vs, &graph_vsl_device_ops);
+        ddf_fun_set_conn_handler(fun_vs, &graph_vsl_connection);
 
         visualizer_t *vs = ddf_fun_data_alloc(fun_vs, sizeof(visualizer_t));

uspace/lib/c/arch/amd64/src/stacktrace.c

@@ -51 +51 @@
 int stacktrace_fp_prev(stacktrace_t *st, uintptr_t fp, uintptr_t *prev)
 {
-        return (*st->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_FP_PREV, prev);
+        return (*st->ops->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_FP_PREV, prev);
 }
 
 int stacktrace_ra_get(stacktrace_t *st, uintptr_t fp, uintptr_t *ra)
 {
-        return (*st->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_RA, ra);
+        return (*st->ops->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_RA, ra);
 }
 

uspace/lib/c/arch/arm32/src/stacktrace.c

@@ -51 +51 @@
 int stacktrace_fp_prev(stacktrace_t *st, uintptr_t fp, uintptr_t *prev)
 {
-        return (*st->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_FP_PREV, prev);
+        return (*st->ops->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_FP_PREV, prev);
 }
 
 int stacktrace_ra_get(stacktrace_t *st, uintptr_t fp, uintptr_t *ra)
 {
-        return (*st->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_RA, ra);
+        return (*st->ops->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_RA, ra);
 }
 

uspace/lib/c/arch/ia32/src/stacktrace.c

@@ -51 +51 @@
 int stacktrace_fp_prev(stacktrace_t *st, uintptr_t fp, uintptr_t *prev)
 {
-        return (*st->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_FP_PREV, prev);
+        return (*st->ops->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_FP_PREV, prev);
 }
 
 int stacktrace_ra_get(stacktrace_t *st, uintptr_t fp, uintptr_t *ra)
 {
-        return (*st->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_RA, ra);
+        return (*st->ops->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_RA, ra);
 }
 

uspace/lib/c/arch/ppc32/src/stacktrace.c

@@ -51 +51 @@
 int stacktrace_fp_prev(stacktrace_t *st, uintptr_t fp, uintptr_t *prev)
 {
-        return (*st->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_FP_PREV, prev);
+        return (*st->ops->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_FP_PREV, prev);
 }
 
 int stacktrace_ra_get(stacktrace_t *st, uintptr_t fp, uintptr_t *ra)
 {
-        return (*st->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_RA, ra);
+        return (*st->ops->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_RA, ra);
 }
 

uspace/lib/c/arch/sparc32/src/stacktrace.c

@@ -53 +53 @@
 {
         uintptr_t bprev;
-        int rc = (*st->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_FP_PREV,
+        int rc = (*st->ops->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_FP_PREV,
             &bprev);
         if (rc == EOK)
@@ -63 +63 @@
 int stacktrace_ra_get(stacktrace_t *st, uintptr_t fp, uintptr_t *ra)
 {
-        return (*st->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_RA, ra);
+        return (*st->ops->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_RA, ra);
 }
 

uspace/lib/c/arch/sparc64/src/stacktrace.c

@@ -55 +55 @@
         int rc;
 
-        rc = (*st->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_FP_PREV, &bprev);
+        rc = (*st->ops->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_FP_PREV, &bprev);
         if (rc == EOK)
                 *prev = bprev + STACK_BIAS;
@@ -63 +63 @@
 int stacktrace_ra_get(stacktrace_t *st, uintptr_t fp, uintptr_t *ra)
 {
-        return (*st->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_RA, ra);
+        return (*st->ops->read_uintptr)(st->op_arg, fp + FRAME_OFFSET_RA, ra);
 }
 

uspace/lib/c/generic/fibril.c

@@ -59 +59 @@
 static LIST_INITIALIZE(serialized_list);
 static LIST_INITIALIZE(manager_list);
+static LIST_INITIALIZE(fibril_list);
 
 /** Number of threads that are executing a manager fibril. */
@@ -116 +117 @@
         
         fibril->waits_for = NULL;
+        list_append(&fibril->all_link, &fibril_list);
         
         return fibril;
@@ -122 +124 @@
 void fibril_teardown(fibril_t *fibril)
 {
+        list_remove(&fibril->all_link);
         tls_free(fibril->tcb);
         free(fibril);

uspace/lib/c/generic/fibril_synch.c

@@ -448 +448 @@
         int rc;
 
-        fibril_mutex_lock(&timer->lock);
-
-        while (true) {
-                while (timer->state != fts_active &&
-                    timer->state != fts_cleanup) {
-
-                        if (timer->state == fts_cleanup)
-                                break;
-
-                        fibril_condvar_wait(&timer->cv, &timer->lock);
+        fibril_mutex_lock(timer->lockp);
+
+        while (timer->state != fts_cleanup) {
+                switch (timer->state) {
+                case fts_not_set:
+                case fts_fired:
+                        fibril_condvar_wait(&timer->cv, timer->lockp);
+                        break;
+                case fts_active:
+                        rc = fibril_condvar_wait_timeout(&timer->cv,
+                            timer->lockp, timer->delay);
+                        if (rc == ETIMEOUT && timer->state == fts_active) {
+                                timer->state = fts_fired;
+                                timer->handler_running = true;
+                                fibril_mutex_unlock(timer->lockp);
+                                timer->fun(timer->arg);
+                                fibril_mutex_lock(timer->lockp);
+                                timer->handler_running = false;
+                        }
+                        break;
+                case fts_cleanup:
+                case fts_clean:
+                        assert(false);
+                        break;
                 }
-
-                if (timer->state == fts_cleanup)
-                        break;
-
-                rc = fibril_condvar_wait_timeout(&timer->cv, &timer->lock,
-                    timer->delay);
-                if (rc == ETIMEOUT) {
-                        timer->state = fts_fired;
-                        fibril_mutex_unlock(&timer->lock);
-                        timer->fun(timer->arg);
-                        fibril_mutex_lock(&timer->lock);
-                }
-        }
-
-        fibril_mutex_unlock(&timer->lock);
+        }
+
+        /* Acknowledge timer fibril has finished cleanup. */
+        timer->state = fts_clean;
+        fibril_mutex_unlock(timer->lockp);
+        free(timer);
+
         return 0;
 }
@@ -481 +487 @@
  * @return              New timer on success, @c NULL if out of memory.
  */
-fibril_timer_t *fibril_timer_create(void)
+fibril_timer_t *fibril_timer_create(fibril_mutex_t *lock)
 {
         fid_t fid;
@@ -501 +507 @@
         timer->fibril = fid;
         timer->state = fts_not_set;
+        timer->lockp = (lock != NULL) ? lock : &timer->lock;
 
         fibril_add_ready(fid);
-
         return timer;
 }
@@ -513 +519 @@
 void fibril_timer_destroy(fibril_timer_t *timer)
 {
-        fibril_mutex_lock(&timer->lock);
-        assert(timer->state != fts_active);
+        fibril_mutex_lock(timer->lockp);
+        assert(timer->state == fts_not_set || timer->state == fts_fired);
+
+        /* Request timer fibril to terminate. */
         timer->state = fts_cleanup;
         fibril_condvar_broadcast(&timer->cv);
-        fibril_mutex_unlock(&timer->lock);
+        fibril_mutex_unlock(timer->lockp);
 }
 
@@ -533 +541 @@
     fibril_timer_fun_t fun, void *arg)
 {
-        fibril_mutex_lock(&timer->lock);
+        fibril_mutex_lock(timer->lockp);
+        fibril_timer_set_locked(timer, delay, fun, arg);
+        fibril_mutex_unlock(timer->lockp);
+}
+
+/** Set locked timer.
+ *
+ * Set timer to execute a callback function after the specified
+ * interval. Must be called when the timer is locked.
+ *
+ * @param timer         Timer
+ * @param delay         Delay in microseconds
+ * @param fun           Callback function
+ * @param arg           Argument for @a fun
+ */
+void fibril_timer_set_locked(fibril_timer_t *timer, suseconds_t delay,
+    fibril_timer_fun_t fun, void *arg)
+{
+        assert(fibril_mutex_is_locked(timer->lockp));
+        assert(timer->state == fts_not_set || timer->state == fts_fired);
         timer->state = fts_active;
         timer->delay = delay;
@@ -539 +566 @@
         timer->arg = arg;
         fibril_condvar_broadcast(&timer->cv);
-        fibril_mutex_unlock(&timer->lock);
 }
 
@@ -557 +583 @@
         fibril_timer_state_t old_state;
 
-        fibril_mutex_lock(&timer->lock);
+        fibril_mutex_lock(timer->lockp);
+        old_state = fibril_timer_clear_locked(timer);
+        fibril_mutex_unlock(timer->lockp);
+
+        return old_state;
+}
+
+/** Clear locked timer.
+ *
+ * Clears (cancels) timer and returns last state of the timer.
+ * This can be one of:
+ *    - fts_not_set     If the timer has not been set or has been cleared
+ *    - fts_active      Timer was set but did not fire
+ *    - fts_fired       Timer fired
+ * Must be called when the timer is locked.
+ *
+ * @param timer         Timer
+ * @return              Last timer state
+ */
+fibril_timer_state_t fibril_timer_clear_locked(fibril_timer_t *timer)
+{
+        fibril_timer_state_t old_state;
+
+        assert(fibril_mutex_is_locked(timer->lockp));
+
+        while (timer->handler_running)
+                fibril_condvar_wait(&timer->cv, timer->lockp);
+
         old_state = timer->state;
         timer->state = fts_not_set;
@@ -565 +618 @@
         timer->arg = NULL;
         fibril_condvar_broadcast(&timer->cv);
-        fibril_mutex_unlock(&timer->lock);
 
         return old_state;

uspace/lib/c/generic/inet.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2012 Jiri Svoboda
+ * Copyright (c) 2013 Jiri Svoboda
  * All rights reserved.
  *
@@ -34 +34 @@
 #include <ipc/services.h>
 #include <loc.h>
+#include <stdlib.h>
 
 static void inet_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
@@ -224 +225 @@
         
         rc = inet_ev_ops->recv(&dgram);
+        free(dgram.data);
         async_answer_0(iid, rc);
 }

uspace/lib/c/generic/stacktrace.c

@@ -42 +42 @@
 static int stacktrace_read_uintptr(void *arg, uintptr_t addr, uintptr_t *data);
 
-void stacktrace_print_fp_pc(uintptr_t fp, uintptr_t pc)
+static stacktrace_ops_t basic_ops = {
+        .read_uintptr = stacktrace_read_uintptr
+};
+
+void stacktrace_print_generic(stacktrace_ops_t *ops, void *arg, uintptr_t fp,
+    uintptr_t pc)
 {
         stacktrace_t st;
         uintptr_t nfp;
+        int rc;
 
-        st.op_arg = NULL;
-        st.read_uintptr = stacktrace_read_uintptr;
+        st.op_arg = arg;
+        st.ops = ops;
 
         while (stacktrace_fp_valid(&st, fp)) {
                 printf("%p: %p()\n", (void *) fp, (void *) pc);
-                (void) stacktrace_ra_get(&st, fp, &pc);
-                (void) stacktrace_fp_prev(&st, fp, &nfp);
+                rc =  stacktrace_ra_get(&st, fp, &pc);
+                if (rc != EOK)
+                        break;
+                rc = stacktrace_fp_prev(&st, fp, &nfp);
+                if (rc != EOK)
+                        break;
                 fp = nfp;
         }
+}
+
+void stacktrace_print_fp_pc(uintptr_t fp, uintptr_t pc)
+{
+        stacktrace_print_generic(&basic_ops, NULL, fp, pc);
 }
 

uspace/lib/c/generic/str.c

@@ -1360 +1360 @@
 }
 
-char *strtok(char *s, const char *delim)
-{
-        static char *next;
-
-        return strtok_r(s, delim, &next);
-}
-
-char *strtok_r(char *s, const char *delim, char **next)
+/** Split string by delimiters.
+ *
+ * @param s             String to be tokenized. May not be NULL.
+ * @param delim         String with the delimiters.
+ * @param next          Variable which will receive the pointer to the
+ *                      continuation of the string following the first
+ *                      occurrence of any of the delimiter characters.
+ *                      May be NULL.
+ * @return              Pointer to the prefix of @a s before the first
+ *                      delimiter character. NULL if no such prefix
+ *                      exists.
+ */
+char *str_tok(char *s, const char *delim, char **next)
 {
         char *start, *end;
 
-        if (s == NULL)
-                s = *next;
+        if (!s)
+                return NULL;
+        
+        size_t len = str_size(s);
+        size_t cur;
+        size_t tmp;
+        wchar_t ch;
 
         /* Skip over leading delimiters. */
-        while (*s && (str_chr(delim, *s) != NULL)) ++s;
-        start = s;
+        for (tmp = cur = 0;
+            (ch = str_decode(s, &tmp, len)) && str_chr(delim, ch); /**/)
+                cur = tmp;
+        start = &s[cur];
 
         /* Skip over token characters. */
-        while (*s && (str_chr(delim, *s) == NULL)) ++s;
-        end = s;
-        *next = (*s ? s + 1 : s);
-
-        if (start == end) {
+        for (tmp = cur;
+            (ch = str_decode(s, &tmp, len)) && !str_chr(delim, ch); /**/)
+                cur = tmp;
+        end = &s[cur];
+        if (next)
+                *next = (ch ? &s[tmp] : &s[cur]);
+
+        if (start == end)
                 return NULL;    /* No more tokens. */
-        }
 
         /* Overwrite delimiter with NULL terminator. */

uspace/lib/c/include/fibril.h

@@ -67 +67 @@
 typedef struct fibril {
         link_t link;
+        link_t all_link;
         context_t ctx;
         void *stack;

uspace/lib/c/include/fibril_synch.h

@@ -116 +116 @@
         /** Timer has fired and has not been cleared since */
         fts_fired,
-        /** Timer is being destroyed */
-        fts_cleanup
+        /** Timer fibril is requested to terminate */
+        fts_cleanup,
+        /** Timer fibril acknowledged termination */
+        fts_clean
 } fibril_timer_state_t;
 
@@ -129 +131 @@
 typedef struct {
         fibril_mutex_t lock;
+        fibril_mutex_t *lockp;
         fibril_condvar_t cv;
         fid_t fibril;
         fibril_timer_state_t state;
+        bool handler_running;
 
         suseconds_t delay;
@@ -160 +164 @@
 extern void fibril_condvar_broadcast(fibril_condvar_t *);
 
-extern fibril_timer_t *fibril_timer_create(void);
+extern fibril_timer_t *fibril_timer_create(fibril_mutex_t *);
 extern void fibril_timer_destroy(fibril_timer_t *);
 extern void fibril_timer_set(fibril_timer_t *, suseconds_t, fibril_timer_fun_t,
     void *);
+extern void fibril_timer_set_locked(fibril_timer_t *, suseconds_t,
+    fibril_timer_fun_t, void *);
 extern fibril_timer_state_t fibril_timer_clear(fibril_timer_t *);
+extern fibril_timer_state_t fibril_timer_clear_locked(fibril_timer_t *);
 
 #endif

uspace/lib/c/include/ipc/dev_iface.h

@@ -40 +40 @@
         /** Character device interface */
         CHAR_DEV_IFACE,
-
-        /** Graphic device interface */
-        GRAPH_DEV_IFACE,
 
         /** Audio device mixer interface */

uspace/lib/c/include/stacktrace.h

@@ -41 +41 @@
 
 typedef struct {
+        int (*read_uintptr)(void *, uintptr_t, uintptr_t *);
+} stacktrace_ops_t;
+
+typedef struct {
         void *op_arg;
-        int (*read_uintptr)(void *, uintptr_t, uintptr_t *);
+        stacktrace_ops_t *ops;
 } stacktrace_t;
 
 extern void stacktrace_print(void);
 extern void stacktrace_print_fp_pc(uintptr_t, uintptr_t);
+extern void stacktrace_print_generic(stacktrace_ops_t *, void *, uintptr_t,
+    uintptr_t);
 
 /*

uspace/lib/c/include/str.h

@@ -109 +109 @@
 extern char *str_ndup(const char *, size_t max_size);
 
+extern char *str_tok(char *, const char *, char **);
+
 extern int str_uint8_t(const char *, const char **, unsigned int, bool,
     uint8_t *);
@@ -132 +134 @@
 extern unsigned long strtoul(const char *, char **, int);
 
-extern char * strtok_r(char *, const char *, char **);
-extern char * strtok(char *, const char *);
-
 #endif
 

uspace/lib/drv/Makefile

@@ -47 +47 @@
         generic/remote_pio_window.c \
         generic/remote_char_dev.c \
-        generic/remote_graph_dev.c \
         generic/remote_nic.c \
         generic/remote_usb.c \

uspace/lib/drv/generic/dev_iface.c

@@ -45 +45 @@
 #include "remote_led_dev.h"
 #include "remote_battery_dev.h"
-#include "remote_graph_dev.h"
 #include "remote_nic.h"
 #include "remote_usb.h"
@@ -62 +61 @@
                 [PIO_WINDOW_DEV_IFACE] = &remote_pio_window_iface,
                 [CHAR_DEV_IFACE] = &remote_char_dev_iface,
-                [GRAPH_DEV_IFACE] = &remote_graph_dev_iface,
                 [NIC_DEV_IFACE] = &remote_nic_iface,
                 [PCI_DEV_IFACE] = &remote_pci_iface,

uspace/lib/graph/graph.c

@@ -58 +58 @@
 visualizer_t *graph_alloc_visualizer(void)
 {
-        visualizer_t *vs = (visualizer_t *) malloc(sizeof(visualizer_t));
-        if (vs == NULL) {
-                return NULL;
-        }
-        
-        return vs;
+        return ((visualizer_t *) malloc(sizeof(visualizer_t)));
 }
 
@@ -69 +64 @@
 {
         // TODO
-        renderer_t *rnd = (renderer_t *) malloc(sizeof(renderer_t));
-        if (rnd == NULL) {
-                return NULL;
-        }
-
-        return rnd;
+        return ((renderer_t *) malloc(sizeof(renderer_t)));
 }
 
@@ -98 +88 @@
 int graph_register_visualizer(visualizer_t *vs)
 {
-        int rc = EOK;
-        
         char node[LOC_NAME_MAXLEN + 1];
         snprintf(node, LOC_NAME_MAXLEN, "%s%zu/%s%zu", NAMESPACE,
             namespace_idx, VISUALIZER_NAME, visualizer_idx++);
-
+        
         category_id_t cat;
-        rc = loc_category_get_id("visualizer", &cat, 0);
-        if (rc != EOK) {
+        int rc = loc_category_get_id("visualizer", &cat, 0);
+        if (rc != EOK)
                 return rc;
-        }
-
+        
         rc = loc_service_register(node, &vs->reg_svc_handle);
-        if (rc != EOK) {
+        if (rc != EOK)
                 return rc;
-        }
-
+        
         rc = loc_service_add_to_cat(vs->reg_svc_handle, cat);
         if (rc != EOK) {
@@ -120 +106 @@
                 return rc;
         }
-
+        
         fibril_mutex_lock(&visualizer_list_mtx);
         list_append(&vs->link, &visualizer_list);
         fibril_mutex_unlock(&visualizer_list_mtx);
-
+        
         return rc;
 }
@@ -130 +116 @@
 int graph_register_renderer(renderer_t *rnd)
 {
-        int rc = EOK;
-
         char node[LOC_NAME_MAXLEN + 1];
         snprintf(node, LOC_NAME_MAXLEN, "%s%zu/%s%zu", NAMESPACE,
             namespace_idx, RENDERER_NAME, renderer_idx++);
-
+        
         category_id_t cat;
-        rc = loc_category_get_id("renderer", &cat, 0);
-        if (rc != EOK) {
+        int rc = loc_category_get_id("renderer", &cat, 0);
+        if (rc != EOK)
                 return rc;
-        }
-
+        
         rc = loc_service_register(node, &rnd->reg_svc_handle);
-        if (rc != EOK) {
+        if (rc != EOK)
                 return rc;
-        }
-
+        
         rc = loc_service_add_to_cat(rnd->reg_svc_handle, cat);
         if (rc != EOK) {
@@ -152 +134 @@
                 return rc;
         }
-
+        
         fibril_mutex_lock(&renderer_list_mtx);
         list_append(&rnd->link, &renderer_list);
         fibril_mutex_unlock(&renderer_list_mtx);
-
+        
         return rc;
 }
@@ -163 +145 @@
 {
         visualizer_t *vs = NULL;
-
+        
         fibril_mutex_lock(&visualizer_list_mtx);
+        
         list_foreach(visualizer_list, link, visualizer_t, vcur) {
                 if (vcur->reg_svc_handle == handle) {
@@ -171 +154 @@
                 }
         }
+        
         fibril_mutex_unlock(&visualizer_list_mtx);
-
+        
         return vs;
 }
@@ -179 +163 @@
 {
         renderer_t *rnd = NULL;
-
+        
         fibril_mutex_lock(&renderer_list_mtx);
+        
         list_foreach(renderer_list, link, renderer_t, rcur) {
                 if (rcur->reg_svc_handle == handle) {
@@ -187 +172 @@
                 }
         }
+        
         fibril_mutex_unlock(&renderer_list_mtx);
-
+        
         return rnd;
 }
@@ -194 +180 @@
 int graph_unregister_visualizer(visualizer_t *vs)
 {
-        int rc = EOK;
-
         fibril_mutex_lock(&visualizer_list_mtx);
-        rc = loc_service_unregister(vs->reg_svc_handle);
+        int rc = loc_service_unregister(vs->reg_svc_handle);
         list_remove(&vs->link);
         fibril_mutex_unlock(&visualizer_list_mtx);
-
+        
         return rc;
 }
@@ -206 +190 @@
 int graph_unregister_renderer(renderer_t *rnd)
 {
-        int rc = EOK;
-
         fibril_mutex_lock(&renderer_list_mtx);
-        rc = loc_service_unregister(rnd->reg_svc_handle);
+        int rc = loc_service_unregister(rnd->reg_svc_handle);
         list_remove(&rnd->link);
         fibril_mutex_unlock(&renderer_list_mtx);
-
+        
         return rc;
 }
@@ -225 +207 @@
         assert(vs->cells.data == NULL);
         assert(vs->dev_ctx == NULL);
-
+        
         free(vs);
 }
@@ -233 +215 @@
         // TODO
         assert(atomic_get(&rnd->ref_cnt) == 0);
-
+        
         free(rnd);
 }
@@ -242 +224 @@
         int ret = async_req_2_0(exch, VISUALIZER_MODE_CHANGE, handle, mode_idx);
         async_exchange_end(exch);
-
+        
         return ret;
 }
@@ -251 +233 @@
         int ret = async_req_1_0(exch, VISUALIZER_DISCONNECT, handle);
         async_exchange_end(exch);
-
+        
         async_hangup(sess);
-
+        
         return ret;
 }
@@ -273 +255 @@
                 }
         }
-
+        
         /* Driver might also deallocate resources for the current mode. */
         int rc = vs->ops.yield(vs);
-
+        
         /* Now that the driver was given a chance to deallocate resources,
          * current mode can be unset. */
-        if (vs->mode_set) {
+        if (vs->mode_set)
                 vs->mode_set = false;
-        }
-
+        
         async_answer_0(iid, rc);
 }
@@ -288 +269 @@
 static void vs_enumerate_modes(visualizer_t *vs, ipc_callid_t iid, ipc_call_t *icall)
 {
+        ipc_callid_t callid;
+        size_t len;
+        
+        if (!async_data_read_receive(&callid, &len)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
         fibril_mutex_lock(&vs->mode_mtx);
         link_t *link = list_nth(&vs->modes, IPC_GET_ARG1(*icall));
-
+        
         if (link != NULL) {
                 vslmode_list_element_t *mode_elem =
                     list_get_instance(link, vslmode_list_element_t, link);
-                vslmode_t mode = mode_elem->mode;
-                fibril_mutex_unlock(&vs->mode_mtx);
-
-                ipc_callid_t callid;
-                size_t len;
-
-        if (!async_data_read_receive(&callid, &len)) {
-                        async_answer_0(iid, EINVAL);
-                        return;
-        }
-        int rc = async_data_read_finalize(callid, &mode, len);
-                if (rc != EOK) {
-                        async_answer_0(iid, ENOMEM);
-                        return;
-                }
-
-                async_answer_0(iid, EOK);
+                
+                int rc = async_data_read_finalize(callid, &mode_elem->mode, len);
+                async_answer_0(iid, rc);
         } else {
+                async_answer_0(callid, ENOENT);
                 async_answer_0(iid, ENOENT);
         }
+        
+        fibril_mutex_unlock(&vs->mode_mtx);
 }
 
 static void vs_get_default_mode(visualizer_t *vs, ipc_callid_t iid, ipc_call_t *icall)
 {
+        ipc_callid_t callid;
+        size_t len;
+        
+        if (!async_data_read_receive(&callid, &len)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
         fibril_mutex_lock(&vs->mode_mtx);
         vslmode_list_element_t *mode_elem = NULL;
+        
         list_foreach(vs->modes, link, vslmode_list_element_t, cur) {
                 if (cur->mode.index == vs->def_mode_idx) {
@@ -326 +315 @@
                 }
         }
-
-        vslmode_t mode;
+        
         if (mode_elem != NULL) {
-                mode = mode_elem->mode;
-                fibril_mutex_unlock(&vs->mode_mtx);
-
-                ipc_callid_t callid;
-                size_t len;
-
-                if (!async_data_read_receive(&callid, &len)) {
-                        async_answer_0(iid, EINVAL);
-                        return;
-                }
-                int rc = async_data_read_finalize(callid, &mode, len);
-                if (rc != EOK) {
-                        async_answer_0(iid, ENOMEM);
-                        return;
-                }
-                async_answer_0(iid, EOK);
+                int rc = async_data_read_finalize(callid, &mode_elem->mode, len);
+                async_answer_0(iid, rc);
         } else {
                 fibril_mutex_unlock(&vs->mode_mtx);
+                async_answer_0(callid, ENOENT);
                 async_answer_0(iid, ENOENT);
         }
+        
+        fibril_mutex_unlock(&vs->mode_mtx);
 }
 
 static void vs_get_current_mode(visualizer_t *vs, ipc_callid_t iid, ipc_call_t *icall)
 {
+        ipc_callid_t callid;
+        size_t len;
+        
+        if (!async_data_read_receive(&callid, &len)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
         if (vs->mode_set) {
-                ipc_callid_t callid;
-                size_t len;
-
-                if (!async_data_read_receive(&callid, &len)) {
-                        async_answer_0(iid, EINVAL);
-                        return;
-                }
                 int rc = async_data_read_finalize(callid, &vs->cur_mode, len);
-                if (rc != EOK) {
-                        async_answer_0(iid, ENOMEM);
-                        return;
-                }
-
-                async_answer_0(iid, EOK);
+                async_answer_0(iid, rc);
         } else {
+                async_answer_0(callid, ENOENT);
                 async_answer_0(iid, ENOENT);
         }
@@ -375 +350 @@
 static void vs_get_mode(visualizer_t *vs, ipc_callid_t iid, ipc_call_t *icall)
 {
+        ipc_callid_t callid;
+        size_t len;
+        
+        if (!async_data_read_receive(&callid, &len)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
         sysarg_t mode_idx = IPC_GET_ARG1(*icall);
-
+        
         fibril_mutex_lock(&vs->mode_mtx);
         vslmode_list_element_t *mode_elem = NULL;
+        
         list_foreach(vs->modes, link, vslmode_list_element_t, cur) {
                 if (cur->mode.index == mode_idx) {
@@ -385 +370 @@
                 }
         }
-
-        vslmode_t mode;
+        
         if (mode_elem != NULL) {
-                mode = mode_elem->mode;
-                fibril_mutex_unlock(&vs->mode_mtx);
-
-                ipc_callid_t callid;
-                size_t len;
-
-                if (!async_data_read_receive(&callid, &len)) {
-                        async_answer_0(iid, EINVAL);
-                        return;
-                }
-                int rc = async_data_read_finalize(callid, &mode, len);
-                if (rc != EOK) {
-                        async_answer_0(iid, ENOMEM);
-                        return;
-                }
-                async_answer_0(iid, EOK);
+                int rc = async_data_read_finalize(callid, &mode_elem->mode, len);
+                async_answer_0(iid, rc);
         } else {
-                fibril_mutex_unlock(&vs->mode_mtx);
+                async_answer_0(callid, ENOENT);
                 async_answer_0(iid, ENOENT);
         }
+        
+        fibril_mutex_unlock(&vs->mode_mtx);
 }
 
 static void vs_set_mode(visualizer_t *vs, ipc_callid_t iid, ipc_call_t *icall)
 {
-        int rc = EOK;
-
+        ipc_callid_t callid;
+        size_t size;
+        unsigned int flags;
+        
+        /* Retrieve the shared cell storage for the new mode. */
+        if (!async_share_out_receive(&callid, &size, &flags)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
         /* Retrieve mode index and version. */
         sysarg_t mode_idx = IPC_GET_ARG1(*icall);
         sysarg_t mode_version = IPC_GET_ARG2(*icall);
-
+        
         /* Find mode in the list. */
         fibril_mutex_lock(&vs->mode_mtx);
         vslmode_list_element_t *mode_elem = NULL;
+        
         list_foreach(vs->modes, link, vslmode_list_element_t, cur) {
                 if (cur->mode.index == mode_idx) {
@@ -427 +409 @@
                 }
         }
-
+        
+        if (mode_elem == NULL) {
+                fibril_mutex_unlock(&vs->mode_mtx);
+                async_answer_0(callid, ENOENT);
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
         /* Extract mode description from the list node. */
-        vslmode_t new_mode;
-        if (mode_elem != NULL) {
-                new_mode = mode_elem->mode;
-                fibril_mutex_unlock(&vs->mode_mtx);
-        } else {
-                fibril_mutex_unlock(&vs->mode_mtx);
-                async_answer_0(iid, ENOENT);
-                return;
-        }
-
+        vslmode_t new_mode = mode_elem->mode;
+        fibril_mutex_unlock(&vs->mode_mtx);
+        
         /* Check whether the mode is still up-to-date. */
         if (new_mode.version != mode_version) {
+                async_answer_0(callid, EINVAL);
                 async_answer_0(iid, EINVAL);
                 return;
         }
-
-        ipc_callid_t callid;
-        size_t size;
-        unsigned int flags;
-
-        /* Retrieve the shared cell storage for the new mode. */
-        if (!async_share_out_receive(&callid, &size, &flags)) {
-                async_answer_0(iid, EINVAL);
-                return;
-        }
+        
         void *new_cell_storage;
-        rc = async_share_out_finalize(callid, &new_cell_storage);
+        int rc = async_share_out_finalize(callid, &new_cell_storage);
         if ((rc != EOK) || (new_cell_storage == AS_MAP_FAILED)) {
                 async_answer_0(iid, ENOMEM);
                 return;
         }
-
+        
         /* Change device internal state. */
         rc = vs->ops.change_mode(vs, new_mode);
-
+        
         /* Device driver could not establish new mode. Rollback. */
         if (rc != EOK) {
@@ -470 +444 @@
                 return;
         }
-
-        /* Because resources for the new mode were successfully claimed,
-         * it is finally possible to free resources allocated for the old mode. */
+        
+        /*
+         * Because resources for the new mode were successfully
+         * claimed, it is finally possible to free resources
+         * allocated for the old mode.
+         */
         if (vs->mode_set) {
                 if (vs->cells.data != NULL) {
@@ -479 +456 @@
                 }
         }
-
+        
         /* Insert new mode into the visualizer. */
         vs->cells.width = new_mode.screen_width;
@@ -486 +463 @@
         vs->cur_mode = new_mode;
         vs->mode_set = true;
-
+        
         async_answer_0(iid, EOK);
 }
@@ -499 +476 @@
         sysarg_t y_offset = (IPC_GET_ARG5(*icall) & 0xffffffff);
 #endif
-
+        
         int rc = vs->ops.handle_damage(vs,
             IPC_GET_ARG1(*icall), IPC_GET_ARG2(*icall),
             IPC_GET_ARG3(*icall), IPC_GET_ARG4(*icall),
-                x_offset, y_offset);
+            x_offset, y_offset);
         async_answer_0(iid, rc);
 }
@@ -524 +501 @@
         ipc_call_t call;
         ipc_callid_t callid;
-
+        
         /* Claim the visualizer. */
         if (!cas(&vs->ref_cnt, 0, 1)) {
@@ -530 +507 @@
                 return;
         }
-
+        
         /* Accept the connection. */
         async_answer_0(iid, EOK);
-
+        
         /* Establish callback session. */
         callid = async_get_call(&call);
         vs->notif_sess = async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
-        if (vs->notif_sess != NULL) {
+        if (vs->notif_sess != NULL)
                 async_answer_0(callid, EOK);
-        } else {
+        else
                 async_answer_0(callid, ELIMIT);
-        }
-
+        
         /* Enter command loop. */
         while (true) {
                 callid = async_get_call(&call);
-
+                
                 if (!IPC_GET_IMETHOD(call)) {
                         async_answer_0(callid, EINVAL);
                         break;
                 }
-
+                
                 switch (IPC_GET_IMETHOD(call)) {
                 case VISUALIZER_CLAIM:
@@ -588 +564 @@
                 }
         }
-
+        
 terminate:
         async_hangup(vs->notif_sess);
@@ -599 +575 @@
 {
         // TODO
-
+        
         ipc_call_t call;
         ipc_callid_t callid;
-
+        
         /* Accept the connection. */
         atomic_inc(&rnd->ref_cnt);
         async_answer_0(iid, EOK);
-
+        
         /* Enter command loop. */
         while (true) {
                 callid = async_get_call(&call);
-
+                
                 if (!IPC_GET_IMETHOD(call)) {
                         async_answer_0(callid, EINVAL);
                         break;
                 }
-
+                
                 switch (IPC_GET_IMETHOD(call)) {
                 default:
@@ -622 +598 @@
                 }
         }
-
+        
 terminate:
         atomic_dec(&rnd->ref_cnt);
@@ -632 +608 @@
         visualizer_t *vs = graph_get_visualizer(IPC_GET_ARG1(*icall));
         renderer_t *rnd = graph_get_renderer(IPC_GET_ARG1(*icall));
-
-        if (vs != NULL) {
+        
+        if (vs != NULL)
                 graph_visualizer_connection(vs, iid, icall, arg);
-        } else if (rnd != NULL) {
+        else if (rnd != NULL)
                 graph_renderer_connection(rnd, iid, icall, arg);
-        } else {
+        else
                 async_answer_0(iid, ENOENT);
-        }
 }
 

uspace/srv/devman/main.c

@@ -116 +116 @@
                 
                 fwd_h = dev->pfun->handle;
-        } else if (dev->state == DEVICE_USABLE) {
+        } else {
                 /* Connect to the specified function */
                 driver = dev->drv;
-                assert(driver != NULL);
-                
                 fwd_h = handle;
         }

uspace/srv/fs/fat/fat_ops.c

@@ -930 +930 @@
         /* Parse mount options. */
         char *mntopts = (char *) opts;
-        char *saveptr;
         char *opt;
-        while ((opt = strtok_r(mntopts, " ,", &saveptr)) != NULL) {
+        while ((opt = str_tok(mntopts, " ,", &mntopts)) != NULL) {
                 if (str_cmp(opt, "wtcache") == 0)
                         cmode = CACHE_MODE_WT;
                 else if (str_cmp(opt, "nolfn") == 0)
                         instance->lfn_enabled = false;
-                mntopts = NULL;
         }
 

uspace/srv/hid/compositor/compositor.c

@@ -55 +55 @@
 #include <async.h>
 #include <loc.h>
-#include <devman.h>
 
 #include <event.h>
-#include <graph_iface.h>
 #include <io/keycode.h>
 #include <io/mode.h>
@@ -1149 +1147 @@
 }
 
-static async_sess_t *vsl_connect(const char *svc)
+static async_sess_t *vsl_connect(service_id_t sid, const char *svc)
 {
         int rc;
         async_sess_t *sess;
-        service_id_t dsid;
-        devman_handle_t handle;
-
-        rc = loc_service_get_id(svc, &dsid, 0);
-        if (rc != EOK) {
+
+        sess = loc_service_connect(EXCHANGE_SERIALIZE, sid, 0);
+        if (sess == NULL) {
+                printf("%s: Unable to connect to visualizer %s\n", NAME, svc);
                 return NULL;
         }
 
-        rc = devman_fun_sid_to_handle(dsid, &handle);
-        if (rc == EOK) {
-                sess = devman_device_connect(EXCHANGE_SERIALIZE, handle, 0);
-                if (sess == NULL) {
-                        printf("%s: Unable to connect to visualizer %s\n", NAME, svc);
-                        return NULL;
-                }
-                rc = graph_dev_connect(sess);
-                if (rc != EOK) {
-                        return NULL;
-                }
-        } else if (rc == ENOENT) {
-                sess = loc_service_connect(EXCHANGE_SERIALIZE, dsid, 0);
-                if (sess == NULL) {
-                        printf("%s: Unable to connect to visualizer %s\n", NAME, svc);
-                        return NULL;
-                }
-        } else {
-                return NULL;
-        }
-
         async_exch_t *exch = async_exchange_begin(sess);
-        rc = async_connect_to_me(exch, dsid, 0, 0, vsl_notifications, NULL);
+        rc = async_connect_to_me(exch, sid, 0, 0, vsl_notifications, NULL);
         async_exchange_end(exch);
 
@@ -1196 +1172 @@
 }
 
-static viewport_t *viewport_create(const char *vsl_name)
+static viewport_t *viewport_create(service_id_t sid)
 {
         int rc;
-
-        viewport_t *vp = (viewport_t *) malloc(sizeof(viewport_t));
-        if (!vp) {
-                return NULL;
-        }
+        char *vsl_name = NULL;
+        viewport_t *vp = NULL;
+        bool claimed = false;
+
+        rc = loc_service_get_name(sid, &vsl_name);
+        if (rc != EOK)
+                goto error;
+
+        vp = (viewport_t *) calloc(1, sizeof(viewport_t));
+        if (!vp)
+                goto error;
 
         link_initialize(&vp->link);
@@ -1210 +1192 @@
 
         /* Establish output bidirectional connection. */
-        vp->sess = vsl_connect(vsl_name);
-        rc = loc_service_get_id(vsl_name, &vp->dsid, 0);
-        if (vp->sess == NULL || rc != EOK) {
-                free(vp);
-                return NULL;
-        }
+        vp->dsid = sid;
+        vp->sess = vsl_connect(sid, vsl_name);
+        if (vp->sess == NULL)
+                goto error;
 
         /* Claim the given visualizer. */
         rc = visualizer_claim(vp->sess, 0);
         if (rc != EOK) {
-                async_hangup(vp->sess);
-                free(vp);
                 printf("%s: Unable to claim visualizer (%s)\n", NAME, str_error(rc));
-                return NULL;
-        }
+                goto error;
+        }
+
+        claimed = true;
 
         /* Retrieve the default mode. */
         rc = visualizer_get_default_mode(vp->sess, &vp->mode);
         if (rc != EOK) {
-                visualizer_yield(vp->sess);
-                async_hangup(vp->sess);
-                free(vp);
                 printf("%s: Unable to retrieve mode (%s)\n", NAME, str_error(rc));
-                return NULL;
+                goto error;
         }
 
@@ -1240 +1217 @@
             NULL, SURFACE_FLAG_SHARED);
         if (vp->surface == NULL) {
-                visualizer_yield(vp->sess);
-                async_hangup(vp->sess);
-                free(vp);
                 printf("%s: Unable to create surface (%s)\n", NAME, str_error(rc));
-                return NULL;
+                goto error;
         }
 
@@ -1251 +1225 @@
                 vp->mode.index, vp->mode.version, surface_direct_access(vp->surface));
         if (rc != EOK) {
+                printf("%s: Unable to set mode (%s)\n", NAME, str_error(rc));
+                goto error;
+        }
+
+        return vp;
+error:
+        if (claimed)
                 visualizer_yield(vp->sess);
-                surface_destroy(vp->surface);
+        if (vp->sess != NULL)
                 async_hangup(vp->sess);
-                free(vp);
-                printf("%s: Unable to set mode (%s)\n", NAME, str_error(rc));
-                return NULL;
-        }
-
-        return vp;
+        free(vp);
+        free(vsl_name);
+        return NULL;
 }
 
@@ -2190 +2168 @@
                         continue;
                 
-                char *svc_name;
-                rc = loc_service_get_name(svcs[i], &svc_name);
-                if (rc == EOK) {
-                        viewport_t *vp = viewport_create(svc_name);
-                        if (vp != NULL) {
-                                list_append(&vp->link, &viewport_list);
-                        }
-                }
+                viewport_t *vp = viewport_create(svcs[i]);
+                if (vp != NULL)
+                        list_append(&vp->link, &viewport_list);
         }
         fibril_mutex_unlock(&viewport_list_mtx);

uspace/srv/logger/initlvl.c

@@ -44 +44 @@
 {
         char *tmp;
-        char *key = strtok_r(setting, "=", &tmp);
-        char *value = strtok_r(NULL, "=", &tmp);
+        char *key = str_tok(setting, "=", &tmp);
+        char *value = str_tok(tmp, "=", &tmp);
         if (key == NULL)
                 return;
@@ -76 +76 @@
 {
         char *tmp;
-        char *single_setting = strtok_r(settings, " ", &tmp);
+        char *single_setting = str_tok(settings, " ", &tmp);
         while (single_setting != NULL) {
                 parse_single_level_setting(single_setting);
-                single_setting = strtok_r(NULL, " ", &tmp);
+                single_setting = str_tok(tmp, " ", &tmp);
         }
 }

uspace/srv/net/dhcp/dhcp.c

@@ -304 +304 @@
                         break;
                 case opt_dns_server:
-                        if (opt_len != 4)
+                        if (opt_len < 4 || opt_len % 4 != 0)
                                 return EINVAL;
+                        /* XXX Handle multiple DNS servers properly */
                         inet_addr_set(dhcp_uint32_decode(&msgb[i]),
                             &offer->dns_server);
@@ -435 +436 @@
 
         dlink->link_id = link_id;
-        dlink->timeout = fibril_timer_create();
+        dlink->timeout = fibril_timer_create(NULL);
         if (dlink->timeout == NULL) {
                 rc = ENOMEM;

uspace/srv/net/inetsrv/inetsrv.c

@@ -296 +296 @@
         
         uint8_t ttl = IPC_GET_ARG3(*icall);
-        int df = IPC_GET_ARG3(*icall);
+        int df = IPC_GET_ARG4(*icall);
         
         ipc_callid_t callid;

uspace/srv/net/tcp/conn.c

@@ -78 +78 @@
                 goto error;
 
-        conn->tw_timer = fibril_timer_create();
+        fibril_mutex_initialize(&conn->lock);
+
+        conn->tw_timer = fibril_timer_create(&conn->lock);
         if (conn->tw_timer == NULL)
                 goto error;
-
-        fibril_mutex_initialize(&conn->lock);
 
         /* One for the user, one for not being in closed state */
@@ -200 +200 @@
         if (atomic_predec(&conn->refcnt) == 0)
                 tcp_conn_free(conn);
+}
+
+/** Lock connection.
+ *
+ * Must be called before any other connection-manipulating function,
+ * except tcp_conn_{add|del}ref(). Locks the connection including
+ * its timers. Must not be called inside any of the connection
+ * timer handlers.
+ *
+ * @param conn          Connection
+ */
+void tcp_conn_lock(tcp_conn_t *conn)
+{
+        fibril_mutex_lock(&conn->lock);
+}
+
+/** Unlock connection.
+ *
+ * @param conn          Connection
+ */
+void tcp_conn_unlock(tcp_conn_t *conn)
+{
+        fibril_mutex_unlock(&conn->lock);
 }
 
@@ -1183 +1206 @@
         log_msg(LOG_DEFAULT, LVL_DEBUG, "tw_timeout_func(%p)", conn);
 
-        fibril_mutex_lock(&conn->lock);
+        tcp_conn_lock(conn);
 
         if (conn->cstate == st_closed) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Connection already closed.");
-                fibril_mutex_unlock(&conn->lock);
+                tcp_conn_unlock(conn);
                 tcp_conn_delref(conn);
                 return;
@@ -1196 +1219 @@
         tcp_conn_state_set(conn, st_closed);
 
-        fibril_mutex_unlock(&conn->lock);
+        tcp_conn_unlock(conn);
         tcp_conn_delref(conn);
+
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "tw_timeout_func(%p) end", conn);
 }
 
@@ -1206 +1231 @@
 void tcp_conn_tw_timer_set(tcp_conn_t *conn)
 {
+        log_msg(LOG_DEFAULT, LVL_DEBUG2, "tcp_conn_tw_timer_set() begin");
         tcp_conn_addref(conn);
-        fibril_timer_set(conn->tw_timer, TIME_WAIT_TIMEOUT, tw_timeout_func,
-            (void *)conn);
+        fibril_timer_set_locked(conn->tw_timer, TIME_WAIT_TIMEOUT,
+            tw_timeout_func, (void *)conn);
+        log_msg(LOG_DEFAULT, LVL_DEBUG2, "tcp_conn_tw_timer_set() end");
 }
 
@@ -1217 +1244 @@
 void tcp_conn_tw_timer_clear(tcp_conn_t *conn)
 {
-        if (fibril_timer_clear(conn->tw_timer) == fts_active)
+        log_msg(LOG_DEFAULT, LVL_DEBUG2, "tcp_conn_tw_timer_clear() begin");
+        if (fibril_timer_clear_locked(conn->tw_timer) == fts_active)
                 tcp_conn_delref(conn);
+        log_msg(LOG_DEFAULT, LVL_DEBUG2, "tcp_conn_tw_timer_clear() end");
 }
 

uspace/srv/net/tcp/conn.h

@@ -50 +50 @@
 extern void tcp_conn_addref(tcp_conn_t *);
 extern void tcp_conn_delref(tcp_conn_t *);
+extern void tcp_conn_lock(tcp_conn_t *);
+extern void tcp_conn_unlock(tcp_conn_t *);
 extern bool tcp_conn_got_syn(tcp_conn_t *);
 extern void tcp_conn_segment_arrived(tcp_conn_t *, tcp_segment_t *);

uspace/srv/net/tcp/iqueue.c

@@ -148 +148 @@
         list_remove(&iqe->link);
         *seg = iqe->seg;
+        free(iqe);
 
         return EOK;

uspace/srv/net/tcp/rqueue.c

@@ -141 +141 @@
 
                 tcp_as_segment_arrived(&rqe->sp, rqe->seg);
+                free(rqe);
         }
 

uspace/srv/net/tcp/segment.c

@@ -51 +51 @@
 void tcp_segment_delete(tcp_segment_t *seg)
 {
+        free(seg->dfptr);
         free(seg);
 }

uspace/srv/net/tcp/tcp.c

@@ -151 +151 @@
         if (rc != EOK)
                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to transmit PDU.");
+
+        free(pdu_raw);
 }
 

uspace/srv/net/tcp/tqueue.c

@@ -59 +59 @@
 static void tcp_tqueue_timer_clear(tcp_conn_t *conn);
 
+#include <stdio.h>
 int tcp_tqueue_init(tcp_tqueue_t *tqueue, tcp_conn_t *conn)
 {
+        printf("tcp_tqueue_init\n");
         tqueue->conn = conn;
-        tqueue->timer = fibril_timer_create();
+        tqueue->timer = fibril_timer_create(&conn->lock);
         if (tqueue->timer == NULL)
                 return ENOMEM;
@@ -78 +80 @@
 void tcp_tqueue_fini(tcp_tqueue_t *tqueue)
 {
+        printf("tcp_tqueue_fini\n");
         if (tqueue->timer != NULL) {
                 fibril_timer_destroy(tqueue->timer);
@@ -92 +95 @@
         seg = tcp_segment_make_ctrl(ctrl);
         tcp_tqueue_seg(conn, seg);
+        tcp_segment_delete(seg);
 }
 
@@ -212 +216 @@
 
         tcp_tqueue_seg(conn, seg);
+        tcp_segment_delete(seg);
 }
 
@@ -317 +322 @@
         log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: retransmit_timeout_func(%p)", conn->name, conn);
 
-        fibril_mutex_lock(&conn->lock);
+        tcp_conn_lock(conn);
 
         if (conn->cstate == st_closed) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Connection already closed.");
-                fibril_mutex_unlock(&conn->lock);
+                tcp_conn_unlock(conn);
                 tcp_conn_delref(conn);
                 return;
@@ -329 +334 @@
         if (link == NULL) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Nothing to retransmit");
-                fibril_mutex_unlock(&conn->lock);
+                tcp_conn_unlock(conn);
                 tcp_conn_delref(conn);
                 return;
@@ -339 +344 @@
         if (rt_seg == NULL) {
                 log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed.");
-                fibril_mutex_unlock(&conn->lock);
+                tcp_conn_unlock(conn);
                 tcp_conn_delref(conn);
                 /* XXX Handle properly */
@@ -351 +356 @@
         tcp_tqueue_timer_set(tqe->conn);
 
-        fibril_mutex_unlock(&conn->lock);
+        tcp_conn_unlock(conn);
         tcp_conn_delref(conn);
+
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: retransmit_timeout_func(%p) end", conn->name, conn);
 }
 
@@ -358 +365 @@
 static void tcp_tqueue_timer_set(tcp_conn_t *conn)
 {
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_set()", conn->name);
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_set() begin", conn->name);
 
         /* Clear first to make sure we update refcnt correctly */
@@ -364 +371 @@
 
         tcp_conn_addref(conn);
-        fibril_timer_set(conn->retransmit.timer, RETRANSMIT_TIMEOUT,
+        fibril_timer_set_locked(conn->retransmit.timer, RETRANSMIT_TIMEOUT,
             retransmit_timeout_func, (void *) conn);
+
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_set() end", conn->name);
 }
 
@@ -371 +380 @@
 static void tcp_tqueue_timer_clear(tcp_conn_t *conn)
 {
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_clear()", conn->name);
-
-        if (fibril_timer_clear(conn->retransmit.timer) == fts_active)
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_clear() begin", conn->name);
+
+        if (fibril_timer_clear_locked(conn->retransmit.timer) == fts_active)
                 tcp_conn_delref(conn);
+
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_clear() end", conn->name);
 }
 

uspace/srv/net/tcp/ucall.c

@@ -90 +90 @@
         /* Wait for connection to be established or reset */
         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open: Wait for connection.");
-        fibril_mutex_lock(&nconn->lock);
+        tcp_conn_lock(nconn);
         while (nconn->cstate == st_listen ||
             nconn->cstate == st_syn_sent ||
@@ -100 +100 @@
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open: Connection was reset.");
                 assert(nconn->cstate == st_closed);
-                fibril_mutex_unlock(&nconn->lock);
+                tcp_conn_unlock(nconn);
                 return TCP_ERESET;
         }
 
-        fibril_mutex_unlock(&nconn->lock);
+        tcp_conn_unlock(nconn);
         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open: Connection was established.");
 
@@ -121 +121 @@
         log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_send()", conn->name);
 
-        fibril_mutex_lock(&conn->lock);
+        tcp_conn_lock(conn);
 
         if (conn->cstate == st_closed) {
-                fibril_mutex_unlock(&conn->lock);
+                tcp_conn_unlock(conn);
                 return TCP_ENOTEXIST;
         }
@@ -135 +135 @@
 
         if (conn->snd_buf_fin) {
-                fibril_mutex_unlock(&conn->lock);
+                tcp_conn_unlock(conn);
                 return TCP_ECLOSING;
         }
@@ -149 +149 @@
 
                 if (conn->reset) {
-                        fibril_mutex_unlock(&conn->lock);
+                        tcp_conn_unlock(conn);
                         return TCP_ERESET;
                 }
@@ -165 +165 @@
 
         tcp_tqueue_new_data(conn);
-        fibril_mutex_unlock(&conn->lock);
+        tcp_conn_unlock(conn);
 
         return TCP_EOK;
@@ -178 +178 @@
         log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_receive()", conn->name);
 
-        fibril_mutex_lock(&conn->lock);
+        tcp_conn_lock(conn);
 
         if (conn->cstate == st_closed) {
-                fibril_mutex_unlock(&conn->lock);
+                tcp_conn_unlock(conn);
                 return TCP_ENOTEXIST;
         }
@@ -197 +197 @@
                 if (conn->rcv_buf_fin) {
                         /* End of data, peer closed connection */
-                        fibril_mutex_unlock(&conn->lock);
+                        tcp_conn_unlock(conn);
                         return TCP_ECLOSING;
                 } else {
                         /* Connection was reset */
                         assert(conn->reset);
-                        fibril_mutex_unlock(&conn->lock);
+                        tcp_conn_unlock(conn);
                         return TCP_ERESET;
                 }
@@ -227 +227 @@
             conn->name, xfer_size);
 
-        fibril_mutex_unlock(&conn->lock);
+        tcp_conn_unlock(conn);
 
         return TCP_EOK;
@@ -238 +238 @@
             conn);
 
-        fibril_mutex_lock(&conn->lock);
+        tcp_conn_lock(conn);
 
         if (conn->cstate == st_closed) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_close - ENOTEXIST");
-                fibril_mutex_unlock(&conn->lock);
+                tcp_conn_unlock(conn);
                 return TCP_ENOTEXIST;
         }
@@ -250 +250 @@
                 tcp_conn_reset(conn);
                 tcp_conn_remove(conn);
+                tcp_conn_unlock(conn);
                 return TCP_EOK;
         }
@@ -255 +256 @@
         if (conn->snd_buf_fin) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_close - ECLOSING");
-                fibril_mutex_unlock(&conn->lock);
+                tcp_conn_unlock(conn);
                 return TCP_ECLOSING;
         }
@@ -263 +264 @@
         tcp_tqueue_new_data(conn);
 
-        fibril_mutex_unlock(&conn->lock);
+        tcp_conn_unlock(conn);
         return TCP_EOK;
 }
@@ -321 +322 @@
         }
 
-        fibril_mutex_lock(&conn->lock);
+        tcp_conn_lock(conn);
 
         if (conn->cstate == st_closed) {
                 log_msg(LOG_DEFAULT, LVL_WARN, "Connection is closed.");
                 tcp_unexpected_segment(sp, seg);
-                fibril_mutex_unlock(&conn->lock);
+                tcp_conn_unlock(conn);
                 tcp_conn_delref(conn);
                 return;
@@ -342 +343 @@
         tcp_conn_segment_arrived(conn, seg);
 
-        fibril_mutex_unlock(&conn->lock);
+        tcp_conn_unlock(conn);
         tcp_conn_delref(conn);
 }

uspace/srv/net/udp/udp_inet.c

@@ -71 +71 @@
 
         udp_received_pdu(pdu);
+
+        /* We don't want udp_pdu_delete() to free dgram->data */
+        pdu->data = NULL;
         udp_pdu_delete(pdu);