WebSVN – HelenOS – Path Comparison – / – /branches/network/uspace/ Rev 4580 and /branches/network/uspace/ Rev 4581

Ignore whitespace Rev 4580 → Rev 4581

 /branches/network/uspace/app/bdsh/input.c
 ,10 → 32,10
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <io/stream.h>
-#include <console.h>
-#include <kbd/kbd.h>
-#include <kbd/keycode.h>
+#include <io/console.h>
+#include <io/keycode.h>
+#include <io/style.h>
+#include <vfs/vfs.h>
 #include <errno.h>
 #include <bool.h>
 ,7 → 100,7
 static void read_line(char *buffer, int n)
 {
-    kbd_event_t ev;
+    console_event_t ev;
     size_t offs, otmp;
     wchar_t dec;
 ,11 → 107,12
     offs = 0;
     while (true) {
         fflush(stdout);
-        if (kbd_get_event(&ev) < 0)
+        if (!console_get_event(fphone(stdin), &ev))
             return;
-        if (ev.type == KE_RELEASE)
+        if (ev.type != KEY_PRESS)
             continue;
         if (ev.key == KC_ENTER || ev.key == KC_NENTER)
             break;
         if (ev.key == KC_BACKSPACE) {
 ,9 → 132,8
             continue;
         }
         if (ev.c >= ' ') {
-            //putchar(ev.c);
             if (chr_encode(ev.c, buffer, &offs, n - 1) == EOK)
-                console_putchar(ev.c);
+                putchar(ev.c);
         }
     }
     putchar('\n');
 ,9 → 147,11
 {
     char line[INPUT_MAX];
-    console_set_style(STYLE_EMPHASIS);
+    fflush(stdout);
+    console_set_style(fphone(stdout), STYLE_EMPHASIS);
     printf("%s", usr->prompt);
-    console_set_style(STYLE_NORMAL);
+    fflush(stdout);
+    console_set_style(fphone(stdout), STYLE_NORMAL);
     read_line(line, INPUT_MAX);
     /* Make sure we don't have rubbish or a C/R happy user */

 /branches/network/uspace/app/bdsh/cmds/modules/mv/mv.c
 ,0 → 1,70
+/*
+ * Copyright (c) 2009 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include "config.h"
+#include "util.h"
+#include "errors.h"
+#include "entry.h"
+#include "mv.h"
+#include "cmds.h"
+static const char *cmdname = "mv";
+/* Dispays help for mv in various levels */
+void help_cmd_mv(unsigned int level)
+{
+    printf("'%s' renames files\n", cmdname);
+    return;
+}
+/* Main entry point for mv, accepts an array of arguments */
+int cmd_mv(char **argv)
+{
+    unsigned int argc;
+    int rc;
+    argc = cli_count_args(argv);
+    if (argc != 3) {
+        printf("%s: invalid number of arguments.\n",
+            cmdname);
+        return CMD_FAILURE;
+    }
+    rc = rename(argv[1], argv[2]);
+    if (rc != EOK) {
+        printf("Unable to rename %s to %s (rc=%d)\n",
+            argv[1], argv[2], rc);
+        return CMD_FAILURE;
+    }
+    return CMD_SUCCESS;
+}

 /branches/network/uspace/app/bdsh/cmds/modules/mv/mv_def.h
 ,0 → 1,14
+{
+    "mv",
+    "The mv command",
+    &cmd_mv,
+    &help_cmd_mv,
+},
+{
+    "ren",
+    NULL,
+    &cmd_mv,
+    &help_cmd_mv,
+},

 /branches/network/uspace/app/bdsh/cmds/modules/mv/entry.h
 ,0 → 1,9
+#ifndef MV_ENTRY_H
+#define MV_ENTRY_H
+/* Entry points for the mv command */
+extern int cmd_mv(char **);
+extern void help_cmd_mv(unsigned int);
+#endif /* MV_ENTRY_H */

 /branches/network/uspace/app/bdsh/cmds/modules/mv/mv.h
 ,0 → 1,8
+#ifndef MV_H
+#define MV_H
+/* Prototypes for the mv command, excluding entry points */
+#endif /* MV_H */

 /branches/network/uspace/app/bdsh/cmds/modules/bdd/bdd.c
 ,0 → 1,154
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "config.h"
+#include "util.h"
+#include "errors.h"
+#include "entry.h"
+#include "bdd.h"
+#include "cmds.h"
+#include <libblock.h>
+#include <devmap.h>
+#include <errno.h>
+#define BLOCK_SIZE  512
+#define BPR      16
+static const char *cmdname = "bdd";
+/* Dispays help for bdd in various levels */
+void help_cmd_bdd(unsigned int level)
+{
+    static char helpfmt[] =
+        "Usage:  %s <device> [<block_number> [<bytes>]]\n";
+    if (level == HELP_SHORT) {
+        printf("'%s' dump block device contents.\n", cmdname);
+    } else {
+        help_cmd_bdd(HELP_SHORT);
+        printf(helpfmt, cmdname);
+    }
+    return;
+}
+/* Main entry point for bdd, accepts an array of arguments */
+int cmd_bdd(char **argv)
+{
+    unsigned int argc;
+    unsigned int i, j;
+    dev_handle_t handle;
+    block_t *block;
+    uint8_t *blk;
+    size_t size, bytes, rows;
+    int rc;
+    bn_t boff;
+    uint8_t b;
+    /* Count the arguments */
+    for (argc = 0; argv[argc] != NULL; argc ++);
+    if (argc < 2 || argc > 4) {
+        printf("%s - incorrect number of arguments.\n", cmdname);
+        return CMD_FAILURE;
+    }
+    if (argc >= 3)
+        boff = strtol(argv[2], NULL, 0);
+    else
+        boff = 0;
+    if (argc >= 4)
+        size = strtol(argv[3], NULL, 0);
+    else
+        size = 256;
+    rc = devmap_device_get_handle(argv[1], &handle, 0);
+    if (rc != EOK) {
+        printf("Error: could not resolve device `%s'.\n", argv[1]);
+        return CMD_FAILURE;
+    }
+    rc = block_init(handle, BLOCK_SIZE);
+    if (rc != EOK)  {
+        printf("Error: could not init libblock.\n");
+        return CMD_FAILURE;
+    }
+    rc = block_cache_init(handle, BLOCK_SIZE, 2, CACHE_MODE_WB);
+    if (rc != EOK) {
+        printf("Error: could not init block cache.\n");
+        return CMD_FAILURE;
+    }
+    while (size > 0) {
+        block = block_get(handle, boff, 0);
+        blk = (uint8_t *) block->data;
+        bytes = (size < BLOCK_SIZE) ? size : BLOCK_SIZE;
+        rows = (bytes + BPR - 1) / BPR;
+        for (j = 0; j < rows; j++) {
+            for (i = 0; i < BPR; i++) {
+                if (j * BPR + i < bytes)
+                    printf("%02x ", blk[j * BPR + i]);
+                else
+                    printf("   ");
+            }
+            putchar('\t');
+            for (i = 0; i < BPR; i++) {
+                if (j * BPR + i < bytes) {
+                    b = blk[j * BPR + i];
+                    if (b >= 32 && b < 127)
+                        putchar(b);
+                    else
+                        putchar(' ');
+                } else {
+                    putchar(' ');
+                }
+            }
+            putchar('\n');
+        }
+        block_put(block);
+        if (size > rows * BPR)
+            size -= rows * BPR;
+        else
+            size = 0;
+        boff += rows * BPR;
+    }
+    block_fini(handle);
+    return CMD_SUCCESS;
+}

 /branches/network/uspace/app/bdsh/cmds/modules/bdd/bdd.h
 ,0 → 1,8
+#ifndef BDD_H
+#define BDD_H
+/* Prototypes for the bdd command, excluding entry points */
+#endif /* BDD_H */

 /branches/network/uspace/app/bdsh/cmds/modules/bdd/entry.h
 ,0 → 1,9
+#ifndef BDD_ENTRY_H
+#define BDD_ENTRY_H
+/* Entry points for the bdd command */
+extern int cmd_bdd(char **);
+extern void help_cmd_bdd(unsigned int);
+#endif /* BDD_ENTRY_H */

/branches/network/uspace/app/bdsh/cmds/modules/bdd/bdd_def.h
0,0 → 1,7
{
"bdd",
"Dump block device contents",
&cmd_bdd,
&help_cmd_bdd,
},

 /branches/network/uspace/app/bdsh/cmds/modules/kcon/kcon.c
 ,7 → 30,8
 #include <stdio.h>
 #include <stdlib.h>
-#include <console.h>
+#include <io/console.h>
+#include <vfs/vfs.h>
 #include "config.h"
 #include "util.h"
 #include "errors.h"
 ,7 → 66,7
         return CMD_FAILURE;
     }
-    console_kcon_enable();
+    console_kcon_enable(fphone(stdout));
     return CMD_SUCCESS;
 }

/branches/network/uspace/app/bdsh/cmds/modules/pwd/pwd.c
30,6 → 30,7

#include <stdio.h>
#include <stdlib.h>
#include <mem.h>

#include "config.h"
#include "errors.h"

 /branches/network/uspace/app/bdsh/cmds/modules/modules.h
 ,6 → 20,7
 #include "help/entry.h"
 #include "mkdir/entry.h"
 #include "rm/entry.h"
+#include "bdd/entry.h"
 #include "cat/entry.h"
 #include "touch/entry.h"
 #include "ls/entry.h"
 ,6 → 27,8
 #include "pwd/entry.h"
 #include "sleep/entry.h"
 #include "cp/entry.h"
+#include "mv/entry.h"
+#include "mount/entry.h"
 #include "kcon/entry.h"
 /* Each .def function fills the module_t struct with the individual name, entry
 ,6 → 39,7
 #include "help/help_def.h"
 #include "mkdir/mkdir_def.h"
 #include "rm/rm_def.h"
+#include "bdd/bdd_def.h"
 #include "cat/cat_def.h"
 #include "touch/touch_def.h"
 #include "ls/ls_def.h"
 ,7 → 46,10
 #include "pwd/pwd_def.h"
 #include "sleep/sleep_def.h"
 #include "cp/cp_def.h"
+#include "mv/mv_def.h"
+#include "mount/mount_def.h"
 #include "kcon/kcon_def.h"
     {NULL, NULL, NULL, NULL}
 };

 /branches/network/uspace/app/bdsh/cmds/modules/mount/mount.c
 ,0 → 1,82
+/*
+ * Copyright (c) 2009 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <vfs/vfs.h>
+#include <errno.h>
+#include "config.h"
+#include "util.h"
+#include "errors.h"
+#include "entry.h"
+#include "mount.h"
+#include "cmds.h"
+static const char *cmdname = "mount";
+/* Dispays help for mount in various levels */
+void help_cmd_mount(unsigned int level)
+{
+    static char helpfmt[] =
+        "Usage:  %s <fstype> <mp> <dev> [<moptions>]\n";
+    if (level == HELP_SHORT) {
+        printf("'%s' mounts a file system.\n", cmdname);
+    } else {
+        help_cmd_mount(HELP_SHORT);
+        printf(helpfmt, cmdname);
+    }
+    return;
+}
+/* Main entry point for mount, accepts an array of arguments */
+int cmd_mount(char **argv)
+{
+    unsigned int argc;
+    char *mopts = "";
+    int rc;
+    argc = cli_count_args(argv);
+    if ((argc < 4) || (argc > 5)) {
+        printf("%s: invalid number of arguments.\n",
+            cmdname);
+        return CMD_FAILURE;
+    }
+    if (argc == 5)
+        mopts = argv[4];
+    rc = mount(argv[1], argv[2], argv[3], mopts, 0);
+    if (rc != EOK) {
+        printf("Unable to mount %s filesystem to %s on %s (rc=%d)\n",
+            argv[1], argv[2], argv[3], rc);
+        return CMD_FAILURE;
+    }
+    return CMD_SUCCESS;
+}

/branches/network/uspace/app/bdsh/cmds/modules/mount/mount_def.h
0,0 → 1,7
{
"mount",
"The mount command",
&cmd_mount,
&help_cmd_mount,
},

 /branches/network/uspace/app/bdsh/cmds/modules/mount/entry.h
 ,0 → 1,9
+#ifndef MOUNT_ENTRY_H
+#define MOUNT_ENTRY_H
+/* Entry points for the mount command */
+extern int cmd_mount(char **);
+extern void help_cmd_mount(unsigned int);
+#endif /* MOUNT_ENTRY_H */

 /branches/network/uspace/app/bdsh/cmds/modules/mount/mount.h
 ,0 → 1,8
+#ifndef MOUNT_H
+#define MOUNT_H
+/* Prototypes for the mount command, excluding entry points */
+#endif /* MOUNT_H */

/branches/network/uspace/app/bdsh/cmds/modules/mkdir/mkdir.c
37,6 → 37,7
#include <sys/stat.h>
#include <getopt.h>
#include <stdarg.h>
#include <string.h>

#include "config.h"
#include "errors.h"

 /branches/network/uspace/app/bdsh/cmds/modules/cat/cat.c
 ,7 → 87,8
     off_t total = 0;
     char *buff = NULL;
-    if (-1 == (fd = open(fname, O_RDONLY))) {
+    fd = open(fname, O_RDONLY);
+    if (fd < 0) {
         printf("Unable to open %s\n", fname);
         return 1;
     }

/branches/network/uspace/app/bdsh/cmds/modules/module_aliases.h
12,6 → 12,7
* the entry point being reached. */

char *mod_aliases[] = {
"ren", "mv",
NULL, NULL
};

 /branches/network/uspace/app/bdsh/cmds/modules/rm/rm.c
 ,6 → 34,8
 #include <fcntl.h>
 #include <dirent.h>
 #include <getopt.h>
+#include <mem.h>
+#include <string.h>
 #include "config.h"
 #include "errors.h"

 /branches/network/uspace/app/bdsh/exec.c
 ,7 → 123,8
     if (tid == 0) {
         cli_error(CL_EEXEC, "Cannot spawn `%s'.", cmd);
         return 1;
-    } else {
-        return 0;
     }
+    task_wait(tid);
+    return 0;
 }

 /branches/network/uspace/app/bdsh/Makefile
 ,12 → 33,13
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
+LIBBLOCK_PREFIX = ../../lib/libblock
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS += -I../../srv/kbd/include
+CFLAGS += -I../../srv/kbd/include -I$(LIBBLOCK_PREFIX)
-LIBS = $(LIBC_PREFIX)/libc.a
+LIBS = $(LIBBLOCK_PREFIX)/libblock.a $(LIBC_PREFIX)/libc.a
 DEFS += -DRELEASE=$(RELEASE)
 PROGRAM = bdsh
 ,6 → 52,7
     cmds/modules/help/ \
     cmds/modules/mkdir/ \
     cmds/modules/rm/ \
+    cmds/modules/bdd/ \
     cmds/modules/cat/ \
     cmds/modules/touch/ \
     cmds/modules/ls/ \
 ,6 → 59,8
     cmds/modules/pwd/ \
     cmds/modules/sleep/ \
     cmds/modules/cp/ \
+    cmds/modules/mv/ \
+    cmds/modules/mount/ \
     cmds/modules/kcon/ \
     cmds/builtins/ \
     cmds/builtins/exit/\
 ,6 → 70,7
     cmds/modules/help/help.c \
     cmds/modules/mkdir/mkdir.c \
     cmds/modules/rm/rm.c \
+    cmds/modules/bdd/bdd.c \
     cmds/modules/cat/cat.c \
     cmds/modules/touch/touch.c \
     cmds/modules/ls/ls.c \
 ,6 → 77,8
     cmds/modules/pwd/pwd.c \
     cmds/modules/sleep/sleep.c \
     cmds/modules/cp/cp.c \
+    cmds/modules/mv/mv.c \
+    cmds/modules/mount/mount.c \
     cmds/modules/kcon/kcon.c \
     cmds/builtins/exit/exit.c \
     cmds/builtins/cd/cd.c \

/branches/network/uspace/app/init/version.c
File deleted

/branches/network/uspace/app/init/version.h
File deleted

 /branches/network/uspace/app/init/init.c
 ,25 → 44,31
 #include <task.h>
 #include <malloc.h>
 #include <macros.h>
-#include <console.h>
 #include <string.h>
+#include <devmap.h>
 #include "init.h"
-#include "version.h"
-static bool mount_fs(const char *fstype)
+static void info_print(void)
 {
+    printf(NAME ": HelenOS init\n");
+}
+static bool mount_root(const char *fstype)
+{
     int rc = -1;
     char *opts = "";
+    const char *root_dev = "initrd";
     if (str_cmp(fstype, "tmpfs") == 0)
         opts = "restore";
     while (rc < 0) {
-        rc = mount(fstype, "/", "initrd", opts, IPC_FLAG_BLOCKING);
+        rc = mount(fstype, "/", root_dev, opts, IPC_FLAG_BLOCKING);
         switch (rc) {
         case EOK:
-            printf(NAME ": Root filesystem mounted\n");
+            printf(NAME ": Root filesystem mounted, %s at %s\n",
+                fstype, root_dev);
             break;
         case EBUSY:
             printf(NAME ": Root filesystem already mounted\n");
 ,6 → 85,32
     return true;
 }
+static bool mount_devfs(void)
+{
+    int rc = -1;
+    while (rc < 0) {
+        rc = mount("devfs", "/dev", "null", "", IPC_FLAG_BLOCKING);
+        switch (rc) {
+        case EOK:
+            printf(NAME ": Device filesystem mounted\n");
+            break;
+        case EBUSY:
+            printf(NAME ": Device filesystem already mounted\n");
+            break;
+        case ELIMIT:
+            printf(NAME ": Unable to mount device filesystem\n");
+            return false;
+        case ENOENT:
+            printf(NAME ": Unknown filesystem type (devfs)\n");
+            return false;
+        }
+    }
+    return true;
+}
 static void spawn(char *fname)
 {
     char *argv[2];
 ,16 → 124,62
         printf(NAME ": Error spawning %s\n", fname);
 }
+static void getvc(char *dev, char *app)
+{
+    char *argv[4];
+    char vc[MAX_DEVICE_NAME];
+    int rc;
+    snprintf(vc, MAX_DEVICE_NAME, "/dev/%s", dev);
+    printf(NAME ": Spawning getvc on %s\n", vc);
+    dev_handle_t handle;
+    rc = devmap_device_get_handle(dev, &handle, IPC_FLAG_BLOCKING);
+    if (rc == EOK) {
+        argv[0] = "/app/getvc";
+        argv[1] = vc;
+        argv[2] = app;
+        argv[3] = NULL;
+        if (!task_spawn("/app/getvc", argv))
+            printf(NAME ": Error spawning getvc on %s\n", vc);
+    } else {
+        printf(NAME ": Error waiting on %s\n", vc);
+    }
+}
+void mount_data(void)
+{
+    int rc;
+    printf("Trying to mount disk0 on /data... ");
+    fflush(stdout);
+    rc = mount("fat", "/data", "disk0", "wtcache", 0);
+    if (rc == EOK)
+        printf("OK\n");
+    else
+        printf("Failed\n");
+}
 int main(int argc, char *argv[])
 {
     info_print();
-    if (!mount_fs(STRING(RDFMT))) {
+    if (!mount_root(STRING(RDFMT))) {
         printf(NAME ": Exiting\n");
         return -1;
     }
-    // FIXME: spawn("/srv/pci");
+    spawn("/srv/devfs");
+    if (!mount_devfs()) {
+        printf(NAME ": Exiting\n");
+        return -2;
+    }
     spawn("/srv/fb");
     spawn("/srv/kbd");
 //  spawn("/srv/netstart");
 ,13 → 186,20
     spawn("/srv/console");
     spawn("/srv/fhc");
     spawn("/srv/obio");
+    spawn("/srv/ata_bd");
+    spawn("/srv/gxe_bd");
+    usleep(250000);
+    mount_data();
+    getvc("vc0", "/app/bdsh");
+    getvc("vc1", "/app/bdsh");
+    getvc("vc2", "/app/bdsh");
+    getvc("vc3", "/app/bdsh");
+    getvc("vc4", "/app/bdsh");
+    getvc("vc5", "/app/bdsh");
+    getvc("vc6", "/app/klog");
-    console_wait();
-    version_print();
-    spawn("/app/klog");
-    spawn("/app/bdsh");
     return 0;
 }

 /branches/network/uspace/app/init/init.h
 ,7 → 28,7
 /** @addtogroup init
  * @{
- */
+ */
 /**
  * @file
  */
 ,10 → 36,11
 #ifndef __INIT_H__
 #define __INIT_H__
-#define NAME "init"
+#define NAME  "init"
+#define MAX_DEVICE_NAME  32
 #endif
 /** @}
  */

 /branches/network/uspace/app/init/Makefile
 ,8 → 26,6
 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
-include ../../../version
 ## Setup toolchain
 #
 ,10 → 34,7
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS += -I../../srv/kbd/include
 LIBS = $(LIBC_PREFIX)/libc.a
-DEFS += -DRELEASE=$(RELEASE)
 ## Sources
 #
 ,8 → 41,7
 OUTPUT = init
 SOURCES = \
-    init.c \
-    version.c
+    init.c
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
 ,7 → 63,7
 disasm: $(OUTPUT).disasm
 $(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
+    $(OBJDUMP) -d $< > $@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/network/uspace/app/tester/console/console1.c
 ,12 → 28,13
 #include <stdio.h>
 #include <stdlib.h>
-#include <io/stream.h>
+#include <io/console.h>
+#include <io/color.h>
+#include <io/style.h>
+#include <vfs/vfs.h>
 #include <async.h>
 #include "../tester.h"
-#include <console.h>
 const char *color_name[] = {
     [COLOR_BLACK] = "black",
     [COLOR_BLUE] = "blue",
 ,21 → 51,26
     int i, j;
     printf("Style test: ");
-    console_set_style(STYLE_NORMAL);
+    fflush(stdout);
+    console_set_style(fphone(stdout), STYLE_NORMAL);
     printf("normal ");
-    console_set_style(STYLE_EMPHASIS);
+    fflush(stdout);
+    console_set_style(fphone(stdout), STYLE_EMPHASIS);
     printf("emphasized");
-    console_set_style(STYLE_NORMAL);
+    fflush(stdout);
+    console_set_style(fphone(stdout), STYLE_NORMAL);
     printf(".\n");
     printf("Foreground color test:\n");
     for (j = 0; j < 2; j++) {
         for (i = COLOR_BLACK; i <= COLOR_WHITE; i++) {
-            console_set_color(i, COLOR_WHITE,
+            fflush(stdout);
+            console_set_color(fphone(stdout), i, COLOR_WHITE,
                 j ? CATTR_BRIGHT : 0);
             printf(" %s ", color_name[i]);
         }
-        console_set_color(COLOR_BLACK, COLOR_WHITE, 0);
+        fflush(stdout);
+        console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0);
         putchar('\n');
     }
 ,11 → 77,13
     printf("Background color test:\n");
     for (j = 0; j < 2; j++) {
         for (i = COLOR_BLACK; i <= COLOR_WHITE; i++) {
-            console_set_color(COLOR_WHITE, i,
+            fflush(stdout);
+            console_set_color(fphone(stdout), COLOR_WHITE, i,
                 j ? CATTR_BRIGHT : 0);
             printf(" %s ", color_name[i]);
         }
-        console_set_color(COLOR_BLACK, COLOR_WHITE, 0);
+        fflush(stdout);
+        console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0);
         putchar('\n');
     }
 ,24 → 90,30
     printf("Now let's test RGB colors:\n");
     for (i = 0; i < 255; i += 16) {
-        console_set_rgb_color(0xffffff, i << 16);
+        fflush(stdout);
+        console_set_rgb_color(fphone(stdout), 0xffffff, i << 16);
         putchar('X');
     }
-    console_set_color(COLOR_BLACK, COLOR_WHITE, 0);
+    fflush(stdout);
+    console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0);
     putchar('\n');
     for (i = 0; i < 255; i += 16) {
-        console_set_rgb_color(0xffffff, i << 8);
+        fflush(stdout);
+        console_set_rgb_color(fphone(stdout), 0xffffff, i << 8);
         putchar('X');
     }
-    console_set_color(COLOR_BLACK, COLOR_WHITE, 0);
+    fflush(stdout);
+    console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0);
     putchar('\n');
     for (i = 0; i < 255; i += 16) {
-        console_set_rgb_color(0xffffff, i);
+        fflush(stdout);
+        console_set_rgb_color(fphone(stdout), 0xffffff, i);
         putchar('X');
     }
-    console_set_color(COLOR_BLACK, COLOR_WHITE, 0);
+    fflush(stdout);
+    console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0);
     putchar('\n');
     printf("[press a key]\n");

/branches/network/uspace/app/tester/stdio/stdio2.c
35,7 → 35,6
{
FILE *f;
char *file_name = "/test";
size_t n;
int c;

printf("Open file '%s' for writing\n", file_name);

/branches/network/uspace/app/tester/tester.c
56,6 → 56,7
#include "ipc/send_sync.def"
#include "ipc/answer.def"
#include "ipc/hangup.def"
#include "ipc/ping_pong.def"
#include "devmap/devmap1.def"
#include "loop/loop1.def"
#include "vfs/vfs1.def"
129,6 → 130,7

list_tests();
printf("> ");
fflush(stdout);

c = getchar();
printf("%c\n", c);

 /branches/network/uspace/app/tester/ipc/ping_pong.c
 ,0 → 1,73
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <ipc/ns.h>
+#include <async.h>
+#include <errno.h>
+#include "../tester.h"
+#define DURATION_SECS      10
+#define COUNT_GRANULARITY  100
+char *test_ping_pong(bool quiet)
+{
+    printf("Pinging ns server for %d seconds...\n", DURATION_SECS);
+    struct timeval start;
+    if (gettimeofday(&start, NULL) != 0)
+        return "Failed getting the time.";
+    uint64_t count = 0;
+    while (true) {
+        struct timeval now;
+        if (gettimeofday(&now, NULL) != 0)
+            return "Failed getting the time.";
+        if (tv_sub(&now, &start) >= DURATION_SECS * 1000000L)
+            break;
+        size_t i;
+        for (i = 0; i < COUNT_GRANULARITY; i++) {
+            int retval = async_req_0_0(PHONE_NS, NS_PING);
+            if (retval != EOK)
+                return "Failed to send ping message.";
+        }
+        count += COUNT_GRANULARITY;
+    }
+    printf("Completed %lu round trips in %u seconds, %lu RT/s.\n",
+        count, DURATION_SECS, count / DURATION_SECS);
+    return NULL;
+}

/branches/network/uspace/app/tester/ipc/ping_pong.def
0,0 → 1,6
{
"ping_pong",
"IPC ping-pong benchmark",
&test_ping_pong,
true
},

 /branches/network/uspace/app/tester/devmap/devmap1.c
 ,7 → 32,7
 #include <ipc/services.h>
 #include <async.h>
 #include <errno.h>
-#include <ipc/devmap.h>
+#include <devmap.h>
 #include "../tester.h"
 #include <time.h>
 ,22 → 84,14
     handle = (int)arg;
-    device_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
-        DEVMAP_CONNECT_TO_DEVICE, handle);
+    device_phone = devmap_device_connect(handle, 0);
     if (device_phone < 0) {
-        printf("Failed to connect to devmap as client (handle = %u).\n",
+        printf("Failed to connect to device (handle = %u).\n",
             handle);
         return -1;
     }
-/*
- *  device_phone = (int) IPC_GET_ARG5(answer);
- */
     printf("Connected to device.\n");
-    ipc_call_sync_1_0(device_phone, 1024, 1025);
-/*
- * ipc_hangup(device_phone);
- */
     ipc_hangup(device_phone);
     return EOK;
 ,126 → 113,6
     return EOK;
 }
-/**
- *
- */
-static int driver_register(char *name)
-{
-    ipcarg_t retval;
-    aid_t req;
-    ipc_call_t answer;
-    int phone;
-    ipcarg_t callback_phonehash;
-    phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP, DEVMAP_DRIVER, 0);
-    if (phone < 0) {
-        printf("Failed to connect to device mapper\n");
-        return -1;
-    }
-    req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer);
-    retval = ipc_data_write_start(phone, (char *)name, str_size(name) + 1);
-    if (retval != EOK) {
-        async_wait_for(req, NULL);
-        return -1;
-    }
-    async_set_client_connection(driver_client_connection);
-    ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash);
-/*
-    if (NULL == async_new_connection(callback_phonehash, 0, NULL,
-            driver_client_connection)) {
-        printf("Failed to create new fibril.\n");
-        async_wait_for(req, NULL);
-        return -1;
-    }
-*/
-    async_wait_for(req, &retval);
-    printf("Driver '%s' registered.\n", name);
-    return phone;
-}
-static int device_get_handle(int driver_phone, char *name, int *handle)
-{
-    ipcarg_t retval;
-    aid_t req;
-    ipc_call_t answer;
-    req = async_send_2(driver_phone, DEVMAP_DEVICE_GET_HANDLE, 0, 0,
-        &answer);
-    retval = ipc_data_write_start(driver_phone, name, str_size(name) + 1);
-    if (retval != EOK) {
-        printf("Failed to send device name '%s'.\n", name);
-        async_wait_for(req, NULL);
-        return retval;
-    }
-    async_wait_for(req, &retval);
-    if (NULL != handle) {
-        *handle = -1;
-    }
-    if (EOK == retval) {
-        if (NULL != handle) {
-            *handle = (int) IPC_GET_ARG1(answer);
-        }
-        printf("Device '%s' has handle %u.\n", name,
-            (int) IPC_GET_ARG1(answer));
-    } else {
-        printf("Failed to get handle for device '%s'.\n", name);
-    }
-    return retval;
-}
-/** Register new device.
- * @param driver_phone
- * @param name Device name.
- * @param handle Output variable. Handle to the created instance of device.
- */
-static int device_register(int driver_phone, char *name, int *handle)
-{
-    ipcarg_t retval;
-    aid_t req;
-    ipc_call_t answer;
-    req = async_send_2(driver_phone, DEVMAP_DEVICE_REGISTER, 0, 0, &answer);
-    retval = ipc_data_write_start(driver_phone, (char *)name,
-        str_size(name) + 1);
-    if (retval != EOK) {
-        printf("Failed to send device name '%s'.\n", name);
-        async_wait_for(req, NULL);
-        return retval;
-    }
-    async_wait_for(req, &retval);
-    if (NULL != handle) {
-        *handle = -1;
-    }
-    if (EOK == retval) {
-        if (NULL != handle) {
-            *handle = (int) IPC_GET_ARG1(answer);
-        }
-        printf("Device registered with handle %u.\n",
-            (int) IPC_GET_ARG1(answer));
-    }
-    return retval;
-}
 /** Test DevMap from the driver's point of view.
  *
  *
 ,64 → 119,71
  */
 char * test_devmap1(bool quiet)
 {
-    int driver_phone;
-    int dev1_handle;
-    int dev2_handle;
-    int dev3_handle;
-    int handle;
+    const char *retval = NULL;
     /* Register new driver */
-    driver_phone = driver_register("TestDriver");
-    if (driver_phone < 0) {
-        return "Error: Cannot register driver.\n";
+    int rc = devmap_driver_register("TestDriver", driver_client_connection);
+    if (rc < 0) {
+        retval = "Error: Cannot register driver.\n";
+        goto out;
     }
-    /* Register new device dev1*/
-    if (EOK != device_register(driver_phone, TEST_DEVICE1, &dev1_handle)) {
-        ipc_hangup(driver_phone);
-        return "Error: cannot register device.\n";
+    /* Register new device dev1. */
+    dev_handle_t dev1_handle;
+    rc = devmap_device_register(TEST_DEVICE1, &dev1_handle);
+    if (rc != EOK) {
+        retval = "Error: cannot register device.\n";
+        goto out;
     }
-    /* Get handle for dev2 (Should fail unless device is already
-     * registered by someone else)
+    /*
+     * Get handle for dev2 (Should fail unless device is already registered
+     * by someone else).
      */
-    if (EOK == device_get_handle(driver_phone, TEST_DEVICE2, &handle)) {
-        ipc_hangup(driver_phone);
-        return "Error: got handle for dev2 before it was registered.\n";
+    dev_handle_t handle;
+    rc = devmap_device_get_handle(TEST_DEVICE2, &handle, 0);
+    if (rc == EOK) {
+        retval = "Error: got handle for dev2 before it was registered.\n";
+        goto out;
     }
-    /* Register new device dev2*/
-    if (EOK != device_register(driver_phone, TEST_DEVICE2, &dev2_handle)) {
-        ipc_hangup(driver_phone);
-        return "Error: cannot register device dev2.\n";
+    /* Register new device dev2. */
+    dev_handle_t dev2_handle;
+    rc = devmap_device_register(TEST_DEVICE2, &dev2_handle);
+    if (rc != EOK) {
+        retval = "Error: cannot register device dev2.\n";
+        goto out;
     }
-    /* Register again device dev1 */
-    if (EOK == device_register(driver_phone, TEST_DEVICE1, &dev3_handle)) {
-        return "Error: dev1 registered twice.\n";
+    /* Register device dev1 again. */
+    dev_handle_t dev3_handle;
+    rc = devmap_device_register(TEST_DEVICE1, &dev3_handle);
+    if (rc == EOK) {
+        retval = "Error: dev1 registered twice.\n";
+        goto out;
     }
-    /* Get handle for dev1*/
-    if (EOK != device_get_handle(driver_phone, TEST_DEVICE1, &handle)) {
-        ipc_hangup(driver_phone);
-        return "Error: cannot get handle for 'DEVMAP_DEVICE1'.\n";
+    /* Get handle for dev1. */
+    rc = devmap_device_get_handle(TEST_DEVICE1, &handle, 0);
+    if (rc != EOK) {
+        retval = "Error: cannot get handle for 'DEVMAP_DEVICE1'.\n";
+        goto out;
     }
     if (handle != dev1_handle) {
-        ipc_hangup(driver_phone);
-        return "Error: cannot get handle for 'DEVMAP_DEVICE1'.\n";
+        retval = "Error: cannot get handle for 'DEVMAP_DEVICE1'.\n";
+        goto out;
     }
-    if (EOK != device_client(dev1_handle)) {
-        ipc_hangup(driver_phone);
-        return "Error: failed client test for 'DEVMAP_DEVICE1'.\n";
+    if (device_client(dev1_handle) != EOK) {
+        retval = "Error: failed client test for 'DEVMAP_DEVICE1'.\n";
+        goto out;
     }
-    /* TODO: */
-    ipc_hangup(driver_phone);
+out:
+    devmap_hangup_phone(DEVMAP_DRIVER);
+    devmap_hangup_phone(DEVMAP_CLIENT);
     return NULL;
 }

/branches/network/uspace/app/tester/tester.h
69,6 → 69,7
extern char * test_send_sync(bool quiet);
extern char * test_answer(bool quiet);
extern char * test_hangup(bool quiet);
extern char * test_ping_pong(bool quiet);
extern char * test_devmap1(bool quiet);
extern char * test_loop1(bool quiet);
extern char * test_vfs1(bool quiet);

 /branches/network/uspace/app/tester/Makefile
 ,6 → 54,7
     ipc/send_sync.c \
     ipc/answer.c \
     ipc/hangup.c \
+    ipc/ping_pong.c \
     loop/loop1.c \
     devmap/devmap1.c \
     console/console1.c \
 ,7 → 82,7
 disasm: $(OUTPUT).disasm
 $(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
+    $(OBJDUMP) -d $< > $@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/network/uspace/app/getvc/getvc.c
 ,0 → 1,106
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup getvc GetVC
+ * @brief Console initialization task.
+ * @{
+ */
+/**
+ * @file
+ */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <task.h>
+#include "version.h"
+static void usage(void)
+{
+    printf("Usage: getvc <device> <path>\n");
+}
+static void closeall(void)
+{
+    fclose(stdin);
+    fclose(stdout);
+    fclose(stderr);
+    close(0);
+    close(1);
+    close(2);
+}
+static task_id_t spawn(char *fname)
+{
+    char *argv[2];
+    argv[0] = fname;
+    argv[1] = NULL;
+    task_id_t id = task_spawn(fname, argv);
+    if (id == 0)
+        printf("Error spawning %s\n", fname);
+    return id;
+}
+int main(int argc, char *argv[])
+{
+    if (argc < 3) {
+        usage();
+        return -1;
+    }
+    closeall();
+    stdin = fopen(argv[1], "r");
+    stdout = fopen(argv[1], "w");
+    stderr = fopen(argv[1], "w");
+    /*
+     * FIXME: fopen() should actually detect that we are opening a console
+     * and it should set line-buffering mode automatically.
+     */
+    setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
+    if ((stdin == NULL)
+        || (stdout == NULL)
+        || (stderr == NULL))
+        return -2;
+    version_print(argv[1]);
+    task_id_t id = spawn(argv[2]);
+    task_wait(id);
+    return 0;
+}
+/** @}
+ */

 /branches/network/uspace/app/getvc/version.c
 ,0 → 1,67
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup getvc
+ * @{
+ */
+/**
+ * @file
+ */
+#include <unistd.h>
+#include <stdio.h>
+#include <macros.h>
+#include "getvc.h"
+#include "version.h"
+static char *release = STRING(RELEASE);
+static char *name = STRING(NAME);
+static char *arch = STRING(UARCH);
+#ifdef REVISION
+    static char *revision = ", revision " STRING(REVISION);
+#else
+    static char *revision = "";
+#endif
+#ifdef TIMESTAMP
+    static char *timestamp = "\nBuilt on " STRING(TIMESTAMP);
+#else
+    static char *timestamp = "";
+#endif
+/** Print version information. */
+void version_print(const char *vc)
+{
+    printf("HelenOS release %s (%s)%s%s\n", release, name, revision, timestamp);
+    printf("Running on %s (%s)\n", arch, vc);
+    printf("Copyright (c) 2001-2009 HelenOS project\n\n");
+}
+/** @}
+ */

 /branches/network/uspace/app/getvc/version.h
 ,0 → 1,44
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup getvc
+ * @{
+ */
+/**
+ * @file
+ */
+#ifndef VERSION_H__
+#define VERSION_H__
+extern void version_print(const char *vc);
+#endif
+/** @}
+ */

 /branches/network/uspace/app/getvc/Makefile
 ,0 → 1,79
+#
+# Copyright (c) 2009 Martin Decky
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+include ../../../version
+## Setup toolchain
+#
+LIBC_PREFIX = ../../lib/libc
+SOFTINT_PREFIX = ../../lib/softint
+include $(LIBC_PREFIX)/Makefile.toolchain
+LIBS = $(LIBC_PREFIX)/libc.a
+DEFS += -DRELEASE=$(RELEASE) "-DNAME=$(NAME)"
+## Sources
+#
+OUTPUT = getvc
+SOURCES = \
+    getvc.c \
+    version.c
+OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
+.PHONY: all clean depend disasm
+all: $(OUTPUT) $(OUTPUT).disasm
+-include Makefile.depend
+clean:
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
+depend:
+    $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
+$(OUTPUT): $(OBJECTS) $(LIBS)
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< > $@
+%.o: %.S
+    $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@
+%.o: %.s
+    $(AS) $(AFLAGS) $< -o $@
+%.o: %.c
+    $(CC) $(DEFS) $(CFLAGS) -c $< -o $@

 /branches/network/uspace/app/getvc/getvc.h
 ,0 → 1,42
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup getvc
+ * @{
+ */
+/**
+ * @file
+ */
+#ifndef GETVC_H__
+#define GETVC_H__
+#endif
+/** @}
+ */

/branches/network/uspace/app/tetris/pathnames.h
File deleted

 /branches/network/uspace/app/tetris/scores.c
 ,7 → 36,7
  */
 /** @addtogroup tetris
- * @{
+ * @{
  */
 /** @file
  */
 ,24 → 48,18
  *
  * Major whacks since then.
  */
 #include <errno.h>
-/* #include <err.h> */
-/* #include <fcntl.h> */
-/* #include <pwd.h> */
 #include <stdio.h>
-/* #include <stdlib.h> */
 #include <string.h>
-#include <kbd/kbd.h>
-#include <kbd/keycode.h>
+#include <io/console.h>
+#include <io/keycode.h>
+#include <vfs/vfs.h>
 #include <stdlib.h>
-/* #include <time.h> */
-/* #include <term.h> */
-/* #include <unistd.h> */
-/* #include <sys/param.h> */
-/* #include <sys/stat.h> */
-/* #include <sys/types.h> */
+#include <fcntl.h>
+#include <err.h>
+#include <time.h>
-#include "pathnames.h"
 #include "screen.h"
 #include "tetris.h"
 #include "scores.h"
 ,20 → 72,22
  * As long as the scores are kept sorted, this is simply the first one at
  * that level.
  */
-#define NUMSPOTS (MAXHISCORES + 1)
-#define NLEVELS (MAXLEVEL + 1)
-/* static time_t now; */
-/* static int nscores; */
-/* static int gotscores; */
-/* static struct highscore scores[NUMSPOTS]; */
+#define NUMSPOTS  (MAXHISCORES + 1)
+#define NLEVELS   (MAXLEVEL + 1)
 static struct highscore scores[NUMSPOTS];
-/* static int checkscores(struct highscore *, int); */
-/* static int cmpscores(const void *, const void *); */
-/* static void getscores(FILE **); */
-/* static void printem(int, int, struct highscore *, int, const char *); */
-/* static char *thisuser(void); */
+/** Copy from hiscore table score with index src to dest
+ *
+ */
+static void copyhiscore(int dest, int src)
+{
+    str_cpy(scores[dest].hs_name, STR_BOUNDS(MAXLOGNAME) + 1,
+        scores[src].hs_name);
+    scores[dest].hs_score = scores[src].hs_score;
+    scores[dest].hs_level = scores[src].hs_level;
+}
 void showscores(int firstgame)
 {
 ,59 → 97,55
     moveto(10, 0);
     printf("\tRank \tLevel \tName\t                     points\n");
     printf("\t========================================================\n");
-    for (i = 0; i < NUMSPOTS - 1; i++) {
-        printf("\t%6d %6d %-16s %20d\n", i+1, scores[i].hs_level, scores[i].hs_name, scores[i].hs_score);
-    }
+    for (i = 0; i < NUMSPOTS - 1; i++)
+        printf("\t%6d %6d %-16s %20d\n",
+            i + 1, scores[i].hs_level, scores[i].hs_name, scores[i].hs_score);
     if (!firstgame) {
         printf("\t========================================================\n");
-        printf("\t  Last %6d %-16s %20d\n", scores[NUMSPOTS - 1].hs_level, scores[NUMSPOTS - 1].hs_name, scores[NUMSPOTS - 1].hs_score);
+        printf("\t  Last %6d %-16s %20d\n",
+            scores[NUMSPOTS - 1].hs_level, scores[NUMSPOTS - 1].hs_name, scores[NUMSPOTS - 1].hs_score);
     }
     printf("\n\n\n\n\tPress any key to return to main menu.");
     getchar();
 }
-/** Copy from hiscore table score with index src to dest
- *
- */
-static void copyhiscore(int dest, int src)
-{
-    str_cpy(scores[dest].hs_name, STR_BOUNDS(MAXLOGNAME) + 1,
-        scores[src].hs_name);
-    scores[dest].hs_score = scores[src].hs_score;
-    scores[dest].hs_level = scores[src].hs_level;
-}
 void insertscore(int score, int level)
 {
-    int i,j;
+    int i;
+    int j;
     size_t off;
-    kbd_event_t ev;
+    console_event_t ev;
     clear_screen();
-    moveto(10 , 10);
+    moveto(10, 10);
     puts("Insert your name: ");
     str_cpy(scores[NUMSPOTS - 1].hs_name, STR_BOUNDS(MAXLOGNAME) + 1,
         "Player");
-    i = 6; off = 6;
+    i = 6;
+    off = 6;
     moveto(10 , 28);
-    printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");
+    printf("%s%.*s", scores[NUMSPOTS - 1].hs_name, MAXLOGNAME-i,
+        "........................................");
     while (1) {
         fflush(stdout);
-        if (kbd_get_event(&ev) != EOK)
+        if (!console_get_event(fphone(stdin), &ev))
             exit(1);
-        if (ev.type == KE_RELEASE)
+        if (ev.type == KEY_RELEASE)
             continue;
         if (ev.key == KC_ENTER || ev.key == KC_NENTER)
             break;
         if (ev.key == KC_BACKSPACE) {
             if (i > 0) {
                 wchar_t uc;
                 --i;
                 while (off > 0) {
                     --off;
 ,7 → 155,7
                     if (uc != U_SPECIAL)
                         break;
                 }
                 scores[NUMSPOTS - 1].hs_name[off] = '\0';
             }
         } else if (ev.c != '\0') {
 ,398 → 168,66
             }
         }
-        moveto(10 , 28);
-        printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");
+        moveto(10, 28);
+        printf("%s%.*s", scores[NUMSPOTS - 1].hs_name, MAXLOGNAME - i,
+            "........................................");
     }
-    scores[NUMSPOTS - 1].hs_score = score;
+    scores[NUMSPOTS - 1].hs_score = score;
     scores[NUMSPOTS - 1].hs_level = level;
-    i = NUMSPOTS-1;
+    i = NUMSPOTS - 1;
     while ((i > 0) && (scores[i - 1].hs_score < score))
         i--;
-    for (j = NUMSPOTS - 2; j > i; j--) {
-        copyhiscore(j,j-1);
-    }
-    copyhiscore(i, NUMSPOTS - 1);
+    for (j = NUMSPOTS - 2; j > i; j--)
+        copyhiscore(j, j-1);
+    copyhiscore(i, NUMSPOTS - 1);
 }
 void initscores(void)
 {
     int i;
-    for(i = 0; i < NUMSPOTS; i++) {
+    for (i = 0; i < NUMSPOTS; i++) {
         str_cpy(scores[i].hs_name, STR_BOUNDS(MAXLOGNAME) + 1, "HelenOS Team");
-        scores[i].hs_score = (NUMSPOTS - i) * 200;
-        scores[i].hs_level = (i + 1 > MAXLEVEL?MAXLEVEL:i + 1);
+        scores[i].hs_score = (NUMSPOTS - i) * 200;
+        scores[i].hs_level = (i + 1 > MAXLEVEL ? MAXLEVEL : i + 1);
     }
 }
-/*
- * Read the score file.  Can be called from savescore (before showscores)
- * or showscores (if savescore will not be called).  If the given pointer
- * is not NULL, sets *fpp to an open file pointer that corresponds to a
- * read/write score file that is locked with LOCK_EX.  Otherwise, the
- * file is locked with LOCK_SH for the read and closed before return.
- *
- * Note, we assume closing the stdio file releases the lock.
- */
-/* static void */
-/* getscores(FILE **fpp) */
-/* { */
-/*  int sd, mint, lck, mask, i; */
-/*  char *mstr, *human; */
-/*  FILE *sf; */
+int loadscores(void)
+{
+    FILE *f;
+    size_t cnt;
+    int rc;
-/*  if (fpp != NULL) { */
-/*      mint = O_RDWR | O_CREAT; */
-/*      mstr = "r+"; */
-/*      human = "read/write"; */
-/*      lck = LOCK_EX; */
-/*  } else { */
-/*      mint = O_RDONLY; */
-/*      mstr = "r"; */
-/*      human = "reading"; */
-/*      lck = LOCK_SH; */
-/*  } */
-/*  setegid(egid); */
-/*  mask = umask(S_IWOTH); */
-/*  sd = open(_PATH_SCOREFILE, mint, 0666); */
-/*  (void)umask(mask); */
-/*  setegid(gid); */
-/*  if (sd < 0) { */
-/*      if (fpp == NULL) { */
-/*          nscores = 0; */
-/*          return; */
-/*      } */
-/*      err(1, "cannot open %s for %s", _PATH_SCOREFILE, human); */
-/*  } */
-/*  setegid(egid); */
-/*  if ((sf = fdopen(sd, mstr)) == NULL) */
-/*      err(1, "cannot fdopen %s for %s", _PATH_SCOREFILE, human); */
-/*  setegid(gid); */
+    f = fopen("/data/tetris.sco", "rb");
+    if (f == NULL)
+        return ENOENT;
-/*  /\* */
-/*   * Grab a lock. */
-/*   *\/ */
-/*  if (flock(sd, lck)) */
-/*      warn("warning: score file %s cannot be locked", */
-/*          _PATH_SCOREFILE); */
+    cnt = fread(scores, sizeof(struct highscore), NUMSPOTS, f);
+    rc = fclose(f);
-/*  nscores = fread(scores, sizeof(scores[0]), MAXHISCORES, sf); */
-/*  if (ferror(sf)) */
-/*      err(1, "error reading %s", _PATH_SCOREFILE); */
-/*  for (i = 0; i < nscores; i++) */
-/*      if (scores[i].hs_level < MINLEVEL || */
-/*          scores[i].hs_level > MAXLEVEL) */
-/*          errx(1, "scorefile %s corrupt", _PATH_SCOREFILE); */
+    if (cnt != NUMSPOTS || rc != 0)
+        return EIO;
-/*  if (fpp) */
-/*      *fpp = sf; */
-/*  else */
-/*      (void)fclose(sf); */
-/* } */
+    return EOK;
+}
-void
-savescore(int level)
+void savescores(void)
 {
-    return;
-}
-/*  struct highscore *sp; */
-/*  int i; */
-/*  int change; */
-/*  FILE *sf; */
-/*  const char *me; */
+    FILE *f;
+    size_t cnt;
+    int rc;
-/*  getscores(&sf); */
-/*  gotscores = 1; */
-/*  (void)time(&now); */
+    f = fopen("/data/tetris.sco", "wb");
+    cnt = fwrite(scores, sizeof(struct highscore), NUMSPOTS, f);
+    rc = fclose(f);
-/*  /\* */
-/*   * Allow at most one score per person per level -- see if we */
-/*   * can replace an existing score, or (easiest) do nothing. */
-/*   * Otherwise add new score at end (there is always room). */
-/*   *\/ */
-/*  change = 0; */
-/*  me = thisuser(); */
-/*  for (i = 0, sp = &scores[0]; i < nscores; i++, sp++) { */
-/*      if (sp->hs_level != level || str_cmp(sp->hs_name, me) != 0) */
-/*          continue; */
-/*      if (score > sp->hs_score) { */
-/*          (void)printf("%s bettered %s %d score of %d!\n", */
-/*              "\nYou", "your old level", level, */
-/*              sp->hs_score * sp->hs_level); */
-/*          sp->hs_score = score;   /\* new score *\/ */
-/*          sp->hs_time = now;  /\* and time *\/ */
-/*          change = 1; */
-/*      } else if (score == sp->hs_score) { */
-/*          (void)printf("%s tied %s %d high score.\n", */
-/*              "\nYou", "your old level", level); */
-/*          sp->hs_time = now;  /\* renew it *\/ */
-/*          change = 1;     /\* gotta rewrite, sigh *\/ */
-/*      } /\* else new score < old score: do nothing *\/ */
-/*      break; */
-/*  } */
-/*  if (i >= nscores) { */
-/*      strlcpy(sp->hs_name, me, sizeof sp->hs_name); */
-/*      sp->hs_level = level; */
-/*      sp->hs_score = score; */
-/*      sp->hs_time = now; */
-/*      nscores++; */
-/*      change = 1; */
-/*  } */
-/*  if (change) { */
-/*      /\* */
-/*       * Sort & clean the scores, then rewrite. */
-/*       *\/ */
-/*      nscores = checkscores(scores, nscores); */
-/*      rewind(sf); */
-/*      if (fwrite(scores, sizeof(*sp), nscores, sf) != nscores || */
-/*          fflush(sf) == EOF) */
-/*          warnx("error writing %s: %s\n\t-- %s", */
-/*              _PATH_SCOREFILE, strerror(errno), */
-/*              "high scores may be damaged"); */
-/*  } */
-/*  (void)fclose(sf);   /\* releases lock *\/ */
-/* } */
-/*
- * Get login name, or if that fails, get something suitable.
- * The result is always trimmed to fit in a score.
- */
-/* static char * */
-/* thisuser(void) */
-/* { */
-/*  const char *p; */
-/*  struct passwd *pw; */
-/*  static char u[sizeof(scores[0].hs_name)]; */
-/*  if (u[0]) */
-/*      return (u); */
-/*  p = getlogin(); */
-/*  if (p == NULL || *p == '\0') { */
-/*      pw = getpwuid(getuid()); */
-/*      if (pw != NULL) */
-/*          p = pw->pw_name; */
-/*      else */
-/*          p = "  ???"; */
-/*  } */
-/*  strlcpy(u, p, sizeof(u)); */
-/*  return (u); */
-/* } */
-/*
- * Score comparison function for qsort.
- *
- * If two scores are equal, the person who had the score first is
- * listed first in the highscore file.
- */
-/* static int */
-/* cmpscores(const void *x, const void *y) */
-/* { */
-/*  const struct highscore *a, *b; */
-/*  long l; */
-/*  a = x; */
-/*  b = y; */
-/*  l = (long)b->hs_level * b->hs_score - (long)a->hs_level * a->hs_score; */
-/*  if (l < 0) */
-/*      return (-1); */
-/*  if (l > 0) */
-/*      return (1); */
-/*  if (a->hs_time < b->hs_time) */
-/*      return (-1); */
-/*  if (a->hs_time > b->hs_time) */
-/*      return (1); */
-/*  return (0); */
-/* } */
-/*
- * If we've added a score to the file, we need to check the file and ensure
- * that this player has only a few entries.  The number of entries is
- * controlled by MAXSCORES, and is to ensure that the highscore file is not
- * monopolised by just a few people.  People who no longer have accounts are
- * only allowed the highest score.  Scores older than EXPIRATION seconds are
- * removed, unless they are someone's personal best.
- * Caveat:  the highest score on each level is always kept.
- */
-/* static int */
-/* checkscores(struct highscore *hs, int num) */
-/* { */
-/*  struct highscore *sp; */
-/*  int i, j, k, numnames; */
-/*  int levelfound[NLEVELS]; */
-/*  struct peruser { */
-/*      char *name; */
-/*      int times; */
-/*  } count[NUMSPOTS]; */
-/*  struct peruser *pu; */
-/*  /\* */
-/*   * Sort so that highest totals come first. */
-/*   * */
-/*   * levelfound[i] becomes set when the first high score for that */
-/*   * level is encountered.  By definition this is the highest score. */
-/*   *\/ */
-/*  qsort((void *)hs, nscores, sizeof(*hs), cmpscores); */
-/*  for (i = MINLEVEL; i < NLEVELS; i++) */
-/*      levelfound[i] = 0; */
-/*  numnames = 0; */
-/*  for (i = 0, sp = hs; i < num;) { */
-/*      /\* */
-/*       * This is O(n^2), but do you think we care? */
-/*       *\/ */
-/*      for (j = 0, pu = count; j < numnames; j++, pu++) */
-/*          if (str_cmp(sp->hs_name, pu->name) == 0) */
-/*              break; */
-/*      if (j == numnames) { */
-/*          /\* */
-/*           * Add new user, set per-user count to 1. */
-/*           *\/ */
-/*          pu->name = sp->hs_name; */
-/*          pu->times = 1; */
-/*          numnames++; */
-/*      } else { */
-/*          /\* */
-/*           * Two ways to keep this score: */
-/*           * - Not too many (per user), still has acct, & */
-/*           *  score not dated; or */
-/*           * - High score on this level. */
-/*           *\/ */
-/*          if ((pu->times < MAXSCORES && */
-/*               getpwnam(sp->hs_name) != NULL && */
-/*               sp->hs_time + EXPIRATION >= now) || */
-/*              levelfound[sp->hs_level] == 0) */
-/*              pu->times++; */
-/*          else { */
-/*              /\* */
-/*               * Delete this score, do not count it, */
-/*               * do not pass go, do not collect $200. */
-/*               *\/ */
-/*              num--; */
-/*              for (k = i; k < num; k++) */
-/*                  hs[k] = hs[k + 1]; */
-/*              continue; */
-/*          } */
-/*      } */
-/*      levelfound[sp->hs_level] = 1; */
-/*      i++, sp++; */
-/*  } */
-/*  return (num > MAXHISCORES ? MAXHISCORES : num); */
-/* } */
-/*
- * Show current scores.  This must be called after savescore, if
- * savescore is called at all, for two reasons:
- * - Showscores munches the time field.
- * - Even if that were not the case, a new score must be recorded
- *   before it can be shown anyway.
- */
-/*
-void
-showscores(int level)
-{
-    return;
+    if (cnt != NUMSPOTS || rc != 0)
+        printf("Error saving score table\n");
 }
-*/
-/*  struct highscore *sp; */
-/*  int i, n, c; */
-/*  const char *me; */
-/*  int levelfound[NLEVELS]; */
-/*  if (!gotscores) */
-/*      getscores((FILE **)NULL); */
-/*  (void)printf("\n\t\t    Tetris High Scores\n"); */
-/*  /\* */
-/*   * If level == 0, the person has not played a game but just asked for */
-/*   * the high scores; we do not need to check for printing in highlight */
-/*   * mode.  If SOstr is null, we can't do highlighting anyway. */
-/*   *\/ */
-/*  me = level && SOstr ? thisuser() : NULL; */
-/*  /\* */
-/*   * Set times to 0 except for high score on each level. */
-/*   *\/ */
-/*  for (i = MINLEVEL; i < NLEVELS; i++) */
-/*      levelfound[i] = 0; */
-/*  for (i = 0, sp = scores; i < nscores; i++, sp++) { */
-/*      if (levelfound[sp->hs_level]) */
-/*          sp->hs_time = 0; */
-/*      else { */
-/*          sp->hs_time = 1; */
-/*          levelfound[sp->hs_level] = 1; */
-/*      } */
-/*  } */
-/*  /\* */
-/*   * Page each screenful of scores. */
-/*   *\/ */
-/*  for (i = 0, sp = scores; i < nscores; sp += n) { */
-/*      n = 20; */
-/*      if (i + n > nscores) */
-/*          n = nscores - i; */
-/*      printem(level, i + 1, sp, n, me); */
-/*      if ((i += n) < nscores) { */
-/*          (void)printf("\nHit RETURN to continue."); */
-/*          (void)fflush(stdout); */
-/*          while ((c = getchar()) != '\n') */
-/*              if (c == EOF) */
-/*                  break; */
-/*          (void)printf("\n"); */
-/*      } */
-/*  } */
-/*  if (nscores == 0) */
-/*      printf("\t\t\t      - none to date.\n"); */
-/* } */
-/* static void */
-/* printem(int level, int offset, struct highscore *hs, int n, const char *me) */
-/* { */
-/*  struct highscore *sp; */
-/*  int row, highlight, i; */
-/*  char buf[100]; */
-/* #define  TITLE "Rank  Score   Name                          (points/level)" */
-/* #define  TITL2 "==========================================================" */
-/*  printf("%s\n%s\n", TITLE, TITL2); */
-/*  highlight = 0; */
-/*  for (row = 0; row < n; row++) { */
-/*      sp = &hs[row]; */
-/*      (void)snprintf(buf, sizeof(buf), */
-/*          "%3d%c %6d  %-31s (%6d on %d)\n", */
-/*          row + offset, sp->hs_time ? '*' : ' ', */
-/*          sp->hs_score * sp->hs_level, */
-/*          sp->hs_name, sp->hs_score, sp->hs_level); */
-/*      /\* Print leaders every three lines *\/ */
-/*      if ((row + 1) % 3 == 0) { */
-/*          for (i = 0; i < sizeof(buf); i++) */
-/*              if (buf[i] == ' ') */
-/*                  buf[i] = '_'; */
-/*      } */
-/*      /\* */
-/*       * Highlight if appropriate.  This works because */
-/*       * we only get one score per level. */
-/*       *\/ */
-/*      if (me != NULL && */
-/*          sp->hs_level == level && */
-/*          sp->hs_score == score && */
-/*          str_cmp(sp->hs_name, me) == 0) { */
-/*          putpad(SOstr); */
-/*          highlight = 1; */
-/*      } */
-/*      (void)printf("%s", buf); */
-/*      if (highlight) { */
-/*          putpad(SEstr); */
-/*          highlight = 0; */
-/*      } */
-/*  } */
-/* } */
 /** @}
  */

 /branches/network/uspace/app/tetris/input.c
 ,7 → 36,7
  */
 /** @addtogroup tetris
- * @{
+ * @{
  */
 /** @file
  */
 ,9 → 57,9
 #include "tetris.h"
 #include <async.h>
+#include <vfs/vfs.h>
+#include <io/console.h>
 #include <ipc/console.h>
-#include <console.h>
-#include <kbd/kbd.h>
 /* return true iff the given timeval is positive */
 #define TV_POS(tv) \
 ,14 → 92,12
  * Return 0 => no input, 1 => can read() from stdin
  *
  */
-int
-rwait(struct timeval *tvp)
+int rwait(struct timeval *tvp)
 {
     struct timeval starttv, endtv, *s;
     static ipc_call_t charcall;
     ipcarg_t rc;
-    int cons_phone;
     /*
      * Someday, select() will do this for us.
      * Just in case that day is now, and no one has
 ,15 → 109,15
         s = &endtv;
     } else
         s = NULL;
     if (!lastchar) {
 again:
         if (!getchar_inprog) {
-            cons_phone = console_open(true);
-            getchar_inprog = async_send_2(cons_phone,
-                CONSOLE_GETKEY, 0, 0, &charcall);
+            getchar_inprog = async_send_0(fphone(stdin),
+                CONSOLE_GET_EVENT, &charcall);
         }
-        if (!s)
+        if (!s)
             async_wait_for(getchar_inprog, &rc);
         else if (async_wait_timeout(getchar_inprog, &rc, s->tv_usec) == ETIMEOUT) {
             tvp->tv_sec = 0;
 ,22 → 124,25
             tvp->tv_usec = 0;
             return (0);
         }
         getchar_inprog = 0;
-        if (rc) {
+        if (rc)
             stop("end of file, help");
-        }
-        if (IPC_GET_ARG1(charcall) == KE_RELEASE)
+        if (IPC_GET_ARG1(charcall) == KEY_RELEASE)
             goto again;
         lastchar = IPC_GET_ARG4(charcall);
     }
     if (tvp) {
         /* since there is input, we may not have timed out */
         (void) gettimeofday(&endtv, NULL);
         TV_SUB(&endtv, &starttv);
-        TV_SUB(tvp, &endtv);    /* adjust *tvp by elapsed time */
+        TV_SUB(tvp, &endtv);  /* adjust *tvp by elapsed time */
     }
-    return (1);
+    return 1;
 }
 /*
 ,11 → 149,10
  * `sleep' for the current turn time (using select).
  * Eat any input that might be available.
  */
-void
-tsleep(void)
+void tsleep(void)
 {
     struct timeval tv;
     tv.tv_sec = 0;
     tv.tv_usec = fallrate;
     while (TV_POS(&tv))
 ,12 → 165,11
 /*
  * getchar with timeout.
  */
-int
-tgetchar(void)
+int tgetchar(void)
 {
     static struct timeval timeleft;
     char c;
     /*
      * Reset timeleft to fallrate whenever it is not positive.
      * In any case, wait to see if there is any input.  If so,
 ,17 → 180,18
      * Most of the hard work is done by rwait().
      */
     if (!TV_POS(&timeleft)) {
-        faster();   /* go faster */
+        faster();  /* go faster */
         timeleft.tv_sec = 0;
         timeleft.tv_usec = fallrate;
     }
     if (!rwait(&timeleft))
-        return (-1);
+        return -1;
     c = lastchar;
     lastchar = '\0';
-    return ((int)(unsigned char)c);
+    return ((int) (unsigned char) c);
 }
 /** @}
  */

 /branches/network/uspace/app/tetris/screen.c
 ,7 → 36,7
  */
 /** @addtogroup tetris
- * @{
+ * @{
  */
 /** @file
  */
 ,21 → 50,24
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#include <console.h>
+#include <vfs/vfs.h>
 #include <async.h>
 #include "screen.h"
 #include "tetris.h"
-#include <ipc/console.h>
+#include <io/console.h>
-static cell curscreen[B_SIZE];  /* 1 => standout (or otherwise marked) */
+#define STOP  (B_COLS - 3)
+static cell curscreen[B_SIZE];  /* non-zero => standout (or otherwise marked) */
 static int curscore;
-static int isset;       /* true => terminal is in game mode */
+static int isset;               /* true => terminal is in game mode */
+static const struct shape *lastshape;
 /*
  * putstr() is for unpadded strings (either as in termcap(5) or
- * simply literal strings);
+ * simply literal strings);
  */
 static inline void putstr(char *s)
 {
 ,19 → 75,21
         putchar(*(s++));
 }
-static void start_standout(void)
+static void start_standout(uint32_t color)
 {
-    console_set_rgb_color(0xf0f0f0, 0);
+    fflush(stdout);
+    console_set_rgb_color(fphone(stdout), 0xf0f0f0, color);
 }
 static void resume_normal(void)
 {
-    console_set_rgb_color(0, 0xf0f0f0);
+    fflush(stdout);
+    console_set_rgb_color(fphone(stdout), 0, 0xf0f0f0);
 }
 void clear_screen(void)
 {
-    console_clear();
+    console_clear(fphone(stdout));
     moveto(0, 0);
 }
 ,23 → 96,20
 /*
  * Clear the screen, forgetting the current contents in the process.
  */
-void
-scr_clear(void)
+void scr_clear(void)
 {
     resume_normal();
-    console_clear();
+    console_clear(fphone(stdout));
     curscore = -1;
-    memset((char *)curscreen, 0, sizeof(curscreen));
+    memset(curscreen, 0, sizeof(curscreen));
 }
 /*
  * Set up screen
  */
-void
-scr_init(void)
+void scr_init(void)
 {
-    console_cursor_visibility(0);
+    console_cursor_visibility(fphone(stdout), 0);
     resume_normal();
     scr_clear();
 }
 ,7 → 116,8
 void moveto(int r, int c)
 {
-    console_goto(r, c);
+    fflush(stdout);
+    console_goto(fphone(stdout), c, r);
 }
 winsize_t winsize;
 ,25 → 124,27
 static int get_display_size(winsize_t *ws)
 {
-    return console_get_size(&ws->ws_row, &ws->ws_col);
+    return console_get_size(fphone(stdout), &ws->ws_col, &ws->ws_row);
 }
 /*
  * Set up screen mode.
  */
-void
-scr_set(void)
+void scr_set(void)
 {
     winsize_t ws;
-    Rows = 0, Cols = 0;
+    Rows = 0;
+    Cols = 0;
     if (get_display_size(&ws) == 0) {
         Rows = ws.ws_row;
         Cols = ws.ws_col;
     }
-    if (Rows < MINROWS || Cols < MINCOLS) {
+    if ((Rows < MINROWS) || (Cols < MINCOLS)) {
         char smallscr[55];
         snprintf(smallscr, sizeof(smallscr),
             "the screen is too small (must be at least %dx%d)",
             MINROWS, MINCOLS);
 ,7 → 151,7
         stop(smallscr);
     }
     isset = 1;
     scr_clear();
 }
 ,76 → 158,80
 /*
  * End screen mode.
  */
-void
-scr_end(void)
+void scr_end(void)
 {
+    console_cursor_visibility(fphone(stdout), 1);
 }
-void
-stop(char *why)
+void stop(char *why)
 {
     if (isset)
         scr_end();
     errx(1, "aborting: %s", why);
 }
 /*
  * Update the screen.
  */
-void
-scr_update(void)
+void scr_update(void)
 {
-    cell *bp, *sp;
-    cell so, cur_so = 0;
-    int i, ccol, j;
-    static const struct shape *lastshape;
-    /* always leave cursor after last displayed point */
+    cell *bp;
+    cell *sp;
+    cell so;
+    cell cur_so = 0;
+    int i;
+    int j;
+    int ccol;
+    /* Always leave cursor after last displayed point */
     curscreen[D_LAST * B_COLS - 1] = -1;
     if (score != curscore) {
         moveto(0, 0);
         printf("Score: %d", score);
         curscore = score;
     }
-    /* draw preview of next pattern */
-    if (showpreview && (nextshape != lastshape)) {
+    /* Draw preview of next pattern */
+    if ((showpreview) && (nextshape != lastshape)) {
         int i;
-        static int r=5, c=2;
+        static int r = 5, c = 2;
         int tr, tc, t;
         lastshape = nextshape;
-        /* clean */
+        /* Clean */
         resume_normal();
-        moveto(r-1, c-1); putstr("          ");
-        moveto(r,   c-1); putstr("          ");
-        moveto(r+1, c-1); putstr("          ");
-        moveto(r+2, c-1); putstr("          ");
-        moveto(r-3, c-2);
+        moveto(r - 1, c - 1);
+        putstr("          ");
+        moveto(r, c - 1);
+        putstr("          ");
+        moveto(r + 1, c - 1);
+        putstr("          ");
+        moveto(r + 2, c - 1);
+        putstr("          ");
+        moveto(r - 3, c - 2);
         putstr("Next shape:");
-        /* draw */
-        start_standout();
+        /* Draw */
+        start_standout(nextshape->color);
         moveto(r, 2 * c);
         putstr("  ");
         for (i = 0; i < 3; i++) {
             t = c + r * B_COLS;
             t += nextshape->off[i];
             tr = t / B_COLS;
             tc = t % B_COLS;
             moveto(tr, 2*tc);
             putstr("  ");
         }
         resume_normal();
     }
     bp = &board[D_FIRST * B_COLS];
     sp = &curscreen[D_FIRST * B_COLS];
     for (j = D_FIRST; j < D_LAST; j++) {
 ,6 → 239,7
         for (i = 0; i < B_COLS; bp++, sp++, i++) {
             if (*sp == (so = *bp))
                 continue;
             *sp = so;
             if (i != ccol) {
                 if (cur_so) {
 ,15 → 248,16
                 }
                 moveto(RTOD(j), CTOD(i));
             }
             if (so != cur_so) {
                 if (so)
-                    start_standout();
+                    start_standout(so);
                 else
                     resume_normal();
                 cur_so = so;
             }
             putstr("  ");
             ccol = i + 1;
             /*
              * Look ahead a bit, to avoid extra motion if
 ,33 → 267,35
              * `unnecessarily'.  Skip it all, though, if
              * the next cell is a different color.
              */
-#define STOP (B_COLS - 3)
-            if (i > STOP || sp[1] != bp[1] || so != bp[1])
+            if ((i > STOP) || (sp[1] != bp[1]) || (so != bp[1]))
                 continue;
             if (sp[2] != bp[2])
                 sp[1] = -1;
-            else if (i < STOP && so == bp[2] && sp[3] != bp[3]) {
+            else if ((i < STOP) && (so == bp[2]) && (sp[3] != bp[3])) {
                 sp[2] = -1;
                 sp[1] = -1;
             }
         }
     }
     if (cur_so)
         resume_normal();
-    fflush(stdout);
+    fflush(stdout);
 }
 /*
- * Write a message (set!=0), or clear the same message (set==0).
+ * Write a message (set != 0), or clear the same message (set == 0).
  * (We need its length in case we have to overwrite with blanks.)
  */
-void
-scr_msg(char *s, int set)
+void scr_msg(char *s, int set)
 {
     int l = str_size(s);
     moveto(Rows - 2, ((Cols - l) >> 1) - 1);
     if (set)
         putstr(s);
     else
 ,4 → 305,3
 /** @}
  */

 /branches/network/uspace/app/tetris/tetris.h
 ,7 → 36,7
  */
 /** @addtogroup tetris
- * @{
+ * @{
  */
 /** @file
  */
 ,57 → 55,60
  * worrying about addressing problems.
  */
-    /* the board */
-#define B_COLS  12
-#define B_ROWS  23
-#define B_SIZE  (B_ROWS * B_COLS)
+/* The board */
+#define B_COLS  12
+#define B_ROWS  23
+#define B_SIZE  (B_ROWS * B_COLS)
-typedef unsigned char cell;
-extern cell board[B_SIZE];  /* 1 => occupied, 0 => empty */
+typedef uint32_t cell;
-    /* the displayed area (rows) */
-#define D_FIRST 1
-#define D_LAST  22
+extern cell board[B_SIZE];  /* 1 => occupied, 0 => empty */
-    /* the active area (rows) */
-#define A_FIRST 1
-#define A_LAST  21
+/* The displayed area (rows) */
+#define D_FIRST  1
+#define D_LAST   22
+/* The active area (rows) */
+#define A_FIRST  1
+#define A_LAST   21
 /*
  * Minimum display size.
  */
-#define MINROWS 23
-#define MINCOLS 40
+#define MINROWS  23
+#define MINCOLS  40
-extern int  Rows, Cols; /* current screen size */
+/* Current screen size */
+extern int Rows;
+extern int Cols;
 /*
  * Translations from board coordinates to display coordinates.
  * As with board coordinates, display coordiates are zero origin.
  */
-#define RTOD(x) ((x) - 1)
-#define CTOD(x) ((x) * 2 + (((Cols - 2 * B_COLS) >> 1) - 1))
+#define RTOD(x)  ((x) - 1)
+#define CTOD(x)  ((x) * 2 + (((Cols - 2 * B_COLS) >> 1) - 1))
 /*
  * A `shape' is the fundamental thing that makes up the game.  There
  * are 7 basic shapes, each consisting of four `blots':
  *
- *  X.X   X.X       X.X
- *    X.X   X.X X.X.X   X.X X.X.X   X.X.X   X.X.X.X
- *            X     X       X
+ *      X.X       X.X           X.X
+ *        X.X   X.X     X.X.X   X.X     X.X.X   X.X.X   X.X.X.X
+ *                        X             X           X
  *
- *    0   1   2   3   4   5   6
+ *          0     1       2       3       4       5       6
  *
  * Except for 3 and 6, the center of each shape is one of the blots.
- * This blot is designated (0,0).  The other three blots can then be
+ * This blot is designated (0, 0).  The other three blots can then be
  * described as offsets from the center.  Shape 3 is the same under
  * rotation, so its center is effectively irrelevant; it has been chosen
  * so that it `sticks out' upward and leftward.  Except for shape 6,
- * all the blots are contained in a box going from (-1,-1) to (+1,+1);
+ * all the blots are contained in a box going from (-1, -1) to (+1, +1);
  * shape 6's center `wobbles' as it rotates, so that while it `sticks out'
  * rightward, its rotation---a vertical line---`sticks out' downward.
- * The containment box has to include the offset (2,0), making the overall
- * containment box range from offset (-1,-1) to (+2,+1).  (This is why
+ * The containment box has to include the offset (2, 0), making the overall
+ * containment box range from offset (-1, -1) to (+2, +1).  (This is why
  * there is only one row above, but two rows below, the display area.)
  *
  * The game works by choosing one of these shapes at random and putting
 ,7 → 119,7
  * At this time, any completely filled rows are elided, and blots above
  * these rows move down to make more room.  A new random shape is again
  * introduced at the top of the board, and the whole process repeats.
- * The game ends when the new shape will not fit at (1,5).
+ * The game ends when the new shape will not fit at (1, 5).
  *
  * While the shapes are falling, the user can rotate them counterclockwise
  * 90 degrees (in addition to moving them left or right), provided that the
 ,9 → 131,10
  * rotated forms.
  */
 struct shape {
-    int rot;    /* index of rotated version of this shape */
-    int rotc;   /* -- " -- in classic version  */
-    int off[3]; /* offsets to other blots if center is at (0,0) */
+    int rot;     /* index of rotated version of this shape */
+    int rotc;    /* -- " -- in classic version  */
+    int off[3];  /* offsets to other blots if center is at (0,0) */
+    uint32_t color;
 };
 extern const struct shape shapes[];
 ,15 → 152,16
  * The value eventually reaches a limit, and things stop going faster,
  * but by then the game is utterly impossible.
  */
-extern long fallrate;   /* less than 1 million; smaller => faster */
-#define faster() (fallrate -= fallrate / 3000)
+extern long fallrate;  /* less than 1 million; smaller => faster */
+#define faster()  (fallrate -= fallrate / 3000)
 /*
  * Game level must be between 1 and 9.  This controls the initial fall rate
  * and affects scoring.
  */
-#define MINLEVEL    1
-#define MAXLEVEL    9
+#define MINLEVEL  1
+#define MAXLEVEL  9
 /*
  * Scoring is as follows:
 ,19 → 175,17
  *
  * If previewing has been turned on, the score is multiplied by PRE_PENALTY.
  */
-#define PRE_PENALTY 0.75
+#define PRE_PENALTY  0.75
-extern int  score;      /* the obvious thing */
-//extern gid_t  gid, egid;
+extern int score;  /* The obvious thing */
-extern char key_msg[100];
-extern int  showpreview;
-extern int  classic;
+extern char key_msg[100];
+extern int showpreview;
+extern int classic;
-int fits_in(const struct shape *, int);
-void    place(const struct shape *, int, int);
-void    stop(char *);
+extern int fits_in(const struct shape *, int);
+extern void place(const struct shape *, int, int);
+extern void stop(char *);
 /** @}
  */

 /branches/network/uspace/app/tetris/scores.h
 ,8 → 34,9
  *
  *  @(#)scores.h    8.1 (Berkeley) 5/31/93
  */
 /** @addtogroup tetris
- * @{
+ * @{
  */
 /** @file
  */
 ,26 → 45,27
 /*
  * Tetris scores.
  */
 #include <sys/time.h>
 #include <string.h>
-#define MAXLOGNAME 16
+#define MAXLOGNAME   16
+#define MAXHISCORES  10
+#define MAXSCORES    9  /* maximum high score entries per person */
+#define EXPIRATION   (5L * 365 * 24 * 60 * 60)
 struct highscore {
-    char    hs_name[STR_BOUNDS(MAXLOGNAME) + 1];    /* login name */
-    int hs_score;   /* raw score */
-    int hs_level;   /* play level */
-//  time_t  hs_time;    /* time at game end */
+    char hs_name[STR_BOUNDS(MAXLOGNAME) + 1];  /* login name */
+    int hs_score;                              /* raw score */
+    int hs_level;                              /* play level */
+    time_t hs_time;                            /* time at game end */
 };
-#define MAXHISCORES 10
-//#define MAXSCORES 9   /* maximum high score entries per person */
-//#define   EXPIRATION  (5L * 365 * 24 * 60 * 60)
+extern void showscores(int);
+extern void initscores(void);
+extern void insertscore(int score, int level);
+extern int loadscores(void);
+extern void savescores(void);
-void savescore(int);
-void showscores(int);
-void insertscore(int score, int level);
-void initscores(void);
 /** @}
  */

 /branches/network/uspace/app/tetris/shapes.c
 ,7 → 36,7
  */
 /** @addtogroup tetris
- * @{
+ * @{
  */
 /** @file
  */
 ,35 → 50,35
 #include <unistd.h>
 #include "tetris.h"
-#define TL  -B_COLS-1   /* top left */
-#define TC  -B_COLS     /* top center */
-#define TR  -B_COLS+1   /* top right */
-#define ML  -1      /* middle left */
-#define MR  1       /* middle right */
-#define BL  B_COLS-1    /* bottom left */
-#define BC  B_COLS      /* bottom center */
-#define BR  B_COLS+1    /* bottom right */
+#define TL  (-B_COLS - 1)  /* top left */
+#define TC  (-B_COLS)      /* top center */
+#define TR  (-B_COLS + 1)  /* top right */
+#define ML  -1             /* middle left */
+#define MR  1              /* middle right */
+#define BL  (B_COLS - 1)   /* bottom left */
+#define BC  B_COLS         /* bottom center */
+#define BR  (B_COLS + 1)   /* bottom right */
 const struct shape shapes[] = {
-    /* 0*/  { 7,    7,  { TL, TC, MR } },
-    /* 1*/  { 8,    8,  { TC, TR, ML } },
-    /* 2*/  { 9,    11, { ML, MR, BC } },
-    /* 3*/  { 3,    3,  { TL, TC, ML } },
-    /* 4*/  { 12,   14, { ML, BL, MR } },
-    /* 5*/  { 15,   17, { ML, BR, MR } },
-    /* 6*/  { 18,   18, { ML, MR, 2  } }, /* sticks out */
-    /* 7*/  { 0,    0,  { TC, ML, BL } },
-    /* 8*/  { 1,    1,  { TC, MR, BR } },
-    /* 9*/  { 10,   2,  { TC, MR, BC } },
-    /*10*/  { 11,   9,  { TC, ML, MR } },
-    /*11*/  { 2,    10, { TC, ML, BC } },
-    /*12*/  { 13,   4,  { TC, BC, BR } },
-    /*13*/  { 14,   12, { TR, ML, MR } },
-    /*14*/  { 4,    13, { TL, TC, BC } },
-    /*15*/  { 16,   5,  { TR, TC, BC } },
-    /*16*/  { 17,   15, { TL, MR, ML } },
-    /*17*/  { 5,    16, { TC, BC, BL } },
-    /*18*/  { 6,    6,  { TC, BC, 2*B_COLS } }/* sticks out */
+    /*  0 */  {  7,  7, { TL, TC, MR }, 0xff042d},
+    /*  1 */  {  8,  8, { TC, TR, ML }, 0xff9304},
+    /*  2 */  {  9, 11, { ML, MR, BC }, 0xbeff04},
+    /*  3 */  {  3,  3, { TL, TC, ML }, 0x63ff04},
+    /*  4 */  { 12, 14, { ML, BL, MR }, 0xce04ff},
+    /*  5 */  { 15, 17, { ML, BR, MR }, 0xff04cf},
+    /*  6 */  { 18, 18, { ML, MR, 2  }, 0x7604ff},  /* sticks out */
+    /*  7 */  {  0,  0, { TC, ML, BL }, 0xff042d},
+    /*  8 */  {  1,  1, { TC, MR, BR }, 0xff9304},
+    /*  9 */  { 10,  2, { TC, MR, BC }, 0xbeff04},
+    /* 10 */  { 11,  9, { TC, ML, MR }, 0xbeff04},
+    /* 11 */  {  2, 10, { TC, ML, BC }, 0xbeff04},
+    /* 12 */  { 13,  4, { TC, BC, BR }, 0xce04ff},
+    /* 13 */  { 14, 12, { TR, ML, MR }, 0xce04ff},
+    /* 14 */  {  4, 13, { TL, TC, BC }, 0xce04ff},
+    /* 15 */  { 16,  5, { TR, TC, BC }, 0xff04cf},
+    /* 16 */  { 17, 15, { TL, MR, ML }, 0xff04cf},
+    /* 17 */  {  5, 16, { TC, BC, BL }, 0xff04cf},
+    /* 18 */  {  6,  6, { TC, BC, 2 * B_COLS }, 0x7604ff}  /* sticks out */
 };
 /*
 ,14 → 85,14
  * Return true iff the given shape fits in the given position,
  * taking the current board into account.
  */
-int
-fits_in(const struct shape *shape, int pos)
+int fits_in(const struct shape *shape, int pos)
 {
     int *o = shape->off;
-    if (board[pos] || board[pos + *o++] || board[pos + *o++] ||
-        board[pos + *o])
+    if ((board[pos]) || (board[pos + *o++]) || (board[pos + *o++]) ||
+        (board[pos + *o]))
         return 0;
     return 1;
 }
 ,17 → 100,15
  * Write the given shape into the current board, turning it on
  * if `onoff' is 1, and off if `onoff' is 0.
  */
-void
-place(const struct shape *shape, int pos, int onoff)
+void place(const struct shape *shape, int pos, int onoff)
 {
     int *o = shape->off;
-    board[pos] = onoff;
-    board[pos + *o++] = onoff;
-    board[pos + *o++] = onoff;
-    board[pos + *o] = onoff;
+    board[pos] = onoff ? shape->color : 0x000000;
+    board[pos + *o++] = onoff ? shape->color : 0x000000;
+    board[pos + *o++] = onoff ? shape->color : 0x000000;
+    board[pos + *o] = onoff ? shape->color : 0x000000;
 }
 /** @}
  */

 /branches/network/uspace/app/tetris/input.h
 ,15 → 36,14
  */
 /** @addtogroup tetris
- * @{
+ * @{
  */
 /** @file
  */
-int rwait(struct timeval *);
-int tgetchar(void);
-void    tsleep(void);
+extern int rwait(struct timeval *);
+extern int tgetchar(void);
+extern void tsleep(void);
 /** @}
  */

 /branches/network/uspace/app/tetris/screen.h
 ,36 → 36,37
  */
 /** @addtogroup tetris
- * @{
+ * @{
  */
 /** @file
  */
 /*
- * putpad() is for padded strings with count=1.
+ * putpad() is for padded strings with count = 1.
  */
-#define putpad(s)   tputs(s, 1, put)
+#define putpad(s)  tputs(s, 1, put)
+#include <sys/types.h>
 #include <async.h>
 typedef struct {
-    int ws_row;
-    int ws_col;
+    ipcarg_t ws_row;
+    ipcarg_t ws_col;
 } winsize_t;
 extern winsize_t winsize;
-void moveto(int r, int c);
-void clear_screen(void);
+extern void moveto(int r, int c);
+extern void clear_screen(void);
-int put(int);           /* just calls putchar; for tputs */
-void    scr_clear(void);
-void    scr_end(void);
-void    scr_init(void);
-void    scr_msg(char *, int);
-void    scr_set(void);
-void    scr_update(void);
+/* just calls putchar; for tputs */
+extern int put(int);
+extern void scr_clear(void);
+extern void scr_end(void);
+extern void scr_init(void);
+extern void scr_msg(char *, int);
+extern void scr_set(void);
+extern void scr_update(void);
 /** @}
  */

 /branches/network/uspace/app/tetris/tetris.c
 ,30 → 36,25
  */
 /** @addtogroup tetris Tetris
- * @brief   Tetris ported from OpenBSD
- * @{
+ * @brief Tetris ported from OpenBSD
+ * @{
  */
 /** @file
  */
-#ifndef lint
 static const char copyright[] =
-"@(#) Copyright (c) 1992, 1993\n\
-    The Regents of the University of California.  All rights reserved.\n";
-#endif /* not lint */
+    "@(#) Copyright (c) 1992, 1993\n"
+    "\tThe Regents of the University of California.  All rights reserved.\n";
-/*
- * Tetris (or however it is spelled).
- */
 #include <sys/time.h>
 #include <sys/types.h>
 #include <err.h>
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#include <getopt.h>
 #include "input.h"
 #include "scores.h"
 ,66 → 61,76
 #include "screen.h"
 #include "tetris.h"
-cell    board[B_SIZE];
-int Rows, Cols;
+cell board[B_SIZE];
+int Rows;
+int Cols;
 const struct shape *curshape;
 const struct shape *nextshape;
-long    fallrate;
-int score;
-//gid_t gid, egid;
-char    key_msg[100];
-int showpreview, classic;
-static void elide(void);
-static void setup_board(void);
-const struct shape *randshape(void);
-void    onintr(int);
-void    usage(void);
+long fallrate;
+int score;
+char key_msg[100];
+int showpreview;
+int classic;
+static void elide(void);
+static void setup_board(void);
+static const struct shape *randshape(void);
+static void usage(void);
+static int firstgame = 1;
 /*
- * Set up the initial board.  The bottom display row is completely set,
- * along with another (hidden) row underneath that.  Also, the left and
+ * Set up the initial board. The bottom display row is completely set,
+ * along with another (hidden) row underneath that. Also, the left and
  * right edges are set.
  */
-static void
-setup_board(void)
+static void setup_board(void)
 {
     int i;
-    cell *p;
-    p = board;
+    cell *p = board;
     for (i = B_SIZE; i; i--)
-        *p++ = i <= (2 * B_COLS) || (i % B_COLS) < 2;
+        *p++ = (i <= (2 * B_COLS) || (i % B_COLS) < 2) ? 0x0000ff : 0x000000;
 }
 /*
  * Elide any full active rows.
  */
-static void
-elide(void)
+static void elide(void)
 {
     int rows = 0;
-    int i, j, base;
+    int i;
+    int j;
+    int base;
     cell *p;
     for (i = A_FIRST; i < A_LAST; i++) {
         base = i * B_COLS + 1;
         p = &board[base];
         for (j = B_COLS - 2; *p++ != 0;) {
             if (--j <= 0) {
-                /* this row is to be elided */
+                /* This row is to be elided */
                 rows++;
-                memset(&board[base], 0, B_COLS - 2);
+                memset(&board[base], 0, sizeof(cell) * (B_COLS - 2));
                 scr_update();
                 tsleep();
                 while (--base != 0)
                     board[base + B_COLS] = board[base];
                 scr_update();
                 tsleep();
                 break;
             }
         }
     }
     switch (rows) {
     case 1:
         score += 10;
 ,16 → 149,15
     }
 }
-const struct shape *
-randshape(void)
+const struct shape *randshape(void)
 {
-    const struct shape *tmp;
-    int i, j;
-    tmp = &shapes[random() % 7];
-    j = random() % 4;
+    const struct shape *tmp = &shapes[random() % 7];
+    int i;
+    int j = random() % 4;
     for (i = 0; i < j; i++)
-        tmp = &shapes[classic? tmp->rotc : tmp->rot];
+        tmp = &shapes[classic ? tmp->rotc : tmp->rot];
     return (tmp);
 }
 ,7 → 164,7
 static void srandomdev(void)
 {
     struct timeval tv;
     gettimeofday(&tv, NULL);
     srandom(tv.tv_sec + tv.tv_usec / 100000);
 }
 ,61 → 171,43
 static void tetris_menu_draw(int level)
 {
-        clear_screen();
-        moveto(5,10);
-        puts("Tetris\n\n");
-        moveto(8,10);
-        printf("Level = %d (press keys 1 - 9 to change)",level);
-        moveto(9,10);
-        printf("Preview is %s (press 'p' to change)", (showpreview?"on ":"off"));
-        moveto(12,10);
-        printf("Press 'h' to show hiscore table.");
-        moveto(13,10);
-        printf("Press 's' to start game.");
-        moveto(14,10);
-        printf("Press 'q' to quit game.");
-        moveto(20,10);
-        printf("In game controls:");
-        moveto(21,0);
-        puts(key_msg);
+    clear_screen();
+    moveto(5, 10);
+    puts("Tetris\n\n");
+    moveto(8, 10);
+    printf("Level = %d (press keys 1 - 9 to change)", level);
+    moveto(9, 10);
+    printf("Preview is %s (press 'p' to change)", (showpreview ? "on ": "off"));
+    moveto(12, 10);
+    printf("Press 'h' to show hiscore table.");
+    moveto(13, 10);
+    printf("Press 's' to start game.");
+    moveto(14, 10);
+    printf("Press 'q' to quit game.");
+    moveto(20, 10);
+    printf("In game controls:");
+    moveto(21, 0);
+    puts(key_msg);
 }
-static int tetris_menu(int *level)
+static int tetris_menu(int *level)
 {
-    static int firstgame = 1;
-    int i;
-/*  if (showpreview == 0)
-        (void)printf("Your score:  %d point%s  x  level %d  =  %d\n",
-            score, score == 1 ? "" : "s", level, score * level);
-    else {
-        (void)printf("Your score:  %d point%s x level %d x preview penalty %0.3f = %d\n",
-            score, score == 1 ? "" : "s", level, (double)PRE_PENALTY,
-            (int)(score * level * PRE_PENALTY));
-        score = score * PRE_PENALTY;
-    }
-    savescore(level);
-    showscores(level);
-    printf("\nHit 's' to new game, 'q' to quit.\n");
-*/
     tetris_menu_draw(*level);
     while (1) {
-        i = getchar();
+        int i = getchar();
         switch(i) {
             case 'p':
                 showpreview = !showpreview;
-                moveto(9,21);
+                moveto(9, 21);
                 if (showpreview)
                     printf("on ");
                 else
                     printf("off");
                 break;
             case 'h':
+                loadscores();
                 showscores(firstgame);
                 tetris_menu_draw(*level);
                 break;
 ,112 → 221,103
             case '3':
             case '4':
             case '5':
-            case '6':
+            case '6':
             case '7':
             case '8':
             case '9':
                 *level = i - '0';
-                moveto(8,18);
+                moveto(8, 18);
                 printf("%d", *level);
                 break;
         }
     }
 }
-int
-main(int argc, char *argv[])
+int main(int argc, char *argv[])
 {
-    int pos, c;
+    int pos;
+    int c;
     char *keys;
     int level = 2;
     char key_write[6][10];
-    int i, j;
+    int i;
+    int j;
+    int ch;
     keys = "jkl pq";
-//  gid = getgid();
-//  egid = getegid();
-//  setegid(gid);
     classic = 0;
     showpreview = 1;
-/*  while ((ch = getopt(argc, argv, "ck:l:ps")) != -1) */
-/*      switch(ch) { */
-/*      case 'c': */
-/*          /\* */
-/*           * this means: */
-/*           *  - rotate the other way; */
-/*           *  - no reverse video. */
-/*           *\/ */
-/*          classic = 1; */
-/*          break; */
-/*      case 'k': */
-/*          if (str_size(keys = optarg) != 6) */
-/*              usage(); */
-/*          break; */
-/*      case 'l': */
-/*          level = (int)strtonum(optarg, MINLEVEL, MAXLEVEL, */
-/*              &errstr); */
-/*          if (errstr) */
-/*              errx(1, "level must be from %d to %d", */
-/*                  MINLEVEL, MAXLEVEL); */
-/*          break; */
-/*      case 'p': */
-/*          showpreview = 1; */
-/*          break; */
-/*      case 's': */
-/*          showscores(0); */
-/*          exit(0); */
-/*      default: */
-/*          usage(); */
-/*      } */
-/*  argc -= optind; */
-/*  argv += optind; */
-/*  if (argc) */
-/*      usage(); */
+    while ((ch = getopt(argc, argv, "ck:ps")) != -1)
+        switch(ch) {
+        case 'c':
+            /*
+             * this means:
+             *  - rotate the other way
+             *  - no reverse video
+             */
+            classic = 1;
+            break;
+        case 'k':
+            if (str_size(keys = optarg) != 6)
+                usage();
+            break;
+        case 'p':
+            showpreview = 1;
+            break;
+        case 's':
+            showscores(0);
+            exit(0);
+        default:
+            usage();
+        }
+    argc -= optind;
+    argv += optind;
+    if (argc)
+        usage();
     for (i = 0; i <= 5; i++) {
-        for (j = i+1; j <= 5; j++) {
+        for (j = i + 1; j <= 5; j++) {
             if (keys[i] == keys[j])
                 errx(1, "duplicate command keys specified.");
         }
         if (keys[i] == ' ')
-            str_cpy(key_write[i], sizeof key_write[i], "<space>");
+            str_cpy(key_write[i], sizeof(key_write[i]), "<space>");
         else {
             key_write[i][0] = keys[i];
             key_write[i][1] = '\0';
         }
     }
+    snprintf(key_msg, sizeof(key_msg),
+        "%s - left   %s - rotate   %s - right   %s - drop   %s - pause   %s - quit",
+        key_write[0], key_write[1], key_write[2], key_write[3],
+        key_write[4], key_write[5]);
+    scr_init();
+    if (loadscores() != EOK)
+        initscores();
-    snprintf(key_msg, sizeof key_msg,
-"%s - left   %s - rotate   %s - right   %s - drop   %s - pause   %s - quit",
-        key_write[0], key_write[1], key_write[2], key_write[3],
-        key_write[4], key_write[5]);
-    scr_init();
-    initscores();
     while (tetris_menu(&level)) {
         fallrate = 1000000 / level;
         scr_clear();
         setup_board();
         srandomdev();
         scr_set();
-        pos = A_FIRST*B_COLS + (B_COLS/2)-1;
+        pos = A_FIRST * B_COLS + (B_COLS / 2) - 1;
         nextshape = randshape();
         curshape = randshape();
         scr_msg(key_msg, 1);
-        for (;;) {
+        while (1) {
             place(curshape, pos, 1);
             scr_update();
             place(curshape, pos, 0);
 ,7 → 330,7
                     pos += B_COLS;
                     continue;
                 }
                 /*
                  * Put up the current shape `permanently',
                  * bump score, and elide any full rows.
 ,7 → 338,7
                 place(curshape, pos, 1);
                 score++;
                 elide();
                 /*
                  * Choose a new shape.  If it does not fit,
                  * the game is over.
 ,12 → 345,14
                  */
                 curshape = nextshape;
                 nextshape = randshape();
-                pos = A_FIRST*B_COLS + (B_COLS/2)-1;
+                pos = A_FIRST * B_COLS + (B_COLS / 2) - 1;
                 if (!fits_in(curshape, pos))
                     break;
                 continue;
             }
             /*
              * Handle command keys.
              */
 ,10 → 360,11
                 /* quit */
                 break;
             }
             if (c == keys[4]) {
                 static char msg[] =
                     "paused - press RETURN to continue";
                 place(curshape, pos, 1);
                 do {
                     scr_update();
 ,12 → 371,14
                     scr_msg(key_msg, 0);
                     scr_msg(msg, 1);
                     (void) fflush(stdout);
-                } while (rwait((struct timeval *)NULL) == -1);
+                } while (rwait((struct timeval *) NULL) == -1);
                 scr_msg(msg, 0);
                 scr_msg(key_msg, 1);
                 place(curshape, pos, 0);
                 continue;
             }
             if (c == keys[0]) {
                 /* move left */
                 if (fits_in(curshape, pos - 1))
 ,15 → 385,17
                     pos--;
                 continue;
             }
             if (c == keys[1]) {
                 /* turn */
-                const struct shape *new = &shapes[
-                    classic? curshape->rotc : curshape->rot];
+                const struct shape *new =
+                    &shapes[classic ? curshape->rotc : curshape->rot];
                 if (fits_in(new, pos))
                     curshape = new;
                 continue;
             }
             if (c == keys[2]) {
                 /* move right */
                 if (fits_in(curshape, pos + 1))
 ,6 → 402,7
                     pos++;
                 continue;
             }
             if (c == keys[3]) {
                 /* move to bottom */
                 while (fits_in(curshape, pos + B_COLS)) {
 ,6 → 411,7
                 }
                 continue;
             }
             if (c == '\f') {
                 scr_clear();
                 scr_msg(key_msg, 1);
 ,37 → 419,24
         }
         scr_clear();
+        loadscores();
         insertscore(score, level);
-        score=0;
+        savescores();
+        score = 0;
     }
     scr_clear();
-    printf("\n\n\n\t\tGame over.\n");
-/*
-    while ((i = getchar()) != '\n')
-        if (i == EOF)
-            break
-*/
+    printf("\nGame over.\n");
     scr_end();
     return 0;
 }
-/* void */
-/* onintr(int signo) */
-/* { */
-/*  scr_clear();        /\* XXX signal race *\/ */
-/*  scr_end();      /\* XXX signal race *\/ */
-/*  _exit(0); */
-/* } */
-void
-usage(void)
+void usage(void)
 {
-    (void)fprintf(stderr, "usage: tetris [-ps] [-k keys] [-l level]\n");
+    fprintf(stderr, "usage: tetris [-ps] [-k keys]\n");
     exit(1);
 }
 /** @}
  */

 /branches/network/uspace/app/tetris/Makefile
 ,7 → 27,7
 disasm: $(OUTPUT).disasm
 $(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
+    $(OBJDUMP) -d $< > $@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/network/uspace/app/klog/Makefile
 ,7 → 64,7
 disasm: $(OUTPUT).disasm
 $(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
+    $(OBJDUMP) -d $< > $@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/network/uspace/app/klog/klog.c
 ,41 → 40,34
 #include <ipc/services.h>
 #include <as.h>
 #include <sysinfo.h>
-#include <io/stream.h>
-#include <console.h>
 #include <event.h>
 #include <errno.h>
+#include <io/klog.h>
-#define NAME "klog"
+#define NAME  "klog"
 /* Pointer to klog area */
 static wchar_t *klog;
-static count_t klog_length;
+static size_t klog_length;
 static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
 {
-    async_serialize_start();
+    size_t klog_start = (size_t) IPC_GET_ARG1(*call);
+    size_t klog_len = (size_t) IPC_GET_ARG2(*call);
+    size_t klog_stored = (size_t) IPC_GET_ARG3(*call);
+    size_t i;
-    count_t klog_start = (count_t) IPC_GET_ARG1(*call);
-    count_t klog_len = (count_t) IPC_GET_ARG2(*call);
-    count_t klog_stored = (count_t) IPC_GET_ARG3(*call);
-    count_t i;
     for (i = klog_len - klog_stored; i < klog_len; i++)
         putchar(klog[(klog_start + i) % klog_length]);
-    async_serialize_end();
 }
 int main(int argc, char *argv[])
 {
-    console_wait();
-    count_t klog_pages = sysinfo_value("klog.pages");
+    size_t klog_pages = sysinfo_value("klog.pages");
     size_t klog_size = klog_pages * PAGE_SIZE;
     klog_length = klog_size / sizeof(wchar_t);
-    klog = (wchar_t *) as_get_mappable_page(klog_pages);
+    klog = (wchar_t *) as_get_mappable_page(klog_size);
     if (klog == NULL) {
         printf(NAME ": Error allocating memory area\n");
         return -1;

 /branches/network/uspace/app/trace/trace.c
 ,6 → 41,8
 #include <udebug.h>
 #include <async.h>
 #include <task.h>
+#include <mem.h>
+#include <string.h>
 #include <loader/loader.h>
 #include <libc.h>
 ,11 → 663,8
     resp_def[0] = V_INTEGER; resp_def[1] = V_INTEGER;
     resp_def[2] = V_INTEGER; resp_def[3] = V_CHAR;
     o = oper_new("getkey", 0, arg_def, V_ERRNO, 4, resp_def);
-    proto_add_oper(p, CONSOLE_GETKEY, o);
     arg_def[0] = V_CHAR;
-    o = oper_new("putchar", 1, arg_def, V_VOID, 0, resp_def);
-    proto_add_oper(p, CONSOLE_PUTCHAR, o);
     o = oper_new("clear", 0, arg_def, V_VOID, 0, resp_def);
     proto_add_oper(p, CONSOLE_CLEAR, o);
 ,9 → 674,7
     resp_def[0] = V_INTEGER; resp_def[1] = V_INTEGER;
     o = oper_new("getsize", 0, arg_def, V_INTEGER, 2, resp_def);
-    proto_add_oper(p, CONSOLE_GETSIZE, o);
-    o = oper_new("flush", 0, arg_def, V_VOID, 0, resp_def);
-    proto_add_oper(p, CONSOLE_FLUSH, o);
+    proto_add_oper(p, CONSOLE_GET_SIZE, o);
     arg_def[0] = V_INTEGER;
     o = oper_new("set_style", 1, arg_def, V_VOID, 0, resp_def);

 /branches/network/uspace/app/trace/proto.c
 ,7 → 35,7
 #include <stdio.h>
 #include <stdlib.h>
 #include <ipc/ipc.h>
-#include <libadt/hash_table.h>
+#include <adt/hash_table.h>
 #include "trace.h"
 #include "proto.h"

 /branches/network/uspace/app/trace/proto.h
 ,7 → 35,7
 #ifndef PROTO_H_
 #define PROTO_H_
-#include <libadt/hash_table.h>
+#include <adt/hash_table.h>
 #include <ipc/ipc.h>
 #include "trace.h"

 /branches/network/uspace/app/trace/ipcp.c
 ,7 → 34,7
 #include <stdio.h>
 #include <stdlib.h>
-#include <libadt/hash_table.h>
+#include <adt/hash_table.h>
 #include "ipc_desc.h"
 #include "proto.h"

 /branches/network/uspace/lib/libfs/libfs.c
 ,5 → 1,5
 /*
- * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2009 Jakub Jermar
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,6 → 42,7
 #include <as.h>
 #include <assert.h>
 #include <dirent.h>
+#include <mem.h>
 /** Register file system server.
  *
 ,23 → 123,106
     return IPC_GET_RETVAL(answer);
 }
+void fs_node_initialize(fs_node_t *fn)
+{
+    memset(fn, 0, sizeof(fs_node_t));
+}
+void libfs_mount(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
+    ipc_call_t *request)
+{
+    dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+    fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*request);
+    fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request);
+    dev_handle_t mr_dev_handle = (dev_handle_t) IPC_GET_ARG4(*request);
+    int res;
+    ipcarg_t rc;
+    ipc_call_t call;
+    ipc_callid_t callid;
+    /* accept the phone */
+    callid = async_get_call(&call);
+    int mountee_phone = (int)IPC_GET_ARG1(call);
+    if ((IPC_GET_METHOD(call) != IPC_M_CONNECTION_CLONE) ||
+        mountee_phone < 0) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    ipc_answer_0(callid, EOK);  /* acknowledge the mountee_phone */
+    res = ipc_data_write_receive(&callid, NULL);
+    if (!res) {
+        ipc_hangup(mountee_phone);
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    fs_node_t *fn = ops->node_get(mp_dev_handle, mp_fs_index);
+    if (!fn) {
+        ipc_hangup(mountee_phone);
+        ipc_answer_0(callid, ENOENT);
+        ipc_answer_0(rid, ENOENT);
+        return;
+    }
+    if (fn->mp_data.mp_active) {
+        ipc_hangup(mountee_phone);
+        ops->node_put(fn);
+        ipc_answer_0(callid, EBUSY);
+        ipc_answer_0(rid, EBUSY);
+        return;
+    }
+    rc = async_req_0_0(mountee_phone, IPC_M_CONNECT_ME);
+    if (rc != 0) {
+        ipc_hangup(mountee_phone);
+        ops->node_put(fn);
+        ipc_answer_0(callid, rc);
+        ipc_answer_0(rid, rc);
+        return;
+    }
+    ipc_call_t answer;
+    aid_t msg = async_send_1(mountee_phone, VFS_MOUNTED, mr_dev_handle,
+        &answer);
+    ipc_forward_fast(callid, mountee_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
+    async_wait_for(msg, &rc);
+    if (rc == EOK) {
+        fn->mp_data.mp_active = true;
+        fn->mp_data.fs_handle = mr_fs_handle;
+        fn->mp_data.dev_handle = mr_dev_handle;
+        fn->mp_data.phone = mountee_phone;
+    }
+    /*
+     * Do not release the FS node so that it stays in memory.
+     */
+    ipc_answer_3(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
+        IPC_GET_ARG3(answer));
+}
 /** Lookup VFS triplet by name in the file system name space.
  *
  * The path passed in the PLB must be in the canonical file system path format
  * as returned by the canonify() function.
  *
- * @param ops       libfs operations structure with function pointers to
- *          file system implementation
- * @param fs_handle File system handle of the file system where to perform
- *          the lookup.
- * @param rid       Request ID of the VFS_LOOKUP request.
- * @param request   VFS_LOOKUP request data itself.
+ * @param ops       libfs operations structure with function pointers to
+ *                  file system implementation
+ * @param fs_handle File system handle of the file system where to perform
+ *                  the lookup.
+ * @param rid       Request ID of the VFS_LOOKUP request.
+ * @param request   VFS_LOOKUP request data itself.
+ *
  */
 void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
     ipc_call_t *request)
 {
-    unsigned next = IPC_GET_ARG1(*request);
+    unsigned first = IPC_GET_ARG1(*request);
     unsigned last = IPC_GET_ARG2(*request);
+    unsigned next = first;
     dev_handle_t dev_handle = IPC_GET_ARG3(*request);
     int lflag = IPC_GET_ARG4(*request);
     fs_index_t index = IPC_GET_ARG5(*request); /* when L_LINK specified */
 ,10 → 232,18
     if (last < next)
         last += PLB_SIZE;
-    void *par = NULL;
-    void *cur = ops->root_get(dev_handle);
-    void *tmp = NULL;
+    fs_node_t *par = NULL;
+    fs_node_t *cur = ops->root_get(dev_handle);
+    fs_node_t *tmp = NULL;
+    if (cur->mp_data.mp_active) {
+        ipc_forward_slow(rid, cur->mp_data.phone, VFS_LOOKUP,
+            next, last, cur->mp_data.dev_handle, lflag, index,
+            IPC_FF_ROUTE_FROM_ME);
+        ops->node_put(cur);
+        return;
+    }
     if (ops->plb_get_char(next) == '/')
         next++;     /* eat slash */
 ,6 → 266,21
         /* match the component */
         tmp = ops->match(cur, component);
+        if (tmp && tmp->mp_data.mp_active) {
+            if (next > last)
+                next = last = first;
+            else
+                next--;
+            ipc_forward_slow(rid, tmp->mp_data.phone, VFS_LOOKUP,
+                next, last, tmp->mp_data.dev_handle, lflag, index,
+                IPC_FF_ROUTE_FROM_ME);
+            ops->node_put(cur);
+            ops->node_put(tmp);
+            if (par)
+                ops->node_put(par);
+            return;
+        }
         /* handle miss: match amongst siblings */
         if (!tmp) {
 ,39 → 296,33
                     ipc_answer_0(rid, ENOTDIR);
                     goto out;
                 }
-                void *nodep;
+                fs_node_t *fn;
                 if (lflag & L_CREATE)
-                    nodep = ops->create(dev_handle, lflag);
+                    fn = ops->create(dev_handle, lflag);
                 else
-                    nodep = ops->node_get(dev_handle,
+                    fn = ops->node_get(dev_handle,
                         index);
-                if (nodep) {
+                if (fn) {
                     int rc;
-                    rc = ops->link(cur, nodep, component);
+                    rc = ops->link(cur, fn, component);
                     if (rc != EOK) {
                         if (lflag & L_CREATE) {
-                            (void)ops->destroy(
-                                nodep);
+                            (void)ops->destroy(fn);
                         }
                         ipc_answer_0(rid, rc);
                     } else {
                         ipc_answer_5(rid, EOK,
                             fs_handle, dev_handle,
-                            ops->index_get(nodep),
-                            ops->size_get(nodep),
-                            ops->lnkcnt_get(nodep));
-                        ops->node_put(nodep);
+                            ops->index_get(fn),
+                            ops->size_get(fn),
+                            ops->lnkcnt_get(fn));
+                        ops->node_put(fn);
                     }
                 } else {
                     ipc_answer_0(rid, ENOSPC);
                 }
                 goto out;
-            } else if (lflag & L_PARENT) {
-                /* return parent */
-                ipc_answer_5(rid, EOK, fs_handle, dev_handle,
-                    ops->index_get(cur), ops->size_get(cur),
-                    ops->lnkcnt_get(cur));
             }
             ipc_answer_0(rid, ENOENT);
             goto out;
 ,26 → 364,26
             assert(len);
             component[len] = '\0';
-            void *nodep;
+            fs_node_t *fn;
             if (lflag & L_CREATE)
-                nodep = ops->create(dev_handle, lflag);
+                fn = ops->create(dev_handle, lflag);
             else
-                nodep = ops->node_get(dev_handle, index);
-            if (nodep) {
+                fn = ops->node_get(dev_handle, index);
+            if (fn) {
                 int rc;
-                rc = ops->link(cur, nodep, component);
+                rc = ops->link(cur, fn, component);
                 if (rc != EOK) {
                     if (lflag & L_CREATE)
-                        (void)ops->destroy(nodep);
+                        (void)ops->destroy(fn);
                     ipc_answer_0(rid, rc);
                 } else {
                     ipc_answer_5(rid, EOK,
                         fs_handle, dev_handle,
-                        ops->index_get(nodep),
-                        ops->size_get(nodep),
-                        ops->lnkcnt_get(nodep));
-                    ops->node_put(nodep);
+                        ops->index_get(fn),
+                        ops->size_get(fn),
+                        ops->lnkcnt_get(fn));
+                    ops->node_put(fn);
                 }
             } else {
                 ipc_answer_0(rid, ENOSPC);
 ,18 → 395,9
     }
     /* handle hit */
-    if (lflag & L_PARENT) {
-        ops->node_put(cur);
-        cur = par;
-        par = NULL;
-        if (!cur) {
-            ipc_answer_0(rid, ENOENT);
-            goto out;
-        }
-    }
     if (lflag & L_UNLINK) {
         unsigned old_lnkcnt = ops->lnkcnt_get(cur);
-        int res = ops->unlink(par, cur);
+        int res = ops->unlink(par, cur, component);
         ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,
             ops->index_get(cur), ops->size_get(cur), old_lnkcnt);
         goto out;
 ,5 → 428,32
         ops->node_put(tmp);
 }
+/** Open VFS triplet.
+ *
+ * @param ops       libfs operations structure with function pointers to
+ *                  file system implementation
+ * @param rid       Request ID of the VFS_OPEN_NODE request.
+ * @param request   VFS_OPEN_NODE request data itself.
+ *
+ */
+void libfs_open_node(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
+    ipc_call_t *request)
+{
+    dev_handle_t dev_handle = IPC_GET_ARG1(*request);
+    fs_index_t index = IPC_GET_ARG2(*request);
+    fs_node_t *node = ops->node_get(dev_handle, index);
+    if (node == NULL) {
+        ipc_answer_0(rid, ENOENT);
+        return;
+    }
+    ipc_answer_5(rid, EOK, fs_handle, dev_handle, index,
+        ops->size_get(node), ops->lnkcnt_get(node));
+    ops->node_put(node);
+}
 /** @}
  */

 /branches/network/uspace/lib/libfs/libfs.h
 ,5 → 1,5
 /*
- * Copyright (c) 2007 Jakub Jermar
+ * Copyright (c) 2009 Jakub Jermar
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,51 → 26,68
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup libfs
+/** @addtogroup libfs
  * @{
- */
+ */
 /**
  * @file
  */
 #ifndef LIBFS_LIBFS_H_
-#define LIBFS_LIBFS_H_
+#define LIBFS_LIBFS_H_
-#include "../../srv/vfs/vfs.h"
+#include <ipc/vfs.h>
 #include <stdint.h>
 #include <ipc/ipc.h>
 #include <async.h>
+#include <devmap.h>
 typedef struct {
-    void * (* match)(void *, const char *);
-    void * (* node_get)(dev_handle_t, fs_index_t);
-    void (* node_put)(void *);
-    void * (* create)(dev_handle_t, int);
-    int (* destroy)(void *);
-    int (* link)(void *, void *, const char *);
-    int (* unlink)(void *, void *);
-    fs_index_t (* index_get)(void *);
-    size_t (* size_get)(void *);
-    unsigned (* lnkcnt_get)(void *);
-    bool (* has_children)(void *);
-    void *(* root_get)(dev_handle_t);
-    char (* plb_get_char)(unsigned pos);
-    bool (* is_directory)(void *);
-    bool (* is_file)(void *);
+    bool mp_active;
+    int phone;
+    fs_handle_t fs_handle;
+    dev_handle_t dev_handle;
+} mp_data_t;
+typedef struct {
+    mp_data_t mp_data;  /**< Mount point info. */
+    void *data;         /**< Data of the file system implementation. */
+} fs_node_t;
+typedef struct {
+    fs_node_t * (* match)(fs_node_t *, const char *);
+    fs_node_t * (* node_get)(dev_handle_t, fs_index_t);
+    void (* node_put)(fs_node_t *);
+    fs_node_t * (* create)(dev_handle_t, int);
+    int (* destroy)(fs_node_t *);
+    int (* link)(fs_node_t *, fs_node_t *, const char *);
+    int (* unlink)(fs_node_t *, fs_node_t *, const char *);
+    fs_index_t (* index_get)(fs_node_t *);
+    size_t (* size_get)(fs_node_t *);
+    unsigned (* lnkcnt_get)(fs_node_t *);
+    bool (* has_children)(fs_node_t *);
+    fs_node_t *(* root_get)(dev_handle_t);
+    char (* plb_get_char)(unsigned pos);
+    bool (* is_directory)(fs_node_t *);
+    bool (* is_file)(fs_node_t *);
 } libfs_ops_t;
 typedef struct {
-    int fs_handle;      /**< File system handle. */
-    ipcarg_t vfs_phonehash; /**< Initial VFS phonehash. */
-    uint8_t *plb_ro;    /**< Read-only PLB view. */
+    int fs_handle;           /**< File system handle. */
+    ipcarg_t vfs_phonehash;  /**< Initial VFS phonehash. */
+    uint8_t *plb_ro;         /**< Read-only PLB view. */
 } fs_reg_t;
 extern int fs_register(int, fs_reg_t *, vfs_info_t *, async_client_conn_t);
+extern void fs_node_initialize(fs_node_t *);
+extern void libfs_mount(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);
 extern void libfs_lookup(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);
+extern void libfs_open_node(libfs_ops_t *, fs_handle_t, ipc_callid_t,
+    ipc_call_t *);
 #endif
 /** @}
  */

 /branches/network/uspace/lib/libblock/libblock.c
 ,8 → 37,8
 #include "libblock.h"
 #include "../../srv/vfs/vfs.h"
-#include "../../srv/rd/rd.h"
 #include <ipc/devmap.h>
+#include <ipc/bd.h>
 #include <ipc/services.h>
 #include <errno.h>
 #include <sys/mman.h>
 ,12 → 46,13
 #include <ipc/ipc.h>
 #include <as.h>
 #include <assert.h>
-#include <futex.h>
-#include <libadt/list.h>
-#include <libadt/hash_table.h>
+#include <fibril_sync.h>
+#include <adt/list.h>
+#include <adt/hash_table.h>
+#include <mem.h>
 /** Lock protecting the device connection list */
-static futex_t dcl_lock = FUTEX_INITIALIZER;
+static FIBRIL_MUTEX_INITIALIZE(dcl_lock);
 /** Device connection list head. */
 static LIST_INITIALIZE(dcl_head);
 ,16 → 60,17
 #define CACHE_BUCKETS           (1 << CACHE_BUCKETS_LOG2)
 typedef struct {
-    futex_t lock;
+    fibril_mutex_t lock;
     size_t block_size;      /**< Block size. */
     unsigned block_count;       /**< Total number of blocks. */
     hash_table_t block_hash;
     link_t free_head;
+    enum cache_mode mode;
 } cache_t;
 typedef struct {
     link_t link;
-    int dev_handle;
+    dev_handle_t dev_handle;
     int dev_phone;
     void *com_area;
     size_t com_size;
 ,19 → 80,22
     cache_t *cache;
 } devcon_t;
+static int write_block(devcon_t *devcon, bn_t boff, size_t block_size,
+    const void *src);
 static devcon_t *devcon_search(dev_handle_t dev_handle)
 {
     link_t *cur;
-    futex_down(&dcl_lock);
+    fibril_mutex_lock(&dcl_lock);
     for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
         devcon_t *devcon = list_get_instance(cur, devcon_t, link);
         if (devcon->dev_handle == dev_handle) {
-            futex_up(&dcl_lock);
+            fibril_mutex_unlock(&dcl_lock);
             return devcon;
         }
     }
-    futex_up(&dcl_lock);
+    fibril_mutex_unlock(&dcl_lock);
     return NULL;
 }
 ,25 → 119,25
     devcon->bb_size = 0;
     devcon->cache = NULL;
-    futex_down(&dcl_lock);
+    fibril_mutex_lock(&dcl_lock);
     for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
         devcon_t *d = list_get_instance(cur, devcon_t, link);
         if (d->dev_handle == dev_handle) {
-            futex_up(&dcl_lock);
+            fibril_mutex_unlock(&dcl_lock);
             free(devcon);
             return EEXIST;
         }
     }
     list_append(&devcon->link, &dcl_head);
-    futex_up(&dcl_lock);
+    fibril_mutex_unlock(&dcl_lock);
     return EOK;
 }
 static void devcon_remove(devcon_t *devcon)
 {
-    futex_down(&dcl_lock);
+    fibril_mutex_lock(&dcl_lock);
     list_remove(&devcon->link);
-    futex_up(&dcl_lock);
+    fibril_mutex_unlock(&dcl_lock);
 }
 int block_init(dev_handle_t dev_handle, size_t com_size)
 ,9 → 151,8
     if (!com_area) {
         return ENOMEM;
     }
-    dev_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,
-        DEVMAP_CONNECT_TO_DEVICE, dev_handle);
+    dev_phone = devmap_device_connect(dev_handle, IPC_FLAG_BLOCKING);
     if (dev_phone < 0) {
         munmap(com_area, com_size);
         return dev_phone;
 ,7 → 254,8
     .remove_callback = cache_remove_callback
 };
-int block_cache_init(dev_handle_t dev_handle, size_t size, unsigned blocks)
+int block_cache_init(dev_handle_t dev_handle, size_t size, unsigned blocks,
+    enum cache_mode mode)
 {
     devcon_t *devcon = devcon_search(dev_handle);
     cache_t *cache;
 ,10 → 267,11
     if (!cache)
         return ENOMEM;
-    futex_initialize(&cache->lock, 1);
+    fibril_mutex_initialize(&cache->lock);
     list_initialize(&cache->free_head);
     cache->block_size = size;
     cache->block_count = blocks;
+    cache->mode = mode;
     if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1,
         &cache_ops)) {
 ,10 → 290,10
 static void block_initialize(block_t *b)
 {
-    futex_initialize(&b->lock, 1);
+    fibril_mutex_initialize(&b->lock);
     b->refcnt = 1;
     b->dirty = false;
-    rwlock_initialize(&b->contents_lock);
+    fibril_rwlock_initialize(&b->contents_lock);
     link_initialize(&b->free_link);
     link_initialize(&b->hash_link);
 }
 ,7 → 322,7
     assert(devcon->cache);
     cache = devcon->cache;
-    futex_down(&cache->lock);
+    fibril_mutex_lock(&cache->lock);
     l = hash_table_find(&cache->block_hash, &key);
     if (l) {
         /*
 ,11 → 329,11
          * We found the block in the cache.
          */
         b = hash_table_get_instance(l, block_t, hash_link);
-        futex_down(&b->lock);
+        fibril_mutex_lock(&b->lock);
         if (b->refcnt++ == 0)
             list_remove(&b->free_link);
-        futex_up(&b->lock);
-        futex_up(&cache->lock);
+        fibril_mutex_unlock(&b->lock);
+        fibril_mutex_unlock(&cache->lock);
     } else {
         /*
          * The block was not found in the cache.
 ,8 → 384,8
          * kill concurent operations on the cache while doing I/O on the
          * block.
          */
-        futex_down(&b->lock);
-        futex_up(&cache->lock);
+        fibril_mutex_lock(&b->lock);
+        fibril_mutex_unlock(&cache->lock);
         if (sync) {
             /*
 ,7 → 404,7
             assert(rc == EOK);
         }
-        futex_up(&b->lock);
+        fibril_mutex_unlock(&b->lock);
     }
     return b;
 }
 ,13 → 419,14
 {
     devcon_t *devcon = devcon_search(block->dev_handle);
     cache_t *cache;
+    int rc;
     assert(devcon);
     assert(devcon->cache);
     cache = devcon->cache;
-    futex_down(&cache->lock);
-    futex_down(&block->lock);
+    fibril_mutex_lock(&cache->lock);
+    fibril_mutex_lock(&block->lock);
     if (!--block->refcnt) {
         /*
          * Last reference to the block was dropped, put the block on the
 ,9 → 433,16
          * free list.
          */
         list_append(&block->free_link, &cache->free_head);
+        if (cache->mode != CACHE_MODE_WB && block->dirty) {
+            rc = write_block(devcon, block->boff, block->size,
+                block->data);
+            assert(rc == EOK);
+            block->dirty = false;
+        }
     }
-    futex_up(&block->lock);
-    futex_up(&cache->lock);
+    fibril_mutex_unlock(&block->lock);
+    fibril_mutex_unlock(&cache->lock);
 }
 /** Read data from a block device.
 ,8 → 460,8
  * @return      EOK on success or a negative return code on failure.
  */
 int
-block_read(int dev_handle, off_t *bufpos, size_t *buflen, off_t *pos, void *dst,
-    size_t size, size_t block_size)
+block_read(dev_handle_t dev_handle, off_t *bufpos, size_t *buflen, off_t *pos,
+    void *dst, size_t size, size_t block_size)
 {
     off_t offset = 0;
     size_t left = size;
 ,13 → 488,13
             left -= rd;
         }
-        if (*bufpos == *buflen) {
+        if (*bufpos == (off_t) *buflen) {
             /* Refill the communication buffer with a new block. */
             ipcarg_t retval;
-            int rc = async_req_2_1(devcon->dev_phone, RD_READ_BLOCK,
+            int rc = async_req_2_1(devcon->dev_phone, BD_READ_BLOCK,
                 *pos / block_size, block_size, &retval);
             if ((rc != EOK) || (retval != EOK))
-                return (rc != EOK ? rc : retval);
+                return (rc != EOK ? rc : (int) retval);
             *bufpos = 0;
             *buflen = block_size;
 ,5 → 504,31
     return EOK;
 }
+/** Write block to block device.
+ *
+ * @param devcon    Device connection.
+ * @param boff      Block index.
+ * @param block_size    Block size.
+ * @param src       Buffer containing the data to write.
+ *
+ * @return      EOK on success or negative error code on failure.
+ */
+static int write_block(devcon_t *devcon, bn_t boff, size_t block_size,
+    const void *src)
+{
+    ipcarg_t retval;
+    int rc;
+    assert(devcon);
+    memcpy(devcon->com_area, src, block_size);
+    rc = async_req_2_1(devcon->dev_phone, BD_WRITE_BLOCK,
+        boff, block_size, &retval);
+    if ((rc != EOK) || (retval != EOK))
+        return (rc != EOK ? rc : (int) retval);
+    return EOK;
+}
 /** @}
  */

 /branches/network/uspace/lib/libblock/libblock.h
 ,10 → 39,9
 #include <stdint.h>
 #include "../../srv/vfs/vfs.h"
-#include <futex.h>
-#include <rwlock.h>
-#include <libadt/hash_table.h>
-#include <libadt/list.h>
+#include <fibril_sync.h>
+#include <adt/hash_table.h>
+#include <adt/list.h>
 /*
  * Flags that can be used with block_get().
 ,14 → 62,14
 typedef unsigned bn_t;  /**< Block number type. */
 typedef struct block {
-    /** Futex protecting the reference count. */
-    futex_t lock;
+    /** Mutex protecting the reference count. */
+    fibril_mutex_t lock;
     /** Number of references to the block_t structure. */
     unsigned refcnt;
     /** If true, the block needs to be written back to the block device. */
     bool dirty;
     /** Readers / Writer lock protecting the contents of the block. */
-    rwlock_t contents_lock;
+    fibril_rwlock_t contents_lock;
     /** Handle of the device where the block resides. */
     dev_handle_t dev_handle;
     /** Block offset on the block device. Counted in 'size'-byte blocks. */
 ,6 → 84,14
     void *data;
 } block_t;
+/** Caching mode */
+enum cache_mode {
+    /** Write-Through */
+    CACHE_MODE_WT,
+    /** Write-Back */
+    CACHE_MODE_WB
+};
 extern int block_init(dev_handle_t, size_t);
 extern void block_fini(dev_handle_t);
 ,12 → 98,13
 extern int block_bb_read(dev_handle_t, off_t, size_t);
 extern void *block_bb_get(dev_handle_t);
-extern int block_cache_init(dev_handle_t, size_t, unsigned);
+extern int block_cache_init(dev_handle_t, size_t, unsigned, enum cache_mode);
 extern block_t *block_get(dev_handle_t, bn_t, int flags);
 extern void block_put(block_t *);
-extern int block_read(int, off_t *, size_t *, off_t *, void *, size_t, size_t);
+extern int block_read(dev_handle_t, off_t *, size_t *, off_t *, void *, size_t,
+    size_t);
 #endif

 /branches/network/uspace/lib/softfloat/include/sftypes.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
- /** @addtogroup softfloat
+/** @addtogroup softfloat
  * @{
  */
 /** @file
 ,40 → 41,40
 typedef union {
     float f;
     uint32_t binary;
-    struct  {
-#if defined(ARCH_IS_BIG_ENDIAN)
-        uint32_t sign:1;
-        uint32_t exp:8;
-        uint32_t fraction:23;
-#elif defined(ARCH_IS_LITTLE_ENDIAN)
-        uint32_t fraction:23;
-        uint32_t exp:8;
-        uint32_t sign:1;
-#else
-#error "Unknown endians."
+    struct {
+#if defined(__BE__)
+        uint32_t sign : 1;
+        uint32_t exp : 8;
+        uint32_t fraction : 23;
+#elif defined(__LE__)
+        uint32_t fraction : 23;
+        uint32_t exp : 8;
+        uint32_t sign : 1;
+#else
+    #error Unknown endianess
 #endif
         } parts __attribute__ ((packed));
-    } float32;
+} float32;
 typedef union {
     double d;
     uint64_t binary;
-    struct  {
-#if defined(ARCH_IS_BIG_ENDIAN)
-        uint64_t sign:1;
-        uint64_t exp:11;
-        uint64_t fraction:52;
-#elif defined(ARCH_IS_LITTLE_ENDIAN)
-        uint64_t fraction:52;
-        uint64_t exp:11;
-        uint64_t sign:1;
-#else
-#error "Unknown endians."
+    struct {
+#if defined(__BE__)
+        uint64_t sign : 1;
+        uint64_t exp : 11;
+        uint64_t fraction : 52;
+#elif defined(__LE__)
+        uint64_t fraction : 52;
+        uint64_t exp : 11;
+        uint64_t sign : 1;
+#else
+    #error Unknown endianess
 #endif
-        } parts __attribute__ ((packed));
-    } float64;
+    } parts __attribute__ ((packed));
+} float64;
 #define FLOAT32_MAX 0x7f800000
 #define FLOAT32_MIN 0xff800000
 ,7 → 109,5
 #endif
- /** @}
+/** @}
  */

 /branches/network/uspace/lib/softfloat/Makefile
 ,7 → 36,7
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS +=-Iinclude -Iarch/$(UARCH)/include/
+CFLAGS += -Iinclude -Iarch/$(UARCH)/include/
 ## Sources
 #

 /branches/network/uspace/lib/libc/include/byteorder.h
 ,48 → 35,47
 #ifndef LIBC_BYTEORDER_H_
 #define LIBC_BYTEORDER_H_
-#include <libarch/byteorder.h>
 #include <stdint.h>
-#if !(defined(ARCH_IS_BIG_ENDIAN) ^ defined(ARCH_IS_LITTLE_ENDIAN))
-#error The architecture must be either big-endian or little-endian.
+#if !(defined(__BE__) ^ defined(__LE__))
+    #error The architecture must be either big-endian or little-endian.
 #endif
-#ifdef ARCH_IS_BIG_ENDIAN
+#ifdef __BE__
-#define uint16_t_le2host(n)     uint16_t_byteorder_swap(n)
-#define uint32_t_le2host(n)     uint32_t_byteorder_swap(n)
-#define uint64_t_le2host(n)     uint64_t_byteorder_swap(n)
+#define uint16_t_le2host(n)  (uint16_t_byteorder_swap(n))
+#define uint32_t_le2host(n)  (uint32_t_byteorder_swap(n))
+#define uint64_t_le2host(n)  (uint64_t_byteorder_swap(n))
-#define uint16_t_be2host(n)     (n)
-#define uint32_t_be2host(n)     (n)
-#define uint64_t_be2host(n)     (n)
+#define uint16_t_be2host(n)  (n)
+#define uint32_t_be2host(n)  (n)
+#define uint64_t_be2host(n)  (n)
-#define host2uint16_t_le(n)     uint16_t_byteorder_swap(n)
-#define host2uint32_t_le(n)     uint32_t_byteorder_swap(n)
-#define host2uint64_t_le(n)     uint64_t_byteorder_swap(n)
+#define host2uint16_t_le(n)  (uint16_t_byteorder_swap(n))
+#define host2uint32_t_le(n)  (uint32_t_byteorder_swap(n))
+#define host2uint64_t_le(n)  (uint64_t_byteorder_swap(n))
-#define host2uint16_t_be(n)     (n)
-#define host2uint32_t_be(n)     (n)
-#define host2uint64_t_be(n)     (n)
+#define host2uint16_t_be(n)  (n)
+#define host2uint32_t_be(n)  (n)
+#define host2uint64_t_be(n)  (n)
 #else
-#define uint16_t_le2host(n)     (n)
-#define uint32_t_le2host(n)     (n)
-#define uint64_t_le2host(n)     (n)
+#define uint16_t_le2host(n)  (n)
+#define uint32_t_le2host(n)  (n)
+#define uint64_t_le2host(n)  (n)
-#define uint16_t_be2host(n)     uint16_t_byteorder_swap(n)
-#define uint32_t_be2host(n)     uint32_t_byteorder_swap(n)
-#define uint64_t_be2host(n)     uint64_t_byteorder_swap(n)
+#define uint16_t_be2host(n)  (uint16_t_byteorder_swap(n))
+#define uint32_t_be2host(n)  (uint32_t_byteorder_swap(n))
+#define uint64_t_be2host(n)  (uint64_t_byteorder_swap(n))
-#define host2uint16_t_le(n)     (n)
-#define host2uint32_t_le(n)     (n)
-#define host2uint64_t_le(n)     (n)
+#define host2uint16_t_le(n)  (n)
+#define host2uint32_t_le(n)  (n)
+#define host2uint64_t_le(n)  (n)
-#define host2uint16_t_be(n)     uint16_t_byteorder_swap(n)
-#define host2uint32_t_be(n)     uint32_t_byteorder_swap(n)
-#define host2uint64_t_be(n)     uint64_t_byteorder_swap(n)
+#define host2uint16_t_be(n)  (uint16_t_byteorder_swap(n))
+#define host2uint32_t_be(n)  (uint32_t_byteorder_swap(n))
+#define host2uint64_t_be(n)  (uint64_t_byteorder_swap(n))
 #endif

 /branches/network/uspace/lib/libc/include/fcntl.h
 ,13 → 35,13
 #ifndef LIBC_FCNTL_H_
 #define LIBC_FCNTL_H_
-#define O_CREAT     1
-#define O_EXCL      2
-#define O_TRUNC     4
-#define O_APPEND    8
-#define O_RDONLY    16
-#define O_RDWR      32
-#define O_WRONLY    64
+#define O_CREAT   1
+#define O_EXCL    2
+#define O_TRUNC   4
+#define O_APPEND  8
+#define O_RDONLY  16
+#define O_RDWR    32
+#define O_WRONLY  64
 extern int open(const char *, int, ...);

 /branches/network/uspace/lib/libc/include/string.h
 ,13 → 39,12
 #include <sys/types.h>
 #include <bool.h>
-#define U_SPECIAL      '?'
-#define U_BOM          0xfeff
+#define U_SPECIAL  '?'
-/**< No size limit constant */
+/** No size limit constant */
 #define STR_NO_LIMIT  ((size_t) -1)
-/**< Maximum size of a string containing @c length characters */
+/** Maximum size of a string containing @c length characters */
 #define STR_BOUNDS(length)  ((length) << 2)
 extern wchar_t str_decode(const char *str, size_t *offset, size_t sz);
 ,20 → 53,20
 extern size_t str_size(const char *str);
 extern size_t wstr_size(const wchar_t *str);
-extern size_t str_lsize(const char *str, count_t max_len);
-extern size_t wstr_lsize(const wchar_t *str, count_t max_len);
+extern size_t str_lsize(const char *str, size_t max_len);
+extern size_t wstr_lsize(const wchar_t *str, size_t max_len);
-extern count_t str_length(const char *str);
-extern count_t wstr_length(const wchar_t *wstr);
+extern size_t str_length(const char *str);
+extern size_t wstr_length(const wchar_t *wstr);
-extern count_t str_nlength(const char *str, size_t size);
-extern count_t wstr_nlength(const wchar_t *str, size_t size);
+extern size_t str_nlength(const char *str, size_t size);
+extern size_t wstr_nlength(const wchar_t *str, size_t size);
 extern bool ascii_check(wchar_t ch);
 extern bool chr_check(wchar_t ch);
 extern int str_cmp(const char *s1, const char *s2);
-extern int str_lcmp(const char *s1, const char *s2, count_t max_len);
+extern int str_lcmp(const char *s1, const char *s2, size_t max_len);
 extern void str_cpy(char *dest, size_t size, const char *src);
 extern void str_ncpy(char *dest, size_t size, const char *src, size_t n);
 ,8 → 77,8
 extern const char *str_chr(const char *str, wchar_t ch);
 extern const char *str_rchr(const char *str, wchar_t ch);
-extern bool wstr_linsert(wchar_t *str, wchar_t ch, count_t pos, count_t max_pos);
-extern bool wstr_remove(wchar_t *str, count_t pos);
+extern bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos);
+extern bool wstr_remove(wchar_t *str, size_t pos);
 extern char *str_dup(const char *);

 /branches/network/uspace/lib/libc/include/vfs/vfs.h
 ,12 → 36,36
 #define LIBC_VFS_H_
 #include <sys/types.h>
+#include <ipc/vfs.h>
+#include <ipc/devmap.h>
+#include <stdio.h>
+/**
+ * This type is a libc version of the VFS triplet.
+ * It uniquelly identifies a file system node within a file system instance.
+ */
+typedef struct {
+    fs_handle_t fs_handle;
+    dev_handle_t dev_handle;
+    fs_index_t index;
+} fdi_node_t;
 extern char *absolutize(const char *, size_t *);
 extern int mount(const char *, const char *, const char *, const char *,
-    const unsigned int flags);
+    unsigned int);
+extern void stdio_init(int filc, fdi_node_t *filv[]);
+extern void stdio_done(void);
+extern int open_node(fdi_node_t *, int);
+extern int fd_phone(int);
+extern int fd_node(int, fdi_node_t *);
+extern FILE *fopen_node(fdi_node_t *, const char *);
+extern int fphone(FILE *);
+extern int fnode(FILE *, fdi_node_t *);
 #endif
 /** @}

 /branches/network/uspace/lib/libc/include/async.h
 ,12 → 44,15
 typedef ipc_callid_t aid_t;
 typedef void (*async_client_conn_t)(ipc_callid_t callid, ipc_call_t *call);
+extern atomic_t async_futex;
 static inline void async_manager(void)
 {
     fibril_switch(FIBRIL_TO_MANAGER);
 }
-ipc_callid_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs);
+extern ipc_callid_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs);
 static inline ipc_callid_t async_get_call(ipc_call_t *data)
 {
     return async_get_call_timeout(data, 0);
 ,19 → 66,19
  */
 #define async_send_0(phoneid, method, dataptr) \
-    async_send_fast((phoneid), (method), 0, 0, 0, 0, (dataptr))
+    async_send_fast((phoneid), (method), 0, 0, 0, 0, (dataptr))
 #define async_send_1(phoneid, method, arg1, dataptr) \
-    async_send_fast((phoneid), (method), (arg1), 0, 0, 0, (dataptr))
+    async_send_fast((phoneid), (method), (arg1), 0, 0, 0, (dataptr))
 #define async_send_2(phoneid, method, arg1, arg2, dataptr) \
-    async_send_fast((phoneid), (method), (arg1), (arg2), 0, 0, (dataptr))
+    async_send_fast((phoneid), (method), (arg1), (arg2), 0, 0, (dataptr))
 #define async_send_3(phoneid, method, arg1, arg2, arg3, dataptr) \
-    async_send_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (dataptr))
+    async_send_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (dataptr))
 #define async_send_4(phoneid, method, arg1, arg2, arg3, arg4, dataptr) \
-    async_send_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
-        (dataptr))
+    async_send_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
+        (dataptr))
 #define async_send_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, dataptr) \
-    async_send_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
-        (arg5), (dataptr))
+    async_send_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
+        (arg5), (dataptr))
 extern aid_t async_send_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr);
 ,12 → 89,12
 extern int async_wait_timeout(aid_t amsgid, ipcarg_t *retval,
     suseconds_t timeout);
-fid_t async_new_connection(ipcarg_t in_phone_hash, ipc_callid_t callid,
+extern fid_t async_new_connection(ipcarg_t in_phone_hash, ipc_callid_t callid,
     ipc_call_t *call, void (*cthread)(ipc_callid_t, ipc_call_t *));
-void async_usleep(suseconds_t timeout);
-void async_create_manager(void);
-void async_destroy_manager(void);
-int _async_init(void);
+extern void async_usleep(suseconds_t timeout);
+extern void async_create_manager(void);
+extern void async_destroy_manager(void);
+extern int _async_init(void);
 extern void async_set_client_connection(async_client_conn_t conn);
 extern void async_set_interrupt_received(async_client_conn_t conn);
 ,22 → 101,22
 /* Wrappers for simple communication */
 #define async_msg_0(phone, method) \
-    ipc_call_async_0((phone), (method), NULL, NULL, true)
+    ipc_call_async_0((phone), (method), NULL, NULL, true)
 #define async_msg_1(phone, method, arg1) \
-    ipc_call_async_1((phone), (method), (arg1), NULL, NULL, \
-        true)
+    ipc_call_async_1((phone), (method), (arg1), NULL, NULL, \
+        true)
 #define async_msg_2(phone, method, arg1, arg2) \
-    ipc_call_async_2((phone), (method), (arg1), (arg2), NULL, NULL, \
-        true)
+    ipc_call_async_2((phone), (method), (arg1), (arg2), NULL, NULL, \
+        true)
 #define async_msg_3(phone, method, arg1, arg2, arg3) \
-    ipc_call_async_3((phone), (method), (arg1), (arg2), (arg3), NULL, NULL, \
-        true)
+    ipc_call_async_3((phone), (method), (arg1), (arg2), (arg3), NULL, NULL, \
+        true)
 #define async_msg_4(phone, method, arg1, arg2, arg3, arg4) \
-    ipc_call_async_4((phone), (method), (arg1), (arg2), (arg3), (arg4), NULL, \
-        NULL, true)
+    ipc_call_async_4((phone), (method), (arg1), (arg2), (arg3), (arg4), NULL, \
+        NULL, true)
 #define async_msg_5(phone, method, arg1, arg2, arg3, arg4, arg5) \
-    ipc_call_async_5((phone), (method), (arg1), (arg2), (arg3), (arg4), \
-        (arg5), NULL, NULL, true)
+    ipc_call_async_5((phone), (method), (arg1), (arg2), (arg3), (arg4), \
+        (arg5), NULL, NULL, true)
 /*
  * User-friendly wrappers for async_req_fast() and async_req_slow(). The macros
 ,90 → 125,90
  * and slow verion based on m.
  */
 #define async_req_0_0(phoneid, method) \
-    async_req_fast((phoneid), (method), 0, 0, 0, 0, NULL, NULL, NULL, NULL, \
-    NULL)
+    async_req_fast((phoneid), (method), 0, 0, 0, 0, NULL, NULL, NULL, NULL, \
+        NULL)
 #define async_req_0_1(phoneid, method, r1) \
-    async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), NULL, NULL, NULL, \
-    NULL)
+    async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), NULL, NULL, NULL, \
+        NULL)
 #define async_req_0_2(phoneid, method, r1, r2) \
-    async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), NULL, NULL, \
-    NULL)
+    async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), NULL, NULL, \
+        NULL)
 #define async_req_0_3(phoneid, method, r1, r2, r3) \
-    async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), (r3), NULL, \
-    NULL)
+    async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), (r3), NULL, \
+        NULL)
 #define async_req_0_4(phoneid, method, r1, r2, r3, r4) \
-    async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), (r3), (r4), \
-    NULL)
+    async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), (r3), (r4), \
+        NULL)
 #define async_req_0_5(phoneid, method, r1, r2, r3, r4, r5) \
-    async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), (r3), (r4), \
-    (r5))
+    async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), (r3), (r4), \
+        (r5))
 #define async_req_1_0(phoneid, method, arg1) \
-    async_req_fast((phoneid), (method), (arg1), 0, 0, 0, NULL, NULL, NULL, \
-    NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), 0, 0, 0, NULL, NULL, NULL, \
+        NULL, NULL)
 #define async_req_1_1(phoneid, method, arg1, rc1) \
-    async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), NULL, NULL, \
-    NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), NULL, NULL, \
+        NULL, NULL)
 #define async_req_1_2(phoneid, method, arg1, rc1, rc2) \
-    async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), NULL, \
-    NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), NULL, \
+        NULL, NULL)
 #define async_req_1_3(phoneid, method, arg1, rc1, rc2, rc3) \
-    async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), (rc3), \
-    NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), (rc3), \
+        NULL, NULL)
 #define async_req_1_4(phoneid, method, arg1, rc1, rc2, rc3, rc4) \
-    async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), (rc3), \
-    (rc4), NULL)
+    async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), (rc3), \
+        (rc4), NULL)
 #define async_req_1_5(phoneid, method, arg1, rc1, rc2, rc3, rc4, rc5) \
-    async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), (rc3), \
-    (rc4), (rc5))
+    async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), (rc3), \
+        (rc4), (rc5))
 #define async_req_2_0(phoneid, method, arg1, arg2) \
-    async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, NULL, NULL, \
-    NULL, NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, NULL, NULL, \
+        NULL, NULL, NULL)
 #define async_req_2_1(phoneid, method, arg1, arg2, rc1) \
-    async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), NULL, \
-    NULL, NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), NULL, \
+        NULL, NULL, NULL)
 #define async_req_2_2(phoneid, method, arg1, arg2, rc1, rc2) \
-    async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \
-    NULL, NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \
+        NULL, NULL, NULL)
 #define async_req_2_3(phoneid, method, arg1, arg2, rc1, rc2, rc3) \
-    async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \
-    (rc3), NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \
+        (rc3), NULL, NULL)
 #define async_req_2_4(phoneid, method, arg1, arg2, rc1, rc2, rc3, rc4) \
-    async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \
-    (rc3), (rc4), NULL)
+    async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \
+        (rc3), (rc4), NULL)
 #define async_req_2_5(phoneid, method, arg1, arg2, rc1, rc2, rc3, rc4, rc5) \
-    async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \
-    (rc3), (rc4), (rc5))
+    async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \
+        (rc3), (rc4), (rc5))
 #define async_req_3_0(phoneid, method, arg1, arg2, arg3) \
-    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, NULL, NULL, \
-    NULL, NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, NULL, NULL, \
+        NULL, NULL, NULL)
 #define async_req_3_1(phoneid, method, arg1, arg2, arg3, rc1) \
-    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \
-    NULL, NULL, NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \
+        NULL, NULL, NULL, NULL)
 #define async_req_3_2(phoneid, method, arg1, arg2, arg3, rc1, rc2) \
-    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \
-    (rc2), NULL, NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \
+        (rc2), NULL, NULL, NULL)
 #define async_req_3_3(phoneid, method, arg1, arg2, arg3, rc1, rc2, rc3) \
-    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \
-    (rc2), (rc3), NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \
+        (rc2), (rc3), NULL, NULL)
 #define async_req_3_4(phoneid, method, arg1, arg2, arg3, rc1, rc2, rc3, rc4) \
-    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \
-    (rc2), (rc3), (rc4), NULL)
+    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \
+        (rc2), (rc3), (rc4), NULL)
 #define async_req_3_5(phoneid, method, arg1, arg2, arg3, rc1, rc2, rc3, rc4, \
     rc5) \
     async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \
         (rc2), (rc3), (rc4), (rc5))
 #define async_req_4_0(phoneid, method, arg1, arg2, arg3, arg4) \
-    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), NULL, \
-    NULL, NULL, NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), NULL, \
+        NULL, NULL, NULL, NULL)
 #define async_req_4_1(phoneid, method, arg1, arg2, arg3, arg4, rc1) \
-    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), (rc1), \
-    NULL, NULL, NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), (rc1), \
+        NULL, NULL, NULL, NULL)
 #define async_req_4_2(phoneid, method, arg1, arg2, arg3, arg4, rc1, rc2) \
-    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), (rc1), \
-    (rc2), NULL, NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), (rc1), \
+        (rc2), NULL, NULL, NULL)
 #define async_req_4_3(phoneid, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3) \
-    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), (rc1), \
-    (rc2), (rc3), NULL, NULL)
+    async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), (rc1), \
+        (rc2), (rc3), NULL, NULL)
 #define async_req_4_4(phoneid, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3, \
     rc4) \
     async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
 ,14 → 218,14
     async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
         (rc1), (rc2), (rc3), (rc4), (rc5))
 #define async_req_5_0(phoneid, method, arg1, arg2, arg3, arg4, arg5) \
-    async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
-        (arg5), NULL, NULL, NULL, NULL, NULL)
+    async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
+        (arg5), NULL, NULL, NULL, NULL, NULL)
 #define async_req_5_1(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1) \
-    async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
-    (arg5), (rc1), NULL, NULL, NULL, NULL)
+    async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
+        (arg5), (rc1), NULL, NULL, NULL, NULL)
 #define async_req_5_2(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2) \
-    async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
-    (arg5), (rc1), (rc2), NULL, NULL, NULL)
+    async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
+        (arg5), (rc1), (rc2), NULL, NULL, NULL)
 #define async_req_5_3(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \
     rc3) \
     async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
 ,8 → 256,6
     fibril_dec_sercount();
 }
-extern atomic_t async_futex;
 #endif
 /** @}

 /branches/network/uspace/lib/libc/include/stdio.h
 ,78 → 37,117
 #include <sys/types.h>
 #include <stdarg.h>
+#include <adt/list.h>
-#define EOF (-1)
+#define EOF  (-1)
-#include <string.h>
-#include <io/stream.h>
+/** Default size for stream I/O buffers */
+#define BUFSIZ 4096
 #define DEBUG(fmt, ...) \
 { \
     char buf[256]; \
-    int n; \
-    n = snprintf(buf, sizeof(buf), fmt, ##__VA_ARGS__); \
+    int n = snprintf(buf, sizeof(buf), fmt, ##__VA_ARGS__); \
     if (n > 0) \
         (void) __SYSCALL3(SYS_KLOG, 1, (sysarg_t) buf, str_size(buf)); \
 }
+#ifndef SEEK_SET
+    #define SEEK_SET  0
+    #define SEEK_CUR  1
+    #define SEEK_END  2
+#endif
+enum _buffer_type {
+    /** No buffering */
+    _IONBF,
+    /** Line buffering */
+    _IOLBF,
+    /** Full buffering */
+    _IOFBF
+};
 typedef struct {
+    /** Linked list pointer. */
+    link_t link;
     /** Underlying file descriptor. */
     int fd;
     /** Error indicator. */
     int error;
     /** End-of-file indicator. */
     int eof;
+    /** Klog indicator */
+    int klog;
+    /** Phone to the file provider */
+    int phone;
+    /** Buffering type */
+    enum _buffer_type btype;
+    /** Buffer */
+    uint8_t *buf;
+    /** Buffer size */
+    size_t buf_size;
+    /** Buffer I/O pointer */
+    uint8_t *buf_head;
 } FILE;
-extern FILE *stdin, *stdout, *stderr;
+extern FILE *stdin;
+extern FILE *stdout;
+extern FILE *stderr;
+/* Character and string input functions */
+extern int fgetc(FILE *);
+extern char *fgets(char *, size_t, FILE *);
 extern int getchar(void);
+extern char *gets(char *, size_t);
+/* Character and string output functions */
+extern int fputc(wchar_t, FILE *);
+extern int fputs(const char *, FILE *);
+extern int putchar(wchar_t);
 extern int puts(const char *);
-extern int putchar(int);
-extern int fflush(FILE *);
+/* Formatted string output functions */
+extern int fprintf(FILE *, const char*, ...);
+extern int vfprintf(FILE *, const char *, va_list);
 extern int printf(const char *, ...);
+extern int vprintf(const char *, va_list);
+extern int snprintf(char *, size_t , const char *, ...);
 extern int asprintf(char **, const char *, ...);
-extern int sprintf(char *, const char *, ...);
-extern int snprintf(char *, size_t , const char *, ...);
-extern int vprintf(const char *, va_list);
-extern int vsprintf(char *, const char *, va_list);
 extern int vsnprintf(char *, size_t, const char *, va_list);
-extern int rename(const char *, const char *);
+/* File stream functions */
 extern FILE *fopen(const char *, const char *);
+extern FILE *fdopen(int, const char *);
 extern int fclose(FILE *);
 extern size_t fread(void *, size_t, size_t, FILE *);
 extern size_t fwrite(const void *, size_t, size_t, FILE *);
+extern int fseek(FILE *, long, int);
+extern void rewind(FILE *);
+extern int ftell(FILE *);
 extern int feof(FILE *);
+extern int fflush(FILE *);
 extern int ferror(FILE *);
 extern void clearerr(FILE *);
-extern int fgetc(FILE *);
-extern int fputc(int, FILE *);
-extern int fputs(const char *, FILE *);
+extern void setvbuf(FILE *, void *, int, size_t);
-extern int fprintf(FILE *, const char *, ...);
-extern int vfprintf(FILE *, const char *, va_list);
+/* Misc file functions */
+extern int rename(const char *, const char *);
-#define getc fgetc
-#define putc fputc
-extern int fseek(FILE *, long, int);
-#ifndef SEEK_SET
-    #define SEEK_SET    0
-    #define SEEK_CUR    1
-    #define SEEK_END    2
 #endif
-#endif
 /** @}
  */

 /branches/network/uspace/lib/libc/include/dirent.h
 ,7 → 35,7
 #ifndef LIBC_DIRENT_H_
 #define LIBC_DIRENT_H_
-#define NAME_MAX    256
+#define NAME_MAX  256
 struct dirent {
     char d_name[NAME_MAX + 1];
 ,7 → 46,6
     struct dirent res;
 } DIR;
 extern DIR *opendir(const char *);
 extern struct dirent *readdir(DIR *);
 extern void rewinddir(DIR *);

/branches/network/uspace/lib/libc/include/task.h
42,6 → 42,7
extern task_id_t task_get_id(void);
extern int task_set_name(const char *name);
extern task_id_t task_spawn(const char path, char const argv[]);
extern int task_wait(task_id_t id);

#endif

 /branches/network/uspace/lib/libc/include/fibril_sync.h
 ,0 → 1,104
+/*
+ * Copyright (c) 2009 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_FIBRIL_SYNC_H_
+#define LIBC_FIBRIL_SYNC_H_
+#include <async.h>
+#include <fibril.h>
+#include <adt/list.h>
+#include <libarch/tls.h>
+typedef struct {
+    int counter;
+    link_t waiters;
+} fibril_mutex_t;
+#define FIBRIL_MUTEX_INITIALIZE(name) \
+    fibril_mutex_t name = { \
+        .counter = 1, \
+        .waiters = { \
+            .prev = &name.waiters, \
+            .next = &name.waiters, \
+        } \
+    }
+typedef struct {
+    unsigned writers;
+    unsigned readers;
+    link_t waiters;
+} fibril_rwlock_t;
+#define FIBRIL_RWLOCK_INITIALIZE(name) \
+    fibril_rwlock_t name = { \
+        .readers = 0, \
+        .writers = 0, \
+        .waiters = { \
+            .prev = &name.waiters, \
+            .next = &name.waiters, \
+        } \
+    }
+typedef struct {
+    link_t waiters;
+} fibril_condvar_t;
+#define FIBRIL_CONDVAR_INITIALIZE(name) \
+    fibril_condvar_t name = { \
+        .waiters = { \
+            .next = &name.waiters, \
+            .prev = &name.waiters, \
+        } \
+    }
+extern void fibril_mutex_initialize(fibril_mutex_t *);
+extern void fibril_mutex_lock(fibril_mutex_t *);
+extern bool fibril_mutex_trylock(fibril_mutex_t *);
+extern void fibril_mutex_unlock(fibril_mutex_t *);
+extern void fibril_rwlock_initialize(fibril_rwlock_t *);
+extern void fibril_rwlock_read_lock(fibril_rwlock_t *);
+extern void fibril_rwlock_write_lock(fibril_rwlock_t *);
+extern void fibril_rwlock_read_unlock(fibril_rwlock_t *);
+extern void fibril_rwlock_write_unlock(fibril_rwlock_t *);
+extern void fibril_condvar_initialize(fibril_condvar_t *);
+extern void fibril_condvar_wait(fibril_condvar_t *, fibril_mutex_t *);
+extern void fibril_condvar_signal(fibril_condvar_t *);
+extern void fibril_condvar_broadcast(fibril_condvar_t *);
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/unistd.h
 ,26 → 39,30
 #include <libarch/config.h>
 #ifndef NULL
-#define NULL 0
+    #define NULL  0
 #endif
-#define getpagesize()     (PAGE_SIZE)
+#define getpagesize()  (PAGE_SIZE)
 #ifndef SEEK_SET
-    #define SEEK_SET    0
-    #define SEEK_CUR    1
-    #define SEEK_END    2
+    #define SEEK_SET  0
+    #define SEEK_CUR  1
+    #define SEEK_END  2
 #endif
 extern ssize_t write(int, const void *, size_t);
 extern ssize_t read(int, void *, size_t);
 extern off_t lseek(int, off_t, int);
 extern int ftruncate(int, off_t);
 extern int close(int);
+extern int fsync(int);
 extern int unlink(const char *);
+extern char *getcwd(char *buf, size_t);
 extern int rmdir(const char *);
 extern int chdir(const char *);
-extern char *getcwd(char *buf, size_t);
 extern void _exit(int status) __attribute__ ((noreturn));
 extern void *sbrk(ssize_t incr);

 /branches/network/uspace/lib/libc/include/fibril.h
 ,17 → 36,18
 #define LIBC_FIBRIL_H_
 #include <libarch/fibril.h>
-#include <libadt/list.h>
+#include <adt/list.h>
 #include <libarch/tls.h>
 #ifndef context_set
-#define context_set(c, _pc, stack, size, ptls)          \
-    (c)->pc = (sysarg_t) (_pc);             \
-    (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA;     \
-        (c)->tls = (sysarg_t) (ptls);
+#define context_set(c, _pc, stack, size, ptls) \
+    (c)->pc = (sysarg_t) (_pc); \
+    (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; \
+    (c)->tls = (sysarg_t) (ptls);
 #endif /* context_set */
-#define FIBRIL_SERIALIZED   1
+#define FIBRIL_SERIALIZED   1
+#define FIBRIL_WRITER       2
 typedef enum {
     FIBRIL_PREEMPT,
 ,6 → 72,9
 };
 typedef struct fibril fibril_t;
+/** Fibril-local variable specifier */
+#define fibril_local __thread
 extern int context_save(context_t *c);
 extern void context_restore(context_t *c) __attribute__ ((noreturn));

 /branches/network/uspace/lib/libc/include/devmap.h
 ,0 → 1,56
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_DEVMAP_H_
+#define LIBC_DEVMAP_H_
+#include <ipc/devmap.h>
+#include <async.h>
+extern int devmap_get_phone(devmap_interface_t, unsigned int);
+extern void devmap_hangup_phone(devmap_interface_t iface);
+extern int devmap_driver_register(const char *, async_client_conn_t);
+extern int devmap_device_register(const char *, dev_handle_t *);
+extern int devmap_device_get_handle(const char *, dev_handle_t *, unsigned int);
+extern int devmap_device_connect(dev_handle_t, unsigned int);
+extern ipcarg_t devmap_device_get_count(void);
+extern ipcarg_t devmap_device_get_devices(ipcarg_t, dev_desc_t *);
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/loader/pcb.h
 ,6 → 37,7
 #define LIBC_PCB_H_
 #include <sys/types.h>
+#include <vfs/vfs.h>
 typedef void (*entry_point_t)(void);
 ,19 → 46,26
  * Holds pointers to data passed from the program loader to the program
  * and/or to the dynamic linker. This includes the program entry point,
  * arguments, environment variables etc.
+ *
  */
 typedef struct {
     /** Program entry point. */
     entry_point_t entry;
     /** Number of command-line arguments. */
     int argc;
     /** Command-line arguments. */
     char **argv;
+    /** Number of preset files. */
+    int filc;
+    /** Preset files. */
+    fdi_node_t **filv;
     /*
      * ELF-specific data.
      */
     /** Pointer to ELF dynamic section of the program. */
     void *dynamic;
 } pcb_t;

 /branches/network/uspace/lib/libc/include/loader/loader.h
 ,6 → 37,7
 #define LIBC_LOADER_H_
 #include <task.h>
+#include <vfs/vfs.h>
 /** Abstraction of a loader connection */
 typedef struct {
 ,7 → 49,8
 extern loader_t *loader_connect(void);
 extern int loader_get_task_id(loader_t *, task_id_t *);
 extern int loader_set_pathname(loader_t *, const char *);
-extern int loader_set_args(loader_t *, char *const []);
+extern int loader_set_args(loader_t *, char *const[]);
+extern int loader_set_files(loader_t *, fdi_node_t *const[]);
 extern int loader_load_program(loader_t *);
 extern int loader_run(loader_t *);
 extern void loader_abort(loader_t *);

 /branches/network/uspace/lib/libc/include/io/klog.h
 ,0 → 1,46
+/*
+ * Copyright (c) 2006 Jakub Vana
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_STREAM_H_
+#define LIBC_STREAM_H_
+#include <sys/types.h>
+extern size_t klog_write(const void *buf, size_t size);
+extern void klog_update(void);
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/io/color.h
 ,0 → 1,55
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_IO_COLOR_H_
+#define LIBC_IO_COLOR_H_
+enum console_color {
+    COLOR_BLACK   = 0,
+    COLOR_BLUE    = 1,
+    COLOR_GREEN   = 2,
+    COLOR_CYAN    = 3,
+    COLOR_RED     = 4,
+    COLOR_MAGENTA = 5,
+    COLOR_YELLOW  = 6,
+    COLOR_WHITE   = 7,
+    CATTR_BRIGHT  = 8,
+    CATTR_BLINK   = 8
+};
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/io/style.h
 ,0 → 1,46
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_IO_STYLE_H_
+#define LIBC_IO_STYLE_H_
+enum console_style {
+    STYLE_NORMAL   = 0,
+    STYLE_EMPHASIS = 1
+};
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/io/console.h
 ,0 → 1,78
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_IO_CONSOLE_H_
+#define LIBC_IO_CONSOLE_H_
+#include <ipc/ipc.h>
+#include <bool.h>
+typedef enum {
+    KEY_PRESS,
+    KEY_RELEASE
+} console_ev_type_t;
+/** Console event structure. */
+typedef struct {
+    /** Press or release event. */
+    console_ev_type_t type;
+    /** Keycode of the key that was pressed or released. */
+    unsigned int key;
+    /** Bitmask of modifiers held. */
+    unsigned int mods;
+    /** The character that was generated or '\0' for none. */
+    wchar_t c;
+} console_event_t;
+extern void console_clear(int phone);
+extern int console_get_size(int phone, ipcarg_t *rows, ipcarg_t *cols);
+extern void console_goto(int phone, ipcarg_t row, ipcarg_t col);
+extern void console_set_style(int phone, int style);
+extern void console_set_color(int phone, int fg_color, int bg_color, int flags);
+extern void console_set_rgb_color(int phone, int fg_color, int bg_color);
+extern void console_cursor_visibility(int phone, bool show);
+extern void console_kcon_enable(int phone);
+extern bool console_get_event(int phone, console_event_t *event);
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/io/keycode.h
 ,0 → 1,220
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_IO_KEYCODE_H_
+#define LIBC_IO_KEYCODE_H_
+/** Keycode definitions.
+ *
+ * A keycode identifies a key by its position on the keyboard, rather
+ * than by its label. For human readability, key positions are noted
+ * with the key label on a keyboard with US layout. This label has
+ * nothing to do with the character, that the key produces
+ * -- this is determined by the keymap.
+ *
+ * The keyboard model reflects a standard PC keyboard layout.
+ * Non-standard keyboards need to be mapped to this model in some
+ * logical way. Scancodes are mapped to keycodes with a scanmap.
+ *
+ * For easier mapping to the model and to emphasize the nature of keycodes,
+ * they really are organized here by position, rather than by label.
+ */
+enum keycode {
+    /* Main block row 1 */
+    KC_BACKTICK = 1,
+    KC_1,
+    KC_2,
+    KC_3,
+    KC_4,
+    KC_5,
+    KC_6,
+    KC_7,
+    KC_8,
+    KC_9,
+    KC_0,
+    KC_MINUS,
+    KC_EQUALS,
+    KC_BACKSPACE,
+    /* Main block row 2 */
+    KC_TAB,
+    KC_Q,
+    KC_W,
+    KC_E,
+    KC_R,
+    KC_T,
+    KC_Y,
+    KC_U,
+    KC_I,
+    KC_O,
+    KC_P,
+    KC_LBRACKET,
+    KC_RBRACKET,
+    /* Main block row 3 */
+    KC_CAPS_LOCK,
+    KC_A,
+    KC_S,
+    KC_D,
+    KC_F,
+    KC_G,
+    KC_H,
+    KC_J,
+    KC_K,
+    KC_L,
+    KC_SEMICOLON,
+    KC_QUOTE,
+    KC_BACKSLASH,
+    KC_ENTER,
+    /* Main block row 4 */
+    KC_LSHIFT,
+    KC_Z,
+    KC_X,
+    KC_C,
+    KC_V,
+    KC_B,
+    KC_N,
+    KC_M,
+    KC_COMMA,
+    KC_PERIOD,
+    KC_SLASH,
+    KC_RSHIFT,
+    /* Main block row 5 */
+    KC_LCTRL,
+    KC_LALT,
+    KC_SPACE,
+    KC_RALT,
+    KC_RCTRL,
+    /* Function keys block */
+    KC_ESCAPE,
+    KC_F1,
+    KC_F2,
+    KC_F3,
+    KC_F4,
+    KC_F5,
+    KC_F6,
+    KC_F7,
+    KC_F8,
+    KC_F9,
+    KC_F10,
+    KC_F11,
+    KC_F12,
+    KC_PRTSCR,
+    KC_SCROLL_LOCK,
+    KC_PAUSE,
+    /* Cursor keys block */
+    KC_INSERT,
+    KC_HOME,
+    KC_PAGE_UP,
+    KC_DELETE,
+    KC_END,
+    KC_PAGE_DOWN,
+    KC_UP,
+    KC_LEFT,
+    KC_DOWN,
+    KC_RIGHT,
+    /* Numeric block */
+    KC_NUM_LOCK,
+    KC_NSLASH,
+    KC_NTIMES,
+    KC_NMINUS,
+    KC_NPLUS,
+    KC_NENTER,
+    KC_N7,
+    KC_N8,
+    KC_N9,
+    KC_N4,
+    KC_N5,
+    KC_N6,
+    KC_N1,
+    KC_N2,
+    KC_N3,
+    KC_N0,
+    KC_NPERIOD
+} keycode_t;
+enum keymod {
+    KM_LSHIFT      = 0x001,
+    KM_RSHIFT      = 0x002,
+    KM_LCTRL       = 0x004,
+    KM_RCTRL       = 0x008,
+    KM_LALT        = 0x010,
+    KM_RALT        = 0x020,
+    KM_CAPS_LOCK   = 0x040,
+    KM_NUM_LOCK    = 0x080,
+    KM_SCROLL_LOCK = 0x100,
+    KM_SHIFT       = KM_LSHIFT | KM_RSHIFT,
+    KM_CTRL        = KM_LCTRL | KM_RCTRL,
+    KM_ALT         = KM_LALT | KM_RALT
+} keymod_t;
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/adt/hash_table.h
 ,0 → 1,94
+/*
+ * Copyright (c) 2006 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_HASH_TABLE_H_
+#define LIBC_HASH_TABLE_H_
+#include <adt/list.h>
+#include <unistd.h>
+typedef unsigned long hash_count_t;
+typedef unsigned long hash_index_t;
+typedef struct hash_table hash_table_t;
+typedef struct hash_table_operations hash_table_operations_t;
+/** Hash table structure. */
+struct hash_table {
+    link_t *entry;
+    hash_count_t entries;
+    hash_count_t max_keys;
+    hash_table_operations_t *op;
+};
+/** Set of operations for hash table. */
+struct hash_table_operations {
+    /** Hash function.
+     *
+     * @param key   Array of keys needed to compute hash index. All keys
+     *      must be passed.
+     *
+     * @return  Index into hash table.
+     */
+    hash_index_t (* hash)(unsigned long key[]);
+    /** Hash table item comparison function.
+     *
+     * @param key   Array of keys that will be compared with item. It is
+     *      not necessary to pass all keys.
+     *
+     * @return  true if the keys match, false otherwise.
+     */
+    int (*compare)(unsigned long key[], hash_count_t keys, link_t *item);
+    /** Hash table item removal callback.
+     *
+     * @param item  Item that was removed from the hash table.
+     */
+    void (*remove_callback)(link_t *item);
+};
+#define hash_table_get_instance(item, type, member) \
+    list_get_instance((item), type, member)
+extern int hash_table_create(hash_table_t *, hash_count_t, hash_count_t,
+    hash_table_operations_t *);
+extern void hash_table_insert(hash_table_t *, unsigned long [], link_t *);
+extern link_t *hash_table_find(hash_table_t *, unsigned long []);
+extern void hash_table_remove(hash_table_t *, unsigned long [], hash_count_t);
+extern void hash_table_destroy(hash_table_t *);
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/adt/list.h
 ,0 → 1,201
+/*
+ * Copyright (c) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_LIST_H_
+#define LIBC_LIST_H_
+#include <unistd.h>
+/** Doubly linked list head and link type. */
+typedef struct link {
+    struct link *prev;  /**< Pointer to the previous item in the list. */
+    struct link *next;  /**< Pointer to the next item in the list. */
+} link_t;
+/** Declare and initialize statically allocated list.
+ *
+ * @param name Name of the new statically allocated list.
+ */
+#define LIST_INITIALIZE(name)  link_t name = { \
+    .prev = &name, \
+    .next = &name \
+}
+/** Initialize doubly-linked circular list link
+ *
+ * Initialize doubly-linked list link.
+ *
+ * @param link Pointer to link_t structure to be initialized.
+ */
+static inline void link_initialize(link_t *link)
+{
+    link->prev = NULL;
+    link->next = NULL;
+}
+/** Initialize doubly-linked circular list
+ *
+ * Initialize doubly-linked circular list.
+ *
+ * @param head Pointer to link_t structure representing head of the list.
+ */
+static inline void list_initialize(link_t *head)
+{
+    head->prev = head;
+    head->next = head;
+}
+/** Add item to the beginning of doubly-linked circular list
+ *
+ * Add item to the beginning of doubly-linked circular list.
+ *
+ * @param link Pointer to link_t structure to be added.
+ * @param head Pointer to link_t structure representing head of the list.
+ */
+static inline void list_prepend(link_t *link, link_t *head)
+{
+    link->next = head->next;
+    link->prev = head;
+    head->next->prev = link;
+    head->next = link;
+}
+/** Add item to the end of doubly-linked circular list
+ *
+ * Add item to the end of doubly-linked circular list.
+ *
+ * @param link Pointer to link_t structure to be added.
+ * @param head Pointer to link_t structure representing head of the list.
+ */
+static inline void list_append(link_t *link, link_t *head)
+{
+    link->prev = head->prev;
+    link->next = head;
+    head->prev->next = link;
+    head->prev = link;
+}
+/** Insert item before another item in doubly-linked circular list. */
+static inline void list_insert_before(link_t *l, link_t *r)
+{
+    list_append(l, r);
+}
+/** Insert item after another item in doubly-linked circular list. */
+static inline void list_insert_after(link_t *r, link_t *l)
+{
+    list_prepend(l, r);
+}
+/** Remove item from doubly-linked circular list
+ *
+ * Remove item from doubly-linked circular list.
+ *
+ * @param link Pointer to link_t structure to be removed from the list it is contained in.
+ */
+static inline void list_remove(link_t *link)
+{
+    link->next->prev = link->prev;
+    link->prev->next = link->next;
+    link_initialize(link);
+}
+/** Query emptiness of doubly-linked circular list
+ *
+ * Query emptiness of doubly-linked circular list.
+ *
+ * @param head Pointer to link_t structure representing head of the list.
+ */
+static inline int list_empty(link_t *head)
+{
+    return ((head->next == head) ? 1 : 0);
+}
+/** Split or concatenate headless doubly-linked circular list
+ *
+ * Split or concatenate headless doubly-linked circular list.
+ *
+ * Note that the algorithm works both directions:
+ * concatenates splitted lists and splits concatenated lists.
+ *
+ * @param part1 Pointer to link_t structure leading the first (half of the headless) list.
+ * @param part2 Pointer to link_t structure leading the second (half of the headless) list.
+ */
+static inline void headless_list_split_or_concat(link_t *part1, link_t *part2)
+{
+    part1->prev->next = part2;
+    part2->prev->next = part1;
+    link_t *hlp = part1->prev;
+    part1->prev = part2->prev;
+    part2->prev = hlp;
+}
+/** Split headless doubly-linked circular list
+ *
+ * Split headless doubly-linked circular list.
+ *
+ * @param part1 Pointer to link_t structure leading the first half of the headless list.
+ * @param part2 Pointer to link_t structure leading the second half of the headless list.
+ */
+static inline void headless_list_split(link_t *part1, link_t *part2)
+{
+    headless_list_split_or_concat(part1, part2);
+}
+/** Concatenate two headless doubly-linked circular lists
+ *
+ * Concatenate two headless doubly-linked circular lists.
+ *
+ * @param part1 Pointer to link_t structure leading the first headless list.
+ * @param part2 Pointer to link_t structure leading the second headless list.
+ */
+static inline void headless_list_concat(link_t *part1, link_t *part2)
+{
+    headless_list_split_or_concat(part1, part2);
+}
+#define list_get_instance(link, type, member)  ((type *) (((void *)(link)) - ((void *) &(((type *) NULL)->member))))
+extern int list_member(const link_t *link, const link_t *head);
+extern void list_concat(link_t *head1, link_t *head2);
+extern unsigned int list_count(const link_t *link);
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/adt/fifo.h
 ,0 → 1,127
+/*
+ * Copyright (c) 2006 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+/*
+ * This implementation of FIFO stores values in an array
+ * (static or dynamic). As such, these FIFOs have upper bound
+ * on number of values they can store. Push and pop operations
+ * are done via accessing the array through head and tail indices.
+ * Because of better operation ordering in fifo_pop(), the access
+ * policy for these two indices is to 'increment (mod size of FIFO)
+ * and use'.
+ */
+#ifndef LIBC_FIFO_H_
+#define LIBC_FIFO_H_
+#include <malloc.h>
+typedef unsigned long fifo_count_t;
+typedef unsigned long fifo_index_t;
+#define FIFO_CREATE_STATIC(name, t, itms)       \
+    struct {                    \
+        t fifo[(itms)];             \
+        fifo_count_t items;         \
+        fifo_index_t head;          \
+        fifo_index_t tail;          \
+    } name
+/** Create and initialize static FIFO.
+ *
+ * FIFO is allocated statically.
+ * This macro is suitable for creating smaller FIFOs.
+ *
+ * @param name Name of FIFO.
+ * @param t Type of values stored in FIFO.
+ * @param itms Number of items that can be stored in FIFO.
+ */
+#define FIFO_INITIALIZE_STATIC(name, t, itms)       \
+    FIFO_CREATE_STATIC(name, t, itms) = {       \
+        .items = (itms),            \
+        .head = 0,              \
+        .tail = 0               \
+    }
+/** Create and prepare dynamic FIFO.
+ *
+ * FIFO is allocated dynamically.
+ * This macro is suitable for creating larger FIFOs.
+ *
+ * @param name Name of FIFO.
+ * @param t Type of values stored in FIFO.
+ * @param itms Number of items that can be stored in FIFO.
+ */
+#define FIFO_INITIALIZE_DYNAMIC(name, t, itms)      \
+    struct {                    \
+        t *fifo;                \
+        fifo_count_t items;         \
+        fifo_index_t head;          \
+        fifo_index_t tail;          \
+    } name = {                  \
+        .fifo = NULL,               \
+        .items = (itms),            \
+        .head = 0,              \
+        .tail = 0               \
+    }
+/** Pop value from head of FIFO.
+ *
+ * @param name FIFO name.
+ *
+ * @return Leading value in FIFO.
+ */
+#define fifo_pop(name) \
+    name.fifo[name.head = (name.head + 1) < name.items ? (name.head + 1) : 0]
+/** Push value to tail of FIFO.
+ *
+ * @param name FIFO name.
+ * @param value Value to be appended to FIFO.
+ *
+ */
+#define fifo_push(name, value) \
+    name.fifo[name.tail = (name.tail + 1) < name.items ? (name.tail + 1) : 0] = (value)
+/** Allocate memory for dynamic FIFO.
+ *
+ * @param name FIFO name.
+ */
+#define fifo_create(name) \
+    name.fifo = malloc(sizeof(*name.fifo) * name.items)
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/macros.h
 ,15 → 35,22
 #ifndef LIBC_MACROS_H_
 #define LIBC_MACROS_H_
-#define SIZE2KB(size) ((size) >> 10)
-#define SIZE2MB(size) ((size) >> 20)
+#define SIZE2KB(size)  ((size) >> 10)
+#define SIZE2MB(size)  ((size) >> 20)
-#define KB2SIZE(kb) ((kb) << 10)
-#define MB2SIZE(mb) ((mb) << 20)
+#define KB2SIZE(kb)  ((kb) << 10)
+#define MB2SIZE(mb)  ((mb) << 20)
-#define STRING(arg) STRING_ARG(arg)
-#define STRING_ARG(arg) #arg
+#define STRING(arg)      STRING_ARG(arg)
+#define STRING_ARG(arg)  #arg
+#define LOWER32(arg)  ((arg) & 0xffffffff)
+#define UPPER32(arg)  (((arg) >> 32) & 0xffffffff)
+#define MERGE_LOUP32(lo, up) \
+    ((((uint64_t) (lo)) & 0xffffffff) \
+        | ((((uint64_t) (up)) & 0xffffffff) << 32))
 #endif
 /** @}

 /branches/network/uspace/lib/libc/include/ipc/ipc.h
 ,21 → 30,26
  * @{
  */
 /** @file
- */
+ */
 #ifndef LIBIPC_IPC_H_
 #define LIBIPC_IPC_H_
+#include <task.h>
 #include <kernel/ipc/ipc.h>
 #include <kernel/ddi/irq.h>
 #include <sys/types.h>
 #include <kernel/synch/synch.h>
+#define IPC_FLAG_BLOCKING  0x01
 typedef sysarg_t ipcarg_t;
 typedef struct {
     ipcarg_t args[IPC_CALL_LEN];
     ipcarg_t in_phone_hash;
 } ipc_call_t;
 typedef sysarg_t ipc_callid_t;
 typedef void (* ipc_async_callback_t)(void *, int, ipc_call_t *);
 ,49 → 61,51
  * possible, the fast version is used.
  */
 #define ipc_call_sync_0_0(phoneid, method) \
-    ipc_call_sync_fast((phoneid), (method), 0, 0, 0, 0, 0, 0, 0, 0)
+    ipc_call_sync_fast((phoneid), (method), 0, 0, 0, 0, 0, 0, 0, 0)
 #define ipc_call_sync_0_1(phoneid, method, res1) \
-    ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), 0, 0, 0, 0)
+    ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), 0, 0, 0, 0)
 #define ipc_call_sync_0_2(phoneid, method, res1, res2) \
-    ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), 0, 0, 0)
+    ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), 0, 0, 0)
 #define ipc_call_sync_0_3(phoneid, method, res1, res2, res3) \
-    ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), (res3), \
-, 0)
+    ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), (res3), \
+, 0)
 #define ipc_call_sync_0_4(phoneid, method, res1, res2, res3, res4) \
-    ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), (res3), \
-        (res4), 0)
+    ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), (res3), \
+        (res4), 0)
 #define ipc_call_sync_0_5(phoneid, method, res1, res2, res3, res4, res5) \
-    ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), (res3), \
-        (res4), (res5))
+    ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), (res3), \
+        (res4), (res5))
 #define ipc_call_sync_1_0(phoneid, method, arg1) \
-    ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, 0, 0, 0, 0, 0)
+    ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, 0, 0, 0, 0, 0)
 #define ipc_call_sync_1_1(phoneid, method, arg1, res1) \
-    ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), 0, 0, 0, 0)
+    ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), 0, 0, 0, 0)
 #define ipc_call_sync_1_2(phoneid, method, arg1, res1, res2) \
-    ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), 0, \
-, 0)
+    ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), 0, \
+, 0)
 #define ipc_call_sync_1_3(phoneid, method, arg1, res1, res2, res3) \
-    ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), \
-    (res3), 0, 0)
+    ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), \
+        (res3), 0, 0)
 #define ipc_call_sync_1_4(phoneid, method, arg1, res1, res2, res3, res4) \
-    ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), \
-    (res3), (res4), 0)
+    ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), \
+        (res3), (res4), 0)
 #define ipc_call_sync_1_5(phoneid, method, arg1, res1, res2, res3, res4, \
     res5) \
     ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), \
         (res3), (res4), (res5))
 #define ipc_call_sync_2_0(phoneid, method, arg1, arg2) \
-    ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, 0, 0, 0, \
-, 0)
+    ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, 0, 0, 0, \
+, 0)
 #define ipc_call_sync_2_1(phoneid, method, arg1, arg2, res1) \
-    ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), 0, 0, \
-, 0)
+    ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), 0, 0, \
+, 0)
 #define ipc_call_sync_2_2(phoneid, method, arg1, arg2, res1, res2) \
-    ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \
-    (res2), 0, 0, 0)
+    ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \
+        (res2), 0, 0, 0)
 #define ipc_call_sync_2_3(phoneid, method, arg1, arg2, res1, res2, res3) \
-    ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \
-    (res2), (res3), 0, 0)
+    ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \
+        (res2), (res3), 0, 0)
 #define ipc_call_sync_2_4(phoneid, method, arg1, arg2, res1, res2, res3, \
     res4) \
     ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \
 ,15 → 114,16
     res4, res5)\
     ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \
         (res2), (res3), (res4), (res5))
 #define ipc_call_sync_3_0(phoneid, method, arg1, arg2, arg3) \
-    ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, 0, 0, \
-, 0)
+    ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, 0, 0, \
+, 0)
 #define ipc_call_sync_3_1(phoneid, method, arg1, arg2, arg3, res1) \
-    ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), (res1), \
-, 0, 0, 0)
+    ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), (res1), \
+, 0, 0, 0)
 #define ipc_call_sync_3_2(phoneid, method, arg1, arg2, arg3, res1, res2) \
-    ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), (res1), \
-    (res2), 0, 0, 0)
+    ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), (res1), \
+        (res2), 0, 0, 0)
 #define ipc_call_sync_3_3(phoneid, method, arg1, arg2, arg3, res1, res2, \
     res3) \
     ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), \
 ,15 → 136,16
     res3, res4, res5) \
     ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), \
         (res1), (res2), (res3), (res4), (res5))
 #define ipc_call_sync_4_0(phoneid, method, arg1, arg2, arg3, arg4) \
-    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \
-, 0, 0, 0, 0)
+    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \
+, 0, 0, 0, 0)
 #define ipc_call_sync_4_1(phoneid, method, arg1, arg2, arg3, arg4, res1) \
-    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \
-    (res1), 0, 0, 0, 0)
+    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \
+        (res1), 0, 0, 0, 0)
 #define ipc_call_sync_4_2(phoneid, method, arg1, arg2, arg3, arg4, res1, res2) \
-    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \
-    (res1), (res2), 0, 0, 0)
+    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \
+        (res1), (res2), 0, 0, 0)
 #define ipc_call_sync_4_3(phoneid, method, arg1, arg2, arg3, arg4, res1, res2, \
     res3) \
     ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
 ,12 → 158,13
     res3, res4, res5) \
     ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
         (arg4), 0, (res1), (res2), (res3), (res4), (res5))
 #define ipc_call_sync_5_0(phoneid, method, arg1, arg2, arg3, arg4, arg5) \
-    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
-        (arg5), 0, 0, 0, 0, 0)
+    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
+        (arg5), 0, 0, 0, 0, 0)
 #define ipc_call_sync_5_1(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1) \
-    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
-        (arg5), (res1), 0, 0, 0, 0)
+    ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
+        (arg5), (res1), 0, 0, 0, 0)
 #define ipc_call_sync_5_2(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1, \
     res2) \
     ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
 ,10 → 191,12
 extern ipc_callid_t ipc_wait_cycle(ipc_call_t *, uint32_t, int);
 extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *, uint32_t);
 static inline ipc_callid_t ipc_wait_for_call(ipc_call_t *data)
 {
     return ipc_wait_for_call_timeout(data, SYNCH_NO_TIMEOUT);
 }
 extern ipc_callid_t ipc_trywait_for_call(ipc_call_t *);
 /*
 ,17 → 206,17
  * to m.
  */
 #define ipc_answer_0(callid, retval) \
-    ipc_answer_fast((callid), (retval), 0, 0, 0, 0)
+    ipc_answer_fast((callid), (retval), 0, 0, 0, 0)
 #define ipc_answer_1(callid, retval, arg1) \
-    ipc_answer_fast((callid), (retval), (arg1), 0, 0, 0)
+    ipc_answer_fast((callid), (retval), (arg1), 0, 0, 0)
 #define ipc_answer_2(callid, retval, arg1, arg2) \
-    ipc_answer_fast((callid), (retval), (arg1), (arg2), 0, 0)
+    ipc_answer_fast((callid), (retval), (arg1), (arg2), 0, 0)
 #define ipc_answer_3(callid, retval, arg1, arg2, arg3) \
-    ipc_answer_fast((callid), (retval), (arg1), (arg2), (arg3), 0)
+    ipc_answer_fast((callid), (retval), (arg1), (arg2), (arg3), 0)
 #define ipc_answer_4(callid, retval, arg1, arg2, arg3, arg4) \
-    ipc_answer_fast((callid), (retval), (arg1), (arg2), (arg3), (arg4))
+    ipc_answer_fast((callid), (retval), (arg1), (arg2), (arg3), (arg4))
 #define ipc_answer_5(callid, retval, arg1, arg2, arg3, arg4, arg5) \
-    ipc_answer_slow((callid), (retval), (arg1), (arg2), (arg3), (arg4), (arg5))
+    ipc_answer_slow((callid), (retval), (arg1), (arg2), (arg3), (arg4), (arg5))
 extern ipcarg_t ipc_answer_fast(ipc_callid_t, ipcarg_t, ipcarg_t, ipcarg_t,
     ipcarg_t, ipcarg_t);
 ,8 → 258,6
 extern void ipc_call_async_slow(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
     ipcarg_t, ipcarg_t, void *, ipc_async_callback_t, int);
-#define IPC_FLAG_BLOCKING  0x01
 extern int ipc_connect_to_me(int, int, int, int, ipcarg_t *);
 extern int ipc_connect_me_to(int, int, int, int);
 extern int ipc_connect_me_to_blocking(int, int, int, int);
 ,20 → 266,19
 extern int ipc_unregister_irq(int, int);
 extern int ipc_forward_fast(ipc_callid_t, int, int, ipcarg_t, ipcarg_t, int);
 extern int ipc_forward_slow(ipc_callid_t, int, int, ipcarg_t, ipcarg_t,
-    ipcarg_t, ipcarg_t, ipcarg_t, int);
+    ipcarg_t, ipcarg_t, ipcarg_t, int);
 /*
  * User-friendly wrappers for ipc_share_in_start().
  */
 #define ipc_share_in_start_0_0(phoneid, dst, size) \
-    ipc_share_in_start((phoneid), (dst), (size), 0, NULL)
+    ipc_share_in_start((phoneid), (dst), (size), 0, NULL)
 #define ipc_share_in_start_0_1(phoneid, dst, size, flags) \
-    ipc_share_in_start((phoneid), (dst), (size), 0, (flags))
+    ipc_share_in_start((phoneid), (dst), (size), 0, (flags))
 #define ipc_share_in_start_1_0(phoneid, dst, size, arg) \
-    ipc_share_in_start((phoneid), (dst), (size), (arg), NULL)
+    ipc_share_in_start((phoneid), (dst), (size), (arg), NULL)
 #define ipc_share_in_start_1_1(phoneid, dst, size, arg, flags) \
-    ipc_share_in_start((phoneid), (dst), (size), (arg), (flags))
+    ipc_share_in_start((phoneid), (dst), (size), (arg), (flags))
 extern int ipc_share_in_start(int, void *, size_t, ipcarg_t, int *);
 extern int ipc_share_in_receive(ipc_callid_t *, size_t *);
 ,8 → 293,6
 extern int ipc_data_write_receive(ipc_callid_t *, size_t *);
 extern int ipc_data_write_finalize(ipc_callid_t, void *, size_t);
-#include <task.h>
 extern int ipc_connect_kbox(task_id_t);
 #endif

 /branches/network/uspace/lib/libc/include/ipc/devmap.h
 ,11 → 33,14
 #ifndef DEVMAP_DEVMAP_H_
 #define DEVMAP_DEVMAP_H_
+#include <atomic.h>
 #include <ipc/ipc.h>
-#include <libadt/list.h>
+#include <adt/list.h>
-#define DEVMAP_NAME_MAXLEN 512
+#define DEVMAP_NAME_MAXLEN  255
+typedef ipcarg_t dev_handle_t;
 typedef enum {
     DEVMAP_DRIVER_REGISTER = IPC_FIRST_USER_METHOD,
     DEVMAP_DRIVER_UNREGISTER,
 ,56 → 47,30
     DEVMAP_DEVICE_REGISTER,
     DEVMAP_DEVICE_UNREGISTER,
     DEVMAP_DEVICE_GET_NAME,
-    DEVMAP_DEVICE_GET_HANDLE
+    DEVMAP_DEVICE_GET_HANDLE,
+    DEVMAP_DEVICE_GET_COUNT,
+    DEVMAP_DEVICE_GET_DEVICES
 } devmap_request_t;
-/** Representation of device driver.
- * Each driver is responsible for a set of devices.
- */
-typedef struct {
-        /** Pointers to previous and next drivers in linked list */
-    link_t drivers;
-        /** Pointer to the linked list of devices controlled by
-         * this driver */
-    link_t devices;
-        /** Phone asociated with this driver */
-    ipcarg_t phone;
-        /** Device driver name */
-    char *name;
-        /** Futex for list of devices owned by this driver */
-    atomic_t devices_futex;
-} devmap_driver_t;
-/** Info about registered device
+/** Interface provided by devmap.
  *
- */
-typedef struct {
-        /** Pointer to the previous and next device in the list of all devices */
-    link_t devices;
-        /** Pointer to the previous and next device in the list of devices
-         owned by one driver */
-    link_t driver_devices;
-        /** Unique device identifier  */
-    int handle;
-        /** Device name */
-    char *name;
-        /** Device driver handling this device */
-    devmap_driver_t *driver;
-} devmap_device_t;
-/** Interface provided by devmap.
  * Every process that connects to devmap must ask one of following
  * interfaces otherwise connection will be refused.
+ *
  */
 typedef enum {
-        /** Connect as device driver */
-    DEVMAP_DRIVER = 1,
-        /** Connect as client */
+    /** Connect as device driver */
+    DEVMAP_DRIVER = 1,
+    /** Connect as client */
     DEVMAP_CLIENT,
-        /** Create new connection to instance of device that
-         * is specified by second argument of call. */
+    /** Create new connection to instance of device that
+        is specified by second argument of call. */
     DEVMAP_CONNECT_TO_DEVICE
 } devmap_interface_t;
+typedef struct {
+    dev_handle_t handle;
+    char name[DEVMAP_NAME_MAXLEN + 1];
+} dev_desc_t;
 #endif

 /branches/network/uspace/lib/libc/include/ipc/vfs.h
 ,0 → 1,147
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libcipc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_IPC_VFS_H_
+#define LIBC_IPC_VFS_H_
+#include <sys/types.h>
+#include <ipc/ipc.h>
+#define FS_NAME_MAXLEN  20
+#define MAX_PATH_LEN    (64 * 1024)
+#define PLB_SIZE        (2 * MAX_PATH_LEN)
+/* Basic types. */
+typedef int16_t fs_handle_t;
+typedef uint32_t fs_index_t;
+/**
+ * A structure like this is passed to VFS by each individual FS upon its
+ * registration. It assosiates a human-readable identifier with each
+ * registered FS.
+ */
+typedef struct {
+    /** Unique identifier of the fs. */
+    char name[FS_NAME_MAXLEN + 1];
+} vfs_info_t;
+typedef enum {
+    VFS_OPEN_NODE = IPC_FIRST_USER_METHOD,
+    VFS_READ,
+    VFS_WRITE,
+    VFS_TRUNCATE,
+    VFS_MOUNT,
+    VFS_UNMOUNT,
+    VFS_DEVICE,
+    VFS_SYNC,
+    VFS_CLOSE,
+    VFS_LAST_CMN  /* keep this the last member of this enum */
+} vfs_request_cmn_t;
+typedef enum {
+    VFS_LOOKUP = VFS_LAST_CMN,
+    VFS_MOUNTED,
+    VFS_DESTROY,
+    VFS_LAST_CLNT  /* keep this the last member of this enum */
+} vfs_request_clnt_t;
+typedef enum {
+    VFS_REGISTER = VFS_LAST_CMN,
+    VFS_OPEN,
+    VFS_SEEK,
+    VFS_MKDIR,
+    VFS_UNLINK,
+    VFS_RENAME,
+    VFS_NODE,
+    VFS_LAST_SRV  /* keep this the last member of this enum */
+} vfs_request_srv_t;
+/*
+ * Lookup flags.
+ */
+/**
+ * No lookup flags used.
+ */
+#define L_NONE  0
+/**
+ * Lookup will succeed only if the object is a regular file.  If L_CREATE is
+ * specified, an empty file will be created. This flag is mutually exclusive
+ * with L_DIRECTORY.
+ */
+#define L_FILE  1
+/**
+ * Lookup wil succeed only if the object is a directory. If L_CREATE is
+ * specified, an empty directory will be created. This flag is mutually
+ * exclusive with L_FILE.
+ */
+#define L_DIRECTORY  2
+/**
+ * When used with L_CREATE, L_EXCLUSIVE will cause the lookup to fail if the
+ * object already exists. L_EXCLUSIVE is implied when L_DIRECTORY is used.
+ */
+#define L_EXCLUSIVE  4
+/**
+ * L_CREATE is used for creating both regular files and directories.
+ */
+#define L_CREATE  8
+/**
+ * L_LINK is used for linking to an already existing nodes.
+ */
+#define L_LINK  16
+/**
+ * L_UNLINK is used to remove leaves from the file system namespace. This flag
+ * cannot be passed directly by the client, but will be set by VFS during
+ * VFS_UNLINK.
+ */
+#define L_UNLINK  32
+/**
+ * L_OPEN is used to indicate that the lookup operation is a part of VFS_OPEN
+ * call from the client. This means that the server might allocate some
+ * resources for the opened file. This flag cannot be passed directly by the
+ * client.
+ */
+#define L_OPEN  64
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/ipc/ns.h
 ,6 → 35,13
 #ifndef LIBIPC_NS_H_
 #define LIBIPC_NS_H_
+#include <ipc/ipc.h>
+typedef enum {
+    NS_PING = IPC_FIRST_USER_METHOD,
+    NS_TASK_WAIT
+} ns_request_t;
 #endif
 /** @}

 /branches/network/uspace/lib/libc/include/ipc/console.h
 ,7 → 27,7
  */
 /** @addtogroup libcipc
- * @{
+ * @{
  */
 /** @file
  */
 ,15 → 36,13
 #define LIBC_IPC_CONSOLE_H_
 #include <ipc/ipc.h>
+#include <ipc/vfs.h>
 typedef enum {
-    CONSOLE_GETKEY = IPC_FIRST_USER_METHOD,
-    CONSOLE_PUTCHAR,
-    CONSOLE_WRITE,
+    CONSOLE_GET_SIZE = VFS_LAST_SRV,
+    CONSOLE_GET_EVENT,
+    CONSOLE_GOTO,
     CONSOLE_CLEAR,
-    CONSOLE_GOTO,
-    CONSOLE_GETSIZE,
-    CONSOLE_FLUSH,
     CONSOLE_SET_STYLE,
     CONSOLE_SET_COLOR,
     CONSOLE_SET_RGB_COLOR,
 ,6 → 51,6
 } console_request_t;
 #endif
 /** @}
  */

 /branches/network/uspace/lib/libc/include/ipc/bd.h
 ,0 → 1,48
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libcipc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_IPC_BD_H_
+#define LIBC_IPC_BD_H_
+#include <ipc/ipc.h>
+typedef enum {
+    BD_READ_BLOCK = IPC_FIRST_USER_METHOD,
+    BD_WRITE_BLOCK
+} bd_request_t;
+#endif
+/** @}
+ */

/branches/network/uspace/lib/libc/include/ipc/loader.h
42,6 → 42,7
LOADER_GET_TASKID,
LOADER_SET_PATHNAME,
LOADER_SET_ARGS,
LOADER_SET_FILES,
LOADER_LOAD,
LOADER_RUN
} loader_request_t;

 /branches/network/uspace/lib/libc/include/errno.h
 ,17 → 41,18
 #include <kernel/errno.h>
-#define ENAMETOOLONG    (-256)
-#define EISDIR      (-257)
-#define ENOTDIR     (-258)
-#define ENOSPC      (-259)
-#define EEXIST      (-260)
-#define ENOTEMPTY   (-261)
-#define EBADF       (-262)
-#define ERANGE      (-263)
-#define EXDEV       (-264)
-#define EIO     (-265)
-#define EMLINK      (-266)
+#define EMFILE        (-17)
+#define ENAMETOOLONG  (-256)
+#define EISDIR        (-257)
+#define ENOTDIR       (-258)
+#define ENOSPC        (-259)
+#define EEXIST        (-260)
+#define ENOTEMPTY     (-261)
+#define EBADF         (-262)
+#define ERANGE        (-263)
+#define EXDEV         (-264)
+#define EIO           (-265)
+#define EMLINK        (-266)
 #endif

 /branches/network/uspace/lib/libc/Makefile.toolchain
 ,10 → 26,11
 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
-CFLAGS = -fno-builtin -Wall -Werror-implicit-function-declaration \
-    -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32 -finput-charset=UTF-8 \
-    -Wmissing-prototypes -O3 -nostdlib -nostdinc -imacros \
-    $(LIBC_PREFIX)/../../../config.h -I$(LIBC_PREFIX)/include -pipe -g
+CFLAGS = -I$(LIBC_PREFIX)/include -O3 -imacros $(LIBC_PREFIX)/../../../config.h \
+    -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32$(ENDIANESS) \
+    -finput-charset=UTF-8 -fno-builtin -Wall -Wextra -Wno-unused-parameter \
+    -Wmissing-prototypes -Werror-implicit-function-declaration -nostdlib \
+    -nostdinc -pipe -g -D__$(ENDIANESS)__
 LFLAGS = -M -N $(SOFTINT_PREFIX)/libsoftint.a
 AFLAGS =

 /branches/network/uspace/lib/libc/generic/ddi.c
 ,10 → 127,10
     }
 #endif
-    phys = ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
+    phys = (void *) ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
     offset = pio_addr - phys;
     pages = ALIGN_UP(offset + size, PAGE_SIZE) >> PAGE_WIDTH;
-    virt = as_get_mappable_page(pages);
+    virt = as_get_mappable_page(pages << PAGE_WIDTH);
     *use_addr = virt + offset;
     return physmem_map(phys, virt, pages, AS_AREA_READ | AS_AREA_WRITE);
 }

 /branches/network/uspace/lib/libc/generic/task.c
 ,7 → 31,7
  * @{
  */
 /** @file
- */
+ */
 #include <task.h>
 #include <libc.h>
 ,21 → 39,25
 #include <errno.h>
 #include <loader/loader.h>
 #include <string.h>
+#include <ipc/ns.h>
+#include <macros.h>
+#include <async.h>
 task_id_t task_get_id(void)
 {
     task_id_t task_id;
     (void) __SYSCALL1(SYS_TASK_GET_ID, (sysarg_t) &task_id);
     return task_id;
 }
 /** Set the task name.
  *
- * @param name  The new name, typically the command used to execute the
- *      program.
- * @return  Zero on success or negative error code.
+ * @param name The new name, typically the command used to execute the
+ *             program.
+ *
+ * @return Zero on success or negative error code.
+ *
  */
 int task_set_name(const char *name)
 {
 ,58 → 69,89
  * This is really just a convenience wrapper over the more complicated
  * loader API.
  *
- * @param path  pathname of the binary to execute
- * @param argv  command-line arguments
- * @return  ID of the newly created task or zero on error.
+ * @param path pathname of the binary to execute
+ * @param argv command-line arguments
+ *
+ * @return ID of the newly created task or zero on error.
+ *
  */
-task_id_t task_spawn(const char *path, char *const argv[])
+task_id_t task_spawn(const char *path, char *const args[])
 {
-    loader_t *ldr;
-    task_id_t task_id;
-    int rc;
     /* Connect to a program loader. */
-    ldr = loader_connect();
+    loader_t *ldr = loader_connect();
     if (ldr == NULL)
         return 0;
     /* Get task ID. */
-    rc = loader_get_task_id(ldr, &task_id);
+    task_id_t task_id;
+    int rc = loader_get_task_id(ldr, &task_id);
     if (rc != EOK)
         goto error;
     /* Send program pathname. */
     rc = loader_set_pathname(ldr, path);
     if (rc != EOK)
         goto error;
     /* Send arguments. */
-    rc = loader_set_args(ldr, argv);
+    rc = loader_set_args(ldr, args);
     if (rc != EOK)
         goto error;
+    /* Send default files */
+    fdi_node_t *files[4];
+    fdi_node_t stdin_node;
+    fdi_node_t stdout_node;
+    fdi_node_t stderr_node;
+    if ((stdin != NULL) && (fnode(stdin, &stdin_node) == EOK))
+        files[0] = &stdin_node;
+    else
+        files[0] = NULL;
+    if ((stdout != NULL) && (fnode(stdout, &stdout_node) == EOK))
+        files[1] = &stdout_node;
+    else
+        files[1] = NULL;
+    if ((stderr != NULL) && (fnode(stderr, &stderr_node) == EOK))
+        files[2] = &stderr_node;
+    else
+        files[2] = NULL;
+    files[3] = NULL;
+    rc = loader_set_files(ldr, files);
+    if (rc != EOK)
+        goto error;
     /* Load the program. */
     rc = loader_load_program(ldr);
     if (rc != EOK)
         goto error;
     /* Run it. */
     rc = loader_run(ldr);
     if (rc != EOK)
         goto error;
     /* Success */
     free(ldr);
     return task_id;
+error:
     /* Error exit */
-error:
     loader_abort(ldr);
     free(ldr);
     return 0;
 }
+int task_wait(task_id_t id)
+{
+    return (int) async_req_2_0(PHONE_NS, NS_TASK_WAIT, LOWER32(id), UPPER32(id));
+}
 /** @}
  */

 /branches/network/uspace/lib/libc/generic/fibril_sync.c
 ,0 → 1,219
+/*
+ * Copyright (c) 2009 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#include <fibril_sync.h>
+#include <fibril.h>
+#include <async.h>
+#include <adt/list.h>
+#include <futex.h>
+#include <assert.h>
+void fibril_mutex_initialize(fibril_mutex_t *fm)
+{
+    fm->counter = 1;
+    list_initialize(&fm->waiters);
+}
+void fibril_mutex_lock(fibril_mutex_t *fm)
+{
+    futex_down(&async_futex);
+    if (fm->counter-- <= 0) {
+        fibril_t *f = (fibril_t *) fibril_get_id();
+        list_append(&f->link, &fm->waiters);
+        fibril_switch(FIBRIL_TO_MANAGER);
+    } else {
+        futex_up(&async_futex);
+    }
+}
+bool fibril_mutex_trylock(fibril_mutex_t *fm)
+{
+    bool locked = false;
+    futex_down(&async_futex);
+    if (fm->counter > 0) {
+        fm->counter--;
+        locked = true;
+    }
+    futex_up(&async_futex);
+    return locked;
+}
+static void _fibril_mutex_unlock_unsafe(fibril_mutex_t *fm)
+{
+    assert(fm->counter <= 0);
+    if (fm->counter++ < 0) {
+        link_t *tmp;
+        fibril_t *f;
+        assert(!list_empty(&fm->waiters));
+        tmp = fm->waiters.next;
+        f = list_get_instance(tmp, fibril_t, link);
+        list_remove(&f->link);
+        fibril_add_ready((fid_t) f);
+    }
+}
+void fibril_mutex_unlock(fibril_mutex_t *fm)
+{
+    futex_down(&async_futex);
+    _fibril_mutex_unlock_unsafe(fm);
+    futex_up(&async_futex);
+}
+void fibril_rwlock_initialize(fibril_rwlock_t *frw)
+{
+    frw->writers = 0;
+    frw->readers = 0;
+    list_initialize(&frw->waiters);
+}
+void fibril_rwlock_read_lock(fibril_rwlock_t *frw)
+{
+    futex_down(&async_futex);
+    if (frw->writers) {
+        fibril_t *f = (fibril_t *) fibril_get_id();
+        f->flags &= ~FIBRIL_WRITER;
+        list_append(&f->link, &frw->waiters);
+        fibril_switch(FIBRIL_TO_MANAGER);
+    } else {
+        frw->readers++;
+        futex_up(&async_futex);
+    }
+}
+void fibril_rwlock_write_lock(fibril_rwlock_t *frw)
+{
+    futex_down(&async_futex);
+    if (frw->writers || frw->readers) {
+        fibril_t *f = (fibril_t *) fibril_get_id();
+        f->flags |= FIBRIL_WRITER;
+        list_append(&f->link, &frw->waiters);
+        fibril_switch(FIBRIL_TO_MANAGER);
+    } else {
+        frw->writers++;
+        futex_up(&async_futex);
+    }
+}
+static void _fibril_rwlock_common_unlock(fibril_rwlock_t *frw)
+{
+    futex_down(&async_futex);
+    assert(frw->readers || (frw->writers == 1));
+    if (frw->readers) {
+        if (--frw->readers)
+            goto out;
+    } else {
+        frw->writers--;
+    }
+    assert(!frw->readers && !frw->writers);
+    while (!list_empty(&frw->waiters)) {
+        link_t *tmp = frw->waiters.next;
+        fibril_t *f = list_get_instance(tmp, fibril_t, link);
+        if (f->flags & FIBRIL_WRITER) {
+            if (frw->readers)
+                break;
+            list_remove(&f->link);
+            fibril_add_ready((fid_t) f);
+            frw->writers++;
+            break;
+        } else {
+            list_remove(&f->link);
+            fibril_add_ready((fid_t) f);
+            frw->readers++;
+        }
+    }
+out:
+    futex_up(&async_futex);
+}
+void fibril_rwlock_read_unlock(fibril_rwlock_t *frw)
+{
+    _fibril_rwlock_common_unlock(frw);
+}
+void fibril_rwlock_write_unlock(fibril_rwlock_t *frw)
+{
+    _fibril_rwlock_common_unlock(frw);
+}
+void fibril_condvar_initialize(fibril_condvar_t *fcv)
+{
+    list_initialize(&fcv->waiters);
+}
+void fibril_condvar_wait(fibril_condvar_t *fcv, fibril_mutex_t *fm)
+{
+    fibril_t *f = (fibril_t *) fibril_get_id();
+    futex_down(&async_futex);
+    list_append(&f->link, &fcv->waiters);
+    _fibril_mutex_unlock_unsafe(fm);
+    fibril_switch(FIBRIL_TO_MANAGER);
+    fibril_mutex_lock(fm);
+}
+static void _fibril_condvar_wakeup_common(fibril_condvar_t *fcv, bool once)
+{
+    link_t *tmp;
+    fibril_t *f;
+    futex_down(&async_futex);
+    while (!list_empty(&fcv->waiters)) {
+        tmp = fcv->waiters.next;
+        f = list_get_instance(tmp, fibril_t, link);
+        list_remove(&f->link);
+        fibril_add_ready((fid_t) f);
+        if (once)
+            break;
+    }
+    futex_up(&async_futex);
+}
+void fibril_condvar_signal(fibril_condvar_t *fcv)
+{
+    _fibril_condvar_wakeup_common(fcv, true);
+}
+void fibril_condvar_broadcast(fibril_condvar_t *fcv)
+{
+    _fibril_condvar_wakeup_common(fcv, false);
+}
+/** @}
+ */

 /branches/network/uspace/lib/libc/generic/as.c
 ,7 → 30,7
  * @{
  */
 /** @file
- */
+ */
 #include <as.h>
 #include <libc.h>
 ,7 → 102,7
 static size_t heapsize = 0;
 static size_t maxheapsize = (size_t) (-1);
-static void * last_allocated = 0;
+static void *last_allocated = 0;
 /* Start of heap linker symbol */
 extern char _heap;
 ,15 → 119,15
     void *res;
     /* Check for invalid values */
-    if (incr < 0 && -incr > heapsize)
+    if ((incr < 0) && (((size_t) -incr) > heapsize))
         return NULL;
     /* Check for too large value */
-    if (incr > 0 && incr+heapsize < heapsize)
+    if ((incr > 0) && (incr + heapsize < heapsize))
         return NULL;
     /* Check for too small values */
-    if (incr < 0 && incr+heapsize > heapsize)
+    if ((incr < 0) && (incr + heapsize > heapsize))
         return NULL;
     /* Check for user limit */
 ,7 → 175,7
     asz = 1 << (fnzb64(sz - 1) + 1);
     /* Set heapsize to some meaningful value */
-    if (maxheapsize == -1)
+    if (maxheapsize == (size_t) -1)
         set_maxheapsize(MAX_HEAP_SIZE);
     /*

 /branches/network/uspace/lib/libc/generic/string.c
 ,8 → 138,8
  * @param size   Size of the output buffer (in bytes).
  *
  * @return EOK if the character was encoded successfully, EOVERFLOW if there
- *     was not enough space in the output buffer or EINVAL if the character
- *     code was invalid.
+ *         was not enough space in the output buffer or EINVAL if the character
+ *         code was invalid.
  */
 int chr_encode(const wchar_t ch, char *str, size_t *offset, size_t size)
 {
 ,9 → 243,9
  * @return Number of bytes used by the characters.
  *
  */
-size_t str_lsize(const char *str, count_t max_len)
+size_t str_lsize(const char *str, size_t max_len)
 {
-    count_t len = 0;
+    size_t len = 0;
     size_t offset = 0;
     while (len < max_len) {
 ,7 → 271,7
  * @return Number of bytes used by the wide characters.
  *
  */
-size_t wstr_lsize(const wchar_t *str, count_t max_len)
+size_t wstr_lsize(const wchar_t *str, size_t max_len)
 {
     return (wstr_nlength(str, max_len * sizeof(wchar_t)) * sizeof(wchar_t));
 }
 ,9 → 283,9
  * @return Number of characters in string.
  *
  */
-count_t str_length(const char *str)
+size_t str_length(const char *str)
 {
-    count_t len = 0;
+    size_t len = 0;
     size_t offset = 0;
     while (str_decode(str, &offset, STR_NO_LIMIT) != 0)
 ,9 → 301,9
  * @return Number of characters in @a str.
  *
  */
-count_t wstr_length(const wchar_t *wstr)
+size_t wstr_length(const wchar_t *wstr)
 {
-    count_t len = 0;
+    size_t len = 0;
     while (*wstr++ != 0)
         len++;
 ,9 → 319,9
  * @return Number of characters in string.
  *
  */
-count_t str_nlength(const char *str, size_t size)
+size_t str_nlength(const char *str, size_t size)
 {
-    count_t len = 0;
+    size_t len = 0;
     size_t offset = 0;
     while (str_decode(str, &offset, size) != 0)
 ,11 → 338,11
  * @return Number of characters in string.
  *
  */
-count_t wstr_nlength(const wchar_t *str, size_t size)
+size_t wstr_nlength(const wchar_t *str, size_t size)
 {
-    count_t len = 0;
-    count_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
-    count_t offset = 0;
+    size_t len = 0;
+    size_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
+    size_t offset = 0;
     while ((offset < limit) && (*str++ != 0)) {
         len++;
 ,7 → 430,7
  *         1 if second smaller.
  *
  */
-int str_lcmp(const char *s1, const char *s2, count_t max_len)
+int str_lcmp(const char *s1, const char *s2, size_t max_len)
 {
     wchar_t c1 = 0;
     wchar_t c2 = 0;
 ,7 → 438,7
     size_t off1 = 0;
     size_t off2 = 0;
-    count_t len = 0;
+    size_t len = 0;
     while (true) {
         if (len >= max_len)
 ,7 → 568,7
         return;
     wchar_t ch;
-    count_t src_idx = 0;
+    size_t src_idx = 0;
     size_t dst_off = 0;
     while ((ch = src[src_idx++]) != 0) {
 ,7 → 616,7
     wchar_t acc;
     size_t off = 0;
     size_t last = 0;
-    char *res = NULL;
+    const char *res = NULL;
     while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) {
         if (acc == ch)
 ,14 → 641,14
  *         is out of bounds.
  *
  */
-bool wstr_linsert(wchar_t *str, wchar_t ch, count_t pos, count_t max_pos)
+bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos)
 {
-    count_t len = wstr_length(str);
+    size_t len = wstr_length(str);
     if ((pos > len) || (pos + 1 > max_pos))
         return false;
-    count_t i;
+    size_t i;
     for (i = len; i + 1 > pos; i--)
         str[i + 1] = str[i];
 ,14 → 669,14
  *         is out of bounds.
  *
  */
-bool wstr_remove(wchar_t *str, count_t pos)
+bool wstr_remove(wchar_t *str, size_t pos)
 {
-    count_t len = wstr_length(str);
+    size_t len = wstr_length(str);
     if (pos >= len)
         return false;
-    count_t i;
+    size_t i;
     for (i = pos + 1; i <= len; i++)
         str[i - 1] = str[i];

 /branches/network/uspace/lib/libc/generic/loader.c
 ,7 → 30,7
  * @{
  */
 /** @file
- */
+ */
 #include <ipc/ipc.h>
 #include <ipc/loader.h>
 ,9 → 47,12
 /** Connect to a new program loader.
  *
  * Spawns a new program loader task and returns the connection structure.
- * @param name  Symbolic name to set on the newly created task.
- * @return  Pointer to the loader connection structure (should be
- *      de-allocated using free() after use).
+ *
+ * @param name Symbolic name to set on the newly created task.
+ *
+ * @return Pointer to the loader connection structure (should be
+ *         deallocated using free() after use).
+ *
  */
 int loader_spawn(const char *name)
 {
 ,19 → 62,16
 loader_t *loader_connect(void)
 {
-    loader_t *ldr;
-    int phone_id;
-    phone_id = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_LOAD, 0, 0);
+    int phone_id = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_LOAD, 0, 0);
     if (phone_id < 0)
         return NULL;
-    ldr = malloc(sizeof(loader_t));
+    loader_t *ldr = malloc(sizeof(loader_t));
     if (ldr == NULL)
         return NULL;
     ldr->phone_id = phone_id;
-    return ldr;
+    return ldr;
 }
 /** Get ID of the new task.
 ,27 → 78,26
  *
  * Retrieves the ID of the new task from the loader.
  *
- * @param ldr       Loader connection structure.
- * @param task_id   Points to a variable where the ID should be stored.
- * @return      Zero on success or negative error code.
+ * @param ldr     Loader connection structure.
+ * @param task_id Points to a variable where the ID should be stored.
+ *
+ * @return Zero on success or negative error code.
+ *
  */
 int loader_get_task_id(loader_t *ldr, task_id_t *task_id)
 {
+    /* Get task ID. */
     ipc_call_t answer;
-    aid_t req;
-    int rc;
-    ipcarg_t retval;
-    /* Get task ID. */
-    req = async_send_0(ldr->phone_id, LOADER_GET_TASKID, &answer);
-    rc = ipc_data_read_start(ldr->phone_id, task_id, sizeof(task_id_t));
+    aid_t req = async_send_0(ldr->phone_id, LOADER_GET_TASKID, &answer);
+    int rc = ipc_data_read_start(ldr->phone_id, task_id, sizeof(task_id_t));
     if (rc != EOK) {
         async_wait_for(req, NULL);
         return rc;
     }
+    ipcarg_t retval;
     async_wait_for(req, &retval);
-    return (int)retval;
+    return (int) retval;
 }
 /** Set pathname of the program to load.
 ,39 → 106,35
  * to the current working directory (it will be absolutized before
  * sending to the loader).
  *
- * @param ldr       Loader connection structure.
- * @param path      Pathname of the program file.
- * @return      Zero on success or negative error code.
+ * @param ldr  Loader connection structure.
+ * @param path Pathname of the program file.
+ *
+ * @return Zero on success or negative error code.
+ *
  */
 int loader_set_pathname(loader_t *ldr, const char *path)
 {
-    ipc_call_t answer;
-    aid_t req;
-    int rc;
-    ipcarg_t retval;
-    char *pa;
     size_t pa_len;
-    pa = absolutize(path, &pa_len);
+    char *pa = absolutize(path, &pa_len);
     if (!pa)
         return 0;
     /* Send program pathname */
-    req = async_send_0(ldr->phone_id, LOADER_SET_PATHNAME, &answer);
-    rc = ipc_data_write_start(ldr->phone_id, (void *)pa, pa_len);
+    ipc_call_t answer;
+    aid_t req = async_send_0(ldr->phone_id, LOADER_SET_PATHNAME, &answer);
+    int rc = ipc_data_write_start(ldr->phone_id, (void *) pa, pa_len);
     if (rc != EOK) {
         async_wait_for(req, NULL);
         return rc;
     }
     free(pa);
+    ipcarg_t retval;
     async_wait_for(req, &retval);
-    return (int)retval;
+    return (int) retval;
 }
 /** Set command-line arguments for the program.
  *
  * Sets the vector of command-line arguments to be passed to the loaded
 ,61 → 141,110
  * program. By convention, the very first argument is typically the same as
  * the command used to execute the program.
  *
- * @param ldr       Loader connection structure.
- * @param argv      NULL-terminated array of pointers to arguments.
- * @return      Zero on success or negative error code.
+ * @param ldr  Loader connection structure.
+ * @param argv NULL-terminated array of pointers to arguments.
+ *
+ * @return Zero on success or negative error code.
+ *
  */
 int loader_set_args(loader_t *ldr, char *const argv[])
 {
-    aid_t req;
-    ipc_call_t answer;
-    ipcarg_t rc;
-    char *const *ap;
-    char *dp;
-    char *arg_buf;
-    size_t buffer_size;
-    /*
+    /*
      * Serialize the arguments into a single array. First
      * compute size of the buffer needed.
      */
-    ap = argv;
-    buffer_size = 0;
+    char *const *ap = argv;
+    size_t buffer_size = 0;
     while (*ap != NULL) {
         buffer_size += str_size(*ap) + 1;
-        ++ap;
+        ap++;
     }
-    arg_buf = malloc(buffer_size);
-    if (arg_buf == NULL) return ENOMEM;
+    char *arg_buf = malloc(buffer_size);
+    if (arg_buf == NULL)
+        return ENOMEM;
     /* Now fill the buffer with null-terminated argument strings */
     ap = argv;
-    dp = arg_buf;
+    char *dp = arg_buf;
     while (*ap != NULL) {
         str_cpy(dp, buffer_size - (dp - arg_buf), *ap);
         dp += str_size(*ap) + 1;
-        ++ap;
+        ap++;
     }
     /* Send serialized arguments to the loader */
-    req = async_send_0(ldr->phone_id, LOADER_SET_ARGS, &answer);
-    rc = ipc_data_write_start(ldr->phone_id, (void *)arg_buf, buffer_size);
+    ipc_call_t answer;
+    aid_t req = async_send_0(ldr->phone_id, LOADER_SET_ARGS, &answer);
+    ipcarg_t rc = ipc_data_write_start(ldr->phone_id, (void *) arg_buf, buffer_size);
     if (rc != EOK) {
         async_wait_for(req, NULL);
         return rc;
     }
     async_wait_for(req, &rc);
-    if (rc != EOK) return rc;
+    if (rc != EOK)
+        return rc;
     /* Free temporary buffer */
     free(arg_buf);
+    return EOK;
+}
+/** Set preset files for the program.
+ *
+ * Sets the vector of preset files to be passed to the loaded
+ * program. By convention, the first three files represent stdin,
+ * stdout and stderr respectively.
+ *
+ * @param ldr   Loader connection structure.
+ * @param files NULL-terminated array of pointers to files.
+ *
+ * @return Zero on success or negative error code.
+ *
+ */
+int loader_set_files(loader_t *ldr, fdi_node_t *const files[])
+{
+    /*
+     * Serialize the arguments into a single array. First
+     * compute size of the buffer needed.
+     */
+    fdi_node_t *const *ap = files;
+    size_t count = 0;
+    while (*ap != NULL) {
+        count++;
+        ap++;
+    }
+    fdi_node_t *files_buf;
+    files_buf = (fdi_node_t *) malloc(count * sizeof(fdi_node_t));
+    if (files_buf == NULL)
+        return ENOMEM;
+    /* Fill the buffer */
+    size_t i;
+    for (i = 0; i < count; i++)
+        files_buf[i] = *files[i];
+    /* Send serialized files to the loader */
+    ipc_call_t answer;
+    aid_t req = async_send_0(ldr->phone_id, LOADER_SET_FILES, &answer);
+    ipcarg_t rc = ipc_data_write_start(ldr->phone_id, (void *) files_buf,
+        count * sizeof(fdi_node_t));
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        return rc;
+    }
+    async_wait_for(req, &rc);
+    if (rc != EOK)
+        return rc;
+    /* Free temporary buffer */
+    free(files_buf);
     return EOK;
 }
 ,18 → 253,14
  * If this function succeeds, the program has been successfully loaded
  * and is ready to be executed.
  *
- * @param ldr       Loader connection structure.
- * @return      Zero on success or negative error code.
+ * @param ldr Loader connection structure.
+ *
+ * @return Zero on success or negative error code.
+ *
  */
 int loader_load_program(loader_t *ldr)
 {
-    int rc;
-    rc = async_req_0_0(ldr->phone_id, LOADER_LOAD);
-    if (rc != EOK)
-        return rc;
-    return EOK;
+    return (int) async_req_0_0(ldr->phone_id, LOADER_LOAD);
 }
 /** Instruct loader to execute the program.
 ,17 → 272,17
  * After using this function, no further operations must be performed
  * on the loader structure. It should be de-allocated using free().
  *
- * @param ldr       Loader connection structure.
- * @return      Zero on success or negative error code.
+ * @param ldr Loader connection structure.
+ *
+ * @return Zero on success or negative error code.
+ *
  */
 int loader_run(loader_t *ldr)
 {
-    int rc;
-    rc = async_req_0_0(ldr->phone_id, LOADER_RUN);
+    int rc = async_req_0_0(ldr->phone_id, LOADER_RUN);
     if (rc != EOK)
         return rc;
     ipc_hangup(ldr->phone_id);
     ldr->phone_id = 0;
     return EOK;
 ,8 → 294,10
  * After using this function, no further operations must be performed
  * on the loader structure. It should be de-allocated using free().
  *
- * @param ldr       Loader connection structure.
- * @return      Zero on success or negative error code.
+ * @param ldr Loader connection structure.
+ *
+ * @return Zero on success or negative error code.
+ *
  */
 void loader_abort(loader_t *ldr)
 {

 /branches/network/uspace/lib/libc/generic/fibril.c
 ,7 → 33,7
 /** @file
  */
-#include <libadt/list.h>
+#include <adt/list.h>
 #include <fibril.h>
 #include <thread.h>
 #include <tls.h>
 ,7 → 49,8
 #define FIBRIL_INITIAL_STACK_PAGES_NO   1
 #endif
-/** This futex serializes access to ready_list, serialized_list and manage_list.
+/**
+ * This futex serializes access to ready_list, serialized_list and manager_list.
  */
 static atomic_t fibril_futex = FUTEX_INITIALIZER;
 ,12 → 60,12
 static void fibril_main(void);
-/** Number of fibrils that are in async_serialized mode */
-static int serialized_fibrils;  /* Protected by async_futex */
-/** Thread-local count of serialization. If >0, we must not preempt */
-static __thread int serialization_count;
-/** Counter for fibrils residing in async_manager */
-static int fibrils_in_manager;
+/** Number of threads that are executing a manager fibril. */
+static int threads_in_manager;
+/** Number of threads that are executing a manager fibril and are serialized. */
+static int serialized_threads;  /* Protected by async_futex */
+/** Fibril-local count of serialization. If > 0, we must not preempt */
+static fibril_local int serialization_count;
 /** Setup fibril information into TCB structure */
 fibril_t *fibril_setup(void)
 ,11 → 144,11
         if (list_empty(&ready_list) && list_empty(&serialized_list))
             goto ret_0;
         /*
-         * Do not preempt if there is not sufficient count of fibril
-         * managers.
+         * Do not preempt if there is not enough threads to run the
+         * ready fibrils which are not serialized.
          */
         if (list_empty(&serialized_list) &&
-            fibrils_in_manager <= serialized_fibrils) {
+            threads_in_manager <= serialized_threads) {
             goto ret_0;
         }
     }
 ,7 → 195,7
             list_append(&srcf->link, &ready_list);
         else if (stype == FIBRIL_FROM_MANAGER) {
             list_append(&srcf->link, &manager_list);
-            fibrils_in_manager--;
+            threads_in_manager--;
         } else {
             /*
              * If stype == FIBRIL_TO_MANAGER, don't put ourselves to
 ,10 → 209,10
     if (stype == FIBRIL_TO_MANAGER || stype == FIBRIL_FROM_DEAD) {
         dstf = list_get_instance(manager_list.next, fibril_t, link);
         if (serialization_count && stype == FIBRIL_TO_MANAGER) {
-            serialized_fibrils++;
+            serialized_threads++;
             srcf->flags |= FIBRIL_SERIALIZED;
         }
-        fibrils_in_manager++;
+        threads_in_manager++;
         if (stype == FIBRIL_FROM_DEAD)
             dstf->clean_after_me = srcf;
 ,7 → 220,7
         if (!list_empty(&serialized_list)) {
             dstf = list_get_instance(serialized_list.next, fibril_t,
                 link);
-            serialized_fibrils--;
+            serialized_threads--;
         } else {
             dstf = list_get_instance(ready_list.next, fibril_t,
                 link);
 ,7 → 270,7
 /** Add a fibril to the ready list.
  *
- * @param fid       Pinter to the fibril structure of the fibril to be
+ * @param fid       Pointer to the fibril structure of the fibril to be
  *          added.
  */
 void fibril_add_ready(fid_t fid)
 ,7 → 288,8
 /** Add a fibril to the manager list.
  *
- * @param fid       Pinter to the fibril structure of the fibril to be added.
+ * @param fid       Pointer to the fibril structure of the fibril to be
+ *          added.
  */
 void fibril_add_manager(fid_t fid)
 {
 ,7 → 316,8
 /** Return fibril id of the currently running fibril.
  *
- * @return      Fibril ID of the currently running pseudo thread.
+ * @return fibril ID of the currently running fibril.
+ *
  */
 fid_t fibril_get_id(void)
 {
 ,13 → 324,14
     return (fid_t) __tcb_get()->fibril_data;
 }
-/** Disable preemption
+/** Disable preemption
  *
  * If the fibril wants to send several message in a row and does not want to be
  * preempted, it should start async_serialize_start() in the beginning of
  * communication and async_serialize_end() in the end. If it is a true
  * multithreaded application, it should protect the communication channel by a
- * futex as well. Interrupt messages can still be preempted.
+ * futex as well.
+ *
  */
 void fibril_inc_sercount(void)
 {

 /branches/network/uspace/lib/libc/generic/libc.c
 ,28 → 27,29
  */
 /** @addtogroup lc Libc
- * @brief   HelenOS C library
+ * @brief HelenOS C library
  * @{
  * @}
  */
 /** @addtogroup libc generic
  * @ingroup lc
  * @{
  */
 /** @file
- */
+ */
 #include <libc.h>
+#include <stdio.h>
 #include <unistd.h>
 #include <malloc.h>
 #include <tls.h>
 #include <thread.h>
 #include <fibril.h>
-#include <io/stream.h>
 #include <ipc/ipc.h>
 #include <async.h>
 #include <as.h>
-#include <console.h>
 #include <loader/pcb.h>
 extern char _heap;
 ,28 → 64,30
 void __main(void *pcb_ptr)
 {
-    fibril_t *f;
-    int argc;
-    char **argv;
     (void) as_area_create(&_heap, 1, AS_AREA_WRITE | AS_AREA_READ);
     _async_init();
-    f = fibril_setup();
-    __tcb_set(f->tcb);
+    fibril_t *fibril = fibril_setup();
+    __tcb_set(fibril->tcb);
     /* Save the PCB pointer */
-    __pcb = (pcb_t *)pcb_ptr;
+    __pcb = (pcb_t *) pcb_ptr;
+    int argc;
+    char **argv;
     if (__pcb == NULL) {
         argc = 0;
         argv = NULL;
+        stdio_init(0, NULL);
     } else {
         argc = __pcb->argc;
         argv = __pcb->argv;
+        stdio_init(__pcb->filc, __pcb->filv);
     }
     main(argc, argv);
-    console_flush();
+    stdio_done();
 }
 void __exit(void)

 /branches/network/uspace/lib/libc/generic/ipc.c
 ,7 → 43,7
 #include <libc.h>
 #include <malloc.h>
 #include <errno.h>
-#include <libadt/list.h>
+#include <adt/list.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <futex.h>
 ,7 → 232,7
         return;
     }
-    if (callid == IPC_CALLRET_FATAL) {
+    if (callid == (ipc_callid_t) IPC_CALLRET_FATAL) {
         futex_up(&ipc_futex);
         /* Call asynchronous handler with error code */
         if (call->callback)
 ,7 → 241,7
         return;
     }
-    if (callid == IPC_CALLRET_TEMPORARY) {
+    if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY) {
         futex_up(&ipc_futex);
         call->u.msg.phoneid = phoneid;
 ,7 → 309,7
     callid = __SYSCALL6(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1,
         arg2, arg3, arg4);
-    if (callid == IPC_CALLRET_TEMPORARY) {
+    if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY) {
         if (!call) {
             call = ipc_prepare_async(private, callback);
             if (!call)
 ,7 → 442,7
         call = list_get_instance(queued_calls.next, async_call_t, list);
         callid = _ipc_call_async(call->u.msg.phoneid,
             &call->u.msg.data);
-        if (callid == IPC_CALLRET_TEMPORARY) {
+        if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY) {
             break;
         }
         list_remove(&call->list);
 ,7 → 451,7
         if (call->fid)
             fibril_add_ready(call->fid);
-        if (callid == IPC_CALLRET_FATAL) {
+        if (callid == (ipc_callid_t) IPC_CALLRET_FATAL) {
             if (call->callback)
                 call->callback(call->private, ENOENT, NULL);
             free(call);
 ,7 → 704,7
     IPC_SET_ARG4(data, arg4);
     IPC_SET_ARG5(data, arg5);
-    return __SYSCALL3(SYS_IPC_FORWARD_SLOW, callid, (sysarg_t) &data, mode);
+    return __SYSCALL4(SYS_IPC_FORWARD_SLOW, callid, phoneid, (sysarg_t) &data, mode);
 }
 /** Wrapper for making IPC_M_SHARE_IN calls.

 /branches/network/uspace/lib/libc/generic/devmap.c
 ,0 → 1,264
+/*
+ * Copyright (c) 2007 Josef Cejka
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <string.h>
+#include <ipc/ipc.h>
+#include <ipc/services.h>
+#include <ipc/devmap.h>
+#include <devmap.h>
+#include <async.h>
+#include <errno.h>
+static int devmap_phone_driver = -1;
+static int devmap_phone_client = -1;
+/** Get phone to device mapper task. */
+int devmap_get_phone(devmap_interface_t iface, unsigned int flags)
+{
+    switch (iface) {
+    case DEVMAP_DRIVER:
+        if (devmap_phone_driver >= 0)
+            return devmap_phone_driver;
+        if (flags & IPC_FLAG_BLOCKING)
+            devmap_phone_driver = ipc_connect_me_to_blocking(PHONE_NS,
+                SERVICE_DEVMAP, DEVMAP_DRIVER, 0);
+        else
+            devmap_phone_driver = ipc_connect_me_to(PHONE_NS,
+                SERVICE_DEVMAP, DEVMAP_DRIVER, 0);
+        return devmap_phone_driver;
+    case DEVMAP_CLIENT:
+        if (devmap_phone_client >= 0)
+            return devmap_phone_client;
+        if (flags & IPC_FLAG_BLOCKING)
+            devmap_phone_client = ipc_connect_me_to_blocking(PHONE_NS,
+                SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
+        else
+            devmap_phone_client = ipc_connect_me_to(PHONE_NS,
+                SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
+        return devmap_phone_client;
+    default:
+        return -1;
+    }
+}
+void devmap_hangup_phone(devmap_interface_t iface)
+{
+    switch (iface) {
+    case DEVMAP_DRIVER:
+        if (devmap_phone_driver >= 0) {
+            ipc_hangup(devmap_phone_driver);
+            devmap_phone_driver = -1;
+        }
+        break;
+    case DEVMAP_CLIENT:
+        if (devmap_phone_client >= 0) {
+            ipc_hangup(devmap_phone_client);
+            devmap_phone_client = -1;
+        }
+        break;
+    default:
+        break;
+    }
+}
+/** Register new driver with devmap. */
+int devmap_driver_register(const char *name, async_client_conn_t conn)
+{
+    int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING);
+    if (phone < 0)
+        return phone;
+    async_serialize_start();
+    ipc_call_t answer;
+    aid_t req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer);
+    ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
+    if (retval != EOK) {
+        async_wait_for(req, NULL);
+        async_serialize_end();
+        return -1;
+    }
+    async_set_client_connection(conn);
+    ipcarg_t callback_phonehash;
+    ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash);
+    async_wait_for(req, &retval);
+    async_serialize_end();
+    return retval;
+}
+/** Register new device.
+ *
+ * @param name   Device name.
+ * @param handle Output: Handle to the created instance of device.
+ *
+ */
+int devmap_device_register(const char *name, dev_handle_t *handle)
+{
+    int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING);
+    if (phone < 0)
+        return phone;
+    async_serialize_start();
+    ipc_call_t answer;
+    aid_t req = async_send_2(phone, DEVMAP_DEVICE_REGISTER, 0, 0,
+        &answer);
+    ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
+    if (retval != EOK) {
+        async_wait_for(req, NULL);
+        async_serialize_end();
+        return retval;
+    }
+    async_wait_for(req, &retval);
+    async_serialize_end();
+    if (retval != EOK) {
+        if (handle != NULL)
+            *handle = -1;
+        return retval;
+    }
+    if (handle != NULL)
+        *handle = (dev_handle_t) IPC_GET_ARG1(answer);
+    return retval;
+}
+int devmap_device_get_handle(const char *name, dev_handle_t *handle, unsigned int flags)
+{
+    int phone = devmap_get_phone(DEVMAP_CLIENT, flags);
+    if (phone < 0)
+        return phone;
+    async_serialize_start();
+    ipc_call_t answer;
+    aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0,
+        &answer);
+    ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
+    if (retval != EOK) {
+        async_wait_for(req, NULL);
+        async_serialize_end();
+        return retval;
+    }
+    async_wait_for(req, &retval);
+    async_serialize_end();
+    if (retval != EOK) {
+        if (handle != NULL)
+            *handle = (dev_handle_t) -1;
+        return retval;
+    }
+    if (handle != NULL)
+        *handle = (dev_handle_t) IPC_GET_ARG1(answer);
+    return retval;
+}
+int devmap_device_connect(dev_handle_t handle, unsigned int flags)
+{
+    int phone;
+    if (flags & IPC_FLAG_BLOCKING) {
+        phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,
+            DEVMAP_CONNECT_TO_DEVICE, handle);
+    } else {
+        phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
+            DEVMAP_CONNECT_TO_DEVICE, handle);
+    }
+    return phone;
+}
+ipcarg_t devmap_device_get_count(void)
+{
+    int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
+    if (phone < 0)
+        return 0;
+    ipcarg_t count;
+    int retval = async_req_0_1(phone, DEVMAP_DEVICE_GET_COUNT, &count);
+    if (retval != EOK)
+        return 0;
+    return count;
+}
+ipcarg_t devmap_device_get_devices(ipcarg_t count, dev_desc_t *data)
+{
+    int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
+    if (phone < 0)
+        return 0;
+    async_serialize_start();
+    ipc_call_t answer;
+    aid_t req = async_send_0(phone, DEVMAP_DEVICE_GET_DEVICES, &answer);
+    ipcarg_t retval = ipc_data_read_start(phone, data, count * sizeof(dev_desc_t));
+    if (retval != EOK) {
+        async_wait_for(req, NULL);
+        async_serialize_end();
+        return 0;
+    }
+    async_wait_for(req, &retval);
+    async_serialize_end();
+    if (retval != EOK)
+        return 0;
+    return IPC_GET_ARG1(answer);
+}

 /branches/network/uspace/lib/libc/generic/async.c
 ,8 → 95,8
 #include <async.h>
 #include <fibril.h>
 #include <stdio.h>
-#include <libadt/hash_table.h>
-#include <libadt/list.h>
+#include <adt/hash_table.h>
+#include <adt/list.h>
 #include <ipc/ipc.h>
 #include <assert.h>
 #include <errno.h>
 ,7 → 174,7
 } connection_t;
 /** Identifier of the incoming connection handled by the current fibril. */
-__thread connection_t *FIBRIL_connection;
+fibril_local connection_t *FIBRIL_connection;
 static void default_client_connection(ipc_callid_t callid, ipc_call_t *call);
 static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call);
 ,11 → 190,9
  */
 static async_client_conn_t interrupt_received = default_interrupt_received;
 static hash_table_t conn_hash_table;
 static LIST_INITIALIZE(timeout_list);
 #define CONN_HASH_TABLE_CHAINS  32
 /** Compute hash into the connection hash table based on the source phone hash.
 ,9 → 498,10
     /* Answer all remaining messages with EHANGUP */
     while (!list_empty(&FIBRIL_connection->msg_queue)) {
-        msg_t *msg
-            = list_get_instance(FIBRIL_connection->msg_queue.next, msg_t, link);
+        msg_t *msg;
+        msg = list_get_instance(FIBRIL_connection->msg_queue.next,
+            msg_t, link);
         list_remove(&msg->link);
         ipc_answer_0(msg->callid, EHANGUP);
         free(msg);
 ,7 → 562,7
     }
     /* Add connection to the connection hash table */
-    ipcarg_t key = conn->in_phone_hash;
+    unsigned long key = conn->in_phone_hash;
     futex_down(&async_futex);
     hash_table_insert(&conn_hash_table, &key, &conn->link);
 ,23 → 587,28
     /* Unrouted call - do some default behaviour */
     if ((callid & IPC_CALLID_NOTIFICATION)) {
         process_notification(callid, call);
-        return;
+        goto out;
     }
     switch (IPC_GET_METHOD(*call)) {
+    case IPC_M_CONNECT_ME:
     case IPC_M_CONNECT_ME_TO:
         /* Open new connection with fibril etc. */
         async_new_connection(IPC_GET_ARG5(*call), callid, call,
             client_connection);
-        return;
+        goto out;
     }
     /* Try to route the call through the connection hash table */
     if (route_call(callid, call))
-        return;
+        goto out;
     /* Unknown call from unknown phone - hang it up */
     ipc_answer_0(callid, EHANGUP);
+    return;
+out:
+    ;
 }
 /** Fire all timeouts that expired. */
 ,8 → 666,8
         suseconds_t timeout;
         if (!list_empty(&timeout_list)) {
-            awaiter_t *waiter
-                = list_get_instance(timeout_list.next, awaiter_t, link);
+            awaiter_t *waiter = list_get_instance(timeout_list.next,
+                awaiter_t, link);
             struct timeval tv;
             gettimeofday(&tv, NULL);
 ,8 → 684,8
         futex_up(&async_futex);
         ipc_call_t call;
-        ipc_callid_t callid
-            = ipc_wait_cycle(&call, timeout, SYNCH_FLAGS_NONE);
+        ipc_callid_t callid = ipc_wait_cycle(&call, timeout,
+            SYNCH_FLAGS_NONE);
         if (!callid) {
             handle_expired_timeouts();
 ,13 → 762,13
  */
 static void reply_received(void *arg, int retval, ipc_call_t *data)
 {
+    futex_down(&async_futex);
     amsg_t *msg = (amsg_t *) arg;
     msg->retval = retval;
-    futex_down(&async_futex);
     /* Copy data after futex_down, just in case the call was detached */
-    if (msg->dataptr)
+    if ((msg->dataptr) && (data))
         *msg->dataptr = *data;
     write_barrier();
 ,6 → 814,7
     msg->done = false;
     msg->dataptr = dataptr;
+    msg->wdata.inlist = false;
     /* We may sleep in the next method, but it will use its own mechanism */
     msg->wdata.active = true;
 ,6 → 854,7
     msg->done = false;
     msg->dataptr = dataptr;
+    msg->wdata.inlist = false;
     /* We may sleep in next method, but it will use its own mechanism */
     msg->wdata.active = true;

 /branches/network/uspace/lib/libc/generic/vfs/vfs.c
 ,13 → 48,14
 #include <futex.h>
 #include <errno.h>
 #include <string.h>
+#include <devmap.h>
+#include <ipc/vfs.h>
 #include <ipc/devmap.h>
-#include "../../../srv/vfs/vfs.h"
-int vfs_phone = -1;
-futex_t vfs_phone_futex = FUTEX_INITIALIZER;
+static int vfs_phone = -1;
+static futex_t vfs_phone_futex = FUTEX_INITIALIZER;
+static futex_t cwd_futex = FUTEX_INITIALIZER;
-futex_t cwd_futex = FUTEX_INITIALIZER;
 DIR *cwd_dir = NULL;
 char *cwd_path = NULL;
 size_t cwd_size = 0;
 ,47 → 116,8
         vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
 }
-static int device_get_handle(const char *name, dev_handle_t *handle,
-    const unsigned int flags)
-{
-    int phone;
-    if (flags & IPC_FLAG_BLOCKING)
-        phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
-    else
-        phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
-    if (phone < 0)
-        return phone;
-    ipc_call_t answer;
-    aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0,
-        &answer);
-    ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
-    if (retval != EOK) {
-        async_wait_for(req, NULL);
-        ipc_hangup(phone);
-        return retval;
-    }
-    async_wait_for(req, &retval);
-    if (handle != NULL)
-        *handle = -1;
-    if (retval == EOK) {
-        if (handle != NULL)
-            *handle = (dev_handle_t) IPC_GET_ARG1(answer);
-    }
-    ipc_hangup(phone);
-    return retval;
-}
 int mount(const char *fs_name, const char *mp, const char *dev,
-    const char *opts, const unsigned int flags)
+    const char *opts, unsigned int flags)
 {
     int res;
     ipcarg_t rc;
 ,7 → 124,7
     aid_t req;
     dev_handle_t dev_handle;
-    res = device_get_handle(dev, &dev_handle, flags);
+    res = devmap_device_get_handle(dev, &dev_handle, flags);
     if (res != EOK)
         return res;
 ,9 → 211,10
     async_serialize_end();
     futex_up(&vfs_phone_futex);
     free(pa);
     if (rc != EOK)
         return (int) rc;
     return (int) IPC_GET_ARG1(answer);
 }
 ,6 → 223,27
     return _open(path, L_FILE, oflag);
 }
+int open_node(fdi_node_t *node, int oflag)
+{
+    futex_down(&vfs_phone_futex);
+    async_serialize_start();
+    vfs_connect();
+    ipc_call_t answer;
+    aid_t req = async_send_4(vfs_phone, VFS_OPEN_NODE, node->fs_handle,
+        node->dev_handle, node->index, oflag, &answer);
+    ipcarg_t rc;
+    async_wait_for(req, &rc);
+    async_serialize_end();
+    futex_up(&vfs_phone_futex);
+    if (rc != EOK)
+        return (int) rc;
+    return (int) IPC_GET_ARG1(answer);
+}
 int close(int fildes)
 {
     ipcarg_t rc;
 ,6 → 314,62
         return -1;
 }
+int fd_phone(int fildes)
+{
+    futex_down(&vfs_phone_futex);
+    async_serialize_start();
+    vfs_connect();
+    ipcarg_t device;
+    ipcarg_t rc = async_req_1_1(vfs_phone, VFS_DEVICE, fildes, &device);
+    async_serialize_end();
+    futex_up(&vfs_phone_futex);
+    if (rc != EOK)
+        return -1;
+    return devmap_device_connect((dev_handle_t) device, 0);
+}
+int fd_node(int fildes, fdi_node_t *node)
+{
+    futex_down(&vfs_phone_futex);
+    async_serialize_start();
+    vfs_connect();
+    ipcarg_t fs_handle;
+    ipcarg_t dev_handle;
+    ipcarg_t index;
+    ipcarg_t rc = async_req_1_3(vfs_phone, VFS_NODE, fildes, &fs_handle,
+        &dev_handle, &index);
+    async_serialize_end();
+    futex_up(&vfs_phone_futex);
+    if (rc == EOK) {
+        node->fs_handle = (fs_handle_t) fs_handle;
+        node->dev_handle = (dev_handle_t) dev_handle;
+        node->index = (fs_index_t) index;
+    }
+    return rc;
+}
+int fsync(int fildes)
+{
+    futex_down(&vfs_phone_futex);
+    async_serialize_start();
+    vfs_connect();
+    ipcarg_t rc = async_req_1_0(vfs_phone, VFS_SYNC, fildes);
+    async_serialize_end();
+    futex_up(&vfs_phone_futex);
+    return (int) rc;
+}
 off_t lseek(int fildes, off_t offset, int whence)
 {
     ipcarg_t rc;
 ,7 → 465,7
     async_serialize_end();
     futex_up(&vfs_phone_futex);
     free(pa);
-    return rc;
+    return rc;
 }
 static int _unlink(const char *path, int lflag)
 ,7 → 495,7
     async_serialize_end();
     futex_up(&vfs_phone_futex);
     free(pa);
-    return rc;
+    return rc;
 }
 int unlink(const char *path)

 /branches/network/uspace/lib/libc/generic/mem.c
 ,7 → 95,7
 static void *unaligned_memcpy(void *dst, const void *src, size_t n)
 {
-    int i, j;
+    size_t i, j;
     struct along *adst = dst;
     const struct along *asrc = src;

 /branches/network/uspace/lib/libc/generic/io/printf.c
 ,23 → 34,43
 #include <io/printf_core.h>
 #include <stdio.h>
-#include <stdio.h>
 /** Print formatted text.
- * @param fmt   format string
+ *
+ * @param stream Output stream
+ * @param fmt    Format string
+ *
  * \see For more details about format string see printf_core.
+ *
  */
+int fprintf(FILE *stream, const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    int ret = vfprintf(stream, fmt, args);
+    va_end(args);
+    return ret;
+}
+/** Print formatted text to stdout.
+ *
+ * @param fmt Format string
+ *
+ * \see For more details about format string see printf_core.
+ *
+ */
 int printf(const char *fmt, ...)
 {
-    int ret;
     va_list args;
     va_start(args, fmt);
-    ret = vprintf(fmt, args);
+    int ret = vprintf(fmt, args);
     va_end(args);
     return ret;
 }

 /branches/network/uspace/lib/libc/generic/io/console.c
 ,0 → 1,102
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * Copyright (c) 2006 Jakub Vana
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#include <libc.h>
+#include <async.h>
+#include <io/console.h>
+#include <ipc/console.h>
+void console_clear(int phone)
+{
+    async_msg_0(phone, CONSOLE_CLEAR);
+}
+int console_get_size(int phone, ipcarg_t *rows, ipcarg_t *cols)
+{
+    return async_req_0_2(phone, CONSOLE_GET_SIZE, rows, cols);
+}
+void console_set_style(int phone, int style)
+{
+    async_msg_1(phone, CONSOLE_SET_STYLE, style);
+}
+void console_set_color(int phone, int fg_color, int bg_color, int flags)
+{
+    async_msg_3(phone, CONSOLE_SET_COLOR, fg_color, bg_color, flags);
+}
+void console_set_rgb_color(int phone, int fg_color, int bg_color)
+{
+    async_msg_2(phone, CONSOLE_SET_RGB_COLOR, fg_color, bg_color);
+}
+void console_cursor_visibility(int phone, bool show)
+{
+    async_msg_1(phone, CONSOLE_CURSOR_VISIBILITY, show != false);
+}
+void console_kcon_enable(int phone)
+{
+    async_msg_0(phone, CONSOLE_KCON_ENABLE);
+}
+void console_goto(int phone, ipcarg_t row, ipcarg_t col)
+{
+    async_msg_2(phone, CONSOLE_GOTO, row, col);
+}
+bool console_get_event(int phone, console_event_t *event)
+{
+    ipcarg_t type;
+    ipcarg_t key;
+    ipcarg_t mods;
+    ipcarg_t c;
+    int rc = async_req_0_4(phone, CONSOLE_GET_EVENT, &type, &key, &mods, &c);
+    if (rc < 0)
+        return false;
+    event->type = type;
+    event->key = key;
+    event->mods = mods;
+    event->c = c;
+    return true;
+}
+/** @}
+ */

 /branches/network/uspace/lib/libc/generic/io/snprintf.c
 ,21 → 37,23
 #include <io/printf_core.h>
 /** Print formatted to the given buffer with limited size.
- * @param str   buffer
- * @param size  buffer size
- * @param fmt   format string
+ *
+ * @param str  Buffer
+ * @param size Buffer size
+ * @param fmt  Format string
+ *
  * \see For more details about format string see printf_core.
+ *
  */
 int snprintf(char *str, size_t size, const char *fmt, ...)
 {
-    int ret;
     va_list args;
+    va_start(args, fmt);
-    va_start(args, fmt);
-    ret = vsnprintf(str, size, fmt, args);
+    int ret = vsnprintf(str, size, fmt, args);
     va_end(args);
     return ret;
 }

 /branches/network/uspace/lib/libc/generic/io/asprintf.c
 ,42 → 36,52
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <io/printf_core.h>
-static int asprintf_prewrite(const char *str, size_t count, void *unused)
+static int asprintf_str_write(const char *str, size_t count, void *unused)
 {
-    return count;
+    return str_nlength(str, count);
 }
+static int asprintf_wstr_write(const wchar_t *str, size_t count, void *unused)
+{
+    return wstr_nlength(str, count);
+}
 /** Allocate and print to string.
  *
- * @param strp      Address of the pointer where to store the address of
- *          the newly allocated string.
- * @fmt         Format strin.
+ * @param strp Address of the pointer where to store the address of
+ *             the newly allocated string.
+ * @fmt        Format string.
  *
- * @return      Number of characters printed or a negative error code.
+ * @return Number of characters printed or a negative error code.
+ *
  */
 int asprintf(char **strp, const char *fmt, ...)
 {
     struct printf_spec ps = {
-         asprintf_prewrite,
-         NULL
+        asprintf_str_write,
+        asprintf_wstr_write,
+        NULL
     };
-    int ret;
     va_list args;
     va_start(args, fmt);
-    ret = printf_core(fmt, &ps, args);
+    int ret = printf_core(fmt, &ps, args);
     va_end(args);
     if (ret > 0) {
-        *strp = malloc(ret + 20);
-        if (!*strp)
+        *strp = malloc(STR_BOUNDS(ret) + 1);
+        if (*strp == NULL)
             return -1;
         va_start(args, fmt);
-        vsprintf(*strp, fmt, args);
-        va_end(args);
+        vsnprintf(*strp, STR_BOUNDS(ret) + 1, fmt, args);
+        va_end(args);
     }
     return ret;
 }

 /branches/network/uspace/lib/libc/generic/io/io.c
 ,98 → 30,551
  * @{
  */
 /** @file
- */
+ */
-#include <libc.h>
+#include <stdio.h>
 #include <unistd.h>
-#include <stdio.h>
-#include <io/io.h>
+#include <fcntl.h>
+#include <assert.h>
 #include <string.h>
 #include <errno.h>
-#include <console.h>
+#include <bool.h>
+#include <malloc.h>
+#include <io/klog.h>
+#include <vfs/vfs.h>
+#include <ipc/devmap.h>
+#include <adt/list.h>
-const static char nl = '\n';
+static void _fflushbuf(FILE *stream);
-int puts(const char *str)
+static FILE stdin_null = {
+    .fd = -1,
+    .error = true,
+    .eof = true,
+    .klog = false,
+    .phone = -1,
+    .btype = _IONBF,
+    .buf = NULL,
+    .buf_size = 0,
+    .buf_head = NULL
+};
+static FILE stdout_klog = {
+    .fd = -1,
+    .error = false,
+    .eof = false,
+    .klog = true,
+    .phone = -1,
+    .btype = _IOLBF,
+    .buf = NULL,
+    .buf_size = BUFSIZ,
+    .buf_head = NULL
+};
+static FILE stderr_klog = {
+    .fd = -1,
+    .error = false,
+    .eof = false,
+    .klog = true,
+    .phone = -1,
+    .btype = _IONBF,
+    .buf = NULL,
+    .buf_size = 0,
+    .buf_head = NULL
+};
+FILE *stdin = NULL;
+FILE *stdout = NULL;
+FILE *stderr = NULL;
+static LIST_INITIALIZE(files);
+void stdio_init(int filc, fdi_node_t *filv[])
 {
-    size_t count;
+    if (filc > 0) {
+        stdin = fopen_node(filv[0], "r");
+    } else {
+        stdin = &stdin_null;
+        list_append(&stdin->link, &files);
+    }
-    if (str == NULL)
-        return putnchars("(NULL)", 6);
+    if (filc > 1) {
+        stdout = fopen_node(filv[1], "w");
+    } else {
+        stdout = &stdout_klog;
+        list_append(&stdout->link, &files);
+    }
-    for (count = 0; str[count] != 0; count++);
+    if (filc > 2) {
+        stderr = fopen_node(filv[2], "w");
+    } else {
+        stderr = &stderr_klog;
+        list_append(&stderr->link, &files);
+    }
+}
+void stdio_done(void)
+{
+    link_t *link = files.next;
-    if (console_write((void *) str, count) == count) {
-        if (console_write(&nl, 1) == 1)
-            return 0;
+    while (link != &files) {
+        FILE *file = list_get_instance(link, FILE, link);
+        fclose(file);
+        link = files.next;
     }
+}
+static bool parse_mode(const char *mode, int *flags)
+{
+    /* Parse mode except first character. */
+    const char *mp = mode;
+    if (*mp++ == 0) {
+        errno = EINVAL;
+        return false;
+    }
-    return EOF;
+    if ((*mp == 'b') || (*mp == 't'))
+        mp++;
+    bool plus;
+    if (*mp == '+') {
+        mp++;
+        plus = true;
+    } else
+        plus = false;
+    if (*mp != 0) {
+        errno = EINVAL;
+        return false;
+    }
+    /* Parse first character of mode and determine flags for open(). */
+    switch (mode[0]) {
+    case 'r':
+        *flags = plus ? O_RDWR : O_RDONLY;
+        break;
+    case 'w':
+        *flags = (O_TRUNC | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
+        break;
+    case 'a':
+        /* TODO: a+ must read from beginning, append to the end. */
+        if (plus) {
+            errno = ENOTSUP;
+            return false;
+        }
+        *flags = (O_APPEND | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
+    default:
+        errno = EINVAL;
+        return false;
+    }
+    return true;
 }
-/** Put count chars from buffer to stdout without adding newline
- * @param buf Buffer with size at least count bytes - NULL pointer NOT allowed!
- * @param count
- * @return 0 on succes, EOF on fail
+/** Set stream buffer. */
+void setvbuf(FILE *stream, void *buf, int mode, size_t size)
+{
+    stream->btype = mode;
+    stream->buf = buf;
+    stream->buf_size = size;
+    stream->buf_head = stream->buf;
+}
+/** Allocate stream buffer. */
+static int _fallocbuf(FILE *stream)
+{
+    assert(stream->buf == NULL);
+    stream->buf = malloc(stream->buf_size);
+    if (stream->buf == NULL) {
+        errno = ENOMEM;
+        return -1;
+    }
+    stream->buf_head = stream->buf;
+    return 0;
+}
+/** Open a stream.
+ *
+ * @param path Path of the file to open.
+ * @param mode Mode string, (r|w|a)[b|t][+].
+ *
  */
-int putnchars(const char *buf, size_t count)
+FILE *fopen(const char *path, const char *mode)
 {
-    if (console_write((void *) buf, count) == count)
-        return 0;
+    int flags;
+    if (!parse_mode(mode, &flags))
+        return NULL;
-    return EOF;
+    /* Open file. */
+    FILE *stream = malloc(sizeof(FILE));
+    if (stream == NULL) {
+        errno = ENOMEM;
+        return NULL;
+    }
+    stream->fd = open(path, flags, 0666);
+    if (stream->fd < 0) {
+        /* errno was set by open() */
+        free(stream);
+        return NULL;
+    }
+    stream->error = false;
+    stream->eof = false;
+    stream->klog = false;
+    stream->phone = -1;
+    /* FIXME: Should select buffering type based on what was opened. */
+    setvbuf(stream, NULL, _IOFBF, BUFSIZ);
+    list_append(&stream->link, &files);
+    return stream;
 }
-/** Same as puts, but does not print newline at end
+FILE *fdopen(int fd, const char *mode)
+{
+    /* Open file. */
+    FILE *stream = malloc(sizeof(FILE));
+    if (stream == NULL) {
+        errno = ENOMEM;
+        return NULL;
+    }
+    stream->fd = fd;
+    stream->error = false;
+    stream->eof = false;
+    stream->klog = false;
+    stream->phone = -1;
+    /* FIXME: Should select buffering type based on what was opened. */
+    setvbuf(stream, NULL, _IOLBF, BUFSIZ);
+    list_append(&stream->link, &files);
+    return stream;
+}
+FILE *fopen_node(fdi_node_t *node, const char *mode)
+{
+    int flags;
+    if (!parse_mode(mode, &flags))
+        return NULL;
+    /* Open file. */
+    FILE *stream = malloc(sizeof(FILE));
+    if (stream == NULL) {
+        errno = ENOMEM;
+        return NULL;
+    }
+    stream->fd = open_node(node, flags);
+    if (stream->fd < 0) {
+        /* errno was set by open_node() */
+        free(stream);
+        return NULL;
+    }
+    stream->error = false;
+    stream->eof = false;
+    stream->klog = false;
+    stream->phone = -1;
+    /* FIXME: Should select buffering type based on what was opened. */
+    setvbuf(stream, NULL, _IOLBF, BUFSIZ);
+    list_append(&stream->link, &files);
+    return stream;
+}
+int fclose(FILE *stream)
+{
+    int rc = 0;
+    fflush(stream);
+    if (stream->phone >= 0)
+        ipc_hangup(stream->phone);
+    if (stream->fd >= 0)
+        rc = close(stream->fd);
+    list_remove(&stream->link);
+    if ((stream != &stdin_null)
+        && (stream != &stdout_klog)
+        && (stream != &stderr_klog))
+        free(stream);
+    stream = NULL;
+    if (rc != 0) {
+        /* errno was set by close() */
+        return EOF;
+    }
+    return 0;
+}
+/** Read from a stream.
  *
+ * @param buf    Destination buffer.
+ * @param size   Size of each record.
+ * @param nmemb  Number of records to read.
+ * @param stream Pointer to the stream.
+ *
  */
-int putstr(const char *str)
+size_t fread(void *buf, size_t size, size_t nmemb, FILE *stream)
 {
-    size_t count;
+    size_t left = size * nmemb;
+    size_t done = 0;
+    /* Make sure no data is pending write. */
+    _fflushbuf(stream);
+    while ((left > 0) && (!stream->error) && (!stream->eof)) {
+        ssize_t rd = read(stream->fd, buf + done, left);
+        if (rd < 0)
+            stream->error = true;
+        else if (rd == 0)
+            stream->eof = true;
+        else {
+            left -= rd;
+            done += rd;
+        }
+    }
-    if (str == NULL)
-        return putnchars("(NULL)", 6);
+    return (done / size);
+}
-    for (count = 0; str[count] != 0; count++);
-    if (console_write((void *) str, count) == count)
-        return 0;
+static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
+{
+    size_t left = size * nmemb;
+    size_t done = 0;
-    return EOF;
+    while ((left > 0) && (!stream->error)) {
+        ssize_t wr;
+        if (stream->klog)
+            wr = klog_write(buf + done, left);
+        else
+            wr = write(stream->fd, buf + done, left);
+        if (wr <= 0)
+            stream->error = true;
+        else {
+            left -= wr;
+            done += wr;
+        }
+    }
+    return (done / size);
 }
-int putchar(int c)
+/** Drain stream buffer, do not sync stream. */
+static void _fflushbuf(FILE *stream)
 {
-    char buf[STR_BOUNDS(1)];
-    size_t offs;
+    size_t bytes_used;
-    offs = 0;
-    if (chr_encode(c, buf, &offs, STR_BOUNDS(1)) != EOK)
-        return EOF;
+    if (!stream->buf || stream->btype == _IONBF || stream->error)
+        return;
-    if (console_write((void *) buf, offs) == offs)
-        return c;
+    bytes_used = stream->buf_head - stream->buf;
+    if (bytes_used == 0)
+        return;
-    return EOF;
+    (void) _fwrite(stream->buf, 1, bytes_used, stream);
+    stream->buf_head = stream->buf;
 }
-int getchar(void)
+/** Write to a stream.
+ *
+ * @param buf    Source buffer.
+ * @param size   Size of each record.
+ * @param nmemb  Number of records to write.
+ * @param stream Pointer to the stream.
+ *
+ */
+size_t fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
 {
-    unsigned char c;
+    uint8_t *data;
+    size_t bytes_left;
+    size_t now;
+    size_t buf_free;
+    size_t total_written;
+    size_t i;
+    uint8_t b;
+    bool need_flush;
+    /* If not buffered stream, write out directly. */
+    if (stream->btype == _IONBF)
+        return _fwrite(buf, size, nmemb, stream);
+    /* Perform lazy allocation of stream buffer. */
+    if (stream->buf == NULL) {
+        if (_fallocbuf(stream) != 0)
+            return 0; /* Errno set by _fallocbuf(). */
+    }
+    data = (uint8_t *) buf;
+    bytes_left = size * nmemb;
+    total_written = 0;
+    need_flush = false;
+    while (!stream->error && bytes_left > 0) {
+        buf_free = stream->buf_size - (stream->buf_head - stream->buf);
+        if (bytes_left > buf_free)
+            now = buf_free;
+        else
+            now = bytes_left;
+        for (i = 0; i < now; i++) {
+            b = data[i];
+            stream->buf_head[i] = b;
+            if (b == '\n' && stream->btype == _IOLBF)
+                need_flush = true;
+        }
+        buf += now;
+        stream->buf_head += now;
+        buf_free -= now;
+        bytes_left -= now;
+        total_written += now;
+        if (buf_free == 0) {
+            /* Only need to drain buffer. */
+            _fflushbuf(stream);
+            need_flush = false;
+        }
+    }
+    if (need_flush)
+        fflush(stream);
+    return (total_written / size);
+}
+int fputc(wchar_t c, FILE *stream)
+{
+    char buf[STR_BOUNDS(1)];
+    size_t sz = 0;
-    console_flush();
-    if (read_stdin((void *) &c, 1) == 1)
-        return c;
+    if (chr_encode(c, buf, &sz, STR_BOUNDS(1)) == EOK) {
+        size_t wr = fwrite(buf, sz, 1, stream);
+        if (wr < sz)
+            return EOF;
+        return (int) c;
+    }
     return EOF;
 }
-int fflush(FILE *f)
+int putchar(wchar_t c)
 {
-    /* Dummy implementation */
-    (void) f;
-    console_flush();
+    return fputc(c, stdout);
+}
+int fputs(const char *str, FILE *stream)
+{
+    return fwrite(str, str_size(str), 1, stream);
+}
+int puts(const char *str)
+{
+    return fputs(str, stdout);
+}
+int fgetc(FILE *stream)
+{
+    char c;
+    /* This could be made faster by only flushing when needed. */
+    if (stdout)
+        fflush(stdout);
+    if (stderr)
+        fflush(stderr);
+    if (fread(&c, sizeof(char), 1, stream) < sizeof(char))
+        return EOF;
+    return (int) c;
+}
+int getchar(void)
+{
+    return fgetc(stdin);
+}
+int fseek(FILE *stream, long offset, int origin)
+{
+    off_t rc = lseek(stream->fd, offset, origin);
+    if (rc == (off_t) (-1)) {
+        /* errno has been set by lseek. */
+        return -1;
+    }
+    stream->eof = false;
     return 0;
 }
+void rewind(FILE *stream)
+{
+    (void) fseek(stream, 0, SEEK_SET);
+}
+int fflush(FILE *stream)
+{
+    _fflushbuf(stream);
+    if (stream->klog) {
+        klog_update();
+        return EOK;
+    }
+    if (stream->fd >= 0)
+        return fsync(stream->fd);
+    return ENOENT;
+}
+int feof(FILE *stream)
+{
+    return stream->eof;
+}
+int ferror(FILE *stream)
+{
+    return stream->error;
+}
+int fphone(FILE *stream)
+{
+    if (stream->fd >= 0) {
+        if (stream->phone < 0)
+            stream->phone = fd_phone(stream->fd);
+        return stream->phone;
+    }
+    return -1;
+}
+int fnode(FILE *stream, fdi_node_t *node)
+{
+    if (stream->fd >= 0)
+        return fd_node(stream->fd, node);
+    return ENOENT;
+}
 /** @}
  */

 /branches/network/uspace/lib/libc/generic/io/vprintf.c
 ,37 → 38,25
 #include <io/printf_core.h>
 #include <futex.h>
 #include <async.h>
-#include <console.h>
+#include <string.h>
 static atomic_t printf_futex = FUTEX_INITIALIZER;
-static int vprintf_str_write(const char *str, size_t size, void *data)
+static int vprintf_str_write(const char *str, size_t size, void *stream)
 {
-    size_t offset = 0;
-    size_t prev;
-    count_t chars = 0;
-    while (offset < size) {
-        prev = offset;
-        str_decode(str, &offset, size);
-        console_write(str + prev, offset - prev);
-        chars++;
-    }
-    return chars;
+    size_t wr = fwrite(str, 1, size, (FILE *) stream);
+    return str_nlength(str, wr);
 }
-static int vprintf_wstr_write(const wchar_t *str, size_t size, void *data)
+static int vprintf_wstr_write(const wchar_t *str, size_t size, void *stream)
 {
     size_t offset = 0;
-    size_t boff;
-    count_t chars = 0;
-    char buf[4];
+    size_t chars = 0;
     while (offset < size) {
-        boff = 0;
-        chr_encode(str[chars], buf, &boff, 4);
-        console_write(buf, boff);
+        if (fputc(str[chars], (FILE *) stream) <= 0)
+            break;
         chars++;
         offset += sizeof(wchar_t);
     }
 ,33 → 64,55
     return chars;
 }
 /** Print formatted text.
- * @param fmt   format string
- * @param ap    format parameters
+ *
+ * @param stream Output stream
+ * @param fmt    Format string
+ * @param ap     Format parameters
+ *
  * \see For more details about format string see printf_core.
+ *
  */
-int vprintf(const char *fmt, va_list ap)
+int vfprintf(FILE *stream, const char *fmt, va_list ap)
 {
     struct printf_spec ps = {
         vprintf_str_write,
         vprintf_wstr_write,
-         NULL
+        stream
     };
     /*
      * Prevent other threads to execute printf_core()
      */
     futex_down(&printf_futex);
     /*
-     * Prevent other pseudo threads of the same thread
+     * Prevent other fibrils of the same thread
      * to execute printf_core()
      */
     async_serialize_start();
     int ret = printf_core(fmt, &ps, ap);
     async_serialize_end();
     futex_up(&printf_futex);
     return ret;
 }
+/** Print formatted text to stdout.
+ *
+ * @param file Output stream
+ * @param fmt  Format string
+ * @param ap   Format parameters
+ *
+ * \see For more details about format string see printf_core.
+ *
+ */
+int vprintf(const char *fmt, va_list ap)
+{
+    return vfprintf(stdout, fmt, ap);
+}
 /** @}
  */

 /branches/network/uspace/lib/libc/generic/io/vsnprintf.c
 ,7 → 82,7
          * with the trailing zero => print only a part
          * of string
          */
-        index_t index = 0;
+        size_t index = 0;
         while (index < size) {
             wchar_t uc = str_decode(str, &index, size);
 ,7 → 130,7
  */
 static int vsnprintf_wstr_write(const wchar_t *str, size_t size, vsnprintf_data_t *data)
 {
-    index_t index = 0;
+    size_t index = 0;
     while (index < (size / sizeof(wchar_t))) {
         size_t left = data->size - data->len;

 /branches/network/uspace/lib/libc/generic/io/printf_core.c
 ,7 → 173,7
  */
 static int print_char(const char ch, int width, uint32_t flags, printf_spec_t *ps)
 {
-    count_t counter = 0;
+    size_t counter = 0;
     if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
         while (--width > 0) {
             /*
 ,7 → 211,7
  */
 static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps)
 {
-    count_t counter = 0;
+    size_t counter = 0;
     if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
         while (--width > 0) {
             /*
 ,12 → 254,12
         return printf_putstr(nullstr, ps);
     /* Print leading spaces. */
-    count_t strw = str_length(str);
+    size_t strw = str_length(str);
     if (precision == 0)
         precision = strw;
     /* Left padding */
-    count_t counter = 0;
+    size_t counter = 0;
     width -= precision;
     if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
         while (width-- > 0) {
 ,9 → 301,6
     if (str == NULL)
         return printf_putstr(nullstr, ps);
-    if (*str == U_BOM)
-        str++;
     /* Print leading spaces. */
     size_t strw = wstr_length(str);
     if (precision == 0)
 ,7 → 307,7
         precision = strw;
     /* Left padding */
-    count_t counter = 0;
+    size_t counter = 0;
     width -= precision;
     if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
         while (width-- > 0) {
 ,7 → 429,7
     }
     width -= precision + size - number_size;
-    count_t counter = 0;
+    size_t counter = 0;
     if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
         while (width-- > 0) {
 ,7 → 592,7
     size_t nxt = 0;  /* Index of the next character from fmt */
     size_t j = 0;    /* Index to the first not printed nonformating character */
-    count_t counter = 0;  /* Number of characters printed */
+    size_t counter = 0;   /* Number of characters printed */
     int retval;           /* Return values from nested functions */
     while (true) {

 /branches/network/uspace/lib/libc/generic/io/klog.c
 ,0 → 1,53
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * Copyright (c) 2006 Jakub Vana
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#include <libc.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <io/klog.h>
+size_t klog_write(const void *buf, size_t size)
+{
+    return (size_t) __SYSCALL3(SYS_KLOG, 1, (sysarg_t) buf, size);
+}
+void klog_update(void)
+{
+    (void) __SYSCALL3(SYS_KLOG, 1, NULL, 0);
+}
+/** @}
+ */

 /branches/network/uspace/lib/libc/generic/adt/hash_table.c
 ,0 → 1,196
+/*
+ * Copyright (c) 2008 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+/*
+ * This is an implementation of generic chained hash table.
+ */
+#include <adt/hash_table.h>
+#include <adt/list.h>
+#include <unistd.h>
+#include <malloc.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+/** Create chained hash table.
+ *
+ * @param h     Hash table structure. Will be initialized by this call.
+ * @param m     Number of hash table buckets.
+ * @param max_keys  Maximal number of keys needed to identify an item.
+ * @param op        Hash table operations structure.
+ * @return      True on success
+ */
+int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
+    hash_table_operations_t *op)
+{
+    hash_count_t i;
+    assert(h);
+    assert(op && op->hash && op->compare);
+    assert(max_keys > 0);
+    h->entry = malloc(m * sizeof(link_t));
+    if (!h->entry) {
+        printf("cannot allocate memory for hash table\n");
+        return false;
+    }
+    memset((void *) h->entry, 0,  m * sizeof(link_t));
+    for (i = 0; i < m; i++)
+        list_initialize(&h->entry[i]);
+    h->entries = m;
+    h->max_keys = max_keys;
+    h->op = op;
+    return true;
+}
+/** Destroy a hash table instance.
+ *
+ * @param h     Hash table to be destroyed.
+ */
+void hash_table_destroy(hash_table_t *h)
+{
+    assert(h);
+    assert(h->entry);
+    free(h->entry);
+}
+/** Insert item into a hash table.
+ *
+ * @param h     Hash table.
+ * @param key       Array of all keys necessary to compute hash index.
+ * @param item      Item to be inserted into the hash table.
+ */
+void hash_table_insert(hash_table_t *h, unsigned long key[], link_t *item)
+{
+    hash_index_t chain;
+    assert(item);
+    assert(h && h->op && h->op->hash && h->op->compare);
+    chain = h->op->hash(key);
+    assert(chain < h->entries);
+    list_append(item, &h->entry[chain]);
+}
+/** Search hash table for an item matching keys.
+ *
+ * @param h     Hash table.
+ * @param key       Array of all keys needed to compute hash index.
+ *
+ * @return      Matching item on success, NULL if there is no such item.
+ */
+link_t *hash_table_find(hash_table_t *h, unsigned long key[])
+{
+    link_t *cur;
+    hash_index_t chain;
+    assert(h && h->op && h->op->hash && h->op->compare);
+    chain = h->op->hash(key);
+    assert(chain < h->entries);
+    for (cur = h->entry[chain].next; cur != &h->entry[chain];
+        cur = cur->next) {
+        if (h->op->compare(key, h->max_keys, cur)) {
+            /*
+             * The entry is there.
+             */
+            return cur;
+        }
+    }
+    return NULL;
+}
+/** Remove all matching items from hash table.
+ *
+ * For each removed item, h->remove_callback() is called.
+ *
+ * @param h     Hash table.
+ * @param key       Array of keys that will be compared against items of
+ *          the hash table.
+ * @param keys      Number of keys in the 'key' array.
+ */
+void hash_table_remove(hash_table_t *h, unsigned long key[], hash_count_t keys)
+{
+    hash_index_t chain;
+    link_t *cur;
+    assert(h && h->op && h->op->hash && h->op->compare &&
+        h->op->remove_callback);
+    assert(keys <= h->max_keys);
+    if (keys == h->max_keys) {
+        /*
+         * All keys are known, hash_table_find() can be used to find the
+         * entry.
+         */
+        cur = hash_table_find(h, key);
+        if (cur) {
+            list_remove(cur);
+            h->op->remove_callback(cur);
+        }
+        return;
+    }
+    /*
+     * Fewer keys were passed.
+     * Any partially matching entries are to be removed.
+     */
+    for (chain = 0; chain < h->entries; chain++) {
+        for (cur = h->entry[chain].next; cur != &h->entry[chain];
+            cur = cur->next) {
+            if (h->op->compare(key, keys, cur)) {
+                link_t *hlp;
+                hlp = cur;
+                cur = cur->prev;
+                list_remove(hlp);
+                h->op->remove_callback(hlp);
+                continue;
+            }
+        }
+    }
+}
+/** @}
+ */

 /branches/network/uspace/lib/libc/generic/adt/list.c
 ,0 → 1,112
+/*
+ * Copyright (c) 2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#include <adt/list.h>
+/** Check for membership
+ *
+ * Check whether link is contained in the list head.
+ * The membership is defined as pointer equivalence.
+ *
+ * @param link Item to look for.
+ * @param head List to look in.
+ *
+ * @return true if link is contained in head, false otherwise.
+ *
+ */
+int list_member(const link_t *link, const link_t *head)
+{
+    int found = 0;
+    link_t *hlp = head->next;
+    while (hlp != head) {
+        if (hlp == link) {
+            found = 1;
+            break;
+        }
+        hlp = hlp->next;
+    }
+    return found;
+}
+/** Concatenate two lists
+ *
+ * Concatenate lists head1 and head2, producing a single
+ * list head1 containing items from both (in head1, head2
+ * order) and empty list head2.
+ *
+ * @param head1 First list and concatenated output
+ * @param head2 Second list and empty output.
+ *
+ */
+void list_concat(link_t *head1, link_t *head2)
+{
+    if (list_empty(head2))
+        return;
+    head2->next->prev = head1->prev;
+    head2->prev->next = head1;
+    head1->prev->next = head2->next;
+    head1->prev = head2->prev;
+    list_initialize(head2);
+}
+/** Count list items
+ *
+ * Return the number of items in the list.
+ *
+ * @param link List to count.
+ *
+ * @return Number of items in the list.
+ *
+ */
+unsigned int list_count(const link_t *link)
+{
+    unsigned int count = 0;
+    link_t *hlp = link->next;
+    while (hlp != link) {
+        count++;
+        hlp = hlp->next;
+    }
+    return count;
+}
+/** @}
+ */

 /branches/network/uspace/lib/libc/Makefile
 ,6 → 32,7
 LIBC_PREFIX = $(shell pwd)
 SOFTINT_PREFIX = ../softint
 ## Setup toolchain
 #
 ,11 → 47,12
     generic/ddi.c \
     generic/as.c \
     generic/cap.c \
-    generic/console.c \
+    generic/devmap.c \
     generic/event.c \
     generic/mem.c \
     generic/string.c \
     generic/fibril.c \
+    generic/fibril_sync.c \
     generic/pcb.c \
     generic/smc.c \
     generic/thread.c \
 ,15 → 62,12
     generic/io/asprintf.c \
     generic/io/io.c \
     generic/io/printf.c \
-    generic/io/fprintf.c \
-    generic/io/stdio.c \
-    generic/io/stream.c \
-    generic/io/sprintf.c \
+    generic/io/klog.c \
     generic/io/snprintf.c \
     generic/io/vprintf.c \
-    generic/io/vsprintf.c \
     generic/io/vsnprintf.c \
     generic/io/printf_core.c \
+    generic/io/console.c \
     malloc/malloc.c \
     generic/sysinfo.c \
     generic/ipc.c \
 ,12 → 74,11
     generic/async.c \
     generic/loader.c \
     generic/getopt.c \
-    generic/libadt/list.o \
-    generic/libadt/hash_table.o \
+    generic/adt/list.o \
+    generic/adt/hash_table.o \
     generic/time.c \
     generic/err.c \
     generic/stdlib.c \
-    generic/kbd.c \
     generic/mman.c \
     generic/udebug.c \
     generic/vfs/vfs.c \

 /branches/network/uspace/lib/libc/arch/sparc64/include/types.h
 ,8 → 49,6
 typedef int64_t ssize_t;
 typedef uint64_t size_t;
-typedef uint64_t count_t;
-typedef uint64_t index_t;
 typedef uint64_t uintptr_t;

/branches/network/uspace/lib/libc/arch/sparc64/Makefile.inc
38,5 → 38,7
CFLAGS += -mcpu=ultrasparc -m64
LFLAGS += -no-check-sections -N

ENDIANESS = BE

BFD_NAME = elf64-sparc
BFD_ARCH = sparc

 /branches/network/uspace/lib/libc/arch/ia64/include/types.h
 ,8 → 49,6
 typedef int64_t ssize_t;
 typedef uint64_t size_t;
-typedef uint64_t count_t;
-typedef uint64_t index_t;
 typedef uint64_t uintptr_t;

 /branches/network/uspace/lib/libc/arch/ia64/Makefile.inc
 ,9 → 31,6
 TARGET = ia64-pc-linux-gnu
 TOOLCHAIN_DIR = $(CROSS_PREFIX)/ia64/bin
-CFLAGS += -fno-unwind-tables -DMALLOC_ALIGNMENT_16
-LFLAGS += -N $(SOFTINT_PREFIX)/libsoftint.a
-AFLAGS +=
 ARCH_SOURCES += arch/$(UARCH)/src/syscall.S \
     arch/$(UARCH)/src/fibril.S \
 ,5 → 37,10
     arch/$(UARCH)/src/tls.c \
     arch/$(UARCH)/src/ddi.c
+CFLAGS += -fno-unwind-tables -DMALLOC_ALIGNMENT_16
+LFLAGS += -N $(SOFTINT_PREFIX)/libsoftint.a
+ENDIANESS = LE
 BFD_NAME = elf64-ia64-little
 BFD_ARCH = ia64-elf64

 /branches/network/uspace/lib/libc/arch/arm32/include/tls.h
 ,7 → 40,7
 #define CONFIG_TLS_VARIANT_1
-/** Offsets for accessing __thread variables are shifted 8 bytes higher. */
+/** Offsets for accessing thread-local variables are shifted 8 bytes higher. */
 #define ARM_TP_OFFSET  (-8)
 /** TCB (Thread Control Block) struct.

 /branches/network/uspace/lib/libc/arch/arm32/include/types.h
 ,8 → 50,6
 typedef int32_t ssize_t;
 typedef uint32_t size_t;
-typedef uint32_t count_t;
-typedef uint32_t index_t;
 typedef uint32_t uintptr_t;

 /branches/network/uspace/lib/libc/arch/arm32/include/fibril.h
 ,7 → 38,7
 #include <sys/types.h>
 #include <align.h>
-#include "thread.h"
+#include <thread.h>
 /** Size of a stack item */
 #define STACK_ITEM_SIZE     4

 /branches/network/uspace/lib/libc/arch/arm32/Makefile.inc
 ,9 → 32,6
 TARGET = arm-linux-gnu
 TOOLCHAIN_DIR = $(CROSS_PREFIX)/arm/bin
-CFLAGS += -ffixed-r9 -mtp=soft
-LFLAGS += -N $(SOFTINT_PREFIX)/libsoftint.a
-AFLAGS +=
 ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \
     arch/$(UARCH)/src/fibril.S \
 ,5 → 38,10
     arch/$(UARCH)/src/tls.c \
     arch/$(UARCH)/src/eabi.S
+CFLAGS += -ffixed-r9 -mtp=soft
+LFLAGS += -N $(SOFTINT_PREFIX)/libsoftint.a
+ENDIANESS = LE
 BFD_NAME = elf32-littlearm
 BFD_ARCH = arm

 /branches/network/uspace/lib/libc/arch/mips32eb/Makefile.inc
 ,13 → 31,15
 TARGET = mips-linux-gnu
 TOOLCHAIN_DIR = $(CROSS_PREFIX)/mips/bin
-CFLAGS += -mips3
 ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \
         arch/$(UARCH)/src/fibril.S \
         arch/$(UARCH)/src/tls.c
+CFLAGS += -mips3
 LFLAGS += -N
+ENDIANESS = BE
 BFD_ARCH = mips
 BFD_NAME = elf32-tradbigmips

 /branches/network/uspace/lib/libc/arch/ppc32/include/types.h
 ,8 → 49,6
 typedef int32_t ssize_t;
 typedef uint32_t size_t;
-typedef uint32_t count_t;
-typedef uint32_t index_t;
 typedef uint32_t uintptr_t;

/branches/network/uspace/lib/libc/arch/ppc32/Makefile.inc
40,5 → 40,7
AFLAGS += -a32
LFLAGS += -N

ENDIANESS = BE

BFD_NAME = elf32-powerpc
BFD_ARCH = powerpc:common

 /branches/network/uspace/lib/libc/arch/amd64/include/types.h
 ,8 → 49,6
 typedef int64_t ssize_t;
 typedef uint64_t size_t;
-typedef uint64_t count_t;
-typedef uint64_t index_t;
 typedef uint64_t uintptr_t;

/branches/network/uspace/lib/libc/arch/amd64/Makefile.inc
38,5 → 38,7

LFLAGS += -N

ENDIANESS = LE

BFD_NAME = elf64-x86-64
BFD_ARCH = i386:x86-64

 /branches/network/uspace/lib/libc/arch/mips32/include/types.h
 ,8 → 50,6
 typedef int32_t ssize_t;
 typedef uint32_t size_t;
-typedef uint32_t count_t;
-typedef uint32_t index_t;
 typedef uint32_t uintptr_t;

 /branches/network/uspace/lib/libc/arch/mips32/Makefile.inc
 ,11 → 31,14
 TARGET = mipsel-linux-gnu
 TOOLCHAIN_DIR = $(CROSS_PREFIX)/mipsel/bin
-CFLAGS += -mips3
 ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \
     arch/$(UARCH)/src/fibril.S \
     arch/$(UARCH)/src/tls.c
+CFLAGS += -mips3
+ENDIANESS = LE
 BFD_ARCH = mips
 BFD_NAME = elf32-tradlittlemips

 /branches/network/uspace/lib/libc/arch/ia32/include/types.h
 ,8 → 49,6
 typedef int32_t ssize_t;
 typedef uint32_t size_t;
-typedef uint32_t count_t;
-typedef uint32_t index_t;
 typedef uint32_t uintptr_t;

/branches/network/uspace/lib/libc/arch/ia32/Makefile.inc
39,5 → 39,7

LFLAGS += -N

ENDIANESS = LE

BFD_NAME = elf32-i386
BFD_ARCH = i386

 /branches/network/uspace/srv/kbd/ctl/pc.c
 ,12 → 32,12
  */
 /**
  * @file
- * @brief   PC keyboard controller driver.
+ * @brief PC keyboard controller driver.
  */
 #include <kbd.h>
-#include <kbd/kbd.h>
-#include <kbd/keycode.h>
+#include <io/console.h>
+#include <io/keycode.h>
 #include <kbd_ctl.h>
 #include <gsp.h>
 ,7 → 188,7
 void kbd_ctl_parse_scancode(int scancode)
 {
-    kbd_ev_type_t type;
+    console_ev_type_t type;
     unsigned int key;
     int *map;
     size_t map_length;
 ,9 → 213,9
     if (scancode & 0x80) {
         scancode &= ~0x80;
-        type = KE_RELEASE;
+        type = KEY_RELEASE;
     } else {
-        type = KE_PRESS;
+        type = KEY_PRESS;
     }
     if (scancode < 0 || scancode >= map_length)

 /branches/network/uspace/srv/kbd/ctl/stty.c
 ,8 → 36,7
  */
 #include <kbd.h>
-#include <kbd/kbd.h>
-#include <kbd/keycode.h>
+#include <io/keycode.h>
 #include <kbd_ctl.h>
 #include <gsp.h>
 #include <stroke.h>

 /branches/network/uspace/srv/kbd/ctl/sun.c
 ,8 → 36,8
  */
 #include <kbd.h>
-#include <kbd/kbd.h>
-#include <kbd/keycode.h>
+#include <io/console.h>
+#include <io/keycode.h>
 #include <kbd_ctl.h>
 #define KBD_KEY_RELEASE     0x80
 ,7 → 52,7
 void kbd_ctl_parse_scancode(int scancode)
 {
-    kbd_ev_type_t type;
+    console_ev_type_t type;
     unsigned int key;
     if (scancode < 0 || scancode >= 0x100)
 ,9 → 63,9
     if (scancode & KBD_KEY_RELEASE) {
         scancode &= ~KBD_KEY_RELEASE;
-        type = KE_RELEASE;
+        type = KEY_RELEASE;
     } else {
-        type = KE_PRESS;
+        type = KEY_PRESS;
     }
     key = scanmap_simple[scancode];

 /branches/network/uspace/srv/kbd/ctl/gxe_fb.c
 ,8 → 36,8
  */
 #include <kbd.h>
-#include <kbd/kbd.h>
-#include <kbd/keycode.h>
+#include <io/console.h>
+#include <io/keycode.h>
 #include <kbd_ctl.h>
 #include <gsp.h>
 #include <stroke.h>

 /branches/network/uspace/srv/kbd/include/gsp.h
 ,7 → 37,7
 #ifndef KBD_GSP_H_
 #define KBD_GSP_H_
-#include <libadt/hash_table.h>
+#include <adt/hash_table.h>
 enum {
     GSP_END     = -1,   /**< Terminates a sequence. */

 /branches/network/uspace/srv/kbd/include/layout.h
 ,10 → 27,10
  */
 /** @addtogroup kbdgen generic
- * @brief   HelenOS generic uspace keyboard handler.
- * @ingroup  kbd
+ * @brief HelenOS generic uspace keyboard handler.
+ * @ingroup kbd
  * @{
- */
+ */
 /** @file
  */
 ,12 → 37,12
 #ifndef KBD_LAYOUT_H_
 #define KBD_LAYOUT_H_
-#include <kbd/kbd.h>
 #include <sys/types.h>
+#include <io/console.h>
 typedef struct {
     void (*reset)(void);
-    wchar_t (*parse_ev)(kbd_event_t *);
+    wchar_t (*parse_ev)(console_event_t *);
 } layout_op_t;
 extern layout_op_t us_qwerty_op;
 ,5 → 53,4
 /**
  * @}
- */
+ */

 /branches/network/uspace/srv/kbd/include/kbd.h
 ,10 → 27,10
  */
 /** @addtogroup kbdgen generic
- * @brief   HelenOS generic uspace keyboard handler.
- * @ingroup  kbd
+ * @brief HelenOS generic uspace keyboard handler.
+ * @ingroup kbd
  * @{
- */
+ */
 /** @file
  */
 ,14 → 37,20
 #ifndef KBD_KBD_H_
 #define KBD_KBD_H_
-#include <key_buffer.h>
+#include <keybuffer.h>
+#include <ipc/ipc.h>
-#define KBD_EVENT   1024
-#define KBD_MS_LEFT 1025
-#define KBD_MS_RIGHT    1026
-#define KBD_MS_MIDDLE   1027
-#define KBD_MS_MOVE 1028
+#define KBD_EVENT      1024
+#define KBD_MS_LEFT    1025
+#define KBD_MS_RIGHT   1026
+#define KBD_MS_MIDDLE  1027
+#define KBD_MS_MOVE    1028
+typedef enum {
+    KBD_YIELD = IPC_FIRST_USER_METHOD,
+    KBD_RECLAIM
+} kbd_request_t;
 extern int cir_service;
 extern int cir_phone;
 ,5 → 61,4
 /**
  * @}
- */
+ */

 /branches/network/uspace/srv/kbd/include/keybuffer.h
 ,0 → 1,65
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbdgen
+ * @brief HelenOS generic uspace keyboard handler.
+ * @ingroup kbd
+ * @{
+ */
+/** @file
+ */
+#ifndef __KEYBUFFER_H__
+#define __KEYBUFFER_H__
+#include <sys/types.h>
+#include <io/console.h>
+#include <bool.h>
+/** Size of buffer for pressed keys */
+#define KEYBUFFER_SIZE  128
+typedef struct {
+    console_event_t fifo[KEYBUFFER_SIZE];
+    unsigned long head;
+    unsigned long tail;
+    unsigned long items;
+} keybuffer_t;
+extern void keybuffer_free(keybuffer_t *);
+extern void keybuffer_init(keybuffer_t *);
+extern size_t keybuffer_available(keybuffer_t *);
+extern bool keybuffer_empty(keybuffer_t *);
+extern void keybuffer_push(keybuffer_t *, const console_event_t *);
+extern bool keybuffer_pop(keybuffer_t *, console_event_t *);
+#endif
+/**
+ * @}
+ */

 /branches/network/uspace/srv/kbd/include/kbd_port.h
 ,6 → 38,8
 #define KBD_PORT_H_
 extern int kbd_port_init(void);
+extern void kbd_port_yield(void);
+extern void kbd_port_reclaim(void);
 #endif

 /branches/network/uspace/srv/kbd/port/gxemul.c
 ,6 → 69,14
     return 0;
 }
+void kbd_port_yield(void)
+{
+}
+void kbd_port_reclaim(void)
+{
+}
 /** Process data sent when a key is pressed.
  *
  *  @param keybuffer Buffer of pressed keys.

 /branches/network/uspace/srv/kbd/port/ns16550.c
 ,6 → 106,14
     return pio_enable((void *) ns16550_physical, 8, &vaddr);
 }
+void ns16550_port_yield(void)
+{
+}
+void ns16550_port_reclaim(void)
+{
+}
 static void ns16550_irq_handler(ipc_callid_t iid, ipc_call_t *call)
 {
     int scan_code = IPC_GET_ARG2(*call);

 /branches/network/uspace/srv/kbd/port/msim.c
 ,22 → 69,17
     return 0;
 }
+void kbd_port_yield(void)
+{
+}
+void kbd_port_reclaim(void)
+{
+}
 static void msim_irq_handler(ipc_callid_t iid, ipc_call_t *call)
 {
     int scan_code = IPC_GET_ARG2(*call);
-//  static int esc_count=0;
-//  if (scan_code == 0x1b) {
-//      esc_count++;
-//      if (esc_count == 3)
-//          __SYSCALL0(SYS_DEBUG_ENABLE_CONSOLE);
-//  } else {
-//      esc_count=0;
-//  }
-//  if (fb_fb)
-//      return kbd_arch_process_fb(keybuffer, scan_code);
     kbd_push_scancode(scan_code);
 }

 /branches/network/uspace/srv/kbd/port/sun.c
 ,5 → 62,13
     return -1;
 }
+void kbd_port_yield(void)
+{
+}
+void kbd_port_reclaim(void)
+{
+}
 /** @}
 */

 /branches/network/uspace/srv/kbd/port/i8042.c
 ,6 → 151,14
     return 0;
 }
+void kbd_port_yield(void)
+{
+}
+void kbd_port_reclaim(void)
+{
+}
 static void i8042_irq_handler(ipc_callid_t iid, ipc_call_t *call)
 {
     int status = IPC_GET_ARG1(*call);

 /branches/network/uspace/srv/kbd/port/ski.c
 ,6 → 42,7
 #include <kbd_port.h>
 #include <sys/types.h>
 #include <thread.h>
+#include <bool.h>
 #define SKI_GETCHAR     21
 ,6 → 51,8
 static void *ski_thread_impl(void *arg);
 static int32_t ski_getchar(void);
+static volatile bool polling_disabled = false;
 /** Initialize Ski port driver. */
 int kbd_port_init(void)
 {
 ,6 → 67,16
     return 0;
 }
+void kbd_port_yield(void)
+{
+    polling_disabled = true;
+}
+void kbd_port_reclaim(void)
+{
+    polling_disabled = false;
+}
 /** Thread to poll Ski for keypresses. */
 static void *ski_thread_impl(void *arg)
 {
 ,7 → 84,7
     (void) arg;
     while (1) {
-        while (1) {
+        while (polling_disabled == false) {
             c = ski_getchar();
             if (c == 0)
                 break;

 /branches/network/uspace/srv/kbd/port/z8530.c
 ,6 → 95,14
     return 0;
 }
+void z8530_port_yield(void)
+{
+}
+void z8530_port_reclaim(void)
+{
+}
 static void z8530_irq_handler(ipc_callid_t iid, ipc_call_t *call)
 {
     int scan_code = IPC_GET_ARG2(*call);

 /branches/network/uspace/srv/kbd/port/sgcn.c
 ,6 → 42,7
 #include <sysinfo.h>
 #include <stdio.h>
 #include <thread.h>
+#include <bool.h>
 #define POLL_INTERVAL       10000
 ,6 → 93,7
 /* polling thread */
 static void *sgcn_thread_impl(void *arg);
+static volatile bool polling_disabled = false;
 /**
  * Initializes the SGCN driver.
 ,6 → 122,16
     return 0;
 }
+void kbd_port_yield(void)
+{
+    polling_disabled = true;
+}
+void kbd_port_reclaim(void)
+{
+    polling_disabled = false;
+}
 /**
  * Handler of the "key pressed" event. Reads codes of all the pressed keys from
  * the buffer.
 ,11 → 166,11
     (void) arg;
     while (1) {
-        sgcn_key_pressed();
+        if (polling_disabled == false)
+            sgcn_key_pressed();
         usleep(POLL_INTERVAL);
     }
 }
 /** @}
  */

 /branches/network/uspace/srv/kbd/port/dummy.c
 ,5 → 42,13
     return 0;
 }
+void kbd_port_yield(void)
+{
+}
+void kbd_port_reclaim(void)
+{
+}
 /** @}
 */

 /branches/network/uspace/srv/kbd/genarch/stroke.c
 ,17 → 31,18
  */
 /**
  * @file
- * @brief   Stroke simulator.
+ * @brief Stroke simulator.
  *
  * When simulating a keyboard using a serial TTY we need to convert the
  * recognized strokes (such as Shift-A) to sequences of key presses and
  * releases (such as 'press Shift, press A, release A, release Shift').
+ *
  */
 #include <stroke.h>
 #include <kbd.h>
-#include <kbd/kbd.h>
-#include <kbd/keycode.h>
+#include <io/console.h>
+#include <io/keycode.h>
 /** Correspondence between modifers and the modifier keycodes. */
 static unsigned int mods_keys[][2] = {
 ,7 → 59,7
     i = 0;
     while (mods_keys[i][0] != 0) {
         if (mod & mods_keys[i][0]) {
-            kbd_push_ev(KE_PRESS, mods_keys[i][1]);
+            kbd_push_ev(KEY_PRESS, mods_keys[i][1]);
         }
         ++i;
     }
 ,8 → 66,8
     /* Simulate key press and release. */
     if (key != 0) {
-        kbd_push_ev(KE_PRESS, key);
-        kbd_push_ev(KE_RELEASE, key);
+        kbd_push_ev(KEY_PRESS, key);
+        kbd_push_ev(KEY_RELEASE, key);
     }
     /* Simulate modifier releases. */
 ,7 → 74,7
     i = 0;
     while (mods_keys[i][0] != 0) {
         if (mod & mods_keys[i][0]) {
-            kbd_push_ev(KE_RELEASE, mods_keys[i][1]);
+            kbd_push_ev(KEY_RELEASE, mods_keys[i][1]);
         }
         ++i;
     }
 ,4 → 82,4
 /**
  * @}
- */
+ */

 /branches/network/uspace/srv/kbd/genarch/gsp.c
 ,7 → 49,7
  */
 #include <gsp.h>
-#include <libadt/hash_table.h>
+#include <adt/hash_table.h>
 #include <stdlib.h>
 #include <stdio.h>

 /branches/network/uspace/srv/kbd/generic/kbd.c
 ,10 → 28,10
 /**
  * @addtogroup kbdgen generic
- * @brief   HelenOS generic uspace keyboard handler.
- * @ingroup  kbd
+ * @brief HelenOS generic uspace keyboard handler.
+ * @ingroup kbd
  * @{
- */
+ */
 /** @file
  */
 ,12 → 45,12
 #include <ipc/ns.h>
 #include <async.h>
 #include <errno.h>
-#include <libadt/fifo.h>
-#include <kbd/kbd.h>
-#include <kbd/keycode.h>
+#include <adt/fifo.h>
+#include <io/console.h>
+#include <io/keycode.h>
 #include <kbd.h>
-#include <key_buffer.h>
+#include <keybuffer.h>
 #include <kbd_port.h>
 #include <kbd_ctl.h>
 #include <layout.h>
 ,7 → 88,7
 void kbd_push_ev(int type, unsigned int key)
 {
-    kbd_event_t ev;
+    console_event_t ev;
     unsigned mod_mask;
     switch (key) {
 ,7 → 102,7
     }
     if (mod_mask != 0) {
-        if (type == KE_PRESS)
+        if (type == KEY_PRESS)
             mods = mods | mod_mask;
         else
             mods = mods & ~mod_mask;
 ,7 → 116,7
     }
     if (mod_mask != 0) {
-        if (type == KE_PRESS) {
+        if (type == KEY_PRESS) {
             /*
              * Only change lock state on transition from released
              * to pressed. This prevents autorepeat from messing
 ,7 → 133,7
     printf("mods: 0x%x\n", mods);
     printf("keycode: %u\n", key);
 */
-    if (type == KE_PRESS && (mods & KM_LCTRL) &&
+    if (type == KEY_PRESS && (mods & KM_LCTRL) &&
         key == KC_F1) {
         active_layout = 0;
         layout[active_layout]->reset();
 ,7 → 140,7
         return;
     }
-    if (type == KE_PRESS && (mods & KM_LCTRL) &&
+    if (type == KEY_PRESS && (mods & KM_LCTRL) &&
         key == KC_F2) {
         active_layout = 1;
         layout[active_layout]->reset();
 ,7 → 147,7
         return;
     }
-    if (type == KE_PRESS && (mods & KM_LCTRL) &&
+    if (type == KEY_PRESS && (mods & KM_LCTRL) &&
         key == KC_F3) {
         active_layout = 2;
         layout[active_layout]->reset();
 ,6 → 193,14
             phone2cons = IPC_GET_ARG5(call);
             retval = 0;
             break;
+        case KBD_YIELD:
+            kbd_port_yield();
+            retval = 0;
+            break;
+        case KBD_RECLAIM:
+            kbd_port_reclaim();
+            retval = 0;
+            break;
         default:
             retval = EINVAL;
         }

 /branches/network/uspace/srv/kbd/generic/keybuffer.c
 ,0 → 1,132
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbdgen
+ * @brief HelenOS generic uspace keyboard handler.
+ * @ingroup kbd
+ * @{
+ */
+/** @file
+ */
+#include <keybuffer.h>
+#include <futex.h>
+atomic_t keybuffer_futex = FUTEX_INITIALIZER;
+/** Clear key buffer.
+ */
+void keybuffer_free(keybuffer_t *keybuffer)
+{
+    futex_down(&keybuffer_futex);
+    keybuffer->head = 0;
+    keybuffer->tail = 0;
+    keybuffer->items = 0;
+    futex_up(&keybuffer_futex);
+}
+/** Key buffer initialization.
+ *
+ */
+void keybuffer_init(keybuffer_t *keybuffer)
+{
+    keybuffer_free(keybuffer);
+}
+/** Get free space in buffer.
+ *
+ * This function is useful for processing some scancodes that are translated
+ * to more than one character.
+ *
+ * @return empty buffer space
+ *
+ */
+size_t keybuffer_available(keybuffer_t *keybuffer)
+{
+    return KEYBUFFER_SIZE - keybuffer->items;
+}
+/**
+ *
+ * @return nonzero, if buffer is not empty.
+ *
+ */
+bool keybuffer_empty(keybuffer_t *keybuffer)
+{
+    return (keybuffer->items == 0);
+}
+/** Push key event to key buffer.
+ *
+ * If the buffer is full, the event is ignored.
+ *
+ * @param keybuffer The keybuffer.
+ * @param ev        The event to push.
+ *
+ */
+void keybuffer_push(keybuffer_t *keybuffer, const console_event_t *ev)
+{
+    futex_down(&keybuffer_futex);
+    if (keybuffer->items < KEYBUFFER_SIZE) {
+        keybuffer->fifo[keybuffer->tail] = *ev;
+        keybuffer->tail = (keybuffer->tail + 1) % KEYBUFFER_SIZE;
+        keybuffer->items++;
+    }
+    futex_up(&keybuffer_futex);
+}
+/** Pop event from buffer.
+ *
+ * @param edst Pointer to where the event should be saved.
+ *
+ * @return True if an event was popped.
+ *
+ */
+bool keybuffer_pop(keybuffer_t *keybuffer, console_event_t *edst)
+{
+    futex_down(&keybuffer_futex);
+    if (keybuffer->items > 0) {
+        keybuffer->items--;
+        *edst = (keybuffer->fifo[keybuffer->head]);
+        keybuffer->head = (keybuffer->head + 1) % KEYBUFFER_SIZE;
+        futex_up(&keybuffer_futex);
+        return true;
+    }
+    futex_up(&keybuffer_futex);
+    return false;
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/kbd/Makefile
 ,7 → 34,7
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS += -Iinclude -I../libadt/include
+CFLAGS += -Iinclude
 LIBS = $(LIBC_PREFIX)/libc.a
 ,7 → 46,7
     generic/kbd.c \
     genarch/gsp.c \
     genarch/stroke.c \
-    generic/key_buffer.c
+    generic/keybuffer.c
 ARCH_SOURCES =
 GENARCH_SOURCES = \
 ,8 → 112,15
 ifeq ($(MACHINE), bgxemul)
     GENARCH_SOURCES += \
-        port/gxemul.c \
-        ctl/stty.c
+        port/gxemul.c
+    ifeq ($(CONFIG_FB), y)
+        GENARCH_SOURCES += \
+            ctl/gxe_fb.c
+    else
+        GENARCH_SOURCES += \
+            ctl/stty.c
+    endif
 endif
 ifeq ($(UARCH), ppc32)
 ,7 → 167,7
 disasm: $(OUTPUT).disasm
 $(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
+    $(OBJDUMP) -d $< > $@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/network/uspace/srv/kbd/layout/us_qwerty.c
 ,12 → 32,12
  */
 #include <kbd.h>
-#include <kbd/kbd.h>
-#include <kbd/keycode.h>
+#include <io/console.h>
+#include <io/keycode.h>
 #include <layout.h>
 static void layout_reset(void);
-static wchar_t layout_parse_ev(kbd_event_t *ev);
+static wchar_t layout_parse_ev(console_event_t *ev);
 layout_op_t us_qwerty_op = {
     layout_reset,
 ,7 → 203,7
 {
 }
-static wchar_t layout_parse_ev(kbd_event_t *ev)
+static wchar_t layout_parse_ev(console_event_t *ev)
 {
     wchar_t c;

 /branches/network/uspace/srv/kbd/layout/cz.c
 ,23 → 27,23
  */
 /** @addtogroup kbd
- * @brief   US QWERTY leyout.
+ * @brief US QWERTY leyout.
  * @{
- */
+ */
 #include <kbd.h>
-#include <kbd/kbd.h>
-#include <kbd/keycode.h>
+#include <io/console.h>
+#include <io/keycode.h>
 #include <bool.h>
 #include <layout.h>
 static void layout_reset(void);
-static wchar_t layout_parse_ev(kbd_event_t *ev);
+static wchar_t layout_parse_ev(console_event_t *ev);
 enum m_state {
     ms_start,
     ms_hacek,
-    ms_carka
+    ms_carka
 };
 static enum m_state mstate;
 ,7 → 272,7
     return map[key];
 }
-static wchar_t parse_ms_hacek(kbd_event_t *ev)
+static wchar_t parse_ms_hacek(console_event_t *ev)
 {
     wchar_t c;
 ,7 → 290,7
     return c;
 }
-static wchar_t parse_ms_carka(kbd_event_t *ev)
+static wchar_t parse_ms_carka(console_event_t *ev)
 {
     wchar_t c;
 ,7 → 308,7
     return c;
 }
-static wchar_t parse_ms_start(kbd_event_t *ev)
+static wchar_t parse_ms_start(console_event_t *ev)
 {
     wchar_t c;
 ,21 → 383,24
     mstate = ms_start;
 }
-static wchar_t layout_parse_ev(kbd_event_t *ev)
+static wchar_t layout_parse_ev(console_event_t *ev)
 {
-    if (ev->type != KE_PRESS)
-        return '\0';
+    if (ev->type != KEY_PRESS)
+        return 0;
     if (key_is_mod(ev->key))
-        return '\0';
+        return 0;
     switch (mstate) {
-    case ms_start: return parse_ms_start(ev);
-    case ms_hacek: return parse_ms_hacek(ev);
-    case ms_carka: return parse_ms_carka(ev);
+    case ms_start:
+        return parse_ms_start(ev);
+    case ms_hacek:
+        return parse_ms_hacek(ev);
+    case ms_carka:
+        return parse_ms_carka(ev);
     }
 }
 /**
  * @}
- */
+ */

 /branches/network/uspace/srv/kbd/layout/us_dvorak.c
 ,12 → 32,12
  */
 #include <kbd.h>
-#include <kbd/kbd.h>
-#include <kbd/keycode.h>
+#include <io/console.h>
+#include <io/keycode.h>
 #include <layout.h>
 static void layout_reset(void);
-static wchar_t layout_parse_ev(kbd_event_t *ev);
+static wchar_t layout_parse_ev(console_event_t *ev);
 layout_op_t us_dvorak_op = {
     layout_reset,
 ,7 → 209,7
 {
 }
-static wchar_t layout_parse_ev(kbd_event_t *ev)
+static wchar_t layout_parse_ev(console_event_t *ev)
 {
     wchar_t c;

 /branches/network/uspace/srv/ns/clonable.c
 ,0 → 1,143
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup ns
+ * @{
+ */
+#include <ipc/ipc.h>
+#include <ipc/services.h>
+#include <adt/list.h>
+#include <bool.h>
+#include <errno.h>
+#include <assert.h>
+#include <stdio.h>
+#include <malloc.h>
+#include <loader/loader.h>
+#include "clonable.h"
+#include "ns.h"
+/** Request for connection to a clonable service. */
+typedef struct {
+    link_t link;
+    ipcarg_t service;
+    ipc_call_t call;
+    ipc_callid_t callid;
+} cs_req_t;
+/** List of clonable-service connection requests. */
+static link_t cs_req;
+int clonable_init(void)
+{
+    list_initialize(&cs_req);
+    return EOK;
+}
+/** Return true if @a service is clonable. */
+bool service_clonable(int service)
+{
+    return (service == SERVICE_LOAD);
+}
+/** Register clonable service.
+ *
+ * @param service Service to be registered.
+ * @param phone   Phone to be used for connections to the service.
+ * @param call    Pointer to call structure.
+ *
+ */
+void register_clonable(ipcarg_t service, ipcarg_t phone, ipc_call_t *call,
+    ipc_callid_t callid)
+{
+    if (list_empty(&cs_req)) {
+        /* There was no pending connection request. */
+        printf(NAME ": Unexpected clonable server.\n");
+        ipc_answer_0(callid, EBUSY);
+        return;
+    }
+    cs_req_t *csr = list_get_instance(cs_req.next, cs_req_t, link);
+    list_remove(&csr->link);
+    /* Currently we can only handle a single type of clonable service. */
+    assert(csr->service == SERVICE_LOAD);
+    ipc_answer_0(callid, EOK);
+    ipc_forward_fast(csr->callid, phone, IPC_GET_ARG2(csr->call),
+        IPC_GET_ARG3(csr->call), 0, IPC_FF_NONE);
+    free(csr);
+    ipc_hangup(phone);
+}
+/** Connect client to clonable service.
+ *
+ * @param service Service to be connected to.
+ * @param call    Pointer to call structure.
+ * @param callid  Call ID of the request.
+ *
+ * @return Zero on success or a value from @ref errno.h.
+ *
+ */
+void connect_to_clonable(ipcarg_t service, ipc_call_t *call,
+    ipc_callid_t callid)
+{
+    assert(service == SERVICE_LOAD);
+    cs_req_t *csr = malloc(sizeof(cs_req_t));
+    if (csr == NULL) {
+        ipc_answer_0(callid, ENOMEM);
+        return;
+    }
+    /* Spawn a loader. */
+    int rc = loader_spawn("loader");
+    if (rc < 0) {
+        free(csr);
+        ipc_answer_0(callid, rc);
+        return;
+    }
+    csr->service = service;
+    csr->call = *call;
+    csr->callid = callid;
+    /*
+     * We can forward the call only after the server we spawned connects
+     * to us. Meanwhile we might need to service more connection requests.
+     * Thus we store the call in a queue.
+     */
+    list_append(&csr->link, &cs_req);
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/ns/ns.c
 ,93 → 35,28
  * @brief Naming service for HelenOS IPC.
  */
 #include <ipc/ipc.h>
+#include <ipc/services.h>
 #include <ipc/ns.h>
-#include <ipc/services.h>
+#include <unistd.h>
 #include <stdio.h>
-#include <bool.h>
-#include <unistd.h>
-#include <stdlib.h>
 #include <errno.h>
-#include <assert.h>
-#include <libadt/list.h>
-#include <libadt/hash_table.h>
+#include <as.h>
+#include <ddi.h>
+#include <event.h>
+#include <macros.h>
 #include <sysinfo.h>
-#include <loader/loader.h>
-#include <ddi.h>
-#include <as.h>
+#include "ns.h"
+#include "service.h"
+#include "clonable.h"
+#include "task.h"
-#define NAME  "ns"
-#define NS_HASH_TABLE_CHAINS  20
-static int register_service(ipcarg_t service, ipcarg_t phone, ipc_call_t *call);
-static void connect_to_service(ipcarg_t service, ipc_call_t *call,
-    ipc_callid_t callid);
-void register_clonable(ipcarg_t service, ipcarg_t phone, ipc_call_t *call,
-    ipc_callid_t callid);
-void connect_to_clonable(ipcarg_t service, ipc_call_t *call,
-    ipc_callid_t callid);
-/* Static functions implementing NS hash table operations. */
-static hash_index_t ns_hash(unsigned long *key);
-static int ns_compare(unsigned long *key, hash_count_t keys, link_t *item);
-static void ns_remove(link_t *item);
-/** Operations for NS hash table. */
-static hash_table_operations_t ns_hash_table_ops = {
-    .hash = ns_hash,
-    .compare = ns_compare,
-    .remove_callback = ns_remove
-};
-/** NS hash table structure. */
-static hash_table_t ns_hash_table;
-/** NS hash table item. */
-typedef struct {
-    link_t link;
-    ipcarg_t service;        /**< Number of the service. */
-    ipcarg_t phone;          /**< Phone registered with the service. */
-    ipcarg_t in_phone_hash;  /**< Incoming phone hash. */
-} hashed_service_t;
-/** Pending connection structure. */
-typedef struct {
-    link_t link;
-    ipcarg_t service;        /**< Number of the service. */
-    ipc_callid_t callid;     /**< Call ID waiting for the connection */
-    ipcarg_t arg2;           /**< Second argument */
-    ipcarg_t arg3;           /**< Third argument */
-} pending_req_t;
-static link_t pending_req;
-/** Request for connection to a clonable service. */
-typedef struct {
-    link_t link;
-    ipcarg_t service;
-    ipc_call_t call;
-    ipc_callid_t callid;
-} cs_req_t;
-/** List of clonable-service connection requests. */
-static link_t cs_req;
 static void *clockaddr = NULL;
 static void *klogaddr = NULL;
-/** Return true if @a service is clonable. */
-static bool service_clonable(int service)
+static void get_as_area(ipc_callid_t callid, ipc_call_t *call, void *ph_addr,
+    size_t pages, void **addr)
 {
-    return (service == SERVICE_LOAD);
-}
-static void get_as_area(ipc_callid_t callid, ipc_call_t *call, void *ph_addr, count_t pages, void **addr)
-{
     if (ph_addr == NULL) {
         ipc_answer_0(callid, ENOENT);
         return;
 ,67 → 80,53
     ipc_answer_2(callid, EOK, (ipcarg_t) *addr, AS_AREA_READ);
 }
-/** Process pending connection requests */
-static void process_pending_req()
-{
-    link_t *cur;
-loop:
-    for (cur = pending_req.next; cur != &pending_req; cur = cur->next) {
-        pending_req_t *pr = list_get_instance(cur, pending_req_t, link);
-        unsigned long keys[3] = {
-            pr->service,
-,
-        };
-        link_t *link = hash_table_find(&ns_hash_table, keys);
-        if (!link)
-            continue;
-        hashed_service_t *hs = hash_table_get_instance(link, hashed_service_t, link);
-        ipcarg_t retval = ipc_forward_fast(pr->callid, hs->phone,
-            pr->arg2, pr->arg3, 0, IPC_FF_NONE);
-        if (!(pr->callid & IPC_CALLID_NOTIFICATION))
-            ipc_answer_0(pr->callid, retval);
-        list_remove(cur);
-        free(pr);
-        goto loop;
-    }
-}
 int main(int argc, char **argv)
 {
     printf(NAME ": HelenOS IPC Naming Service\n");
-    if (!hash_table_create(&ns_hash_table, NS_HASH_TABLE_CHAINS, 3,
-        &ns_hash_table_ops)) {
-        printf(NAME ": No memory available for services\n");
-        return ENOMEM;
-    }
+    int rc = service_init();
+    if (rc != EOK)
+        return rc;
-    list_initialize(&pending_req);
-    list_initialize(&cs_req);
+    rc = clonable_init();
+    if (rc != EOK)
+        return rc;
+    rc = task_init();
+    if (rc != EOK)
+        return rc;
     printf(NAME ": Accepting connections\n");
     while (true) {
-        process_pending_req();
+        process_pending_conn();
+        process_pending_wait();
         ipc_call_t call;
         ipc_callid_t callid = ipc_wait_for_call(&call);
+        task_id_t id;
         ipcarg_t retval;
+        if (callid & IPC_CALLID_NOTIFICATION) {
+            id = (task_id_t)
+                MERGE_LOUP32(IPC_GET_ARG2(call), IPC_GET_ARG3(call));
+            wait_notification((wait_type_t) IPC_GET_ARG1(call), id);
+            continue;
+        }
         switch (IPC_GET_METHOD(call)) {
         case IPC_M_SHARE_IN:
             switch (IPC_GET_ARG3(call)) {
             case SERVICE_MEM_REALTIME:
-                get_as_area(callid, &call, sysinfo_value("clock.faddr"), 1, &clockaddr);
+                get_as_area(callid, &call,
+                    (void *) sysinfo_value("clock.faddr"),
+, &clockaddr);
                 break;
             case SERVICE_MEM_KLOG:
-                get_as_area(callid, &call, sysinfo_value("klog.faddr"), sysinfo_value("klog.pages"), &klogaddr);
+                get_as_area(callid, &call,
+                    (void *) sysinfo_value("klog.faddr"),
+                    sysinfo_value("klog.pages"), &klogaddr);
                 break;
             default:
                 ipc_answer_0(callid, ENOENT);
 ,6 → 162,14
                 continue;
             }
             break;
+        case NS_PING:
+            retval = EOK;
+            break;
+        case NS_TASK_WAIT:
+            id = (task_id_t)
+                MERGE_LOUP32(IPC_GET_ARG1(call), IPC_GET_ARG2(call));
+            wait_for_task(id, &call, callid);
+            continue;
         default:
             retval = ENOENT;
             break;
 ,213 → 183,6
     return 0;
 }
-/** Register service.
- *
- * @param service Service to be registered.
- * @param phone   Phone to be used for connections to the service.
- * @param call    Pointer to call structure.
- *
- * @return Zero on success or a value from @ref errno.h.
- *
- */
-int register_service(ipcarg_t service, ipcarg_t phone, ipc_call_t *call)
-{
-    unsigned long keys[3] = {
-        service,
-        call->in_phone_hash,
-    };
-    if (hash_table_find(&ns_hash_table, keys))
-        return EEXISTS;
-    hashed_service_t *hs = (hashed_service_t *) malloc(sizeof(hashed_service_t));
-    if (!hs)
-        return ENOMEM;
-    link_initialize(&hs->link);
-    hs->service = service;
-    hs->phone = phone;
-    hs->in_phone_hash = call->in_phone_hash;
-    hash_table_insert(&ns_hash_table, keys, &hs->link);
-    return 0;
-}
-/** Connect client to service.
- *
- * @param service Service to be connected to.
- * @param call    Pointer to call structure.
- * @param callid  Call ID of the request.
- *
- * @return Zero on success or a value from @ref errno.h.
- *
- */
-void connect_to_service(ipcarg_t service, ipc_call_t *call, ipc_callid_t callid)
-{
-    ipcarg_t retval;
-    unsigned long keys[3] = {
-        service,
-,
-    };
-    link_t *link = hash_table_find(&ns_hash_table, keys);
-    if (!link) {
-        if (IPC_GET_ARG4(*call) & IPC_FLAG_BLOCKING) {
-            /* Blocking connection, add to pending list */
-            pending_req_t *pr = (pending_req_t *) malloc(sizeof(pending_req_t));
-            if (!pr) {
-                retval = ENOMEM;
-                goto out;
-            }
-            pr->service = service;
-            pr->callid = callid;
-            pr->arg2 = IPC_GET_ARG2(*call);
-            pr->arg3 = IPC_GET_ARG3(*call);
-            list_append(&pr->link, &pending_req);
-            return;
-        }
-        retval = ENOENT;
-        goto out;
-    }
-    hashed_service_t *hs = hash_table_get_instance(link, hashed_service_t, link);
-    retval = ipc_forward_fast(callid, hs->phone, IPC_GET_ARG2(*call),
-        IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
-out:
-    if (!(callid & IPC_CALLID_NOTIFICATION))
-        ipc_answer_0(callid, retval);
-}
-/** Register clonable service.
- *
- * @param service Service to be registered.
- * @param phone   Phone to be used for connections to the service.
- * @param call    Pointer to call structure.
- *
- */
-void register_clonable(ipcarg_t service, ipcarg_t phone, ipc_call_t *call,
-    ipc_callid_t callid)
-{
-    if (list_empty(&cs_req)) {
-        /* There was no pending connection request. */
-        printf(NAME ": Unexpected clonable server.\n");
-        ipc_answer_0(callid, EBUSY);
-        return;
-    }
-    cs_req_t *csr = list_get_instance(cs_req.next, cs_req_t, link);
-    list_remove(&csr->link);
-    /* Currently we can only handle a single type of clonable service. */
-    assert(csr->service == SERVICE_LOAD);
-    ipc_answer_0(callid, EOK);
-    int rc = ipc_forward_fast(csr->callid, phone, IPC_GET_ARG2(csr->call),
-        IPC_GET_ARG3(csr->call), 0, IPC_FF_NONE);
-    free(csr);
-    ipc_hangup(phone);
-}
-/** Connect client to clonable service.
- *
- * @param service Service to be connected to.
- * @param call    Pointer to call structure.
- * @param callid  Call ID of the request.
- *
- * @return Zero on success or a value from @ref errno.h.
- *
- */
-void connect_to_clonable(ipcarg_t service, ipc_call_t *call,
-    ipc_callid_t callid)
-{
-    assert(service == SERVICE_LOAD);
-    cs_req_t *csr = malloc(sizeof(cs_req_t));
-    if (csr == NULL) {
-        ipc_answer_0(callid, ENOMEM);
-        return;
-    }
-    /* Spawn a loader. */
-    int rc = loader_spawn("loader");
-    if (rc < 0) {
-        free(csr);
-        ipc_answer_0(callid, rc);
-        return;
-    }
-    csr->service = service;
-    csr->call = *call;
-    csr->callid = callid;
-    /*
-     * We can forward the call only after the server we spawned connects
-     * to us. Meanwhile we might need to service more connection requests.
-     * Thus we store the call in a queue.
-     */
-    list_append(&csr->link, &cs_req);
-}
-/** Compute hash index into NS hash table.
- *
- * @param key Pointer keys. However, only the first key (i.e. service number)
- *            is used to compute the hash index.
- *
- * @return Hash index corresponding to key[0].
- *
- */
-hash_index_t ns_hash(unsigned long *key)
-{
-    assert(key);
-    return (*key % NS_HASH_TABLE_CHAINS);
-}
-/** Compare a key with hashed item.
- *
- * This compare function always ignores the third key.
- * It exists only to make it possible to remove records
- * originating from connection with key[1] in_phone_hash
- * value. Note that this is close to being classified
- * as a nasty hack.
- *
- * @param key  Array of keys.
- * @param keys Must be lesser or equal to 3.
- * @param item Pointer to a hash table item.
- *
- * @return Non-zero if the key matches the item, zero otherwise.
- *
- */
-int ns_compare(unsigned long key[], hash_count_t keys, link_t *item)
-{
-    assert(key);
-    assert(keys <= 3);
-    assert(item);
-    hashed_service_t *hs = hash_table_get_instance(item, hashed_service_t, link);
-    if (keys == 2)
-        return key[1] == hs->in_phone_hash;
-    else
-        return key[0] == hs->service;
-}
-/** Perform actions after removal of item from the hash table.
- *
- * @param item Item that was removed from the hash table.
- *
- */
-void ns_remove(link_t *item)
-{
-    assert(item);
-    free(hash_table_get_instance(item, hashed_service_t, link));
-}
 /**
  * @}
  */

 /branches/network/uspace/srv/ns/service.c
 ,0 → 1,254
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup ns
+ * @{
+ */
+#include <ipc/ipc.h>
+#include <adt/hash_table.h>
+#include <assert.h>
+#include <errno.h>
+#include "service.h"
+#include "ns.h"
+#define SERVICE_HASH_TABLE_CHAINS  20
+/** Service hash table item. */
+typedef struct {
+    link_t link;
+    ipcarg_t service;        /**< Number of the service. */
+    ipcarg_t phone;          /**< Phone registered with the service. */
+    ipcarg_t in_phone_hash;  /**< Incoming phone hash. */
+} hashed_service_t;
+/** Compute hash index into service hash table.
+ *
+ * @param key Pointer keys. However, only the first key (i.e. service number)
+ *            is used to compute the hash index.
+ *
+ * @return Hash index corresponding to key[0].
+ *
+ */
+static hash_index_t service_hash(unsigned long *key)
+{
+    assert(key);
+    return (*key % SERVICE_HASH_TABLE_CHAINS);
+}
+/** Compare a key with hashed item.
+ *
+ * This compare function always ignores the third key.
+ * It exists only to make it possible to remove records
+ * originating from connection with key[1] in_phone_hash
+ * value. Note that this is close to being classified
+ * as a nasty hack.
+ *
+ * @param key  Array of keys.
+ * @param keys Must be lesser or equal to 3.
+ * @param item Pointer to a hash table item.
+ *
+ * @return Non-zero if the key matches the item, zero otherwise.
+ *
+ */
+static int service_compare(unsigned long key[], hash_count_t keys, link_t *item)
+{
+    assert(key);
+    assert(keys <= 3);
+    assert(item);
+    hashed_service_t *hs = hash_table_get_instance(item, hashed_service_t, link);
+    if (keys == 2)
+        return (key[1] == hs->in_phone_hash);
+    else
+        return (key[0] == hs->service);
+}
+/** Perform actions after removal of item from the hash table.
+ *
+ * @param item Item that was removed from the hash table.
+ *
+ */
+static void service_remove(link_t *item)
+{
+    assert(item);
+    free(hash_table_get_instance(item, hashed_service_t, link));
+}
+/** Operations for service hash table. */
+static hash_table_operations_t service_hash_table_ops = {
+    .hash = service_hash,
+    .compare = service_compare,
+    .remove_callback = service_remove
+};
+/** Service hash table structure. */
+static hash_table_t service_hash_table;
+/** Pending connection structure. */
+typedef struct {
+    link_t link;
+    ipcarg_t service;        /**< Number of the service. */
+    ipc_callid_t callid;     /**< Call ID waiting for the connection */
+    ipcarg_t arg2;           /**< Second argument */
+    ipcarg_t arg3;           /**< Third argument */
+} pending_conn_t;
+static link_t pending_conn;
+int service_init(void)
+{
+    if (!hash_table_create(&service_hash_table, SERVICE_HASH_TABLE_CHAINS,
+, &service_hash_table_ops)) {
+        printf(NAME ": No memory available for services\n");
+        return ENOMEM;
+    }
+    list_initialize(&pending_conn);
+    return EOK;
+}
+/** Process pending connection requests */
+void process_pending_conn(void)
+{
+    link_t *cur;
+loop:
+    for (cur = pending_conn.next; cur != &pending_conn; cur = cur->next) {
+        pending_conn_t *pr = list_get_instance(cur, pending_conn_t, link);
+        unsigned long keys[3] = {
+            pr->service,
+,
+        };
+        link_t *link = hash_table_find(&service_hash_table, keys);
+        if (!link)
+            continue;
+        hashed_service_t *hs = hash_table_get_instance(link, hashed_service_t, link);
+        ipcarg_t retval = ipc_forward_fast(pr->callid, hs->phone,
+            pr->arg2, pr->arg3, 0, IPC_FF_NONE);
+        if (!(pr->callid & IPC_CALLID_NOTIFICATION))
+            ipc_answer_0(pr->callid, retval);
+        list_remove(cur);
+        free(pr);
+        goto loop;
+    }
+}
+/** Register service.
+ *
+ * @param service Service to be registered.
+ * @param phone   Phone to be used for connections to the service.
+ * @param call    Pointer to call structure.
+ *
+ * @return Zero on success or a value from @ref errno.h.
+ *
+ */
+int register_service(ipcarg_t service, ipcarg_t phone, ipc_call_t *call)
+{
+    unsigned long keys[3] = {
+        service,
+        call->in_phone_hash,
+    };
+    if (hash_table_find(&service_hash_table, keys))
+        return EEXISTS;
+    hashed_service_t *hs = (hashed_service_t *) malloc(sizeof(hashed_service_t));
+    if (!hs)
+        return ENOMEM;
+    link_initialize(&hs->link);
+    hs->service = service;
+    hs->phone = phone;
+    hs->in_phone_hash = call->in_phone_hash;
+    hash_table_insert(&service_hash_table, keys, &hs->link);
+    return 0;
+}
+/** Connect client to service.
+ *
+ * @param service Service to be connected to.
+ * @param call    Pointer to call structure.
+ * @param callid  Call ID of the request.
+ *
+ * @return Zero on success or a value from @ref errno.h.
+ *
+ */
+void connect_to_service(ipcarg_t service, ipc_call_t *call, ipc_callid_t callid)
+{
+    ipcarg_t retval;
+    unsigned long keys[3] = {
+        service,
+,
+    };
+    link_t *link = hash_table_find(&service_hash_table, keys);
+    if (!link) {
+        if (IPC_GET_ARG4(*call) & IPC_FLAG_BLOCKING) {
+            /* Blocking connection, add to pending list */
+            pending_conn_t *pr =
+                (pending_conn_t *) malloc(sizeof(pending_conn_t));
+            if (!pr) {
+                retval = ENOMEM;
+                goto out;
+            }
+            pr->service = service;
+            pr->callid = callid;
+            pr->arg2 = IPC_GET_ARG2(*call);
+            pr->arg3 = IPC_GET_ARG3(*call);
+            list_append(&pr->link, &pending_conn);
+            return;
+        }
+        retval = ENOENT;
+        goto out;
+    }
+    hashed_service_t *hs = hash_table_get_instance(link, hashed_service_t, link);
+    retval = ipc_forward_fast(callid, hs->phone, IPC_GET_ARG2(*call),
+        IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
+out:
+    if (!(callid & IPC_CALLID_NOTIFICATION))
+        ipc_answer_0(callid, retval);
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/ns/task.c
 ,0 → 1,269
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup ns
+ * @{
+ */
+#include <ipc/ipc.h>
+#include <adt/hash_table.h>
+#include <bool.h>
+#include <errno.h>
+#include <assert.h>
+#include <stdio.h>
+#include <macros.h>
+#include "task.h"
+#include "ns.h"
+#define TASK_HASH_TABLE_CHAINS  256
+/* TODO:
+ *
+ * The current implementation of waiting on a task is not perfect. If somebody
+ * wants to wait on a task which has already finished before the NS asked
+ * the kernel to receive notifications, it would block indefinitively.
+ *
+ * A solution to this is to fail immediately on a task for which no creation
+ * notification was received yet. However, there is a danger of a race condition
+ * in this solution -- the caller has to make sure that it is not trying to wait
+ * before the NS has a change to receive the task creation notification. This
+ * can be assured by waiting for this event in task_spawn().
+ *
+ * Finally, as there is currently no convention that each task has to be waited
+ * for, the NS can leak memory because of the zombie tasks.
+ *
+ */
+/** Task hash table item. */
+typedef struct {
+    link_t link;
+    task_id_t id;    /**< Task ID. */
+    bool destroyed;
+} hashed_task_t;
+/** Compute hash index into task hash table.
+ *
+ * @param key Pointer keys. However, only the first key (i.e. truncated task
+ *            number) is used to compute the hash index.
+ *
+ * @return Hash index corresponding to key[0].
+ *
+ */
+static hash_index_t task_hash(unsigned long *key)
+{
+    assert(key);
+    return (LOWER32(*key) % TASK_HASH_TABLE_CHAINS);
+}
+/** Compare a key with hashed item.
+ *
+ * @param key  Array of keys.
+ * @param keys Must be lesser or equal to 2.
+ * @param item Pointer to a hash table item.
+ *
+ * @return Non-zero if the key matches the item, zero otherwise.
+ *
+ */
+static int task_compare(unsigned long key[], hash_count_t keys, link_t *item)
+{
+    assert(key);
+    assert(keys <= 2);
+    assert(item);
+    hashed_task_t *ht = hash_table_get_instance(item, hashed_task_t, link);
+    if (keys == 2)
+        return ((LOWER32(key[1]) == UPPER32(ht->id))
+            && (LOWER32(key[0]) == LOWER32(ht->id)));
+    else
+        return (LOWER32(key[0]) == LOWER32(ht->id));
+}
+/** Perform actions after removal of item from the hash table.
+ *
+ * @param item Item that was removed from the hash table.
+ *
+ */
+static void task_remove(link_t *item)
+{
+    assert(item);
+    free(hash_table_get_instance(item, hashed_task_t, link));
+}
+/** Operations for task hash table. */
+static hash_table_operations_t task_hash_table_ops = {
+    .hash = task_hash,
+    .compare = task_compare,
+    .remove_callback = task_remove
+};
+/** Task hash table structure. */
+static hash_table_t task_hash_table;
+/** Pending task wait structure. */
+typedef struct {
+    link_t link;
+    task_id_t id;         /**< Task ID. */
+    ipc_callid_t callid;  /**< Call ID waiting for the connection */
+} pending_wait_t;
+static link_t pending_wait;
+int task_init(void)
+{
+    if (!hash_table_create(&task_hash_table, TASK_HASH_TABLE_CHAINS,
+, &task_hash_table_ops)) {
+        printf(NAME ": No memory available for tasks\n");
+        return ENOMEM;
+    }
+    if (event_subscribe(EVENT_WAIT, 0) != EOK)
+        printf(NAME ": Error registering wait notifications\n");
+    list_initialize(&pending_wait);
+    return EOK;
+}
+/** Process pending wait requests */
+void process_pending_wait(void)
+{
+    link_t *cur;
+loop:
+    for (cur = pending_wait.next; cur != &pending_wait; cur = cur->next) {
+        pending_wait_t *pr = list_get_instance(cur, pending_wait_t, link);
+        unsigned long keys[2] = {
+            LOWER32(pr->id),
+            UPPER32(pr->id)
+        };
+        link_t *link = hash_table_find(&task_hash_table, keys);
+        if (!link)
+            continue;
+        hashed_task_t *ht = hash_table_get_instance(link, hashed_task_t, link);
+        if (!ht->destroyed)
+            continue;
+        if (!(pr->callid & IPC_CALLID_NOTIFICATION))
+            ipc_answer_0(pr->callid, EOK);
+        hash_table_remove(&task_hash_table, keys, 2);
+        list_remove(cur);
+        free(pr);
+        goto loop;
+    }
+}
+static void fail_pending_wait(task_id_t id, int rc)
+{
+    link_t *cur;
+loop:
+    for (cur = pending_wait.next; cur != &pending_wait; cur = cur->next) {
+        pending_wait_t *pr = list_get_instance(cur, pending_wait_t, link);
+        if (pr->id == id) {
+            if (!(pr->callid & IPC_CALLID_NOTIFICATION))
+                ipc_answer_0(pr->callid, rc);
+            list_remove(cur);
+            free(pr);
+            goto loop;
+        }
+    }
+}
+void wait_notification(wait_type_t et, task_id_t id)
+{
+    unsigned long keys[2] = {
+        LOWER32(id),
+        UPPER32(id)
+    };
+    link_t *link = hash_table_find(&task_hash_table, keys);
+    if (link == NULL) {
+        hashed_task_t *ht =
+            (hashed_task_t *) malloc(sizeof(hashed_task_t));
+        if (ht == NULL) {
+            fail_pending_wait(id, ENOMEM);
+            return;
+        }
+        link_initialize(&ht->link);
+        ht->id = id;
+        ht->destroyed = (et == TASK_CREATE) ? false : true;
+        hash_table_insert(&task_hash_table, keys, &ht->link);
+    } else {
+        hashed_task_t *ht =
+            hash_table_get_instance(link, hashed_task_t, link);
+        ht->destroyed = (et == TASK_CREATE) ? false : true;
+    }
+}
+void wait_for_task(task_id_t id, ipc_call_t *call, ipc_callid_t callid)
+{
+    ipcarg_t retval;
+    unsigned long keys[2] = {
+        LOWER32(id),
+        UPPER32(id)
+    };
+    link_t *link = hash_table_find(&task_hash_table, keys);
+    hashed_task_t *ht = (link != NULL) ?
+        hash_table_get_instance(link, hashed_task_t, link) : NULL;
+    if ((ht == NULL) || (!ht->destroyed)) {
+        /* Add to pending list */
+        pending_wait_t *pr =
+            (pending_wait_t *) malloc(sizeof(pending_wait_t));
+        if (!pr) {
+            retval = ENOMEM;
+            goto out;
+        }
+        pr->id = id;
+        pr->callid = callid;
+        list_append(&pr->link, &pending_wait);
+        return;
+    }
+    hash_table_remove(&task_hash_table, keys, 2);
+    retval = EOK;
+out:
+    if (!(callid & IPC_CALLID_NOTIFICATION))
+        ipc_answer_0(callid, retval);
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/ns/clonable.h
 ,0 → 1,51
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup ns
+ * @{
+ */
+#ifndef NS_CLONABLE_H__
+#define NS_CLONABLE_H__
+#include <ipc/ipc.h>
+#include <bool.h>
+extern int clonable_init(void);
+extern bool service_clonable(int service);
+extern void register_clonable(ipcarg_t service, ipcarg_t phone,
+    ipc_call_t *call, ipc_callid_t callid);
+extern void connect_to_clonable(ipcarg_t service, ipc_call_t *call,
+    ipc_callid_t callid);
+#endif
+/**
+ * @}
+ */

 /branches/network/uspace/srv/ns/ns.h
 ,0 → 1,42
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup ns
+ * @{
+ */
+#ifndef NS_NS_H__
+#define NS_NS_H__
+#define NAME  "ns"
+#endif
+/**
+ * @}
+ */

 /branches/network/uspace/srv/ns/service.h
 ,0 → 1,49
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup ns
+ * @{
+ */
+#ifndef NS_SERVICE_H__
+#define NS_SERVICE_H__
+#include <ipc/ipc.h>
+extern int service_init(void);
+extern void process_pending_conn(void);
+extern int register_service(ipcarg_t service, ipcarg_t phone, ipc_call_t *call);
+extern void connect_to_service(ipcarg_t service, ipc_call_t *call,
+     ipc_callid_t callid);
+#endif
+/**
+ * @}
+ */

 /branches/network/uspace/srv/ns/task.h
 ,0 → 1,49
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup ns
+ * @{
+ */
+#ifndef NS_TASK_H__
+#define NS_TASK_H__
+#include <ipc/ipc.h>
+#include <event.h>
+extern int task_init(void);
+extern void process_pending_wait(void);
+extern void wait_notification(wait_type_t et, task_id_t id);
+extern void wait_for_task(task_id_t id, ipc_call_t *call, ipc_callid_t callid);
+#endif
+/**
+ * @}
+ */

 /branches/network/uspace/srv/ns/Makefile
 ,7 → 41,10
 OUTPUT = ns
 SOURCES = \
-    ns.c
+    ns.c \
+    service.c \
+    clonable.c \
+    task.c
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
 ,7 → 66,7
 disasm: $(OUTPUT).disasm
 $(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
+    $(OBJDUMP) -d $< > $@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

/branches/network/uspace/srv/console/nameic.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Deleted: svn:mime-type
-application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/anim_4.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Deleted: svn:mime-type
-application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/anim_3.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Deleted: svn:mime-type
-application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/anim_2.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Deleted: svn:mime-type
-application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/anim_1.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Deleted: svn:mime-type
-application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/helenos.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Deleted: svn:mime-type
-application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/cons_selected.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Deleted: svn:mime-type
-application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/cons_idle.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Deleted: svn:mime-type
-application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/cons_kernel.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Deleted: svn:mime-type
-application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/cons_has_data.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Deleted: svn:mime-type
-application/octet-stream
\ No newline at end of property

 /branches/network/uspace/srv/console/gcons.h
 ,25 → 27,30
  */
 /** @addtogroup console
- * @{
+ * @{
  */
 /** @file
  */
-#ifndef _GCONS_H_
-#define _GCONS_H_
+#ifndef GCONS_H_
+#define GCONS_H_
+#include <sys/types.h>
 void gcons_init(int phone);
 void gcons_redraw_console(void);
-void gcons_change_console(int consnum);
-void gcons_notify_char(int consnum);
+void gcons_change_console(size_t index);
+void gcons_notify_char(size_t index);
 void gcons_in_kernel(void);
-void gcons_notify_connect(int consnum);
-void gcons_notify_disconnect(int consnum);
-void gcons_mouse_move(int dx, int dy);
-int gcons_mouse_btn(int state);
+void gcons_notify_connect(size_t index);
+void gcons_notify_disconnect(size_t index);
+void gcons_mouse_move(ssize_t dx, ssize_t dy);
+int gcons_mouse_btn(bool state);
 #endif
 /** @}
  */

 /branches/network/uspace/srv/console/screenbuffer.h
 ,19 → 27,20
  */
 /** @addtogroup console
- * @{
+ * @{
  */
 /** @file
  */
-#ifndef __SCREENBUFFER_H__
-#define __SCREENBUFFER_H__
+#ifndef SCREENBUFFER_H__
+#define SCREENBUFFER_H__
 #include <stdint.h>
 #include <sys/types.h>
+#include <bool.h>
-#define DEFAULT_FOREGROUND 0x0  /**< default console foreground color */
-#define DEFAULT_BACKGROUND 0xf0f0f0 /**< default console background color */
+#define DEFAULT_FOREGROUND  0x0       /**< default console foreground color */
+#define DEFAULT_BACKGROUND  0xf0f0f0  /**< default console background color */
 typedef struct {
     uint8_t style;
 ,8 → 53,8
 } attr_idx_t;
 typedef struct {
-    uint32_t bg_color;      /**< background color */
-    uint32_t fg_color;      /**< foreground color */
+    uint32_t bg_color;  /**< background color */
+    uint32_t fg_color;  /**< foreground color */
 } attr_rgb_t;
 typedef struct {
 ,73 → 67,91
         attr_style_t s;
         attr_idx_t i;
         attr_rgb_t r;
-    } a;
+    } a;
 } attrs_t;
 /** One field on screen. It contain one character and its attributes. */
 typedef struct {
-    wchar_t character;      /**< Character itself */
-    attrs_t attrs;          /**< Character`s attributes */
+    wchar_t character;  /**< Character itself */
+    attrs_t attrs;      /**< Character attributes */
 } keyfield_t;
 /** Structure for buffering state of one virtual console.
  */
 typedef struct {
-    keyfield_t *buffer;         /**< Screen content - characters and their attributes. Used as a circular buffer. */
-    unsigned int size_x, size_y;        /**< Number of columns and rows */
-    unsigned int position_x, position_y;    /**< Coordinates of last printed character for determining cursor position */
-    attrs_t attrs;              /**< Current attributes. */
-    unsigned int top_line;          /**< Points to buffer[][] line that will be printed at screen as the first line */
-    unsigned char is_cursor_visible;    /**< Cursor state - default is visible */
+    keyfield_t *buffer;      /**< Screen content - characters and
+                                  their attributes (used as a circular buffer) */
+    size_t size_x;           /**< Number of columns  */
+    size_t size_y;           /**< Number of rows */
+    /** Coordinates of last printed character for determining cursor position */
+    size_t position_x;
+    size_t position_y;
+    attrs_t attrs;           /**< Current attributes. */
+    size_t top_line;         /**< Points to buffer[][] line that will
+                                  be printed at screen as the first line */
+    bool is_cursor_visible;  /**< Cursor state - default is visible */
 } screenbuffer_t;
-/** Returns keyfield for position on screen. Screenbuffer->buffer is cyclic buffer so we must couted in index of the topmost line.
- * @param scr   screenbuffer
- * @param x position on screen
- * @param y position on screen
- * @return  keyfield structure with character and its attributes on x,y
+/** Returns keyfield for position on screen
+ *
+ * Screenbuffer->buffer is cyclic buffer so we
+ * must couted in index of the topmost line.
+ *
+ * @param scr Screenbuffer
+ * @param x   Position on screen
+ * @param y   Position on screen
+ *
+ * @return Keyfield structure with character and its attributes on x, y
+ *
  */
-static inline keyfield_t *get_field_at(screenbuffer_t *scr, unsigned int x, unsigned int y)
+static inline keyfield_t *get_field_at(screenbuffer_t *scr, size_t x, size_t y)
 {
     return scr->buffer + x + ((y + scr->top_line) % scr->size_y) * scr->size_x;
 }
 /** Compares two sets of attributes.
- * @param s1 first style
- * @param s2 second style
- * @return nonzero on equality
+ *
+ * @param s1 First style
+ * @param s2 Second style
+ *
+ * @return Nonzero on equality
+ *
  */
 static inline int attrs_same(attrs_t a1, attrs_t a2)
 {
-    if (a1.t != a2.t) return 0;
+    if (a1.t != a2.t)
+        return 0;
     switch (a1.t) {
-    case at_style: return a1.a.s.style == a2.a.s.style;
-    case at_idx: return a1.a.i.fg_color == a2.a.i.fg_color &&
-        a1.a.i.bg_color == a2.a.i.bg_color &&
-        a1.a.i.flags == a2.a.i.flags;
-    case at_rgb: return a1.a.r.fg_color == a2.a.r.fg_color &&
-        a1.a.r.bg_color == a2.a.r.bg_color;
+    case at_style:
+        return (a1.a.s.style == a2.a.s.style);
+    case at_idx:
+        return (a1.a.i.fg_color == a2.a.i.fg_color)
+            && (a1.a.i.bg_color == a2.a.i.bg_color)
+            && (a1.a.i.flags == a2.a.i.flags);
+    case at_rgb:
+        return (a1.a.r.fg_color == a2.a.r.fg_color)
+            && (a1.a.r.bg_color == a2.a.r.bg_color);
     }
 }
 void screenbuffer_putchar(screenbuffer_t *scr, wchar_t c);
-screenbuffer_t *screenbuffer_init(screenbuffer_t *scr, int size_x, int size_y);
+screenbuffer_t *screenbuffer_init(screenbuffer_t *scr, size_t size_x, size_t size_y);
 void screenbuffer_clear(screenbuffer_t *scr);
-void screenbuffer_clear_line(screenbuffer_t *scr, unsigned int line);
+void screenbuffer_clear_line(screenbuffer_t *scr, size_t line);
 void screenbuffer_copy_buffer(screenbuffer_t *scr, keyfield_t *dest);
-void screenbuffer_goto(screenbuffer_t *scr, unsigned int x, unsigned int y);
-void screenbuffer_set_style(screenbuffer_t *scr, int style);
-void screenbuffer_set_color(screenbuffer_t *scr, unsigned int fg_color,
-    unsigned int bg_color, unsigned int attr);
-void screenbuffer_set_rgb_color(screenbuffer_t *scr, unsigned int fg_color,
-    unsigned int bg_color);
+void screenbuffer_goto(screenbuffer_t *scr, size_t x, size_t y);
+void screenbuffer_set_style(screenbuffer_t *scr, uint8_t style);
+void screenbuffer_set_color(screenbuffer_t *scr, uint8_t fg_color,
+    uint8_t bg_color, uint8_t attr);
+void screenbuffer_set_rgb_color(screenbuffer_t *scr, uint32_t fg_color,
+    uint32_t bg_color);
 #endif
 /** @}
  */

 /branches/network/uspace/srv/console/console.c
 ,7 → 27,7
  */
 /** @addtogroup console
- * @{
+ * @{
  */
 /** @file
  */
 ,96 → 36,71
 #include <fb.h>
 #include <ipc/ipc.h>
 #include <kbd.h>
-#include <kbd/keycode.h>
+#include <io/keycode.h>
 #include <ipc/fb.h>
 #include <ipc/services.h>
 #include <errno.h>
-#include <key_buffer.h>
+#include <keybuffer.h>
 #include <ipc/console.h>
 #include <unistd.h>
 #include <async.h>
-#include <libadt/fifo.h>
-#include <screenbuffer.h>
+#include <adt/fifo.h>
 #include <sys/mman.h>
 #include <stdio.h>
 #include <string.h>
 #include <sysinfo.h>
 #include <event.h>
+#include <devmap.h>
+#include <fibril_sync.h>
 #include "console.h"
 #include "gcons.h"
+#include "screenbuffer.h"
-#define MAX_KEYREQUESTS_BUFFERED 32
+#define NAME  "console"
-#define NAME "console"
+#define MAX_DEVICE_NAME  32
-/** Index of currently used virtual console.
- */
-int active_console = 0;
-int prev_console = 0;
+/** Phone to the keyboard driver. */
+static int kbd_phone;
 /** Information about framebuffer */
 struct {
-    int phone;      /**< Framebuffer phone */
-    ipcarg_t rows;      /**< Framebuffer rows */
-    ipcarg_t cols;      /**< Framebuffer columns */
+    int phone;      /**< Framebuffer phone */
+    ipcarg_t cols;  /**< Framebuffer columns */
+    ipcarg_t rows;  /**< Framebuffer rows */
 } fb_info;
 typedef struct {
-    keybuffer_t keybuffer;      /**< Buffer for incoming keys. */
-    /** Buffer for unsatisfied request for keys. */
-    FIFO_CREATE_STATIC(keyrequests, ipc_callid_t,
-        MAX_KEYREQUESTS_BUFFERED);
-    int keyrequest_counter;     /**< Number of requests in buffer. */
-    int client_phone;       /**< Phone to connected client. */
-    int used;           /**< 1 if this virtual console is
-                     * connected to some client.*/
-    screenbuffer_t screenbuffer;    /**< Screenbuffer for saving screen
-                     * contents and related settings. */
-} connection_t;
+    size_t index;             /**< Console index */
+    size_t refcount;          /**< Connection reference count */
+    dev_handle_t dev_handle;  /**< Device handle */
+    keybuffer_t keybuffer;    /**< Buffer for incoming keys. */
+    screenbuffer_t scr;       /**< Screenbuffer for saving screen
+                                   contents and related settings. */
+} console_t;
-static connection_t connections[CONSOLE_COUNT]; /**< Array of data for virtual
-                         * consoles */
-static keyfield_t *interbuffer = NULL;      /**< Pointer to memory shared
-                         * with framebufer used for
-                         * faster virtual console
-                         * switching */
+/** Array of data for virtual consoles */
+static console_t consoles[CONSOLE_COUNT];
+static console_t *active_console = &consoles[0];
+static console_t *prev_console = &consoles[0];
+static console_t *kernel_console = &consoles[KERNEL_CONSOLE];
+/** Pointer to memory shared with framebufer used for
+    faster virtual console switching */
+static keyfield_t *interbuffer = NULL;
 /** Information on row-span yet unsent to FB driver. */
 struct {
-    int row;        /**< Row where the span lies. */
-    int col;        /**< Leftmost column of the span. */
-    int n;          /**< Width of the span. */
+    size_t col;  /**< Leftmost column of the span. */
+    size_t row;  /**< Row where the span lies. */
+    size_t cnt;  /**< Width of the span. */
 } fb_pending;
-/** Size of cwrite_buf. */
-#define CWRITE_BUF_SIZE 256
+static FIBRIL_MUTEX_INITIALIZE(input_mutex);
+static FIBRIL_CONDVAR_INITIALIZE(input_cv);
-/** Buffer for receiving data via the CONSOLE_WRITE call from the client. */
-static char cwrite_buf[CWRITE_BUF_SIZE];
-static void fb_putchar(wchar_t c, int row, int col);
-/** Find unused virtual console.
- *
- */
-static int find_free_connection(void)
-{
-    int i;
-    for (i = 0; i < CONSOLE_COUNT; i++) {
-        if (!connections[i].used)
-            return i;
-    }
-    return -1;
-}
-static void clrscr(void)
-{
-    async_msg_0(fb_info.phone, FB_CLEAR);
-}
 static void curs_visibility(bool visible)
 {
     async_msg_1(fb_info.phone, FB_CURSOR_VISIBILITY, visible);
 ,11 → 111,16
     ipc_call_sync_1_0(fb_info.phone, FB_CURSOR_VISIBILITY, false);
 }
-static void curs_goto(int row, int col)
+static void curs_goto(size_t x, size_t y)
 {
-    async_msg_2(fb_info.phone, FB_CURSOR_GOTO, row, col);
+    async_msg_2(fb_info.phone, FB_CURSOR_GOTO, x, y);
 }
+static void screen_clear(void)
+{
+    async_msg_0(fb_info.phone, FB_CLEAR);
+}
 static void screen_yield(void)
 {
     ipc_call_sync_0_0(fb_info.phone, FB_SCREEN_YIELD);
 ,9 → 131,19
     ipc_call_sync_0_0(fb_info.phone, FB_SCREEN_RECLAIM);
 }
+static void kbd_yield(void)
+{
+    ipc_call_sync_0_0(kbd_phone, KBD_YIELD);
+}
+static void kbd_reclaim(void)
+{
+    ipc_call_sync_0_0(kbd_phone, KBD_RECLAIM);
+}
 static void set_style(int style)
 {
-    async_msg_1(fb_info.phone, FB_SET_STYLE, style);
+    async_msg_1(fb_info.phone, FB_SET_STYLE, style);
 }
 static void set_color(int fgcolor, int bgcolor, int flags)
 ,12 → 162,10
     case at_style:
         set_style(attrs->a.s.style);
         break;
     case at_idx:
         set_color(attrs->a.i.fg_color, attrs->a.i.bg_color,
             attrs->a.i.flags);
         break;
     case at_rgb:
         set_rgb_color(attrs->a.r.fg_color, attrs->a.r.bg_color);
         break;
 ,57 → 173,31
 }
 /** Send an area of screenbuffer to the FB driver. */
-static void fb_update_area(connection_t *conn, int x, int y, int w, int h)
+static void fb_update_area(console_t *cons, ipcarg_t x0, ipcarg_t y0, ipcarg_t width, ipcarg_t height)
 {
-    int i, j;
-    int rc;
-    attrs_t *attrs;
-    keyfield_t *field;
     if (interbuffer) {
-        for (j = 0; j < h; j++) {
-            for (i = 0; i < w; i++) {
-                interbuffer[i + j * w] =
-                    *get_field_at(&conn->screenbuffer,
-                    x + i, y + j);
+        ipcarg_t x;
+        ipcarg_t y;
+        for (y = 0; y < height; y++) {
+            for (x = 0; x < width; x++) {
+                interbuffer[y * width + x] =
+                    *get_field_at(&cons->scr, x0 + x, y0 + y);
             }
         }
-        rc = async_req_4_0(fb_info.phone, FB_DRAW_TEXT_DATA,
-            x, y, w, h);
-    } else {
-        rc = ENOTSUP;
+        async_req_4_0(fb_info.phone, FB_DRAW_TEXT_DATA,
+            x0, y0, width, height);
     }
-    if (rc != 0) {
-        /*
-        attrs = &conn->screenbuffer.attrs;
-        for (j = 0; j < h; j++) {
-            for (i = 0; i < w; i++) {
-                field = get_field_at(&conn->screenbuffer,
-                    x + i, y + j);
-                if (!attrs_same(*attrs, field->attrs))
-                    set_attrs(&field->attrs);
-                attrs = &field->attrs;
-                fb_putchar(field->character, y + j, x + i);
-            }
-        }*/
-    }
 }
 /** Flush pending cells to FB. */
 static void fb_pending_flush(void)
 {
-    screenbuffer_t *scr;
-    scr = &(connections[active_console].screenbuffer);
-    if (fb_pending.n > 0) {
-        fb_update_area(&connections[active_console], fb_pending.col,
-            fb_pending.row, fb_pending.n, 1);
-        fb_pending.n = 0;
+    if (fb_pending.cnt > 0) {
+        fb_update_area(active_console, fb_pending.col,
+            fb_pending.row, fb_pending.cnt, 1);
+        fb_pending.cnt = 0;
     }
 }
 ,167 → 205,162
  *
  * This adds the cell to the pending rowspan if possible. Otherwise
  * the old span is flushed first.
+ *
  */
-static void cell_mark_changed(int row, int col)
+static void cell_mark_changed(size_t col, size_t row)
 {
-    if (fb_pending.n != 0) {
-        if (row != fb_pending.row ||
-            col != fb_pending.col + fb_pending.n) {
+    if (fb_pending.cnt != 0) {
+        if ((col != fb_pending.col + fb_pending.cnt)
+            || (row != fb_pending.row)) {
             fb_pending_flush();
         }
     }
-    if (fb_pending.n == 0) {
+    if (fb_pending.cnt == 0) {
+        fb_pending.col = col;
         fb_pending.row = row;
-        fb_pending.col = col;
     }
-    ++fb_pending.n;
+    fb_pending.cnt++;
 }
 /** Print a character to the active VC with buffering. */
-static void fb_putchar(wchar_t c, int row, int col)
+static void fb_putchar(wchar_t c, ipcarg_t col, ipcarg_t row)
 {
-    async_msg_3(fb_info.phone, FB_PUTCHAR, c, row, col);
+    async_msg_3(fb_info.phone, FB_PUTCHAR, c, col, row);
 }
 /** Process a character from the client (TTY emulation). */
-static void write_char(int console, wchar_t ch)
+static void write_char(console_t *cons, wchar_t ch)
 {
     bool flush_cursor = false;
-    screenbuffer_t *scr = &(connections[console].screenbuffer);
     switch (ch) {
     case '\n':
         fb_pending_flush();
         flush_cursor = true;
-        scr->position_y++;
-        scr->position_x = 0;
+        cons->scr.position_y++;
+        cons->scr.position_x = 0;
         break;
     case '\r':
         break;
     case '\t':
-        scr->position_x += 8;
-        scr->position_x -= scr->position_x % 8;
+        cons->scr.position_x += 8;
+        cons->scr.position_x -= cons->scr.position_x % 8;
         break;
     case '\b':
-        if (scr->position_x == 0)
+        if (cons->scr.position_x == 0)
             break;
-        scr->position_x--;
-        if (console == active_console)
-            cell_mark_changed(scr->position_y, scr->position_x);
-        screenbuffer_putchar(scr, ' ');
+        cons->scr.position_x--;
+        if (cons == active_console)
+            cell_mark_changed(cons->scr.position_x, cons->scr.position_y);
+        screenbuffer_putchar(&cons->scr, ' ');
         break;
-    default:
-        if (console == active_console)
-            cell_mark_changed(scr->position_y, scr->position_x);
-        screenbuffer_putchar(scr, ch);
-        scr->position_x++;
+    default:
+        if (cons == active_console)
+            cell_mark_changed(cons->scr.position_x, cons->scr.position_y);
+        screenbuffer_putchar(&cons->scr, ch);
+        cons->scr.position_x++;
     }
-    if (scr->position_x >= scr->size_x) {
+    if (cons->scr.position_x >= cons->scr.size_x) {
         flush_cursor = true;
-        scr->position_y++;
+        cons->scr.position_y++;
     }
-    if (scr->position_y >= scr->size_y) {
+    if (cons->scr.position_y >= cons->scr.size_y) {
         fb_pending_flush();
-        scr->position_y = scr->size_y - 1;
-        screenbuffer_clear_line(scr, scr->top_line);
-        scr->top_line = (scr->top_line + 1) % scr->size_y;
-        if (console == active_console)
+        cons->scr.position_y = cons->scr.size_y - 1;
+        screenbuffer_clear_line(&cons->scr, cons->scr.top_line);
+        cons->scr.top_line = (cons->scr.top_line + 1) % cons->scr.size_y;
+        if (cons == active_console)
             async_msg_1(fb_info.phone, FB_SCROLL, 1);
     }
-    scr->position_x = scr->position_x % scr->size_x;
-    if (console == active_console && flush_cursor)
-        curs_goto(scr->position_y, scr->position_x);
+    if (cons == active_console && flush_cursor)
+        curs_goto(cons->scr.position_x, cons->scr.position_y);
+    cons->scr.position_x = cons->scr.position_x % cons->scr.size_x;
 }
 /** Switch to new console */
-static void change_console(int newcons)
+static void change_console(console_t *cons)
 {
-    connection_t *conn;
-    int i, j, rc;
-    keyfield_t *field;
-    attrs_t *attrs;
+    if (cons == active_console)
+        return;
-    if (newcons == active_console)
-        return;
     fb_pending_flush();
-    if (newcons == KERNEL_CONSOLE) {
+    if (cons == kernel_console) {
         async_serialize_start();
         curs_hide_sync();
         gcons_in_kernel();
         screen_yield();
+        kbd_yield();
         async_serialize_end();
         if (__SYSCALL0(SYS_DEBUG_ENABLE_CONSOLE)) {
             prev_console = active_console;
-            active_console = KERNEL_CONSOLE;
+            active_console = kernel_console;
         } else
-            newcons = active_console;
+            cons = active_console;
     }
-    if (newcons != KERNEL_CONSOLE) {
+    if (cons != kernel_console) {
+        size_t x;
+        size_t y;
+        int rc = 0;
         async_serialize_start();
-        if (active_console == KERNEL_CONSOLE) {
+        if (active_console == kernel_console) {
             screen_reclaim();
+            kbd_reclaim();
             gcons_redraw_console();
         }
-        active_console = newcons;
-        gcons_change_console(newcons);
-        conn = &connections[active_console];
+        active_console = cons;
+        gcons_change_console(cons->index);
-        set_attrs(&conn->screenbuffer.attrs);
+        set_attrs(&cons->scr.attrs);
         curs_visibility(false);
         if (interbuffer) {
-            for (j = 0; j < conn->screenbuffer.size_y; j++) {
-                for (i = 0; i < conn->screenbuffer.size_x; i++) {
-                    unsigned int size_x;
-                    size_x = conn->screenbuffer.size_x;
-                    interbuffer[j * size_x + i] =
-                        *get_field_at(&conn->screenbuffer, i, j);
+            for (y = 0; y < cons->scr.size_y; y++) {
+                for (x = 0; x < cons->scr.size_x; x++) {
+                    interbuffer[y * cons->scr.size_x + x] =
+                        *get_field_at(&cons->scr, x, y);
                 }
             }
             /* This call can preempt, but we are already at the end */
             rc = async_req_4_0(fb_info.phone, FB_DRAW_TEXT_DATA,
-, 0, conn->screenbuffer.size_x,
-                conn->screenbuffer.size_y);
+, 0, cons->scr.size_x,
+                cons->scr.size_y);
         }
         if ((!interbuffer) || (rc != 0)) {
-            set_attrs(&conn->screenbuffer.attrs);
-            clrscr();
-            attrs = &conn->screenbuffer.attrs;
+            set_attrs(&cons->scr.attrs);
+            screen_clear();
-            for (j = 0; j < conn->screenbuffer.size_y; j++)
-                for (i = 0; i < conn->screenbuffer.size_x; i++) {
-                    field = get_field_at(&conn->screenbuffer, i, j);
-                    if (!attrs_same(*attrs, field->attrs))
+            for (y = 0; y < cons->scr.size_y; y++)
+                for (x = 0; x < cons->scr.size_x; x++) {
+                    keyfield_t *field = get_field_at(&cons->scr, x, y);
+                    if (!attrs_same(cons->scr.attrs, field->attrs))
                         set_attrs(&field->attrs);
-                    attrs = &field->attrs;
+                    cons->scr.attrs = field->attrs;
                     if ((field->character == ' ') &&
-                        (attrs_same(field->attrs,
-                        conn->screenbuffer.attrs)))
+                        (attrs_same(field->attrs, cons->scr.attrs)))
                         continue;
-                    fb_putchar(field->character, j, i);
+                    fb_putchar(field->character, x, y);
                 }
         }
-        curs_goto(conn->screenbuffer.position_y,
-            conn->screenbuffer.position_x);
-        curs_visibility(conn->screenbuffer.is_cursor_visible);
+        curs_goto(cons->scr.position_x, cons->scr.position_y);
+        curs_visibility(cons->scr.is_cursor_visible);
         async_serialize_end();
     }
 ,31 → 369,19
 /** Handler for keyboard */
 static void keyboard_events(ipc_callid_t iid, ipc_call_t *icall)
 {
-    ipc_callid_t callid;
-    ipc_call_t call;
-    int retval;
-    kbd_event_t ev;
-    connection_t *conn;
-    int newcon;
-    /* Ignore parameters, the connection is alread opened */
-    while (1) {
-        callid = async_get_call(&call);
+    /* Ignore parameters, the connection is already opened */
+    while (true) {
+        ipc_call_t call;
+        ipc_callid_t callid = async_get_call(&call);
+        int retval;
+        console_event_t ev;
         switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
             /* TODO: Handle hangup */
             return;
-        case KBD_MS_LEFT:
-            newcon = gcons_mouse_btn(IPC_GET_ARG1(call));
-            if (newcon != -1)
-                change_console(newcon);
-            retval = 0;
-            break;
-        case KBD_MS_MOVE:
-            gcons_mouse_move(IPC_GET_ARG1(call),
-                IPC_GET_ARG2(call));
-            retval = 0;
-            break;
         case KBD_EVENT:
             /* Got event from keyboard driver. */
             retval = 0;
 ,30 → 390,19
             ev.mods = IPC_GET_ARG3(call);
             ev.c = IPC_GET_ARG4(call);
-            /* switch to another virtual console */
-            conn = &connections[active_console];
             if ((ev.key >= KC_F1) && (ev.key < KC_F1 +
                 CONSOLE_COUNT) && ((ev.mods & KM_CTRL) == 0)) {
-                if (ev.key == KC_F12)
-                    change_console(KERNEL_CONSOLE);
+                if (ev.key == KC_F1 + KERNEL_CONSOLE)
+                    change_console(kernel_console);
                 else
-                    change_console(ev.key - KC_F1);
+                    change_console(&consoles[ev.key - KC_F1]);
                 break;
             }
-            /* if client is awaiting key, send it */
-            if (conn->keyrequest_counter > 0) {
-                conn->keyrequest_counter--;
-                ipc_answer_4(fifo_pop(conn->keyrequests), EOK,
-                    ev.type, ev.key, ev.mods, ev.c);
-                break;
-            }
-            keybuffer_push(&conn->keybuffer, &ev);
-            retval = 0;
+            fibril_mutex_lock(&input_mutex);
+            keybuffer_push(&active_console->keybuffer, &ev);
+            fibril_condvar_broadcast(&input_cv);
+            fibril_mutex_unlock(&input_mutex);
             break;
         default:
             retval = ENOENT;
 ,62 → 411,132
     }
 }
-/** Handle CONSOLE_WRITE call. */
-static void cons_write(int consnum, ipc_callid_t rid, ipc_call_t *request)
+static void cons_write(console_t *cons, ipc_callid_t rid, ipc_call_t *request)
 {
     ipc_callid_t callid;
     size_t size;
-    wchar_t ch;
-    size_t off;
     if (!ipc_data_write_receive(&callid, &size)) {
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(rid, EINVAL);
+        return;
     }
+    char *buf = (char *) malloc(size);
+    if (buf == NULL) {
+        ipc_answer_0(callid, ENOMEM);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
+    (void) ipc_data_write_finalize(callid, buf, size);
+    async_serialize_start();
+    size_t off = 0;
+    while (off < size) {
+        wchar_t ch = str_decode(buf, &off, size);
+        write_char(cons, ch);
+    }
+    async_serialize_end();
+    gcons_notify_char(cons->index);
+    ipc_answer_1(rid, EOK, size);
+    free(buf);
+}
-    if (size > CWRITE_BUF_SIZE)
-        size = CWRITE_BUF_SIZE;
+static void cons_read(console_t *cons, ipc_callid_t rid, ipc_call_t *request)
+{
+    ipc_callid_t callid;
+    size_t size;
+    if (!ipc_data_read_receive(&callid, &size)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    char *buf = (char *) malloc(size);
+    if (buf == NULL) {
+        ipc_answer_0(callid, ENOMEM);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
+    size_t pos = 0;
+    console_event_t ev;
+    fibril_mutex_lock(&input_mutex);
+recheck:
+    while ((keybuffer_pop(&cons->keybuffer, &ev)) && (pos < size)) {
+        if (ev.type == KEY_PRESS) {
+            buf[pos] = ev.c;
+            pos++;
+        }
+    }
+    if (pos == size) {
+        (void) ipc_data_read_finalize(callid, buf, size);
+        ipc_answer_1(rid, EOK, size);
+        free(buf);
+    } else {
+        fibril_condvar_wait(&input_cv, &input_mutex);
+        goto recheck;
+    }
+    fibril_mutex_unlock(&input_mutex);
+}
-    (void) ipc_data_write_finalize(callid, cwrite_buf, size);
+static void cons_get_event(console_t *cons, ipc_callid_t rid, ipc_call_t *request)
+{
+    console_event_t ev;
-    off = 0;
-    while (off < size) {
-        ch = str_decode(cwrite_buf, &off, size);
-        write_char(consnum, ch);
+    fibril_mutex_lock(&input_mutex);
+recheck:
+    if (keybuffer_pop(&cons->keybuffer, &ev)) {
+        ipc_answer_4(rid, EOK, ev.type, ev.key, ev.mods, ev.c);
+    } else {
+        fibril_condvar_wait(&input_cv, &input_mutex);
+        goto recheck;
     }
-    gcons_notify_char(consnum);
-    ipc_answer_1(rid, EOK, size);
+    fibril_mutex_unlock(&input_mutex);
 }
 /** Default thread for new connections */
 static void client_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
-    ipc_callid_t callid;
-    ipc_call_t call;
-    int consnum;
-    ipcarg_t arg1, arg2, arg3, arg4;
-    connection_t *conn;
-    screenbuffer_t *scr;
+    console_t *cons = NULL;
-    if ((consnum = find_free_connection()) == -1) {
-        ipc_answer_0(iid, ELIMIT);
+    size_t i;
+    for (i = 0; i < CONSOLE_COUNT; i++) {
+        if (i == KERNEL_CONSOLE)
+            continue;
+        if (consoles[i].dev_handle == (dev_handle_t) IPC_GET_ARG1(*icall)) {
+            cons = &consoles[i];
+            break;
+        }
+    }
+    if (cons == NULL) {
+        ipc_answer_0(iid, ENOENT);
         return;
     }
-    conn = &connections[consnum];
-    conn->used = 1;
+    ipc_callid_t callid;
+    ipc_call_t call;
+    ipcarg_t arg1;
+    ipcarg_t arg2;
+    ipcarg_t arg3;
     async_serialize_start();
-    gcons_notify_connect(consnum);
-    conn->client_phone = IPC_GET_ARG5(*icall);
-    screenbuffer_clear(&conn->screenbuffer);
-    if (consnum == active_console)
-        clrscr();
+    if (cons->refcount == 0)
+        gcons_notify_connect(cons->index);
+    cons->refcount++;
     /* Accept the connection */
     ipc_answer_0(iid, EOK);
-    while (1) {
+    while (true) {
         async_serialize_end();
         callid = async_get_call(&call);
         async_serialize_start();
 ,62 → 544,55
         arg1 = 0;
         arg2 = 0;
         arg3 = 0;
-        arg4 = 0;
         switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
-            gcons_notify_disconnect(consnum);
-            /* Answer all pending requests */
-            while (conn->keyrequest_counter > 0) {
-                conn->keyrequest_counter--;
-                ipc_answer_0(fifo_pop(conn->keyrequests),
-                    ENOENT);
-                break;
+            cons->refcount--;
+            if (cons->refcount == 0)
+                gcons_notify_disconnect(cons->index);
+            return;
+        case VFS_READ:
+            async_serialize_end();
+            cons_read(cons, callid, &call);
+            async_serialize_start();
+            continue;
+        case VFS_WRITE:
+            async_serialize_end();
+            cons_write(cons, callid, &call);
+            async_serialize_start();
+            continue;
+        case VFS_SYNC:
+            fb_pending_flush();
+            if (cons == active_console) {
+                async_req_0_0(fb_info.phone, FB_FLUSH);
+                curs_goto(cons->scr.position_x, cons->scr.position_y);
             }
-            conn->used = 0;
-            return;
-        case CONSOLE_PUTCHAR:
-            write_char(consnum, IPC_GET_ARG1(call));
-            gcons_notify_char(consnum);
             break;
-        case CONSOLE_WRITE:
-            cons_write(consnum, callid, &call);
-            continue;
         case CONSOLE_CLEAR:
             /* Send message to fb */
-            if (consnum == active_console) {
-                async_msg_0(fb_info.phone, FB_CLEAR);
-            }
+            if (cons == active_console)
+                async_msg_0(fb_info.phone, FB_CLEAR);
-            screenbuffer_clear(&conn->screenbuffer);
+            screenbuffer_clear(&cons->scr);
             break;
         case CONSOLE_GOTO:
-            screenbuffer_goto(&conn->screenbuffer,
-                IPC_GET_ARG2(call), IPC_GET_ARG1(call));
-            if (consnum == active_console)
+            screenbuffer_goto(&cons->scr,
+                IPC_GET_ARG1(call), IPC_GET_ARG2(call));
+            if (cons == active_console)
                 curs_goto(IPC_GET_ARG1(call),
                     IPC_GET_ARG2(call));
             break;
-        case CONSOLE_GETSIZE:
-            arg1 = fb_info.rows;
-            arg2 = fb_info.cols;
+        case CONSOLE_GET_SIZE:
+            arg1 = fb_info.cols;
+            arg2 = fb_info.rows;
             break;
-        case CONSOLE_FLUSH:
-            fb_pending_flush();
-            if (consnum == active_console) {
-                async_req_0_0(fb_info.phone, FB_FLUSH);
-                scr = &(connections[consnum].screenbuffer);
-                curs_goto(scr->position_y, scr->position_x);
-            }
-            break;
         case CONSOLE_SET_STYLE:
             fb_pending_flush();
             arg1 = IPC_GET_ARG1(call);
-            screenbuffer_set_style(&conn->screenbuffer, arg1);
-            if (consnum == active_console)
+            screenbuffer_set_style(&cons->scr, arg1);
+            if (cons == active_console)
                 set_style(arg1);
             break;
         case CONSOLE_SET_COLOR:
 ,9 → 600,8
             arg1 = IPC_GET_ARG1(call);
             arg2 = IPC_GET_ARG2(call);
             arg3 = IPC_GET_ARG3(call);
-            screenbuffer_set_color(&conn->screenbuffer, arg1,
-                arg2, arg3);
-            if (consnum == active_console)
+            screenbuffer_set_color(&cons->scr, arg1, arg2, arg3);
+            if (cons == active_console)
                 set_color(arg1, arg2, arg3);
             break;
         case CONSOLE_SET_RGB_COLOR:
 ,46 → 608,27
             fb_pending_flush();
             arg1 = IPC_GET_ARG1(call);
             arg2 = IPC_GET_ARG2(call);
-            screenbuffer_set_rgb_color(&conn->screenbuffer, arg1,
-                arg2);
-            if (consnum == active_console)
+            screenbuffer_set_rgb_color(&cons->scr, arg1, arg2);
+            if (cons == active_console)
                 set_rgb_color(arg1, arg2);
             break;
         case CONSOLE_CURSOR_VISIBILITY:
             fb_pending_flush();
             arg1 = IPC_GET_ARG1(call);
-            conn->screenbuffer.is_cursor_visible = arg1;
-            if (consnum == active_console)
+            cons->scr.is_cursor_visible = arg1;
+            if (cons == active_console)
                 curs_visibility(arg1);
             break;
-        case CONSOLE_GETKEY:
-            if (keybuffer_empty(&conn->keybuffer)) {
-                /* buffer is empty -> store request */
-                if (conn->keyrequest_counter <
-                    MAX_KEYREQUESTS_BUFFERED) {
-                    fifo_push(conn->keyrequests, callid);
-                    conn->keyrequest_counter++;
-                } else {
-                    /*
-                     * No key available and too many
-                     * requests => fail.
-                    */
-                    ipc_answer_0(callid, ELIMIT);
-                }
-                continue;
-            }
-            kbd_event_t ev;
-            keybuffer_pop(&conn->keybuffer, &ev);
-            arg1 = ev.type;
-            arg2 = ev.key;
-            arg3 = ev.mods;
-            arg4 = ev.c;
-            break;
+        case CONSOLE_GET_EVENT:
+            async_serialize_end();
+            cons_get_event(cons, callid, &call);
+            async_serialize_start();
+            continue;
         case CONSOLE_KCON_ENABLE:
-            change_console(KERNEL_CONSOLE);
+            change_console(kernel_console);
             break;
         }
-        ipc_answer_4(callid, EOK, arg1, arg2, arg3, arg4);
+        ipc_answer_3(callid, EOK, arg1, arg2, arg3);
     }
 }
 ,31 → 637,23
     change_console(prev_console);
 }
-int main(int argc, char *argv[])
+static bool console_init(void)
 {
-    printf(NAME ": HelenOS Console service\n");
-    ipcarg_t phonehash;
-    int kbd_phone;
-    size_t ib_size;
-    int i;
-    async_set_client_connection(client_connection);
     /* Connect to keyboard driver */
     kbd_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_KEYBOARD, 0, 0);
     if (kbd_phone < 0) {
         printf(NAME ": Failed to connect to keyboard service\n");
-        return -1;
+        return false;
     }
+    ipcarg_t phonehash;
     if (ipc_connect_to_me(kbd_phone, SERVICE_CONSOLE, 0, 0, &phonehash) != 0) {
         printf(NAME ": Failed to create callback from keyboard service\n");
-        return -1;
+        return false;
     }
     async_new_connection(phonehash, 0, NULL, keyboard_events);
     /* Connect to framebuffer driver */
     fb_info.phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VIDEO, 0, 0);
     if (fb_info.phone < 0) {
 ,48 → 661,28
         return -1;
     }
-    /* Disable kernel output to the console */
-    __SYSCALL0(SYS_DEBUG_DISABLE_CONSOLE);
+    /* Register driver */
+    int rc = devmap_driver_register(NAME, client_connection);
+    if (rc < 0) {
+        printf(NAME ": Unable to register driver (%d)\n", rc);
+        return false;
+    }
     /* Initialize gcons */
     gcons_init(fb_info.phone);
-    /* Synchronize, the gcons can have something in queue */
+    /* Synchronize, the gcons could put something in queue */
     async_req_0_0(fb_info.phone, FB_FLUSH);
+    async_req_0_2(fb_info.phone, FB_GET_CSIZE, &fb_info.cols, &fb_info.rows);
-    async_req_0_2(fb_info.phone, FB_GET_CSIZE, &fb_info.rows,
-        &fb_info.cols);
-    set_rgb_color(DEFAULT_FOREGROUND, DEFAULT_BACKGROUND);
-    clrscr();
-    /* Init virtual consoles */
-    for (i = 0; i < CONSOLE_COUNT; i++) {
-        connections[i].used = 0;
-        keybuffer_init(&connections[i].keybuffer);
-        connections[i].keyrequests.head = 0;
-        connections[i].keyrequests.tail = 0;
-        connections[i].keyrequests.items = MAX_KEYREQUESTS_BUFFERED;
-        connections[i].keyrequest_counter = 0;
-        if (screenbuffer_init(&connections[i].screenbuffer,
-            fb_info.cols, fb_info.rows) == NULL) {
-            /* FIXME: handle error */
-            return -1;
-        }
-    }
-    connections[KERNEL_CONSOLE].used = 1;
     /* Set up shared memory buffer. */
-    ib_size = sizeof(keyfield_t) * fb_info.cols * fb_info.rows;
+    size_t ib_size = sizeof(keyfield_t) * fb_info.cols * fb_info.rows;
     interbuffer = as_get_mappable_page(ib_size);
-    fb_pending.n = 0;
     if (as_area_create(interbuffer, ib_size, AS_AREA_READ |
-        AS_AREA_WRITE | AS_AREA_CACHEABLE) != interbuffer) {
+        AS_AREA_WRITE | AS_AREA_CACHEABLE) != interbuffer)
         interbuffer = NULL;
-    }
     if (interbuffer) {
         if (ipc_share_out_start(fb_info.phone, interbuffer,
             AS_AREA_READ) != EOK) {
 ,22 → 691,62
         }
     }
+    fb_pending.cnt = 0;
+    /* Inititalize consoles */
+    size_t i;
+    for (i = 0; i < CONSOLE_COUNT; i++) {
+        if (i != KERNEL_CONSOLE) {
+            if (screenbuffer_init(&consoles[i].scr,
+                fb_info.cols, fb_info.rows) == NULL) {
+                printf(NAME ": Unable to allocate screen buffer %u\n", i);
+                return false;
+            }
+            screenbuffer_clear(&consoles[i].scr);
+            keybuffer_init(&consoles[i].keybuffer);
+            consoles[i].index = i;
+            consoles[i].refcount = 0;
+            char vc[MAX_DEVICE_NAME];
+            snprintf(vc, MAX_DEVICE_NAME, "vc%u", i);
+            if (devmap_device_register(vc, &consoles[i].dev_handle) != EOK) {
+                devmap_hangup_phone(DEVMAP_DRIVER);
+                printf(NAME ": Unable to register device %s\n", vc);
+                return false;
+            }
+        }
+    }
+    /* Disable kernel output to the console */
+    __SYSCALL0(SYS_DEBUG_DISABLE_CONSOLE);
+    /* Initialize the screen */
+    async_serialize_start();
+    gcons_redraw_console();
+    set_rgb_color(DEFAULT_FOREGROUND, DEFAULT_BACKGROUND);
+    screen_clear();
     curs_goto(0, 0);
-    curs_visibility(
-        connections[active_console].screenbuffer.is_cursor_visible);
+    curs_visibility(active_console->scr.is_cursor_visible);
+    async_serialize_end();
-    /* Register at NS */
-    if (ipc_connect_to_me(PHONE_NS, SERVICE_CONSOLE, 0, 0, &phonehash) != 0)
-        return -1;
     /* Receive kernel notifications */
     if (event_subscribe(EVENT_KCONSOLE, 0) != EOK)
         printf(NAME ": Error registering kconsole notifications\n");
     async_set_interrupt_received(interrupt_received);
-    // FIXME: avoid connectiong to itself, keep using klog
-    // printf(NAME ": Accepting connections\n");
+    return true;
+}
+int main(int argc, char *argv[])
+{
+    printf(NAME ": HelenOS Console service\n");
+    if (!console_init())
+        return -1;
+    printf(NAME ": Accepting connections\n");
     async_manager();
     return 0;

/branches/network/uspace/srv/console/gfx/anim_1.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/gfx/anim_2.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/gfx/anim_3.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/gfx/cons_has_data.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/gfx/anim_4.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/gfx/cons_selected.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/gfx/nameic.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/gfx/helenos.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/gfx/cons_idle.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/branches/network/uspace/srv/console/gfx/cons_kernel.ppm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /branches/network/uspace/srv/console/console.h
 ,7 → 27,7
  */
 /** @addtogroup console
- * @{
+ * @{
  */
 /** @file
  */
 ,11 → 35,10
 #ifndef __CONSOLE_H__
 #define __CONSOLE_H__
-#define KERNEL_CONSOLE 11
+#define CONSOLE_COUNT   12
+#define KERNEL_CONSOLE  11
-#define CONSOLE_COUNT 12
+#endif
-#endif
 /** @}
  */

 /branches/network/uspace/srv/console/screenbuffer.c
 ,44 → 27,50
  */
 /** @addtogroup console
- * @{
+ * @{
  */
 /** @file
  */
 #include <screenbuffer.h>
-#include <console/style.h>
+#include <io/style.h>
 #include <malloc.h>
 #include <unistd.h>
-/** Store one character to screenbuffer. Its position is determined by
- * scr->position_x and scr->position_y.
+/** Store one character to screenbuffer.
  *
- * @param scr   screenbuffer
- * @param c stored character
+ * Its position is determined by scr->position_x
+ * and scr->position_y.
+ *
+ * @param scr Screenbuffer
+ * @param c   Stored character
+ *
  */
 void screenbuffer_putchar(screenbuffer_t *scr, wchar_t ch)
 {
-    keyfield_t *field;
-    field = get_field_at(scr, scr->position_x, scr->position_y);
+    keyfield_t *field =
+        get_field_at(scr, scr->position_x, scr->position_y);
     field->character = ch;
     field->attrs = scr->attrs;
 }
-/** Initilize screenbuffer. Allocate space for screen content in accordance to given size.
- * @param scr       initialized screenbuffer
- * @param size_x    width in characters
- * @param size_y    height in characters
- * @return pointer to screenbuffer (same as scr parameter) or NULL
+/** Initilize screenbuffer.
+ *
+ * Allocate space for screen content in accordance to given size.
+ *
+ * @param scr    Initialized screenbuffer
+ * @param size_x Width in characters
+ * @param size_y Height in characters
+ *
+ * @return Pointer to screenbuffer (same as scr parameter) or NULL
+ *
  */
-screenbuffer_t *screenbuffer_init(screenbuffer_t *scr, int size_x, int size_y)
+screenbuffer_t *screenbuffer_init(screenbuffer_t *scr, size_t size_x, size_t size_y)
 {
     scr->buffer = (keyfield_t *) malloc(sizeof(keyfield_t) * size_x * size_y);
-    if (!scr->buffer) {
+    if (!scr->buffer)
         return NULL;
-    }
     scr->size_x = size_x;
     scr->size_y = size_y;
 ,56 → 83,63
     return scr;
 }
-/** Clear screenbuffer.
- * @param scr screenbuffer
+/** Clear screenbuffer.
+ *
+ * @param scr Screenbuffer
+ *
  */
 void screenbuffer_clear(screenbuffer_t *scr)
 {
-    unsigned int i;
+    size_t i;
     for (i = 0; i < (scr->size_x * scr->size_y); i++) {
         scr->buffer[i].character = ' ';
         scr->buffer[i].attrs = scr->attrs;
     }
     scr->top_line = 0;
+    scr->position_x = 0;
     scr->position_y = 0;
-    scr->position_x = 0;
 }
 /** Clear one buffer line.
+ *
  * @param scr
  * @param line One buffer line (not a screen line!)
+ *
  */
-void screenbuffer_clear_line(screenbuffer_t *scr, unsigned int line)
+void screenbuffer_clear_line(screenbuffer_t *scr, size_t line)
 {
-    unsigned int i;
+    size_t x;
-    for (i = 0; i < scr->size_x; i++) {
-        scr->buffer[i + line * scr->size_x].character = ' ';
-        scr->buffer[i + line * scr->size_x].attrs = scr->attrs;
+    for (x = 0; x < scr->size_x; x++) {
+        scr->buffer[x + line * scr->size_x].character = ' ';
+        scr->buffer[x + line * scr->size_x].attrs = scr->attrs;
     }
 }
 /** Copy content buffer from screenbuffer to given memory.
- * @param scr   source screenbuffer
- * @param dest  destination
+ *
+ * @param scr  Source screenbuffer
+ * @param dest Destination
+ *
  */
-void screenbuffer_copy_buffer(screenbuffer_t *scr, keyfield_t *dest)
+void screenbuffer_copy_buffer(screenbuffer_t *scr, keyfield_t *dest)
 {
-    unsigned int i;
+    size_t i;
-    for (i = 0; i < scr->size_x * scr->size_y; i++) {
+    for (i = 0; i < (scr->size_x * scr->size_y); i++)
         dest[i] = scr->buffer[i];
-    }
 }
 /** Set new cursor position in screenbuffer.
+ *
  * @param scr
  * @param x
  * @param y
+ *
  */
-void screenbuffer_goto(screenbuffer_t *scr, unsigned int x, unsigned int y)
+void screenbuffer_goto(screenbuffer_t *scr, size_t x, size_t y)
 {
     scr->position_x = x % scr->size_x;
     scr->position_y = y % scr->size_y;
 ,11 → 146,13
 }
 /** Set new style.
+ *
  * @param scr
  * @param fg_color
  * @param bg_color
+ *
  */
-void screenbuffer_set_style(screenbuffer_t *scr, int style)
+void screenbuffer_set_style(screenbuffer_t *scr, uint8_t style)
 {
     scr->attrs.t = at_style;
     scr->attrs.a.s.style = style;
 ,11 → 159,13
 }
 /** Set new color.
+ *
  * @param scr
  * @param fg_color
  * @param bg_color
+ *
  */
-void screenbuffer_set_color(screenbuffer_t *scr, unsigned int fg_color, unsigned int bg_color, unsigned int flags)
+void screenbuffer_set_color(screenbuffer_t *scr, uint8_t fg_color, uint8_t bg_color, uint8_t flags)
 {
     scr->attrs.t = at_idx;
     scr->attrs.a.i.fg_color = fg_color;
 ,11 → 174,13
 }
 /** Set new RGB color.
+ *
  * @param scr
  * @param fg_color
  * @param bg_color
+ *
  */
-void screenbuffer_set_rgb_color(screenbuffer_t *scr, unsigned int fg_color, unsigned int bg_color)
+void screenbuffer_set_rgb_color(screenbuffer_t *scr, uint32_t fg_color, uint32_t bg_color)
 {
     scr->attrs.t = at_rgb;
     scr->attrs.a.r.fg_color = fg_color;
 ,6 → 187,5
     scr->attrs.a.r.bg_color = bg_color;
 }
 /** @}
  */

 /branches/network/uspace/srv/console/gcons.c
 ,7 → 27,7
  */
 /** @addtogroup console
- * @{
+ * @{
  */
 /** @file
  */
 ,23 → 39,25
 #include <sys/mman.h>
 #include <string.h>
 #include <align.h>
+#include <bool.h>
 #include "console.h"
 #include "gcons.h"
-#define CONSOLE_TOP      66
-#define CONSOLE_MARGIN   6
+#define CONSOLE_TOP     66
+#define CONSOLE_MARGIN  6
-#define STATUS_START    110
-#define STATUS_TOP      8
-#define STATUS_SPACE    4
-#define STATUS_WIDTH    48
-#define STATUS_HEIGHT   48
+#define STATUS_START   110
+#define STATUS_TOP     8
+#define STATUS_SPACE   4
+#define STATUS_WIDTH   48
+#define STATUS_HEIGHT  48
-#define MAIN_COLOR      0xffffff
+#define MAIN_COLOR  0xffffff
-static int use_gcons = 0;
-static ipcarg_t xres,yres;
+static bool use_gcons = false;
+static ipcarg_t xres;
+static ipcarg_t yres;
 enum butstate {
     CONS_DISCONNECTED = 0,
 ,8 → 79,15
 static int ic_pixmaps[CONS_LAST] = {-1, -1, -1, -1, -1, -1};
 static int animation = -1;
-static int active_console = 0;
+static size_t active_console = 0;
+size_t mouse_x;
+size_t mouse_y;
+bool btn_pressed;
+size_t btn_x;
+size_t btn_y;
 static void vp_switch(int vp)
 {
     async_msg_1(fbphone, FB_VIEWPORT_SWITCH, vp);
 ,8 → 94,7
 }
 /** Create view port */
-static int vp_create(unsigned int x, unsigned int y, unsigned int width,
-    unsigned int height)
+static int vp_create(size_t x, size_t y, size_t width, size_t height)
 {
     return async_req_2_0(fbphone, FB_VIEWPORT_CREATE, (x << 16) | y,
         (width << 16) | height);
 ,48 → 105,52
     async_msg_0(fbphone, FB_CLEAR);
 }
-static void set_rgb_color(int fgcolor, int bgcolor)
+static void set_rgb_color(uint32_t fgcolor, uint32_t bgcolor)
 {
     async_msg_2(fbphone, FB_SET_RGB_COLOR, fgcolor, bgcolor);
 }
 /** Transparent putchar */
-static void tran_putch(char c, int row, int col)
+static void tran_putch(wchar_t ch, size_t col, size_t row)
 {
-    async_msg_3(fbphone, FB_PUTCHAR, c, row, col);
+    async_msg_3(fbphone, FB_PUTCHAR, ch, col, row);
 }
 /** Redraw the button showing state of a given console */
-static void redraw_state(int consnum)
+static void redraw_state(size_t index)
 {
-    char data[5];
-    int i;
-    enum butstate state = console_state[consnum];
-    vp_switch(cstatus_vp[consnum]);
+    vp_switch(cstatus_vp[index]);
+    enum butstate state = console_state[index];
     if (ic_pixmaps[state] != -1)
-        async_msg_2(fbphone, FB_VP_DRAW_PIXMAP, cstatus_vp[consnum],
+        async_msg_2(fbphone, FB_VP_DRAW_PIXMAP, cstatus_vp[index],
             ic_pixmaps[state]);
-    if (state != CONS_DISCONNECTED && state != CONS_KERNEL &&
-        state != CONS_DISCONNECTED_SEL) {
-        snprintf(data, 5, "%d", consnum + 1);
-        for (i = 0; data[i]; i++)
-            tran_putch(data[i], 1, 2 + i);
-    }
+    if ((state != CONS_DISCONNECTED) && (state != CONS_KERNEL)
+        && (state != CONS_DISCONNECTED_SEL)) {
+        char data[5];
+        snprintf(data, 5, "%u", index + 1);
+        size_t i;
+        for (i = 0; data[i] != 0; i++)
+            tran_putch(data[i], 2 + i, 1);
+    }
 }
 /** Notification run on changing console (except kernel console) */
-void gcons_change_console(int consnum)
+void gcons_change_console(size_t index)
 {
-    int i;
     if (!use_gcons)
         return;
     if (active_console == KERNEL_CONSOLE) {
+        size_t i;
         for (i = 0; i < CONSOLE_COUNT; i++)
             redraw_state(i);
         if (animation != -1)
             async_msg_1(fbphone, FB_ANIM_START, animation);
     } else {
 ,71 → 158,74
             console_state[active_console] = CONS_DISCONNECTED;
         else
             console_state[active_console] = CONS_IDLE;
         redraw_state(active_console);
     }
-    active_console = consnum;
-    if (console_state[consnum] == CONS_DISCONNECTED) {
-        console_state[consnum] = CONS_DISCONNECTED_SEL;
-        redraw_state(consnum);
-    } else
-        console_state[consnum] = CONS_SELECTED;
-    redraw_state(consnum);
+    active_console = index;
+    if ((console_state[index] == CONS_DISCONNECTED)
+        || (console_state[index] == CONS_DISCONNECTED_SEL))
+        console_state[index] = CONS_DISCONNECTED_SEL;
+    else
+        console_state[index] = CONS_SELECTED;
+    redraw_state(index);
     vp_switch(console_vp);
 }
 /** Notification function that gets called on new output to virtual console */
-void gcons_notify_char(int consnum)
+void gcons_notify_char(size_t index)
 {
     if (!use_gcons)
         return;
-    if (consnum == active_console ||
-        console_state[consnum] == CONS_HAS_DATA)
+    if ((index == active_console)
+        || (console_state[index] == CONS_HAS_DATA))
         return;
-    console_state[consnum] = CONS_HAS_DATA;
+    console_state[index] = CONS_HAS_DATA;
     if (active_console == KERNEL_CONSOLE)
         return;
-    redraw_state(consnum);
+    redraw_state(index);
     vp_switch(console_vp);
 }
 /** Notification function called on service disconnect from console */
-void gcons_notify_disconnect(int consnum)
+void gcons_notify_disconnect(size_t index)
 {
     if (!use_gcons)
         return;
-    if (active_console == consnum)
-        console_state[consnum] = CONS_DISCONNECTED_SEL;
+    if (index == active_console)
+        console_state[index] = CONS_DISCONNECTED_SEL;
     else
-        console_state[consnum] = CONS_DISCONNECTED;
+        console_state[index] = CONS_DISCONNECTED;
     if (active_console == KERNEL_CONSOLE)
         return;
-    redraw_state(consnum);
+    redraw_state(index);
     vp_switch(console_vp);
 }
 /** Notification function called on console connect */
-void gcons_notify_connect(int consnum)
+void gcons_notify_connect(size_t index)
 {
     if (!use_gcons)
         return;
-    if (active_console == consnum)
-        console_state[consnum] = CONS_SELECTED;
+    if (index == active_console)
+        console_state[index] = CONS_SELECTED;
     else
-        console_state[consnum] = CONS_IDLE;
+        console_state[index] = CONS_IDLE;
     if (active_console == KERNEL_CONSOLE)
         return;
-    redraw_state(consnum);
+    redraw_state(index);
     vp_switch(console_vp);
 }
 ,29 → 239,28
     vp_switch(0);
 }
-/** Return x, where left <= x <= right && |a-x|==min(|a-x|) is smallest */
-static inline int limit(int a,int left, int right)
+/** Return x, where left <= x <= right && |a-x| == min(|a-x|) is smallest */
+static inline int limit(size_t a, size_t left, size_t right)
 {
     if (a < left)
         a = left;
     if (a >= right)
         a = right - 1;
     return a;
 }
-int mouse_x, mouse_y;
-int btn_pressed, btn_x, btn_y;
 /** Handle mouse move
  *
  * @param dx Delta X of mouse move
  * @param dy Delta Y of mouse move
  */
-void gcons_mouse_move(int dx, int dy)
+void gcons_mouse_move(ssize_t dx, ssize_t dy)
 {
     mouse_x = limit(mouse_x + dx, 0, xres);
     mouse_y = limit(mouse_y + dy, 0, yres);
     async_msg_2(fbphone, FB_POINTER_MOVE, mouse_x, mouse_y);
 }
 ,8 → 267,8
 static int gcons_find_conbut(int x, int y)
 {
     int status_start = STATUS_START + (xres - 800) / 2;
-    if (y < STATUS_TOP || y >= STATUS_TOP + STATUS_HEIGHT)
+    if ((y < STATUS_TOP) || (y >= STATUS_TOP + STATUS_HEIGHT))
         return -1;
     if (x < status_start)
 ,28 → 284,31
 /** Handle mouse click
  *
- * @param state New state (1-pressed, 0-depressed)
+ * @param state New state (true - pressed, false - depressed)
  */
-int gcons_mouse_btn(int state)
+int gcons_mouse_btn(bool state)
 {
     int conbut;
     if (state) {
         conbut = gcons_find_conbut(mouse_x, mouse_y);
         if (conbut != -1) {
-            btn_pressed = 1;
+            btn_pressed = true;
             btn_x = mouse_x;
             btn_y = mouse_y;
         }
         return -1;
-    }
-    if (!state && !btn_pressed)
+    }
+    if ((!state) && (!btn_pressed))
         return -1;
-    btn_pressed = 0;
+    btn_pressed = false;
     conbut = gcons_find_conbut(mouse_x, mouse_y);
     if (conbut == gcons_find_conbut(btn_x, btn_y))
         return conbut;
     return -1;
 }
 ,35 → 324,40
 {
     char *shm;
     int rc;
     /* Create area */
     shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED |
         MAP_ANONYMOUS, 0, 0);
     if (shm == MAP_FAILED)
         return;
     memcpy(shm, logo, size);
     /* Send area */
     rc = async_req_1_0(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm);
     if (rc)
         goto exit;
     rc = ipc_share_out_start(fbphone, shm, PROTO_READ);
     if (rc)
         goto drop;
     /* Draw logo */
     async_msg_2(fbphone, FB_DRAW_PPM, x, y);
 drop:
     /* Drop area */
     async_msg_0(fbphone, FB_DROP_SHM);
-exit:
+exit:
     /* Remove area */
     munmap(shm, size);
 }
-extern char _binary_helenos_ppm_start[0];
-extern int _binary_helenos_ppm_size;
-extern char _binary_nameic_ppm_start[0];
-extern int _binary_nameic_ppm_size;
+extern char _binary_gfx_helenos_ppm_start[0];
+extern int _binary_gfx_helenos_ppm_size;
+extern char _binary_gfx_nameic_ppm_start[0];
+extern int _binary_gfx_nameic_ppm_size;
 /** Redraws console graphics */
 void gcons_redraw_console(void)
 ,13 → 370,14
     vp_switch(0);
     set_rgb_color(MAIN_COLOR, MAIN_COLOR);
     clear();
-    draw_pixmap(_binary_helenos_ppm_start,
-        (size_t) &_binary_helenos_ppm_size, xres - 66, 2);
-    draw_pixmap(_binary_nameic_ppm_start,
-        (size_t) &_binary_nameic_ppm_size, 5, 17);
+    draw_pixmap(_binary_gfx_helenos_ppm_start,
+        (size_t) &_binary_gfx_helenos_ppm_size, xres - 66, 2);
+    draw_pixmap(_binary_gfx_nameic_ppm_start,
+        (size_t) &_binary_gfx_nameic_ppm_size, 5, 17);
     for (i = 0; i < CONSOLE_COUNT; i++)
         redraw_state(i);
     vp_switch(console_vp);
 }
 ,102 → 385,102
  *
  * @param data PPM data
  * @param size PPM data size
+ *
  * @return Pixmap identification
+ *
  */
-static int make_pixmap(char *data, int size)
+static int make_pixmap(char *data, size_t size)
 {
     char *shm;
     int rc;
     int pxid = -1;
     /* Create area */
     shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED |
         MAP_ANONYMOUS, 0, 0);
     if (shm == MAP_FAILED)
         return -1;
     memcpy(shm, data, size);
     /* Send area */
     rc = async_req_1_0(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm);
     if (rc)
         goto exit;
     rc = ipc_share_out_start(fbphone, shm, PROTO_READ);
     if (rc)
         goto drop;
     /* Obtain pixmap */
     rc = async_req_0_0(fbphone, FB_SHM2PIXMAP);
     if (rc < 0)
         goto drop;
     pxid = rc;
 drop:
     /* Drop area */
     async_msg_0(fbphone, FB_DROP_SHM);
-exit:
+exit:
     /* Remove area */
     munmap(shm, size);
     return pxid;
 }
-extern char _binary_anim_1_ppm_start[0];
-extern int _binary_anim_1_ppm_size;
-extern char _binary_anim_2_ppm_start[0];
-extern int _binary_anim_2_ppm_size;
-extern char _binary_anim_3_ppm_start[0];
-extern int _binary_anim_3_ppm_size;
-extern char _binary_anim_4_ppm_start[0];
-extern int _binary_anim_4_ppm_size;
+extern char _binary_gfx_anim_1_ppm_start[0];
+extern int _binary_gfx_anim_1_ppm_size;
+extern char _binary_gfx_anim_2_ppm_start[0];
+extern int _binary_gfx_anim_2_ppm_size;
+extern char _binary_gfx_anim_3_ppm_start[0];
+extern int _binary_gfx_anim_3_ppm_size;
+extern char _binary_gfx_anim_4_ppm_start[0];
+extern int _binary_gfx_anim_4_ppm_size;
 static void make_anim(void)
 {
-    int an;
-    int pm;
-    an = async_req_1_0(fbphone, FB_ANIM_CREATE, cstatus_vp[KERNEL_CONSOLE]);
+    int an = async_req_1_0(fbphone, FB_ANIM_CREATE, cstatus_vp[KERNEL_CONSOLE]);
     if (an < 0)
         return;
-    pm = make_pixmap(_binary_anim_1_ppm_start,
-        (int) &_binary_anim_1_ppm_size);
+    int pm = make_pixmap(_binary_gfx_anim_1_ppm_start,
+        (int) &_binary_gfx_anim_1_ppm_size);
     async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
-    pm = make_pixmap(_binary_anim_2_ppm_start,
-        (int) &_binary_anim_2_ppm_size);
+    pm = make_pixmap(_binary_gfx_anim_2_ppm_start,
+        (int) &_binary_gfx_anim_2_ppm_size);
     async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
-    pm = make_pixmap(_binary_anim_3_ppm_start,
-        (int) &_binary_anim_3_ppm_size);
+    pm = make_pixmap(_binary_gfx_anim_3_ppm_start,
+        (int) &_binary_gfx_anim_3_ppm_size);
     async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
-    pm = make_pixmap(_binary_anim_4_ppm_start,
-        (int) &_binary_anim_4_ppm_size);
+    pm = make_pixmap(_binary_gfx_anim_4_ppm_start,
+        (int) &_binary_gfx_anim_4_ppm_size);
     async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
     async_msg_1(fbphone, FB_ANIM_START, an);
     animation = an;
 }
-extern char _binary_cons_selected_ppm_start[0];
-extern int _binary_cons_selected_ppm_size;
-extern char _binary_cons_idle_ppm_start[0];
-extern int _binary_cons_idle_ppm_size;
-extern char _binary_cons_has_data_ppm_start[0];
-extern int _binary_cons_has_data_ppm_size;
-extern char _binary_cons_kernel_ppm_start[0];
-extern int _binary_cons_kernel_ppm_size;
+extern char _binary_gfx_cons_selected_ppm_start[0];
+extern int _binary_gfx_cons_selected_ppm_size;
+extern char _binary_gfx_cons_idle_ppm_start[0];
+extern int _binary_gfx_cons_idle_ppm_size;
+extern char _binary_gfx_cons_has_data_ppm_start[0];
+extern int _binary_gfx_cons_has_data_ppm_size;
+extern char _binary_gfx_cons_kernel_ppm_start[0];
+extern int _binary_gfx_cons_kernel_ppm_size;
 /** Initialize nice graphical console environment */
 void gcons_init(int phone)
 {
-    int rc;
-    int i;
-    int status_start = STATUS_START;
     fbphone = phone;
-    rc = async_req_0_2(phone, FB_GET_RESOLUTION, &xres, &yres);
+    int rc = async_req_0_2(phone, FB_GET_RESOLUTION, &xres, &yres);
     if (rc)
         return;
 ,22 → 487,27
     if ((xres < 800) || (yres < 600))
         return;
-    /* create console viewport */
+    /* Create console viewport */
     /* Align width & height to character size */
     console_vp = vp_create(CONSOLE_MARGIN, CONSOLE_TOP,
         ALIGN_DOWN(xres - 2 * CONSOLE_MARGIN, 8),
         ALIGN_DOWN(yres - (CONSOLE_TOP + CONSOLE_MARGIN), 16));
     if (console_vp < 0)
         return;
     /* Create status buttons */
-    status_start += (xres - 800) / 2;
+    size_t status_start = STATUS_START + (xres - 800) / 2;
+    size_t i;
     for (i = 0; i < CONSOLE_COUNT; i++) {
         cstatus_vp[i] = vp_create(status_start + CONSOLE_MARGIN +
             i * (STATUS_WIDTH + STATUS_SPACE), STATUS_TOP,
             STATUS_WIDTH, STATUS_HEIGHT);
         if (cstatus_vp[i] < 0)
             return;
         vp_switch(cstatus_vp[i]);
         set_rgb_color(0x202020, 0xffffff);
     }
 ,26 → 514,29
     /* Initialize icons */
     ic_pixmaps[CONS_SELECTED] =
-        make_pixmap(_binary_cons_selected_ppm_start,
-        (int) &_binary_cons_selected_ppm_size);
-    ic_pixmaps[CONS_IDLE] = make_pixmap(_binary_cons_idle_ppm_start,
-        (int) &_binary_cons_idle_ppm_size);
+        make_pixmap(_binary_gfx_cons_selected_ppm_start,
+        (size_t) &_binary_gfx_cons_selected_ppm_size);
+    ic_pixmaps[CONS_IDLE] =
+        make_pixmap(_binary_gfx_cons_idle_ppm_start,
+        (size_t) &_binary_gfx_cons_idle_ppm_size);
     ic_pixmaps[CONS_HAS_DATA] =
-        make_pixmap(_binary_cons_has_data_ppm_start,
-        (int) &_binary_cons_has_data_ppm_size);
+        make_pixmap(_binary_gfx_cons_has_data_ppm_start,
+        (size_t) &_binary_gfx_cons_has_data_ppm_size);
     ic_pixmaps[CONS_DISCONNECTED] =
-        make_pixmap(_binary_cons_idle_ppm_start,
-        (int) &_binary_cons_idle_ppm_size);
-    ic_pixmaps[CONS_KERNEL] = make_pixmap(_binary_cons_kernel_ppm_start,
-        (int) &_binary_cons_kernel_ppm_size);
+        make_pixmap(_binary_gfx_cons_idle_ppm_start,
+        (size_t) &_binary_gfx_cons_idle_ppm_size);
+    ic_pixmaps[CONS_KERNEL] =
+        make_pixmap(_binary_gfx_cons_kernel_ppm_start,
+        (size_t) &_binary_gfx_cons_kernel_ppm_size);
     ic_pixmaps[CONS_DISCONNECTED_SEL] = ic_pixmaps[CONS_SELECTED];
     make_anim();
-    use_gcons = 1;
+    use_gcons = true;
     console_state[0] = CONS_DISCONNECTED_SEL;
     console_state[KERNEL_CONSOLE] = CONS_KERNEL;
-    gcons_redraw_console();
+    vp_switch(console_vp);
 }
 /** @}

 /branches/network/uspace/srv/console/Makefile
 ,23 → 42,29
 #
 OUTPUT = console
 GENERIC_SOURCES = \
     console.c \
     screenbuffer.c \
-    ../kbd/generic/key_buffer.c \
+    ../kbd/generic/keybuffer.c \
     gcons.c
-IMAGES = helenos.ppm nameic.ppm cons_selected.ppm cons_idle.ppm \
-    cons_has_data.ppm cons_kernel.ppm anim_1.ppm anim_2.ppm anim_3.ppm \
-    anim_4.ppm
+IMAGES = \
+    gfx/helenos.ppm \
+    gfx/nameic.ppm \
+    gfx/cons_selected.ppm \
+    gfx/cons_idle.ppm \
+    gfx/cons_has_data.ppm \
+    gfx/cons_kernel.ppm \
+    gfx/anim_1.ppm \
+    gfx/anim_2.ppm \
+    gfx/anim_3.ppm \
+    gfx/anim_4.ppm
-ARCH_SOURCES =
 GENERIC_OBJECTS := $(addsuffix .o,$(basename $(GENERIC_SOURCES))) \
-            $(addsuffix .o,$(basename $(IMAGES)))
-ARCH_OBJECTS := $(addsuffix .o,$(basename $(ARCH_SOURCES)))
+    $(addsuffix .o,$(basename $(IMAGES)))
-OBJECTS := $(GENERIC_OBJECTS) $(ARCH_OBJECTS)
+OBJECTS := $(GENERIC_OBJECTS)
 .PHONY: all clean depend disasm
 ,7 → 84,7
 disasm: $(OUTPUT).disasm
 $(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
+    $(OBJDUMP) -d $< > $@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/network/uspace/srv/bd/rd/rd.c
 ,0 → 1,241
+/*
+ * Copyright (c) 2007 Michal Konopa
+ * Copyright (c) 2007 Martin Jelen
+ * Copyright (c) 2007 Peter Majer
+ * Copyright (c) 2007 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup rd
+ * @{
+ */
+/**
+ * @file    rd.c
+ * @brief   Initial RAM disk for HelenOS.
+ */
+#include <ipc/ipc.h>
+#include <ipc/services.h>
+#include <ipc/ns.h>
+#include <sysinfo.h>
+#include <as.h>
+#include <ddi.h>
+#include <align.h>
+#include <bool.h>
+#include <errno.h>
+#include <async.h>
+#include <align.h>
+#include <async.h>
+#include <fibril_sync.h>
+#include <stdio.h>
+#include <devmap.h>
+#include <ipc/bd.h>
+#define NAME "rd"
+/** Pointer to the ramdisk's image. */
+static void *rd_addr;
+/** Size of the ramdisk. */
+static size_t rd_size;
+/**
+ * This rwlock protects the ramdisk's data.
+ * If we were to serve multiple requests (read + write or several writes)
+ * concurrently (i.e. from two or more threads), each read and write needs to be
+ * protected by this rwlock.
+ */
+fibril_rwlock_t rd_lock;
+/** Handle one connection to ramdisk.
+ *
+ * @param iid       Hash of the request that opened the connection.
+ * @param icall     Call data of the request that opened the connection.
+ */
+static void rd_connection(ipc_callid_t iid, ipc_call_t *icall)
+{
+    ipc_callid_t callid;
+    ipc_call_t call;
+    int retval;
+    void *fs_va = NULL;
+    off_t offset;
+    size_t block_size;
+    size_t maxblock_size;
+    /*
+     * Answer the first IPC_M_CONNECT_ME_TO call.
+     */
+    ipc_answer_0(iid, EOK);
+    /*
+     * Now we wait for the client to send us its communication as_area.
+     */
+    int flags;
+    if (ipc_share_out_receive(&callid, &maxblock_size, &flags)) {
+        fs_va = as_get_mappable_page(maxblock_size);
+        if (fs_va) {
+            (void) ipc_share_out_finalize(callid, fs_va);
+        } else {
+            ipc_answer_0(callid, EHANGUP);
+            return;
+        }
+    } else {
+        /*
+         * The client doesn't speak the same protocol.
+         * At this point we can't handle protocol variations.
+         * Close the connection.
+         */
+        ipc_answer_0(callid, EHANGUP);
+        return;
+    }
+    while (true) {
+        callid = async_get_call(&call);
+        switch (IPC_GET_METHOD(call)) {
+        case IPC_M_PHONE_HUNGUP:
+            /*
+             * The other side has hung up.
+             * Answer the message and exit the fibril.
+             */
+            ipc_answer_0(callid, EOK);
+            return;
+        case BD_READ_BLOCK:
+            offset = IPC_GET_ARG1(call);
+            block_size = IPC_GET_ARG2(call);
+            if (block_size > maxblock_size) {
+                /*
+                 * Maximum block size exceeded.
+                 */
+                retval = ELIMIT;
+                break;
+            }
+            if (offset * block_size > rd_size - block_size) {
+                /*
+                 * Reading past the end of the device.
+                 */
+                retval = ELIMIT;
+                break;
+            }
+            fibril_rwlock_read_lock(&rd_lock);
+            memcpy(fs_va, rd_addr + offset * block_size, block_size);
+            fibril_rwlock_read_unlock(&rd_lock);
+            retval = EOK;
+            break;
+        case BD_WRITE_BLOCK:
+            offset = IPC_GET_ARG1(call);
+            block_size = IPC_GET_ARG2(call);
+            if (block_size > maxblock_size) {
+                /*
+                 * Maximum block size exceeded.
+                 */
+                retval = ELIMIT;
+                break;
+            }
+            if (offset * block_size > rd_size - block_size) {
+                /*
+                 * Writing past the end of the device.
+                 */
+                retval = ELIMIT;
+                break;
+            }
+            fibril_rwlock_write_lock(&rd_lock);
+            memcpy(rd_addr + offset * block_size, fs_va, block_size);
+            fibril_rwlock_write_unlock(&rd_lock);
+            retval = EOK;
+            break;
+        default:
+            /*
+             * The client doesn't speak the same protocol.
+             * Instead of closing the connection, we just ignore
+             * the call. This can be useful if the client uses a
+             * newer version of the protocol.
+             */
+            retval = EINVAL;
+            break;
+        }
+        ipc_answer_0(callid, retval);
+    }
+}
+/** Prepare the ramdisk image for operation. */
+static bool rd_init(void)
+{
+    rd_size = sysinfo_value("rd.size");
+    void *rd_ph_addr = (void *) sysinfo_value("rd.address.physical");
+    if (rd_size == 0) {
+        printf(NAME ": No RAM disk found\n");
+        return false;
+    }
+    rd_addr = as_get_mappable_page(rd_size);
+    int flags = AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE;
+    int retval = physmem_map(rd_ph_addr, rd_addr,
+        ALIGN_UP(rd_size, PAGE_SIZE) >> PAGE_WIDTH, flags);
+    if (retval < 0) {
+        printf(NAME ": Error mapping RAM disk\n");
+        return false;
+    }
+    printf(NAME ": Found RAM disk at %p, %d bytes\n", rd_ph_addr, rd_size);
+    int rc = devmap_driver_register(NAME, rd_connection);
+    if (rc < 0) {
+        printf(NAME ": Unable to register driver (%d)\n", rc);
+        return false;
+    }
+    dev_handle_t dev_handle;
+    if (devmap_device_register("initrd", &dev_handle) != EOK) {
+        devmap_hangup_phone(DEVMAP_DRIVER);
+        printf(NAME ": Unable to register device\n");
+        return false;
+    }
+    fibril_rwlock_initialize(&rd_lock);
+    return true;
+}
+int main(int argc, char **argv)
+{
+    printf(NAME ": HelenOS RAM disk server\n");
+    if (!rd_init())
+        return -1;
+    printf(NAME ": Accepting connections\n");
+    async_manager();
+    /* Never reached */
+    return 0;
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/bd/rd/Makefile
 ,0 → 1,76
+#
+# Copyright (c) 2006 Martin Decky
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+## Setup toolchain
+#
+LIBC_PREFIX = ../../../lib/libc
+SOFTINT_PREFIX = ../../../lib/softint
+include $(LIBC_PREFIX)/Makefile.toolchain
+LIBS = $(LIBC_PREFIX)/libc.a
+## Sources
+#
+OUTPUT = rd
+SOURCES = \
+    rd.c
+OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
+.PHONY: all clean depend disasm
+all: $(OUTPUT) $(OUTPUT).disasm
+-include Makefile.depend
+clean:
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
+depend:
+    $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
+$(OUTPUT): $(OBJECTS) $(LIBS)
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< > $@
+%.o: %.S
+    $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@
+%.o: %.s
+    $(AS) $(AFLAGS) $< -o $@
+%.o: %.c
+    $(CC) $(DEFS) $(CFLAGS) -c $< -o $@

 /branches/network/uspace/srv/bd/file_bd/file_bd.c
 ,0 → 1,213
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup bd
+ * @{
+ */
+/**
+ * @file
+ * @brief File-backed block device driver
+ *
+ * Allows accessing a file as a block device. Useful for, e.g., mounting
+ * a disk image.
+ */
+#include <stdio.h>
+#include <unistd.h>
+#include <ipc/ipc.h>
+#include <ipc/bd.h>
+#include <async.h>
+#include <as.h>
+#include <fibril_sync.h>
+#include <devmap.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <bool.h>
+#define NAME "file_bd"
+static size_t comm_size;
+static FILE *img;
+static dev_handle_t dev_handle;
+static fibril_mutex_t dev_lock;
+static int file_bd_init(const char *fname);
+static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
+static int file_bd_read(off_t blk_idx, size_t size, void *buf);
+static int file_bd_write(off_t blk_idx, size_t size, void *buf);
+int main(int argc, char **argv)
+{
+    int rc;
+    printf(NAME ": File-backed block device driver\n");
+    if (argc != 3) {
+        printf("Expected two arguments (image name, device name).\n");
+        return -1;
+    }
+    if (file_bd_init(argv[1]) != EOK)
+        return -1;
+    rc = devmap_device_register(argv[2], &dev_handle);
+    if (rc != EOK) {
+        devmap_hangup_phone(DEVMAP_DRIVER);
+        printf(NAME ": Unable to register device %s.\n",
+            argv[2]);
+        return rc;
+    }
+    printf(NAME ": Accepting connections\n");
+    async_manager();
+    /* Not reached */
+    return 0;
+}
+static int file_bd_init(const char *fname)
+{
+    int rc;
+    rc = devmap_driver_register(NAME, file_bd_connection);
+    if (rc < 0) {
+        printf(NAME ": Unable to register driver.\n");
+        return rc;
+    }
+    img = fopen(fname, "rb+");
+    if (img == NULL)
+        return EINVAL;
+    fibril_mutex_initialize(&dev_lock);
+    return EOK;
+}
+static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall)
+{
+    void *fs_va = NULL;
+    ipc_callid_t callid;
+    ipc_call_t call;
+    ipcarg_t method;
+    int flags;
+    int retval;
+    off_t idx;
+    size_t size;
+    /* Answer the IPC_M_CONNECT_ME_TO call. */
+    ipc_answer_0(iid, EOK);
+    if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
+        ipc_answer_0(callid, EHANGUP);
+        return;
+    }
+    fs_va = as_get_mappable_page(comm_size);
+    if (fs_va == NULL) {
+        ipc_answer_0(callid, EHANGUP);
+        return;
+    }
+    (void) ipc_share_out_finalize(callid, fs_va);
+    while (1) {
+        callid = async_get_call(&call);
+        method = IPC_GET_METHOD(call);
+        switch (method) {
+        case IPC_M_PHONE_HUNGUP:
+            /* The other side has hung up. */
+            ipc_answer_0(callid, EOK);
+            return;
+        case BD_READ_BLOCK:
+        case BD_WRITE_BLOCK:
+            idx = IPC_GET_ARG1(call);
+            size = IPC_GET_ARG2(call);
+            if (size > comm_size) {
+                retval = EINVAL;
+                break;
+            }
+            if (method == BD_READ_BLOCK)
+                retval = file_bd_read(idx, size, fs_va);
+            else
+                retval = file_bd_write(idx, size, fs_va);
+            break;
+        default:
+            retval = EINVAL;
+            break;
+        }
+        ipc_answer_0(callid, retval);
+    }
+}
+static int file_bd_read(off_t blk_idx, size_t size, void *buf)
+{
+    size_t n_rd;
+    fibril_mutex_lock(&dev_lock);
+    fseek(img, blk_idx * size, SEEK_SET);
+    n_rd = fread(buf, 1, size, img);
+    if (ferror(img)) {
+        fibril_mutex_unlock(&dev_lock);
+        return EIO; /* Read error */
+    }
+    fibril_mutex_unlock(&dev_lock);
+    if (n_rd < size)
+        return EINVAL;  /* Read beyond end of disk */
+    return EOK;
+}
+static int file_bd_write(off_t blk_idx, size_t size, void *buf)
+{
+    size_t n_wr;
+    fibril_mutex_lock(&dev_lock);
+    fseek(img, blk_idx * size, SEEK_SET);
+    n_wr = fread(buf, 1, size, img);
+    if (ferror(img) || n_wr < size) {
+        fibril_mutex_unlock(&dev_lock);
+        return EIO; /* Write error */
+    }
+    fibril_mutex_unlock(&dev_lock);
+    return EOK;
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/bd/file_bd/Makefile
 ,0 → 1,76
+#
+# Copyright (c) 2006 Martin Decky
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+## Setup toolchain
+#
+LIBC_PREFIX = ../../../lib/libc
+SOFTINT_PREFIX = ../../../lib/softint
+include $(LIBC_PREFIX)/Makefile.toolchain
+LIBS = $(LIBC_PREFIX)/libc.a
+## Sources
+#
+OUTPUT = file_bd
+SOURCES = \
+    file_bd.c
+OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
+.PHONY: all clean depend disasm
+all: $(OUTPUT) $(OUTPUT).disasm
+-include Makefile.depend
+clean:
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
+depend:
+    $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
+$(OUTPUT): $(OBJECTS) $(LIBS)
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< > $@
+%.o: %.S
+    $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@
+%.o: %.s
+    $(AS) $(AFLAGS) $< -o $@
+%.o: %.c
+    $(CC) $(DEFS) $(CFLAGS) -c $< -o $@

 /branches/network/uspace/srv/bd/gxe_bd/gxe_bd.c
 ,0 → 1,308
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup bd
+ * @{
+ */
+/**
+ * @file
+ * @brief GXemul disk driver
+ */
+#include <stdio.h>
+#include <libarch/ddi.h>
+#include <ddi.h>
+#include <ipc/ipc.h>
+#include <ipc/bd.h>
+#include <async.h>
+#include <as.h>
+#include <fibril_sync.h>
+#include <devmap.h>
+#include <sys/types.h>
+#include <errno.h>
+#define NAME "gxe_bd"
+enum {
+    CTL_READ_START  = 0,
+    CTL_WRITE_START = 1,
+};
+enum {
+    STATUS_FAILURE  = 0
+};
+enum {
+    MAX_DISKS   = 2
+};
+typedef struct {
+    uint32_t offset_lo;
+    uint32_t pad0;
+    uint32_t offset_hi;
+    uint32_t pad1;
+    uint32_t disk_id;
+    uint32_t pad2[3];
+    uint32_t control;
+    uint32_t pad3[3];
+    uint32_t status;
+    uint32_t pad4[3];
+    uint8_t pad5[0x3fc0];
+    uint8_t buffer[512];
+} gxe_bd_t;
+static const size_t block_size = 512;
+static size_t comm_size;
+static uintptr_t dev_physical = 0x13000000;
+static gxe_bd_t *dev;
+static dev_handle_t dev_handle[MAX_DISKS];
+static fibril_mutex_t dev_lock[MAX_DISKS];
+static int gxe_bd_init(void);
+static void gxe_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
+static int gx_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size,
+    void *buf);
+static int gxe_bd_read_block(int disk_id, uint64_t offset, size_t size,
+    void *buf);
+static int gxe_bd_write_block(int disk_id, uint64_t offset, size_t size,
+    const void *buf);
+int main(int argc, char **argv)
+{
+    printf(NAME ": GXemul disk driver\n");
+    if (gxe_bd_init() != EOK)
+        return -1;
+    printf(NAME ": Accepting connections\n");
+    async_manager();
+    /* Not reached */
+    return 0;
+}
+static int gxe_bd_init(void)
+{
+    void *vaddr;
+    int rc, i;
+    char name[16];
+    rc = devmap_driver_register(NAME, gxe_bd_connection);
+    if (rc < 0) {
+        printf(NAME ": Unable to register driver.\n");
+        return rc;
+    }
+    rc = pio_enable((void *) dev_physical, sizeof(gxe_bd_t), &vaddr);
+    if (rc != EOK) {
+        printf(NAME ": Could not initialize device I/O space.\n");
+        return rc;
+    }
+    dev = vaddr;
+    for (i = 0; i < MAX_DISKS; i++) {
+        snprintf(name, 16, "disk%d", i);
+        rc = devmap_device_register(name, &dev_handle[i]);
+        if (rc != EOK) {
+            devmap_hangup_phone(DEVMAP_DRIVER);
+            printf(NAME ": Unable to register device %s.\n",
+                name);
+            return rc;
+        }
+        fibril_mutex_initialize(&dev_lock[i]);
+    }
+    return EOK;
+}
+static void gxe_bd_connection(ipc_callid_t iid, ipc_call_t *icall)
+{
+    void *fs_va = NULL;
+    ipc_callid_t callid;
+    ipc_call_t call;
+    ipcarg_t method;
+    dev_handle_t dh;
+    int flags;
+    int retval;
+    off_t idx;
+    size_t size;
+    int disk_id, i;
+    /* Get the device handle. */
+    dh = IPC_GET_ARG1(*icall);
+    /* Determine which disk device is the client connecting to. */
+    disk_id = -1;
+    for (i = 0; i < MAX_DISKS; i++)
+        if (dev_handle[i] == dh)
+            disk_id = i;
+    if (disk_id < 0) {
+        ipc_answer_0(iid, EINVAL);
+        return;
+    }
+    /* Answer the IPC_M_CONNECT_ME_TO call. */
+    ipc_answer_0(iid, EOK);
+    if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
+        ipc_answer_0(callid, EHANGUP);
+        return;
+    }
+    fs_va = as_get_mappable_page(comm_size);
+    if (fs_va == NULL) {
+        ipc_answer_0(callid, EHANGUP);
+        return;
+    }
+    (void) ipc_share_out_finalize(callid, fs_va);
+    while (1) {
+        callid = async_get_call(&call);
+        method = IPC_GET_METHOD(call);
+        switch (method) {
+        case IPC_M_PHONE_HUNGUP:
+            /* The other side has hung up. */
+            ipc_answer_0(callid, EOK);
+            return;
+        case BD_READ_BLOCK:
+        case BD_WRITE_BLOCK:
+            idx = IPC_GET_ARG1(call);
+            size = IPC_GET_ARG2(call);
+            if (size > comm_size) {
+                retval = EINVAL;
+                break;
+            }
+            retval = gx_bd_rdwr(disk_id, method, idx * size,
+                size, fs_va);
+            break;
+        default:
+            retval = EINVAL;
+            break;
+        }
+        ipc_answer_0(callid, retval);
+    }
+}
+static int gx_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size,
+    void *buf)
+{
+    int rc;
+    size_t now;
+    while (size > 0) {
+        now = size < block_size ? size : block_size;
+        if (method == BD_READ_BLOCK)
+            rc = gxe_bd_read_block(disk_id, offset, now, buf);
+        else
+            rc = gxe_bd_write_block(disk_id, offset, now, buf);
+        if (rc != EOK)
+            return rc;
+        buf += block_size;
+        offset += block_size;
+        if (size > block_size)
+            size -= block_size;
+        else
+            size = 0;
+    }
+    return EOK;
+}
+static int gxe_bd_read_block(int disk_id, uint64_t offset, size_t size,
+    void *buf)
+{
+    uint32_t status;
+    size_t i;
+    uint32_t w;
+    fibril_mutex_lock(&dev_lock[disk_id]);
+    pio_write_32(&dev->offset_lo, (uint32_t) offset);
+    pio_write_32(&dev->offset_hi, offset >> 32);
+    pio_write_32(&dev->disk_id, disk_id);
+    pio_write_32(&dev->control, CTL_READ_START);
+    status = pio_read_32(&dev->status);
+    if (status == STATUS_FAILURE) {
+        fibril_mutex_unlock(&dev_lock[disk_id]);
+        return EIO;
+    }
+    for (i = 0; i < size; i++) {
+        ((uint8_t *) buf)[i] = w = pio_read_8(&dev->buffer[i]);
+    }
+    fibril_mutex_unlock(&dev_lock[disk_id]);
+    return EOK;
+}
+static int gxe_bd_write_block(int disk_id, uint64_t offset, size_t size,
+    const void *buf)
+{
+    uint32_t status;
+    size_t i;
+    for (i = 0; i < size; i++) {
+        pio_write_8(&dev->buffer[i], ((const uint8_t *) buf)[i]);
+    }
+    fibril_mutex_lock(&dev_lock[disk_id]);
+    pio_write_32(&dev->offset_lo, (uint32_t) offset);
+    pio_write_32(&dev->offset_hi, offset >> 32);
+    pio_write_32(&dev->disk_id, disk_id);
+    pio_write_32(&dev->control, CTL_WRITE_START);
+    status = pio_read_32(&dev->status);
+    if (status == STATUS_FAILURE) {
+        fibril_mutex_unlock(&dev_lock[disk_id]);
+        return EIO;
+    }
+    fibril_mutex_unlock(&dev_lock[disk_id]);
+    return EOK;
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/bd/gxe_bd/Makefile
 ,0 → 1,76
+#
+# Copyright (c) 2006 Martin Decky
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+## Setup toolchain
+#
+LIBC_PREFIX = ../../../lib/libc
+SOFTINT_PREFIX = ../../../lib/softint
+include $(LIBC_PREFIX)/Makefile.toolchain
+LIBS = $(LIBC_PREFIX)/libc.a
+## Sources
+#
+OUTPUT = gxe_bd
+SOURCES = \
+    gxe_bd.c
+OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
+.PHONY: all clean depend disasm
+all: $(OUTPUT) $(OUTPUT).disasm
+-include Makefile.depend
+clean:
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
+depend:
+    $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
+$(OUTPUT): $(OBJECTS) $(LIBS)
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< > $@
+%.o: %.S
+    $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@
+%.o: %.s
+    $(AS) $(AFLAGS) $< -o $@
+%.o: %.c
+    $(CC) $(DEFS) $(CFLAGS) -c $< -o $@

 /branches/network/uspace/srv/bd/ata_bd/ata_bd.h
 ,0 → 1,151
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup bd
+ * @{
+ */
+/** @file
+ */
+#ifndef __ATA_BD_H__
+#define __ATA_BD_H__
+#include <sys/types.h>
+#include <fibril_sync.h>
+enum {
+    CTL_READ_START  = 0,
+    CTL_WRITE_START = 1,
+};
+enum {
+    STATUS_FAILURE  = 0
+};
+enum {
+    MAX_DISKS   = 2
+};
+/** ATA Command Register Block. */
+typedef union {
+    /* Read/Write */
+    struct {
+        uint16_t data_port;
+        uint8_t sector_count;
+        uint8_t sector_number;
+        uint8_t cylinder_low;
+        uint8_t cylinder_high;
+        uint8_t drive_head;
+        uint8_t pad_rw0;
+    };
+    /* Read Only */
+    struct {
+        uint8_t pad_ro0;
+        uint8_t error;
+        uint8_t pad_ro1[5];
+        uint8_t status;
+    };
+    /* Write Only */
+    struct {
+        uint8_t pad_wo0;
+        uint8_t features;
+        uint8_t pad_wo1[5];
+        uint8_t command;
+    };
+} ata_cmd_t;
+typedef union {
+    /* Read */
+    struct {
+        uint8_t pad0[6];
+        uint8_t alt_status;
+        uint8_t drive_address;
+    };
+    /* Write */
+    struct {
+        uint8_t pad1[6];
+        uint8_t device_control;
+        uint8_t pad2;
+    };
+} ata_ctl_t;
+enum devctl_bits {
+    DCR_SRST    = 0x04, /**< Software Reset */
+    DCR_nIEN    = 0x02  /**< Interrupt Enable (negated) */
+};
+enum status_bits {
+    SR_BSY      = 0x80, /**< Busy */
+    SR_DRDY     = 0x40, /**< Drive Ready */
+    SR_DWF      = 0x20, /**< Drive Write Fault */
+    SR_DSC      = 0x10, /**< Drive Seek Complete */
+    SR_DRQ      = 0x08, /**< Data Request */
+    SR_CORR     = 0x04, /**< Corrected Data */
+    SR_IDX      = 0x02, /**< Index */
+    SR_ERR      = 0x01  /**< Error */
+};
+enum drive_head_bits {
+    DHR_DRV     = 0x10
+};
+enum error_bits {
+    ER_BBK      = 0x80, /**< Bad Block Detected */
+    ER_UNC      = 0x40, /**< Uncorrectable Data Error */
+    ER_MC       = 0x20, /**< Media Changed */
+    ER_IDNF     = 0x10, /**< ID Not Found */
+    ER_MCR      = 0x08, /**< Media Change Request */
+    ER_ABRT     = 0x04, /**< Aborted Command */
+    ER_TK0NF    = 0x02, /**< Track 0 Not Found */
+    ER_AMNF     = 0x01  /**< Address Mark Not Found */
+};
+enum ata_command {
+    CMD_IDENTIFY_DRIVE  = 0xEC,
+    CMD_READ_SECTORS    = 0x20,
+    CMD_WRITE_SECTORS   = 0x30
+};
+typedef struct {
+    bool present;
+    unsigned heads;
+    unsigned cylinders;
+    unsigned sectors;
+    uint64_t blocks;
+    fibril_mutex_t lock;
+    dev_handle_t dev_handle;
+} disk_t;
+#endif
+/** @}
+ */

 /branches/network/uspace/srv/bd/ata_bd/ata_bd.c
 ,0 → 1,438
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup bd
+ * @{
+ */
+/**
+ * @file
+ * @brief ATA disk driver
+ *
+ * This driver currently works only with CHS addressing and uses PIO.
+ * Currently based on the (now obsolete) ANSI X3.221-1994 (ATA-1) standard.
+ * At this point only reading is possible, not writing.
+ *
+ * The driver services a single controller which can have up to two disks
+ * attached.
+ */
+#include <stdio.h>
+#include <libarch/ddi.h>
+#include <ddi.h>
+#include <ipc/ipc.h>
+#include <ipc/bd.h>
+#include <async.h>
+#include <as.h>
+#include <fibril_sync.h>
+#include <devmap.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <bool.h>
+#include "ata_bd.h"
+#define NAME "ata_bd"
+static const size_t block_size = 512;
+static size_t comm_size;
+static uintptr_t cmd_physical = 0x1f0;
+static uintptr_t ctl_physical = 0x170;
+static ata_cmd_t *cmd;
+static ata_ctl_t *ctl;
+/** Per-disk state. */
+static disk_t disk[MAX_DISKS];
+static int ata_bd_init(void);
+static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
+static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size,
+    void *buf);
+static int ata_bd_read_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
+    void *buf);
+static int ata_bd_write_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
+    const void *buf);
+static int drive_identify(int drive_id, disk_t *d);
+int main(int argc, char **argv)
+{
+    uint8_t status;
+    char name[16];
+    int i, rc;
+    int n_disks;
+    printf(NAME ": ATA disk driver\n");
+    printf("I/O address 0x%x\n", cmd_physical);
+    if (ata_bd_init() != EOK)
+        return -1;
+    /* Put drives to reset, disable interrupts. */
+    printf("Reset drives...\n");
+    pio_write_8(&ctl->device_control, DCR_SRST);
+    /* FIXME: Find out how to do this properly. */
+    async_usleep(100);
+    pio_write_8(&ctl->device_control, 0);
+    do {
+        status = pio_read_8(&cmd->status);
+    } while ((status & SR_BSY) != 0);
+    printf("Done\n");
+    printf("Status = 0x%x\n", pio_read_8(&cmd->status));
+    (void) drive_identify(0, &disk[0]);
+    (void) drive_identify(1, &disk[1]);
+    n_disks = 0;
+    for (i = 0; i < MAX_DISKS; i++) {
+        /* Skip unattached drives. */
+        if (disk[i].present == false)
+            continue;
+        snprintf(name, 16, "disk%d", i);
+        rc = devmap_device_register(name, &disk[i].dev_handle);
+        if (rc != EOK) {
+            devmap_hangup_phone(DEVMAP_DRIVER);
+            printf(NAME ": Unable to register device %s.\n",
+                name);
+            return rc;
+        }
+        ++n_disks;
+    }
+    if (n_disks == 0) {
+        printf("No disks detected.\n");
+        return -1;
+    }
+    printf(NAME ": Accepting connections\n");
+    async_manager();
+    /* Not reached */
+    return 0;
+}
+static int drive_identify(int disk_id, disk_t *d)
+{
+    uint16_t data;
+    uint8_t status;
+    size_t i;
+    printf("Identify drive %d\n", disk_id);
+    pio_write_8(&cmd->drive_head, ((disk_id != 0) ? DHR_DRV : 0));
+    async_usleep(100);
+    pio_write_8(&cmd->command, CMD_IDENTIFY_DRIVE);
+    status = pio_read_8(&cmd->status);
+    printf("Status = 0x%x\n", status);
+    d->present = false;
+    /*
+     * Detect if drive is present. This is Qemu only! Need to
+     * do the right thing to work with real drives.
+     */
+    if ((status & SR_DRDY) == 0) {
+        printf("None attached.\n");
+        return ENOENT;
+    }
+    for (i = 0; i < block_size / 2; i++) {
+        do {
+            status = pio_read_8(&cmd->status);
+        } while ((status & SR_DRDY) == 0);
+        data = pio_read_16(&cmd->data_port);
+        switch (i) {
+        case 1: d->cylinders = data; break;
+        case 3: d->heads = data; break;
+        case 6: d->sectors = data; break;
+        }
+    }
+    d->blocks = d->cylinders * d->heads * d->sectors;
+    printf("Geometry: %u cylinders, %u heads, %u sectors\n",
+        d->cylinders, d->heads, d->sectors);
+    d->present = true;
+    fibril_mutex_initialize(&d->lock);
+    return EOK;
+}
+static int ata_bd_init(void)
+{
+    void *vaddr;
+    int rc;
+    rc = devmap_driver_register(NAME, ata_bd_connection);
+    if (rc < 0) {
+        printf(NAME ": Unable to register driver.\n");
+        return rc;
+    }
+    rc = pio_enable((void *) cmd_physical, sizeof(ata_cmd_t), &vaddr);
+    if (rc != EOK) {
+        printf(NAME ": Could not initialize device I/O space.\n");
+        return rc;
+    }
+    cmd = vaddr;
+    rc = pio_enable((void *) ctl_physical, sizeof(ata_ctl_t), &vaddr);
+    if (rc != EOK) {
+        printf(NAME ": Could not initialize device I/O space.\n");
+        return rc;
+    }
+    ctl = vaddr;
+    return EOK;
+}
+static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall)
+{
+    void *fs_va = NULL;
+    ipc_callid_t callid;
+    ipc_call_t call;
+    ipcarg_t method;
+    dev_handle_t dh;
+    int flags;
+    int retval;
+    off_t idx;
+    size_t size;
+    int disk_id, i;
+    /* Get the device handle. */
+    dh = IPC_GET_ARG1(*icall);
+    /* Determine which disk device is the client connecting to. */
+    disk_id = -1;
+    for (i = 0; i < MAX_DISKS; i++)
+        if (disk[i].dev_handle == dh)
+            disk_id = i;
+    if (disk_id < 0 || disk[disk_id].present == false) {
+        ipc_answer_0(iid, EINVAL);
+        return;
+    }
+    /* Answer the IPC_M_CONNECT_ME_TO call. */
+    ipc_answer_0(iid, EOK);
+    if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
+        ipc_answer_0(callid, EHANGUP);
+        return;
+    }
+    fs_va = as_get_mappable_page(comm_size);
+    if (fs_va == NULL) {
+        ipc_answer_0(callid, EHANGUP);
+        return;
+    }
+    (void) ipc_share_out_finalize(callid, fs_va);
+    while (1) {
+        callid = async_get_call(&call);
+        method = IPC_GET_METHOD(call);
+        switch (method) {
+        case IPC_M_PHONE_HUNGUP:
+            /* The other side has hung up. */
+            ipc_answer_0(callid, EOK);
+            return;
+        case BD_READ_BLOCK:
+        case BD_WRITE_BLOCK:
+            idx = IPC_GET_ARG1(call);
+            size = IPC_GET_ARG2(call);
+            if (size > comm_size) {
+                retval = EINVAL;
+                break;
+            }
+            retval = ata_bd_rdwr(disk_id, method, idx,
+                size, fs_va);
+            break;
+        default:
+            retval = EINVAL;
+            break;
+        }
+        ipc_answer_0(callid, retval);
+    }
+}
+static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t blk_idx, size_t size,
+    void *buf)
+{
+    int rc;
+    size_t now;
+    while (size > 0) {
+        now = size < block_size ? size : block_size;
+        if (now != block_size)
+            return EINVAL;
+        if (method == BD_READ_BLOCK)
+            rc = ata_bd_read_block(disk_id, blk_idx, 1, buf);
+        else
+            rc = ata_bd_write_block(disk_id, blk_idx, 1, buf);
+        if (rc != EOK)
+            return rc;
+        buf += block_size;
+        blk_idx++;
+        if (size > block_size)
+            size -= block_size;
+        else
+            size = 0;
+    }
+    return EOK;
+}
+static int ata_bd_read_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
+    void *buf)
+{
+    size_t i;
+    uint16_t data;
+    uint8_t status;
+    uint64_t c, h, s;
+    uint64_t idx;
+    uint8_t drv_head;
+    disk_t *d;
+    d = &disk[disk_id];
+    /* Check device bounds. */
+    if (blk_idx >= d->blocks)
+        return EINVAL;
+    /* Compute CHS. */
+    c = blk_idx / (d->heads * d->sectors);
+    idx = blk_idx % (d->heads * d->sectors);
+    h = idx / d->sectors;
+    s = 1 + (idx % d->sectors);
+    /* New value for Drive/Head register */
+    drv_head =
+        ((disk_id != 0) ? DHR_DRV : 0) |
+        (h & 0x0f);
+    fibril_mutex_lock(&d->lock);
+    /* Program a Read Sectors operation. */
+    pio_write_8(&cmd->drive_head, drv_head);
+    pio_write_8(&cmd->sector_count, 1);
+    pio_write_8(&cmd->sector_number, s);
+    pio_write_8(&cmd->cylinder_low, c & 0xff);
+    pio_write_8(&cmd->cylinder_high, c >> 16);
+    pio_write_8(&cmd->command, CMD_READ_SECTORS);
+    /* Read data from the disk buffer. */
+    for (i = 0; i < block_size / 2; i++) {
+        do {
+            status = pio_read_8(&cmd->status);
+        } while ((status & SR_DRDY) == 0);
+        data = pio_read_16(&cmd->data_port);
+        ((uint16_t *) buf)[i] = data;
+    }
+    fibril_mutex_unlock(&d->lock);
+    return EOK;
+}
+static int ata_bd_write_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
+    const void *buf)
+{
+    size_t i;
+    uint8_t status;
+    uint64_t c, h, s;
+    uint64_t idx;
+    uint8_t drv_head;
+    disk_t *d;
+    d = &disk[disk_id];
+    /* Check device bounds. */
+    if (blk_idx >= d->blocks)
+        return EINVAL;
+    /* Compute CHS. */
+    c = blk_idx / (d->heads * d->sectors);
+    idx = blk_idx % (d->heads * d->sectors);
+    h = idx / d->sectors;
+    s = 1 + (idx % d->sectors);
+    /* New value for Drive/Head register */
+    drv_head =
+        ((disk_id != 0) ? DHR_DRV : 0) |
+        (h & 0x0f);
+    fibril_mutex_lock(&d->lock);
+    /* Program a Read Sectors operation. */
+    pio_write_8(&cmd->drive_head, drv_head);
+    pio_write_8(&cmd->sector_count, 1);
+    pio_write_8(&cmd->sector_number, s);
+    pio_write_8(&cmd->cylinder_low, c & 0xff);
+    pio_write_8(&cmd->cylinder_high, c >> 16);
+    pio_write_8(&cmd->command, CMD_WRITE_SECTORS);
+    /* Write data to the disk buffer. */
+    for (i = 0; i < block_size / 2; i++) {
+        do {
+            status = pio_read_8(&cmd->status);
+        } while ((status & SR_DRDY) == 0);
+        pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
+    }
+    fibril_mutex_unlock(&d->lock);
+    return EOK;
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/bd/ata_bd/Makefile
 ,0 → 1,76
+#
+# Copyright (c) 2006 Martin Decky
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+## Setup toolchain
+#
+LIBC_PREFIX = ../../../lib/libc
+SOFTINT_PREFIX = ../../../lib/softint
+include $(LIBC_PREFIX)/Makefile.toolchain
+LIBS = $(LIBC_PREFIX)/libc.a
+## Sources
+#
+OUTPUT = ata_bd
+SOURCES = \
+    ata_bd.c
+OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
+.PHONY: all clean depend disasm
+all: $(OUTPUT) $(OUTPUT).disasm
+-include Makefile.depend
+clean:
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
+depend:
+    $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
+$(OUTPUT): $(OBJECTS) $(LIBS)
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< > $@
+%.o: %.S
+    $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@
+%.o: %.s
+    $(AS) $(AFLAGS) $< -o $@
+%.o: %.c
+    $(CC) $(DEFS) $(CFLAGS) -c $< -o $@

 /branches/network/uspace/srv/loader/main.c
 ,9 → 53,9
 #include <ipc/services.h>
 #include <ipc/loader.h>
 #include <loader/pcb.h>
-#include <console.h>
 #include <errno.h>
 #include <async.h>
+#include <string.h>
 #include <as.h>
 #include <elf.h>
 ,6 → 76,13
 /** Buffer holding all arguments */
 static char *arg_buf = NULL;
+/** Number of preset files */
+static int filc = 0;
+/** Preset files vector */
+static fdi_node_t **filv = NULL;
+/** Buffer holding all preset files */
+static fdi_node_t *fil_buf = NULL;
 static elf_info_t prog_info;
 static elf_info_t interp_info;
 ,7 → 91,7
 /** Used to limit number of connections to one. */
 static bool connected;
-static void loader_get_taskid(ipc_callid_t rid, ipc_call_t *request)
+static void ldr_get_taskid(ipc_callid_t rid, ipc_call_t *request)
 {
     ipc_callid_t callid;
     task_id_t task_id;
 ,7 → 118,7
  * @param rid
  * @param request
  */
-static void loader_set_pathname(ipc_callid_t rid, ipc_call_t *request)
+static void ldr_set_pathname(ipc_callid_t rid, ipc_call_t *request)
 {
     ipc_callid_t callid;
     size_t len;
 ,7 → 154,7
  * @param rid
  * @param request
  */
-static void loader_set_args(ipc_callid_t rid, ipc_call_t *request)
+static void ldr_set_args(ipc_callid_t rid, ipc_call_t *request)
 {
     ipc_callid_t callid;
     size_t buf_size, arg_size;
 ,6 → 227,70
     ipc_answer_0(rid, EOK);
 }
+/** Receive a call setting preset files of the program to execute.
+ *
+ * @param rid
+ * @param request
+ */
+static void ldr_set_files(ipc_callid_t rid, ipc_call_t *request)
+{
+    ipc_callid_t callid;
+    size_t buf_size;
+    if (!ipc_data_write_receive(&callid, &buf_size)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    if ((buf_size % sizeof(fdi_node_t)) != 0) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    if (fil_buf != NULL) {
+        free(fil_buf);
+        fil_buf = NULL;
+    }
+    if (filv != NULL) {
+        free(filv);
+        filv = NULL;
+    }
+    fil_buf = malloc(buf_size);
+    if (!fil_buf) {
+        ipc_answer_0(callid, ENOMEM);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
+    ipc_data_write_finalize(callid, fil_buf, buf_size);
+    int count = buf_size / sizeof(fdi_node_t);
+    /* Allocate filvv */
+    filv = malloc((count + 1) * sizeof(fdi_node_t *));
+    if (filv == NULL) {
+        free(fil_buf);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
+    /*
+     * Fill filv with argument pointers
+     */
+    int i;
+    for (i = 0; i < count; i++)
+        filv[i] = &fil_buf[i];
+    filc = count;
+    filv[count] = NULL;
+    ipc_answer_0(rid, EOK);
+}
 /** Load the previously selected program.
  *
  * @param rid
 ,12 → 297,12
  * @param request
  * @return 0 on success, !0 on error.
  */
-static int loader_load(ipc_callid_t rid, ipc_call_t *request)
+static int ldr_load(ipc_callid_t rid, ipc_call_t *request)
 {
     int rc;
     rc = elf_load_file(pathname, 0, &prog_info);
-    if (rc < 0) {
+    if (rc != EE_OK) {
         DPRINTF("Failed to load executable '%s'.\n", pathname);
         ipc_answer_0(rid, EINVAL);
         return 1;
 ,6 → 313,9
     pcb.argc = argc;
     pcb.argv = argv;
+    pcb.filc = filc;
+    pcb.filv = filv;
     if (prog_info.interp == NULL) {
         /* Statically linked program */
         is_dyn_linked = false;
 ,7 → 324,7
     }
     rc = elf_load_file(prog_info.interp, 0, &interp_info);
-    if (rc < 0) {
+    if (rc != EE_OK) {
         DPRINTF("Failed to load interpreter '%s.'\n",
             prog_info.interp);
         ipc_answer_0(rid, EINVAL);
 ,7 → 344,7
  * @param request
  * @return 0 on success, !0 on error.
  */
-static void loader_run(ipc_callid_t rid, ipc_call_t *request)
+static void ldr_run(ipc_callid_t rid, ipc_call_t *request)
 {
     const char *cp;
 ,17 → 357,15
         /* Dynamically linked program */
         DPRINTF("Run ELF interpreter.\n");
         DPRINTF("Entry point: 0x%lx\n", interp_info.entry);
-        console_close();
         ipc_answer_0(rid, EOK);
         elf_run(&interp_info, &pcb);
     } else {
         /* Statically linked program */
-        console_close();
         ipc_answer_0(rid, EOK);
         elf_run(&prog_info, &pcb);
-    }
+    }
     /* Not reached */
 }
 ,7 → 374,7
  * Receive and carry out commands (of which the last one should be
  * to execute the loaded program).
  */
-static void loader_connection(ipc_callid_t iid, ipc_call_t *icall)
+static void ldr_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
     ipc_callid_t callid;
     ipc_call_t call;
 ,19 → 402,22
         case IPC_M_PHONE_HUNGUP:
             exit(0);
         case LOADER_GET_TASKID:
-            loader_get_taskid(callid, &call);
+            ldr_get_taskid(callid, &call);
             continue;
         case LOADER_SET_PATHNAME:
-            loader_set_pathname(callid, &call);
+            ldr_set_pathname(callid, &call);
             continue;
         case LOADER_SET_ARGS:
-            loader_set_args(callid, &call);
+            ldr_set_args(callid, &call);
             continue;
+        case LOADER_SET_FILES:
+            ldr_set_files(callid, &call);
+            continue;
         case LOADER_LOAD:
-            loader_load(callid, &call);
+            ldr_load(callid, &call);
             continue;
         case LOADER_RUN:
-            loader_run(callid, &call);
+            ldr_run(callid, &call);
             /* Not reached */
         default:
             retval = ENOENT;
 ,7 → 441,7
     connected = false;
     /* Set a handler of incomming connections. */
-    async_set_client_connection(loader_connection);
+    async_set_client_connection(ldr_connection);
     /* Register at naming service. */
     if (ipc_connect_to_me(PHONE_NS, SERVICE_LOAD, 0, 0, &phonead) != 0)

 /branches/network/uspace/srv/loader/elf_load.c
 ,7 → 74,7
 static int load_segment(elf_ld_t *elf, elf_segment_header_t *entry);
 /** Read until the buffer is read in its entirety. */
-static int my_read(int fd, char *buf, size_t len)
+static int my_read(int fd, void *buf, size_t len)
 {
     int cnt = 0;
     do {
 ,21 → 331,26
     int flags = 0;
     uintptr_t bias;
     uintptr_t base;
+    void *seg_ptr;
+    uintptr_t seg_addr;
     size_t mem_sz;
     int rc;
-    DPRINTF("Load segment at addr 0x%x, size 0x%x\n", entry->p_vaddr,
-        entry->p_memsz);
     bias = elf->bias;
+    seg_addr = entry->p_vaddr + bias;
+    seg_ptr = (void *) seg_addr;
+    DPRINTF("Load segment at addr 0x%x, size 0x%x\n", seg_addr,
+        entry->p_memsz);
     if (entry->p_align > 1) {
         if ((entry->p_offset % entry->p_align) !=
-            (entry->p_vaddr % entry->p_align)) {
+            (seg_addr % entry->p_align)) {
             DPRINTF("Align check 1 failed offset%%align=%d, "
                 "vaddr%%align=%d\n",
                 entry->p_offset % entry->p_align,
-                entry->p_vaddr % entry->p_align
+                seg_addr % entry->p_align
             );
             return EE_INVALID;
         }
 ,7 → 369,7
     base = ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE);
     mem_sz = entry->p_memsz + (entry->p_vaddr - base);
-    DPRINTF("Map to p_vaddr=0x%x-0x%x.\n", entry->p_vaddr + bias,
+    DPRINTF("Map to seg_addr=0x%x-0x%x.\n", seg_addr,
     entry->p_vaddr + bias + ALIGN_UP(entry->p_memsz, PAGE_SIZE));
     /*
 ,7 → 384,7
     }
     DPRINTF("as_area_create(0x%lx, 0x%x, %d) -> 0x%lx\n",
-        entry->p_vaddr+bias, entry->p_memsz, flags, (uintptr_t)a);
+        base + bias, mem_sz, flags, (uintptr_t)a);
     /*
      * Load segment data
 ,7 → 404,7
     uint8_t *dp;
     left = entry->p_filesz;
-    dp = (uint8_t *)(entry->p_vaddr + bias);
+    dp = seg_ptr;
     while (left > 0) {
         now = 16384;
 ,7 → 421,7
         dp += now;
     }
-    rc = as_area_change_flags((uint8_t *)entry->p_vaddr + bias, flags);
+    rc = as_area_change_flags(seg_ptr, flags);
     if (rc != 0) {
         DPRINTF("Failed to set memory area flags.\n");
         return EE_MEMORY;
 ,7 → 429,7
     if (flags & AS_AREA_EXEC) {
         /* Enforce SMC coherence for the segment */
-        if (smc_coherence(entry->p_vaddr + bias, entry->p_filesz))
+        if (smc_coherence(seg_ptr, entry->p_filesz))
             return EE_MEMORY;
     }

/branches/network/uspace/srv/loader/arch/ia32/ia32.s
46,4 → 46,4
# Save a tiny bit of stack space
pop %ebp

jmp %eax
jmp *%eax

 /branches/network/uspace/srv/fb/ega.h
 ,10 → 27,10
  */
 /** @addtogroup egafb
- * @brief   HelenOS EGA framebuffer.
+ * @brief HelenOS EGA framebuffer.
  * @ingroup fbs
  * @{
- */
+ */
 /** @file
  */
 ,4 → 43,3
 /** @}
  */

 /branches/network/uspace/srv/fb/serial_console.c
 ,8 → 43,9
 #include <ipc/fb.h>
 #include <bool.h>
 #include <errno.h>
-#include <console/color.h>
-#include <console/style.h>
+#include <io/color.h>
+#include <io/style.h>
+#include <string.h>
 #include "../console/screenbuffer.h"
 #include "main.h"
 ,9 → 129,9
 }
-void serial_goto(const unsigned int row, const unsigned int col)
+void serial_goto(const unsigned int col, const unsigned int row)
 {
-    if ((row > scr_height) || (col > scr_width))
+    if ((col > scr_width) || (row > scr_height))
         return;
     char control[MAX_CONTROL];
 ,7 → 154,7
 void serial_scroll(int i)
 {
     if (i > 0) {
-        serial_goto(scr_height - 1, 0);
+        serial_goto(0, scr_height - 1);
         while (i--)
             serial_puts("\033D");
     } else if (i < 0) {
 ,17 → 236,24
     if (fgcolor < bgcolor)
         serial_sgr(SGR_REVERSE_OFF);
     else
-        serial_sgr(SGR_REVERSE);
+        serial_sgr(SGR_REVERSE);
 }
 static void serial_set_attrs(const attrs_t *a)
 {
     switch (a->t) {
-    case at_style: serial_set_style(a->a.s.style); break;
-    case at_rgb: serial_set_rgb(a->a.r.fg_color, a->a.r.bg_color); break;
-    case at_idx: serial_set_idx(a->a.i.fg_color,
-        a->a.i.bg_color, a->a.i.flags); break;
-    default: break;
+    case at_style:
+        serial_set_style(a->a.s.style);
+        break;
+    case at_rgb:
+        serial_set_rgb(a->a.r.fg_color, a->a.r.bg_color);
+        break;
+    case at_idx:
+        serial_set_idx(a->a.i.fg_color,
+            a->a.i.bg_color, a->a.i.flags);
+        break;
+    default:
+        break;
     }
 }
 ,13 → 273,13
     keyfield_t *field;
     attrs_t *a0, *a1;
-    serial_goto(y, x);
+    serial_goto(x, y);
     a0 = &data[0].attrs;
     serial_set_attrs(a0);
     for (j = 0; j < h; j++) {
         if (j > 0 && w != scr_width)
-            serial_goto(y, x);
+            serial_goto(x, j);
         for (i = 0; i < w; i++) {
             field = &data[j * w + i];
 ,16 → 362,16
                 break;
             }
             draw_text_data(interbuf, col, row, w, h);
+            lastcol = col + w;
             lastrow = row + h - 1;
-            lastcol = col + w;
             retval = 0;
             break;
         case FB_PUTCHAR:
             c = IPC_GET_ARG1(call);
-            row = IPC_GET_ARG2(call);
-            col = IPC_GET_ARG3(call);
+            col = IPC_GET_ARG2(call);
+            row = IPC_GET_ARG3(call);
             if ((lastcol != col) || (lastrow != row))
-                serial_goto(row, col);
+                serial_goto(col, row);
             lastcol = col + 1;
             lastrow = row;
             serial_putchar(c);
 ,15 → 378,15
             retval = 0;
             break;
         case FB_CURSOR_GOTO:
-            row = IPC_GET_ARG1(call);
-            col = IPC_GET_ARG2(call);
-            serial_goto(row, col);
+            col = IPC_GET_ARG1(call);
+            row = IPC_GET_ARG2(call);
+            serial_goto(col, row);
+            lastcol = col;
             lastrow = row;
-            lastcol = col;
             retval = 0;
             break;
         case FB_GET_CSIZE:
-            ipc_answer_2(callid, EOK, scr_height, scr_width);
+            ipc_answer_2(callid, EOK, scr_width, scr_height);
             continue;
         case FB_CLEAR:
             serial_clrscr();
 ,7 → 424,7
                 break;
             }
             serial_scroll(i);
-            serial_goto(lastrow, lastcol);
+            serial_goto(lastcol, lastrow);
             retval = 0;
             break;
         case FB_CURSOR_VISIBILITY:
 ,6 → 453,6
     }
 }
-/**
+/**
  * @}
  */

 /branches/network/uspace/srv/fb/serial_console.h
 ,7 → 43,7
 typedef void (*putc_function_t)(char);
 void serial_puts(char *str);
-void serial_goto(const unsigned int row, const unsigned int col);
+void serial_goto(const unsigned int col, const unsigned int row);
 void serial_clrscr(void);
 void serial_scroll(int i);
 void serial_cursor_disable(void);

 /branches/network/uspace/srv/fb/fb.c
 ,9 → 51,10
 #include <ipc/services.h>
 #include <kernel/errno.h>
 #include <kernel/genarch/fb/visuals.h>
-#include <console/color.h>
-#include <console/style.h>
+#include <io/color.h>
+#include <io/style.h>
 #include <async.h>
+#include <fibril.h>
 #include <bool.h>
 #include "font-8x16.h"
 ,8 → 376,8
  */
 static void vport_redraw(viewport_t *vport)
 {
+    unsigned int col;
     unsigned int row;
-    unsigned int col;
     for (row = 0; row < vport->rows; row++) {
         for (col = 0; col < vport->cols; col++) {
 ,8 → 432,8
  */
 static void vport_scroll(viewport_t *vport, int lines)
 {
+    unsigned int col;
     unsigned int row;
-    unsigned int col;
     unsigned int x;
     unsigned int y;
     uint32_t glyph;
 ,7 → 450,8
     for (row = 0; row < vport->rows; row++) {
         x = vport->x;
         for (col = 0; col < vport->cols; col++) {
-            if ((row + lines >= 0) && (row + lines < vport->rows)) {
+            if (((int) row + lines >= 0) &&
+                ((int) row + lines < (int) vport->rows)) {
                 xbp = &vport->backbuf[BB_POS(vport, col, row + lines)];
                 bbp = &vport->backbuf[BB_POS(vport, col, row)];
 ,8 → 1040,8
  *
  * @return false if the call was not handled byt this function, true otherwise
  *
- * Note: this function is not threads safe, you would have
- * to redefine static variables with __thread
+ * Note: this function is not thread-safe, you would have
+ * to redefine static variables with fibril_local.
  *
  */
 static bool shm_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
 ,7 → 1566,7
         unsigned int i;
         int scroll;
         wchar_t ch;
-        unsigned int row, col;
+        unsigned int col, row;
         if ((vport->cursor_active) || (anims_enabled))
             callid = async_get_call_timeout(&call, 250000);
 ,8 → 1603,8
         case FB_PUTCHAR:
             ch = IPC_GET_ARG1(call);
-            row = IPC_GET_ARG2(call);
-            col = IPC_GET_ARG3(call);
+            col = IPC_GET_ARG2(call);
+            row = IPC_GET_ARG3(call);
             if ((col >= vport->cols) || (row >= vport->rows)) {
                 retval = EINVAL;
 ,8 → 1622,8
             retval = EOK;
             break;
         case FB_CURSOR_GOTO:
-            row = IPC_GET_ARG1(call);
-            col = IPC_GET_ARG2(call);
+            col = IPC_GET_ARG1(call);
+            row = IPC_GET_ARG2(call);
             if ((col >= vport->cols) || (row >= vport->rows)) {
                 retval = EINVAL;
 ,7 → 1643,7
             retval = EOK;
             break;
         case FB_GET_CSIZE:
-            ipc_answer_2(callid, EOK, vport->rows, vport->cols);
+            ipc_answer_2(callid, EOK, vport->cols, vport->rows);
             continue;
         case FB_SCROLL:
             scroll = IPC_GET_ARG1(call);

 /branches/network/uspace/srv/fb/ppm.c
 ,7 → 89,7
 {
     unsigned int width, height;
     unsigned int maxcolor;
-    int i;
+    unsigned i;
     unsigned int color;
     unsigned int coef;

 /branches/network/uspace/srv/fb/ega.c
 ,8 → 49,8
 #include <ipc/ns.h>
 #include <ipc/services.h>
 #include <libarch/ddi.h>
-#include <console/style.h>
-#include <console/color.h>
+#include <io/style.h>
+#include <io/color.h>
 #include <sys/types.h>
 #include "ega.h"
 ,7 → 70,7
 int ega_normal_color = 0x0f;
 int ega_inverted_color = 0xf0;
-#define NORMAL_COLOR        ega_normal_color
+#define NORMAL_COLOR        ega_normal_color
 #define INVERTED_COLOR      ega_inverted_color
 /* Allow only 1 connection */
 ,7 → 87,7
 static void clrscr(void)
 {
-    int i;
+    unsigned i;
     for (i = 0; i < scr_width * scr_height; i++) {
         scr_addr[i * 2] = ' ';
 ,7 → 95,7
     }
 }
-static void cursor_goto(unsigned int row, unsigned int col)
+static void cursor_goto(unsigned int col, unsigned int row)
 {
     int ega_cursor;
 ,7 → 129,8
 static void scroll(int rows)
 {
-    int i;
+    unsigned i;
     if (rows > 0) {
         memmove(scr_addr, ((char *) scr_addr) + rows * scr_width * 2,
             scr_width * scr_height * 2 - rows * scr_width * 2);
 ,12 → 145,12
     }
 }
-static void printchar(wchar_t c, unsigned int row, unsigned int col)
+static void printchar(wchar_t c, unsigned int col, unsigned int row)
 {
     scr_addr[(row * scr_width + col) * 2] = ega_glyph(c);
     scr_addr[(row * scr_width + col) * 2 + 1] = style;
-    cursor_goto(row, col + 1);
+    cursor_goto(col + 1, row);
 }
 /** Draw text data to viewport.
 ,11 → 242,15
 static unsigned attr_to_ega_style(const attrs_t *a)
 {
     switch (a->t) {
-    case at_style: return style_to_ega_style(a->a.s.style);
-    case at_rgb: return rgb_to_ega_style(a->a.r.fg_color, a->a.r.bg_color);
-    case at_idx: return color_to_ega_style(a->a.i.fg_color,
-        a->a.i.bg_color, a->a.i.flags);
-    default: return INVERTED_COLOR;
+    case at_style:
+        return style_to_ega_style(a->a.s.style);
+    case at_rgb:
+        return rgb_to_ega_style(a->a.r.fg_color, a->a.r.bg_color);
+    case at_idx:
+        return color_to_ega_style(a->a.i.fg_color,
+            a->a.i.bg_color, a->a.i.flags);
+    default:
+        return INVERTED_COLOR;
     }
 }
 ,7 → 317,7
             retval = 0;
             break;
         case FB_GET_CSIZE:
-            ipc_answer_2(callid, EOK, scr_height, scr_width);
+            ipc_answer_2(callid, EOK, scr_width, scr_height);
             continue;
         case FB_CLEAR:
             clrscr();
 ,28 → 325,28
             break;
         case FB_PUTCHAR:
             c = IPC_GET_ARG1(call);
-            row = IPC_GET_ARG2(call);
-            col = IPC_GET_ARG3(call);
+            col = IPC_GET_ARG2(call);
+            row = IPC_GET_ARG3(call);
             if (col >= scr_width || row >= scr_height) {
                 retval = EINVAL;
                 break;
             }
-            printchar(c, row, col);
+            printchar(c, col, row);
             retval = 0;
             break;
         case FB_CURSOR_GOTO:
-            row = IPC_GET_ARG1(call);
-            col = IPC_GET_ARG2(call);
+            col = IPC_GET_ARG1(call);
+            row = IPC_GET_ARG2(call);
             if (row >= scr_height || col >= scr_width) {
                 retval = EINVAL;
                 break;
             }
-            cursor_goto(row, col);
+            cursor_goto(col, row);
             retval = 0;
             break;
         case FB_SCROLL:
             i = IPC_GET_ARG1(call);
-            if (i > scr_height || i < -((int) scr_height)) {
+            if (i > (int) scr_height || i < -((int) scr_height)) {
                 retval = EINVAL;
                 break;
             }

 /branches/network/uspace/srv/fb/Makefile
 ,10 → 34,8
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS += -I../libipc/include
+LIBS = $(LIBC_PREFIX)/libc.a
-LIBS =  $(LIBC_PREFIX)/libc.a
 ## Sources
 #
 ,7 → 103,7
 disasm: $(OUTPUT).disasm
 $(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
+    $(OBJDUMP) -d $< > $@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/network/uspace/srv/fs/devfs/devfs.c
 ,0 → 1,141
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup fs
+ * @{
+ */
+/**
+ * @file devfs.c
+ * @brief Devices file system.
+ *
+ * Every device registered to device mapper is represented as a file in this
+ * file system.
+ */
+#include <stdio.h>
+#include <ipc/ipc.h>
+#include <ipc/services.h>
+#include <async.h>
+#include <errno.h>
+#include <libfs.h>
+#include "devfs.h"
+#include "devfs_ops.h"
+#define NAME  "devfs"
+static vfs_info_t devfs_vfs_info = {
+    .name = "devfs",
+};
+fs_reg_t devfs_reg;
+static void devfs_connection(ipc_callid_t iid, ipc_call_t *icall)
+{
+    if (iid)
+        ipc_answer_0(iid, EOK);
+    while (true) {
+        ipc_call_t call;
+        ipc_callid_t callid = async_get_call(&call);
+        switch  (IPC_GET_METHOD(call)) {
+        case IPC_M_PHONE_HUNGUP:
+            return;
+        case VFS_MOUNTED:
+            devfs_mounted(callid, &call);
+            break;
+        case VFS_MOUNT:
+            devfs_mount(callid, &call);
+            break;
+        case VFS_LOOKUP:
+            devfs_lookup(callid, &call);
+            break;
+        case VFS_OPEN_NODE:
+            devfs_open_node(callid, &call);
+            break;
+        case VFS_DEVICE:
+            devfs_device(callid, &call);
+            break;
+        case VFS_READ:
+            devfs_read(callid, &call);
+            break;
+        case VFS_WRITE:
+            devfs_write(callid, &call);
+            break;
+        case VFS_TRUNCATE:
+            devfs_truncate(callid, &call);
+            break;
+        case VFS_CLOSE:
+            devfs_close(callid, &call);
+            break;
+        case VFS_SYNC:
+            devfs_sync(callid, &call);
+            break;
+        case VFS_DESTROY:
+            devfs_destroy(callid, &call);
+            break;
+        default:
+            ipc_answer_0(callid, ENOTSUP);
+            break;
+        }
+    }
+}
+int main(int argc, char *argv[])
+{
+    printf(NAME ": HelenOS Device Filesystem\n");
+    if (!devfs_init()) {
+        printf(NAME ": failed to initialize devfs\n");
+        return -1;
+    }
+    int vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
+    if (vfs_phone < EOK) {
+        printf(NAME ": Unable to connect to VFS\n");
+        return -1;
+    }
+    int rc = fs_register(vfs_phone, &devfs_reg, &devfs_vfs_info,
+        devfs_connection);
+    if (rc != EOK) {
+        printf(NAME ": Failed to register file system (%d)\n", rc);
+        return rc;
+    }
+    printf(NAME ": Accepting connections\n");
+    async_manager();
+    /* Not reached */
+    return 0;
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/fs/devfs/devfs_ops.c
 ,0 → 1,513
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup fs
+ * @{
+ */
+/**
+ * @file devfs_ops.c
+ * @brief Implementation of VFS operations for the devfs file system server.
+ */
+#include <ipc/ipc.h>
+#include <bool.h>
+#include <errno.h>
+#include <malloc.h>
+#include <string.h>
+#include <libfs.h>
+#include <fibril_sync.h>
+#include <adt/hash_table.h>
+#include "devfs.h"
+#include "devfs_ops.h"
+#define PLB_GET_CHAR(pos)  (devfs_reg.plb_ro[pos % PLB_SIZE])
+/** Opened devices structure */
+typedef struct {
+    dev_handle_t handle;
+    int phone;
+    size_t refcount;
+    link_t link;
+} device_t;
+/** Hash table of opened devices */
+static hash_table_t devices;
+/** Hash table mutex */
+static FIBRIL_MUTEX_INITIALIZE(devices_mutex);
+#define DEVICES_KEYS        1
+#define DEVICES_KEY_HANDLE  0
+#define DEVICES_BUCKETS     256
+/* Implementation of hash table interface for the nodes hash table. */
+static hash_index_t devices_hash(unsigned long key[])
+{
+    return key[DEVICES_KEY_HANDLE] % DEVICES_BUCKETS;
+}
+static int devices_compare(unsigned long key[], hash_count_t keys, link_t *item)
+{
+    device_t *dev = hash_table_get_instance(item, device_t, link);
+    return (dev->handle == (dev_handle_t) key[DEVICES_KEY_HANDLE]);
+}
+static void devices_remove_callback(link_t *item)
+{
+    free(hash_table_get_instance(item, device_t, link));
+}
+static hash_table_operations_t devices_ops = {
+    .hash = devices_hash,
+    .compare = devices_compare,
+    .remove_callback = devices_remove_callback
+};
+bool devfs_init(void)
+{
+    if (!hash_table_create(&devices, DEVICES_BUCKETS,
+        DEVICES_KEYS, &devices_ops))
+        return false;
+    if (devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING) < 0)
+        return false;
+    return true;
+}
+void devfs_mounted(ipc_callid_t rid, ipc_call_t *request)
+{
+    /* Accept the mount options */
+    ipc_callid_t callid;
+    size_t size;
+    if (!ipc_data_write_receive(&callid, &size)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    char *opts = malloc(size + 1);
+    if (!opts) {
+        ipc_answer_0(callid, ENOMEM);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
+    ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
+    if (retval != EOK) {
+        ipc_answer_0(rid, retval);
+        free(opts);
+        return;
+    }
+    free(opts);
+    ipc_answer_3(rid, EOK, 0, 0, 0);
+}
+void devfs_mount(ipc_callid_t rid, ipc_call_t *request)
+{
+    ipc_answer_0(rid, ENOTSUP);
+}
+void devfs_lookup(ipc_callid_t rid, ipc_call_t *request)
+{
+    ipcarg_t first = IPC_GET_ARG1(*request);
+    ipcarg_t last = IPC_GET_ARG2(*request);
+    dev_handle_t dev_handle = IPC_GET_ARG3(*request);
+    ipcarg_t lflag = IPC_GET_ARG4(*request);
+    fs_index_t index = IPC_GET_ARG5(*request);
+    /* Hierarchy is flat, no altroot is supported */
+    if (index != 0) {
+        ipc_answer_0(rid, ENOENT);
+        return;
+    }
+    if ((lflag & L_LINK) || (lflag & L_UNLINK)) {
+        ipc_answer_0(rid, ENOTSUP);
+        return;
+    }
+    /* Eat slash */
+    if (PLB_GET_CHAR(first) == '/') {
+        first++;
+        first %= PLB_SIZE;
+    }
+    if (first >= last) {
+        /* Root entry */
+        if (lflag & L_DIRECTORY)
+            ipc_answer_5(rid, EOK, devfs_reg.fs_handle, dev_handle, 0, 0, 0);
+        else
+            ipc_answer_0(rid, ENOENT);
+    } else {
+        if (lflag & L_FILE) {
+            size_t len;
+            if (last >= first)
+                len = last - first + 1;
+            else
+                len = first + PLB_SIZE - last + 1;
+            char *name = (char *) malloc(len + 1);
+            if (name == NULL) {
+                ipc_answer_0(rid, ENOMEM);
+                return;
+            }
+            size_t i;
+            for (i = 0; i < len; i++)
+                name[i] = PLB_GET_CHAR(first + i);
+            name[len] = 0;
+            dev_handle_t handle;
+            if (devmap_device_get_handle(name, &handle, 0) != EOK) {
+                free(name);
+                ipc_answer_0(rid, ENOENT);
+                return;
+            }
+            if (lflag & L_OPEN) {
+                unsigned long key[] = {
+                    [DEVICES_KEY_HANDLE] = (unsigned long) handle
+                };
+                fibril_mutex_lock(&devices_mutex);
+                link_t *lnk = hash_table_find(&devices, key);
+                if (lnk == NULL) {
+                    int phone = devmap_device_connect(handle, 0);
+                    if (phone < 0) {
+                        fibril_mutex_unlock(&devices_mutex);
+                        free(name);
+                        ipc_answer_0(rid, ENOENT);
+                        return;
+                    }
+                    device_t *dev = (device_t *) malloc(sizeof(device_t));
+                    if (dev == NULL) {
+                        fibril_mutex_unlock(&devices_mutex);
+                        free(name);
+                        ipc_answer_0(rid, ENOMEM);
+                        return;
+                    }
+                    dev->handle = handle;
+                    dev->phone = phone;
+                    dev->refcount = 1;
+                    hash_table_insert(&devices, key, &dev->link);
+                } else {
+                    device_t *dev = hash_table_get_instance(lnk, device_t, link);
+                    dev->refcount++;
+                }
+                fibril_mutex_unlock(&devices_mutex);
+            }
+            free(name);
+            ipc_answer_5(rid, EOK, devfs_reg.fs_handle, dev_handle, handle, 0, 1);
+        } else
+            ipc_answer_0(rid, ENOENT);
+    }
+}
+void devfs_open_node(ipc_callid_t rid, ipc_call_t *request)
+{
+    dev_handle_t handle = IPC_GET_ARG2(*request);
+    unsigned long key[] = {
+        [DEVICES_KEY_HANDLE] = (unsigned long) handle
+    };
+    fibril_mutex_lock(&devices_mutex);
+    link_t *lnk = hash_table_find(&devices, key);
+    if (lnk == NULL) {
+        int phone = devmap_device_connect(handle, 0);
+        if (phone < 0) {
+            fibril_mutex_unlock(&devices_mutex);
+            ipc_answer_0(rid, ENOENT);
+            return;
+        }
+        device_t *dev = (device_t *) malloc(sizeof(device_t));
+        if (dev == NULL) {
+            fibril_mutex_unlock(&devices_mutex);
+            ipc_answer_0(rid, ENOMEM);
+            return;
+        }
+        dev->handle = handle;
+        dev->phone = phone;
+        dev->refcount = 1;
+        hash_table_insert(&devices, key, &dev->link);
+    } else {
+        device_t *dev = hash_table_get_instance(lnk, device_t, link);
+        dev->refcount++;
+    }
+    fibril_mutex_unlock(&devices_mutex);
+    ipc_answer_3(rid, EOK, 0, 1, L_FILE);
+}
+void devfs_device(ipc_callid_t rid, ipc_call_t *request)
+{
+    fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+    if (index != 0) {
+        unsigned long key[] = {
+            [DEVICES_KEY_HANDLE] = (unsigned long) index
+        };
+        fibril_mutex_lock(&devices_mutex);
+        link_t *lnk = hash_table_find(&devices, key);
+        if (lnk == NULL) {
+            fibril_mutex_unlock(&devices_mutex);
+            ipc_answer_0(rid, ENOENT);
+            return;
+        }
+        fibril_mutex_unlock(&devices_mutex);
+        ipc_answer_1(rid, EOK, (ipcarg_t) index);
+    } else
+        ipc_answer_0(rid, ENOTSUP);
+}
+void devfs_read(ipc_callid_t rid, ipc_call_t *request)
+{
+    fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+    off_t pos = (off_t) IPC_GET_ARG3(*request);
+    if (index != 0) {
+        unsigned long key[] = {
+            [DEVICES_KEY_HANDLE] = (unsigned long) index
+        };
+        fibril_mutex_lock(&devices_mutex);
+        link_t *lnk = hash_table_find(&devices, key);
+        if (lnk == NULL) {
+            fibril_mutex_unlock(&devices_mutex);
+            ipc_answer_0(rid, ENOENT);
+            return;
+        }
+        device_t *dev = hash_table_get_instance(lnk, device_t, link);
+        ipc_callid_t callid;
+        if (!ipc_data_read_receive(&callid, NULL)) {
+            fibril_mutex_unlock(&devices_mutex);
+            ipc_answer_0(callid, EINVAL);
+            ipc_answer_0(rid, EINVAL);
+            return;
+        }
+        /* Make a request at the driver */
+        ipc_call_t answer;
+        aid_t msg = async_send_3(dev->phone, IPC_GET_METHOD(*request),
+            IPC_GET_ARG1(*request), IPC_GET_ARG2(*request),
+            IPC_GET_ARG3(*request), &answer);
+        /* Forward the IPC_M_DATA_READ request to the driver */
+        ipc_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
+        fibril_mutex_unlock(&devices_mutex);
+        /* Wait for reply from the driver. */
+        ipcarg_t rc;
+        async_wait_for(msg, &rc);
+        size_t bytes = IPC_GET_ARG1(answer);
+        /* Driver reply is the final result of the whole operation */
+        ipc_answer_1(rid, rc, bytes);
+    } else {
+        ipc_callid_t callid;
+        size_t size;
+        if (!ipc_data_read_receive(&callid, &size)) {
+            ipc_answer_0(callid, EINVAL);
+            ipc_answer_0(rid, EINVAL);
+            return;
+        }
+        size_t count = devmap_device_get_count();
+        dev_desc_t *desc = malloc(count * sizeof(dev_desc_t));
+        if (desc == NULL) {
+            ipc_answer_0(callid, ENOMEM);
+            ipc_answer_1(rid, ENOMEM, 0);
+            return;
+        }
+        size_t max = devmap_device_get_devices(count, desc);
+        if (pos < max) {
+            ipc_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
+        } else {
+            ipc_answer_0(callid, ENOENT);
+            ipc_answer_1(rid, ENOENT, 0);
+            return;
+        }
+        free(desc);
+        ipc_answer_1(rid, EOK, 1);
+    }
+}
+void devfs_write(ipc_callid_t rid, ipc_call_t *request)
+{
+    fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+    off_t pos = (off_t) IPC_GET_ARG3(*request);
+    if (index != 0) {
+        unsigned long key[] = {
+            [DEVICES_KEY_HANDLE] = (unsigned long) index
+        };
+        fibril_mutex_lock(&devices_mutex);
+        link_t *lnk = hash_table_find(&devices, key);
+        if (lnk == NULL) {
+            fibril_mutex_unlock(&devices_mutex);
+            ipc_answer_0(rid, ENOENT);
+            return;
+        }
+        device_t *dev = hash_table_get_instance(lnk, device_t, link);
+        ipc_callid_t callid;
+        if (!ipc_data_write_receive(&callid, NULL)) {
+            fibril_mutex_unlock(&devices_mutex);
+            ipc_answer_0(callid, EINVAL);
+            ipc_answer_0(rid, EINVAL);
+            return;
+        }
+        /* Make a request at the driver */
+        ipc_call_t answer;
+        aid_t msg = async_send_3(dev->phone, IPC_GET_METHOD(*request),
+            IPC_GET_ARG1(*request), IPC_GET_ARG2(*request),
+            IPC_GET_ARG3(*request), &answer);
+        /* Forward the IPC_M_DATA_WRITE request to the driver */
+        ipc_forward_fast(callid, dev->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
+        fibril_mutex_unlock(&devices_mutex);
+        /* Wait for reply from the driver. */
+        ipcarg_t rc;
+        async_wait_for(msg, &rc);
+        size_t bytes = IPC_GET_ARG1(answer);
+        /* Driver reply is the final result of the whole operation */
+        ipc_answer_1(rid, rc, bytes);
+    } else {
+        /* Read-only filesystem */
+        ipc_answer_0(rid, ENOTSUP);
+    }
+}
+void devfs_truncate(ipc_callid_t rid, ipc_call_t *request)
+{
+    ipc_answer_0(rid, ENOTSUP);
+}
+void devfs_close(ipc_callid_t rid, ipc_call_t *request)
+{
+    fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+    if (index != 0) {
+        unsigned long key[] = {
+            [DEVICES_KEY_HANDLE] = (unsigned long) index
+        };
+        fibril_mutex_lock(&devices_mutex);
+        link_t *lnk = hash_table_find(&devices, key);
+        if (lnk == NULL) {
+            fibril_mutex_unlock(&devices_mutex);
+            ipc_answer_0(rid, ENOENT);
+            return;
+        }
+        device_t *dev = hash_table_get_instance(lnk, device_t, link);
+        dev->refcount--;
+        if (dev->refcount == 0) {
+            ipc_hangup(dev->phone);
+            hash_table_remove(&devices, key, DEVICES_KEYS);
+        }
+        fibril_mutex_unlock(&devices_mutex);
+        ipc_answer_0(rid, EOK);
+    } else
+        ipc_answer_0(rid, ENOTSUP);
+}
+void devfs_sync(ipc_callid_t rid, ipc_call_t *request)
+{
+    fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+    if (index != 0) {
+        unsigned long key[] = {
+            [DEVICES_KEY_HANDLE] = (unsigned long) index
+        };
+        fibril_mutex_lock(&devices_mutex);
+        link_t *lnk = hash_table_find(&devices, key);
+        if (lnk == NULL) {
+            fibril_mutex_unlock(&devices_mutex);
+            ipc_answer_0(rid, ENOENT);
+            return;
+        }
+        device_t *dev = hash_table_get_instance(lnk, device_t, link);
+        /* Make a request at the driver */
+        ipc_call_t answer;
+        aid_t msg = async_send_2(dev->phone, IPC_GET_METHOD(*request),
+            IPC_GET_ARG1(*request), IPC_GET_ARG2(*request), &answer);
+        fibril_mutex_unlock(&devices_mutex);
+        /* Wait for reply from the driver */
+        ipcarg_t rc;
+        async_wait_for(msg, &rc);
+        /* Driver reply is the final result of the whole operation */
+        ipc_answer_0(rid, rc);
+    } else
+        ipc_answer_0(rid, ENOTSUP);
+}
+void devfs_destroy(ipc_callid_t rid, ipc_call_t *request)
+{
+    ipc_answer_0(rid, ENOTSUP);
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/fs/devfs/devfs_ops.h
 ,0 → 1,57
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup fs
+ * @{
+ */
+#ifndef DEVFS_DEVFS_OPS_H_
+#define DEVFS_DEVFS_OPS_H_
+#include <ipc/ipc.h>
+#include <bool.h>
+extern bool devfs_init(void);
+extern void devfs_mounted(ipc_callid_t, ipc_call_t *);
+extern void devfs_mount(ipc_callid_t, ipc_call_t *);
+extern void devfs_lookup(ipc_callid_t, ipc_call_t *);
+extern void devfs_open_node(ipc_callid_t, ipc_call_t *);
+extern void devfs_device(ipc_callid_t, ipc_call_t *);
+extern void devfs_sync(ipc_callid_t, ipc_call_t *);
+extern void devfs_read(ipc_callid_t, ipc_call_t *);
+extern void devfs_write(ipc_callid_t, ipc_call_t *);
+extern void devfs_truncate(ipc_callid_t, ipc_call_t *);
+extern void devfs_close(ipc_callid_t, ipc_call_t *);
+extern void devfs_destroy(ipc_callid_t, ipc_call_t *);
+#endif
+/**
+ * @}
+ */

 /branches/network/uspace/srv/fs/devfs/Makefile
 ,0 → 1,82
+#
+# Copyright (c) 2005 Martin Decky
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+## Setup toolchain
+#
+LIBC_PREFIX = ../../../lib/libc
+LIBFS_PREFIX = ../../../lib/libfs
+SOFTINT_PREFIX = ../../../lib/softint
+include $(LIBC_PREFIX)/Makefile.toolchain
+CFLAGS += -I $(LIBFS_PREFIX)
+LIBS = \
+    $(LIBFS_PREFIX)/libfs.a \
+    $(LIBC_PREFIX)/libc.a
+## Sources
+#
+OUTPUT = devfs
+SOURCES = \
+    devfs.c \
+    devfs_ops.c
+OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
+.PHONY: all clean depend disasm
+all: $(OUTPUT) $(OUTPUT).disasm
+-include Makefile.depend
+clean:
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
+depend:
+    $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
+$(OUTPUT): $(OBJECTS) $(LIBS)
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< > $@
+%.o: %.S
+    $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@
+%.o: %.s
+    $(AS) $(AFLAGS) $< -o $@
+%.o: %.c
+    $(CC) $(DEFS) $(CFLAGS) -c $< -o $@

 /branches/network/uspace/srv/fs/devfs/devfs.h
 ,0 → 1,44
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup fs
+ * @{
+ */
+#ifndef DEVFS_DEVFS_H_
+#define DEVFS_DEVFS_H_
+#include <libfs.h>
+extern fs_reg_t devfs_reg;
+#endif
+/**
+ * @}
+ */

 /branches/network/uspace/srv/fs/tmpfs/tmpfs.h
 ,12 → 38,15
 #include <atomic.h>
 #include <sys/types.h>
 #include <bool.h>
-#include <libadt/hash_table.h>
+#include <adt/hash_table.h>
 #ifndef dprintf
 #define dprintf(...)    printf(__VA_ARGS__)
 #endif
+#define TMPFS_NODE(node)    ((node) ? (tmpfs_node_t *)(node)->data : NULL)
+#define FS_NODE(node)       ((node) ? (node)->bp : NULL)
 typedef enum {
     TMPFS_NONE,
     TMPFS_FILE,
 ,18 → 53,26
     TMPFS_DIRECTORY
 } tmpfs_dentry_type_t;
+/* forward declaration */
+struct tmpfs_node;
 typedef struct tmpfs_dentry {
+    link_t link;        /**< Linkage for the list of siblings. */
+    struct tmpfs_node *node;/**< Back pointer to TMPFS node. */
+    char *name;     /**< Name of dentry. */
+} tmpfs_dentry_t;
+typedef struct tmpfs_node {
+    fs_node_t *bp;      /**< Back pointer to the FS node. */
     fs_index_t index;   /**< TMPFS node index. */
     dev_handle_t dev_handle;/**< Device handle. */
-    link_t dh_link;     /**< Dentries hash table link. */
-    struct tmpfs_dentry *sibling;
-    struct tmpfs_dentry *child;
-    hash_table_t names; /**< All names linking to this TMPFS node. */
+    link_t nh_link;     /**< Nodes hash table link. */
     tmpfs_dentry_type_t type;
     unsigned lnkcnt;    /**< Link count. */
     size_t size;        /**< File size if type is TMPFS_FILE. */
     void *data;     /**< File content's if type is TMPFS_FILE. */
-} tmpfs_dentry_t;
+    link_t cs_head;     /**< Head of child's siblings list. */
+} tmpfs_node_t;
 extern fs_reg_t tmpfs_reg;
 ,7 → 86,11
 extern void tmpfs_read(ipc_callid_t, ipc_call_t *);
 extern void tmpfs_write(ipc_callid_t, ipc_call_t *);
 extern void tmpfs_truncate(ipc_callid_t, ipc_call_t *);
+extern void tmpfs_close(ipc_callid_t, ipc_call_t *);
 extern void tmpfs_destroy(ipc_callid_t, ipc_call_t *);
+extern void tmpfs_open_node(ipc_callid_t, ipc_call_t *);
+extern void tmpfs_device(ipc_callid_t, ipc_call_t *);
+extern void tmpfs_sync(ipc_callid_t, ipc_call_t *);
 extern bool tmpfs_restore(dev_handle_t);

 /branches/network/uspace/srv/fs/tmpfs/tmpfs_dump.c
 ,8 → 54,8
 } __attribute__((packed));
 static bool
-tmpfs_restore_recursion(int dev, off_t *bufpos, size_t *buflen, off_t *pos,
-    tmpfs_dentry_t *parent)
+tmpfs_restore_recursion(dev_handle_t dev, off_t *bufpos, size_t *buflen,
+    off_t *pos, fs_node_t *pfn)
 {
     struct rdentry entry;
     libfs_ops_t *ops = &tmpfs_libfs_ops;
 ,7 → 63,8
     do {
         char *fname;
-        tmpfs_dentry_t *node;
+        fs_node_t *fn;
+        tmpfs_node_t *nodep;
         uint32_t size;
         if (block_read(dev, bufpos, buflen, pos, &entry, sizeof(entry),
 ,8 → 81,8
             if (fname == NULL)
                 return false;
-            node = (tmpfs_dentry_t *) ops->create(dev, L_FILE);
-            if (node == NULL) {
+            fn = ops->create(dev, L_FILE);
+            if (fn == NULL) {
                 free(fname);
                 return false;
             }
 ,15 → 89,15
             if (block_read(dev, bufpos, buflen, pos, fname,
                 entry.len, TMPFS_BLOCK_SIZE) != EOK) {
-                ops->destroy((void *) node);
+                ops->destroy(fn);
                 free(fname);
                 return false;
             }
             fname[entry.len] = 0;
-            rc = ops->link((void *) parent, (void *) node, fname);
+            rc = ops->link(pfn, fn, fname);
             if (rc != EOK) {
-                ops->destroy((void *) node);
+                ops->destroy(fn);
                 free(fname);
                 return false;
             }
 ,12 → 109,13
             size = uint32_t_le2host(size);
-            node->data = malloc(size);
-            if (node->data == NULL)
+            nodep = TMPFS_NODE(fn);
+            nodep->data = malloc(size);
+            if (nodep->data == NULL)
                 return false;
-            node->size = size;
-            if (block_read(dev, bufpos, buflen, pos, node->data,
+            nodep->size = size;
+            if (block_read(dev, bufpos, buflen, pos, nodep->data,
                 size, TMPFS_BLOCK_SIZE) != EOK)
                 return false;
 ,8 → 125,8
             if (fname == NULL)
                 return false;
-            node = (tmpfs_dentry_t *) ops->create(dev, L_DIRECTORY);
-            if (node == NULL) {
+            fn = ops->create(dev, L_DIRECTORY);
+            if (fn == NULL) {
                 free(fname);
                 return false;
             }
 ,15 → 133,15
             if (block_read(dev, bufpos, buflen, pos, fname,
                 entry.len, TMPFS_BLOCK_SIZE) != EOK) {
-                ops->destroy((void *) node);
+                ops->destroy(fn);
                 free(fname);
                 return false;
             }
             fname[entry.len] = 0;
-            rc = ops->link((void *) parent, (void *) node, fname);
+            rc = ops->link(pfn, fn, fname);
             if (rc != EOK) {
-                ops->destroy((void *) node);
+                ops->destroy(fn);
                 free(fname);
                 return false;
             }
 ,7 → 148,7
             free(fname);
             if (!tmpfs_restore_recursion(dev, bufpos, buflen, pos,
-                node))
+                fn))
                 return false;
             break;

 /branches/network/uspace/srv/fs/tmpfs/tmpfs.c
 ,6 → 96,8
         callid = async_get_call(&call);
         switch  (IPC_GET_METHOD(call)) {
+        case IPC_M_PHONE_HUNGUP:
+            return;
         case VFS_MOUNTED:
             tmpfs_mounted(callid, &call);
             break;
 ,9 → 116,21
         case VFS_TRUNCATE:
             tmpfs_truncate(callid, &call);
             break;
+        case VFS_CLOSE:
+            tmpfs_close(callid, &call);
+            break;
         case VFS_DESTROY:
             tmpfs_destroy(callid, &call);
             break;
+        case VFS_OPEN_NODE:
+            tmpfs_open_node(callid, &call);
+            break;
+        case VFS_DEVICE:
+            tmpfs_device(callid, &call);
+            break;
+        case VFS_SYNC:
+            tmpfs_sync(callid, &call);
+            break;
         default:
             ipc_answer_0(callid, ENOTSUP);
             break;

 /branches/network/uspace/srv/fs/tmpfs/tmpfs_ops.c
 ,7 → 47,7
 #include <stdio.h>
 #include <assert.h>
 #include <sys/types.h>
-#include <libadt/hash_table.h>
+#include <adt/hash_table.h>
 #include <as.h>
 #include <libfs.h>
 ,10 → 54,8
 #define min(a, b)       ((a) < (b) ? (a) : (b))
 #define max(a, b)       ((a) > (b) ? (a) : (b))
-#define DENTRIES_BUCKETS    256
+#define NODES_BUCKETS   256
-#define NAMES_BUCKETS       4
 /** All root nodes have index 0. */
 #define TMPFS_SOME_ROOT     0
 /** Global counter for assigning node indices. Shared by all instances. */
 ,36 → 66,36
  */
 /* Forward declarations of static functions. */
-static void *tmpfs_match(void *, const char *);
-static void *tmpfs_node_get(dev_handle_t, fs_index_t);
-static void tmpfs_node_put(void *);
-static void *tmpfs_create_node(dev_handle_t, int);
-static int tmpfs_link_node(void *, void *, const char *);
-static int tmpfs_unlink_node(void *, void *);
-static int tmpfs_destroy_node(void *);
+static fs_node_t *tmpfs_match(fs_node_t *, const char *);
+static fs_node_t *tmpfs_node_get(dev_handle_t, fs_index_t);
+static void tmpfs_node_put(fs_node_t *);
+static fs_node_t *tmpfs_create_node(dev_handle_t, int);
+static int tmpfs_link_node(fs_node_t *, fs_node_t *, const char *);
+static int tmpfs_unlink_node(fs_node_t *, fs_node_t *, const char *);
+static int tmpfs_destroy_node(fs_node_t *);
 /* Implementation of helper functions. */
-static fs_index_t tmpfs_index_get(void *nodep)
+static fs_index_t tmpfs_index_get(fs_node_t *fn)
 {
-    return ((tmpfs_dentry_t *) nodep)->index;
+    return TMPFS_NODE(fn)->index;
 }
-static size_t tmpfs_size_get(void *nodep)
+static size_t tmpfs_size_get(fs_node_t *fn)
 {
-    return ((tmpfs_dentry_t *) nodep)->size;
+    return TMPFS_NODE(fn)->size;
 }
-static unsigned tmpfs_lnkcnt_get(void *nodep)
+static unsigned tmpfs_lnkcnt_get(fs_node_t *fn)
 {
-    return ((tmpfs_dentry_t *) nodep)->lnkcnt;
+    return TMPFS_NODE(fn)->lnkcnt;
 }
-static bool tmpfs_has_children(void *nodep)
+static bool tmpfs_has_children(fs_node_t *fn)
 {
-    return ((tmpfs_dentry_t *) nodep)->child != NULL;
+    return !list_empty(&TMPFS_NODE(fn)->cs_head);
 }
-static void *tmpfs_root_get(dev_handle_t dev_handle)
+static fs_node_t *tmpfs_root_get(dev_handle_t dev_handle)
 {
     return tmpfs_node_get(dev_handle, TMPFS_SOME_ROOT);
 }
 ,14 → 105,14
     return tmpfs_reg.plb_ro[pos % PLB_SIZE];
 }
-static bool tmpfs_is_directory(void *nodep)
+static bool tmpfs_is_directory(fs_node_t *fn)
 {
-    return ((tmpfs_dentry_t *) nodep)->type == TMPFS_DIRECTORY;
+    return TMPFS_NODE(fn)->type == TMPFS_DIRECTORY;
 }
-static bool tmpfs_is_file(void *nodep)
+static bool tmpfs_is_file(fs_node_t *fn)
 {
-    return ((tmpfs_dentry_t *) nodep)->type == TMPFS_FILE;
+    return TMPFS_NODE(fn)->type == TMPFS_FILE;
 }
 /** libfs operations */
 ,99 → 134,60
     .is_file = tmpfs_is_file
 };
-/** Hash table of all directory entries. */
-hash_table_t dentries;
+/** Hash table of all TMPFS nodes. */
+hash_table_t nodes;
-#define DENTRIES_KEY_INDEX  0
-#define DENTRIES_KEY_DEV    1
+#define NODES_KEY_INDEX 0
+#define NODES_KEY_DEV   1
-/* Implementation of hash table interface for the dentries hash table. */
-static hash_index_t dentries_hash(unsigned long key[])
+/* Implementation of hash table interface for the nodes hash table. */
+static hash_index_t nodes_hash(unsigned long key[])
 {
-    return key[DENTRIES_KEY_INDEX] % DENTRIES_BUCKETS;
+    return key[NODES_KEY_INDEX] % NODES_BUCKETS;
 }
-static int dentries_compare(unsigned long key[], hash_count_t keys,
-    link_t *item)
+static int nodes_compare(unsigned long key[], hash_count_t keys, link_t *item)
 {
-    tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t,
-        dh_link);
-    return (dentry->index == key[DENTRIES_KEY_INDEX] &&
-        dentry->dev_handle == key[DENTRIES_KEY_DEV]);
+    tmpfs_node_t *nodep = hash_table_get_instance(item, tmpfs_node_t,
+        nh_link);
+    return (nodep->index == key[NODES_KEY_INDEX] &&
+        nodep->dev_handle == key[NODES_KEY_DEV]);
 }
-static void dentries_remove_callback(link_t *item)
+static void nodes_remove_callback(link_t *item)
 {
 }
-/** TMPFS dentries hash table operations. */
-hash_table_operations_t dentries_ops = {
-    .hash = dentries_hash,
-    .compare = dentries_compare,
-    .remove_callback = dentries_remove_callback
+/** TMPFS nodes hash table operations. */
+hash_table_operations_t nodes_ops = {
+    .hash = nodes_hash,
+    .compare = nodes_compare,
+    .remove_callback = nodes_remove_callback
 };
-typedef struct {
-    char *name;
-    tmpfs_dentry_t *parent;
-    link_t link;
-} tmpfs_name_t;
-/* Implementation of hash table interface for the names hash table. */
-static hash_index_t names_hash(unsigned long *key)
+static void tmpfs_node_initialize(tmpfs_node_t *nodep)
 {
-    tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) *key;
-    return dentry->index % NAMES_BUCKETS;
+    nodep->bp = NULL;
+    nodep->index = 0;
+    nodep->dev_handle = 0;
+    nodep->type = TMPFS_NONE;
+    nodep->lnkcnt = 0;
+    nodep->size = 0;
+    nodep->data = NULL;
+    link_initialize(&nodep->nh_link);
+    list_initialize(&nodep->cs_head);
 }
-static int names_compare(unsigned long *key, hash_count_t keys, link_t *item)
+static void tmpfs_dentry_initialize(tmpfs_dentry_t *dentryp)
 {
-    tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) *key;
-    tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,
-        link);
-    return dentry == namep->parent;
+    link_initialize(&dentryp->link);
+    dentryp->name = NULL;
+    dentryp->node = NULL;
 }
-static void names_remove_callback(link_t *item)
-{
-    tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,
-        link);
-    free(namep->name);
-    free(namep);
-}
-/** TMPFS node names hash table operations. */
-static hash_table_operations_t names_ops = {
-    .hash = names_hash,
-    .compare = names_compare,
-    .remove_callback = names_remove_callback
-};
-static void tmpfs_name_initialize(tmpfs_name_t *namep)
-{
-    namep->name = NULL;
-    namep->parent = NULL;
-    link_initialize(&namep->link);
-}
-static bool tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)
-{
-    dentry->index = 0;
-    dentry->dev_handle = 0;
-    dentry->sibling = NULL;
-    dentry->child = NULL;
-    dentry->type = TMPFS_NONE;
-    dentry->lnkcnt = 0;
-    dentry->size = 0;
-    dentry->data = NULL;
-    link_initialize(&dentry->dh_link);
-    return (bool)hash_table_create(&dentry->names, NAMES_BUCKETS, 1,
-        &names_ops);
-}
 bool tmpfs_init(void)
 {
-    if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 2, &dentries_ops))
+    if (!hash_table_create(&nodes, NODES_BUCKETS, 2, &nodes_ops))
         return false;
     return true;
 ,181 → 195,170
 static bool tmpfs_instance_init(dev_handle_t dev_handle)
 {
-    tmpfs_dentry_t *root;
+    fs_node_t *rfn;
-    root = (tmpfs_dentry_t *) tmpfs_create_node(dev_handle, L_DIRECTORY);
-    if (!root)
+    rfn = tmpfs_create_node(dev_handle, L_DIRECTORY);
+    if (!rfn)
         return false;
-    root->lnkcnt = 0;   /* FS root is not linked */
+    TMPFS_NODE(rfn)->lnkcnt = 0;    /* FS root is not linked */
     return true;
 }
-/** Compare one component of path to a directory entry.
- *
- * @param parentp   Pointer to node from which we descended.
- * @param childp    Pointer to node to compare the path component with.
- * @param component Array of characters holding component name.
- *
- * @return      True on match, false otherwise.
- */
-static bool
-tmpfs_match_one(tmpfs_dentry_t *parentp, tmpfs_dentry_t *childp,
-    const char *component)
+fs_node_t *tmpfs_match(fs_node_t *pfn, const char *component)
 {
-    unsigned long key = (unsigned long) parentp;
-    link_t *hlp = hash_table_find(&childp->names, &key);
-    assert(hlp);
-    tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t, link);
-    return !str_cmp(namep->name, component);
-}
+    tmpfs_node_t *parentp = TMPFS_NODE(pfn);
+    link_t *lnk;
-void *tmpfs_match(void *prnt, const char *component)
-{
-    tmpfs_dentry_t *parentp = (tmpfs_dentry_t *) prnt;
-    tmpfs_dentry_t *childp = parentp->child;
+    for (lnk = parentp->cs_head.next; lnk != &parentp->cs_head;
+        lnk = lnk->next) {
+        tmpfs_dentry_t *dentryp = list_get_instance(lnk, tmpfs_dentry_t,
+            link);
+        if (!str_cmp(dentryp->name, component))
+            return FS_NODE(dentryp->node);
+    }
-    while (childp && !tmpfs_match_one(parentp, childp, component))
-        childp = childp->sibling;
-    return (void *) childp;
+    return NULL;
 }
-void *
-tmpfs_node_get(dev_handle_t dev_handle, fs_index_t index)
+fs_node_t *tmpfs_node_get(dev_handle_t dev_handle, fs_index_t index)
 {
     unsigned long key[] = {
-        [DENTRIES_KEY_INDEX] = index,
-        [DENTRIES_KEY_DEV] = dev_handle
+        [NODES_KEY_INDEX] = index,
+        [NODES_KEY_DEV] = dev_handle
     };
-    link_t *lnk = hash_table_find(&dentries, key);
+    link_t *lnk = hash_table_find(&nodes, key);
     if (!lnk)
         return NULL;
-    return hash_table_get_instance(lnk, tmpfs_dentry_t, dh_link);
+    return FS_NODE(hash_table_get_instance(lnk, tmpfs_node_t, nh_link));
 }
-void tmpfs_node_put(void *node)
+void tmpfs_node_put(fs_node_t *fn)
 {
     /* nothing to do */
 }
-void *tmpfs_create_node(dev_handle_t dev_handle, int lflag)
+fs_node_t *tmpfs_create_node(dev_handle_t dev_handle, int lflag)
 {
     assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
-    tmpfs_dentry_t *node = malloc(sizeof(tmpfs_dentry_t));
-    if (!node)
+    tmpfs_node_t *nodep = malloc(sizeof(tmpfs_node_t));
+    if (!nodep)
         return NULL;
-    if (!tmpfs_dentry_initialize(node)) {
-        free(node);
+    tmpfs_node_initialize(nodep);
+    nodep->bp = malloc(sizeof(fs_node_t));
+    if (!nodep->bp) {
+        free(nodep);
         return NULL;
     }
+    fs_node_initialize(nodep->bp);
+    nodep->bp->data = nodep;    /* link the FS and TMPFS nodes */
     if (!tmpfs_root_get(dev_handle))
-        node->index = TMPFS_SOME_ROOT;
+        nodep->index = TMPFS_SOME_ROOT;
     else
-        node->index = tmpfs_next_index++;
-    node->dev_handle = dev_handle;
+        nodep->index = tmpfs_next_index++;
+    nodep->dev_handle = dev_handle;
     if (lflag & L_DIRECTORY)
-        node->type = TMPFS_DIRECTORY;
+        nodep->type = TMPFS_DIRECTORY;
     else
-        node->type = TMPFS_FILE;
+        nodep->type = TMPFS_FILE;
-    /* Insert the new node into the dentry hash table. */
+    /* Insert the new node into the nodes hash table. */
     unsigned long key[] = {
-        [DENTRIES_KEY_INDEX] = node->index,
-        [DENTRIES_KEY_DEV] = node->dev_handle
+        [NODES_KEY_INDEX] = nodep->index,
+        [NODES_KEY_DEV] = nodep->dev_handle
     };
-    hash_table_insert(&dentries, key, &node->dh_link);
-    return (void *) node;
+    hash_table_insert(&nodes, key, &nodep->nh_link);
+    return FS_NODE(nodep);
 }
-int tmpfs_link_node(void *prnt, void *chld, const char *nm)
+int tmpfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
 {
-    tmpfs_dentry_t *parentp = (tmpfs_dentry_t *) prnt;
-    tmpfs_dentry_t *childp = (tmpfs_dentry_t *) chld;
+    tmpfs_node_t *parentp = TMPFS_NODE(pfn);
+    tmpfs_node_t *childp = TMPFS_NODE(cfn);
+    tmpfs_dentry_t *dentryp;
+    link_t *lnk;
     assert(parentp->type == TMPFS_DIRECTORY);
-    tmpfs_name_t *namep = malloc(sizeof(tmpfs_name_t));
-    if (!namep)
+    /* Check for duplicit entries. */
+    for (lnk = parentp->cs_head.next; lnk != &parentp->cs_head;
+        lnk = lnk->next) {
+        dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
+        if (!str_cmp(dentryp->name, nm))
+            return EEXIST;
+    }
+    /* Allocate and initialize the dentry. */
+    dentryp = malloc(sizeof(tmpfs_dentry_t));
+    if (!dentryp)
         return ENOMEM;
-    tmpfs_name_initialize(namep);
+    tmpfs_dentry_initialize(dentryp);
+    /* Populate and link the new dentry. */
     size_t size = str_size(nm);
-    namep->name = malloc(size + 1);
-    if (!namep->name) {
-        free(namep);
+    dentryp->name = malloc(size + 1);
+    if (!dentryp->name) {
+        free(dentryp);
         return ENOMEM;
     }
-    str_cpy(namep->name, size + 1, nm);
-    namep->parent = parentp;
+    str_cpy(dentryp->name, size + 1, nm);
+    dentryp->node = childp;
     childp->lnkcnt++;
+    list_append(&dentryp->link, &parentp->cs_head);
-    unsigned long key = (unsigned long) parentp;
-    hash_table_insert(&childp->names, &key, &namep->link);
-    /* Insert the new node into the namespace. */
-    if (parentp->child) {
-        tmpfs_dentry_t *tmp = parentp->child;
-        while (tmp->sibling)
-            tmp = tmp->sibling;
-        tmp->sibling = childp;
-    } else {
-        parentp->child = childp;
-    }
     return EOK;
 }
-int tmpfs_unlink_node(void *prnt, void *chld)
+int tmpfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
 {
-    tmpfs_dentry_t *parentp = (tmpfs_dentry_t *)prnt;
-    tmpfs_dentry_t *childp = (tmpfs_dentry_t *)chld;
+    tmpfs_node_t *parentp = TMPFS_NODE(pfn);
+    tmpfs_node_t *childp = NULL;
+    tmpfs_dentry_t *dentryp;
+    link_t *lnk;
     if (!parentp)
         return EBUSY;
+    for (lnk = parentp->cs_head.next; lnk != &parentp->cs_head;
+        lnk = lnk->next) {
+        dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
+        if (!str_cmp(dentryp->name, nm)) {
+            childp = dentryp->node;
+            assert(FS_NODE(childp) == cfn);
+            break;
+        }
+    }
-    if (childp->child)
+    if (!childp)
+        return ENOENT;
+    if ((childp->lnkcnt == 1) && !list_empty(&childp->cs_head))
         return ENOTEMPTY;
-    if (parentp->child == childp) {
-        parentp->child = childp->sibling;
-    } else {
-        /* TODO: consider doubly linked list for organizing siblings. */
-        tmpfs_dentry_t *tmp = parentp->child;
-        while (tmp->sibling != childp)
-            tmp = tmp->sibling;
-        tmp->sibling = childp->sibling;
-    }
-    childp->sibling = NULL;
-    unsigned long key = (unsigned long) parentp;
-    hash_table_remove(&childp->names, &key, 1);
+    list_remove(&dentryp->link);
+    free(dentryp);
     childp->lnkcnt--;
     return EOK;
 }
-int tmpfs_destroy_node(void *nodep)
+int tmpfs_destroy_node(fs_node_t *fn)
 {
-    tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) nodep;
+    tmpfs_node_t *nodep = TMPFS_NODE(fn);
-    assert(!dentry->lnkcnt);
-    assert(!dentry->child);
-    assert(!dentry->sibling);
+    assert(!nodep->lnkcnt);
+    assert(list_empty(&nodep->cs_head));
     unsigned long key[] = {
-        [DENTRIES_KEY_INDEX] = dentry->index,
-        [DENTRIES_KEY_DEV] = dentry->dev_handle
+        [NODES_KEY_INDEX] = nodep->index,
+        [NODES_KEY_DEV] = nodep->dev_handle
     };
-    hash_table_remove(&dentries, key, 2);
+    hash_table_remove(&nodes, key, 2);
-    hash_table_destroy(&dentry->names);
-    if (dentry->type == TMPFS_FILE)
-        free(dentry->data);
-    free(dentry);
+    if (nodep->type == TMPFS_FILE)
+        free(nodep->data);
+    free(nodep->bp);
+    free(nodep);
     return EOK;
 }
 ,26 → 394,22
         return;
     }
-    tmpfs_dentry_t *root = tmpfs_root_get(dev_handle);
+    tmpfs_node_t *rootp = TMPFS_NODE(tmpfs_root_get(dev_handle));
     if (str_cmp(opts, "restore") == 0) {
         if (tmpfs_restore(dev_handle))
-            ipc_answer_3(rid, EOK, root->index, root->size,
-                root->lnkcnt);
+            ipc_answer_3(rid, EOK, rootp->index, rootp->size,
+                rootp->lnkcnt);
         else
             ipc_answer_0(rid, ELIMIT);
     } else {
-        ipc_answer_3(rid, EOK, root->index, root->size, root->lnkcnt);
+        ipc_answer_3(rid, EOK, rootp->index, rootp->size,
+            rootp->lnkcnt);
     }
 }
 void tmpfs_mount(ipc_callid_t rid, ipc_call_t *request)
 {
-    dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
-    fs_index_t mp_index = (fs_index_t) IPC_GET_ARG2(*request);
-    fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request);
-    dev_handle_t mr_dev_handle = (dev_handle_t) IPC_GET_ARG4(*request);
-    ipc_answer_0(rid, ENOTSUP);
+    libfs_mount(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
 }
 void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)
 ,20 → 424,20
     off_t pos = (off_t)IPC_GET_ARG3(*request);
     /*
-     * Lookup the respective dentry.
+     * Lookup the respective TMPFS node.
      */
     link_t *hlp;
     unsigned long key[] = {
-        [DENTRIES_KEY_INDEX] = index,
-        [DENTRIES_KEY_DEV] = dev_handle,
+        [NODES_KEY_INDEX] = index,
+        [NODES_KEY_DEV] = dev_handle,
     };
-    hlp = hash_table_find(&dentries, key);
+    hlp = hash_table_find(&nodes, key);
     if (!hlp) {
         ipc_answer_0(rid, ENOENT);
         return;
     }
-    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
-        dh_link);
+    tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
+        nh_link);
     /*
      * Receive the read request.
 ,15 → 451,16
     }
     size_t bytes;
-    if (dentry->type == TMPFS_FILE) {
-        bytes = max(0, min(dentry->size - pos, size));
-        (void) ipc_data_read_finalize(callid, dentry->data + pos,
+    if (nodep->type == TMPFS_FILE) {
+        bytes = max(0, min(nodep->size - pos, size));
+        (void) ipc_data_read_finalize(callid, nodep->data + pos,
             bytes);
     } else {
+        tmpfs_dentry_t *dentryp;
+        link_t *lnk;
         int i;
-        tmpfs_dentry_t *cur;
-        assert(dentry->type == TMPFS_DIRECTORY);
+        assert(nodep->type == TMPFS_DIRECTORY);
         /*
          * Yes, we really use O(n) algorithm here.
 ,24 → 467,21
          * If it bothers someone, it could be fixed by introducing a
          * hash table.
          */
-        for (i = 0, cur = dentry->child; i < pos && cur; i++,
-            cur = cur->sibling)
+        for (i = 0, lnk = nodep->cs_head.next;
+            i < pos && lnk != &nodep->cs_head;
+            i++, lnk = lnk->next)
             ;
-        if (!cur) {
+        if (lnk == &nodep->cs_head) {
             ipc_answer_0(callid, ENOENT);
             ipc_answer_1(rid, ENOENT, 0);
             return;
         }
-        unsigned long key = (unsigned long) dentry;
-        link_t *hlp = hash_table_find(&cur->names, &key);
-        assert(hlp);
-        tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t,
-            link);
+        dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
-        (void) ipc_data_read_finalize(callid, namep->name,
-            str_size(namep->name) + 1);
+        (void) ipc_data_read_finalize(callid, dentryp->name,
+            str_size(dentryp->name) + 1);
         bytes = 1;
     }
 ,20 → 498,20
     off_t pos = (off_t)IPC_GET_ARG3(*request);
     /*
-     * Lookup the respective dentry.
+     * Lookup the respective TMPFS node.
      */
     link_t *hlp;
     unsigned long key[] = {
-        [DENTRIES_KEY_INDEX] = index,
-        [DENTRIES_KEY_DEV] = dev_handle
+        [NODES_KEY_INDEX] = index,
+        [NODES_KEY_DEV] = dev_handle
     };
-    hlp = hash_table_find(&dentries, key);
+    hlp = hash_table_find(&nodes, key);
     if (!hlp) {
         ipc_answer_0(rid, ENOENT);
         return;
     }
-    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
-        dh_link);
+    tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
+        nh_link);
     /*
      * Receive the write request.
 ,13 → 527,13
     /*
      * Check whether the file needs to grow.
      */
-    if (pos + size <= dentry->size) {
+    if (pos + size <= nodep->size) {
         /* The file size is not changing. */
-        (void) ipc_data_write_finalize(callid, dentry->data + pos, size);
-        ipc_answer_2(rid, EOK, size, dentry->size);
+        (void) ipc_data_write_finalize(callid, nodep->data + pos, size);
+        ipc_answer_2(rid, EOK, size, nodep->size);
         return;
     }
-    size_t delta = (pos + size) - dentry->size;
+    size_t delta = (pos + size) - nodep->size;
     /*
      * At this point, we are deliberately extremely straightforward and
      * simply realloc the contents of the file on every write that grows the
 ,18 → 541,18
      * our heap allocator can save us and just grow the block whenever
      * possible.
      */
-    void *newdata = realloc(dentry->data, dentry->size + delta);
+    void *newdata = realloc(nodep->data, nodep->size + delta);
     if (!newdata) {
         ipc_answer_0(callid, ENOMEM);
-        ipc_answer_2(rid, EOK, 0, dentry->size);
+        ipc_answer_2(rid, EOK, 0, nodep->size);
         return;
     }
     /* Clear any newly allocated memory in order to emulate gaps. */
-    memset(newdata + dentry->size, 0, delta);
-    dentry->size += delta;
-    dentry->data = newdata;
-    (void) ipc_data_write_finalize(callid, dentry->data + pos, size);
-    ipc_answer_2(rid, EOK, size, dentry->size);
+    memset(newdata + nodep->size, 0, delta);
+    nodep->size += delta;
+    nodep->data = newdata;
+    (void) ipc_data_write_finalize(callid, nodep->data + pos, size);
+    ipc_answer_2(rid, EOK, size, nodep->size);
 }
 void tmpfs_truncate(ipc_callid_t rid, ipc_call_t *request)
 ,40 → 562,45
     size_t size = (off_t)IPC_GET_ARG3(*request);
     /*
-     * Lookup the respective dentry.
+     * Lookup the respective TMPFS node.
      */
     link_t *hlp;
     unsigned long key[] = {
-        [DENTRIES_KEY_INDEX] = index,
-        [DENTRIES_KEY_DEV] = dev_handle
+        [NODES_KEY_INDEX] = index,
+        [NODES_KEY_DEV] = dev_handle
     };
-    hlp = hash_table_find(&dentries, key);
+    hlp = hash_table_find(&nodes, key);
     if (!hlp) {
         ipc_answer_0(rid, ENOENT);
         return;
     }
-    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
-        dh_link);
+    tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
+        nh_link);
-    if (size == dentry->size) {
+    if (size == nodep->size) {
         ipc_answer_0(rid, EOK);
         return;
     }
-    void *newdata = realloc(dentry->data, size);
+    void *newdata = realloc(nodep->data, size);
     if (!newdata) {
         ipc_answer_0(rid, ENOMEM);
         return;
     }
-    if (size > dentry->size) {
-        size_t delta = size - dentry->size;
-        memset(newdata + dentry->size, 0, delta);
+    if (size > nodep->size) {
+        size_t delta = size - nodep->size;
+        memset(newdata + nodep->size, 0, delta);
     }
-    dentry->size = size;
-    dentry->data = newdata;
+    nodep->size = size;
+    nodep->data = newdata;
     ipc_answer_0(rid, EOK);
 }
+void tmpfs_close(ipc_callid_t rid, ipc_call_t *request)
+{
+    ipc_answer_0(rid, EOK);
+}
 void tmpfs_destroy(ipc_callid_t rid, ipc_call_t *request)
 {
     dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
 ,20 → 609,36
     link_t *hlp;
     unsigned long key[] = {
-        [DENTRIES_KEY_INDEX] = index,
-        [DENTRIES_KEY_DEV] = dev_handle
+        [NODES_KEY_INDEX] = index,
+        [NODES_KEY_DEV] = dev_handle
     };
-    hlp = hash_table_find(&dentries, key);
+    hlp = hash_table_find(&nodes, key);
     if (!hlp) {
         ipc_answer_0(rid, ENOENT);
         return;
     }
-    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
-        dh_link);
-    rc = tmpfs_destroy_node(dentry);
+    tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
+        nh_link);
+    rc = tmpfs_destroy_node(FS_NODE(nodep));
     ipc_answer_0(rid, rc);
 }
+void tmpfs_open_node(ipc_callid_t rid, ipc_call_t *request)
+{
+    libfs_open_node(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
+}
+void tmpfs_device(ipc_callid_t rid, ipc_call_t *request)
+{
+    ipc_answer_0(rid, ENOTSUP);
+}
+void tmpfs_sync(ipc_callid_t rid, ipc_call_t *request)
+{
+    /* Dummy implementation */
+    ipc_answer_0(rid, EOK);
+}
 /**
  * @}
- */
+ */

 /branches/network/uspace/srv/fs/tmpfs/Makefile
 ,7 → 72,7
 disasm: $(OUTPUT).disasm
 $(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
+    $(OBJDUMP) -d $< > $@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/network/uspace/srv/fs/fat/fat_idx.c
 ,10 → 39,10
 #include "../../vfs/vfs.h"
 #include <errno.h>
 #include <string.h>
-#include <libadt/hash_table.h>
-#include <libadt/list.h>
+#include <adt/hash_table.h>
+#include <adt/list.h>
 #include <assert.h>
-#include <futex.h>
+#include <fibril_sync.h>
 /** Each instance of this type describes one interval of freed VFS indices. */
 typedef struct {
 ,8 → 68,8
     link_t      freed_head;
 } unused_t;
-/** Futex protecting the list of unused structures. */
-static futex_t unused_futex = FUTEX_INITIALIZER;
+/** Mutex protecting the list of unused structures. */
+static FIBRIL_MUTEX_INITIALIZE(unused_lock);
 /** List of unused structures. */
 static LIST_INITIALIZE(unused_head);
 ,7 → 89,7
     link_t *l;
     if (lock)
-        futex_down(&unused_futex);
+        fibril_mutex_lock(&unused_lock);
     for (l = unused_head.next; l != &unused_head; l = l->next) {
         u = list_get_instance(l, unused_t, link);
         if (u->dev_handle == dev_handle)
 ,12 → 96,12
             return u;
     }
     if (lock)
-        futex_up(&unused_futex);
+        fibril_mutex_unlock(&unused_lock);
     return NULL;
 }
-/** Futex protecting the up_hash and ui_hash. */
-static futex_t used_futex = FUTEX_INITIALIZER;
+/** Mutex protecting the up_hash and ui_hash. */
+static FIBRIL_MUTEX_INITIALIZE(used_lock);
 /**
  * Global hash table of all used fat_idx_t structures.
 ,7 → 231,7
              */
             *index = u->next++;
             --u->remaining;
-            futex_up(&unused_futex);
+            fibril_mutex_unlock(&unused_lock);
             return true;
         }
     } else {
 ,7 → 244,7
             list_remove(&f->link);
             free(f);
         }
-        futex_up(&unused_futex);
+        fibril_mutex_unlock(&unused_lock);
         return true;
     }
     /*
 ,7 → 252,7
      * theoretically still possible (e.g. too many open unlinked nodes or
      * too many zero-sized nodes).
      */
-    futex_up(&unused_futex);
+    fibril_mutex_unlock(&unused_lock);
     return false;
 }
 ,7 → 302,7
                 if (lnk->prev != &u->freed_head)
                     try_coalesce_intervals(lnk->prev, lnk,
                         lnk);
-                futex_up(&unused_futex);
+                fibril_mutex_unlock(&unused_lock);
                 return;
             }
             if (f->last == index - 1) {
 ,7 → 310,7
                 if (lnk->next != &u->freed_head)
                     try_coalesce_intervals(lnk, lnk->next,
                         lnk);
-                futex_up(&unused_futex);
+                fibril_mutex_unlock(&unused_lock);
                 return;
             }
             if (index > f->first) {
 ,7 → 321,7
                 n->first = index;
                 n->last = index;
                 list_insert_before(&n->link, lnk);
-                futex_up(&unused_futex);
+                fibril_mutex_unlock(&unused_lock);
                 return;
             }
 ,7 → 335,7
         n->last = index;
         list_append(&n->link, &u->freed_head);
     }
-    futex_up(&unused_futex);
+    fibril_mutex_unlock(&unused_lock);
 }
 static fat_idx_t *fat_idx_create(dev_handle_t dev_handle)
 ,7 → 352,7
     link_initialize(&fidx->uph_link);
     link_initialize(&fidx->uih_link);
-    futex_initialize(&fidx->lock, 1);
+    fibril_mutex_initialize(&fidx->lock);
     fidx->dev_handle = dev_handle;
     fidx->pfc = FAT_CLST_RES0;  /* no parent yet */
     fidx->pdi = 0;
 ,10 → 365,10
 {
     fat_idx_t *fidx;
-    futex_down(&used_futex);
+    fibril_mutex_lock(&used_lock);
     fidx = fat_idx_create(dev_handle);
     if (!fidx) {
-        futex_up(&used_futex);
+        fibril_mutex_unlock(&used_lock);
         return NULL;
     }
 ,8 → 378,8
     };
     hash_table_insert(&ui_hash, ikey, &fidx->uih_link);
-    futex_down(&fidx->lock);
-    futex_up(&used_futex);
+    fibril_mutex_lock(&fidx->lock);
+    fibril_mutex_unlock(&used_lock);
     return fidx;
 }
 ,7 → 395,7
         [UPH_PDI_KEY] = pdi,
     };
-    futex_down(&used_futex);
+    fibril_mutex_lock(&used_lock);
     l = hash_table_find(&up_hash, pkey);
     if (l) {
         fidx = hash_table_get_instance(l, fat_idx_t, uph_link);
 ,7 → 402,7
     } else {
         fidx = fat_idx_create(dev_handle);
         if (!fidx) {
-            futex_up(&used_futex);
+            fibril_mutex_unlock(&used_lock);
             return NULL;
         }
 ,8 → 417,8
         hash_table_insert(&up_hash, pkey, &fidx->uph_link);
         hash_table_insert(&ui_hash, ikey, &fidx->uih_link);
     }
-    futex_down(&fidx->lock);
-    futex_up(&used_futex);
+    fibril_mutex_lock(&fidx->lock);
+    fibril_mutex_unlock(&used_lock);
     return fidx;
 }
 ,9 → 431,9
         [UPH_PDI_KEY] = idx->pdi,
     };
-    futex_down(&used_futex);
+    fibril_mutex_lock(&used_lock);
     hash_table_insert(&up_hash, pkey, &idx->uph_link);
-    futex_up(&used_futex);
+    fibril_mutex_unlock(&used_lock);
 }
 void fat_idx_hashout(fat_idx_t *idx)
 ,9 → 444,9
         [UPH_PDI_KEY] = idx->pdi,
     };
-    futex_down(&used_futex);
+    fibril_mutex_lock(&used_lock);
     hash_table_remove(&up_hash, pkey, 3);
-    futex_up(&used_futex);
+    fibril_mutex_unlock(&used_lock);
 }
 fat_idx_t *
 ,13 → 459,13
         [UIH_INDEX_KEY] = index,
     };
-    futex_down(&used_futex);
+    fibril_mutex_lock(&used_lock);
     l = hash_table_find(&ui_hash, ikey);
     if (l) {
         fidx = hash_table_get_instance(l, fat_idx_t, uih_link);
-        futex_down(&fidx->lock);
+        fibril_mutex_lock(&fidx->lock);
     }
-    futex_up(&used_futex);
+    fibril_mutex_unlock(&used_lock);
     return fidx;
 }
 ,7 → 483,7
     assert(idx->pfc == FAT_CLST_RES0);
-    futex_down(&used_futex);
+    fibril_mutex_lock(&used_lock);
     /*
      * Since we can only free unlinked nodes, the index structure is not
      * present in the position hash (uph). We therefore hash it out from
 ,7 → 490,7
      * the index hash only.
      */
     hash_table_remove(&ui_hash, ikey, 2);
-    futex_up(&used_futex);
+    fibril_mutex_unlock(&used_lock);
     /* Release the VFS index. */
     fat_index_free(idx->dev_handle, idx->index);
     /* Deallocate the structure. */
 ,12 → 524,12
     if (!u)
         return ENOMEM;
     unused_initialize(u, dev_handle);
-    futex_down(&unused_futex);
+    fibril_mutex_lock(&unused_lock);
     if (!unused_find(dev_handle, false))
         list_append(&u->link, &unused_head);
     else
         rc = EEXIST;
-    futex_up(&unused_futex);
+    fibril_mutex_unlock(&unused_lock);
     return rc;
 }
 ,7 → 540,7
     u = unused_find(dev_handle, true);
     assert(u);
     list_remove(&u->link);
-    futex_up(&unused_futex);
+    fibril_mutex_unlock(&unused_lock);
     while (!list_empty(&u->freed_head)) {
         freed_t *f;

 /branches/network/uspace/srv/fs/fat/fat.h
 ,6 → 35,7
 #include "fat_fat.h"
 #include <ipc/ipc.h>
+#include <fibril_sync.h>
 #include <libfs.h>
 #include <atomic.h>
 #include <sys/types.h>
 ,7 → 161,7
     /** Used indices (index) hash table link. */
     link_t      uih_link;
-    futex_t     lock;
+    fibril_mutex_t  lock;
     dev_handle_t    dev_handle;
     fs_index_t  index;
     /**
 ,7 → 179,10
 /** FAT in-core node. */
 typedef struct fat_node {
-    futex_t         lock;
+    /** Back pointer to the FS node. */
+    fs_node_t       *bp;
+    fibril_mutex_t      lock;
     fat_node_type_t     type;
     fat_idx_t       *idx;
     /**
 ,7 → 207,11
 extern void fat_read(ipc_callid_t, ipc_call_t *);
 extern void fat_write(ipc_callid_t, ipc_call_t *);
 extern void fat_truncate(ipc_callid_t, ipc_call_t *);
+extern void fat_close(ipc_callid_t, ipc_call_t *);
 extern void fat_destroy(ipc_callid_t, ipc_call_t *);
+extern void fat_open_node(ipc_callid_t, ipc_call_t *);
+extern void fat_device(ipc_callid_t, ipc_call_t *);
+extern void fat_sync(ipc_callid_t, ipc_call_t *);
 extern fat_idx_t *fat_idx_get_new(dev_handle_t);
 extern fat_idx_t *fat_idx_get_by_pos(dev_handle_t, fat_cluster_t, unsigned);

 /branches/network/uspace/srv/fs/fat/fat_dentry.c
 ,37 → 114,51
 void fat_dentry_name_get(const fat_dentry_t *d, char *buf)
 {
-    int i;
+    unsigned int i;
     for (i = 0; i < FAT_NAME_LEN; i++) {
         if (d->name[i] == FAT_PAD)
             break;
         if (d->name[i] == FAT_DENTRY_E5_ESC)
             *buf++ = 0xe5;
-        else
-            *buf++ = d->name[i];
+        else {
+            if (d->lcase & FAT_LCASE_LOWER_NAME)
+                *buf++ = tolower(d->name[i]);
+            else
+                *buf++ = d->name[i];
+        }
     }
     if (d->ext[0] != FAT_PAD)
         *buf++ = '.';
     for (i = 0; i < FAT_EXT_LEN; i++) {
         if (d->ext[i] == FAT_PAD) {
             *buf = '\0';
             return;
         }
         if (d->ext[i] == FAT_DENTRY_E5_ESC)
             *buf++ = 0xe5;
-        else
-            *buf++ = d->ext[i];
+        else {
+            if (d->lcase & FAT_LCASE_LOWER_EXT)
+                *buf++ = tolower(d->ext[i]);
+            else
+                *buf++ = d->ext[i];
+        }
     }
     *buf = '\0';
 }
 void fat_dentry_name_set(fat_dentry_t *d, const char *name)
 {
-    int i;
+    unsigned int i;
     const char fake_ext[] = "   ";
+    bool lower_name = true;
+    bool lower_ext = true;
     for (i = 0; i < FAT_NAME_LEN; i++) {
         switch ((uint8_t) *name) {
         case 0xe5:
 ,12 → 170,19
             d->name[i] = FAT_PAD;
             break;
         default:
+            if (isalpha(*name)) {
+                if (!islower(*name))
+                    lower_name = false;
+            }
             d->name[i] = toupper(*name++);
             break;
         }
     }
     if (*name++ != '.')
         name = fake_ext;
     for (i = 0; i < FAT_EXT_LEN; i++) {
         switch ((uint8_t) *name) {
         case 0xe5:
 ,10 → 193,25
             d->ext[i] = FAT_PAD;
             break;
         default:
+            if (isalpha(*name)) {
+                if (!islower(*name))
+                    lower_ext = false;
+            }
             d->ext[i] = toupper(*name++);
             break;
         }
     }
+    if (lower_name)
+        d->lcase |= FAT_LCASE_LOWER_NAME;
+    else
+        d->lcase &= ~FAT_LCASE_LOWER_NAME;
+    if (lower_ext)
+        d->lcase |= FAT_LCASE_LOWER_EXT;
+    else
+        d->lcase &= ~FAT_LCASE_LOWER_EXT;
 }
 fat_dentry_clsf_t fat_classify_dentry(const fat_dentry_t *d)

 /branches/network/uspace/srv/fs/fat/fat_dentry.h
 ,6 → 47,9
 #define FAT_ATTR_VOLLABEL   (1 << 3)
 #define FAT_ATTR_SUBDIR     (1 << 4)
+#define FAT_LCASE_LOWER_NAME    0x08
+#define FAT_LCASE_LOWER_EXT 0x10
 #define FAT_PAD         ' '
 #define FAT_DENTRY_UNUSED   0x00
 ,7 → 68,7
     uint8_t     name[8];
     uint8_t     ext[3];
     uint8_t     attr;
-    uint8_t     reserved;
+    uint8_t     lcase;
     uint8_t     ctime_fine;
     uint16_t    ctime;
     uint16_t    cdate;

 /branches/network/uspace/srv/fs/fat/fat_fat.c
 ,14 → 45,15
 #include <byteorder.h>
 #include <align.h>
 #include <assert.h>
-#include <futex.h>
+#include <fibril_sync.h>
+#include <mem.h>
 /**
- * The fat_alloc_lock futex protects all copies of the File Allocation Table
+ * The fat_alloc_lock mutex protects all copies of the File Allocation Table
  * during allocation of clusters. The lock does not have to be held durring
  * deallocation of clusters.
  */
-static futex_t fat_alloc_lock = FUTEX_INITIALIZER;
+static FIBRIL_MUTEX_INITIALIZE(fat_alloc_lock);
 /** Walk the cluster chain.
  *
 ,7 → 326,7
     /*
      * Search FAT1 for unused clusters.
      */
-    futex_down(&fat_alloc_lock);
+    fibril_mutex_lock(&fat_alloc_lock);
     for (b = 0, cl = 0; b < sf; b++) {
         blk = block_get(dev_handle, rscnt + b, BLOCK_FLAGS_NONE);
         for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {
 ,7 → 350,7
                     *mcl = lifo[found - 1];
                     *lcl = lifo[0];
                     free(lifo);
-                    futex_up(&fat_alloc_lock);
+                    fibril_mutex_unlock(&fat_alloc_lock);
                     return EOK;
                 }
             }
 ,7 → 357,7
         }
         block_put(blk);
     }
-    futex_up(&fat_alloc_lock);
+    fibril_mutex_unlock(&fat_alloc_lock);
     /*
      * We could not find enough clusters. Now we need to free the clusters

 /branches/network/uspace/srv/fs/fat/fat.c
 ,6 → 89,8
         callid = async_get_call(&call);
         switch  (IPC_GET_METHOD(call)) {
+        case IPC_M_PHONE_HUNGUP:
+            return;
         case VFS_MOUNTED:
             fat_mounted(callid, &call);
             break;
 ,9 → 109,21
         case VFS_TRUNCATE:
             fat_truncate(callid, &call);
             break;
+        case VFS_CLOSE:
+            fat_close(callid, &call);
+            break;
         case VFS_DESTROY:
             fat_destroy(callid, &call);
             break;
+        case VFS_OPEN_NODE:
+            fat_open_node(callid, &call);
+            break;
+        case VFS_DEVICE:
+            fat_device(callid, &call);
+            break;
+        case VFS_SYNC:
+            fat_sync(callid, &call);
+            break;
         default:
             ipc_answer_0(callid, ENOTSUP);
             break;

 /branches/network/uspace/srv/fs/fat/fat_ops.c
 ,22 → 48,26
 #include <errno.h>
 #include <string.h>
 #include <byteorder.h>
-#include <libadt/hash_table.h>
-#include <libadt/list.h>
+#include <adt/hash_table.h>
+#include <adt/list.h>
 #include <assert.h>
-#include <futex.h>
+#include <fibril_sync.h>
 #include <sys/mman.h>
 #include <align.h>
-/** Futex protecting the list of cached free FAT nodes. */
-static futex_t ffn_futex = FUTEX_INITIALIZER;
+#define FAT_NODE(node)  ((node) ? (fat_node_t *) (node)->data : NULL)
+#define FS_NODE(node)   ((node) ? (node)->bp : NULL)
+/** Mutex protecting the list of cached free FAT nodes. */
+static FIBRIL_MUTEX_INITIALIZE(ffn_mutex);
 /** List of cached free FAT nodes. */
 static LIST_INITIALIZE(ffn_head);
 static void fat_node_initialize(fat_node_t *node)
 {
-    futex_initialize(&node->lock, 1);
+    fibril_mutex_initialize(&node->lock);
+    node->bp = NULL;
     node->idx = NULL;
     node->type = 0;
     link_initialize(&node->ffn_link);
 ,36 → 112,46
 static fat_node_t *fat_node_get_new(void)
 {
+    fs_node_t *fn;
     fat_node_t *nodep;
-    futex_down(&ffn_futex);
+    fibril_mutex_lock(&ffn_mutex);
     if (!list_empty(&ffn_head)) {
         /* Try to use a cached free node structure. */
         fat_idx_t *idxp_tmp;
         nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);
-        if (futex_trydown(&nodep->lock) == ESYNCH_WOULD_BLOCK)
+        if (!fibril_mutex_trylock(&nodep->lock))
             goto skip_cache;
         idxp_tmp = nodep->idx;
-        if (futex_trydown(&idxp_tmp->lock) == ESYNCH_WOULD_BLOCK) {
-            futex_up(&nodep->lock);
+        if (!fibril_mutex_trylock(&idxp_tmp->lock)) {
+            fibril_mutex_unlock(&nodep->lock);
             goto skip_cache;
         }
         list_remove(&nodep->ffn_link);
-        futex_up(&ffn_futex);
+        fibril_mutex_unlock(&ffn_mutex);
         if (nodep->dirty)
             fat_node_sync(nodep);
         idxp_tmp->nodep = NULL;
-        futex_up(&nodep->lock);
-        futex_up(&idxp_tmp->lock);
+        fibril_mutex_unlock(&nodep->lock);
+        fibril_mutex_unlock(&idxp_tmp->lock);
+        fn = FS_NODE(nodep);
     } else {
 skip_cache:
         /* Try to allocate a new node structure. */
-        futex_up(&ffn_futex);
+        fibril_mutex_unlock(&ffn_mutex);
+        fn = (fs_node_t *)malloc(sizeof(fs_node_t));
+        if (!fn)
+            return NULL;
         nodep = (fat_node_t *)malloc(sizeof(fat_node_t));
-        if (!nodep)
+        if (!nodep) {
+            free(fn);
             return NULL;
+        }
     }
     fat_node_initialize(nodep);
+    fs_node_initialize(fn);
+    fn->data = nodep;
+    nodep->bp = fn;
     return nodep;
 }
 ,7 → 160,7
  *
  * @param idxp      Locked index structure.
  */
-static void *fat_node_get_core(fat_idx_t *idxp)
+static fat_node_t *fat_node_get_core(fat_idx_t *idxp)
 {
     block_t *b;
     fat_bs_t *bs;
 ,10 → 175,10
          * We are lucky.
          * The node is already instantiated in memory.
          */
-        futex_down(&idxp->nodep->lock);
+        fibril_mutex_lock(&idxp->nodep->lock);
         if (!idxp->nodep->refcnt++)
             list_remove(&idxp->nodep->ffn_link);
-        futex_up(&idxp->nodep->lock);
+        fibril_mutex_unlock(&idxp->nodep->lock);
         return idxp->nodep;
     }
 ,21 → 237,21
 /*
  * Forward declarations of FAT libfs operations.
  */
-static void *fat_node_get(dev_handle_t, fs_index_t);
-static void fat_node_put(void *);
-static void *fat_create_node(dev_handle_t, int);
-static int fat_destroy_node(void *);
-static int fat_link(void *, void *, const char *);
-static int fat_unlink(void *, void *);
-static void *fat_match(void *, const char *);
-static fs_index_t fat_index_get(void *);
-static size_t fat_size_get(void *);
-static unsigned fat_lnkcnt_get(void *);
-static bool fat_has_children(void *);
-static void *fat_root_get(dev_handle_t);
+static fs_node_t *fat_node_get(dev_handle_t, fs_index_t);
+static void fat_node_put(fs_node_t *);
+static fs_node_t *fat_create_node(dev_handle_t, int);
+static int fat_destroy_node(fs_node_t *);
+static int fat_link(fs_node_t *, fs_node_t *, const char *);
+static int fat_unlink(fs_node_t *, fs_node_t *, const char *);
+static fs_node_t *fat_match(fs_node_t *, const char *);
+static fs_index_t fat_index_get(fs_node_t *);
+static size_t fat_size_get(fs_node_t *);
+static unsigned fat_lnkcnt_get(fs_node_t *);
+static bool fat_has_children(fs_node_t *);
+static fs_node_t *fat_root_get(dev_handle_t);
 static char fat_plb_get_char(unsigned);
-static bool fat_is_directory(void *);
-static bool fat_is_file(void *node);
+static bool fat_is_directory(fs_node_t *);
+static bool fat_is_file(fs_node_t *node);
 /*
  * FAT libfs operations.
 ,9 → 258,9
  */
 /** Instantiate a FAT in-core node. */
-void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
+fs_node_t *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
 {
-    void *node;
+    fat_node_t *nodep;
     fat_idx_t *idxp;
     idxp = fat_idx_get_by_index(dev_handle, index);
 ,22 → 267,22
     if (!idxp)
         return NULL;
     /* idxp->lock held */
-    node = fat_node_get_core(idxp);
-    futex_up(&idxp->lock);
-    return node;
+    nodep = fat_node_get_core(idxp);
+    fibril_mutex_unlock(&idxp->lock);
+    return FS_NODE(nodep);
 }
-void fat_node_put(void *node)
+void fat_node_put(fs_node_t *fn)
 {
-    fat_node_t *nodep = (fat_node_t *)node;
+    fat_node_t *nodep = FAT_NODE(fn);
     bool destroy = false;
-    futex_down(&nodep->lock);
+    fibril_mutex_lock(&nodep->lock);
     if (!--nodep->refcnt) {
         if (nodep->idx) {
-            futex_down(&ffn_futex);
+            fibril_mutex_lock(&ffn_mutex);
             list_append(&nodep->ffn_link, &ffn_head);
-            futex_up(&ffn_futex);
+            fibril_mutex_unlock(&ffn_mutex);
         } else {
             /*
              * The node does not have any index structure associated
 ,12 → 293,14
             destroy = true;
         }
     }
-    futex_up(&nodep->lock);
-    if (destroy)
-        free(node);
+    fibril_mutex_unlock(&nodep->lock);
+    if (destroy) {
+        free(nodep->bp);
+        free(nodep);
+    }
 }
-void *fat_create_node(dev_handle_t dev_handle, int flags)
+fs_node_t *fat_create_node(dev_handle_t dev_handle, int flags)
 {
     fat_idx_t *idxp;
     fat_node_t *nodep;
 ,7 → 326,7
     idxp = fat_idx_get_new(dev_handle);
     if (!idxp) {
         fat_free_clusters(bs, dev_handle, mcl);
-        fat_node_put(nodep);
+        fat_node_put(FS_NODE(nodep));
         return NULL;
     }
     /* idxp->lock held */
 ,13 → 360,13
     nodep->idx = idxp;
     idxp->nodep = nodep;
-    futex_up(&idxp->lock);
-    return nodep;
+    fibril_mutex_unlock(&idxp->lock);
+    return FS_NODE(nodep);
 }
-int fat_destroy_node(void *node)
+int fat_destroy_node(fs_node_t *fn)
 {
-    fat_node_t *nodep = (fat_node_t *)node;
+    fat_node_t *nodep = FAT_NODE(fn);
     fat_bs_t *bs;
     /*
 ,7 → 380,7
     /*
      * The node may not have any children.
      */
-    assert(fat_has_children(node) == false);
+    assert(fat_has_children(fn) == false);
     bs = block_bb_get(nodep->idx->dev_handle);
     if (nodep->firstc != FAT_CLST_RES0) {
 ,14 → 390,15
     }
     fat_idx_destroy(nodep->idx);
+    free(nodep->bp);
     free(nodep);
     return EOK;
 }
-int fat_link(void *prnt, void *chld, const char *name)
+int fat_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
 {
-    fat_node_t *parentp = (fat_node_t *)prnt;
-    fat_node_t *childp = (fat_node_t *)chld;
+    fat_node_t *parentp = FAT_NODE(pfn);
+    fat_node_t *childp = FAT_NODE(cfn);
     fat_dentry_t *d;
     fat_bs_t *bs;
     block_t *b;
 ,16 → 409,16
     fat_cluster_t mcl, lcl;
     int rc;
-    futex_down(&childp->lock);
+    fibril_mutex_lock(&childp->lock);
     if (childp->lnkcnt == 1) {
         /*
          * On FAT, we don't support multiple hard links.
          */
-        futex_up(&childp->lock);
+        fibril_mutex_unlock(&childp->lock);
         return EMLINK;
     }
     assert(childp->lnkcnt == 0);
-    futex_up(&childp->lock);
+    fibril_mutex_unlock(&childp->lock);
     if (!fat_dentry_name_verify(name)) {
         /*
 ,7 → 432,7
      * a new one.
      */
-    futex_down(&parentp->idx->lock);
+    fibril_mutex_lock(&parentp->idx->lock);
     bs = block_bb_get(parentp->idx->dev_handle);
     bps = uint16_t_le2host(bs->bps);
     dps = bps / sizeof(fat_dentry_t);
 ,12 → 463,12
      */
     if (parentp->idx->pfc == FAT_CLST_ROOT) {
         /* Can't grow the root directory. */
-        futex_up(&parentp->idx->lock);
+        fibril_mutex_unlock(&parentp->idx->lock);
         return ENOSPC;
     }
     rc = fat_alloc_clusters(bs, parentp->idx->dev_handle, 1, &mcl, &lcl);
     if (rc != EOK) {
-        futex_up(&parentp->idx->lock);
+        fibril_mutex_unlock(&parentp->idx->lock);
         return rc;
     }
     fat_append_clusters(bs, parentp, mcl);
 ,9 → 491,9
     fat_dentry_name_set(d, name);
     b->dirty = true;        /* need to sync block */
     block_put(b);
-    futex_up(&parentp->idx->lock);
+    fibril_mutex_unlock(&parentp->idx->lock);
-    futex_down(&childp->idx->lock);
+    fibril_mutex_lock(&childp->idx->lock);
     /*
      * If possible, create the Sub-directory Identifier Entry and the
 ,12 → 529,12
     childp->idx->pfc = parentp->firstc;
     childp->idx->pdi = i * dps + j;
-    futex_up(&childp->idx->lock);
+    fibril_mutex_unlock(&childp->idx->lock);
-    futex_down(&childp->lock);
+    fibril_mutex_lock(&childp->lock);
     childp->lnkcnt = 1;
     childp->dirty = true;       /* need to sync node */
-    futex_up(&childp->lock);
+    fibril_mutex_unlock(&childp->lock);
     /*
      * Hash in the index structure into the position hash.
 ,19 → 544,25
     return EOK;
 }
-int fat_unlink(void *prnt, void *chld)
+int fat_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
 {
-    fat_node_t *parentp = (fat_node_t *)prnt;
-    fat_node_t *childp = (fat_node_t *)chld;
+    fat_node_t *parentp = FAT_NODE(pfn);
+    fat_node_t *childp = FAT_NODE(cfn);
     fat_bs_t *bs;
     fat_dentry_t *d;
     uint16_t bps;
     block_t *b;
-    futex_down(&parentp->lock);
-    futex_down(&childp->lock);
+    if (!parentp)
+        return EBUSY;
+    if (fat_has_children(cfn))
+        return ENOTEMPTY;
+    fibril_mutex_lock(&parentp->lock);
+    fibril_mutex_lock(&childp->lock);
     assert(childp->lnkcnt == 1);
-    futex_down(&childp->idx->lock);
+    fibril_mutex_lock(&childp->idx->lock);
     bs = block_bb_get(childp->idx->dev_handle);
     bps = uint16_t_le2host(bs->bps);
 ,19 → 581,19
     /* clear position information */
     childp->idx->pfc = FAT_CLST_RES0;
     childp->idx->pdi = 0;
-    futex_up(&childp->idx->lock);
+    fibril_mutex_unlock(&childp->idx->lock);
     childp->lnkcnt = 0;
     childp->dirty = true;
-    futex_up(&childp->lock);
-    futex_up(&parentp->lock);
+    fibril_mutex_unlock(&childp->lock);
+    fibril_mutex_unlock(&parentp->lock);
     return EOK;
 }
-void *fat_match(void *prnt, const char *component)
+fs_node_t *fat_match(fs_node_t *pfn, const char *component)
 {
     fat_bs_t *bs;
-    fat_node_t *parentp = (fat_node_t *)prnt;
+    fat_node_t *parentp = FAT_NODE(pfn);
     char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
     unsigned i, j;
     unsigned bps;       /* bytes per sector */
 ,7 → 602,7
     fat_dentry_t *d;
     block_t *b;
-    futex_down(&parentp->idx->lock);
+    fibril_mutex_lock(&parentp->idx->lock);
     bs = block_bb_get(parentp->idx->dev_handle);
     bps = uint16_t_le2host(bs->bps);
     dps = bps / sizeof(fat_dentry_t);
 ,7 → 617,7
                 continue;
             case FAT_DENTRY_LAST:
                 block_put(b);
-                futex_up(&parentp->idx->lock);
+                fibril_mutex_unlock(&parentp->idx->lock);
                 return NULL;
             default:
             case FAT_DENTRY_VALID:
 ,7 → 626,7
             }
             if (fat_dentry_namecmp(name, component) == 0) {
                 /* hit */
-                void *node;
+                fat_node_t *nodep;
                 /*
                  * Assume tree hierarchy for locking.  We
                  * already have the parent and now we are going
 ,7 → 636,7
                 fat_idx_t *idx = fat_idx_get_by_pos(
                     parentp->idx->dev_handle, parentp->firstc,
                     i * dps + j);
-                futex_up(&parentp->idx->lock);
+                fibril_mutex_unlock(&parentp->idx->lock);
                 if (!idx) {
                     /*
                      * Can happen if memory is low or if we
 ,41 → 645,38
                     block_put(b);
                     return NULL;
                 }
-                node = fat_node_get_core(idx);
-                futex_up(&idx->lock);
+                nodep = fat_node_get_core(idx);
+                fibril_mutex_unlock(&idx->lock);
                 block_put(b);
-                return node;
+                return FS_NODE(nodep);
             }
         }
         block_put(b);
     }
-    futex_up(&parentp->idx->lock);
+    fibril_mutex_unlock(&parentp->idx->lock);
     return NULL;
 }
-fs_index_t fat_index_get(void *node)
+fs_index_t fat_index_get(fs_node_t *fn)
 {
-    fat_node_t *fnodep = (fat_node_t *)node;
-    if (!fnodep)
-        return 0;
-    return fnodep->idx->index;
+    return FAT_NODE(fn)->idx->index;
 }
-size_t fat_size_get(void *node)
+size_t fat_size_get(fs_node_t *fn)
 {
-    return ((fat_node_t *)node)->size;
+    return FAT_NODE(fn)->size;
 }
-unsigned fat_lnkcnt_get(void *node)
+unsigned fat_lnkcnt_get(fs_node_t *fn)
 {
-    return ((fat_node_t *)node)->lnkcnt;
+    return FAT_NODE(fn)->lnkcnt;
 }
-bool fat_has_children(void *node)
+bool fat_has_children(fs_node_t *fn)
 {
     fat_bs_t *bs;
-    fat_node_t *nodep = (fat_node_t *)node;
+    fat_node_t *nodep = FAT_NODE(fn);
     unsigned bps;
     unsigned dps;
     unsigned blocks;
 ,7 → 686,7
     if (nodep->type != FAT_DIRECTORY)
         return false;
-    futex_down(&nodep->idx->lock);
+    fibril_mutex_lock(&nodep->idx->lock);
     bs = block_bb_get(nodep->idx->dev_handle);
     bps = uint16_t_le2host(bs->bps);
     dps = bps / sizeof(fat_dentry_t);
 ,26 → 705,26
                 continue;
             case FAT_DENTRY_LAST:
                 block_put(b);
-                futex_up(&nodep->idx->lock);
+                fibril_mutex_unlock(&nodep->idx->lock);
                 return false;
             default:
             case FAT_DENTRY_VALID:
                 block_put(b);
-                futex_up(&nodep->idx->lock);
+                fibril_mutex_unlock(&nodep->idx->lock);
                 return true;
             }
             block_put(b);
-            futex_up(&nodep->idx->lock);
+            fibril_mutex_unlock(&nodep->idx->lock);
             return true;
         }
         block_put(b);
     }
-    futex_up(&nodep->idx->lock);
+    fibril_mutex_unlock(&nodep->idx->lock);
     return false;
 }
-void *fat_root_get(dev_handle_t dev_handle)
+fs_node_t *fat_root_get(dev_handle_t dev_handle)
 {
     return fat_node_get(dev_handle, 0);
 }
 ,14 → 734,14
     return fat_reg.plb_ro[pos % PLB_SIZE];
 }
-bool fat_is_directory(void *node)
+bool fat_is_directory(fs_node_t *fn)
 {
-    return ((fat_node_t *)node)->type == FAT_DIRECTORY;
+    return FAT_NODE(fn)->type == FAT_DIRECTORY;
 }
-bool fat_is_file(void *node)
+bool fat_is_file(fs_node_t *fn)
 {
-    return ((fat_node_t *)node)->type == FAT_FILE;
+    return FAT_NODE(fn)->type == FAT_FILE;
 }
 /** libfs operations */
 ,6 → 770,7
 void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
 {
     dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+    enum cache_mode cmode;
     fat_bs_t *bs;
     uint16_t bps;
     uint16_t rde;
 ,6 → 798,12
     }
     opts[size] = '\0';
+    /* Check for option enabling write through. */
+    if (str_cmp(opts, "wtcache") == 0)
+        cmode = CACHE_MODE_WT;
+    else
+        cmode = CACHE_MODE_WB;
     /* initialize libblock */
     rc = block_init(dev_handle, BS_SIZE);
     if (rc != EOK) {
 ,7 → 833,7
     }
     /* Initialize the block cache */
-    rc = block_cache_init(dev_handle, bps, 0 /* XXX */);
+    rc = block_cache_init(dev_handle, bps, 0 /* XXX */, cmode);
     if (rc != EOK) {
         block_fini(dev_handle);
         ipc_answer_0(rid, rc);
 ,8 → 848,17
     }
     /* Initialize the root node. */
+    fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
+    if (!rfn) {
+        block_fini(dev_handle);
+        fat_idx_fini_by_dev_handle(dev_handle);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
+    fs_node_initialize(rfn);
     fat_node_t *rootp = (fat_node_t *)malloc(sizeof(fat_node_t));
     if (!rootp) {
+        free(rfn);
         block_fini(dev_handle);
         fat_idx_fini_by_dev_handle(dev_handle);
         ipc_answer_0(rid, ENOMEM);
 ,8 → 868,9
     fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
     if (!ridxp) {
+        free(rfn);
+        free(rootp);
         block_fini(dev_handle);
-        free(rootp);
         fat_idx_fini_by_dev_handle(dev_handle);
         ipc_answer_0(rid, ENOMEM);
         return;
 ,8 → 885,10
     rootp->size = rde * sizeof(fat_dentry_t);
     rootp->idx = ridxp;
     ridxp->nodep = rootp;
+    rootp->bp = rfn;
+    rfn->data = rootp;
-    futex_up(&ridxp->lock);
+    fibril_mutex_unlock(&ridxp->lock);
     ipc_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
 }
 ,7 → 895,7
 void fat_mount(ipc_callid_t rid, ipc_call_t *request)
 {
-    ipc_answer_0(rid, ENOTSUP);
+    libfs_mount(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
 }
 void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
 ,21 → 908,23
     dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
     fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     off_t pos = (off_t)IPC_GET_ARG3(*request);
-    fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
+    fs_node_t *fn = fat_node_get(dev_handle, index);
+    fat_node_t *nodep;
     fat_bs_t *bs;
     uint16_t bps;
     size_t bytes;
     block_t *b;
-    if (!nodep) {
+    if (!fn) {
         ipc_answer_0(rid, ENOENT);
         return;
     }
+    nodep = FAT_NODE(fn);
     ipc_callid_t callid;
     size_t len;
     if (!ipc_data_read_receive(&callid, &len)) {
-        fat_node_put(nodep);
+        fat_node_put(fn);
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(rid, EINVAL);
         return;
 ,7 → 995,7
             bnum++;
         }
 miss:
-        fat_node_put(nodep);
+        fat_node_put(fn);
         ipc_answer_0(callid, ENOENT);
         ipc_answer_1(rid, ENOENT, 0);
         return;
 ,7 → 1004,7
         bytes = (pos - spos) + 1;
     }
-    fat_node_put(nodep);
+    fat_node_put(fn);
     ipc_answer_1(rid, EOK, (ipcarg_t)bytes);
 }
 ,7 → 1013,8
     dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
     fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     off_t pos = (off_t)IPC_GET_ARG3(*request);
-    fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
+    fs_node_t *fn = fat_node_get(dev_handle, index);
+    fat_node_t *nodep;
     fat_bs_t *bs;
     size_t bytes;
     block_t *b;
 ,15 → 1024,16
     off_t boundary;
     int flags = BLOCK_FLAGS_NONE;
-    if (!nodep) {
+    if (!fn) {
         ipc_answer_0(rid, ENOENT);
         return;
     }
+    nodep = FAT_NODE(fn);
     ipc_callid_t callid;
     size_t len;
     if (!ipc_data_write_receive(&callid, &len)) {
-        fat_node_put(nodep);
+        fat_node_put(fn);
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(rid, EINVAL);
         return;
 ,7 → 1074,7
             nodep->dirty = true;    /* need to sync node */
         }
         ipc_answer_2(rid, EOK, bytes, nodep->size);
-        fat_node_put(nodep);
+        fat_node_put(fn);
         return;
     } else {
         /*
 ,7 → 1090,7
         status = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl, &lcl);
         if (status != EOK) {
             /* could not allocate a chain of nclsts clusters */
-            fat_node_put(nodep);
+            fat_node_put(fn);
             ipc_answer_0(callid, status);
             ipc_answer_0(rid, status);
             return;
 ,7 → 1111,7
         nodep->size = pos + bytes;
         nodep->dirty = true;        /* need to sync node */
         ipc_answer_2(rid, EOK, bytes, nodep->size);
-        fat_node_put(nodep);
+        fat_node_put(fn);
         return;
     }
 }
 ,7 → 1121,8
     dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
     fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     size_t size = (off_t)IPC_GET_ARG3(*request);
-    fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
+    fs_node_t *fn = fat_node_get(dev_handle, index);
+    fat_node_t *nodep;
     fat_bs_t *bs;
     uint16_t bps;
     uint8_t spc;
 ,10 → 1129,11
     unsigned bpc;   /* bytes per cluster */
     int rc;
-    if (!nodep) {
+    if (!fn) {
         ipc_answer_0(rid, ENOENT);
         return;
     }
+    nodep = FAT_NODE(fn);
     bs = block_bb_get(dev_handle);
     bps = uint16_t_le2host(bs->bps);
 ,11 → 1171,16
         nodep->dirty = true;        /* need to sync node */
         rc = EOK;
     }
-    fat_node_put(nodep);
+    fat_node_put(fn);
     ipc_answer_0(rid, rc);
     return;
 }
+void fat_close(ipc_callid_t rid, ipc_call_t *request)
+{
+    ipc_answer_0(rid, EOK);
+}
 void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
 {
     dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
 ,16 → 1187,32
     fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     int rc;
-    fat_node_t *nodep = fat_node_get(dev_handle, index);
-    if (!nodep) {
+    fs_node_t *fn = fat_node_get(dev_handle, index);
+    if (!fn) {
         ipc_answer_0(rid, ENOENT);
         return;
     }
-    rc = fat_destroy_node(nodep);
+    rc = fat_destroy_node(fn);
     ipc_answer_0(rid, rc);
 }
+void fat_open_node(ipc_callid_t rid, ipc_call_t *request)
+{
+    libfs_open_node(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
+}
+void fat_device(ipc_callid_t rid, ipc_call_t *request)
+{
+    ipc_answer_0(rid, ENOTSUP);
+}
+void fat_sync(ipc_callid_t rid, ipc_call_t *request)
+{
+    /* Dummy implementation */
+    ipc_answer_0(rid, EOK);
+}
 /**
  * @}
- */
+ */

 /branches/network/uspace/srv/fs/fat/Makefile
 ,7 → 74,7
 disasm: $(OUTPUT).disasm
 $(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
+    $(OBJDUMP) -d $< > $@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/network/uspace/srv/devmap/Makefile
 ,10 → 34,8
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS += -I../libipc/include
+LIBS = $(LIBC_PREFIX)/libc.a
-LIBS =  $(LIBC_PREFIX)/libc.a
 ## Sources
 #
 ,7 → 65,7
 disasm: $(OUTPUT).disasm
 $(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
+    $(OBJDUMP) -d $< > $@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/network/uspace/srv/devmap/devmap.c
 ,7 → 41,7
 #include <stdio.h>
 #include <errno.h>
 #include <bool.h>
-#include <futex.h>
+#include <fibril_sync.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ipc/devmap.h>
 ,60 → 48,71
 #define NAME  "devmap"
-/** Pending lookup structure. */
+/** Representation of device driver.
+ *
+ * Each driver is responsible for a set of devices.
+ *
+ */
 typedef struct {
-    link_t link;
-    char *name;              /**< Device name */
-    ipc_callid_t callid;     /**< Call ID waiting for the lookup */
-} pending_req_t;
+    /** Pointers to previous and next drivers in linked list */
+    link_t drivers;
+    /** Pointer to the linked list of devices controlled by this driver */
+    link_t devices;
+    /** Phone asociated with this driver */
+    ipcarg_t phone;
+    /** Device driver name */
+    char *name;
+    /** Fibril mutex for list of devices owned by this driver */
+    fibril_mutex_t devices_mutex;
+} devmap_driver_t;
+/** Info about registered device
+ *
+ */
+typedef struct {
+    /** Pointer to the previous and next device in the list of all devices */
+    link_t devices;
+    /** Pointer to the previous and next device in the list of devices
+        owned by one driver */
+    link_t driver_devices;
+    /** Unique device identifier  */
+    dev_handle_t handle;
+    /** Device name */
+    char *name;
+    /** Device driver handling this device */
+    devmap_driver_t *driver;
+} devmap_device_t;
 LIST_INITIALIZE(devices_list);
 LIST_INITIALIZE(drivers_list);
-LIST_INITIALIZE(pending_req);
 /* Locking order:
- *  drivers_list_futex
- *  devices_list_futex
- *  (devmap_driver_t *)->devices_futex
- *  create_handle_futex
+ *  drivers_list_mutex
+ *  devices_list_mutex
+ *  (devmap_driver_t *)->devices_mutex
+ *  create_handle_mutex
  **/
-static atomic_t devices_list_futex = FUTEX_INITIALIZER;
-static atomic_t drivers_list_futex = FUTEX_INITIALIZER;
-static atomic_t create_handle_futex = FUTEX_INITIALIZER;
+static FIBRIL_MUTEX_INITIALIZE(devices_list_mutex);
+static FIBRIL_CONDVAR_INITIALIZE(devices_list_cv);
+static FIBRIL_MUTEX_INITIALIZE(drivers_list_mutex);
+static FIBRIL_MUTEX_INITIALIZE(create_handle_mutex);
-static int devmap_create_handle(void)
+static dev_handle_t last_handle = 0;
+static dev_handle_t devmap_create_handle(void)
 {
-    static int last_handle = 0;
-    int handle;
     /* TODO: allow reusing old handles after their unregistration
-     * and implement some version of LRU algorithm
+     * and implement some version of LRU algorithm, avoid overflow
      */
-    /* FIXME: overflow */
-    futex_down(&create_handle_futex);
+    fibril_mutex_lock(&create_handle_mutex);
+    last_handle++;
+    fibril_mutex_unlock(&create_handle_mutex);
-    last_handle += 1;
-    handle = last_handle;
-    futex_up(&create_handle_futex);
-    return handle;
+    return last_handle;
 }
-/** Initialize device mapper.
- *
- *
- */
-static int devmap_init()
-{
-    /* TODO: */
-    return EOK;
-}
 /** Find device with given name.
  *
  */
 ,7 → 123,7
     while (item != &devices_list) {
         device = list_get_instance(item, devmap_device_t, devices);
-        if (0 == str_cmp(device->name, name))
+        if (str_cmp(device->name, name) == 0)
             break;
         item = item->next;
     }
 ,9 → 140,9
  * @todo: use hash table
  *
  */
-static devmap_device_t *devmap_device_find_handle(int handle)
+static devmap_device_t *devmap_device_find_handle(dev_handle_t handle)
 {
-    futex_down(&devices_list_futex);
+    fibril_mutex_lock(&devices_list_mutex);
     link_t *item = (&devices_list)->next;
     devmap_device_t *device = NULL;
 ,22 → 155,20
     }
     if (item == &devices_list) {
-        futex_up(&devices_list_futex);
+        fibril_mutex_unlock(&devices_list_mutex);
         return NULL;
     }
     device = list_get_instance(item, devmap_device_t, devices);
-    futex_up(&devices_list_futex);
+    fibril_mutex_unlock(&devices_list_mutex);
     return device;
 }
 /**
- *
  * Unregister device and free it. It's assumed that driver's device list is
  * already locked.
- *
  */
 static int devmap_device_unregister_core(devmap_device_t *device)
 {
 ,10 → 182,8
 }
 /**
- *
  * Read info about new driver and add it into linked list of registered
  * drivers.
- *
  */
 static void devmap_driver_register(devmap_driver_t **odriver)
 {
 ,7 → 237,7
     /*
      * Send confirmation to sender and get data into buffer.
      */
-    if (EOK != ipc_data_write_finalize(callid, driver->name, name_size)) {
+    if (ipc_data_write_finalize(callid, driver->name, name_size) != EOK) {
         free(driver->name);
         free(driver);
         ipc_answer_0(iid, EREFUSED);
 ,21 → 246,21
     driver->name[name_size] = 0;
-    /* Initialize futex for list of devices owned by this driver */
-    futex_initialize(&(driver->devices_futex), 1);
+    /* Initialize mutex for list of devices owned by this driver */
+    fibril_mutex_initialize(&driver->devices_mutex);
     /*
      * Initialize list of asociated devices
      */
-    list_initialize(&(driver->devices));
+    list_initialize(&driver->devices);
     /*
-     * Create connection to the driver
+     * Create connection to the driver
      */
     ipc_call_t call;
     callid = async_get_call(&call);
-    if (IPC_M_CONNECT_TO_ME != IPC_GET_METHOD(call)) {
+    if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
         ipc_answer_0(callid, ENOTSUP);
         free(driver->name);
 ,7 → 275,7
     list_initialize(&(driver->drivers));
-    futex_down(&drivers_list_futex);
+    fibril_mutex_lock(&drivers_list_mutex);
     /* TODO:
      * check that no driver with name equal to driver->name is registered
 ,7 → 285,7
      * Insert new driver into list of registered drivers
      */
     list_append(&(driver->drivers), &drivers_list);
-    futex_up(&drivers_list_futex);
+    fibril_mutex_unlock(&drivers_list_mutex);
     ipc_answer_0(iid, EOK);
 ,18 → 302,18
     if (driver == NULL)
         return EEXISTS;
-    futex_down(&drivers_list_futex);
+    fibril_mutex_lock(&drivers_list_mutex);
-    ipc_hangup(driver->phone);
+    if (driver->phone != 0)
+        ipc_hangup(driver->phone);
-    /* remove it from list of drivers */
+    /* Remove it from list of drivers */
     list_remove(&(driver->drivers));
-    /* unregister all its devices */
+    /* Unregister all its devices */
+    fibril_mutex_lock(&devices_list_mutex);
+    fibril_mutex_lock(&driver->devices_mutex);
-    futex_down(&devices_list_futex);
-    futex_down(&(driver->devices_futex));
     while (!list_empty(&(driver->devices))) {
         devmap_device_t *device = list_get_instance(driver->devices.next,
             devmap_device_t, driver_devices);
 ,12 → 320,12
         devmap_device_unregister_core(device);
     }
-    futex_up(&(driver->devices_futex));
-    futex_up(&devices_list_futex);
-    futex_up(&drivers_list_futex);
+    fibril_mutex_unlock(&driver->devices_mutex);
+    fibril_mutex_unlock(&devices_list_mutex);
+    fibril_mutex_unlock(&drivers_list_mutex);
     /* free name and driver */
-    if (NULL != driver->name)
+    if (driver->name != NULL)
         free(driver->name);
     free(driver);
 ,30 → 333,6
     return EOK;
 }
-/** Process pending lookup requests */
-static void process_pending_lookup()
-{
-    link_t *cur;
-loop:
-    for (cur = pending_req.next; cur != &pending_req; cur = cur->next) {
-        pending_req_t *pr = list_get_instance(cur, pending_req_t, link);
-        const devmap_device_t *dev = devmap_device_find_name(pr->name);
-        if (!dev)
-            continue;
-        ipc_answer_1(pr->callid, EOK, dev->handle);
-        free(pr->name);
-        list_remove(cur);
-        free(pr);
-        goto loop;
-    }
-}
 /** Register instance of device
  *
  */
 ,12 → 383,12
     list_initialize(&(device->devices));
     list_initialize(&(device->driver_devices));
-    futex_down(&devices_list_futex);
+    fibril_mutex_lock(&devices_list_mutex);
     /* Check that device with such name is not already registered */
     if (NULL != devmap_device_find_name(device->name)) {
         printf(NAME ": Device '%s' already registered\n", device->name);
-        futex_up(&devices_list_futex);
+        fibril_mutex_unlock(&devices_list_mutex);
         free(device->name);
         free(device);
         ipc_answer_0(iid, EEXISTS);
 ,16 → 404,15
     list_append(&device->devices, &devices_list);
     /* Insert device into list of devices that belog to one driver */
-    futex_down(&device->driver->devices_futex);
+    fibril_mutex_lock(&device->driver->devices_mutex);
     list_append(&device->driver_devices, &device->driver->devices);
-    futex_up(&device->driver->devices_futex);
-    futex_up(&devices_list_futex);
+    fibril_mutex_unlock(&device->driver->devices_mutex);
+    fibril_condvar_broadcast(&devices_list_cv);
+    fibril_mutex_unlock(&devices_list_mutex);
     ipc_answer_1(iid, EOK, device->handle);
-    process_pending_lookup();
 }
 /**
 ,15 → 436,15
     /*
      * Get handle from request
      */
-    int handle = IPC_GET_ARG2(*call);
+    dev_handle_t handle = IPC_GET_ARG2(*call);
     devmap_device_t *dev = devmap_device_find_handle(handle);
-    if (NULL == dev) {
+    if ((dev == NULL) || (dev->driver == NULL) || (dev->driver->phone == 0)) {
         ipc_answer_0(callid, ENOENT);
         return;
     }
-    ipc_forward_fast(callid, dev->driver->phone, (ipcarg_t)(dev->handle),
+    ipc_forward_fast(callid, dev->driver->phone, dev->handle,
         IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
 }
 ,7 → 477,7
     /*
      * Allocate buffer for device name.
      */
-    char *name = (char *) malloc(size);
+    char *name = (char *) malloc(size + 1);
     if (name == NULL) {
         ipc_answer_0(callid, ENOMEM);
         ipc_answer_0(iid, EREFUSED);
 ,10 → 495,14
     }
     name[size] = '\0';
+    fibril_mutex_lock(&devices_list_mutex);
+    const devmap_device_t *dev;
+recheck:
     /*
-     * Find device name in linked list of known devices.
+     * Find device name in the list of known devices.
      */
-    const devmap_device_t *dev = devmap_device_find_name(name);
+    dev = devmap_device_find_name(name);
     /*
      * Device was not found.
 ,24 → 509,18
      */
     if (dev == NULL) {
         if (IPC_GET_ARG1(*icall) & IPC_FLAG_BLOCKING) {
-            /* Blocking lookup, add to pending list */
-            pending_req_t *pr = (pending_req_t *) malloc(sizeof(pending_req_t));
-            if (!pr) {
-                ipc_answer_0(iid, ENOMEM);
-                free(name);
-                return;
-            }
-            pr->name = name;
-            pr->callid = iid;
-            list_append(&pr->link, &pending_req);
-            return;
+            /* Blocking lookup */
+            fibril_condvar_wait(&devices_list_cv,
+                &devices_list_mutex);
+            goto recheck;
         }
         ipc_answer_0(iid, ENOENT);
         free(name);
+        fibril_mutex_unlock(&devices_list_mutex);
         return;
     }
+    fibril_mutex_unlock(&devices_list_mutex);
     ipc_answer_1(iid, EOK, dev->handle);
     free(name);
 ,7 → 529,7
 /** Find name of device identified by id and send it to caller.
  *
  */
-static void devmap_get_name(ipc_callid_t iid, ipc_call_t *icall)
+static void devmap_get_name(ipc_callid_t iid, ipc_call_t *icall)
 {
     const devmap_device_t *device = devmap_device_find_handle(IPC_GET_ARG1(*icall));
 ,6 → 559,99
     /* TODO: send name in response */
 }
+static void devmap_get_count(ipc_callid_t iid, ipc_call_t *icall)
+{
+    fibril_mutex_lock(&devices_list_mutex);
+    ipc_answer_1(iid, EOK, list_count(&devices_list));
+    fibril_mutex_unlock(&devices_list_mutex);
+}
+static void devmap_get_devices(ipc_callid_t iid, ipc_call_t *icall)
+{
+    fibril_mutex_lock(&devices_list_mutex);
+    ipc_callid_t callid;
+    size_t size;
+    if (!ipc_data_read_receive(&callid, &size)) {
+        ipc_answer_0(callid, EREFUSED);
+        ipc_answer_0(iid, EREFUSED);
+        return;
+    }
+    if ((size % sizeof(dev_desc_t)) != 0) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(iid, EREFUSED);
+        return;
+    }
+    size_t count = size / sizeof(dev_desc_t);
+    dev_desc_t *desc = (dev_desc_t *) malloc(size);
+    if (desc == NULL) {
+        ipc_answer_0(callid, ENOMEM);
+        ipc_answer_0(iid, EREFUSED);
+        return;
+    }
+    size_t pos = 0;
+    link_t *item = devices_list.next;
+    while ((item != &devices_list) && (pos < count)) {
+        devmap_device_t *device = list_get_instance(item, devmap_device_t, devices);
+        desc[pos].handle = device->handle;
+        str_cpy(desc[pos].name, DEVMAP_NAME_MAXLEN, device->name);
+        pos++;
+        item = item->next;
+    }
+    ipcarg_t retval = ipc_data_read_finalize(callid, desc, pos * sizeof(dev_desc_t));
+    if (retval != EOK) {
+        ipc_answer_0(iid, EREFUSED);
+        free(desc);
+        return;
+    }
+    free(desc);
+    fibril_mutex_unlock(&devices_list_mutex);
+    ipc_answer_1(iid, EOK, pos);
+}
+/** Initialize device mapper.
+ *
+ *
+ */
+static bool devmap_init(void)
+{
+    /* Create NULL device entry */
+    devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
+    if (device == NULL)
+        return false;
+    device->name = str_dup("null");
+    if (device->name == NULL) {
+        free(device);
+        return false;
+    }
+    list_initialize(&(device->devices));
+    list_initialize(&(device->driver_devices));
+    fibril_mutex_lock(&devices_list_mutex);
+    /* Get unique device handle */
+    device->handle = devmap_create_handle();
+    device->driver = NULL;
+    /* Insert device into list of all devices  */
+    list_append(&device->devices, &devices_list);
+    fibril_mutex_unlock(&devices_list_mutex);
+    return true;
+}
 /** Handle connection with device driver.
  *
  */
 ,7 → 660,7
     /* Accept connection */
     ipc_answer_0(iid, EOK);
-    devmap_driver_t *driver = NULL;
+    devmap_driver_t *driver = NULL;
     devmap_driver_register(&driver);
     if (NULL == driver)
 ,7 → 674,6
         switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
             cont = false;
-            /* Exit thread */
             continue;
         case DEVMAP_DRIVER_UNREGISTER:
             if (NULL == driver)
 ,7 → 693,7
             devmap_get_handle(callid, &call);
             break;
         case DEVMAP_DEVICE_GET_NAME:
-            devmap_get_handle(callid, &call);
+            devmap_get_name(callid, &call);
             break;
         default:
             if (!(callid & IPC_CALLID_NOTIFICATION))
 ,15 → 726,19
         switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
             cont = false;
-            /* Exit thread */
             continue;
         case DEVMAP_DEVICE_GET_HANDLE:
             devmap_get_handle(callid, &call);
             break;
         case DEVMAP_DEVICE_GET_NAME:
-            /* TODO */
             devmap_get_name(callid, &call);
             break;
+        case DEVMAP_DEVICE_GET_COUNT:
+            devmap_get_count(callid, &call);
+            break;
+        case DEVMAP_DEVICE_GET_DEVICES:
+            devmap_get_devices(callid, &call);
+            break;
         default:
             if (!(callid & IPC_CALLID_NOTIFICATION))
                 ipc_answer_0(callid, ENOENT);
 ,7 → 765,7
         break;
     default:
         /* No such interface */
-        ipc_answer_0(iid, ENOENT);
+        ipc_answer_0(iid, ENOENT);
     }
 }
 ,7 → 776,7
 {
     printf(NAME ": HelenOS Device Mapper\n");
-    if (devmap_init() != 0) {
+    if (!devmap_init()) {
         printf(NAME ": Error while initializing service\n");
         return -1;
     }
 ,7 → 783,7
     /* Set a handler of incomming connections */
     async_set_client_connection(devmap_connection);
     /* Register device mapper at naming service */
     ipcarg_t phonead;
     if (ipc_connect_to_me(PHONE_NS, SERVICE_DEVMAP, 0, 0, &phonead) != 0)

 /branches/network/uspace/srv/cir/obio/Makefile
 ,0 → 1,76
+#
+# Copyright (c) 2006 Martin Decky
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+## Setup toolchain
+#
+LIBC_PREFIX = ../../../lib/libc
+SOFTINT_PREFIX = ../../../lib/softint
+include $(LIBC_PREFIX)/Makefile.toolchain
+LIBS = $(LIBC_PREFIX)/libc.a
+## Sources
+#
+OUTPUT = obio
+SOURCES = \
+    obio.c
+OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
+.PHONY: all clean depend disasm
+all: $(OUTPUT) $(OUTPUT).disasm
+-include Makefile.depend
+clean:
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
+depend:
+    $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
+$(OUTPUT): $(OBJECTS) $(LIBS)
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< > $@
+%.o: %.S
+    $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@
+%.o: %.s
+    $(AS) $(AFLAGS) $< -o $@
+%.o: %.c
+    $(CC) $(DEFS) $(CFLAGS) -c $< -o $@

 /branches/network/uspace/srv/cir/obio/obio.c
 ,0 → 1,158
+/*
+ * Copyright (c) 2009 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup obio
+ * @{
+ */
+/**
+ * @file    obio.c
+ * @brief   OBIO driver.
+ *
+ * OBIO is a short for on-board I/O. On UltraSPARC IIi and systems with U2P,
+ * there is a piece of the root PCI bus controller address space, which
+ * contains interrupt mapping and clear registers for all on-board devices.
+ * Although UltraSPARC IIi and U2P are different in general, these registers can
+ * be found at the same addresses.
+ */
+#include <ipc/ipc.h>
+#include <ipc/services.h>
+#include <ipc/bus.h>
+#include <ipc/ns.h>
+#include <sysinfo.h>
+#include <as.h>
+#include <ddi.h>
+#include <align.h>
+#include <bool.h>
+#include <errno.h>
+#include <async.h>
+#include <align.h>
+#include <async.h>
+#include <stdio.h>
+#include <ipc/devmap.h>
+#define NAME "obio"
+#define OBIO_SIZE   0x1898
+#define OBIO_IMR_BASE   0x200
+#define OBIO_IMR(ino)   (OBIO_IMR_BASE + ((ino) & INO_MASK))
+#define OBIO_CIR_BASE   0x300
+#define OBIO_CIR(ino)   (OBIO_CIR_BASE + ((ino) & INO_MASK))
+#define INO_MASK    0x1f
+static void *base_phys;
+static volatile uint64_t *base_virt;
+/** Handle one connection to obio.
+ *
+ * @param iid       Hash of the request that opened the connection.
+ * @param icall     Call data of the request that opened the connection.
+ */
+static void obio_connection(ipc_callid_t iid, ipc_call_t *icall)
+{
+    ipc_callid_t callid;
+    ipc_call_t call;
+    /*
+     * Answer the first IPC_M_CONNECT_ME_TO call.
+     */
+    ipc_answer_0(iid, EOK);
+    while (1) {
+        int inr;
+        callid = async_get_call(&call);
+        switch (IPC_GET_METHOD(call)) {
+        case BUS_CLEAR_INTERRUPT:
+            inr = IPC_GET_ARG1(call);
+            base_virt[OBIO_CIR(inr & INO_MASK)] = 0;
+            ipc_answer_0(callid, EOK);
+            break;
+        default:
+            ipc_answer_0(callid, EINVAL);
+            break;
+        }
+    }
+}
+/** Initialize the OBIO driver.
+ *
+ * So far, the driver heavily depends on information provided by the kernel via
+ * sysinfo. In the future, there should be a standalone OBIO driver.
+ */
+static bool obio_init(void)
+{
+    ipcarg_t phonead;
+    base_phys = (void *) sysinfo_value("obio.base.physical");
+    if (!base_phys) {
+        printf(NAME ": no OBIO registers found\n");
+        return false;
+    }
+    base_virt = as_get_mappable_page(OBIO_SIZE);
+    int flags = AS_AREA_READ | AS_AREA_WRITE;
+    int retval = physmem_map(base_phys, (void *) base_virt,
+        ALIGN_UP(OBIO_SIZE, PAGE_SIZE) >> PAGE_WIDTH, flags);
+    if (retval < 0) {
+        printf(NAME ": Error mapping OBIO registers\n");
+        return false;
+    }
+    printf(NAME ": OBIO registers with base at %p\n", base_phys);
+    async_set_client_connection(obio_connection);
+    ipc_connect_to_me(PHONE_NS, SERVICE_OBIO, 0, 0, &phonead);
+    return true;
+}
+int main(int argc, char **argv)
+{
+    printf(NAME ": HelenOS OBIO driver\n");
+    if (!obio_init())
+        return -1;
+    printf(NAME ": Accepting connections\n");
+    async_manager();
+    /* Never reached */
+    return 0;
+}
+/**
+ * @}
+ */
 Property changes:
 Added: svn:mergeinfo

 /branches/network/uspace/srv/cir/fhc/Makefile
 ,0 → 1,76
+#
+# Copyright (c) 2006 Martin Decky
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+## Setup toolchain
+#
+LIBC_PREFIX = ../../../lib/libc
+SOFTINT_PREFIX = ../../../lib/softint
+include $(LIBC_PREFIX)/Makefile.toolchain
+LIBS = $(LIBC_PREFIX)/libc.a
+## Sources
+#
+OUTPUT = fhc
+SOURCES = \
+    fhc.c
+OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
+.PHONY: all clean depend disasm
+all: $(OUTPUT) $(OUTPUT).disasm
+-include Makefile.depend
+clean:
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
+depend:
+    $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
+$(OUTPUT): $(OBJECTS) $(LIBS)
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< > $@
+%.o: %.S
+    $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@
+%.o: %.s
+    $(AS) $(AFLAGS) $< -o $@
+%.o: %.c
+    $(CC) $(DEFS) $(CFLAGS) -c $< -o $@

 /branches/network/uspace/srv/cir/fhc/fhc.c
 ,0 → 1,157
+/*
+ * Copyright (c) 2009 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup fhc
+ * @{
+ */
+/**
+ * @file    fhc.c
+ * @brief   FHC bus controller driver.
+ */
+#include <ipc/ipc.h>
+#include <ipc/services.h>
+#include <ipc/bus.h>
+#include <ipc/ns.h>
+#include <sysinfo.h>
+#include <as.h>
+#include <ddi.h>
+#include <align.h>
+#include <bool.h>
+#include <errno.h>
+#include <async.h>
+#include <align.h>
+#include <async.h>
+#include <stdio.h>
+#include <ipc/devmap.h>
+#define NAME "fhc"
+#define FHC_UART_INR    0x39
+#define FHC_UART_IMAP   0x0
+#define FHC_UART_ICLR   0x4
+static void *fhc_uart_phys;
+static volatile uint32_t *fhc_uart_virt;
+static size_t fhc_uart_size;
+/** Handle one connection to fhc.
+ *
+ * @param iid       Hash of the request that opened the connection.
+ * @param icall     Call data of the request that opened the connection.
+ */
+static void fhc_connection(ipc_callid_t iid, ipc_call_t *icall)
+{
+    ipc_callid_t callid;
+    ipc_call_t call;
+    /*
+     * Answer the first IPC_M_CONNECT_ME_TO call.
+     */
+    ipc_answer_0(iid, EOK);
+    while (1) {
+        int inr;
+        callid = async_get_call(&call);
+        switch (IPC_GET_METHOD(call)) {
+        case BUS_CLEAR_INTERRUPT:
+            inr = IPC_GET_ARG1(call);
+            switch (inr) {
+            case FHC_UART_INR:
+                fhc_uart_virt[FHC_UART_ICLR] = 0;
+                ipc_answer_0(callid, EOK);
+                break;
+            default:
+                ipc_answer_0(callid, ENOTSUP);
+                break;
+            }
+            break;
+        default:
+            ipc_answer_0(callid, EINVAL);
+            break;
+        }
+    }
+}
+/** Initialize the FHC driver.
+ *
+ * So far, the driver heavily depends on information provided by the kernel via
+ * sysinfo. In the future, there should be a standalone FHC driver.
+ */
+static bool fhc_init(void)
+{
+    ipcarg_t phonead;
+    fhc_uart_size = sysinfo_value("fhc.uart.size");
+    fhc_uart_phys = (void *) sysinfo_value("fhc.uart.physical");
+    if (!fhc_uart_size) {
+        printf(NAME ": no FHC UART registers found\n");
+        return false;
+    }
+    fhc_uart_virt = as_get_mappable_page(fhc_uart_size);
+    int flags = AS_AREA_READ | AS_AREA_WRITE;
+    int retval = physmem_map(fhc_uart_phys, (void *) fhc_uart_virt,
+        ALIGN_UP(fhc_uart_size, PAGE_SIZE) >> PAGE_WIDTH, flags);
+    if (retval < 0) {
+        printf(NAME ": Error mapping FHC UART registers\n");
+        return false;
+    }
+    printf(NAME ": FHC UART registers at %p, %d bytes\n", fhc_uart_phys,
+        fhc_uart_size);
+    async_set_client_connection(fhc_connection);
+    ipc_connect_to_me(PHONE_NS, SERVICE_FHC, 0, 0, &phonead);
+    return true;
+}
+int main(int argc, char **argv)
+{
+    printf(NAME ": HelenOS FHC bus controller driver\n");
+    if (!fhc_init())
+        return -1;
+    printf(NAME ": Accepting connections\n");
+    async_manager();
+    /* Never reached */
+    return 0;
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/vfs/vfs.c
 ,7 → 43,6
 #include <bool.h>
 #include <string.h>
 #include <as.h>
-#include <libadt/list.h>
 #include <atomic.h>
 #include "vfs.h"
 ,7 → 51,7
 static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
     bool keep_on_going = true;
     /*
      * The connection was opened via the IPC_CONNECT_ME_TO call.
      * This call needs to be answered.
 ,28 → 79,9
         case IPC_M_PHONE_HUNGUP:
             keep_on_going = false;
             break;
-        case IPC_M_CONNECT_ME_TO:
-            /*
-             * Connect the client file system to another one.
-             */
-            /* FIXME:
-             * Prevent ordinary clients from connecting to file
-             * system servers directly. This should be solved by
-             * applying some security mechanisms.
-             */
-            fs_handle = IPC_GET_ARG1(call);
-            phone = vfs_grab_phone(fs_handle);
-            (void) ipc_forward_fast(callid, phone, 0, 0, 0,
-                IPC_FF_NONE);
-            vfs_release_phone(phone);
-            break;
         case VFS_REGISTER:
             vfs_register(callid, &call);
-            /*
-             * Keep the connection open so that a file system can
-             * later ask us to connect it to another file system.
-             * This is necessary to support non-root mounts.
-             */
+            keep_on_going = false;
             break;
         case VFS_MOUNT:
             vfs_mount(callid, &call);
 ,6 → 89,9
         case VFS_OPEN:
             vfs_open(callid, &call);
             break;
+        case VFS_OPEN_NODE:
+            vfs_open_node(callid, &call);
+            break;
         case VFS_CLOSE:
             vfs_close(callid, &call);
             break;
 ,6 → 116,15
         case VFS_RENAME:
             vfs_rename(callid, &call);
             break;
+        case VFS_DEVICE:
+            vfs_device(callid, &call);
+            break;
+        case VFS_SYNC:
+            vfs_sync(callid, &call);
+            break;
+        case VFS_NODE:
+            vfs_node(callid, &call);
+            break;
         default:
             ipc_answer_0(callid, ENOTSUP);
             break;
 ,11 → 139,6
     printf(NAME ": HelenOS VFS server\n");
     /*
-     * Initialize the list of registered file systems.
-     */
-    list_initialize(&fs_head);
-    /*
      * Initialize VFS node hash table.
      */
     if (!vfs_nodes_init()) {
 ,7 → 149,6
     /*
      * Allocate and initialize the Path Lookup Buffer.
      */
-    list_initialize(&plb_head);
     plb = as_get_mappable_page(PLB_SIZE);
     if (!plb) {
         printf(NAME ": Cannot allocate a mappable piece of address space\n");
 ,10 → 163,10
     memset(plb, 0, PLB_SIZE);
     /*
-     * Set a connectio handling function/fibril.
+     * Set a connection handling function/fibril.
      */
     async_set_client_connection(vfs_connection);
     /*
      * Register at the naming service.
      */

 /branches/network/uspace/srv/vfs/vfs_ops.c
 ,9 → 43,8
 #include <stdlib.h>
 #include <string.h>
 #include <bool.h>
-#include <futex.h>
-#include <rwlock.h>
-#include <libadt/list.h>
+#include <fibril_sync.h>
+#include <adt/list.h>
 #include <unistd.h>
 #include <ctype.h>
 #include <fcntl.h>
 ,26 → 54,12
 /* Forward declarations of static functions. */
 static int vfs_truncate_internal(fs_handle_t, dev_handle_t, fs_index_t, size_t);
-/** Pending mount structure. */
-typedef struct {
-    link_t link;
-    char *fs_name;            /**< File system name */
-    char *mp;                 /**< Mount point */
-    char *opts;       /**< Mount options. */
-    ipc_callid_t callid;      /**< Call ID waiting for the mount */
-    ipc_callid_t rid;         /**< Request ID */
-    dev_handle_t dev_handle;  /**< Device handle */
-} pending_req_t;
-LIST_INITIALIZE(pending_req);
 /**
  * This rwlock prevents the race between a triplet-to-VFS-node resolution and a
  * concurrent VFS operation which modifies the file system namespace.
  */
-RWLOCK_INITIALIZE(namespace_rwlock);
+FIBRIL_RWLOCK_INITIALIZE(namespace_rwlock);
-futex_t rootfs_futex = FUTEX_INITIALIZER;
 vfs_pair_t rootfs = {
     .fs_handle = 0,
     .dev_handle = 0
 ,21 → 69,24
     fs_handle_t fs_handle, char *mp, char *opts)
 {
     vfs_lookup_res_t mp_res;
+    vfs_lookup_res_t mr_res;
     vfs_node_t *mp_node = NULL;
+    vfs_node_t *mr_node;
+    fs_index_t rindex;
+    size_t rsize;
+    unsigned rlnkcnt;
     ipcarg_t rc;
     int phone;
     aid_t msg;
     ipc_call_t answer;
     /* Resolve the path to the mountpoint. */
-    futex_down(&rootfs_futex);
+    fibril_rwlock_write_lock(&namespace_rwlock);
     if (rootfs.fs_handle) {
         /* We already have the root FS. */
-        rwlock_write_lock(&namespace_rwlock);
         if (str_cmp(mp, "/") == 0) {
             /* Trying to mount root FS over root FS */
-            rwlock_write_unlock(&namespace_rwlock);
-            futex_up(&rootfs_futex);
+            fibril_rwlock_write_unlock(&namespace_rwlock);
             ipc_answer_0(rid, EBUSY);
             return;
         }
 ,8 → 94,7
         rc = vfs_lookup_internal(mp, L_DIRECTORY, &mp_res, NULL);
         if (rc != EOK) {
             /* The lookup failed for some reason. */
-            rwlock_write_unlock(&namespace_rwlock);
-            futex_up(&rootfs_futex);
+            fibril_rwlock_write_unlock(&namespace_rwlock);
             ipc_answer_0(rid, rc);
             return;
         }
 ,8 → 101,7
         mp_node = vfs_node_get(&mp_res);
         if (!mp_node) {
-            rwlock_write_unlock(&namespace_rwlock);
-            futex_up(&rootfs_futex);
+            fibril_rwlock_write_unlock(&namespace_rwlock);
             ipc_answer_0(rid, ENOMEM);
             return;
         }
 ,16 → 111,9
          * It will be dropped upon the corresponding VFS_UNMOUNT.
          * This prevents the mount point from being deleted.
          */
-        rwlock_write_unlock(&namespace_rwlock);
     } else {
         /* We still don't have the root file system mounted. */
         if (str_cmp(mp, "/") == 0) {
-            vfs_lookup_res_t mr_res;
-            vfs_node_t *mr_node;
-            fs_index_t rindex;
-            size_t rsize;
-            unsigned rlnkcnt;
             /*
              * For this simple, but important case,
              * we are almost done.
 ,7 → 129,7
             if (rc != EOK) {
                 async_wait_for(msg, NULL);
                 vfs_release_phone(phone);
-                futex_up(&rootfs_futex);
+                fibril_rwlock_write_unlock(&namespace_rwlock);
                 ipc_answer_0(rid, rc);
                 return;
             }
 ,7 → 137,7
             vfs_release_phone(phone);
             if (rc != EOK) {
-                futex_up(&rootfs_futex);
+                fibril_rwlock_write_unlock(&namespace_rwlock);
                 ipc_answer_0(rid, rc);
                 return;
             }
 ,12 → 155,12
             rootfs.fs_handle = fs_handle;
             rootfs.dev_handle = dev_handle;
-            futex_up(&rootfs_futex);
             /* Add reference to the mounted root. */
             mr_node = vfs_node_get(&mr_res);
             assert(mr_node);
+            fibril_rwlock_write_unlock(&namespace_rwlock);
             ipc_answer_0(rid, rc);
             return;
         } else {
 ,12 → 168,11
              * We can't resolve this without the root filesystem
              * being mounted first.
              */
-            futex_up(&rootfs_futex);
+            fibril_rwlock_write_unlock(&namespace_rwlock);
             ipc_answer_0(rid, ENOENT);
             return;
         }
     }
-    futex_up(&rootfs_futex);
     /*
      * At this point, we have all necessary pieces: file system and device
 ,6 → 179,9
      * handles, and we know the mount point VFS node.
      */
+    int mountee_phone = vfs_grab_phone(fs_handle);
+    assert(mountee_phone >= 0);
     phone = vfs_grab_phone(mp_res.triplet.fs_handle);
     msg = async_send_4(phone, VFS_MOUNT,
         (ipcarg_t) mp_res.triplet.dev_handle,
 ,6 → 188,23
         (ipcarg_t) mp_res.triplet.index,
         (ipcarg_t) fs_handle,
         (ipcarg_t) dev_handle, &answer);
+    /* send connection */
+    rc = async_req_1_0(phone, IPC_M_CONNECTION_CLONE, mountee_phone);
+    if (rc != EOK) {
+        async_wait_for(msg, NULL);
+        vfs_release_phone(mountee_phone);
+        vfs_release_phone(phone);
+        /* Mount failed, drop reference to mp_node. */
+        if (mp_node)
+            vfs_node_put(mp_node);
+        ipc_answer_0(rid, rc);
+        fibril_rwlock_write_unlock(&namespace_rwlock);
+        return;
+    }
+    vfs_release_phone(mountee_phone);
     /* send the mount options */
     rc = ipc_data_write_start(phone, (void *)opts, str_size(opts));
     if (rc != EOK) {
 ,6 → 213,7
         /* Mount failed, drop reference to mp_node. */
         if (mp_node)
             vfs_node_put(mp_node);
+        fibril_rwlock_write_unlock(&namespace_rwlock);
         ipc_answer_0(rid, rc);
         return;
     }
 ,44 → 220,31
     async_wait_for(msg, &rc);
     vfs_release_phone(phone);
-    if (rc != EOK) {
+    if (rc == EOK) {
+        rindex = (fs_index_t) IPC_GET_ARG1(answer);
+        rsize = (size_t) IPC_GET_ARG2(answer);
+        rlnkcnt = (unsigned) IPC_GET_ARG3(answer);
+        mr_res.triplet.fs_handle = fs_handle;
+        mr_res.triplet.dev_handle = dev_handle;
+        mr_res.triplet.index = rindex;
+        mr_res.size = rsize;
+        mr_res.lnkcnt = rlnkcnt;
+        mr_res.type = VFS_NODE_DIRECTORY;
+        /* Add reference to the mounted root. */
+        mr_node = vfs_node_get(&mr_res);
+        assert(mr_node);
+    } else {
         /* Mount failed, drop reference to mp_node. */
         if (mp_node)
             vfs_node_put(mp_node);
     }
     ipc_answer_0(rid, rc);
+    fibril_rwlock_write_unlock(&namespace_rwlock);
 }
-/** Process pending mount requests */
-void vfs_process_pending_mount()
-{
-    link_t *cur;
-loop:
-    for (cur = pending_req.next; cur != &pending_req; cur = cur->next) {
-        pending_req_t *pr = list_get_instance(cur, pending_req_t, link);
-        fs_handle_t fs_handle = fs_name_to_handle(pr->fs_name, true);
-        if (!fs_handle)
-            continue;
-        /* Acknowledge that we know fs_name. */
-        ipc_answer_0(pr->callid, EOK);
-        /* Do the mount */
-        vfs_mount_internal(pr->rid, pr->dev_handle, fs_handle, pr->mp,
-            pr->opts);
-        free(pr->fs_name);
-        free(pr->mp);
-        free(pr->opts);
-        list_remove(cur);
-        free(pr);
-        goto loop;
-    }
-}
 void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
 {
     /*
 ,33 → 398,17
      * Check if we know a file system with the same name as is in fs_name.
      * This will also give us its file system handle.
      */
-    fs_handle_t fs_handle = fs_name_to_handle(fs_name, true);
+    fibril_mutex_lock(&fs_head_lock);
+    fs_handle_t fs_handle;
+recheck:
+    fs_handle = fs_name_to_handle(fs_name, false);
     if (!fs_handle) {
         if (flags & IPC_FLAG_BLOCKING) {
-            pending_req_t *pr;
-            /* Blocking mount, add to pending list */
-            pr = (pending_req_t *) malloc(sizeof(pending_req_t));
-            if (!pr) {
-                ipc_answer_0(callid, ENOMEM);
-                ipc_answer_0(rid, ENOMEM);
-                free(mp);
-                free(fs_name);
-                free(opts);
-                return;
-            }
-            pr->fs_name = fs_name;
-            pr->mp = mp;
-            pr->opts = opts;
-            pr->callid = callid;
-            pr->rid = rid;
-            pr->dev_handle = dev_handle;
-            link_initialize(&pr->link);
-            list_append(&pr->link, &pending_req);
-            return;
+            fibril_condvar_wait(&fs_head_cv, &fs_head_lock);
+            goto recheck;
         }
+        fibril_mutex_unlock(&fs_head_lock);
         ipc_answer_0(callid, ENOENT);
         ipc_answer_0(rid, ENOENT);
         free(mp);
 ,6 → 416,7
         free(opts);
         return;
     }
+    fibril_mutex_unlock(&fs_head_lock);
     /* Acknowledge that we know fs_name. */
     ipc_answer_0(callid, EOK);
 ,7 → 434,7
         ipc_answer_0(rid, ENOMEM);
         return;
     }
     /*
      * The POSIX interface is open(path, oflag, mode).
      * We can receive oflags and mode along with the VFS_OPEN call; the path
 ,29 → 447,30
     int oflag = IPC_GET_ARG2(*request);
     int mode = IPC_GET_ARG3(*request);
     size_t len;
     /*
      * Make sure that we are called with exactly one of L_FILE and
-     * L_DIRECTORY.
+     * L_DIRECTORY. Make sure that the user does not pass L_OPEN.
      */
-    if ((lflag & (L_FILE | L_DIRECTORY)) == 0 ||
-        (lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY)) {
+    if (((lflag & (L_FILE | L_DIRECTORY)) == 0) ||
+        ((lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY)) ||
+        ((lflag & L_OPEN) != 0)) {
         ipc_answer_0(rid, EINVAL);
         return;
     }
     if (oflag & O_CREAT)
         lflag |= L_CREATE;
     if (oflag & O_EXCL)
         lflag |= L_EXCLUSIVE;
     ipc_callid_t callid;
     if (!ipc_data_write_receive(&callid, &len)) {
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(rid, EINVAL);
         return;
     }
     char *path = malloc(len + 1);
     if (!path) {
         ipc_answer_0(callid, ENOMEM);
 ,6 → 477,7
         ipc_answer_0(rid, ENOMEM);
         return;
     }
     int rc;
     if ((rc = ipc_data_write_finalize(callid, path, len))) {
         ipc_answer_0(rid, rc);
 ,40 → 492,40
      * triplet.
      */
     if (lflag & L_CREATE)
-        rwlock_write_lock(&namespace_rwlock);
+        fibril_rwlock_write_lock(&namespace_rwlock);
     else
-        rwlock_read_lock(&namespace_rwlock);
+        fibril_rwlock_read_lock(&namespace_rwlock);
     /* The path is now populated and we can call vfs_lookup_internal(). */
     vfs_lookup_res_t lr;
-    rc = vfs_lookup_internal(path, lflag, &lr, NULL);
-    if (rc) {
+    rc = vfs_lookup_internal(path, lflag | L_OPEN, &lr, NULL);
+    if (rc != EOK) {
         if (lflag & L_CREATE)
-            rwlock_write_unlock(&namespace_rwlock);
+            fibril_rwlock_write_unlock(&namespace_rwlock);
         else
-            rwlock_read_unlock(&namespace_rwlock);
+            fibril_rwlock_read_unlock(&namespace_rwlock);
         ipc_answer_0(rid, rc);
         free(path);
         return;
     }
     /* Path is no longer needed. */
     free(path);
     vfs_node_t *node = vfs_node_get(&lr);
     if (lflag & L_CREATE)
-        rwlock_write_unlock(&namespace_rwlock);
+        fibril_rwlock_write_unlock(&namespace_rwlock);
     else
-        rwlock_read_unlock(&namespace_rwlock);
+        fibril_rwlock_read_unlock(&namespace_rwlock);
     /* Truncate the file if requested and if necessary. */
     if (oflag & O_TRUNC) {
-        rwlock_write_lock(&node->contents_rwlock);
+        fibril_rwlock_write_lock(&node->contents_rwlock);
         if (node->size) {
             rc = vfs_truncate_internal(node->fs_handle,
                 node->dev_handle, node->index, 0);
             if (rc) {
-                rwlock_write_unlock(&node->contents_rwlock);
+                fibril_rwlock_write_unlock(&node->contents_rwlock);
                 vfs_node_put(node);
                 ipc_answer_0(rid, rc);
                 return;
 ,9 → 532,9
             }
             node->size = 0;
         }
-        rwlock_write_unlock(&node->contents_rwlock);
+        fibril_rwlock_write_unlock(&node->contents_rwlock);
     }
     /*
      * Get ourselves a file descriptor and the corresponding vfs_file_t
      * structure.
 ,10 → 547,87
     }
     vfs_file_t *file = vfs_file_get(fd);
     file->node = node;
-    if (oflag & O_APPEND)
+    if (oflag & O_APPEND)
         file->append = true;
+    /*
+     * The following increase in reference count is for the fact that the
+     * file is being opened and that a file structure is pointing to it.
+     * It is necessary so that the file will not disappear when
+     * vfs_node_put() is called. The reference will be dropped by the
+     * respective VFS_CLOSE.
+     */
+    vfs_node_addref(node);
+    vfs_node_put(node);
+    /* Success! Return the new file descriptor to the client. */
+    ipc_answer_1(rid, EOK, fd);
+}
+void vfs_open_node(ipc_callid_t rid, ipc_call_t *request)
+{
+    // FIXME: check for sanity of the supplied fs, dev and index
+    if (!vfs_files_init()) {
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
     /*
+     * The interface is open_node(fs, dev, index, oflag).
+     */
+    vfs_lookup_res_t lr;
+    lr.triplet.fs_handle = IPC_GET_ARG1(*request);
+    lr.triplet.dev_handle = IPC_GET_ARG2(*request);
+    lr.triplet.index = IPC_GET_ARG3(*request);
+    int oflag = IPC_GET_ARG4(*request);
+    fibril_rwlock_read_lock(&namespace_rwlock);
+    int rc = vfs_open_node_internal(&lr);
+    if (rc != EOK) {
+        fibril_rwlock_read_unlock(&namespace_rwlock);
+        ipc_answer_0(rid, rc);
+        return;
+    }
+    vfs_node_t *node = vfs_node_get(&lr);
+    fibril_rwlock_read_unlock(&namespace_rwlock);
+    /* Truncate the file if requested and if necessary. */
+    if (oflag & O_TRUNC) {
+        fibril_rwlock_write_lock(&node->contents_rwlock);
+        if (node->size) {
+            rc = vfs_truncate_internal(node->fs_handle,
+                node->dev_handle, node->index, 0);
+            if (rc) {
+                fibril_rwlock_write_unlock(&node->contents_rwlock);
+                vfs_node_put(node);
+                ipc_answer_0(rid, rc);
+                return;
+            }
+            node->size = 0;
+        }
+        fibril_rwlock_write_unlock(&node->contents_rwlock);
+    }
+    /*
+     * Get ourselves a file descriptor and the corresponding vfs_file_t
+     * structure.
+     */
+    int fd = vfs_fd_alloc();
+    if (fd < 0) {
+        vfs_node_put(node);
+        ipc_answer_0(rid, fd);
+        return;
+    }
+    vfs_file_t *file = vfs_file_get(fd);
+    file->node = node;
+    if (oflag & O_APPEND)
+        file->append = true;
+    /*
      * The following increase in reference count is for the fact that the
      * file is being opened and that a file structure is pointing to it.
      * It is necessary so that the file will not disappear when
 ,18 → 636,133
      */
     vfs_node_addref(node);
     vfs_node_put(node);
     /* Success! Return the new file descriptor to the client. */
     ipc_answer_1(rid, EOK, fd);
 }
-void vfs_close(ipc_callid_t rid, ipc_call_t *request)
+void vfs_node(ipc_callid_t rid, ipc_call_t *request)
 {
     int fd = IPC_GET_ARG1(*request);
-    int rc = vfs_fd_free(fd);
+    /* Lookup the file structure corresponding to the file descriptor. */
+    vfs_file_t *file = vfs_file_get(fd);
+    if (!file) {
+        ipc_answer_0(rid, ENOENT);
+        return;
+    }
+    ipc_answer_3(rid, EOK, file->node->fs_handle, file->node->dev_handle,
+        file->node->index);
+}
+void vfs_device(ipc_callid_t rid, ipc_call_t *request)
+{
+    int fd = IPC_GET_ARG1(*request);
+    /* Lookup the file structure corresponding to the file descriptor. */
+    vfs_file_t *file = vfs_file_get(fd);
+    if (!file) {
+        ipc_answer_0(rid, ENOENT);
+        return;
+    }
+    /*
+     * Lock the open file structure so that no other thread can manipulate
+     * the same open file at a time.
+     */
+    fibril_mutex_lock(&file->lock);
+    int fs_phone = vfs_grab_phone(file->node->fs_handle);
+    /* Make a VFS_DEVICE request at the destination FS server. */
+    aid_t msg;
+    ipc_call_t answer;
+    msg = async_send_2(fs_phone, IPC_GET_METHOD(*request),
+        file->node->dev_handle, file->node->index, &answer);
+    /* Wait for reply from the FS server. */
+    ipcarg_t rc;
+    async_wait_for(msg, &rc);
+    vfs_release_phone(fs_phone);
+    fibril_mutex_unlock(&file->lock);
+    ipc_answer_1(rid, EOK, IPC_GET_ARG1(answer));
+}
+void vfs_sync(ipc_callid_t rid, ipc_call_t *request)
+{
+    int fd = IPC_GET_ARG1(*request);
+    /* Lookup the file structure corresponding to the file descriptor. */
+    vfs_file_t *file = vfs_file_get(fd);
+    if (!file) {
+        ipc_answer_0(rid, ENOENT);
+        return;
+    }
+    /*
+     * Lock the open file structure so that no other thread can manipulate
+     * the same open file at a time.
+     */
+    fibril_mutex_lock(&file->lock);
+    int fs_phone = vfs_grab_phone(file->node->fs_handle);
+    /* Make a VFS_SYMC request at the destination FS server. */
+    aid_t msg;
+    ipc_call_t answer;
+    msg = async_send_2(fs_phone, IPC_GET_METHOD(*request),
+        file->node->dev_handle, file->node->index, &answer);
+    /* Wait for reply from the FS server. */
+    ipcarg_t rc;
+    async_wait_for(msg, &rc);
+    vfs_release_phone(fs_phone);
+    fibril_mutex_unlock(&file->lock);
     ipc_answer_0(rid, rc);
 }
+void vfs_close(ipc_callid_t rid, ipc_call_t *request)
+{
+    int fd = IPC_GET_ARG1(*request);
+    /* Lookup the file structure corresponding to the file descriptor. */
+    vfs_file_t *file = vfs_file_get(fd);
+    if (!file) {
+        ipc_answer_0(rid, ENOENT);
+        return;
+    }
+    /*
+     * Lock the open file structure so that no other thread can manipulate
+     * the same open file at a time.
+     */
+    fibril_mutex_lock(&file->lock);
+    int fs_phone = vfs_grab_phone(file->node->fs_handle);
+    /* Make a VFS_CLOSE request at the destination FS server. */
+    aid_t msg;
+    ipc_call_t answer;
+    msg = async_send_2(fs_phone, IPC_GET_METHOD(*request),
+        file->node->dev_handle, file->node->index, &answer);
+    /* Wait for reply from the FS server. */
+    ipcarg_t rc;
+    async_wait_for(msg, &rc);
+    vfs_release_phone(fs_phone);
+    fibril_mutex_unlock(&file->lock);
+    int retval = IPC_GET_ARG1(answer);
+    if (retval != EOK)
+        ipc_answer_0(rid, retval);
+    retval = vfs_fd_free(fd);
+    ipc_answer_0(rid, retval);
+}
 static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)
 {
 ,7 → 805,7
      * Lock the open file structure so that no other thread can manipulate
      * the same open file at a time.
      */
-    futex_down(&file->lock);
+    fibril_mutex_lock(&file->lock);
     /*
      * Lock the file's node so that no other client can read/write to it at
 ,9 → 812,9
      * the same time.
      */
     if (read)
-        rwlock_read_lock(&file->node->contents_rwlock);
+        fibril_rwlock_read_lock(&file->node->contents_rwlock);
     else
-        rwlock_write_lock(&file->node->contents_rwlock);
+        fibril_rwlock_write_lock(&file->node->contents_rwlock);
     if (file->node->type == VFS_NODE_DIRECTORY) {
         /*
 ,7 → 822,7
          * while we are in readdir().
          */
         assert(read);
-        rwlock_read_lock(&namespace_rwlock);
+        fibril_rwlock_read_lock(&namespace_rwlock);
     }
     int fs_phone = vfs_grab_phone(file->node->fs_handle);
 ,31 → 842,32
      * don't have to bother.
      */
     ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
+    /* Wait for reply from the FS server. */
+    ipcarg_t rc;
+    async_wait_for(msg, &rc);
     vfs_release_phone(fs_phone);
-    /* Wait for reply from the FS server. */
-    ipcarg_t rc;
-    async_wait_for(msg, &rc);
     size_t bytes = IPC_GET_ARG1(answer);
     if (file->node->type == VFS_NODE_DIRECTORY)
-        rwlock_read_unlock(&namespace_rwlock);
+        fibril_rwlock_read_unlock(&namespace_rwlock);
     /* Unlock the VFS node. */
     if (read)
-        rwlock_read_unlock(&file->node->contents_rwlock);
+        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
     else {
         /* Update the cached version of node's size. */
         if (rc == EOK)
             file->node->size = IPC_GET_ARG2(answer);
-        rwlock_write_unlock(&file->node->contents_rwlock);
+        fibril_rwlock_write_unlock(&file->node->contents_rwlock);
     }
     /* Update the position pointer and unlock the open file. */
     if (rc == EOK)
         file->pos += bytes;
-    futex_up(&file->lock);
+    fibril_mutex_unlock(&file->lock);
     /*
      * FS server's reply is the final result of the whole operation we
 ,40 → 901,40
     }
     off_t newpos;
-    futex_down(&file->lock);
+    fibril_mutex_lock(&file->lock);
     if (whence == SEEK_SET) {
         file->pos = off;
-        futex_up(&file->lock);
+        fibril_mutex_unlock(&file->lock);
         ipc_answer_1(rid, EOK, off);
         return;
     }
     if (whence == SEEK_CUR) {
         if (file->pos + off < file->pos) {
-            futex_up(&file->lock);
+            fibril_mutex_unlock(&file->lock);
             ipc_answer_0(rid, EOVERFLOW);
             return;
         }
         file->pos += off;
         newpos = file->pos;
-        futex_up(&file->lock);
+        fibril_mutex_unlock(&file->lock);
         ipc_answer_1(rid, EOK, newpos);
         return;
     }
     if (whence == SEEK_END) {
-        rwlock_read_lock(&file->node->contents_rwlock);
+        fibril_rwlock_read_lock(&file->node->contents_rwlock);
         size_t size = file->node->size;
-        rwlock_read_unlock(&file->node->contents_rwlock);
+        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
         if (size + off < size) {
-            futex_up(&file->lock);
+            fibril_mutex_unlock(&file->lock);
             ipc_answer_0(rid, EOVERFLOW);
             return;
         }
         newpos = size + off;
-        futex_up(&file->lock);
+        fibril_mutex_unlock(&file->lock);
         ipc_answer_1(rid, EOK, newpos);
         return;
     }
-    futex_up(&file->lock);
+    fibril_mutex_unlock(&file->lock);
     ipc_answer_0(rid, EINVAL);
 }
 ,16 → 963,16
         ipc_answer_0(rid, ENOENT);
         return;
     }
-    futex_down(&file->lock);
+    fibril_mutex_lock(&file->lock);
-    rwlock_write_lock(&file->node->contents_rwlock);
+    fibril_rwlock_write_lock(&file->node->contents_rwlock);
     rc = vfs_truncate_internal(file->node->fs_handle,
         file->node->dev_handle, file->node->index, size);
     if (rc == EOK)
         file->node->size = size;
-    rwlock_write_unlock(&file->node->contents_rwlock);
+    fibril_rwlock_write_unlock(&file->node->contents_rwlock);
-    futex_up(&file->lock);
+    fibril_mutex_unlock(&file->lock);
     ipc_answer_0(rid, (ipcarg_t)rc);
 }
 ,10 → 1002,10
     }
     path[len] = '\0';
-    rwlock_write_lock(&namespace_rwlock);
+    fibril_rwlock_write_lock(&namespace_rwlock);
     int lflag = L_DIRECTORY | L_CREATE | L_EXCLUSIVE;
     rc = vfs_lookup_internal(path, lflag, NULL, NULL);
-    rwlock_write_unlock(&namespace_rwlock);
+    fibril_rwlock_write_unlock(&namespace_rwlock);
     free(path);
     ipc_answer_0(rid, rc);
 }
 ,13 → 1036,13
     }
     path[len] = '\0';
-    rwlock_write_lock(&namespace_rwlock);
+    fibril_rwlock_write_lock(&namespace_rwlock);
     lflag &= L_DIRECTORY;   /* sanitize lflag */
     vfs_lookup_res_t lr;
     rc = vfs_lookup_internal(path, lflag | L_UNLINK, &lr, NULL);
     free(path);
     if (rc != EOK) {
-        rwlock_write_unlock(&namespace_rwlock);
+        fibril_rwlock_write_unlock(&namespace_rwlock);
         ipc_answer_0(rid, rc);
         return;
     }
 ,10 → 1053,10
      * VFS_DESTROY'ed after the last reference to it is dropped.
      */
     vfs_node_t *node = vfs_node_get(&lr);
-    futex_down(&nodes_futex);
+    fibril_mutex_lock(&nodes_mutex);
     node->lnkcnt--;
-    futex_up(&nodes_futex);
-    rwlock_write_unlock(&namespace_rwlock);
+    fibril_mutex_unlock(&nodes_mutex);
+    fibril_rwlock_write_unlock(&namespace_rwlock);
     vfs_node_put(node);
     ipc_answer_0(rid, EOK);
 }
 ,8 → 1118,16
     }
     oldc[olen] = '\0';
     newc[nlen] = '\0';
-    if (!str_lcmp(newc, oldc, str_length(oldc))) {
-        /* oldc is a prefix of newc */
+    if ((!str_lcmp(newc, oldc, str_length(oldc))) &&
+        ((newc[str_length(oldc)] == '/') ||
+        (str_length(oldc) == 1) ||
+        (str_length(oldc) == str_length(newc)))) {
+            /*
+         * oldc is a prefix of newc and either
+         * - newc continues with a / where oldc ends, or
+         * - oldc was / itself, or
+         * - oldc and newc are equal.
+         */
         ipc_answer_0(rid, EINVAL);
         free(old);
         free(new);
 ,11 → 1137,11
     vfs_lookup_res_t old_lr;
     vfs_lookup_res_t new_lr;
     vfs_lookup_res_t new_par_lr;
-    rwlock_write_lock(&namespace_rwlock);
+    fibril_rwlock_write_lock(&namespace_rwlock);
     /* Lookup the node belonging to the old file name. */
     rc = vfs_lookup_internal(oldc, L_NONE, &old_lr, NULL);
     if (rc != EOK) {
-        rwlock_write_unlock(&namespace_rwlock);
+        fibril_rwlock_write_unlock(&namespace_rwlock);
         ipc_answer_0(rid, rc);
         free(old);
         free(new);
 ,16 → 1149,31
     }
     vfs_node_t *old_node = vfs_node_get(&old_lr);
     if (!old_node) {
-        rwlock_write_unlock(&namespace_rwlock);
+        fibril_rwlock_write_unlock(&namespace_rwlock);
         ipc_answer_0(rid, ENOMEM);
         free(old);
         free(new);
         return;
     }
+    /* Determine the path to the parent of the node with the new name. */
+    char *parentc = str_dup(newc);
+    if (!parentc) {
+        fibril_rwlock_write_unlock(&namespace_rwlock);
+        ipc_answer_0(rid, rc);
+        free(old);
+        free(new);
+        return;
+    }
+    char *lastsl = str_rchr(parentc + 1, '/');
+    if (lastsl)
+        *lastsl = '\0';
+    else
+        parentc[1] = '\0';
     /* Lookup parent of the new file name. */
-    rc = vfs_lookup_internal(newc, L_PARENT, &new_par_lr, NULL);
+    rc = vfs_lookup_internal(parentc, L_NONE, &new_par_lr, NULL);
+    free(parentc);  /* not needed anymore */
     if (rc != EOK) {
-        rwlock_write_unlock(&namespace_rwlock);
+        fibril_rwlock_write_unlock(&namespace_rwlock);
         ipc_answer_0(rid, rc);
         free(old);
         free(new);
 ,7 → 1182,7
     /* Check whether linking to the same file system instance. */
     if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
         (old_node->dev_handle != new_par_lr.triplet.dev_handle)) {
-        rwlock_write_unlock(&namespace_rwlock);
+        fibril_rwlock_write_unlock(&namespace_rwlock);
         ipc_answer_0(rid, EXDEV);   /* different file systems */
         free(old);
         free(new);
 ,18 → 1198,18
     case EOK:
         new_node = vfs_node_get(&new_lr);
         if (!new_node) {
-            rwlock_write_unlock(&namespace_rwlock);
+            fibril_rwlock_write_unlock(&namespace_rwlock);
             ipc_answer_0(rid, ENOMEM);
             free(old);
             free(new);
             return;
         }
-        futex_down(&nodes_futex);
+        fibril_mutex_lock(&nodes_mutex);
         new_node->lnkcnt--;
-        futex_up(&nodes_futex);
+        fibril_mutex_unlock(&nodes_mutex);
         break;
     default:
-        rwlock_write_unlock(&namespace_rwlock);
+        fibril_rwlock_write_unlock(&namespace_rwlock);
         ipc_answer_0(rid, ENOTEMPTY);
         free(old);
         free(new);
 ,7 → 1218,7
     /* Create the new link for the new name. */
     rc = vfs_lookup_internal(newc, L_LINK, NULL, NULL, old_node->index);
     if (rc != EOK) {
-        rwlock_write_unlock(&namespace_rwlock);
+        fibril_rwlock_write_unlock(&namespace_rwlock);
         if (new_node)
             vfs_node_put(new_node);
         ipc_answer_0(rid, rc);
 ,13 → 1226,13
         free(new);
         return;
     }
-    futex_down(&nodes_futex);
+    fibril_mutex_lock(&nodes_mutex);
     old_node->lnkcnt++;
-    futex_up(&nodes_futex);
+    fibril_mutex_unlock(&nodes_mutex);
     /* Destroy the link for the old name. */
     rc = vfs_lookup_internal(oldc, L_UNLINK, NULL, NULL);
     if (rc != EOK) {
-        rwlock_write_unlock(&namespace_rwlock);
+        fibril_rwlock_write_unlock(&namespace_rwlock);
         vfs_node_put(old_node);
         if (new_node)
             vfs_node_put(new_node);
 ,10 → 1241,10
         free(new);
         return;
     }
-    futex_down(&nodes_futex);
+    fibril_mutex_lock(&nodes_mutex);
     old_node->lnkcnt--;
-    futex_up(&nodes_futex);
-    rwlock_write_unlock(&namespace_rwlock);
+    fibril_mutex_unlock(&nodes_mutex);
+    fibril_rwlock_write_unlock(&namespace_rwlock);
     vfs_node_put(old_node);
     if (new_node)
         vfs_node_put(new_node);
 ,4 → 1255,4
 /**
  * @}
- */
+ */

 /branches/network/uspace/srv/vfs/vfs_register.c
 ,15 → 45,16
 #include <string.h>
 #include <ctype.h>
 #include <bool.h>
-#include <futex.h>
-#include <libadt/list.h>
+#include <fibril_sync.h>
+#include <adt/list.h>
 #include <as.h>
 #include <assert.h>
 #include <atomic.h>
 #include "vfs.h"
-atomic_t fs_head_futex = FUTEX_INITIALIZER;
-link_t fs_head;
+FIBRIL_CONDVAR_INITIALIZE(fs_head_cv);
+FIBRIL_MUTEX_INITIALIZE(fs_head_lock);
+LIST_INITIALIZE(fs_head);
 atomic_t fs_handle_next = {
     .count = 1
 ,7 → 160,7
         return;
     }
     link_initialize(&fs_info->fs_link);
-    futex_initialize(&fs_info->phone_futex, 1);
+    fibril_mutex_initialize(&fs_info->phone_lock);
     rc = ipc_data_write_finalize(callid, &fs_info->vfs_info, size);
     if (rc != EOK) {
 ,8 → 181,7
         return;
     }
-    futex_down(&fs_head_futex);
-    fibril_inc_sercount();
+    fibril_mutex_lock(&fs_head_lock);
     /*
      * Check for duplicit registrations.
 ,8 → 191,7
          * We already register a fs like this.
          */
         dprintf("FS is already registered.\n");
-        fibril_dec_sercount();
-        futex_up(&fs_head_futex);
+        fibril_mutex_unlock(&fs_head_lock);
         free(fs_info);
         ipc_answer_0(callid, EEXISTS);
         ipc_answer_0(rid, EEXISTS);
 ,8 → 213,7
     if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
         dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));
         list_remove(&fs_info->fs_link);
-        fibril_dec_sercount();
-        futex_up(&fs_head_futex);
+        fibril_mutex_unlock(&fs_head_lock);
         free(fs_info);
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(rid, EINVAL);
 ,8 → 231,7
     if (!ipc_share_in_receive(&callid, &size)) {
         dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));
         list_remove(&fs_info->fs_link);
-        fibril_dec_sercount();
-        futex_up(&fs_head_futex);
+        fibril_mutex_unlock(&fs_head_lock);
         ipc_hangup(fs_info->phone);
         free(fs_info);
         ipc_answer_0(callid, EINVAL);
 ,8 → 245,7
     if (size != PLB_SIZE) {
         dprintf("Client suggests wrong size of PFB, size = %d\n", size);
         list_remove(&fs_info->fs_link);
-        fibril_dec_sercount();
-        futex_up(&fs_head_futex);
+        fibril_mutex_unlock(&fs_head_lock);
         ipc_hangup(fs_info->phone);
         free(fs_info);
         ipc_answer_0(callid, EINVAL);
 ,16 → 269,11
     fs_info->fs_handle = (fs_handle_t) atomic_postinc(&fs_handle_next);
     ipc_answer_1(rid, EOK, (ipcarg_t) fs_info->fs_handle);
-    fibril_dec_sercount();
-    futex_up(&fs_head_futex);
+    fibril_condvar_broadcast(&fs_head_cv);
+    fibril_mutex_unlock(&fs_head_lock);
     dprintf("\"%.*s\" filesystem successfully registered, handle=%d.\n",
         FS_NAME_MAXLEN, fs_info->vfs_info.name, fs_info->fs_handle);
-    /* Process pending mount requests possibly waiting
-     * for this filesystem implementation.
-     */
-    vfs_process_pending_mount();
 }
 /** For a given file system handle, implement policy for allocating a phone.
 ,76 → 285,49
  */
 int vfs_grab_phone(fs_handle_t handle)
 {
+    int phone;
     /*
-     * For now, we don't try to be very clever and very fast.
-     * We simply lookup the phone in the fs_head list. We currently don't
-     * open any additional phones (even though that itself would be pretty
-     * straightforward; housekeeping multiple open phones to a FS task would
-     * be more demanding). Instead, we simply take the respective
-     * phone_futex and keep it until vfs_release_phone().
+     * For now, we don't try to be very clever and very fast.  We simply
+     * lookup the phone in the fs_head list and duplicate it.  The duplicate
+     * phone will be returned to the client and the client will use it for
+     * communication.  In the future, we should cache the connections so
+     * that they do not have to be reestablished over and over again.
      */
-    futex_down(&fs_head_futex);
+    fibril_mutex_lock(&fs_head_lock);
     link_t *cur;
     fs_info_t *fs;
     for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
         fs = list_get_instance(cur, fs_info_t, fs_link);
         if (fs->fs_handle == handle) {
-            futex_up(&fs_head_futex);
-            /*
-             * For now, take the futex unconditionally.
-             * Oh yeah, serialization rocks.
-             * It will be up'ed in vfs_release_phone().
-             */
-            futex_down(&fs->phone_futex);
-            /*
-             * Avoid deadlock with other fibrils in the same thread
-             * by disabling fibril preemption.
-             */
-            fibril_inc_sercount();
-            return fs->phone;
+            fibril_mutex_unlock(&fs_head_lock);
+            fibril_mutex_lock(&fs->phone_lock);
+            phone = ipc_connect_me_to(fs->phone, 0, 0, 0);
+            fibril_mutex_unlock(&fs->phone_lock);
+            assert(phone > 0);
+            return phone;
         }
     }
-    futex_up(&fs_head_futex);
+    fibril_mutex_unlock(&fs_head_lock);
     return 0;
 }
-/** Tell VFS that the phone is in use for any request.
+/** Tell VFS that the phone is not needed anymore.
  *
  * @param phone     Phone to FS task.
  */
 void vfs_release_phone(int phone)
 {
-    bool found = false;
-    /*
-     * Undo the fibril_inc_sercount() done in vfs_grab_phone().
-     */
-    fibril_dec_sercount();
-    futex_down(&fs_head_futex);
-    link_t *cur;
-    for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
-        fs_info_t *fs = list_get_instance(cur, fs_info_t, fs_link);
-        if (fs->phone == phone) {
-            found = true;
-            futex_up(&fs_head_futex);
-            futex_up(&fs->phone_futex);
-            return;
-        }
-    }
-    futex_up(&fs_head_futex);
-    /*
-     * Not good to get here.
-     */
-    assert(found == true);
+    /* TODO: implement connection caching */
+    ipc_hangup(phone);
 }
 /** Convert file system name to its handle.
  *
  * @param name      File system name.
- * @param lock      If true, the function will down and up the
- *          fs_head_futex.
+ * @param lock      If true, the function will lock and unlock the
+ *          fs_head_lock.
  *
  * @return      File system handle or zero if file system not found.
  */
 ,7 → 336,7
     int handle = 0;
     if (lock)
-        futex_down(&fs_head_futex);
+        fibril_mutex_lock(&fs_head_lock);
     link_t *cur;
     for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
         fs_info_t *fs = list_get_instance(cur, fs_info_t, fs_link);
 ,7 → 346,7
         }
     }
     if (lock)
-        futex_up(&fs_head_futex);
+        fibril_mutex_unlock(&fs_head_lock);
     return handle;
 }

 /branches/network/uspace/srv/vfs/vfs.h
 ,70 → 28,25
 /** @addtogroup fs
  * @{
- */
+ */
 #ifndef VFS_VFS_H_
 #define VFS_VFS_H_
 #include <ipc/ipc.h>
-#include <libadt/list.h>
-#include <futex.h>
-#include <rwlock.h>
+#include <adt/list.h>
+#include <fibril_sync.h>
 #include <sys/types.h>
+#include <devmap.h>
 #include <bool.h>
+#include <ipc/vfs.h>
 // FIXME: according to CONFIG_DEBUG
-// #define dprintf(...) printf(__VA_ARGS__)
+// #define dprintf(...)  printf(__VA_ARGS__)
 #define dprintf(...)
-#define VFS_FIRST   IPC_FIRST_USER_METHOD
-/* Basic types. */
-typedef int16_t fs_handle_t;
-typedef int16_t dev_handle_t;
-typedef uint32_t fs_index_t;
-typedef enum {
-    VFS_READ = VFS_FIRST,
-    VFS_WRITE,
-    VFS_TRUNCATE,
-    VFS_MOUNT,
-    VFS_UNMOUNT,
-    VFS_LAST_CMN,   /* keep this the last member of this enum */
-} vfs_request_cmn_t;
-typedef enum {
-    VFS_LOOKUP = VFS_LAST_CMN,
-    VFS_MOUNTED,
-    VFS_DESTROY,
-    VFS_LAST_CLNT,  /* keep this the last member of this enum */
-} vfs_request_clnt_t;
-typedef enum {
-    VFS_REGISTER = VFS_LAST_CMN,
-    VFS_OPEN,
-    VFS_CLOSE,
-    VFS_SEEK,
-    VFS_MKDIR,
-    VFS_UNLINK,
-    VFS_RENAME,
-    VFS_LAST_SRV,   /* keep this the last member of this enum */
-} vfs_request_srv_t;
-#define FS_NAME_MAXLEN  20
 /**
- * A structure like this is passed to VFS by each individual FS upon its
- * registration. It assosiates a human-readable identifier with each
- * registered FS.
- */
-typedef struct {
-    /** Unique identifier of the fs. */
-    char name[FS_NAME_MAXLEN + 1];
-} vfs_info_t;
-/**
  * A structure like this will be allocated for each registered file system.
  */
 typedef struct {
 ,7 → 53,7
     link_t fs_link;
     vfs_info_t vfs_info;
     fs_handle_t fs_handle;
-    futex_t phone_futex;    /**< Phone serializing futex. */
+    fibril_mutex_t phone_lock;
     ipcarg_t phone;
 } fs_info_t;
 ,8 → 60,8
 /**
  * VFS_PAIR uniquely represents a file system instance.
  */
-#define VFS_PAIR        \
-    fs_handle_t fs_handle;  \
+#define VFS_PAIR \
+    fs_handle_t fs_handle; \
     dev_handle_t dev_handle;
 /**
 ,8 → 71,8
  * @note    fs_handle, dev_handle and index are meant to be returned in one
  *      IPC reply.
  */
-#define VFS_TRIPLET \
-    VFS_PAIR;   \
+#define VFS_TRIPLET \
+    VFS_PAIR; \
     fs_index_t index;
 typedef struct {
 ,50 → 83,6
     VFS_TRIPLET;
 } vfs_triplet_t;
-/*
- * Lookup flags.
- */
-/**
- * No lookup flags used.
- */
-#define L_NONE      0
-/**
- * Lookup will succeed only if the object is a regular file.  If L_CREATE is
- * specified, an empty file will be created. This flag is mutually exclusive
- * with L_DIRECTORY.
- */
-#define L_FILE      1
-/**
- * Lookup wil succeed only if the object is a directory. If L_CREATE is
- * specified, an empty directory will be created. This flag is mutually
- * exclusive with L_FILE.
- */
-#define L_DIRECTORY 2
-/**
- * When used with L_CREATE, L_EXCLUSIVE will cause the lookup to fail if the
- * object already exists. L_EXCLUSIVE is implied when L_DIRECTORY is used.
- */
-#define L_EXCLUSIVE 4
-/**
- * L_CREATE is used for creating both regular files and directories.
- */
-#define L_CREATE    8
-/**
- * L_LINK is used for linking to an already existing nodes.
- */
-#define L_LINK      16
-/**
- * L_UNLINK is used to remove leaves from the file system namespace. This flag
- * cannot be passed directly by the client, but will be set by VFS during
- * VFS_UNLINK.
- */
-#define L_UNLINK    32
-/**
- * L_PARENT performs a lookup but returns the triplet of the parent node.
- * This flag may not be combined with any other lookup flag.
- */
-#define L_PARENT    64
 typedef enum vfs_node_type {
     VFS_NODE_UNKNOWN,
     VFS_NODE_FILE,
 ,7 → 121,7
     /**
      * Holding this rwlock prevents modifications of the node's contents.
      */
-    rwlock_t contents_rwlock;
+    fibril_rwlock_t contents_rwlock;
 } vfs_node_t;
 /**
 ,7 → 130,7
  */
 typedef struct {
     /** Serializes access to this open file. */
-    futex_t lock;
+    fibril_mutex_t lock;
     vfs_node_t *node;
 ,16 → 144,14
     off_t pos;
 } vfs_file_t;
-extern futex_t nodes_futex;
+extern fibril_mutex_t nodes_mutex;
+extern fibril_condvar_t fs_head_cv;
+extern fibril_mutex_t fs_head_lock;
 extern link_t fs_head;      /**< List of registered file systems. */
 extern vfs_pair_t rootfs;   /**< Root file system. */
-#define MAX_PATH_LEN        (64 * 1024)
-#define PLB_SIZE        (2 * MAX_PATH_LEN)
 /** Each instance of this type describes one path lookup in progress. */
 typedef struct {
     link_t  plb_link;   /**< Active PLB entries list link. */
 ,7 → 159,7
     size_t len;     /**< Number of characters in this PLB entry. */
 } plb_entry_t;
-extern futex_t plb_futex;   /**< Futex protecting plb and plb_head. */
+extern fibril_mutex_t plb_mutex;/**< Mutex protecting plb and plb_head. */
 extern uint8_t *plb;        /**< Path Lookup Buffer */
 extern link_t plb_head;     /**< List of active PLB entries. */
 ,7 → 166,7
 #define MAX_MNTOPTS_LEN     256
 /** Holding this rwlock prevents changes in file system namespace. */
-extern rwlock_t namespace_rwlock;
+extern fibril_rwlock_t namespace_rwlock;
 extern int vfs_grab_phone(fs_handle_t);
 extern void vfs_release_phone(int);
 ,8 → 173,9
 extern fs_handle_t fs_name_to_handle(char *, bool);
-extern int vfs_lookup_internal(char *, int, vfs_lookup_res_t *, vfs_pair_t *,
-    ...);
+extern int vfs_lookup_internal(char *, int, vfs_lookup_res_t *,
+    vfs_pair_t *, ...);
+extern int vfs_open_node_internal(vfs_lookup_res_t *);
 extern bool vfs_nodes_init(void);
 extern vfs_node_t *vfs_node_get(vfs_lookup_res_t *);
 ,10 → 194,13
 extern void vfs_node_addref(vfs_node_t *);
 extern void vfs_node_delref(vfs_node_t *);
-extern void vfs_process_pending_mount(void);
 extern void vfs_register(ipc_callid_t, ipc_call_t *);
 extern void vfs_mount(ipc_callid_t, ipc_call_t *);
 extern void vfs_open(ipc_callid_t, ipc_call_t *);
+extern void vfs_open_node(ipc_callid_t, ipc_call_t *);
+extern void vfs_device(ipc_callid_t, ipc_call_t *);
+extern void vfs_sync(ipc_callid_t, ipc_call_t *);
+extern void vfs_node(ipc_callid_t, ipc_call_t *);
 extern void vfs_close(ipc_callid_t, ipc_call_t *);
 extern void vfs_read(ipc_callid_t, ipc_call_t *);
 extern void vfs_write(ipc_callid_t, ipc_call_t *);

 /branches/network/uspace/srv/vfs/vfs_node.c
 ,15 → 38,14
 #include "vfs.h"
 #include <stdlib.h>
 #include <string.h>
-#include <futex.h>
-#include <rwlock.h>
-#include <libadt/hash_table.h>
+#include <fibril_sync.h>
+#include <adt/hash_table.h>
 #include <assert.h>
 #include <async.h>
 #include <errno.h>
-/** Futex protecting the VFS node hash table. */
-futex_t nodes_futex = FUTEX_INITIALIZER;
+/** Mutex protecting the VFS node hash table. */
+FIBRIL_MUTEX_INITIALIZE(nodes_mutex);
 #define NODES_BUCKETS_LOG   8
 #define NODES_BUCKETS       (1 << NODES_BUCKETS_LOG)
 ,9 → 88,9
  */
 void vfs_node_addref(vfs_node_t *node)
 {
-    futex_down(&nodes_futex);
+    fibril_mutex_lock(&nodes_mutex);
     _vfs_node_addref(node);
-    futex_up(&nodes_futex);
+    fibril_mutex_unlock(&nodes_mutex);
 }
 /** Decrement reference count of a VFS node.
 ,7 → 104,7
     bool free_vfs_node = false;
     bool free_fs_node = false;
-    futex_down(&nodes_futex);
+    fibril_mutex_lock(&nodes_mutex);
     if (node->refcnt-- == 1) {
         /*
          * We are dropping the last reference to this node.
 ,7 → 120,7
         if (!node->lnkcnt)
             free_fs_node = true;
     }
-    futex_up(&nodes_futex);
+    fibril_mutex_unlock(&nodes_mutex);
     if (free_fs_node) {
         /*
 ,12 → 160,12
     link_t *tmp;
     vfs_node_t *node;
-    futex_down(&nodes_futex);
+    fibril_mutex_lock(&nodes_mutex);
     tmp = hash_table_find(&nodes, key);
     if (!tmp) {
         node = (vfs_node_t *) malloc(sizeof(vfs_node_t));
         if (!node) {
-            futex_up(&nodes_futex);
+            fibril_mutex_unlock(&nodes_mutex);
             return NULL;
         }
         memset(node, 0, sizeof(vfs_node_t));
 ,10 → 176,10
         node->lnkcnt = result->lnkcnt;
         node->type = result->type;
         link_initialize(&node->nh_link);
-        rwlock_initialize(&node->contents_rwlock);
+        fibril_rwlock_initialize(&node->contents_rwlock);
         hash_table_insert(&nodes, key, &node->nh_link);
     } else {
-        node = hash_table_get_instance(tmp, vfs_node_t, nh_link);
+        node = hash_table_get_instance(tmp, vfs_node_t, nh_link);
         if (node->type == VFS_NODE_UNKNOWN &&
             result->type != VFS_NODE_UNKNOWN) {
             /* Upgrade the node type. */
 ,7 → 192,7
     assert(node->type == result->type || result->type == VFS_NODE_UNKNOWN);
     _vfs_node_addref(node);
-    futex_up(&nodes_futex);
+    fibril_mutex_unlock(&nodes_mutex);
     return node;
 }
 ,4 → 232,4
 /**
  * @}
- */
+ */

 /branches/network/uspace/srv/vfs/vfs_lookup.c
 ,10 → 28,10
 /** @addtogroup fs
  * @{
- */
+ */
 /**
- * @file    vfs_lookup.c
+ * @file vfs_lookup.c
  * @brief
  */
 ,27 → 42,28
 #include <string.h>
 #include <stdarg.h>
 #include <bool.h>
-#include <futex.h>
-#include <libadt/list.h>
+#include <fibril_sync.h>
+#include <adt/list.h>
 #include <vfs/canonify.h>
-#define min(a, b)   ((a) < (b) ? (a) : (b))
+#define min(a, b)  ((a) < (b) ? (a) : (b))
-futex_t plb_futex = FUTEX_INITIALIZER;
-link_t plb_head;    /**< PLB entry ring buffer. */
+FIBRIL_MUTEX_INITIALIZE(plb_mutex);
+LIST_INITIALIZE(plb_head);  /**< PLB entry ring buffer. */
 uint8_t *plb = NULL;
 /** Perform a path lookup.
  *
- * @param path      Path to be resolved; it must be a NULL-terminated
- *          string.
- * @param lflag     Flags to be used during lookup.
- * @param result    Empty structure where the lookup result will be stored.
- *          Can be NULL.
- * @param altroot   If non-empty, will be used instead of rootfs as the root
- *          of the whole VFS tree.
+ * @param path    Path to be resolved; it must be a NULL-terminated
+ *                string.
+ * @param lflag   Flags to be used during lookup.
+ * @param result  Empty structure where the lookup result will be stored.
+ *                Can be NULL.
+ * @param altroot If non-empty, will be used instead of rootfs as the root
+ *                of the whole VFS tree.
  *
- * @return      EOK on success or an error code from errno.h.
+ * @return EOK on success or an error code from errno.h.
+ *
  */
 int vfs_lookup_internal(char *path, int lflag, vfs_lookup_res_t *result,
     vfs_pair_t *altroot, ...)
 ,7 → 92,7
         va_end(ap);
     }
-    futex_down(&plb_futex);
+    fibril_mutex_lock(&plb_mutex);
     plb_entry_t entry;
     link_initialize(&entry.plb_link);
 ,7 → 119,7
             /*
              * The buffer cannot absorb the path.
              */
-            futex_up(&plb_futex);
+            fibril_mutex_unlock(&plb_mutex);
             return ELIMIT;
         }
     } else {
 ,7 → 127,7
             /*
              * The buffer cannot absorb the path.
              */
-            futex_up(&plb_futex);
+            fibril_mutex_unlock(&plb_mutex);
             return ELIMIT;
         }
     }
 ,7 → 146,7
      */
     list_append(&entry.plb_link, &plb_head);
-    futex_up(&plb_futex);
+    fibril_mutex_unlock(&plb_mutex);
     /*
      * Copy the path into PLB.
 ,12 → 163,12
         (ipcarg_t) (first + len - 1) % PLB_SIZE,
         (ipcarg_t) root->dev_handle, (ipcarg_t) lflag, (ipcarg_t) index,
         &answer);
-    vfs_release_phone(phone);
     ipcarg_t rc;
     async_wait_for(req, &rc);
-    futex_down(&plb_futex);
+    vfs_release_phone(phone);
+    fibril_mutex_lock(&plb_mutex);
     list_remove(&entry.plb_link);
     /*
      * Erasing the path from PLB will come handy for debugging purposes.
 ,9 → 175,9
      */
     memset(&plb[first], 0, cnt1);
     memset(plb, 0, cnt2);
-    futex_up(&plb_futex);
+    fibril_mutex_unlock(&plb_mutex);
-    if ((rc == EOK) && result) {
+    if ((rc == EOK) && (result)) {
         result->triplet.fs_handle = (fs_handle_t) IPC_GET_ARG1(answer);
         result->triplet.dev_handle = (dev_handle_t) IPC_GET_ARG2(answer);
         result->triplet.index = (fs_index_t) IPC_GET_ARG3(answer);
 ,6 → 194,39
     return rc;
 }
+/** Perform a node open operation.
+ *
+ * @return EOK on success or an error code from errno.h.
+ *
+ */
+int vfs_open_node_internal(vfs_lookup_res_t *result)
+{
+    int phone = vfs_grab_phone(result->triplet.fs_handle);
+    ipc_call_t answer;
+    aid_t req = async_send_2(phone, VFS_OPEN_NODE,
+        (ipcarg_t) result->triplet.dev_handle,
+        (ipcarg_t) result->triplet.index, &answer);
+    ipcarg_t rc;
+    async_wait_for(req, &rc);
+    vfs_release_phone(phone);
+    if (rc == EOK) {
+        result->size = (size_t) IPC_GET_ARG1(answer);
+        result->lnkcnt = (unsigned) IPC_GET_ARG2(answer);
+        if (IPC_GET_ARG3(answer) & L_FILE)
+            result->type = VFS_NODE_FILE;
+        else if (IPC_GET_ARG3(answer) & L_DIRECTORY)
+            result->type = VFS_NODE_DIRECTORY;
+        else
+            result->type = VFS_NODE_UNKNOWN;
+    }
+    return rc;
+}
 /**
  * @}
  */

 /branches/network/uspace/srv/vfs/Makefile
 ,7 → 69,7
 disasm: $(OUTPUT).disasm
 $(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
+    $(OBJDUMP) -d $< > $@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/network/uspace/srv/vfs/vfs_file.c
 ,6 → 40,8
 #include <string.h>
 #include <assert.h>
 #include <bool.h>
+#include <fibril.h>
+#include <fibril_sync.h>
 #include "vfs.h"
 /**
 ,9 → 57,9
  * first VFS_OPEN operation.
  *
  * This resource being per-connection and, in the first place, per-fibril, we
- * don't need to protect it by a futex.
+ * don't need to protect it by a mutex.
  */
-__thread vfs_file_t **files = NULL;
+fibril_local vfs_file_t **files = NULL;
 /** Initialize the table of open files. */
 bool vfs_files_init(void)
 ,19 → 80,23
  */
 int vfs_fd_alloc(void)
 {
-    int i;
+    if (!vfs_files_init())
+        return ENOMEM;
+    unsigned int i;
     for (i = 0; i < MAX_OPEN_FILES; i++) {
         if (!files[i]) {
             files[i] = (vfs_file_t *) malloc(sizeof(vfs_file_t));
             if (!files[i])
                 return ENOMEM;
             memset(files[i], 0, sizeof(vfs_file_t));
-            futex_initialize(&files[i]->lock, 1);
+            fibril_mutex_initialize(&files[i]->lock);
             vfs_file_addref(files[i]);
-            return i;
+            return (int) i;
         }
     }
     return EMFILE;
 }
 ,10 → 109,15
  */
 int vfs_fd_free(int fd)
 {
-    if ((fd >= MAX_OPEN_FILES) || (files[fd] == NULL))
+    if (!vfs_files_init())
+        return ENOMEM;
+    if ((fd < 0) || (fd >= MAX_OPEN_FILES) || (files[fd] == NULL))
         return EBADF;
     vfs_file_delref(files[fd]);
     files[fd] = NULL;
     return EOK;
 }
 ,11 → 161,15
  */
 vfs_file_t *vfs_file_get(int fd)
 {
-    if (fd < MAX_OPEN_FILES)
+    if (!vfs_files_init())
+        return NULL;
+    if ((fd >= 0) && (fd < MAX_OPEN_FILES))
         return files[fd];
     return NULL;
 }
 /**
  * @}
- */
+ */

 /branches/network/uspace/Makefile
 ,14 → 37,18
     lib/libblock \
     lib/softint \
     lib/softfloat \
+    srv/bd/ata_bd \
+    srv/bd/file_bd \
+    srv/bd/gxe_bd \
+    srv/bd/rd \
     srv/ns \
     srv/loader \
     srv/fb \
     srv/kbd \
     srv/console \
-    srv/rd \
     srv/fs/fat \
     srv/fs/tmpfs \
+    srv/fs/devfs \
     srv/vfs \
     srv/devmap \
     srv/net \
 ,6 → 57,7
     app/trace \
     app/klog \
     app/init \
+    app/getvc \
     app/bdsh
 ifeq ($(UARCH),amd64)
 ,8 → 70,8
 ifeq ($(UARCH),sparc64)
     DIRS += \
-        srv/fhc \
-        srv/obio
+        srv/cir/fhc \
+        srv/cir/obio
 endif
 BUILDS := $(addsuffix .build,$(DIRS))

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4580 → Rev 4581