WebSVN – HelenOS – Path Comparison – / – /branches/dd/uspace Rev 3022 and /branches/dd/uspace Rev 4055

Ignore whitespace Rev 3022 → Rev 4055

 /branches/dd/uspace/app/bdsh/input.c
 ,0 → 1,146
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * All rights reserved.
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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 <io/stream.h>
+#include <console.h>
+#include "config.h"
+#include "util.h"
+#include "scli.h"
+#include "input.h"
+#include "errors.h"
+#include "exec.h"
+static void read_line(char *, int);
+/* Tokenizes input from console, sees if the first word is a built-in, if so
+ * invokes the built-in entry point (a[0]) passing all arguments in a[] to
+ * the handler */
+int tok_input(cliuser_t *usr)
+{
+    char *cmd[WORD_MAX];
+    int n = 0, i = 0;
+    int rc = 0;
+    char *tmp;
+    if (NULL == usr->line)
+        return CL_EFAIL;
+    tmp = strdup(usr->line);
+    cmd[n] = strtok(tmp, " ");
+    while (cmd[n] && n < WORD_MAX) {
+        cmd[++n] = strtok(NULL, " ");
+    }
+    /* We have rubbish */
+    if (NULL == cmd[0]) {
+        rc = CL_ENOENT;
+        goto finit;
+    }
+    /* Its a builtin command ? */
+    if ((i = (is_builtin(cmd[0]))) > -1) {
+        rc = run_builtin(i, cmd, usr);
+        goto finit;
+    /* Its a module ? */
+    } else if ((i = (is_module(cmd[0]))) > -1) {
+        rc = run_module(i, cmd);
+        goto finit;
+    }
+    /* See what try_exec thinks of it */
+    rc = try_exec(cmd[0], cmd);
+finit:
+    if (NULL != usr->line) {
+        free(usr->line);
+        usr->line = (char *) NULL;
+    }
+    if (NULL != tmp)
+        free(tmp);
+    return rc;
+}
+static void read_line(char *buffer, int n)
+{
+    char c;
+    int chars;
+    chars = 0;
+    while (chars < n - 1) {
+        c = getchar();
+        if (c < 0)
+            return;
+        if (c == '\n')
+            break;
+        if (c == '\b') {
+            if (chars > 0) {
+                putchar('\b');
+                --chars;
+            }
+            continue;
+        }
+        if (c >= ' ') {
+            putchar(c);
+            buffer[chars++] = c;
+        }
+    }
+    putchar('\n');
+    buffer[chars] = '\0';
+}
+/* TODO:
+ * Implement something like editline() / readline(), if even
+ * just for command history and making arrows work. */
+void get_input(cliuser_t *usr)
+{
+    char line[INPUT_MAX];
+    size_t len = 0;
+    console_set_style(STYLE_EMPHASIS);
+    printf("%s", usr->prompt);
+    console_set_style(STYLE_NORMAL);
+    read_line(line, INPUT_MAX);
+    len = strlen(line);
+    /* Make sure we don't have rubbish or a C/R happy user */
+    if (len == 0 || line[0] == '\n')
+        return;
+    usr->line = strdup(line);
+    return;
+}

 /branches/dd/uspace/app/bdsh/cmds/modules/ls/ls.c
 ,0 → 1,214
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+/* NOTE:
+ * This is a bit of an ugly hack, working around the absence of fstat / etc.
+ * As more stuff is completed and exposed in libc, this will improve */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <string.h>
+#include "errors.h"
+#include "config.h"
+#include "util.h"
+#include "entry.h"
+#include "ls.h"
+#include "cmds.h"
+static char *cmdname = "ls";
+static inline off_t flen(const char *f)
+{
+    int fd;
+    off_t size;
+    fd = open(f, O_RDONLY);
+    if (fd == -1)
+        return 0;
+    size = lseek(fd, 0, SEEK_END);
+    close(fd);
+    if (size < 0)
+        size = 0;
+    return size;
+}
+static unsigned int ls_scope(const char *path)
+{
+    int fd;
+    DIR *dirp;
+    dirp = opendir(path);
+    if (dirp) {
+        closedir(dirp);
+        return LS_DIR;
+    }
+    fd = open(path, O_RDONLY);
+    if (fd > 0) {
+        close(fd);
+        return LS_FILE;
+    }
+    return LS_BOGUS;
+}
+static void ls_scan_dir(const char *d, DIR *dirp)
+{
+    struct dirent *dp;
+    unsigned int scope;
+    char *buff;
+    if (! dirp)
+        return;
+    buff = (char *)malloc(PATH_MAX);
+    if (NULL == buff) {
+        cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
+        return;
+    }
+    while ((dp = readdir(dirp))) {
+        memset(buff, 0, sizeof(buff));
+        /* Don't worry if inserting a double slash, this will be fixed by
+         * absolutize() later with subsequent calls to open() or readdir() */
+        snprintf(buff, PATH_MAX - 1, "%s/%s", d, dp->d_name);
+        scope = ls_scope(buff);
+        switch (scope) {
+        case LS_DIR:
+            ls_print_dir(dp->d_name);
+            break;
+        case LS_FILE:
+            ls_print_file(dp->d_name, buff);
+            break;
+        case LS_BOGUS:
+            /* Odd chance it was deleted from the time readdir() found
+             * it and the time that it was scoped */
+            printf("ls: skipping bogus node %s\n", dp->d_name);
+            break;
+        }
+    }
+    free(buff);
+    return;
+}
+/* ls_print_* currently does nothing more than print the entry.
+ * in the future, we will likely pass the absolute path, and
+ * some sort of ls_options structure that controls how each
+ * entry is printed and what is printed about it.
+ *
+ * Now we just print basic DOS style lists */
+static void ls_print_dir(const char *d)
+{
+    printf("%-40s\t<dir>\n", d);
+    return;
+}
+static void ls_print_file(const char *name, const char *pathname)
+{
+    printf("%-40s\t%llu\n", name, (long long) flen(pathname));
+    return;
+}
+void help_cmd_ls(unsigned int level)
+{
+    if (level == HELP_SHORT) {
+        printf("`%s' lists files and directories.\n", cmdname);
+    } else {
+        help_cmd_ls(HELP_SHORT);
+        printf("  `%s' [path], if no path is given the current "
+                "working directory is used.\n", cmdname);
+    }
+    return;
+}
+int cmd_ls(char **argv)
+{
+    unsigned int argc;
+    unsigned int scope;
+    char *buff;
+    DIR *dirp;
+    argc = cli_count_args(argv);
+    buff = (char *) malloc(PATH_MAX);
+    if (NULL == buff) {
+        cli_error(CL_ENOMEM, "%s: ", cmdname);
+        return CMD_FAILURE;
+    }
+    memset(buff, 0, sizeof(buff));
+    if (argc == 1)
+        getcwd(buff, PATH_MAX);
+    else
+        strncpy(buff, argv[1], PATH_MAX);
+    scope = ls_scope(buff);
+    switch (scope) {
+    case LS_BOGUS:
+        cli_error(CL_ENOENT, buff);
+        free(buff);
+        return CMD_FAILURE;
+    case LS_FILE:
+        ls_print_file(buff, buff);
+        break;
+    case LS_DIR:
+        dirp = opendir(buff);
+        if (! dirp) {
+            /* May have been deleted between scoping it and opening it */
+            cli_error(CL_EFAIL, "Could not stat %s", buff);
+            free(buff);
+            return CMD_FAILURE;
+        }
+        ls_scan_dir(buff, dirp);
+        closedir(dirp);
+        break;
+    }
+    free(buff);
+    return CMD_SUCCESS;
+}

 /branches/dd/uspace/app/bdsh/cmds/modules/ls/ls.h
 ,0 → 1,16
+#ifndef LS_H
+#define LS_H
+/* Various values that can be returned by ls_scope() */
+#define LS_BOGUS 0
+#define LS_FILE  1
+#define LS_DIR   2
+static unsigned int ls_scope(const char *);
+static void ls_scan_dir(const char *, DIR *);
+static void ls_print_dir(const char *);
+static void ls_print_file(const char *, const char *);
+#endif /* LS_H */

/branches/dd/uspace/app/bdsh/cmds/modules/ls/ls_def.h
0,0 → 1,6
{
"ls",
"List files and directories",
&cmd_ls,
&help_cmd_ls,
},

 /branches/dd/uspace/app/bdsh/cmds/modules/ls/entry.h
 ,0 → 1,9
+#ifndef LS_ENTRY_H
+#define LS_ENTRY_H
+/* Entry points for the ls command */
+extern int cmd_ls(char **);
+extern void help_cmd_ls(unsigned int);
+#endif /* LS_ENTRY_H */

 /branches/dd/uspace/app/bdsh/cmds/modules/cp/cp.c
 ,0 → 1,231
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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 <unistd.h>
+#include <getopt.h>
+#include <string.h>
+#include <fcntl.h>
+#include "config.h"
+#include "util.h"
+#include "errors.h"
+#include "entry.h"
+#include "cp.h"
+#include "cmds.h"
+#define CP_VERSION "0.0.1"
+#define CP_DEFAULT_BUFLEN  1024
+static const char *cmdname = "cp";
+static struct option const long_options[] = {
+    { "buffer", required_argument, 0, 'b' },
+    { "force", no_argument, 0, 'f' },
+    { "recursive", no_argument, 0, 'r' },
+    { "help", no_argument, 0, 'h' },
+    { "version", no_argument, 0, 'v' },
+    { "verbose", no_argument, 0, 'V' },
+    { 0, 0, 0, 0 }
+};
+static int strtoint(const char *s1)
+{
+    long t1;
+    if (-1 == (t1 = strtol(s1, (char **) NULL, 10)))
+        return -1;
+    if (t1 <= 0)
+        return -1;
+    return (int) t1;
+}
+static int64_t copy_file(const char *src, const char *dest,
+    size_t blen, int vb)
+{
+    int fd1, fd2, bytes = 0;
+    off_t total = 0;
+    int64_t copied = 0;
+    char *buff = NULL;
+    if (vb)
+        printf("Copying %s to %s\n", src, dest);
+    if (-1 == (fd1 = open(src, O_RDONLY))) {
+        printf("Unable to open source file %s\n", src);
+        return -1;
+    }
+    if (-1 == (fd2 = open(dest, O_CREAT))) {
+        printf("Unable to open destination file %s\n", dest);
+        close(fd1);
+        return -1;
+    }
+    total = lseek(fd1, 0, SEEK_END);
+    if (vb)
+        printf("%d bytes to copy\n", total);
+    lseek(fd1, 0, SEEK_SET);
+    if (NULL == (buff = (char *) malloc(blen))) {
+        printf("Unable to allocate enough memory to read %s\n",
+            src);
+        copied = -1;
+        goto out;
+    }
+    for (;;) {
+        ssize_t res;
+        bytes = read(fd1, buff, blen);
+        if (bytes <= 0)
+            break;
+        copied += bytes;
+        res = bytes;
+        do {
+            /*
+             * Theoretically, it may not be enough to call write()
+             * only once. Also the previous read() may have
+             * returned less data than requested.
+             */
+            bytes = write(fd2, buff, res);
+            if (bytes < 0)
+                goto err;
+            res -= bytes;
+        } while (res > 0);
+        /* TODO: re-insert assert() once this is stand alone,
+         * removed as abort() exits the entire shell
+         */
+        if (res != 0) {
+            printf("\n%d more bytes than actually exist were copied\n", res);
+            goto err;
+        }
+    }
+    if (bytes < 0) {
+err:
+        printf("\nError copying %s, (%d)\n", src, bytes);
+        copied = bytes;
+    }
+out:
+    close(fd1);
+    close(fd2);
+    if (buff)
+        free(buff);
+    return copied;
+}
+void help_cmd_cp(unsigned int level)
+{
+    static char helpfmt[] =
+        "Usage:  %s [options] <source> <dest>\n"
+        "Options: (* indicates not yet implemented)\n"
+        "  -h, --help       A short option summary\n"
+        "  -v, --version    Print version information and exit\n"
+        "* -V, --verbose    Be annoyingly noisy about what's being done\n"
+        "* -f, --force      Do not complain when <dest> exists\n"
+        "* -r, --recursive  Copy entire directories\n"
+        "  -b, --buffer ## Set the read buffer size to ##\n"
+        "Currently, %s is under development, some options may not work.\n";
+    if (level == HELP_SHORT) {
+        printf("`%s' copies files and directories\n", cmdname);
+    } else {
+        help_cmd_cp(HELP_SHORT);
+        printf(helpfmt, cmdname, cmdname);
+    }
+    return;
+}
+int cmd_cp(char **argv)
+{
+    unsigned int argc, buffer = 0, verbose = 0;
+    int c, opt_ind;
+    int64_t ret;
+    argc = cli_count_args(argv);
+    for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
+        c = getopt_long(argc, argv, "hvVfrb:", long_options, &opt_ind);
+        switch (c) {
+        case 'h':
+            help_cmd_cp(1);
+            return CMD_SUCCESS;
+        case 'v':
+            printf("%d\n", CP_VERSION);
+            return CMD_SUCCESS;
+        case 'V':
+            verbose = 1;
+            break;
+        case 'f':
+            break;
+        case 'r':
+            break;
+        case 'b':
+            if (-1 == (buffer = strtoint(optarg))) {
+                printf("%s: Invalid buffer specification, "
+                    "(should be a number greater than zero)\n",
+                    cmdname);
+                return CMD_FAILURE;
+            }
+            if (verbose)
+                printf("Buffer = %d\n", buffer);
+            break;
+        }
+    }
+    if (buffer == 0)
+        buffer = CP_DEFAULT_BUFLEN;
+    argc -= optind;
+    if (argc != 2) {
+        printf("%s: invalid number of arguments. Try %s --help\n",
+            cmdname, cmdname);
+        return CMD_FAILURE;
+    }
+    ret = copy_file(argv[optind], argv[optind + 1], buffer, verbose);
+    if (verbose)
+        printf("%d bytes copied\n", ret);
+    if (ret >= 0)
+        return CMD_SUCCESS;
+    else
+        return CMD_FAILURE;
+}

/branches/dd/uspace/app/bdsh/cmds/modules/cp/cp_def.h
0,0 → 1,7
{
"cp",
"Copy files and directories",
&cmd_cp,
&help_cmd_cp,
},

 /branches/dd/uspace/app/bdsh/cmds/modules/cp/entry.h
 ,0 → 1,9
+#ifndef CP_ENTRY_H
+#define CP_ENTRY_H
+/* Entry points for the cp command */
+extern int cmd_cp(char **);
+extern void help_cmd_cp(unsigned int);
+#endif /* CP_ENTRY_H */

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

 /branches/dd/uspace/app/bdsh/cmds/modules/rm/rm.c
 ,0 → 1,257
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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 <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <getopt.h>
+#include "config.h"
+#include "errors.h"
+#include "util.h"
+#include "entry.h"
+#include "rm.h"
+#include "cmds.h"
+static char *cmdname = "rm";
+#define RM_VERSION "0.0.1"
+static rm_job_t rm;
+static struct option const long_options[] = {
+    { "help", no_argument, 0, 'h' },
+    { "version", no_argument, 0, 'v' },
+    { "recursive", no_argument, 0, 'r' },
+    { "force", no_argument, 0, 'f' },
+    { "safe", no_argument, 0, 's' },
+    { 0, 0, 0, 0 }
+};
+static unsigned int rm_start(rm_job_t *rm)
+{
+    rm->recursive = 0;
+    rm->force = 0;
+    rm->safe = 0;
+    /* Make sure we can allocate enough memory to store
+     * what is needed in the job structure */
+    if (NULL == (rm->nwd = (char *) malloc(PATH_MAX)))
+        return 0;
+    memset(rm->nwd, 0, sizeof(rm->nwd));
+    if (NULL == (rm->owd = (char *) malloc(PATH_MAX)))
+        return 0;
+    memset(rm->owd, 0, sizeof(rm->owd));
+    if (NULL == (rm->cwd = (char *) malloc(PATH_MAX)))
+        return 0;
+    memset(rm->cwd, 0, sizeof(rm->cwd));
+    chdir(".");
+    if (NULL == (getcwd(rm->owd, PATH_MAX)))
+        return 0;
+    return 1;
+}
+static void rm_end(rm_job_t *rm)
+{
+    if (NULL != rm->nwd)
+        free(rm->nwd);
+    if (NULL != rm->owd)
+        free(rm->owd);
+    if (NULL != rm->cwd)
+        free(rm->cwd);
+    return;
+}
+static unsigned int rm_recursive(const char *path)
+{
+    int rc;
+    /* First see if it will just go away */
+    rc = rmdir(path);
+    if (rc == 0)
+        return 0;
+    /* Its not empty, recursively scan it */
+    cli_error(CL_ENOTSUP,
+        "Can not remove %s, directory not empty", path);
+    return 1;
+}
+static unsigned int rm_single(const char *path)
+{
+    if (unlink(path)) {
+        cli_error(CL_EFAIL, "rm: could not remove file %s", path);
+        return 1;
+    }
+    return 0;
+}
+static unsigned int rm_scope(const char *path)
+{
+    int fd;
+    DIR *dirp;
+    dirp = opendir(path);
+    if (dirp) {
+        closedir(dirp);
+        return RM_DIR;
+    }
+    fd = open(path, O_RDONLY);
+    if (fd > 0) {
+        close(fd);
+        return RM_FILE;
+    }
+    return RM_BOGUS;
+}
+/* Dispays help for rm in various levels */
+void help_cmd_rm(unsigned int level)
+{
+    if (level == HELP_SHORT) {
+        printf("`%s' removes files and directories.\n", cmdname);
+    } else {
+        help_cmd_rm(HELP_SHORT);
+        printf(
+        "Usage:  %s [options] <path>\n"
+        "Options:\n"
+        "  -h, --help       A short option summary\n"
+        "  -v, --version    Print version information and exit\n"
+        "  -r, --recursive  Recursively remove sub directories\n"
+        "  -f, --force      Do not prompt prior to removing files\n"
+        "  -s, --safe       Stop if directories change during removal\n\n"
+        "Currently, %s is under development, some options don't work.\n",
+        cmdname, cmdname);
+    }
+    return;
+}
+/* Main entry point for rm, accepts an array of arguments */
+int cmd_rm(char **argv)
+{
+    unsigned int argc;
+    unsigned int i, scope, ret = 0;
+    int c, opt_ind;
+    size_t len;
+    char *buff = NULL;
+    argc = cli_count_args(argv);
+    if (argc < 2) {
+        cli_error(CL_EFAIL,
+            "%s: insufficient arguments. Try %s --help", cmdname, cmdname);
+        return CMD_FAILURE;
+    }
+    if (!rm_start(&rm)) {
+        cli_error(CL_ENOMEM, "%s: could not initialize", cmdname);
+        rm_end(&rm);
+        return CMD_FAILURE;
+    }
+    for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
+        c = getopt_long(argc, argv, "hvrfs", long_options, &opt_ind);
+        switch (c) {
+        case 'h':
+            help_cmd_rm(HELP_LONG);
+            return CMD_SUCCESS;
+        case 'v':
+            printf("%s\n", RM_VERSION);
+            return CMD_SUCCESS;
+        case 'r':
+            rm.recursive = 1;
+            break;
+        case 'f':
+            rm.force = 1;
+            break;
+        case 's':
+            rm.safe = 1;
+            break;
+        }
+    }
+    if (optind == argc) {
+        cli_error(CL_EFAIL,
+            "%s: insufficient arguments. Try %s --help", cmdname, cmdname);
+        rm_end(&rm);
+        return CMD_FAILURE;
+    }
+    i = optind;
+    while (NULL != argv[i]) {
+        len = strlen(argv[i]) + 2;
+        buff = (char *) realloc(buff, len);
+        if (buff == NULL) {
+            printf("rm: out of memory\n");
+            ret = 1;
+            break;
+        }
+        memset(buff, 0, sizeof(buff));
+        snprintf(buff, len, argv[i]);
+        scope = rm_scope(buff);
+        switch (scope) {
+        case RM_BOGUS: /* FIXME */
+        case RM_FILE:
+            ret += rm_single(buff);
+            break;
+        case RM_DIR:
+            if (! rm.recursive) {
+                printf("%s is a directory, use -r to remove it.\n", buff);
+                ret ++;
+            } else {
+                ret += rm_recursive(buff);
+            }
+            break;
+        }
+        i++;
+    }
+    if (NULL != buff)
+        free(buff);
+    rm_end(&rm);
+    if (ret)
+        return CMD_FAILURE;
+    else
+        return CMD_SUCCESS;
+}

/branches/dd/uspace/app/bdsh/cmds/modules/rm/rm_def.h
0,0 → 1,7
{
"rm",
"Remove files and directories",
&cmd_rm,
&help_cmd_rm,
},

 /branches/dd/uspace/app/bdsh/cmds/modules/rm/entry.h
 ,0 → 1,9
+#ifndef RM_ENTRY_H
+#define RM_ENTRY_H
+/* Entry points for the rm command */
+extern int cmd_rm(char **);
+extern void help_cmd_rm(unsigned int);
+#endif /* RM_ENTRY_H */

 /branches/dd/uspace/app/bdsh/cmds/modules/rm/rm.h
 ,0 → 1,43
+#ifndef RM_H
+#define RM_H
+/* Return values for rm_scope() */
+#define RM_BOGUS 0
+#define RM_FILE  1
+#define RM_DIR   2
+/* Flags for rm_update() */
+#define _RM_ENTRY   0
+#define _RM_ADVANCE 1
+#define _RM_REWIND  2
+#define _RM_EXIT    3
+/* A simple job structure */
+typedef struct {
+    /* Options set at run time */
+    unsigned int force;      /* -f option */
+    unsigned int recursive;  /* -r option */
+    unsigned int safe;       /* -s option */
+    /* Keeps track of the job in progress */
+    int advance; /* How far deep we've gone since entering */
+    DIR *entry;  /* Entry point to the tree being removed */
+    char *owd;   /* Where we were when we invoked rm */
+    char *cwd;   /* Current directory being transversed */
+    char *nwd;   /* Next directory to be transversed */
+    /* Counters */
+    int f_removed; /* Number of files unlinked */
+    int d_removed; /* Number of directories unlinked */
+} rm_job_t;
+/* Prototypes for the rm command, excluding entry points */
+static unsigned int rm_start(rm_job_t *);
+static void rm_end(rm_job_t *rm);
+static unsigned int rm_recursive(const char *);
+static unsigned int rm_single(const char *);
+static unsigned int rm_scope(const char *);
+#endif /* RM_H */

 /branches/dd/uspace/app/bdsh/cmds/modules/touch/touch.c
 ,0 → 1,108
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+/* TODO: Options that people would expect, such as not creating the file if
+ * it doesn't exist, specifying the access time, etc */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <string.h>
+#include "config.h"
+#include "errors.h"
+#include "util.h"
+#include "entry.h"
+#include "touch.h"
+#include "cmds.h"
+static char *cmdname = "touch";
+/* Dispays help for touch in various levels */
+void help_cmd_touch(unsigned int level)
+{
+    if (level == HELP_SHORT) {
+        printf("`%s' updates access times for files\n", cmdname);
+    } else {
+        help_cmd_touch(HELP_SHORT);
+        printf("  `%s' <file>, if the file does not exist it will be "
+                "created\n", cmdname);
+    }
+    return;
+}
+/* Main entry point for touch, accepts an array of arguments */
+int cmd_touch(char **argv)
+{
+    unsigned int argc, i = 0, ret = 0;
+    int fd;
+    char *buff = NULL;
+    DIR *dirp;
+    argc = cli_count_args(argv);
+    if (argc == 1) {
+        printf("%s - incorrect number of arguments. Try `help %s extended'\n",
+            cmdname, cmdname);
+        return CMD_FAILURE;
+    }
+    for (i = 1; i < argc; i ++) {
+        buff = strdup(argv[i]);
+        dirp = opendir(buff);
+        if (dirp) {
+            cli_error(CL_ENOTSUP, "%s is a directory", buff);
+            closedir(dirp);
+            ret ++;
+            continue;
+        }
+        fd = open(buff, O_RDWR | O_CREAT);
+        if (fd < 0) {
+            cli_error(CL_EFAIL, "Could not update / create %s ", buff);
+            ret ++;
+            continue;
+        } else
+            close(fd);
+        free(buff);
+    }
+    if (ret)
+        return CMD_FAILURE;
+    else
+        return CMD_SUCCESS;
+}

/branches/dd/uspace/app/bdsh/cmds/modules/touch/touch_def.h
0,0 → 1,7
{
"touch",
"Create files or update access times",
&cmd_touch,
&help_cmd_touch,
},

 /branches/dd/uspace/app/bdsh/cmds/modules/touch/entry.h
 ,0 → 1,9
+#ifndef TOUCH_ENTRY_H
+#define TOUCH_ENTRY_H
+/* Entry points for the touch command */
+extern int cmd_touch(char **);
+extern void help_cmd_touch(unsigned int);
+#endif /* TOUCH_ENTRY_H */

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

 /branches/dd/uspace/app/bdsh/cmds/modules/mkdir/mkdir.c
 ,0 → 1,251
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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 <dirent.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <getopt.h>
+#include <stdarg.h>
+#include "config.h"
+#include "errors.h"
+#include "util.h"
+#include "entry.h"
+#include "mkdir.h"
+#include "cmds.h"
+#define MKDIR_VERSION "0.0.1"
+static char *cmdname = "mkdir";
+static struct option const long_options[] = {
+    {"parents", no_argument, 0, 'p'},
+    {"verbose", no_argument, 0, 'v'},
+    {"mode", required_argument, 0, 'm'},
+    {"help", no_argument, 0, 'h'},
+    {"version", no_argument, 0, 'V'},
+    {"follow", no_argument, 0, 'f'},
+    {0, 0, 0, 0}
+};
+void help_cmd_mkdir(unsigned int level)
+{
+    if (level == HELP_SHORT) {
+        printf("`%s' creates a new directory\n", cmdname);
+    } else {
+        help_cmd_mkdir(HELP_SHORT);
+        printf(
+        "Usage:  %s [options] <path>\n"
+        "Options:\n"
+        "  -h, --help       A short option summary\n"
+        "  -V, --version    Print version information and exit\n"
+        "  -p, --parents    Create needed parents for <path>\n"
+        "  -m, --mode       Set permissions to [mode] (UNUSED)\n"
+        "  -v, --verbose    Be extremely noisy about what is happening\n"
+        "  -f, --follow     Go to the new directory once created\n"
+        "Currently, %s is under development, some options don't work.\n",
+        cmdname, cmdname);
+    }
+    return;
+}
+/* This is kind of clunky, but effective for now */
+static unsigned int
+create_directory(const char *path, unsigned int p)
+{
+    DIR *dirp;
+    char *tmp = NULL, *buff = NULL, *wdp = NULL;
+    char *dirs[255];
+    unsigned int absolute = 0, i = 0, ret = 0;
+    /* Its a good idea to allocate path, plus we (may) need a copy of
+     * path to tokenize if parents are specified */
+    if (NULL == (tmp = strdup(path))) {
+        cli_error(CL_ENOMEM, "%s: path too big?", cmdname);
+        return 1;
+    }
+    if (NULL == (wdp = (char *) malloc(PATH_MAX))) {
+        cli_error(CL_ENOMEM, "%s: could not alloc cwd", cmdname);
+        free(tmp);
+        return 1;
+    }
+    /* The only reason for wdp is to be (optionally) verbose */
+    getcwd(wdp, PATH_MAX);
+    /* Typical use without specifying the creation of parents */
+    if (p == 0) {
+        dirp = opendir(tmp);
+        if (dirp) {
+            cli_error(CL_EEXISTS, "%s: can not create %s, try -p", cmdname, path);
+            closedir(dirp);
+            goto finit;
+        }
+        if (-1 == (mkdir(tmp, 0))) {
+            cli_error(CL_EFAIL, "%s: could not create %s", cmdname, path);
+            goto finit;
+        }
+    }
+    /* Parents need to be created, path has to be broken up */
+    /* See if path[0] is a slash, if so we have to remember to append it */
+    if (tmp[0] == '/')
+        absolute = 1;
+    /* TODO: Canonify the path prior to tokenizing it, see below */
+    dirs[i] = strtok(tmp, "/");
+    while (dirs[i] && i < 255)
+        dirs[++i] = strtok(NULL, "/");
+    if (NULL == dirs[0])
+        return 1;
+    if (absolute == 1) {
+        asprintf(&buff, "/%s", dirs[0]);
+        mkdir(buff, 0);
+        chdir(buff);
+        free(buff);
+        getcwd(wdp, PATH_MAX);
+        i = 1;
+    } else {
+        i = 0;
+    }
+    while (dirs[i] != NULL) {
+        /* Sometimes make or scripts conjoin odd paths. Account for something
+         * like this: ../../foo/bar/../foo/foofoo/./bar */
+        if (!strcmp(dirs[i], "..") || !strcmp(dirs[i], ".")) {
+            if (0 != (chdir(dirs[i]))) {
+                cli_error(CL_EFAIL, "%s: impossible path: %s",
+                    cmdname, path);
+                ret ++;
+                goto finit;
+            }
+            getcwd(wdp, PATH_MAX);
+        } else {
+            if (-1 == (mkdir(dirs[i], 0))) {
+                cli_error(CL_EFAIL,
+                    "%s: failed at %s/%s", wdp, dirs[i]);
+                ret ++;
+                goto finit;
+            }
+            if (0 != (chdir(dirs[i]))) {
+                cli_error(CL_EFAIL, "%s: failed creating %s\n",
+                    cmdname, dirs[i]);
+                ret ++;
+                break;
+            }
+        }
+        i++;
+    }
+    goto finit;
+finit:
+    free(wdp);
+    free(tmp);
+    return ret;
+}
+int cmd_mkdir(char **argv)
+{
+    unsigned int argc, create_parents = 0, i, ret = 0, follow = 0;
+    unsigned int verbose = 0;
+    int c, opt_ind;
+    char *cwd;
+    argc = cli_count_args(argv);
+    for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
+        c = getopt_long(argc, argv, "pvhVfm:", long_options, &opt_ind);
+        switch (c) {
+        case 'p':
+            create_parents = 1;
+            break;
+        case 'v':
+            verbose = 1;
+            break;
+        case 'h':
+            help_cmd_mkdir(HELP_LONG);
+            return CMD_SUCCESS;
+        case 'V':
+            printf("%s\n", MKDIR_VERSION);
+            return CMD_SUCCESS;
+        case 'f':
+            follow = 1;
+            break;
+        case 'm':
+            printf("%s: [W] Ignoring mode %s\n", cmdname, optarg);
+            break;
+        }
+    }
+    argc -= optind;
+    if (argc < 1) {
+        printf("%s - incorrect number of arguments. Try `%s --help'\n",
+            cmdname, cmdname);
+        return CMD_FAILURE;
+    }
+    if (NULL == (cwd = (char *) malloc(PATH_MAX))) {
+        cli_error(CL_ENOMEM, "%s: could not allocate cwd", cmdname);
+        return CMD_FAILURE;
+    }
+    memset(cwd, 0, sizeof(cwd));
+    getcwd(cwd, PATH_MAX);
+    for (i = optind; argv[i] != NULL; i++) {
+        if (verbose == 1)
+            printf("%s: creating %s%s\n",
+                cmdname, argv[i],
+                create_parents ? " (and all parents)" : "");
+        ret += create_directory(argv[i], create_parents);
+    }
+    if (follow == 0)
+        chdir(cwd);
+    free(cwd);
+    if (ret)
+        return CMD_FAILURE;
+    else
+        return CMD_SUCCESS;
+}

 /branches/dd/uspace/app/bdsh/cmds/modules/mkdir/mkdir_def.h
 ,0 → 1,8
+{
+    "mkdir",
+    "Create new directories",
+    &cmd_mkdir,
+    &help_cmd_mkdir,
+},

 /branches/dd/uspace/app/bdsh/cmds/modules/mkdir/entry.h
 ,0 → 1,9
+#ifndef MKDIR_ENTRY_H
+#define MKDIR_ENTRY_H
+/* Entry points for the mkdir command */
+extern int cmd_mkdir(char **);
+extern void help_cmd_mkdir(unsigned int);
+#endif /* MKDIR_ENTRY_H */

 /branches/dd/uspace/app/bdsh/cmds/modules/mkdir/mkdir.h
 ,0 → 1,8
+#ifndef MKDIR_H
+#define MKDIR_H
+/* Prototypes for the mkdir command, excluding entry points */
+static unsigned int create_directory(const char *, unsigned int);
+#endif /* MKDIR_H */

 /branches/dd/uspace/app/bdsh/cmds/modules/modules.h
 ,0 → 1,47
+#ifndef MODULES_H
+#define MODULES_H
+/* Each built in function has two files, one being an entry.h file which
+ * prototypes the run/help entry functions, the other being a .def file
+ * which fills the modules[] array according to the cmd_t structure
+ * defined in cmds.h.
+ *
+ * To add or remove a module, just make a new directory in cmds/modules
+ * for it and copy the 'show' example for basics, then include it here.
+ * (or reverse the process to remove one)
+ *
+ * NOTE: See module_ aliases.h as well, this is where aliases (commands that
+ * share an entry point with others) are indexed */
+#include "config.h"
+/* Prototypes for each module's entry (help/exec) points */
+#include "help/entry.h"
+#include "mkdir/entry.h"
+#include "rm/entry.h"
+#include "cat/entry.h"
+#include "touch/entry.h"
+#include "ls/entry.h"
+#include "pwd/entry.h"
+#include "sleep/entry.h"
+#include "cp/entry.h"
+/* Each .def function fills the module_t struct with the individual name, entry
+ * point, help entry point, etc. You can use config.h to control what modules
+ * are loaded based on what libraries exist on the system. */
+module_t modules[] = {
+#include "help/help_def.h"
+#include "mkdir/mkdir_def.h"
+#include "rm/rm_def.h"
+#include "cat/cat_def.h"
+#include "touch/touch_def.h"
+#include "ls/ls_def.h"
+#include "pwd/pwd_def.h"
+#include "sleep/sleep_def.h"
+#include "cp/cp_def.h"
+    {NULL, NULL, NULL, NULL}
+};
+#endif

/branches/dd/uspace/app/bdsh/cmds/modules/cat/cat_def.h
0,0 → 1,7
{
"cat",
"Show the contents of a file",
&cmd_cat,
&help_cmd_cat,
},

 /branches/dd/uspace/app/bdsh/cmds/modules/cat/cat.c
 ,0 → 1,178
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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 <unistd.h>
+#include <getopt.h>
+#include <string.h>
+#include <fcntl.h>
+#include "config.h"
+#include "util.h"
+#include "errors.h"
+#include "entry.h"
+#include "cat.h"
+#include "cmds.h"
+static char *cmdname = "cat";
+#define CAT_VERSION "0.0.1"
+#define CAT_DEFAULT_BUFLEN 1024
+static char *cat_oops = "That option is not yet supported\n";
+static struct option const long_options[] = {
+    { "help", no_argument, 0, 'h' },
+    { "version", no_argument, 0, 'v' },
+    { "head", required_argument, 0, 'H' },
+    { "tail", required_argument, 0, 't' },
+    { "buffer", required_argument, 0, 'b' },
+    { "more", no_argument, 0, 'm' },
+    { 0, 0, 0, 0 }
+};
+/* Dispays help for cat in various levels */
+void help_cmd_cat(unsigned int level)
+{
+    if (level == HELP_SHORT) {
+        printf("`%s' shows the contents of files\n", cmdname);
+    } else {
+        help_cmd_cat(HELP_SHORT);
+        printf(
+        "Usage:  %s [options] <file1> [file2] [...]\n"
+        "Options:\n"
+        "  -h, --help       A short option summary\n"
+        "  -v, --version    Print version information and exit\n"
+        "  -H, --head ##    Print only the first ## bytes\n"
+        "  -t, --tail ##    Print only the last ## bytes\n"
+        "  -b, --buffer ##  Set the read buffer size to ##\n"
+        "  -m, --more       Pause after each screen full\n"
+        "Currently, %s is under development, some options don't work.\n",
+        cmdname, cmdname);
+    }
+    return;
+}
+static unsigned int cat_file(const char *fname, size_t blen)
+{
+    int fd, bytes = 0, count = 0, reads = 0;
+    off_t total = 0;
+    char *buff = NULL;
+    if (-1 == (fd = open(fname, O_RDONLY))) {
+        printf("Unable to open %s\n", fname);
+        return 1;
+    }
+    total = lseek(fd, 0, SEEK_END);
+    lseek(fd, 0, SEEK_SET);
+    if (NULL == (buff = (char *) malloc(blen + 1))) {
+        close(fd);
+        printf("Unable to allocate enough memory to read %s\n",
+            fname);
+        return 1;
+    }
+    do {
+        bytes = read(fd, buff, blen);
+        if (bytes > 0) {
+            count += bytes;
+            buff[bytes] = '\0';
+            printf("%s", buff);
+            reads++;
+        }
+    } while (bytes > 0);
+    close(fd);
+    if (bytes == -1) {
+        printf("Error reading %s\n", fname);
+        free(buff);
+        return 1;
+    }
+    free(buff);
+    return 0;
+}
+/* Main entry point for cat, accepts an array of arguments */
+int cmd_cat(char **argv)
+{
+    unsigned int argc, i, ret = 0, buffer = 0;
+    int c, opt_ind;
+    argc = cli_count_args(argv);
+    for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
+        c = getopt_long(argc, argv, "hvmH:t:b:", long_options, &opt_ind);
+        switch (c) {
+        case 'h':
+            help_cmd_cat(HELP_LONG);
+            return CMD_SUCCESS;
+        case 'v':
+            printf("%s\n", CAT_VERSION);
+            return CMD_SUCCESS;
+        case 'H':
+            printf(cat_oops);
+            return CMD_FAILURE;
+        case 't':
+            printf(cat_oops);
+            return CMD_FAILURE;
+        case 'b':
+            printf(cat_oops);
+            break;
+        case 'm':
+            printf(cat_oops);
+            return CMD_FAILURE;
+        }
+    }
+    argc -= optind;
+    if (argc < 1) {
+        printf("%s - incorrect number of arguments. Try `%s --help'\n",
+            cmdname, cmdname);
+        return CMD_FAILURE;
+    }
+    if (buffer <= 0)
+        buffer = CAT_DEFAULT_BUFLEN;
+    for (i = optind; argv[i] != NULL; i++)
+        ret += cat_file(argv[i], buffer);
+    if (ret)
+        return CMD_FAILURE;
+    else
+        return CMD_SUCCESS;
+}

 /branches/dd/uspace/app/bdsh/cmds/modules/cat/entry.h
 ,0 → 1,9
+#ifndef CAT_ENTRY_H
+#define CAT_ENTRY_H
+/* Entry points for the cat command */
+extern int cmd_cat(char **);
+extern void help_cmd_cat(unsigned int);
+#endif /* CAT_ENTRY_H */

 /branches/dd/uspace/app/bdsh/cmds/modules/cat/cat.h
 ,0 → 1,9
+#ifndef CAT_H
+#define CAT_H
+/* Prototypes for the cat command, excluding entry points */
+static unsigned int cat_file(const char *, size_t);
+#endif /* CAT_H */

 /branches/dd/uspace/app/bdsh/cmds/modules/help/help.c
 ,0 → 1,158
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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 "entry.h"
+#include "help.h"
+#include "cmds.h"
+#include "modules.h"
+#include "builtins.h"
+#include "errors.h"
+#include "util.h"
+static char *cmdname = "help";
+extern const char *progname;
+#define HELP_IS_MODULE   1
+#define HELP_IS_BUILTIN  0
+#define HELP_IS_RUBBISH  -1
+volatile int mod_switch = -1;
+/* Just use a pointer here, no need for mod_switch */
+static int is_mod_or_builtin(char *cmd)
+{
+    int rc = HELP_IS_RUBBISH;
+    rc = is_builtin(cmd);
+    if (rc > -1) {
+        mod_switch = rc;
+        return HELP_IS_BUILTIN;
+    }
+    rc = is_module(cmd);
+    if (rc > -1) {
+        mod_switch = rc;
+        return HELP_IS_MODULE;
+    }
+    return HELP_IS_RUBBISH;
+}
+void help_cmd_help(unsigned int level)
+{
+    if (level == HELP_SHORT) {
+        printf(
+        "\n  %s [command] <extended>\n"
+        "  Use help [command] extended for detailed help on [command] "
+        ", even `help'\n\n", cmdname);
+    } else {
+        printf(
+        "\n  `%s' - shows help for commands\n"
+        "  Examples:\n"
+        "   %s [command]           Show help for [command]\n"
+        "   %s [command] extended  Show extended help for [command]\n"
+        "\n  If no argument is given to %s, a list of commands are shown\n\n",
+        cmdname, cmdname, cmdname, cmdname);
+    }
+    return;
+}
+int cmd_help(char *argv[])
+{
+    module_t *mod;
+    builtin_t *cmd;
+    unsigned int i = 0;
+    int rc = 0;
+    int argc;
+    int level = HELP_SHORT;
+    argc = cli_count_args(argv);
+    if (argc > 3) {
+        printf("\nToo many arguments to `%s', try:\n", cmdname);
+        help_cmd_help(HELP_SHORT);
+        return CMD_FAILURE;
+    }
+    if (argc == 3) {
+        if (!strcmp("extended", argv[2]))
+            level = HELP_LONG;
+        else
+            level = HELP_SHORT;
+    }
+    if (argc > 1) {
+        rc = is_mod_or_builtin(argv[1]);
+        switch (rc) {
+        case HELP_IS_RUBBISH:
+            printf("Invalid command %s\n", argv[1]);
+            return CMD_FAILURE;
+        case HELP_IS_MODULE:
+            help_module(mod_switch, level);
+            return CMD_SUCCESS;
+        case HELP_IS_BUILTIN:
+            help_builtin(mod_switch, level);
+            return CMD_SUCCESS;
+        }
+    }
+    printf("\n  Available commands are:\n");
+    printf("  ------------------------------------------------------------\n");
+    /* First, show a list of built in commands that are available in this mode */
+    for (cmd = builtins; cmd->name != NULL; cmd++, i++) {
+            if (is_builtin_alias(cmd->name))
+                printf("   %-16s\tAlias for `%s'\n", cmd->name,
+                    alias_for_builtin(cmd->name));
+            else
+                printf("   %-16s\t%s\n", cmd->name, cmd->desc);
+    }
+    i = 0;
+    /* Now, show a list of module commands that are available in this mode */
+    for (mod = modules; mod->name != NULL; mod++, i++) {
+            if (is_module_alias(mod->name))
+                printf("   %-16s\tAlias for `%s'\n", mod->name,
+                    alias_for_module(mod->name));
+            else
+                printf("   %-16s\t%s\n", mod->name, mod->desc);
+    }
+    printf("\n  Try %s %s for more information on how `%s' works.\n\n",
+        cmdname, cmdname, cmdname);
+    return CMD_SUCCESS;
+}

/branches/dd/uspace/app/bdsh/cmds/modules/help/help_def.h
0,0 → 1,6
{
"help",
"Show help for commands",
&cmd_help,
&help_cmd_help,
},

 /branches/dd/uspace/app/bdsh/cmds/modules/help/entry.h
 ,0 → 1,8
+#ifndef HELP_ENTRY_H_
+#define HELP_ENTRY_H_
+/* Entry points for the help command */
+extern void help_cmd_help(unsigned int);
+extern int cmd_help(char *[]);
+#endif

/branches/dd/uspace/app/bdsh/cmds/modules/help/help.h
0,0 → 1,7
#ifndef HELP_H
#define HELP_H

/* Prototypes for the help command (excluding entry points) */
static int is_mod_or_builtin(char *);

#endif

/branches/dd/uspace/app/bdsh/cmds/modules/sleep/sleep_def.h
0,0 → 1,7
{
"sleep",
"Pause for given time interval (in seconds)",
&cmd_sleep,
&help_cmd_sleep,
},

 /branches/dd/uspace/app/bdsh/cmds/modules/sleep/entry.h
 ,0 → 1,9
+#ifndef SLEEP_ENTRY_H
+#define SLEEP_ENTRY_H
+/* Entry points for the sleep command */
+extern int cmd_sleep(char **);
+extern void help_cmd_sleep(unsigned int);
+#endif /* SLEEP_ENTRY_H */

 /branches/dd/uspace/app/bdsh/cmds/modules/sleep/sleep.c
 ,0 → 1,73
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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 "config.h"
+#include "util.h"
+#include "errors.h"
+#include "entry.h"
+#include "sleep.h"
+#include "cmds.h"
+static char *cmdname = "sleep";
+/* Dispays help for sleep in various levels */
+void help_cmd_sleep(unsigned int level)
+{
+    printf("This is the %s help for '%s'.\n",
+        level ? EXT_HELP : SHORT_HELP, cmdname);
+    return;
+}
+/* Main entry point for sleep, accepts an array of arguments */
+int cmd_sleep(char **argv)
+{
+    unsigned int argc;
+    unsigned int i;
+    /* Count the arguments */
+    for (argc = 0; argv[argc] != NULL; argc ++);
+    printf("%s %s\n", TEST_ANNOUNCE, cmdname);
+    printf("%d arguments passed to %s", argc - 1, cmdname);
+    if (argc < 2) {
+        printf("\n");
+        return CMD_SUCCESS;
+    }
+    printf(":\n");
+    for (i = 1; i < argc; i++)
+        printf("[%d] -> %s\n", i, argv[i]);
+    return CMD_SUCCESS;
+}

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

/branches/dd/uspace/app/bdsh/cmds/modules/pwd/pwd_def.h
0,0 → 1,6
{
"pwd",
"Prints the current working directory",
&cmd_pwd,
&help_cmd_pwd,
},

 /branches/dd/uspace/app/bdsh/cmds/modules/pwd/entry.h
 ,0 → 1,12
+#ifndef PWD_ENTRY_H
+#define PWD_ENTRY_H
+#include "scli.h"
+/* Entry points for the pwd command */
+extern void help_cmd_pwd(unsigned int);
+extern int cmd_pwd(char **);
+#endif

 /branches/dd/uspace/app/bdsh/cmds/modules/pwd/pwd.c
 ,0 → 1,71
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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 "config.h"
+#include "errors.h"
+#include "entry.h"
+#include "cmds.h"
+#include "pwd.h"
+static char * cmdname = "pwd";
+void help_cmd_pwd(unsigned int level)
+{
+    printf("`%s' prints your current working directory.\n", cmdname);
+    return;
+}
+int cmd_pwd(char *argv[])
+{
+    char *buff;
+    buff = (char *) malloc(PATH_MAX);
+    if (NULL == buff) {
+        cli_error(CL_ENOMEM, "%s:", cmdname);
+        return CMD_FAILURE;
+    }
+    memset(buff, 0, sizeof(buff));
+    getcwd(buff, PATH_MAX);
+    if (! buff) {
+        cli_error(CL_EFAIL,
+            "Unable to determine the current working directory");
+        free(buff);
+        return CMD_FAILURE;
+    } else {
+        printf("%s\n", buff);
+        free(buff);
+        return CMD_SUCCESS;
+    }
+}

/branches/dd/uspace/app/bdsh/cmds/modules/pwd/pwd.h
0,0 → 1,6
#ifndef PWD_H_
#define PWD_H_

/* Prototypes for the pwd command (excluding entry points) */

#endif

 /branches/dd/uspace/app/bdsh/cmds/modules/module_aliases.h
 ,0 → 1,18
+#ifndef MODULE_ALIASES_H
+#define MODULE_ALIASES_H
+/* Modules that declare multiple names for themselves but use the
+ * same entry functions are aliases. This array helps to determine if
+ * a module is an alias, as such it can be invoked differently.
+ * format is alias , real_name */
+/* So far, this is only used in the help display but could be used to
+ * handle a module differently even prior to reaching its entry code.
+ * For instance, 'exit' could behave differently than 'quit', prior to
+ * the entry point being reached. */
+char *mod_aliases[] = {
+    NULL, NULL
+};
+#endif

 /branches/dd/uspace/app/bdsh/cmds/modules/README
 ,0 → 1,15
+Modules are commands or full programs (anything can be made into a module
+that can return int type) should go here. Note, modules do not (can not)
+update or read cliuser_t.
+Stuff that needs to write to the user structures contained in scli.h should
+be made as built-in commands, not modules, but there are very few times when
+you would want to do that.
+See the README file in the bdsh root directory for a quick overview of how to
+write a new command, or convert an existig stand-alone program into a module
+for BDSH.

 /branches/dd/uspace/app/bdsh/cmds/builtins/builtins.h
 ,0 → 1,15
+#ifndef BUILTINS_H
+#define BUILTINS_H
+#include "config.h"
+#include "cd/entry.h"
+#include "exit/entry.h"
+builtin_t builtins[] = {
+#include "cd/cd_def.h"
+#include "exit/exit_def.h"
+    {NULL, NULL, NULL, NULL}
+};
+#endif

/branches/dd/uspace/app/bdsh/cmds/builtins/exit/exit.h
0,0 → 1,6
#ifndef EXIT_H
#define EXIT_H

/* Prototypes for the quit command (excluding entry points) */

#endif

 /branches/dd/uspace/app/bdsh/cmds/builtins/exit/entry.h
 ,0 → 1,12
+#ifndef EXIT_ENTRY_H_
+#define EXIT_ENTRY_H_
+#include "scli.h"
+/* Entry points for the quit command */
+extern void help_cmd_exit(unsigned int);
+extern int cmd_exit(char *[], cliuser_t *);
+#endif

 /branches/dd/uspace/app/bdsh/cmds/builtins/exit/exit.c
 ,0 → 1,55
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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 "entry.h"
+#include "exit.h"
+#include "cmds.h"
+static const char *cmdname = "exit";
+extern volatile unsigned int cli_quit;
+extern const char *progname;
+void help_cmd_exit(unsigned int level)
+{
+    printf("Type `%s' to exit %s\n", cmdname, progname);
+    return;
+}
+/* Quits the program and returns the status of whatever command
+ * came before invoking 'quit' */
+int cmd_exit(char *argv[], cliuser_t *usr)
+{
+    /* Inform that we're outta here */
+    cli_quit = 1;
+    return CMD_SUCCESS;
+}

/branches/dd/uspace/app/bdsh/cmds/builtins/exit/exit_def.h
0,0 → 1,6
{
"exit",
"Exit the shell",
&cmd_exit,
&help_cmd_exit,
},

/branches/dd/uspace/app/bdsh/cmds/builtins/cd/cd_def.h
0,0 → 1,6
{
"cd",
"Change the current working directory",
&cmd_cd,
&help_cmd_cd,
},

 /branches/dd/uspace/app/bdsh/cmds/builtins/cd/cd.c
 ,0 → 1,106
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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 <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include "util.h"
+#include "errors.h"
+#include "entry.h"
+#include "cmds.h"
+#include "cd.h"
+static char * cmdname = "cd";
+void help_cmd_cd(unsigned int level)
+{
+    if (level == HELP_SHORT) {
+        printf("`%s' changes the current working directory.\n", cmdname);
+    } else {
+        printf(
+        "  %s <directory>\n"
+        "  Change directory to <directory>, e.g `%s /sbin'\n",
+            cmdname, cmdname);
+    }
+    return;
+}
+/* This is a very rudamentary 'cd' command. It is not 'link smart' (yet) */
+int cmd_cd(char **argv, cliuser_t *usr)
+{
+    int argc, rc = 0;
+    argc = cli_count_args(argv);
+    /* We don't yet play nice with whitespace, a getopt implementation should
+     * protect "quoted\ destination" as a single argument. Its not our job to
+     * look for && || or redirection as the tokenizer should have done that
+     * (currently, it does not) */
+    if (argc > 2) {
+        cli_error(CL_EFAIL, "Too many arguments to `%s'", cmdname);
+        return CMD_FAILURE;
+    }
+    if (argc < 2) {
+        printf("%s - no directory specified. Try `help %s extended'\n",
+            cmdname, cmdname);
+        return CMD_FAILURE;
+    }
+    /* We have the correct # of arguments
+     * TODO: handle tidle (~) expansion? */
+    rc = chdir(argv[1]);
+    if (rc == 0) {
+        cli_set_prompt(usr);
+        return CMD_SUCCESS;
+    } else {
+        switch (rc) {
+        case ENOMEM:
+            cli_error(CL_EFAIL, "Destination path too long");
+            break;
+        case ENOENT:
+            cli_error(CL_ENOENT, "Invalid directory `%s'", argv[1]);
+            break;
+        default:
+            cli_error(CL_EFAIL, "Unable to change to `%s'", argv[1]);
+            break;
+        }
+    }
+    return CMD_FAILURE;
+}

 /branches/dd/uspace/app/bdsh/cmds/builtins/cd/entry.h
 ,0 → 1,12
+#ifndef CD_ENTRY_H_
+#define CD_ENTRY_H_
+#include "scli.h"
+/* Entry points for the cd command */
+extern void help_cmd_cd(unsigned int);
+extern int cmd_cd(char **, cliuser_t *);
+#endif

/branches/dd/uspace/app/bdsh/cmds/builtins/cd/cd.h
0,0 → 1,7
#ifndef CD_H
#define CD_H

/* Prototypes for the cd command (excluding entry points) */


#endif

 /branches/dd/uspace/app/bdsh/cmds/builtins/builtin_aliases.h
 ,0 → 1,10
+#ifndef BUILTIN_ALIASES_H
+#define BUILTIN_ALIASES_H
+/* See modules/module_aliases.h for an explanation of this file */
+char *builtin_aliases[] = {
+    NULL, NULL
+};
+#endif

 /branches/dd/uspace/app/bdsh/cmds/builtins/README
 ,0 → 1,21
+Commands that need to modify the running user structure defined in scli.h
+should reside here. They (will) have a slightly different prototype that
+allows passing the user structure to them for ease of modifications.
+Examples of what should be a built-in and not a module would be:
+cd     (cliuser_t->cwd needs to be updated)
+In the future, more user preferences will be set via built-in commands,
+such as the formatting of the prompt string (HelenOS doesn't yet have
+an environment, much less PS*, even if it did we'd likely do it a little
+differently).
+.... etc.
+Anything that does _not_ need to use this structure should be included
+as a module, not a built in. If you want to include a new command, there
+is a 99% chance that you want it to be a module.

 /branches/dd/uspace/app/bdsh/cmds/mknewcmd
 ,0 → 1,314
+#!/bin/sh
+# Copyright (C) 2008 Tim Post - 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.
+#
+# Neither the name of the original program's authors nor the names of its
+# contributors may be used to endorse or promote products derived from this
+# software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+# Script to generate skeletal files for a new command
+# Uses `getopt', not quite a bash-ism but might be
+# lacking on some legacy systems.
+# If your shell does not support eval, shift (x) or
+# here-now documents, sorry :)
+usage()
+{
+    def="$DEFAULT_COMMAND"
+    cat << EOF
+\`$PROGNAME' generates skeletal command files to simplify adding commands
+Usage: $PROGNAME [options] <location>
+Options:
+  -n, --name         Name of the command (default: ${def})
+  -d, --desc         Short (20 30 chars) description of the command
+                     (def: "The $def command")
+  -e, --entry        Entry function of the command (def: cmd_${def})
+  -h, --help-entry   Entry function for command help (def: help_cmd_${def})
+  -a, --alias        Alias (nickname) for this command (def: none)
+  -t, --type         Type of command (module or builtin) (def: module)
+  -H, --help         This help summary
+  -V, --version      Print $PROGNAME version and exit normally
+Notes:
+  You must supply at least the name of the command.
+  If you do not specify a location (i.e. modules/foo), the command will be
+  created in modules/command_name or builtins/command_name depending on your
+  selection.
+  This script will only create skeletal files and inform you what headers
+  need to be modified to incorporate the command. You will also have to
+  manually update the main Makefile.
+  This script is intended only to be a convenience for developers. Example use:
+    $PROGNAME -n foo -d "Foo power" -a bar -r both -t module modules/foo
+  The example would generate a modular command named 'foo', which is also
+  reached by typing 'bar'.
+  Skeletal files do *not* depend on the autoconf generated "config.h" unless you
+  include it. This may or may not be desirable depending on your use.
+Report bugs to $PROGMAINT
+EOF
+}
+# Convert a string to all uppercase
+toupper()
+{
+    local str="$1"
+    echo "${str}" | tr 'a-z' 'A-Z'
+}
+# Template stored `here-now' style, this generates all files needed
+# for a new command according to arguments passed.
+generate_code()
+{
+    echo "Creating ${OUTDIR}/${CMDNAME}_def.h ..."
+    cat << EOF > ${OUTDIR}/${CMDNAME}_def.h
+{
+    "${CMDNAME}",
+    "${CMDDESC}",
+    &${CMDENTRY},
+    &${HELPENTRY},
+},
+EOF
+    [ -n "${CMDALIAS}" ] && cat << EOF >> ${OUTDIR}/${CMDNAME}_def.h
+{
+    "${CMDALIAS}",
+    NULL,
+    &${CMDENTRY},
+    &${HELPENTRY},
+},
+EOF
+    local defname=$(toupper "${CMDNAME}")
+    echo "Creating ${OUTDIR}/entry.h ..."
+    cat << EOF > ${OUTDIR}/entry.h
+#ifndef ${defname}_ENTRY_H
+#define ${defname}_ENTRY_H
+EOF
+    [ "${CMDTYPE}" = "module" ] && cat << EOF >> ${OUTDIR}/entry.h
+/* Entry points for the ${CMDNAME} command */
+extern int ${CMDENTRY}(char **);
+extern void ${HELPENTRY}(unsigned int);
+#endif /* ${defname}_ENTRY_H */
+EOF
+    [ "${CMDTYPE}" = "builtin" ] && cat << EOF >> ${OUTDIR}/entry.h
+/* Pick up cliuser_t */
+#include "scli.h"
+/* Entry points for the ${CMDNAME} command */
+extern int * ${CMDENTRY}(char **, cliuser_t *);
+extern void * ${HELPENTRY}(unsigned int);
+#endif /* ${defname}_ENTRY_H */
+EOF
+    echo "Creating ${OUTDIR}/${CMDNAME}.h ..."
+    cat << EOF > ${OUTDIR}/${CMDNAME}.h
+#ifndef ${defname}_H
+#define ${defname}_H
+/* Prototypes for the ${CMDNAME} command, excluding entry points */
+#endif /* ${defname}_H */
+EOF
+    echo "Creating ${OUTDIR}/${CMDNAME}.c ..."
+    cat << EOF > ${OUTDIR}/${CMDNAME}.c
+/* Automatically generated by ${PROGNAME} on ${TIMESTAMP}
+ * This is machine generated output. The author of ${PROGNAME} claims no
+ * copyright over the contents of this file. Where legally permitted, the
+ * contents herein are donated to the public domain.
+ *
+ * You should apply any license and copyright that you wish to this file,
+ * replacing this header in its entirety. */
+#include <stdio.h>
+#include <stdlib.h>
+#include "config.h"
+#include "util.h"
+#include "errors.h"
+#include "entry.h"
+#include "${CMDNAME}.h"
+#include "cmds.h"
+static const char *cmdname = "${CMDNAME}";
+/* Dispays help for ${CMDNAME} in various levels */
+void ${HELPENTRY}(unsigned int level)
+{
+    printf("This is the %s help for '%s'.\n",
+        level ? EXT_HELP : SHORT_HELP, cmdname);
+    return;
+}
+EOF
+    [ "${CMDTYPE}" = "module" ] && cat << EOF >> ${OUTDIR}/${CMDNAME}.c
+/* Main entry point for ${CMDNAME}, accepts an array of arguments */
+int ${CMDENTRY}(char **argv)
+EOF
+    [ "${CMDTYPE}" = "builtin" ] && cat << EOF >> ${OUTDIR}/${CMDNAME}.c
+/* Main entry point for ${CMDNAME}, accepts an array of arguments and a
+ * pointer to the cliuser_t structure */
+int ${CMDENTRY}(char **argv, cliuser_t *usr)
+EOF
+    cat << EOF >> ${OUTDIR}/${CMDNAME}.c
+{
+    unsigned int argc;
+    unsigned int i;
+    /* Count the arguments */
+    for (argc = 0; argv[argc] != NULL; argc ++);
+    printf("%s %s\n", TEST_ANNOUNCE, cmdname);
+    printf("%d arguments passed to %s", argc - 1, cmdname);
+    if (argc < 2) {
+        printf("\n");
+        return CMD_SUCCESS;
+    }
+    printf(":\n");
+    for (i = 1; i < argc; i++)
+        printf("[%d] -> %s\n", i, argv[i]);
+    return CMD_SUCCESS;
+}
+EOF
+    printf "Done.\n\nYou should now modify %ss/%ss.h and ../Makefile" \
+        "${CMDTYPE}" "${CMDTYPE}"
+    printf " to include your new command.\n"
+    [ -n "$CMDALIAS" ] &&  {
+        printf "\nYou should also modify %ss/%s_aliases.h and " \
+            "${CMDTYPE}" "${CMDTYPE}"
+        printf "add %s as an alias for %s\n" \
+            "${CMDALIAS}" "${CMDNAME}"
+    }
+    printf "\nOnce completed, re-run make\n\n"
+}
+# Main program
+TIMESTAMP="$(date)"
+PROGNAME=$(basename $0)
+PROGVER="0.0.1"
+PROGMAINT="Tim Post <echo@echoreply.us>"
+DEFAULT_COMMAND="cmdname"
+# We need at least one
+[ $# = 0 ] && usage && exit 1;
+TEMP=$(getopt -o n:d:e:h:a:t:HV \
+--long name:,desc:,entry:,help-entry:,alias:,type:,help,version \
+-- "$@") || {
+    echo "Try $PROGNAME --help for help"
+}
+eval set -- "$TEMP"
+while true; do
+    case "$1" in
+    -n | --name)
+        CMDNAME="$2"
+        shift 2
+        continue
+    ;;
+    -d | --desc)
+        CMDDESC="$2"
+        shift 2
+        continue
+    ;;
+    -e | --entry)
+        CMDENTRY="$2"
+        shift 2
+        continue
+    ;;
+    -h | --help-entry)
+        HELPENTRY="$2"
+        shift 2
+        continue
+    ;;
+    -a | --alias)
+        CMDALIAS="$2"
+        shift 2
+        continue
+    ;;
+    -t | --type)
+        CMDTYPE="$2"
+        shift 2
+        continue
+    ;;
+    -H | --help)
+        usage
+        exit 0
+    ;;
+    -V | --version)
+        echo "$PROGVER"
+        exit 0
+    ;;
+    --)
+        break
+    ;;
+    esac
+done
+# Pick up a location if one was specified
+eval set -- "$*"
+[ -n "$2" ] && OUTDIR="$2"
+# Fill in defaults for whatever was not specified
+[ -n "$CMDNAME" ] || CMDNAME="$DEFAULT_COMMAND"
+[ -n "$CMDDESC" ] || CMDDESC="The $CMDNAME command"
+[ -n "$CMDENTRY" ] || CMDENTRY="cmd_${CMDNAME}"
+[ -n "$HELPENTRY" ] || HELPENTRY="help_cmd_${CMDNAME}"
+[ -n "$CMDTYPE" ] || CMDTYPE="module"
+[ -n "$OUTDIR" ] || OUTDIR="${CMDTYPE}s/${CMDNAME}"
+# Do a little sanity
+[ -d $OUTDIR ] && {
+    echo "$OUTDIR already exists, remove it to proceed."
+    exit 1
+}
+mkdir -p ${OUTDIR} >/dev/null 2>&1 || {
+    echo "Could not create ${OUTDIR}, aborting!"
+    exit 1
+}
+# Generate the files and inform on how to include them based on options
+generate_code
+exit 0
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /branches/dd/uspace/app/bdsh/cmds/mod_cmds.c
 ,0 → 1,136
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+/* NOTES:
+ * module_* functions are pretty much identical to builtin_* functions at this
+ * point. On the surface, it would appear that making each function dual purpose
+ * would be economical.
+ *
+ * These are kept separate because the structures (module_t and builtin_t) may
+ * grow apart and become rather different, even though they're identical at this
+ * point.
+ *
+ * To keep things easy to hack, everything is separated. In reality this only adds
+ * 6 - 8 extra functions, but keeps each function very easy to read and modify. */
+/* TODO:
+ * Many of these could be unsigned, provided the modules and builtins themselves
+ * can follow suit. Long term goal. */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "errors.h"
+#include "cmds.h"
+#include "module_aliases.h"
+extern volatile unsigned int cli_interactive;
+/* Checks if an entry function matching command exists in modules[], if so
+ * its position in the array is returned */
+int is_module(const char *command)
+{
+    module_t *mod;
+    unsigned int i = 0;
+    if (NULL == command)
+        return -2;
+    for (mod = modules; mod->name != NULL; mod++, i++) {
+        if (!strcmp(mod->name, command))
+            return i;
+    }
+    return -1;
+}
+/* Checks if a module is an alias (sharing an entry point with another
+ * module). Returns 1 if so */
+int is_module_alias(const char *command)
+{
+    unsigned int i = 0;
+    if (NULL == command)
+        return -1;
+    for(i=0; mod_aliases[i] != NULL; i+=2) {
+        if (!strcmp(mod_aliases[i], command))
+            return 1;
+    }
+    return 0;
+}
+/* Returns the name of the module that an alias points to */
+char *alias_for_module(const char *command)
+{
+    unsigned int i = 0;
+    if (NULL == command)
+        return (char *)NULL;
+    for(i=0; mod_aliases[i] != NULL; i++) {
+        if (!strcmp(mod_aliases[i], command))
+            return (char *)mod_aliases[++i];
+        i++;
+    }
+    return (char *)NULL;
+}
+/* Invokes the 'help' entry function for the module at position (int) module,
+ * which wants an unsigned int to determine brief or extended display. */
+int help_module(int module, unsigned int extended)
+{
+    module_t *mod = modules;
+    mod += module;
+    if (NULL != mod->help) {
+        mod->help(extended);
+        return CL_EOK;
+    } else
+        return CL_ENOENT;
+}
+/* Invokes the module entry point modules[module], passing argv[] as an argument
+ * stack. */
+int run_module(int module, char *argv[])
+{
+    module_t *mod = modules;
+    mod += module;
+    if (NULL != mod->entry)
+        return ((int)mod->entry(argv));
+    return CL_ENOENT;
+}

 /branches/dd/uspace/app/bdsh/cmds/cmds.h
 ,0 → 1,71
+#ifndef CMDS_H
+#define CMDS_H
+#include "config.h"
+#include "scli.h"
+/* Temporary to store strings */
+#define EXT_HELP      "extended"
+#define SHORT_HELP    "short"
+#define TEST_ANNOUNCE "Hello, this is :"
+/* Simple levels of help displays */
+#define HELP_SHORT 0
+#define HELP_LONG  1
+/* Acceptable buffer sizes (for strn functions) */
+/* TODO: Move me, other files duplicate these needlessly */
+#define BUFF_LARGE  1024
+#define BUFF_SMALL  255
+/* Return macros for int type entry points */
+#define CMD_FAILURE 1
+#define CMD_SUCCESS 0
+/* Types for module command entry and help */
+typedef int (* mod_entry_t)(char **);
+typedef void (* mod_help_t)(unsigned int);
+/* Built-in commands need to be able to modify cliuser_t */
+typedef int (* builtin_entry_t)(char **, cliuser_t *);
+typedef void (* builtin_help_t)(unsigned int);
+/* Module structure */
+typedef struct {
+    char *name;         /* Name of the command */
+    char *desc;         /* Description of the command */
+    mod_entry_t entry;  /* Command (exec) entry function */
+    mod_help_t help;    /* Command (help) entry function */
+} module_t;
+/* Builtin structure, same as modules except different types of entry points */
+typedef struct {
+    char *name;
+    char *desc;
+    builtin_entry_t entry;
+    builtin_help_t help;
+    int restricted;
+} builtin_t;
+/* Declared in cmds/modules/modules.h and cmds/builtins/builtins.h
+ * respectively */
+extern module_t modules[];
+extern builtin_t builtins[];
+/* Prototypes for module launchers */
+extern int module_is_restricted(int);
+extern int is_module(const char *);
+extern int is_module_alias(const char *);
+extern char * alias_for_module(const char *);
+extern int help_module(int, unsigned int);
+extern int run_module(int, char *[]);
+/* Prototypes for builtin launchers */
+extern int builtin_is_restricted(int);
+extern int is_builtin(const char *);
+extern int is_builtin_alias(const char *);
+extern char * alias_for_builtin(const char *);
+extern int help_builtin(int, unsigned int);
+extern int run_builtin(int, char *[], cliuser_t *);
+#endif

 /branches/dd/uspace/app/bdsh/cmds/builtin_cmds.c
 ,0 → 1,113
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+/* Almost identical (for now) to mod_cmds.c , however this will not be the case
+ * soon as builtin_t is going to grow way beyond module_t */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "errors.h"
+#include "cmds.h"
+#include "builtin_aliases.h"
+extern volatile unsigned int cli_interactive;
+int is_builtin(const char *command)
+{
+    builtin_t *cmd;
+    unsigned int i = 0;
+    if (NULL == command)
+        return -2;
+    for (cmd = builtins; cmd->name != NULL; cmd++, i++) {
+        if (!strcmp(cmd->name, command))
+            return i;
+    }
+    return -1;
+}
+int is_builtin_alias(const char *command)
+{
+    unsigned int i = 0;
+    if (NULL == command)
+        return -1;
+    for(i=0; builtin_aliases[i] != NULL; i+=2) {
+        if (!strcmp(builtin_aliases[i], command))
+            return 1;
+    }
+    return 0;
+}
+char *alias_for_builtin(const char *command)
+{
+    unsigned int i = 0;
+    if (NULL == command)
+        return (char *)NULL;
+    for(i=0; builtin_aliases[i] != NULL; i++) {
+        if (!strcmp(builtin_aliases[i], command))
+            return (char *)builtin_aliases[++i];
+        i++;
+    }
+    return (char *)NULL;
+}
+int help_builtin(int builtin, unsigned int extended)
+{
+    builtin_t *cmd = builtins;
+    cmd += builtin;
+    if (NULL != cmd->help) {
+        cmd->help(extended);
+        return CL_EOK;
+    } else
+        return CL_ENOENT;
+}
+int run_builtin(int builtin, char *argv[], cliuser_t *usr)
+{
+    builtin_t *cmd = builtins;
+    cmd += builtin;
+    if (NULL != cmd->entry)
+        return((int)cmd->entry(argv, usr));
+    return CL_ENOENT;
+}

 /branches/dd/uspace/app/bdsh/Makefile
 ,0 → 1,130
+# Copyright (c) 2005,  Martin Decky
+# All rights reserved.
+# Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+# 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.
+#
+# Neither the name of the original program's authors nor the names of its
+# contributors may be used to endorse or promote products derived from this
+# software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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
+LIBC_PREFIX = ../../lib/libc
+SOFTINT_PREFIX = ../../lib/softint
+include $(LIBC_PREFIX)/Makefile.toolchain
+CFLAGS += -I../../srv/kbd/include
+LIBS = $(LIBC_PREFIX)/libc.a
+DEFS += -DRELEASE=$(RELEASE)
+PROGRAM = bdsh
+# Any directory that cleaning targets should know about
+SUBDIRS = \
+    ./ \
+    cmds/ \
+    cmds/modules/ \
+    cmds/modules/help/ \
+    cmds/modules/mkdir/ \
+    cmds/modules/rm/ \
+    cmds/modules/cat/ \
+    cmds/modules/touch/ \
+    cmds/modules/ls/ \
+    cmds/modules/pwd/ \
+    cmds/modules/sleep/ \
+    cmds/modules/cp/ \
+    cmds/builtins/ \
+    cmds/builtins/exit/\
+    cmds/builtins/cd/
+SOURCES = \
+    cmds/modules/help/help.c \
+    cmds/modules/mkdir/mkdir.c \
+    cmds/modules/rm/rm.c \
+    cmds/modules/cat/cat.c \
+    cmds/modules/touch/touch.c \
+    cmds/modules/ls/ls.c \
+    cmds/modules/pwd/pwd.c \
+    cmds/modules/sleep/sleep.c \
+    cmds/modules/cp/cp.c \
+    cmds/builtins/exit/exit.c \
+    cmds/builtins/cd/cd.c \
+    cmds/mod_cmds.c \
+    cmds/builtin_cmds.c \
+    errors.c \
+    input.c \
+    util.c \
+    exec.c \
+    scli.c
+CFLAGS += -I. -Icmds/ -Icmds/builtins -Icmds/modules
+OBJECTS = $(SOURCES:.c=.o)
+# For easy cleaning, *.o is already handled
+CLEANDIRS := $(addsuffix *~,$(SUBDIRS))
+CLEANDIRS += $(addsuffix *.bak,$(SUBDIRS))
+CLEANDIRS += $(addsuffix *.tmp,$(SUBDIRS))
+CLEANDIRS += $(addsuffix *.out,$(SUBDIRS))
+CLEANDIRS += $(addsuffix *.d,$(SUBDIRS))
+CLEANDIRS += $(addsuffix *.gch,$(SUBDIRS) )
+%.o: %.S
+    $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@
+%.o: %.s
+    $(AS) $(AFLAGS) $< -o $@
+%.o: %.c
+    $(CC) $(CFLAGS) $(INC) -c $< -o $@
+    @$(CC) -M $(CFLAGS) $(INC) $*.c > $*.d
+$(PROGRAM): $(OBJECTS) $(LIBS)
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(PROGRAM).map
+# Everything else is a phony target
+.PHONY: all clean distclean depend disasm
+all: $(PROGRAM) disasm
+clean:
+    @-rm -f $(OBJECTS)
+    @-rm -f $(PROGRAM)
+    @-rm -f $(PROGRAM).map
+    @-rm -f $(PROGRAM).disasm
+    @-rm -f $(CLEANDIRS)
+depend:
+    @echo ''
+disasm:
+    $(OBJDUMP) -d $(PROGRAM) >$(PROGRAM).disasm
+distclean: clean
+# Do not delete - dependencies
+-include $(OBJECTS:.o=.d)

 /branches/dd/uspace/app/bdsh/AUTHORS
 ,0 → 1,14
+Written by Tim Post <echo@echoreply.us> to serve as a primitive shell
+for HelenOS, or as a template to make a command line interface that
+offers shell like creature comforts.
+This program was mostly written from scratch, some existing code was
+used from other various free software projects:
+* Based on the HelenOS testing sub-system written by Martin Decky
+* read_line() (input.c) was written by Jiri Svoboda
+Individual author copyrights are listed in the headers of each file.

 /branches/dd/uspace/app/bdsh/util.c
 ,0 → 1,82
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com> - 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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 <string.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include "config.h"
+#include "errors.h"
+#include "util.h"
+extern volatile int cli_errno;
+/* Count and return the # of elements in an array */
+unsigned int cli_count_args(char **args)
+{
+    unsigned int i;
+    for (i=0; args[i] != NULL; i++);
+    return i;
+}
+/* (re)allocates memory to store the current working directory, gets
+ * and updates the current working directory, formats the prompt
+ * string */
+unsigned int cli_set_prompt(cliuser_t *usr)
+{
+    usr->prompt = (char *) realloc(usr->prompt, PATH_MAX);
+    if (NULL == usr->prompt) {
+        cli_error(CL_ENOMEM, "Can not allocate prompt");
+        cli_errno = CL_ENOMEM;
+        return 1;
+    }
+    memset(usr->prompt, 0, sizeof(usr->prompt));
+    usr->cwd = (char *) realloc(usr->cwd, PATH_MAX);
+    if (NULL == usr->cwd) {
+        cli_error(CL_ENOMEM, "Can not allocate cwd");
+        cli_errno = CL_ENOMEM;
+        return 1;
+    }
+    memset(usr->cwd, 0, sizeof(usr->cwd));
+    usr->cwd = getcwd(usr->cwd, PATH_MAX - 1);
+    if (NULL == usr->cwd)
+        snprintf(usr->cwd, PATH_MAX, "(unknown)");
+    asprintf(&usr->prompt, "%s # ", usr->cwd);
+    return 0;
+}

 /branches/dd/uspace/app/bdsh/util.h
 ,0 → 1,10
+#ifndef UTIL_H
+#define UTIL_H
+#include "scli.h"
+/* Utility functions */
+extern unsigned int cli_count_args(char **);
+extern unsigned int cli_set_prompt(cliuser_t *usr);
+#endif

 /branches/dd/uspace/app/bdsh/exec.c
 ,0 → 1,129
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+/* The VERY basics of execute in place support. These are buggy, leaky
+ * and not nearly done. Only here for beta testing!! You were warned!!
+ * TODO:
+ * Hash command lookups to save time
+ * Create a running pointer to **path and advance/rewind it as we go */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include "config.h"
+#include "util.h"
+#include "exec.h"
+#include "errors.h"
+/* FIXME: Just have find_command() return an allocated string */
+static char *found;
+static char *find_command(char *);
+static int try_access(const char *);
+/* work-around for access() */
+static int try_access(const char *f)
+{
+    int fd;
+    fd = open(f, O_RDONLY);
+    if (fd > -1) {
+        close(fd);
+        return 0;
+    } else
+        return -1;
+}
+/* Returns the full path of "cmd" if cmd is found, else just hand back
+ * cmd as it was presented */
+static char *find_command(char *cmd)
+{
+    char *path_tok;
+    char *path[PATH_MAX];
+    int n = 0, i = 0;
+    size_t x = strlen(cmd) + 2;
+    found = (char *)malloc(PATH_MAX);
+    /* The user has specified a full or relative path, just give it back. */
+    if (-1 != try_access(cmd)) {
+        return (char *) cmd;
+    }
+    path_tok = strdup(PATH);
+    /* Extract the PATH env to a path[] array */
+    path[n] = strtok(path_tok, PATH_DELIM);
+    while (NULL != path[n]) {
+        if ((strlen(path[n]) + x ) > PATH_MAX) {
+            cli_error(CL_ENOTSUP,
+                "Segment %d of path is too large, search ends at segment %d",
+                n, n-1);
+            break;
+        }
+        path[++n] = strtok(NULL, PATH_DELIM);
+    }
+    /* We now have n places to look for the command */
+    for (i=0; path[i]; i++) {
+        memset(found, 0, sizeof(found));
+        snprintf(found, PATH_MAX, "%s/%s", path[i], cmd);
+        if (-1 != try_access(found)) {
+            free(path_tok);
+            return (char *) found;
+        }
+    }
+    /* We didn't find it, just give it back as-is. */
+    free(path_tok);
+    return (char *) cmd;
+}
+unsigned int try_exec(char *cmd, char **argv)
+{
+    task_id_t tid;
+    char *tmp;
+    tmp = strdup(find_command(cmd));
+    free(found);
+    tid = task_spawn((const char *)tmp, argv);
+    free(tmp);
+    if (tid == 0) {
+        cli_error(CL_EEXEC, "Can not spawn %s", cmd);
+        return 1;
+    } else {
+        return 0;
+    }
+}

 /branches/dd/uspace/app/bdsh/scli.c
 ,0 → 1,105
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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 <unistd.h>
+#include "config.h"
+#include "scli.h"
+#include "input.h"
+#include "util.h"
+#include "errors.h"
+#include "cmds/cmds.h"
+/* See scli.h */
+static cliuser_t usr;
+/* Globals that are modified during start-up that modules/builtins
+ * should be aware of. */
+volatile unsigned int cli_quit = 0;
+volatile unsigned int cli_verbocity = 1;
+/* The official name of this program
+ * (change to your liking in configure.ac and re-run autoconf) */
+const char *progname = PACKAGE_NAME;
+/* These are not exposed, even to builtins */
+static int cli_init(cliuser_t *);
+static void cli_finit(cliuser_t *);
+/* Constructor */
+static int cli_init(cliuser_t *usr)
+{
+    usr->line = (char *) NULL;
+    usr->name = "root";
+    usr->home = "/";
+    usr->cwd = (char *) NULL;
+    usr->prompt = (char *) NULL;
+    chdir(usr->home);
+    usr->lasterr = 0;
+    return (int) cli_set_prompt(usr);
+}
+/* Destructor */
+static void cli_finit(cliuser_t *usr)
+{
+    if (NULL != usr->line)
+        free(usr->line);
+    if (NULL != usr->prompt)
+        free(usr->prompt);
+    if (NULL != usr->cwd)
+        free(usr->cwd);
+}
+int main(int argc, char *argv[])
+{
+    int ret = 0;
+    if (cli_init(&usr))
+        exit(EXIT_FAILURE);
+    printf("Welcome to %s - %s\nType `help' at any time for usage information.\n",
+        progname, PACKAGE_STRING);
+    while (!cli_quit) {
+        get_input(&usr);
+        if (NULL != usr.line) {
+            ret = tok_input(&usr);
+            cli_set_prompt(&usr);
+            usr.lasterr = ret;
+        }
+    }
+    goto finit;
+finit:
+    cli_finit(&usr);
+    return ret;
+}

 /branches/dd/uspace/app/bdsh/config.h
 ,0 → 1,36
+/* Various things that are used in many places including a few
+ * tidbits left over from autoconf prior to the HelenOS port */
+/* Specific port work-arounds : */
+#ifndef PATH_MAX
+#define PATH_MAX 255
+#endif
+#ifndef EXIT_SUCCESS
+#define EXIT_SUCCESS 0
+#define EXIT_FAILURE 1
+#endif
+/* Work around for getenv() */
+#define PATH "/srv:/app"
+#define PATH_DELIM ":"
+/* Used in many places */
+#define SMALL_BUFLEN 256
+#define LARGE_BUFLEN 1024
+/* How many words (arguments) are permitted, how big can a whole
+ * sentence be? Similar to ARG_MAX */
+#define WORD_MAX 255
+#define INPUT_MAX 1024
+/* Leftovers from Autoconf */
+#define PACKAGE_MAINTAINER "Tim Post"
+#define PACKAGE_BUGREPORT "echo@echoreply.us"
+#define PACKAGE_NAME "bdsh"
+#define PACKAGE_STRING "The brain dead shell"
+#define PACKAGE_TARNAME "bdsh"
+#define PACKAGE_VERSION "0.0.1"

 /branches/dd/uspace/app/bdsh/README
 ,0 → 1,252
+BDSH - The Brain Dead Shell | Design Documentation
+--------------------------------------------------
+Overview:
+=========
+BDSH was written as a drop in command line interface for HelenOS to permit
+interactive access to persistent file systems in development. BDSH was
+written from scratch with a very limited userspace standard C library in
+mind. Much like the popular Busybox program, BDSH provides a very limited
+shell with limited common UNIX creature comforts built in.
+Porting Busybox (and by extension ASH) would have taken much longer to
+complete, much less make stable due to stark differences between Linux and
+Spartan with regards to IPC, term I/O and process creation. BDSH was written
+and made stable within the space of less than 30 days.
+BDSH will eventually evolve and be refined into the HelenOS equivalent
+of Busybox. While BDSH is now very intrinsic to HelenOS, its structure and
+use of strictly lower level functions makes it extremely easy to port.
+Design:
+=======
+BDSH is made up of three basic components:
+. Main i/o, error handling and task management
+. The builtin sub system
+. The module sub system
+The main part handles user input, reports errors, spawns external tasks and
+provides a convenient entry point for built-in and modular commands. A simple
+structure, cliuser_t keeps track of the user's vitals, such as their current
+working directory (and eventually uid, home directory, etc if they apply).
+This part defines and exposes all functions that are not intrinsic to a
+certain built in or modular command. For instance: string handlers,
+module/builtin search and launch functions, error handlers and other things
+can be found here.
+Builtin commands are commands that must have access to cliuser_t, which is
+not exposed to modular commands. For instance, the 'cd' command must update
+the current working directory, which is stored in cliuser_t. As such, the
+entry types for builtin commands are slightly different.
+Modular commands do not need anything more than the basic functions that are
+exposed by default. They do not need to modify cliuser_t, they are just self
+contained. A modular command could very easily be made into a stand alone
+program, likewise any stand alone program could easily become a modular
+command.
+Both modular and builtin commands share two things in common. Both must have
+two entry points, one to invoke the command and one to invoke a help display
+for the command. Exec (main()) entry points are int * and are expected to
+return a value. Help entry points are void *, no return value is expected.
+They are typed as such (from cmds.h):
+/* Types for module command entry and help */
+typedef int (* mod_entry_t)(char **);
+typedef void (* mod_help_t)(unsigned int);
+/* Built-in commands need to be able to modify cliuser_t */
+typedef int (* builtin_entry_t)(char **, cliuser_t *);
+typedef void (* builtin_help_t)(unsigned int);
+As you can see, both modular and builtin commands expect an array of
+arguments, however bulitins also expect to be pointed to cliuser_t.
+Both are defined with the same simple structure:
+/* Module structure */
+typedef struct {
+    char *name;         /* Name of the command */
+    char *desc;         /* Description of the command */
+    mod_entry_t entry;  /* Command (exec) entry function */
+    mod_help_t help;    /* Command (help) entry function */
+    int restricted;     /* Restricts to interactive/non-interactive only */
+} module_t;
+NOTE: Builtin commands may grow in this respect, that is why they are
+defined separately.
+Builtins, of course, would use the builtin_entry_t type. The name of the
+command is used to associate user input to a possible entry point. The
+description is a short (40 - 60 chars) summary of what the command does. Both
+entry points are then defined, and the restrict value is used to determine a
+commands availability.
+Restriction levels are easy, a command is either available exclusively within
+interactive mode, exclusively within non-interactive mode or both. If you are
+looking at a prompt, you are in interactive mode. If you issue a command like
+this:
+/sbin/bdsh command [arg1] [arg2]
+... you are in non interactive mode. This is done when you need to force the
+parent shell to be the one who actually handles the command, or ensure that
+/sbin/ls was used in lieu of the built in 'ls' when in non-interactive mode.
+The values are:
+: Unrestricted
+ -1 : Interactive only
+: Non-interactive only
+A script to generate skeletal files for a new command is included, it can be
+found in cmds/mknewcmd. To generate a new modular command named 'foo', which
+should also be reachable by typing 'f00', you would issue this command:
+./mknewcmd -n foo -a f00 -t module
+This generates all needed files and instructs you on how to include your new
+command in the build and make it accessible. By default, the command will be
+unrestricted. Builtin commands can be created by changing 'module' to
+'builtin'
+There are more options to mknewcmd, which allow you to specify the
+description, entry point, help entry point, or restriction. By default, names
+just follow the command such as cmd_foo(), help_cmd_foo(), 'The foo command',
+etc. If you want to see the options and explanations in detail, use
+./mknewcmd --help.
+When working with commands, keep in mind that only the main and help entry
+points need to be exposed. If commands share the same functions, put them
+where they are exposed to all commands, without the potential oops of those
+functions going away if the command is eliminated in favor of a stand alone
+external program.
+The util.c file is a great place to put those types of functions.
+Also, be careful with globals, option structures, etc. The compiler will
+generally tell you if you've made a mistake, however declaring:
+volatile int foo
+... in a command will allow for anything else to pick it up. Sometimes
+this could be desirable .. other times not. When communicating between
+builtins and the main system, try to use cliuser_t. The one exception
+for this is the cli_quit global, since everything may at some point
+need to check it. Modules should only communicate their return value.
+Symbolic constants that everything needs should go in the config.h file,
+however this is not the place to define shared macros.
+Making a program into a module
+==============================
+If you have some neat program that would be useful as a modular command,
+converting it is not very hard. The following steps should get you through
+the process easily (assuming your program is named 'foo'):
+: Use mknewcmd to generate the skeletal files.
+: Change your "usage()" command as shown:
+     -- void usage(...)
+     ++ void help_cmd_foo(unsigned int level)
+     'level' is either 0 or 1, indicating the level of help requested.
+     If the help / usage function currently exits based on how it is
+     called, you'll need to change it.
+: Change the programs "main()" as shown:
+     -- int main(int argc, char **argv)
+     ++ int cmd_foo(char **argv)
+     -- return 1;
+     ++ return CMD_FAILURE;
+     -- return 0;
+     ++ return CMD_SUCCESS;
+     NOTE: If main is void, you'll need to change it and ensure that its
+     expecting an array of arguments, even if they'll never be read or
+     used. I.e.:
+     -- void main(void)
+     ++ int cmd_foo(char **argv)
+: Don't expose more than the entry and help points:
+     -- void my_function(int n)
+     ++ static void my_function(int n)
+: Copy/paste to the stub generated by mknewcmd then add your files to the
+   Makefile. Be sure to add any directories that you made to the SUBDIRS so
+   that a 'make clean' will clean them.
+Provided that all functions that your calling are available in the
+userspace C library, your program should compile just fine and appear
+as a modular command.
+Overcoming userspace libc obstacles
+===================================
+A quick glance through the util.c file will reveal functions like
+cli_strdup(), cli_strtok(), cli_strtok_r() and more. Those are functions
+that were missing from userspace libc when BDSH was born. Later, after
+porting what was needed from FBSD/NBSD, the real functions appeared in
+the userspace libc after being tested in their cli_* implementations.
+Those functions remain because they guarantee that bdsh will work even
+on systems that lack them. Additionally, more BDSH specific stuff can
+go into them, such as error handling and reporting when malloc() fails.
+You will also notice that FILE, fopen() (and all friends), ato*() and
+other common things might be missing. The HelenOS userspace C library is
+still very young, you are sure to run into something that you want/need
+which is missing.
+When that happens, you have three options:
+- Implement it internally in util.c , when its tested and stable send a
+patch to HelenOS asking for your function to be included in libc. This is
+the best option, as you not only improve BDSH .. but HelenOS as a whole.
+- Work around it. Not everyone can implement / port fopen() and all of
+its friends. Make open(), read(), write() (etc) work if at all possible.
+- Send an e-mail to the HelenOS development mailing list. Explain why you
+need the function and what its absence is holding up.
+If what you need is part of a library that is typically a shared object, try
+to implement a 'mini' version of it. Currently, all userspace applications
+are statically linked. Giving up creature comforts for size while avoiding
+temporary 'band aids' is never frowned upon.
+Most of all, don't get discouraged .. ask for some help prior to giving up
+if you just can't accomplish something with the limited means provided.
+Contributing
+============
+I will take any well written patch that sanely improves or expands BDSH. Send
+me a patch against the trunk revision, or, if you like a Mercurial repository
+is also maintained at http://echoreply.us/hg/bdsh.hg and kept in sync with
+the trunk.
+Please be sure to follow the simple coding standards outlined at
+http://www.helenos.eu/cstyle (mostly just regarding formatting), test your
+changes and make sure your patch applies cleanly against the latest revision.
+All patches submitted must be your original code, or a derivative work of
+something licensed under the same 3 clause BSD license as BDSH. See LICENSE
+for more information.
+When sending patches, you agree that your work will be published under the
+same 3 clause BSD license as BDSH itself. Failure to ensure that anything
+you used is not under the same or less restrictive license could cause major
+issues for BDSH in the future .. please be sure. Also, please don't forget
+to add yourself in the AUTHORS file, as I am horrible about keeping such
+things up to date.

 /branches/dd/uspace/app/bdsh/scli.h
 ,0 → 1,16
+#ifndef SCLI_H
+#define SCLI_H
+#include "config.h"
+#include <stdint.h>
+typedef struct {
+    char *name;
+    char *home;
+    char *line;
+    char *cwd;
+    char *prompt;
+    int lasterr;
+} cliuser_t;
+#endif

 /branches/dd/uspace/app/bdsh/input.h
 ,0 → 1,11
+#ifndef INPUT_H
+#define INPUT_H
+#include "cmds/cmds.h"
+/* prototypes */
+extern void get_input(cliuser_t *);
+extern int tok_input(cliuser_t *);
+#endif

/branches/dd/uspace/app/bdsh/exec.h
0,0 → 1,7
#ifndef EXEC_H
#define EXEC_H

#include <task.h>

extern unsigned int try_exec(char , char *);
#endif

 /branches/dd/uspace/app/bdsh/errors.c
 ,0 → 1,87
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * 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.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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 <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include "config.h"
+#include "errors.h"
+#include "errstr.h"
+volatile int cli_errno = CL_EOK;
+extern volatile unsigned int cli_quit;
+/* Error printing, translation and handling functions */
+/* Look up errno in cl_errors and return the corresponding string.
+ * Return NULL if not found */
+static char *err2str(int err)
+{
+    if (NULL != cl_errors[err])
+        return cl_errors[err];
+    return (char *)NULL;
+}
+/* Print an error report signifying errno, which is translated to
+ * its corresponding human readable string. If errno > 0, raise the
+ * cli_quit int that tells the main program loop to exit immediately */
+void cli_error(int err, const char *fmt, ...)
+{
+    va_list vargs;
+    va_start(vargs, fmt);
+    vprintf(fmt, vargs);
+    va_end(vargs);
+    if (NULL != err2str(err))
+        printf(" (%s)\n", err2str(err));
+    else
+        printf(" (Unknown Error %d)\n", err);
+    /* If fatal, raise cli_quit so that we try to exit
+     * gracefully. This will break the main loop and
+     * invoke the destructor */
+    if (err == CL_EFATAL)
+        cli_quit = 1;
+    return;
+}

 /branches/dd/uspace/app/bdsh/errors.h
 ,0 → 1,22
+#ifndef ERRORS_H
+#define ERRORS_H
+/* Various error levels */
+#define CL_EFATAL  -1
+#define CL_EOK     0
+#define CL_EFAIL   1
+#define CL_EBUSY   2
+#define CL_ENOENT  3
+#define CL_ENOMEM  4
+#define CL_EPERM   5
+#define CL_ENOTSUP 6
+#define CL_EEXEC   7
+#define CL_EEXISTS 8
+#define CL_ETOOBIG 9
+/* Just like 'errno' */
+extern volatile int cli_errno;
+extern void cli_error(int, const char *, ...);
+#endif

 /branches/dd/uspace/app/bdsh/errstr.h
 ,0 → 1,23
+#ifndef ERRSTR_H
+#define ERRSTR_H
+/* Simple array to translate error codes to meaningful strings */
+static char *cl_errors[] = {
+    "Success",
+    "Failure",
+    "Busy",
+    "No Such Entry",
+    "Not Enough Memory",
+    "Permission Denied",
+    "Method Not Supported",
+    "Bad command or file name",
+    "Entry already exists",
+    "Object too large",
+    NULL
+};
+static char *err2str(int);
+#endif

 /branches/dd/uspace/app/bdsh/TODO
 ,0 → 1,57
+This is a very brain dead shell. It needs some love, coffee or perhaps beer.
+Currently, you can't even really call it a shell, its more of a CLI that
+offers some shell like creature comforts.
+This was written in a hurry to provide some means of testing persistent file
+systems in HelenOS. It does its job, its nowhere near complete but it is
+actively developed. If your reading this, its likely that you're looking for
+some functionality that is not yet present. Prior to filing a bug report,
+please make sure that what you want is not on the list below.
+A list of things to do:
+-----------------------
+* rm: add support for recursively removing directories and files therein
+* Port an editor (vim?)
+* Finish cat / cp
+* Support basic redirection (i.e ls > foo.txt)
+* Expand wildcards (i.e. *.txt), don't worry about variables for now
+* Basic scripting
+* Hash previously found commands
+* Improve input, add history / etc (port libedit?)
+* Add wrappers for signal, sigaction to make ports to modules easier
+* Add 'echo' and 'printf' modules.
+Regarding POSIX:
+----------------
+POSIX is a standard for Unix-like operating systems. HelenOS is (mostly) just
+a kernel at this point with a few userspace programs that facilitate testing
+of the kernel and file systems.
+HelenOS is not a Unix-like operating system. HelenOS is its own thing, a modern
+microkernel OS and many directions are not yet set.
+Please do not e-mail me to point out that modular implementations that resemble
+typical core utilities do not conform to some POSIX standard, these are temporary
+and serve the useful purpose of testing persistent file systems.
+Contributing:
+-------------
+If you feel like doing any of the above to-do items, I am echo@echoreply.us. Please
+e-mail me and let me know your working on something so that I do not unwittingly
+duplicate your efforts. You can also e-mail the HelenOS list directly:
+HelenOS development mailing list <helenos-devel@lists.modry.cz>
+Subscribe here if you like: http://lists.modry.cz/cgi-bin/listinfo/helenos-devel
+Cheers and happy hacking!
+--Tim

 /branches/dd/uspace/app/bdsh/LICENSE
 ,0 → 1,28
+Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+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.
+Neither the name of the original program's authors nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.

 /branches/dd/uspace/app/init/init.c
 ,37 → 27,93
  */
 /** @addtogroup init Init
- * @brief   Init process for testing purposes.
+ * @brief Init process for user space environment configuration.
  * @{
- */
+ */
 /**
  * @file
  */
+#include <stdio.h>
+#include <unistd.h>
+#include <ipc/ipc.h>
+#include <vfs/vfs.h>
+#include <bool.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <task.h>
+#include <malloc.h>
+#include <macros.h>
+#include "init.h"
 #include "version.h"
-#include <stdio.h>
-static void test_console(void)
+static bool mount_fs(const char *fstype)
 {
-    int c;
+    int rc = -1;
+    while (rc < 0) {
+        rc = mount(fstype, "/", "initrd", IPC_FLAG_BLOCKING);
+        switch (rc) {
+        case EOK:
+            printf(NAME ": Root filesystem mounted\n");
+            break;
+        case EBUSY:
+            printf(NAME ": Root filesystem already mounted\n");
+            break;
+        case ELIMIT:
+            printf(NAME ": Unable to mount root filesystem\n");
+            return false;
+        case ENOENT:
+            printf(NAME ": Unknown filesystem type (%s)\n", fstype);
+            return false;
+        }
+    }
+    return true;
+}
-    while ((c = getchar()) != EOF)
-        putchar(c);
+static void spawn(char *fname)
+{
+    char *argv[2];
+    printf(NAME ": Spawning %s\n", fname);
+    argv[0] = fname;
+    argv[1] = NULL;
+    if (task_spawn(fname, argv))
+        /* Add reasonable delay to avoid
+           intermixed klog output */
+        usleep(10000);
+    else
+        printf(NAME ": Error spawning %s\n", fname);
 }
 int main(int argc, char *argv[])
 {
+    info_print();
+    if (!mount_fs(STRING(RDFMT))) {
+        printf(NAME ": Exiting\n");
+        return -1;
+    }
+    // FIXME: spawn("/srv/pci");
+    spawn("/srv/fb");
+    spawn("/srv/kbd");
+    spawn("/srv/console");
+    spawn("/srv/fhc");
+    spawn("/srv/obio");
+    console_wait();
     version_print();
-    printf("This is init\n");
-    test_console();
-    printf("\nBye.\n");
+    spawn("/app/klog");
+    spawn("/app/bdsh");
     return 0;
 }
 /** @}
  */

 /branches/dd/uspace/app/init/version.c
 ,22 → 35,29
 #include <unistd.h>
 #include <stdio.h>
+#include <macros.h>
+#include "init.h"
 #include "version.h"
-char *release = RELEASE;
+char *release = STRING(RELEASE);
 #ifdef REVISION
-    char *revision = ", revision " REVISION;
+    char *revision = ", revision " STRING(REVISION);
 #else
     char *revision = "";
 #endif
 #ifdef TIMESTAMP
-    char *timestamp = "\nBuilt on " TIMESTAMP;
+    char *timestamp = "\nBuilt on " STRING(TIMESTAMP);
 #else
     char *timestamp = "";
 #endif
+void info_print(void)
+{
+    printf(NAME ": HelenOS init\n");
+}
 /** Print version information. */
 void version_print(void)
 {

 /branches/dd/uspace/app/init/init.h
 ,7 → 36,7
 #ifndef __INIT_H__
 #define __INIT_H__
-#include "version.h"
+#define NAME "init"
 #endif

/branches/dd/uspace/app/init/version.h
36,6 → 36,7
#ifndef __VERSION_H__
#define __VERSION_H__

extern void info_print(void);
extern void version_print(void);

#endif

 /branches/dd/uspace/app/init/Makefile
 ,7 → 27,6
 #
 include ../../../version
-include ../../Makefile.config
 ## Setup toolchain
 #
 ,21 → 33,14
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 CFLAGS += -I../../srv/kbd/include
 LIBS = $(LIBC_PREFIX)/libc.a
-DEFS += -DRELEASE=\"$(RELEASE)\"
+DEFS += -DRELEASE=$(RELEASE)
-ifdef REVISION
-    DEFS += "-DREVISION=\"$(REVISION)\""
-endif
-ifdef TIMESTAMP
-    DEFS += "-DTIMESTAMP=\"$(TIMESTAMP)\""
-endif
 ## Sources
 #
 ,22 → 53,24
 .PHONY: all clean depend disasm
-all: $(OUTPUT) disasm
+all: $(OUTPUT) $(OUTPUT).disasm
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -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/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm:
-    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/dd/uspace/app/tester/console/console1.c
 ,0 → 1,109
+/*
+ * 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.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <io/stream.h>
+#include <async.h>
+#include "../tester.h"
+#include <console.h>
+const char *color_name[] = {
+    [COLOR_BLACK] = "black",
+    [COLOR_BLUE] = "blue",
+    [COLOR_GREEN] = "green",
+    [COLOR_CYAN] = "cyan",
+    [COLOR_RED] = "red",
+    [COLOR_MAGENTA] = "magenta",
+    [COLOR_YELLOW] = "yellow",
+    [COLOR_WHITE] = "white"
+};
+char * test_console1(bool quiet)
+{
+    int i, j;
+    printf("Style test: ");
+    console_set_style(STYLE_NORMAL);
+    printf("normal ");
+    console_set_style(STYLE_EMPHASIS);
+    printf("emphasized");
+    console_set_style(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,
+                j ? CATTR_BRIGHT : 0);
+            printf(" %s ", color_name[i]);
+        }
+        console_set_color(COLOR_BLACK, COLOR_WHITE, 0);
+        putchar('\n');
+    }
+    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,
+                j ? CATTR_BRIGHT : 0);
+            printf(" %s ", color_name[i]);
+        }
+        console_set_color(COLOR_BLACK, COLOR_WHITE, 0);
+        putchar('\n');
+    }
+    printf("Now let's test RGB colors:\n");
+    for (i = 0; i < 255; i += 16) {
+        console_set_rgb_color(0xffffff, i << 16);
+        putchar('X');
+    }
+    console_set_color(COLOR_BLACK, COLOR_WHITE, 0);
+    putchar('\n');
+    for (i = 0; i < 255; i += 16) {
+        console_set_rgb_color(0xffffff, i << 8);
+        putchar('X');
+    }
+    console_set_color(COLOR_BLACK, COLOR_WHITE, 0);
+    putchar('\n');
+    for (i = 0; i < 255; i += 16) {
+        console_set_rgb_color(0xffffff, i);
+        putchar('X');
+    }
+    console_set_color(COLOR_BLACK, COLOR_WHITE, 0);
+    putchar('\n');
+    printf("[press a key]\n");
+    getchar();
+    return NULL;
+}

/branches/dd/uspace/app/tester/console/console1.def
0,0 → 1,6
{
"console1",
"Console color test",
&test_console1,
true
},

/branches/dd/uspace/app/tester/stdio/stdio1.def
0,0 → 1,6
{
"stdio1",
"ANSI C streams reading test",
&test_stdio1,
true
},

/branches/dd/uspace/app/tester/stdio/stdio2.def
0,0 → 1,6
{
"stdio2",
"ANSI C streams writing test",
&test_stdio2,
true
},

 /branches/dd/uspace/app/tester/stdio/stdio2.c
 ,0 → 1,69
+/*
+ * 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.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include "../tester.h"
+char * test_stdio2(bool quiet)
+{
+    FILE *f;
+    char *file_name = "/test";
+    size_t n;
+    int c;
+    printf("Open file '%s' for writing\n", file_name);
+    errno = 0;
+    f = fopen(file_name, "wt");
+    if (f == NULL)
+        return "Failed opening file.";
+    fprintf(f, "Integer: %d, string: '%s'\n", 42, "Hello!");
+    if (fclose(f) != 0)
+        return "Failed closing file.";
+    printf("Open file '%s' for reading\n", file_name);
+    f = fopen(file_name, "rt");
+    if (f == NULL)
+        return "Failed opening file.";
+    printf("File contains:\n");
+    while (true) {
+        c = fgetc(f);
+        if (c == EOF) break;
+        putchar(c);
+    }
+    if (fclose(f) != 0)
+        return "Failed closing file.";
+    return NULL;
+}

 /branches/dd/uspace/app/tester/stdio/stdio1.c
 ,0 → 1,85
+/*
+ * 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.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include "../tester.h"
+#define BUF_SIZE 32
+static char buf[BUF_SIZE + 1];
+char * test_stdio1(bool quiet)
+{
+    FILE *f;
+    char *file_name = "/readme";
+    size_t n;
+    int c;
+    printf("Open file '%s'\n", file_name);
+    errno = 0;
+    f = fopen(file_name, "rt");
+    if (f == NULL) printf("errno = %d\n", errno);
+    if (f == NULL)
+        return "Failed opening file.";
+    n = fread(buf, 1, BUF_SIZE, f);
+    if (ferror(f)) {
+        fclose(f);
+        return "Failed reading file.";
+    }
+    printf("Read %d bytes.\n", n);
+    buf[n] = '\0';
+    printf("Read string '%s'.\n", buf);
+    printf("Seek to beginning.\n");
+    if (fseek(f, 0, SEEK_SET) != 0) {
+        fclose(f);
+        return "Failed seeking.";
+    }
+    printf("Read using fgetc().\n");
+    while (true) {
+        c = fgetc(f);
+        if (c == EOF) break;
+        printf("'%c'", c);
+    }
+    printf("[EOF]\n");
+    printf("Closing.\n");
+    if (fclose(f) != 0)
+        return "Failed closing.";
+    return NULL;
+}

 /branches/dd/uspace/app/tester/tester.c
 ,7 → 56,11
 #include "ipc/answer.def"
 #include "ipc/hangup.def"
 #include "devmap/devmap1.def"
+#include "loop/loop1.def"
 #include "vfs/vfs1.def"
+#include "console/console1.def"
+#include "stdio/stdio1.def"
+#include "stdio/stdio2.def"
     {NULL, NULL, NULL}
 };
 ,8 → 111,17
     printf("*\t\t\tRun all safe tests\n");
 }
-int main(void)
+int main(int argc, char **argv)
 {
+    printf("Number of arguments: %d\n", argc);
+    if (argv) {
+        printf("Arguments:");
+        while (*argv) {
+            printf(" '%s'", *argv++);
+        }
+        printf("\n");
+    }
     while (1) {
         char c;
         test_t *test;
 ,15 → 137,22
                 if (c == 'a')
                     break;
-            if (c > 'a')
+            if (test->name == NULL)
                 printf("Unknown test\n\n");
             else
                 run_test(test);
-        } else if (c == '*')
+        } else if (c == '*') {
             run_safe_tests();
-        else
+        } else if (c < 0) {
+            /* got EOF */
+            break;
+        } else {
             printf("Invalid test\n\n");
+        }
     }
+    return 0;
 }
 /** @}

/branches/dd/uspace/app/tester/loop/loop1.def
0,0 → 1,6
{
"loop1",
"Endless loop",
&test_loop1,
false
},

 /branches/dd/uspace/app/tester/loop/loop1.c
 ,0 → 1,41
+/*
+ * 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.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "../tester.h"
+char *test_loop1(bool quiet)
+{
+    printf("Looping...\n");
+    while (1);
+    printf("Survived endless loop?!!\n");
+    return NULL;
+}

/branches/dd/uspace/app/tester/ipc/send_sync.c
35,7 → 35,6
{
int phoneid;
int res;
static int msgid = 1;
char c;

printf("Select phoneid to send msg: 2-9 (q to skip)\n");

 /branches/dd/uspace/app/tester/devmap/devmap1.c
 ,7 → 32,7
 #include <ipc/services.h>
 #include <async.h>
 #include <errno.h>
-#include <../../../srv/devmap/devmap.h>
+#include <ipc/devmap.h>
 #include "../tester.h"
 #include <time.h>
 ,12 → 132,10
     int phone;
     ipcarg_t callback_phonehash;
-    phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_DRIVER, 0);
-    while (phone < 0) {
-        usleep(100000);
-        phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
-            DEVMAP_DRIVER, 0);
+    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);

 /branches/dd/uspace/app/tester/tester.h
 ,7 → 69,11
 extern char * test_answer(bool quiet);
 extern char * test_hangup(bool quiet);
 extern char * test_devmap1(bool quiet);
+extern char * test_loop1(bool quiet);
 extern char * test_vfs1(bool quiet);
+extern char * test_console1(bool quiet);
+extern char * test_stdio1(bool quiet);
+extern char * test_stdio2(bool quiet);
 extern test_t tests[];

 /branches/dd/uspace/app/tester/Makefile
 ,6 → 31,7
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 CFLAGS += -I../../srv/kbd/include
 ,7 → 53,11
     ipc/send_sync.c \
     ipc/answer.c \
     ipc/hangup.c \
+    loop/loop1.c \
     devmap/devmap1.c \
+    console/console1.c \
+    stdio/stdio1.c \
+    stdio/stdio2.c \
     vfs/vfs1.c
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
 ,22 → 64,24
 .PHONY: all clean depend disasm
-all: $(OUTPUT) disasm
+all: $(OUTPUT) $(OUTPUT).disasm
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -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/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm:
-    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/dd/uspace/app/tester/vfs/vfs1.c
 ,7 → 45,7
 {
     int rc;
-    rc = mount("tmpfs", "/", "nulldev0");
+    rc = mount("tmpfs", "/", "nulldev0", 0);
     switch (rc) {
     case EOK:
         if (!quiet)

 /branches/dd/uspace/app/tetris/scores.c
 ,7 → 52,7
 /* #include <err.h> */
 /* #include <fcntl.h> */
 /* #include <pwd.h> */
- #include <stdio.h>
+#include <stdio.h>
 /* #include <stdlib.h> */
 #include <string.h>
 /* #include <time.h> */

 /branches/dd/uspace/app/tetris/input.c
 ,7 → 57,8
 #include "tetris.h"
 #include <async.h>
-#include "../../srv/console/console.h"
+#include <ipc/console.h>
+#include <kbd/kbd.h>
 /* return true iff the given timeval is positive */
 #define TV_POS(tv) \
 ,6 → 97,7
     struct timeval starttv, endtv, *s;
     static ipc_call_t charcall;
     ipcarg_t rc;
+    int cons_phone;
     /*
      * Someday, select() will do this for us.
 ,8 → 112,12
         s = NULL;
     if (!lastchar) {
-        if (!getchar_inprog)
-            getchar_inprog = async_send_2(1,CONSOLE_GETCHAR,0,0,&charcall);
+again:
+        if (!getchar_inprog) {
+            cons_phone = get_console_phone();
+            getchar_inprog = async_send_2(cons_phone,
+                CONSOLE_GETKEY, 0, 0, &charcall);
+        }
         if (!s)
             async_wait_for(getchar_inprog, &rc);
         else if (async_wait_timeout(getchar_inprog, &rc, s->tv_usec) == ETIMEOUT) {
 ,7 → 129,10
         if (rc) {
             stop("end of file, help");
         }
-        lastchar = IPC_GET_ARG1(charcall);
+        if (IPC_GET_ARG1(charcall) == KE_RELEASE)
+            goto again;
+        lastchar = IPC_GET_ARG4(charcall);
     }
     if (tvp) {
         /* since there is input, we may not have timed out */

 /branches/dd/uspace/app/tetris/screen.c
 ,13 → 50,12
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#include <io/stream.h>
+#include <console.h>
 #include <async.h>
 #include "screen.h"
 #include "tetris.h"
-#include "../../srv/console/console.h"
+#include <ipc/console.h>
 static cell curscreen[B_SIZE];  /* 1 => standout (or otherwise marked) */
 static int curscore;
 ,29 → 72,19
         putchar(*(s++));
 }
-static int con_phone;
-static void set_style(int fgcolor, int bgcolor)
-{
-    async_msg_2(con_phone, CONSOLE_SET_STYLE, fgcolor, bgcolor);
-}
 static void start_standout(void)
 {
-    set_style(0xf0f0f0, 0);
+    console_set_rgb_color(0xf0f0f0, 0);
 }
 static void resume_normal(void)
 {
-    set_style(0, 0xf0f0f0);
+    console_set_rgb_color(0, 0xf0f0f0);
 }
 void clear_screen(void)
 {
-    async_msg_0(con_phone, CONSOLE_CLEAR);
+    console_clear();
     moveto(0, 0);
 }
 ,7 → 96,7
 {
     resume_normal();
-    async_msg_0(con_phone, CONSOLE_CLEAR);
+    console_clear();
     curscore = -1;
     memset((char *)curscreen, 0, sizeof(curscreen));
 }
 ,8 → 107,7
 void
 scr_init(void)
 {
-    con_phone = get_cons_phone();
-    async_msg_1(con_phone, CONSOLE_CURSOR_VISIBILITY, 0);
+    console_cursor_visibility(0);
     resume_normal();
     scr_clear();
 }
 ,12 → 114,12
 void moveto(int r, int c)
 {
-    async_msg_2(con_phone, CONSOLE_GOTO, r, c);
+    console_goto(r, c);
 }
 static void fflush(void)
 {
-    async_msg_0(con_phone, CONSOLE_FLUSH);
+    console_flush();
 }
 winsize_t winsize;
 ,8 → 126,7
 static int get_display_size(winsize_t *ws)
 {
-    return async_req_0_2(con_phone, CONSOLE_GETSIZE, &ws->ws_row,
-        &ws->ws_col);
+    return console_get_size(&ws->ws_row, &ws->ws_col);
 }
 /*

 /branches/dd/uspace/app/tetris/screen.h
 ,8 → 49,8
 #include <async.h>
 typedef struct {
-    ipcarg_t ws_row;
-    ipcarg_t ws_col;
+    int ws_row;
+    int ws_col;
 } winsize_t;
 extern winsize_t winsize;

 /branches/dd/uspace/app/tetris/Makefile
 ,5 → 1,6
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 LIBS = $(LIBC_PREFIX)/libc.a
 ,7 → 11,7
 .PHONY: all clean depend disasm
-all: $(OUTPUT) disasm
+all: $(OUTPUT) $(OUTPUT).disasm
 -include Makefile.depend
 ,13 → 19,16
     $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
 $(OUTPUT): $(OBJECTS) $(LIBS)
-    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
 clean:
     -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend *.o
-disasm:
-    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/dd/uspace/app/klog/Makefile
 ,6 → 31,7
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 LIBS = $(LIBC_PREFIX)/libc.a
 ,22 → 48,24
 .PHONY: all clean depend disasm
-all: $(OUTPUT) disasm
+all: $(OUTPUT) $(OUTPUT).disasm
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -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/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm:
-    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/dd/uspace/app/klog/klog.c
 ,9 → 27,9
  */
 /** @addtogroup klog KLog
- * @brief   HelenOS KLog
+ * @brief HelenOS KLog
  * @{
- */
+ */
 /**
  * @file
  */
 ,46 → 40,56
 #include <ipc/services.h>
 #include <as.h>
 #include <sysinfo.h>
+#include <io/stream.h>
+#include <errno.h>
+#define NAME "klog"
+#define KLOG_SIZE PAGE_SIZE
 /* Pointer to klog area */
 static char *klog;
 static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
 {
-    int i;
+    async_serialize_start();
-    async_serialize_start();
-    for (i=0; klog[i + IPC_GET_ARG1(*call)] && i < IPC_GET_ARG2(*call); i++)
-        putchar(klog[i + IPC_GET_ARG1(*call)]);
-    putchar('\n');
+    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;
+    for (i = klog_len - klog_stored; i < klog_len; i++)
+        putchar(klog[(klog_start + i) % KLOG_SIZE]);
     async_serialize_end();
 }
 int main(int argc, char *argv[])
 {
-    int res;
-    void *mapping;
-    printf("Kernel console output.\n");
+    console_wait();
-    mapping = as_get_mappable_page(PAGE_SIZE);
-    res = ipc_share_in_start_1_0(PHONE_NS, mapping, PAGE_SIZE,
+    klog = (char *) as_get_mappable_page(KLOG_SIZE);
+    if (klog == NULL) {
+        printf(NAME ": Error allocating memory area\n");
+        return -1;
+    }
+    int res = ipc_share_in_start_1_0(PHONE_NS, (void *) klog, KLOG_SIZE,
         SERVICE_MEM_KLOG);
-    if (res) {
-        printf("Failed to initialize klog memarea\n");
-        _exit(1);
+    if (res != EOK) {
+        printf(NAME ": Error initializing memory area\n");
+        return -1;
     }
-    klog = mapping;
+    int devno = sysinfo_value("klog.devno");
     int inr = sysinfo_value("klog.inr");
-    int devno = sysinfo_value("klog.devno");
-    if (ipc_register_irq(inr, devno, 0, NULL)) {
-        printf("Error registering for klog service.\n");
-        return 0;
+    if (ipc_register_irq(inr, devno, 0, NULL) != EOK) {
+        printf(NAME ": Error registering klog notifications\n");
+        return -1;
     }
     async_set_interrupt_received(interrupt_received);
+    klog_update();
     async_manager();
     return 0;

 /branches/dd/uspace/app/trace/trace.c
 ,0 → 1,831
+/*
+ * 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 trace
+ * @{
+ */
+/** @file
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <ipc/ipc.h>
+#include <fibril.h>
+#include <errno.h>
+#include <udebug.h>
+#include <async.h>
+#include <task.h>
+#include <loader/loader.h>
+#include <libc.h>
+// Temporary: service and method names
+#include "proto.h"
+#include <ipc/services.h>
+#include "../../srv/vfs/vfs.h"
+#include <ipc/console.h>
+#include "syscalls.h"
+#include "ipcp.h"
+#include "errors.h"
+#include "trace.h"
+#define THBUF_SIZE 64
+uintptr_t thread_hash_buf[THBUF_SIZE];
+int n_threads;
+int next_thread_id;
+int phoneid;
+int abort_trace;
+uintptr_t thash;
+volatile int paused;
+void thread_trace_start(uintptr_t thread_hash);
+static proto_t *proto_console;
+static task_id_t task_id;
+static loader_t *task_ldr;
+/** Combination of events/data to print. */
+display_mask_t display_mask;
+static int program_run_fibril(void *arg);
+static void program_run(void)
+{
+    fid_t fid;
+    fid = fibril_create(program_run_fibril, NULL);
+    if (fid == 0) {
+        printf("Error creating fibril\n");
+        exit(1);
+    }
+    fibril_add_ready(fid);
+}
+static int program_run_fibril(void *arg)
+{
+    int rc;
+    /*
+     * This must be done in background as it will block until
+     * we let the task reply to this call.
+     */
+    rc = loader_run(task_ldr);
+    if (rc != 0) {
+        printf("Error running program\n");
+        exit(1);
+    }
+    free(task_ldr);
+    task_ldr = NULL;
+    printf("program_run_fibril exiting\n");
+    return 0;
+}
+static int connect_task(task_id_t task_id)
+{
+    int rc;
+    rc = ipc_connect_kbox(task_id);
+    if (rc == ENOTSUP) {
+        printf("You do not have userspace debugging support "
+            "compiled in the kernel.\n");
+        printf("Compile kernel with 'Support for userspace debuggers' "
+            "(CONFIG_UDEBUG) enabled.\n");
+        return rc;
+    }
+    if (rc < 0) {
+        printf("Error connecting\n");
+        printf("ipc_connect_task(%lld) -> %d ", task_id, rc);
+        return rc;
+    }
+    phoneid = rc;
+    rc = udebug_begin(phoneid);
+    if (rc < 0) {
+        printf("udebug_begin() -> %d\n", rc);
+        return rc;
+    }
+    rc = udebug_set_evmask(phoneid, UDEBUG_EM_ALL);
+    if (rc < 0) {
+        printf("udebug_set_evmask(0x%x) -> %d\n ", UDEBUG_EM_ALL, rc);
+        return rc;
+    }
+    return 0;
+}
+static int get_thread_list(void)
+{
+    int rc;
+    size_t tb_copied;
+    size_t tb_needed;
+    int i;
+    rc = udebug_thread_read(phoneid, thread_hash_buf,
+        THBUF_SIZE*sizeof(unsigned), &tb_copied, &tb_needed);
+    if (rc < 0) {
+        printf("udebug_thread_read() -> %d\n", rc);
+        return rc;
+    }
+    n_threads = tb_copied / sizeof(uintptr_t);
+    printf("Threads:");
+    for (i = 0; i < n_threads; i++) {
+        printf(" [%d] (hash 0x%lx)", 1+i, thread_hash_buf[i]);
+    }
+    printf("\ntotal of %u threads\n", tb_needed / sizeof(uintptr_t));
+    return 0;
+}
+void val_print(sysarg_t val, val_type_t v_type)
+{
+    switch (v_type) {
+    case V_VOID:
+        printf("<void>");
+        break;
+    case V_INTEGER:
+        printf("%ld", val);
+        break;
+    case V_HASH:
+    case V_PTR:
+        printf("0x%08lx", val);
+        break;
+    case V_ERRNO:
+        if (val >= -15 && val <= 0) {
+            printf("%ld %s (%s)", val,
+                err_desc[-val].name,
+                err_desc[-val].desc);
+        } else {
+            printf("%ld", val);
+        }
+        break;
+    case V_INT_ERRNO:
+        if (val >= -15 && val < 0) {
+            printf("%ld %s (%s)", val,
+                err_desc[-val].name,
+                err_desc[-val].desc);
+        } else {
+            printf("%ld", val);
+        }
+        break;
+    case V_CHAR:
+        if (val >= 0x20 && val < 0x7f) {
+            printf("'%c'", val);
+        } else {
+            switch (val) {
+            case '\a': printf("'\\a'"); break;
+            case '\b': printf("'\\b'"); break;
+            case '\n': printf("'\\n'"); break;
+            case '\r': printf("'\\r'"); break;
+            case '\t': printf("'\\t'"); break;
+            case '\\': printf("'\\\\'"); break;
+            default: printf("'\\x%02lX'", val); break;
+            }
+        }
+        break;
+    }
+}
+static void print_sc_retval(sysarg_t retval, val_type_t val_type)
+{
+    printf(" -> ");
+    val_print(retval, val_type);
+    putchar('\n');
+}
+static void print_sc_args(sysarg_t *sc_args, int n)
+{
+    int i;
+    putchar('(');
+    if (n > 0) printf("%ld", sc_args[0]);
+    for (i = 1; i < n; i++) {
+        printf(", %ld", sc_args[i]);
+    }
+    putchar(')');
+}
+static void sc_ipc_call_async_fast(sysarg_t *sc_args, sysarg_t sc_rc)
+{
+    ipc_call_t call;
+    ipcarg_t phoneid;
+    if (sc_rc == IPC_CALLRET_FATAL || sc_rc == IPC_CALLRET_TEMPORARY)
+        return;
+    phoneid = sc_args[0];
+    IPC_SET_METHOD(call, sc_args[1]);
+    IPC_SET_ARG1(call, sc_args[2]);
+    IPC_SET_ARG2(call, sc_args[3]);
+    IPC_SET_ARG3(call, sc_args[4]);
+    IPC_SET_ARG4(call, sc_args[5]);
+    IPC_SET_ARG5(call, 0);
+    ipcp_call_out(phoneid, &call, sc_rc);
+}
+static void sc_ipc_call_async_slow(sysarg_t *sc_args, sysarg_t sc_rc)
+{
+    ipc_call_t call;
+    int rc;
+    if (sc_rc == IPC_CALLRET_FATAL || sc_rc == IPC_CALLRET_TEMPORARY)
+        return;
+    memset(&call, 0, sizeof(call));
+    rc = udebug_mem_read(phoneid, &call.args, sc_args[1], sizeof(call.args));
+    if (rc >= 0) {
+        ipcp_call_out(sc_args[0], &call, sc_rc);
+    }
+}
+static void sc_ipc_call_sync_fast(sysarg_t *sc_args)
+{
+    ipc_call_t question, reply;
+    int rc;
+    int phoneidx;
+//  printf("sc_ipc_call_sync_fast()\n");
+    phoneidx = sc_args[0];
+    IPC_SET_METHOD(question, sc_args[1]);
+    IPC_SET_ARG1(question, sc_args[2]);
+    IPC_SET_ARG2(question, sc_args[3]);
+    IPC_SET_ARG3(question, sc_args[4]);
+    IPC_SET_ARG4(question, 0);
+    IPC_SET_ARG5(question, 0);
+//  printf("memset\n");
+    memset(&reply, 0, sizeof(reply));
+//  printf("udebug_mem_read(phone=%d, buffer_ptr=%u, src_addr=%d, n=%d\n",
+//      phoneid, &reply.args, sc_args[5], sizeof(reply.args));
+    rc = udebug_mem_read(phoneid, &reply.args, sc_args[5], sizeof(reply.args));
+//  printf("dmr->%d\n", rc);
+    if (rc < 0) return;
+//  printf("call ipc_call_sync\n");
+    ipcp_call_sync(phoneidx, &question, &reply);
+}
+static void sc_ipc_call_sync_slow(sysarg_t *sc_args)
+{
+    ipc_call_t question, reply;
+    int rc;
+    memset(&question, 0, sizeof(question));
+    rc = udebug_mem_read(phoneid, &question.args, sc_args[1], sizeof(question.args));
+    printf("dmr->%d\n", rc);
+    if (rc < 0) return;
+    memset(&reply, 0, sizeof(reply));
+    rc = udebug_mem_read(phoneid, &reply.args, sc_args[2], sizeof(reply.args));
+    printf("dmr->%d\n", rc);
+    if (rc < 0) return;
+    ipcp_call_sync(sc_args[0], &question, &reply);
+}
+static void sc_ipc_wait(sysarg_t *sc_args, int sc_rc)
+{
+    ipc_call_t call;
+    int rc;
+    if (sc_rc == 0) return;
+    memset(&call, 0, sizeof(call));
+    rc = udebug_mem_read(phoneid, &call, sc_args[0], sizeof(call));
+//  printf("udebug_mem_read(phone %d, dest %d, app-mem src %d, size %d -> %d\n",
+//      phoneid, (int)&call, sc_args[0], sizeof(call), rc);
+    if (rc >= 0) {
+        ipcp_call_in(&call, sc_rc);
+    }
+}
+static void event_syscall_b(unsigned thread_id, uintptr_t thread_hash,
+    unsigned sc_id, sysarg_t sc_rc)
+{
+    sysarg_t sc_args[6];
+    int rc;
+    /* Read syscall arguments */
+    rc = udebug_args_read(phoneid, thread_hash, sc_args);
+    async_serialize_start();
+//  printf("[%d] ", thread_id);
+    if (rc < 0) {
+        printf("error\n");
+        async_serialize_end();
+        return;
+    }
+    if ((display_mask & DM_SYSCALL) != 0) {
+        /* Print syscall name and arguments */
+        printf("%s", syscall_desc[sc_id].name);
+        print_sc_args(sc_args, syscall_desc[sc_id].n_args);
+    }
+    async_serialize_end();
+}
+static void event_syscall_e(unsigned thread_id, uintptr_t thread_hash,
+    unsigned sc_id, sysarg_t sc_rc)
+{
+    sysarg_t sc_args[6];
+    int rv_type;
+    int rc;
+    /* Read syscall arguments */
+    rc = udebug_args_read(phoneid, thread_hash, sc_args);
+    async_serialize_start();
+//  printf("[%d] ", thread_id);
+    if (rc < 0) {
+        printf("error\n");
+        async_serialize_end();
+        return;
+    }
+    if ((display_mask & DM_SYSCALL) != 0) {
+        /* Print syscall return value */
+        rv_type = syscall_desc[sc_id].rv_type;
+        print_sc_retval(sc_rc, rv_type);
+    }
+    switch (sc_id) {
+    case SYS_IPC_CALL_ASYNC_FAST:
+        sc_ipc_call_async_fast(sc_args, sc_rc);
+        break;
+    case SYS_IPC_CALL_ASYNC_SLOW:
+        sc_ipc_call_async_slow(sc_args, sc_rc);
+        break;
+    case SYS_IPC_CALL_SYNC_FAST:
+        sc_ipc_call_sync_fast(sc_args);
+        break;
+    case SYS_IPC_CALL_SYNC_SLOW:
+        sc_ipc_call_sync_slow(sc_args);
+        break;
+    case SYS_IPC_WAIT:
+        sc_ipc_wait(sc_args, sc_rc);
+        break;
+    default:
+        break;
+    }
+    async_serialize_end();
+}
+static void event_thread_b(uintptr_t hash)
+{
+    async_serialize_start();
+    printf("New thread, hash 0x%lx\n", hash);
+    async_serialize_end();
+    thread_trace_start(hash);
+}
+static int trace_loop(void *thread_hash_arg)
+{
+    int rc;
+    unsigned ev_type;
+    uintptr_t thread_hash;
+    unsigned thread_id;
+    sysarg_t val0, val1;
+    thread_hash = (uintptr_t)thread_hash_arg;
+    thread_id = next_thread_id++;
+    printf("Start tracing thread [%d] (hash 0x%lx).\n", thread_id, thread_hash);
+    while (!abort_trace) {
+        if (paused) {
+            printf("Press R to resume (and be patient).\n");
+            while (paused) {
+                usleep(1000000);
+                fibril_yield();
+                printf(".");
+            }
+            printf("Resumed\n");
+        }
+        /* Run thread until an event occurs */
+        rc = udebug_go(phoneid, thread_hash,
+            &ev_type, &val0, &val1);
+//      printf("rc = %d, ev_type=%d\n", rc, ev_type);
+        if (ev_type == UDEBUG_EVENT_FINISHED) {
+            /* Done tracing this thread */
+            break;
+        }
+        if (rc >= 0) {
+            switch (ev_type) {
+            case UDEBUG_EVENT_SYSCALL_B:
+                event_syscall_b(thread_id, thread_hash, val0, (int)val1);
+                break;
+            case UDEBUG_EVENT_SYSCALL_E:
+                event_syscall_e(thread_id, thread_hash, val0, (int)val1);
+                break;
+            case UDEBUG_EVENT_STOP:
+                printf("Stop event\n");
+                break;
+            case UDEBUG_EVENT_THREAD_B:
+                event_thread_b(val0);
+                break;
+            case UDEBUG_EVENT_THREAD_E:
+                printf("Thread 0x%lx exited.\n", val0);
+                abort_trace = 1;
+                break;
+            default:
+                printf("Unknown event type %d.\n", ev_type);
+                break;
+            }
+        }
+    }
+    printf("Finished tracing thread [%d].\n", thread_id);
+    return 0;
+}
+void thread_trace_start(uintptr_t thread_hash)
+{
+    fid_t fid;
+    thash = thread_hash;
+    fid = fibril_create(trace_loop, (void *)thread_hash);
+    if (fid == 0) {
+        printf("Warning: Failed creating fibril\n");
+    }
+    fibril_add_ready(fid);
+}
+static loader_t *preload_task(const char *path, char *const argv[],
+    task_id_t *task_id)
+{
+    loader_t *ldr;
+    int rc;
+    /* Spawn a program loader */
+    ldr = loader_connect();
+    if (ldr == NULL)
+        return 0;
+    /* Get task ID. */
+    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);
+    if (rc != EOK)
+        goto error;
+    /* Load the program. */
+    rc = loader_load_program(ldr);
+    if (rc != EOK)
+        goto error;
+    /* Success */
+    return ldr;
+    /* Error exit */
+error:
+    loader_abort(ldr);
+    free(ldr);
+    return NULL;
+}
+static void trace_task(task_id_t task_id)
+{
+    int i;
+    int rc;
+    int c;
+    ipcp_init();
+    /*
+     * User apps now typically have console on phone 3.
+     * (Phones 1 and 2 are used by the loader).
+     */
+    ipcp_connection_set(3, 0, proto_console);
+    rc = get_thread_list();
+    if (rc < 0) {
+        printf("Failed to get thread list (error %d)\n", rc);
+        return;
+    }
+    abort_trace = 0;
+    for (i = 0; i < n_threads; i++) {
+        thread_trace_start(thread_hash_buf[i]);
+    }
+    while(1) {
+        c = getchar();
+        if (c == 'q') break;
+        if (c == 'p') {
+            printf("Pause...\n");
+            paused = 1;
+            rc = udebug_stop(phoneid, thash);
+            printf("stop -> %d\n", rc);
+        }
+        if (c == 'r') {
+            paused = 0;
+            printf("Resume...\n");
+        }
+    }
+    printf("\nTerminate debugging session...\n");
+    abort_trace = 1;
+    udebug_end(phoneid);
+    ipc_hangup(phoneid);
+    ipcp_cleanup();
+    printf("Done\n");
+    return;
+}
+static void main_init(void)
+{
+    proto_t *p;
+    oper_t *o;
+    val_type_t arg_def[OPER_MAX_ARGS] = {
+        V_INTEGER,
+        V_INTEGER,
+        V_INTEGER,
+        V_INTEGER,
+        V_INTEGER
+    };
+    val_type_t resp_def[OPER_MAX_ARGS] = {
+        V_INTEGER,
+        V_INTEGER,
+        V_INTEGER,
+        V_INTEGER,
+        V_INTEGER
+    };
+    next_thread_id = 1;
+    paused = 0;
+    proto_init();
+    p = proto_new("vfs");
+    o = oper_new("read", 1, arg_def, V_ERRNO, 1, resp_def);
+    proto_add_oper(p, VFS_READ, o);
+    o = oper_new("write", 1, arg_def, V_ERRNO, 1, resp_def);
+    proto_add_oper(p, VFS_WRITE, o);
+    o = oper_new("truncate", 5, arg_def, V_ERRNO, 0, resp_def);
+    proto_add_oper(p, VFS_TRUNCATE, o);
+    o = oper_new("mount", 2, arg_def, V_ERRNO, 0, resp_def);
+    proto_add_oper(p, VFS_MOUNT, o);
+/*  o = oper_new("unmount", 0, arg_def);
+    proto_add_oper(p, VFS_UNMOUNT, o);*/
+    o = oper_new("open", 2, arg_def, V_INT_ERRNO, 0, resp_def);
+    proto_add_oper(p, VFS_OPEN, o);
+    o = oper_new("close", 1, arg_def, V_ERRNO, 0, resp_def);
+    proto_add_oper(p, VFS_CLOSE, o);
+    o = oper_new("seek", 3, arg_def, V_ERRNO, 0, resp_def);
+    proto_add_oper(p, VFS_SEEK, o);
+    o = oper_new("mkdir", 1, arg_def, V_ERRNO, 0, resp_def);
+    proto_add_oper(p, VFS_MKDIR, o);
+    o = oper_new("unlink", 0, arg_def, V_ERRNO, 0, resp_def);
+    proto_add_oper(p, VFS_UNLINK, o);
+    o = oper_new("rename", 0, arg_def, V_ERRNO, 0, resp_def);
+    proto_add_oper(p, VFS_RENAME, o);
+    proto_register(SERVICE_VFS, p);
+    p = proto_new("console");
+    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);
+    arg_def[0] = V_INTEGER; arg_def[1] = V_INTEGER;
+    o = oper_new("goto", 2, arg_def, V_VOID, 0, resp_def);
+    proto_add_oper(p, CONSOLE_GOTO, o);
+    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);
+    arg_def[0] = V_INTEGER;
+    o = oper_new("set_style", 1, arg_def, V_VOID, 0, resp_def);
+    proto_add_oper(p, CONSOLE_SET_STYLE, o);
+    arg_def[0] = V_INTEGER; arg_def[1] = V_INTEGER; arg_def[2] = V_INTEGER;
+    o = oper_new("set_color", 3, arg_def, V_VOID, 0, resp_def);
+    proto_add_oper(p, CONSOLE_SET_COLOR, o);
+    arg_def[0] = V_INTEGER; arg_def[1] = V_INTEGER;
+    o = oper_new("set_rgb_color", 2, arg_def, V_VOID, 0, resp_def);
+    proto_add_oper(p, CONSOLE_SET_RGB_COLOR, o);
+    o = oper_new("cursor_visibility", 1, arg_def, V_VOID, 0, resp_def);
+    proto_add_oper(p, CONSOLE_CURSOR_VISIBILITY, o);
+    proto_console = p;
+    proto_register(SERVICE_CONSOLE, p);
+}
+static void print_syntax()
+{
+    printf("Syntax:\n");
+    printf("\ttrace [+<events>] <executable> [<arg1> [...]]\n");
+    printf("or\ttrace [+<events>] -t <task_id>\n");
+    printf("Events: (default is +tp)\n");
+    printf("\n");
+    printf("\tt ... Thread creation and termination\n");
+    printf("\ts ... System calls\n");
+    printf("\ti ... Low-level IPC\n");
+    printf("\tp ... Protocol level\n");
+    printf("\n");
+    printf("Examples:\n");
+    printf("\ttrace +s /app/tetris\n");
+    printf("\ttrace +tsip -t 12\n");
+}
+static display_mask_t parse_display_mask(char *text)
+{
+    display_mask_t dm;
+    char *c;
+    c = text;
+    while (*c) {
+        switch (*c) {
+        case 't': dm = dm | DM_THREAD; break;
+        case 's': dm = dm | DM_SYSCALL; break;
+        case 'i': dm = dm | DM_IPC; break;
+        case 'p': dm = dm | DM_SYSTEM | DM_USER; break;
+        default:
+            printf("Unexpected event type '%c'.\n", *c);
+            exit(1);
+        }
+        ++c;
+    }
+    return dm;
+}
+static int parse_args(int argc, char *argv[])
+{
+    char *arg;
+    char *err_p;
+    task_id = 0;
+    --argc; ++argv;
+    while (argc > 0) {
+        arg = *argv;
+        if (arg[0] == '+') {
+            display_mask = parse_display_mask(&arg[1]);
+        } else if (arg[0] == '-') {
+            if (arg[1] == 't') {
+                /* Trace an already running task */
+                --argc; ++argv;
+                task_id = strtol(*argv, &err_p, 10);
+                task_ldr = NULL;
+                if (*err_p) {
+                    printf("Task ID syntax error\n");
+                    print_syntax();
+                    return -1;
+                }
+            } else {
+                printf("Uknown option '%s'\n", arg[0]);
+                print_syntax();
+                return -1;
+            }
+        } else {
+            break;
+        }
+        --argc; ++argv;
+    }
+    if (task_id != 0) {
+        if (argc == 0) return 0;
+        printf("Extra arguments\n");
+        print_syntax();
+        return -1;
+    }
+    if (argc < 1) {
+        printf("Missing argument\n");
+        print_syntax();
+        return -1;
+    }
+    /* Preload the specified program file. */
+    printf("Spawning '%s' with arguments:\n", *argv);
+    {
+        char **cp = argv;
+        while (*cp) printf("'%s'\n", *cp++);
+    }
+    task_ldr = preload_task(*argv, argv, &task_id);
+    return 0;
+}
+int main(int argc, char *argv[])
+{
+    int rc;
+    printf("System Call / IPC Tracer\n");
+    printf("Controls: Q - Quit, P - Pause, R - Resume\n");
+    display_mask = DM_THREAD | DM_SYSTEM | DM_USER;
+    if (parse_args(argc, argv) < 0)
+        return 1;
+    main_init();
+    rc = connect_task(task_id);
+    if (rc < 0) {
+        printf("Failed connecting to task %lld.\n", task_id);
+        return 1;
+    }
+    printf("Connected to task %lld.\n", task_id);
+    if (task_ldr != NULL) {
+        program_run();
+    }
+    trace_task(task_id);
+    return 0;
+}
+/** @}
+ */

 /branches/dd/uspace/app/trace/Makefile
 ,0 → 1,79
+#
+# 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
+SOFTINT_PREFIX = ../../lib/softint
+include $(LIBC_PREFIX)/Makefile.toolchain
+CFLAGS += -I../../srv/kbd/include
+LIBS = $(LIBC_PREFIX)/libc.a
+## Sources
+#
+OUTPUT = trace
+SOURCES = trace.c \
+    syscalls.c \
+    ipcp.c \
+    ipc_desc.c \
+    proto.c \
+    errors.c
+OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
+.PHONY: all clean depend disasm
+all: $(OUTPUT) disasm
+-include Makefile.depend
+clean:
+    -rm -f $(OUTPUT) $(OBJECTS) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+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:
+    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
+%.o: %.S
+    $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@
+%.o: %.s
+    $(AS) $(AFLAGS) $< -o $@
+%.o: %.c
+    $(CC) $(DEFS) $(CFLAGS) -c $< -o $@

 /branches/dd/uspace/app/trace/syscalls.c
 ,0 → 1,81
+/*
+ * 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 trace
+ * @{
+ */
+/** @file
+ */
+#include <kernel/syscall/syscall.h>
+#include "syscalls.h"
+#include "trace.h"
+const sc_desc_t syscall_desc[] = {
+    [SYS_KLOG] ={ "klog",               3,  V_INT_ERRNO },
+    [SYS_TLS_SET] = { "tls_set",            1,  V_ERRNO },
+    [SYS_THREAD_CREATE] = { "thread_create",        3,  V_ERRNO },
+    [SYS_THREAD_EXIT] = { "thread_exit",        1,  V_ERRNO },
+    [SYS_THREAD_GET_ID] = { "thread_get_id",        1,  V_ERRNO },
+    [SYS_TASK_GET_ID] = { "task_get_id",        1,  V_ERRNO },
+    [SYS_FUTEX_SLEEP] = { "futex_sleep_timeout",    3,  V_ERRNO },
+    [SYS_FUTEX_WAKEUP] = { "futex_wakeup",      1,  V_ERRNO },
+    [SYS_AS_AREA_CREATE] = { "as_area_create",      3,  V_ERRNO },
+    [SYS_AS_AREA_RESIZE] = { "as_area_resize",      3,  V_ERRNO },
+    [SYS_AS_AREA_DESTROY] = { "as_area_destroy",    1,  V_ERRNO },
+    [SYS_IPC_CALL_SYNC_FAST] = { "ipc_call_sync_fast",  6,  V_ERRNO },
+    [SYS_IPC_CALL_SYNC_SLOW] = { "ipc_call_sync_slow",  3,  V_ERRNO },
+    [SYS_IPC_CALL_ASYNC_FAST] = { "ipc_call_async_fast", 6, V_HASH },
+    [SYS_IPC_CALL_ASYNC_SLOW] = { "ipc_call_async_slow", 2, V_HASH },
+    [SYS_IPC_ANSWER_FAST] = { "ipc_answer_fast",    6,  V_ERRNO },
+    [SYS_IPC_ANSWER_SLOW] = { "ipc_answer_slow",    2,  V_ERRNO },
+    [SYS_IPC_FORWARD_FAST] = { "ipc_forward_fast",  6,  V_ERRNO },
+    [SYS_IPC_FORWARD_SLOW] = { "ipc_forward_slow",  3,  V_ERRNO },
+    [SYS_IPC_WAIT] = { "ipc_wait_for_call",     3,  V_HASH },
+    [SYS_IPC_HANGUP] = { "ipc_hangup",          1,  V_ERRNO },
+    [SYS_IPC_REGISTER_IRQ] = { "ipc_register_irq",  4,  V_ERRNO },
+    [SYS_IPC_UNREGISTER_IRQ] = { "ipc_unregister_irq",  2,  V_ERRNO },
+    [SYS_CAP_GRANT] = { "cap_grant",            2,  V_ERRNO },
+    [SYS_CAP_REVOKE] = { "cap_revoke",          2,  V_ERRNO },
+    [SYS_PHYSMEM_MAP] = { "physmem_map",        4,  V_ERRNO },
+    [SYS_IOSPACE_ENABLE] = { "iospace_enable",      1,  V_ERRNO },
+    [SYS_PREEMPT_CONTROL] = { "preempt_control",    1,  V_ERRNO },
+    [SYS_SYSINFO_VALID] = { "sysinfo_valid",        2,  V_HASH },
+    [SYS_SYSINFO_VALUE] = { "sysinfo_value",        2,  V_HASH },
+    [SYS_DEBUG_ENABLE_CONSOLE] = { "debug_enable_console", 0,   V_ERRNO },
+    [SYS_IPC_CONNECT_KBOX] = { "ipc_connect_kbox",  1,  V_ERRNO }
+};
+/** @}
+ */

 /branches/dd/uspace/app/trace/ipcp.c
 ,0 → 1,375
+/*
+ * 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 trace
+ * @{
+ */
+/** @file
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <libadt/hash_table.h>
+#include "ipc_desc.h"
+#include "proto.h"
+#include "trace.h"
+#include "ipcp.h"
+#define IPCP_CALLID_SYNC 0
+typedef struct {
+    ipcarg_t phone_hash;
+    ipc_call_t question;
+    oper_t *oper;
+    ipc_callid_t call_hash;
+    link_t link;
+} pending_call_t;
+typedef struct {
+    int server;
+    proto_t *proto;
+} connection_t;
+#define MAX_PHONE 64
+connection_t connections[MAX_PHONE];
+int have_conn[MAX_PHONE];
+#define PCALL_TABLE_CHAINS 32
+hash_table_t pending_calls;
+/*
+ * Pseudo-protocols
+ */
+proto_t *proto_system;      /**< Protocol describing system IPC methods. */
+proto_t *proto_unknown;     /**< Protocol with no known methods. */
+static hash_index_t pending_call_hash(unsigned long key[]);
+static int pending_call_compare(unsigned long key[], hash_count_t keys,
+    link_t *item);
+static void pending_call_remove_callback(link_t *item);
+hash_table_operations_t pending_call_ops = {
+    .hash = pending_call_hash,
+    .compare = pending_call_compare,
+    .remove_callback = pending_call_remove_callback
+};
+static hash_index_t pending_call_hash(unsigned long key[])
+{
+//  printf("pending_call_hash\n");
+    return key[0] % PCALL_TABLE_CHAINS;
+}
+static int pending_call_compare(unsigned long key[], hash_count_t keys,
+    link_t *item)
+{
+    pending_call_t *hs;
+//  printf("pending_call_compare\n");
+    hs = hash_table_get_instance(item, pending_call_t, link);
+    // FIXME: this will fail if sizeof(long) < sizeof(void *).
+    return key[0] == hs->call_hash;
+}
+static void pending_call_remove_callback(link_t *item)
+{
+//  printf("pending_call_remove_callback\n");
+}
+void ipcp_connection_set(int phone, int server, proto_t *proto)
+{
+    if (phone <0 || phone >= MAX_PHONE) return;
+    connections[phone].server = server;
+    connections[phone].proto = proto;
+    have_conn[phone] = 1;
+}
+void ipcp_connection_clear(int phone)
+{
+    have_conn[phone] = 0;
+    connections[phone].server = 0;
+    connections[phone].proto = NULL;
+}
+static void ipc_m_print(proto_t *proto, ipcarg_t method)
+{
+    oper_t *oper;
+    /* Try system methods first */
+    oper = proto_get_oper(proto_system, method);
+    if (oper == NULL && proto != NULL) {
+        /* Not a system method, try the user protocol. */
+        oper = proto_get_oper(proto, method);
+    }
+    if (oper != NULL) {
+        printf("%s (%ld)", oper->name, method);
+        return;
+    }
+    printf("%ld", method);
+}
+void ipcp_init(void)
+{
+    ipc_m_desc_t *desc;
+    oper_t *oper;
+    val_type_t arg_def[OPER_MAX_ARGS] = {
+        V_INTEGER,
+        V_INTEGER,
+        V_INTEGER,
+        V_INTEGER,
+        V_INTEGER
+    };
+    /*
+     * Create a pseudo-protocol 'unknown' that has no known methods.
+     */
+    proto_unknown = proto_new("unknown");
+    /*
+     * Create a pseudo-protocol 'system' defining names of system IPC
+     * methods.
+     */
+    proto_system = proto_new("system");
+    desc = ipc_methods;
+    while (desc->number != 0) {
+        oper = oper_new(desc->name, OPER_MAX_ARGS, arg_def, V_INTEGER,
+            OPER_MAX_ARGS, arg_def);
+        proto_add_oper(proto_system, desc->number, oper);
+        ++desc;
+    }
+    hash_table_create(&pending_calls, PCALL_TABLE_CHAINS, 1, &pending_call_ops);
+}
+void ipcp_cleanup(void)
+{
+    proto_delete(proto_system);
+    hash_table_destroy(&pending_calls);
+}
+void ipcp_call_out(int phone, ipc_call_t *call, ipc_callid_t hash)
+{
+    pending_call_t *pcall;
+    proto_t *proto;
+    unsigned long key[1];
+    oper_t *oper;
+    ipcarg_t *args;
+    int i;
+    if (have_conn[phone]) proto = connections[phone].proto;
+    else proto = NULL;
+    args = call->args;
+    if ((display_mask & DM_IPC) != 0) {
+        printf("Call ID: 0x%lx, phone: %d, proto: %s, method: ", hash,
+            phone, (proto ? proto->name : "n/a"));
+        ipc_m_print(proto, IPC_GET_METHOD(*call));
+        printf(" args: (%lu, %lu, %lu, %lu, %lu)\n", args[1], args[2],
+            args[3], args[4], args[5]);
+    }
+    if ((display_mask & DM_USER) != 0) {
+        if (proto != NULL) {
+            oper = proto_get_oper(proto, IPC_GET_METHOD(*call));
+        } else {
+            oper = NULL;
+        }
+        if (oper != NULL) {
+            printf("%s(%d).%s", (proto ? proto->name : "n/a"),
+                phone, (oper ? oper->name : "unknown"));
+            putchar('(');
+            for (i = 1; i <= oper->argc; ++i) {
+                if (i > 1) printf(", ");
+                val_print(args[i], oper->arg_type[i - 1]);
+            }
+            putchar(')');
+            if (oper->rv_type == V_VOID && oper->respc == 0) {
+                /*
+                 * No response data (typically the task will
+                 * not be interested in the response).
+                 * We will not display response.
+                 */
+                putchar('.');
+            }
+            putchar('\n');
+        }
+    } else {
+        oper = NULL;
+    }
+    /* Store call in hash table for response matching */
+    pcall = malloc(sizeof(pending_call_t));
+    pcall->phone_hash = phone;
+    pcall->question = *call;
+    pcall->call_hash = hash;
+    pcall->oper = oper;
+    key[0] = hash;
+    hash_table_insert(&pending_calls, key, &pcall->link);
+}
+static void parse_answer(ipc_callid_t hash, pending_call_t *pcall,
+    ipc_call_t *answer)
+{
+    ipcarg_t phone;
+    ipcarg_t method;
+    ipcarg_t service;
+    ipcarg_t retval;
+    proto_t *proto;
+    int cphone;
+    ipcarg_t *resp;
+    oper_t *oper;
+    int i;
+//  printf("parse_answer\n");
+    phone = pcall->phone_hash;
+    method = IPC_GET_METHOD(pcall->question);
+    retval = IPC_GET_RETVAL(*answer);
+    resp = answer->args;
+    if ((display_mask & DM_IPC) != 0) {
+        printf("Response to 0x%lx: retval=%ld, args = (%lu, %lu, %lu, %lu, %lu)\n",
+            hash, retval, IPC_GET_ARG1(*answer),
+            IPC_GET_ARG2(*answer), IPC_GET_ARG3(*answer),
+            IPC_GET_ARG4(*answer), IPC_GET_ARG5(*answer));
+    }
+    if ((display_mask & DM_USER) != 0) {
+        oper = pcall->oper;
+        if (oper != NULL && (oper->rv_type != V_VOID || oper->respc > 0)) {
+            printf("->");
+            if (oper->rv_type != V_VOID) {
+                putchar(' ');
+                val_print(retval, oper->rv_type);
+            }
+            if (oper->respc > 0) {
+                putchar(' ');
+                putchar('(');
+                for (i = 1; i <= oper->respc; ++i) {
+                    if (i > 1) printf(", ");
+                    val_print(resp[i], oper->resp_type[i - 1]);
+                }
+                putchar(')');
+            }
+            putchar('\n');
+        }
+    }
+    if (phone == 0 && method == IPC_M_CONNECT_ME_TO && retval == 0) {
+        /* Connected to a service (through NS) */
+        service = IPC_GET_ARG1(pcall->question);
+        proto = proto_get_by_srv(service);
+        if (proto == NULL) proto = proto_unknown;
+        cphone = IPC_GET_ARG5(*answer);
+        if ((display_mask & DM_SYSTEM) != 0) {
+            printf("Registering connection (phone %d, protocol: %s)\n", cphone,
+                    proto->name);
+        }
+        ipcp_connection_set(cphone, 0, proto);
+    }
+}
+void ipcp_call_in(ipc_call_t *call, ipc_callid_t hash)
+{
+    link_t *item;
+    pending_call_t *pcall;
+    unsigned long key[1];
+//  printf("ipcp_call_in()\n");
+    if ((hash & IPC_CALLID_ANSWERED) == 0 && hash != IPCP_CALLID_SYNC) {
+        /* Not a response */
+        if ((display_mask & DM_IPC) != 0) {
+            printf("Not a response (hash 0x%lx)\n", hash);
+        }
+        return;
+    }
+    hash = hash & ~IPC_CALLID_ANSWERED;
+    key[0] = hash;
+    item = hash_table_find(&pending_calls, key);
+    if (item == NULL) return; // No matching question found
+    /*
+     * Response matched to question.
+     */
+    pcall = hash_table_get_instance(item, pending_call_t, link);
+    hash_table_remove(&pending_calls, key, 1);
+    parse_answer(hash, pcall, call);
+    free(pcall);
+}
+void ipcp_call_sync(int phone, ipc_call_t *call, ipc_call_t *answer)
+{
+    ipcp_call_out(phone, call, IPCP_CALLID_SYNC);
+    ipcp_call_in(answer, IPCP_CALLID_SYNC);
+}
+void ipcp_hangup(int phone, int rc)
+{
+    if ((display_mask & DM_SYSTEM) != 0) {
+        printf("Hang phone %d up -> %d\n", phone, rc);
+        ipcp_connection_clear(phone);
+    }
+}
+/** @}
+ */

 /branches/dd/uspace/app/trace/trace.h
 ,0 → 1,71
+/*
+ * 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 trace
+ * @{
+ */
+/** @file
+ */
+#ifndef TRACE_H_
+#define TRACE_H_
+#include <sys/types.h>
+/**
+ * Classes of events that can be displayed. Can be or-ed together.
+ */
+typedef enum {
+    DM_THREAD   = 1,    /**< Thread creation and termination events */
+    DM_SYSCALL  = 2,    /**< System calls */
+    DM_IPC      = 4,    /**< Low-level IPC */
+    DM_SYSTEM   = 8,    /**< Sysipc protocol */
+    DM_USER     = 16    /**< User IPC protocols */
+} display_mask_t;
+typedef enum {
+    V_VOID,
+    V_INTEGER,
+    V_PTR,
+    V_HASH,
+    V_ERRNO,
+    V_INT_ERRNO,
+    V_CHAR
+} val_type_t;
+/** Combination of events to print. */
+extern display_mask_t display_mask;
+void val_print(sysarg_t val, val_type_t v_type);
+#endif
+/** @}
+ */

 /branches/dd/uspace/app/trace/syscalls.h
 ,0 → 1,51
+/*
+ * 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 trace
+ * @{
+ */
+/** @file
+ */
+#ifndef SYSCALLS_H_
+#define SYSCALLS_H_
+#include "trace.h"
+typedef struct {
+    char *name;
+    int n_args;
+    val_type_t rv_type;
+} sc_desc_t;
+extern const sc_desc_t syscall_desc[];
+#endif
+/** @}
+ */

 /branches/dd/uspace/app/trace/proto.c
 ,0 → 1,236
+/*
+ * 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 trace
+ * @{
+ */
+/** @file
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <ipc/ipc.h>
+#include <libadt/hash_table.h>
+#include "trace.h"
+#include "proto.h"
+#define SRV_PROTO_TABLE_CHAINS 32
+#define METHOD_OPER_TABLE_CHAINS 32
+hash_table_t srv_proto;
+typedef struct {
+    int srv;
+    proto_t *proto;
+    link_t link;
+} srv_proto_t;
+typedef struct {
+    ipcarg_t method;
+    oper_t *oper;
+    link_t link;
+} method_oper_t;
+static hash_index_t srv_proto_hash(unsigned long key[]);
+static int srv_proto_compare(unsigned long key[], hash_count_t keys,
+    link_t *item);
+static void srv_proto_remove_callback(link_t *item);
+hash_table_operations_t srv_proto_ops = {
+    .hash = srv_proto_hash,
+    .compare = srv_proto_compare,
+    .remove_callback = srv_proto_remove_callback
+};
+static hash_index_t method_oper_hash(unsigned long key[]);
+static int method_oper_compare(unsigned long key[], hash_count_t keys,
+    link_t *item);
+static void method_oper_remove_callback(link_t *item);
+hash_table_operations_t method_oper_ops = {
+    .hash = method_oper_hash,
+    .compare = method_oper_compare,
+    .remove_callback = method_oper_remove_callback
+};
+static hash_index_t srv_proto_hash(unsigned long key[])
+{
+    return key[0] % SRV_PROTO_TABLE_CHAINS;
+}
+static int srv_proto_compare(unsigned long key[], hash_count_t keys,
+    link_t *item)
+{
+    srv_proto_t *sp;
+    sp = hash_table_get_instance(item, srv_proto_t, link);
+    return key[0] == sp->srv;
+}
+static void srv_proto_remove_callback(link_t *item)
+{
+}
+static hash_index_t method_oper_hash(unsigned long key[])
+{
+    return key[0] % METHOD_OPER_TABLE_CHAINS;
+}
+static int method_oper_compare(unsigned long key[], hash_count_t keys,
+    link_t *item)
+{
+    method_oper_t *mo;
+    mo = hash_table_get_instance(item, method_oper_t, link);
+    return key[0] == mo->method;
+}
+static void method_oper_remove_callback(link_t *item)
+{
+}
+void proto_init(void)
+{
+    hash_table_create(&srv_proto, SRV_PROTO_TABLE_CHAINS, 1,
+        &srv_proto_ops);
+}
+void proto_cleanup(void)
+{
+    hash_table_destroy(&srv_proto);
+}
+void proto_register(int srv, proto_t *proto)
+{
+    srv_proto_t *sp;
+    unsigned long key;
+    sp = malloc(sizeof(srv_proto_t));
+    sp->srv = srv;
+    sp->proto = proto;
+    key = srv;
+    hash_table_insert(&srv_proto, &key, &sp->link);
+}
+proto_t *proto_get_by_srv(int srv)
+{
+    unsigned long key;
+    link_t *item;
+    srv_proto_t *sp;
+    key = srv;
+    item = hash_table_find(&srv_proto, &key);
+    if (item == NULL) return NULL;
+    sp = hash_table_get_instance(item, srv_proto_t, link);
+    return sp->proto;
+}
+static void proto_struct_init(proto_t *proto, char *name)
+{
+    proto->name = name;
+    hash_table_create(&proto->method_oper, SRV_PROTO_TABLE_CHAINS, 1,
+        &method_oper_ops);
+}
+proto_t *proto_new(char *name)
+{
+    proto_t *p;
+    p = malloc(sizeof(proto_t));
+    proto_struct_init(p, name);
+    return p;
+}
+void proto_delete(proto_t *proto)
+{
+    free(proto);
+}
+void proto_add_oper(proto_t *proto, int method, oper_t *oper)
+{
+    method_oper_t *mo;
+    unsigned long key;
+    mo = malloc(sizeof(method_oper_t));
+    mo->method = method;
+    mo->oper = oper;
+    key = method;
+    hash_table_insert(&proto->method_oper, &key, &mo->link);
+}
+oper_t *proto_get_oper(proto_t *proto, int method)
+{
+    unsigned long key;
+    link_t *item;
+    method_oper_t *mo;
+    key = method;
+    item = hash_table_find(&proto->method_oper, &key);
+    if (item == NULL) return NULL;
+    mo = hash_table_get_instance(item, method_oper_t, link);
+    return mo->oper;
+}
+static void oper_struct_init(oper_t *oper, char *name)
+{
+    oper->name = name;
+}
+oper_t *oper_new(char *name, int argc, val_type_t *arg_types,
+    val_type_t rv_type, int respc, val_type_t *resp_types)
+{
+    oper_t *o;
+    int i;
+    o = malloc(sizeof(oper_t));
+    oper_struct_init(o, name);
+    o->argc = argc;
+    for (i = 0; i < argc; i++)
+        o->arg_type[i] = arg_types[i];
+    o->rv_type = rv_type;
+    o->respc = respc;
+    for (i = 0; i < respc; i++)
+        o->resp_type[i] = resp_types[i];
+    return o;
+}
+/** @}
+ */

 /branches/dd/uspace/app/trace/proto.h
 ,0 → 1,85
+/*
+ * 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 trace
+ * @{
+ */
+/** @file
+ */
+#ifndef PROTO_H_
+#define PROTO_H_
+#include <libadt/hash_table.h>
+#include <ipc/ipc.h>
+#include "trace.h"
+#define OPER_MAX_ARGS (IPC_CALL_LEN - 1)
+typedef struct {
+    char *name;
+    int argc;
+    val_type_t arg_type[OPER_MAX_ARGS];
+    val_type_t rv_type;
+    int respc;
+    val_type_t resp_type[OPER_MAX_ARGS];
+} oper_t;
+typedef struct {
+    /** Protocol name */
+    char *name;
+    /** Maps method number to operation */
+    hash_table_t method_oper;
+} proto_t;
+/* Maps service number to protocol */
+extern hash_table_t srv_proto;
+void proto_init(void);
+void proto_cleanup(void);
+void proto_register(int srv, proto_t *proto);
+proto_t *proto_get_by_srv(int srv);
+proto_t *proto_new(char *name);
+void proto_delete(proto_t *proto);
+void proto_add_oper(proto_t *proto, int method, oper_t *oper);
+oper_t *proto_get_oper(proto_t *proto, int method);
+oper_t *oper_new(char *name, int argc, val_type_t *arg_types,
+    val_type_t rv_type, int respc, val_type_t *resp_types);
+#endif
+/** @}
+ */

 /branches/dd/uspace/app/trace/ipc_desc.h
 ,0 → 1,48
+/*
+ * 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 trace
+ * @{
+ */
+/** @file
+ */
+#ifndef IPC_DESC_H_
+#define IPC_DESC_H_
+typedef struct {
+    int number;
+    char *name;
+} ipc_m_desc_t;
+extern ipc_m_desc_t ipc_methods[];
+#endif
+/** @}
+ */

 /branches/dd/uspace/app/trace/ipcp.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 trace
+ * @{
+ */
+/** @file
+ */
+#ifndef IPCP_H_
+#define IPCP_H_
+#include <ipc/ipc.h>
+#include "proto.h"
+void ipcp_init(void);
+void ipcp_cleanup(void);
+void ipcp_call_out(int phone, ipc_call_t *call, ipc_callid_t hash);
+void ipcp_call_sync(int phone, ipc_call_t *call, ipc_call_t *answer);
+void ipcp_call_in(ipc_call_t *call, ipc_callid_t hash);
+void ipcp_hangup(int phone, int rc);
+void ipcp_connection_set(int phone, int server, proto_t *proto);
+void ipcp_connection_clear(int phone);
+#endif
+/** @}
+ */

 /branches/dd/uspace/app/trace/errors.h
 ,0 → 1,48
+/*
+ * 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 trace
+ * @{
+ */
+/** @file
+ */
+#ifndef ERRORS_H_
+#define ERRORS_H_
+typedef struct {
+    char *name; /**< Error value name (Exx) */
+    char *desc; /**< Error description */
+} err_desc_t;
+extern const err_desc_t err_desc[];
+#endif
+/** @}
+ */

 /branches/dd/uspace/app/trace/ipc_desc.c
 ,0 → 1,58
+/*
+ * 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 trace
+ * @{
+ */
+/** @file
+ */
+#include <stdlib.h>
+#include <ipc/ipc.h>
+#include "ipc_desc.h"
+ipc_m_desc_t ipc_methods[] = {
+    /* System methods */
+    { IPC_M_CONNECT_TO_ME,  "CONNECT_TO_ME" },
+    { IPC_M_CONNECT_ME_TO,  "CONNECT_ME_TO" },
+    { IPC_M_PHONE_HUNGUP,   "PHONE_HUNGUP" },
+    { IPC_M_SHARE_OUT,  "SHARE_OUT" },
+    { IPC_M_SHARE_IN,   "SHARE_IN" },
+    { IPC_M_DATA_WRITE, "DATA_WRITE" },
+    { IPC_M_DATA_READ,  "DATA_READ" },
+    { IPC_M_DEBUG_ALL,  "DEBUG_ALL" },
+    /* Well-known methods */
+    { IPC_M_PING,       "PING" },
+    /* Terminating entry */
+    { 0, NULL }
+};
+/** @}
+ */

 /branches/dd/uspace/app/trace/errors.c
 ,0 → 1,61
+/*
+ * 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 trace
+ * @{
+ */
+/** @file
+ */
+#include <errno.h>
+#include "errors.h"
+const err_desc_t err_desc[] = {
+    [-EOK]      = { "EOK",      "No error" },
+    [-ENOENT]   = { "ENOENT",       "No such entry" },
+    [-ENOMEM]   = { "ENOMEM",       "Not enough memory" },
+    [-ELIMIT]   = { "ELIMIT",       "Limit exceeded" },
+    [-EREFUSED] = { "EREFUSED",     "Connection refused" },
+    [-EFORWARD] = { "EFORWARD",     "Forward error" },
+    [-EPERM]    = { "EPERM",        "Permission denied" },
+    [-EHANGUP]  = { "EHANGUP",      "Answerbox closed connection" },
+    [-EEXISTS]  = { "EEXISTS",      "Entry already exists" },
+    [-EBADMEM]  = { "EBADMEM",      "Bad memory pointer" },
+    [-ENOTSUP]  = { "ENOTSUP",      "Not supported" },
+    [-EADDRNOTAVAIL] = { "EADDRNOTAVAIL",   "Address not available." },
+    [-ETIMEOUT] = { "ETIMEOUT",     "Timeout expired" },
+    [-EINVAL]   = { "EINVAL",       "Invalid value" },
+    [-EBUSY]    = { "EBUSY",        "Resource is busy" },
+    [-EOVERFLOW]    = { "EOVERFLOW",    "The result does not fit its size." }
+};
+/** @}
+ */

 /branches/dd/uspace/lib/libfs/libfs.c
 ,7 → 160,7
         len = 0;
         while ((next <= last) &&  (ops->plb_get_char(next) != '/')) {
             if (len + 1 == NAME_MAX) {
-                /* comopnent length overflow */
+                /* component length overflow */
                 ipc_answer_0(rid, ENAMETOOLONG);
                 goto out;
             }
 ,17 → 191,20
                 }
                 void *nodep;
                 if (lflag & L_CREATE)
-                    nodep = ops->create(lflag);
+                    nodep = ops->create(dev_handle, lflag);
                 else
                     nodep = ops->node_get(dev_handle,
                         index);
                 if (nodep) {
-                    if (!ops->link(cur, nodep, component)) {
+                    int rc;
+                    rc = ops->link(cur, nodep, component);
+                    if (rc != EOK) {
                         if (lflag & L_CREATE) {
                             (void)ops->destroy(
                                 nodep);
                         }
-                        ipc_answer_0(rid, ENOSPC);
+                        ipc_answer_0(rid, rc);
                     } else {
                         ipc_answer_5(rid, EOK,
                             fs_handle, dev_handle,
 ,14 → 265,17
             void *nodep;
             if (lflag & L_CREATE)
-                nodep = ops->create(lflag);
+                nodep = ops->create(dev_handle, lflag);
             else
                 nodep = ops->node_get(dev_handle, index);
             if (nodep) {
-                if (!ops->link(cur, nodep, component)) {
+                int rc;
+                rc = ops->link(cur, nodep, component);
+                if (rc != EOK) {
                     if (lflag & L_CREATE)
                         (void)ops->destroy(nodep);
-                    ipc_answer_0(rid, ENOSPC);
+                    ipc_answer_0(rid, rc);
                 } else {
                     ipc_answer_5(rid, EOK,
                         fs_handle, dev_handle,

 /branches/dd/uspace/lib/libfs/libfs.h
 ,9 → 45,9
     void * (* match)(void *, const char *);
     void * (* node_get)(dev_handle_t, fs_index_t);
     void (* node_put)(void *);
-    void * (* create)(int);
+    void * (* create)(dev_handle_t, int);
     int (* destroy)(void *);
-    bool (* link)(void *, void *, const char *);
+    int (* link)(void *, void *, const char *);
     int (* unlink)(void *, void *);
     fs_index_t (* index_get)(void *);
     size_t (* size_get)(void *);

 /branches/dd/uspace/lib/libfs/Makefile
 ,6 → 31,7
 #
 LIBC_PREFIX = ../libc
 ## Setup toolchain
 #
 ,7 → 58,7
     find . -name '*.o' -follow -exec rm \{\} \;
 depend:
-    -makedepend $(DEFS) $(CFLAGS) -f - $(SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend -f - -- $(DEPEND_DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null
 libfs.a: depend $(OBJECTS)
     $(AR) rc libfs.a $(OBJECTS)

 /branches/dd/uspace/lib/softfloat/Makefile
 ,25 → 30,26
 #
 LIBC_PREFIX = ../libc
 ## Setup toolchain
 #
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS +=-Iinclude -Iarch/$(ARCH)/include/
+CFLAGS +=-Iinclude -Iarch/$(UARCH)/include/
 ## Sources
 #
-GENERIC_SOURCES =       \
-    generic/add.c       \
-    generic/common.c    \
-    generic/comparison.c    \
-    generic/conversion.c    \
-    generic/div.c       \
-    generic/mul.c       \
-    generic/other.c     \
-    generic/softfloat.c \
+GENERIC_SOURCES = \
+    generic/add.c \
+    generic/common.c \
+    generic/comparison.c \
+    generic/conversion.c \
+    generic/div.c \
+    generic/mul.c \
+    generic/other.c \
+    generic/softfloat.c \
     generic/sub.c
 ARCH_SOURCES =
 ,7 → 67,7
     find generic/ -name '*.o' -follow -exec rm \{\} \;
 depend:
-    -makedepend $(DEFS) $(CFLAGS) -f - $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend -f - -- $(DEPEND_DEFS) $(CFLAGS) -- $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
 libsoftfloat.a: depend $(ARCH_OBJECTS) $(GENERIC_OBJECTS)
     $(AR) rc libsoftfloat.a $(ARCH_OBJECTS) $(GENERIC_OBJECTS)

 /branches/dd/uspace/lib/libblock/libblock.c
 ,0 → 1,494
+/*
+ * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2008 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 libblock
+ * @{
+ */
+/**
+ * @file
+ * @brief
+ */
+#include "libblock.h"
+#include "../../srv/vfs/vfs.h"
+#include "../../srv/rd/rd.h"
+#include <ipc/devmap.h>
+#include <ipc/services.h>
+#include <errno.h>
+#include <sys/mman.h>
+#include <async.h>
+#include <ipc/ipc.h>
+#include <as.h>
+#include <assert.h>
+#include <futex.h>
+#include <libadt/list.h>
+#include <libadt/hash_table.h>
+/** Lock protecting the device connection list */
+static futex_t dcl_lock = FUTEX_INITIALIZER;
+/** Device connection list head. */
+static LIST_INITIALIZE(dcl_head);
+#define CACHE_BUCKETS_LOG2      10
+#define CACHE_BUCKETS           (1 << CACHE_BUCKETS_LOG2)
+typedef struct {
+    futex_t lock;
+    size_t block_size;      /**< Block size. */
+    unsigned block_count;       /**< Total number of blocks. */
+    hash_table_t block_hash;
+    link_t free_head;
+} cache_t;
+typedef struct {
+    link_t link;
+    int dev_handle;
+    int dev_phone;
+    void *com_area;
+    size_t com_size;
+    void *bb_buf;
+    off_t bb_off;
+    size_t bb_size;
+    cache_t *cache;
+} devcon_t;
+static devcon_t *devcon_search(dev_handle_t dev_handle)
+{
+    link_t *cur;
+    futex_down(&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);
+            return devcon;
+        }
+    }
+    futex_up(&dcl_lock);
+    return NULL;
+}
+static int devcon_add(dev_handle_t dev_handle, int dev_phone, void *com_area,
+   size_t com_size)
+{
+    link_t *cur;
+    devcon_t *devcon;
+    devcon = malloc(sizeof(devcon_t));
+    if (!devcon)
+        return ENOMEM;
+    link_initialize(&devcon->link);
+    devcon->dev_handle = dev_handle;
+    devcon->dev_phone = dev_phone;
+    devcon->com_area = com_area;
+    devcon->com_size = com_size;
+    devcon->bb_buf = NULL;
+    devcon->bb_off = 0;
+    devcon->bb_size = 0;
+    devcon->cache = NULL;
+    futex_down(&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);
+            free(devcon);
+            return EEXIST;
+        }
+    }
+    list_append(&devcon->link, &dcl_head);
+    futex_up(&dcl_lock);
+    return EOK;
+}
+static void devcon_remove(devcon_t *devcon)
+{
+    futex_down(&dcl_lock);
+    list_remove(&devcon->link);
+    futex_up(&dcl_lock);
+}
+int block_init(dev_handle_t dev_handle, size_t com_size)
+{
+    int rc;
+    int dev_phone;
+    void *com_area;
+    com_area = mmap(NULL, com_size, PROTO_READ | PROTO_WRITE,
+        MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
+    if (!com_area) {
+        return ENOMEM;
+    }
+    dev_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,
+        DEVMAP_CONNECT_TO_DEVICE, dev_handle);
+    if (dev_phone < 0) {
+        munmap(com_area, com_size);
+        return dev_phone;
+    }
+    rc = ipc_share_out_start(dev_phone, com_area,
+        AS_AREA_READ | AS_AREA_WRITE);
+    if (rc != EOK) {
+            munmap(com_area, com_size);
+        ipc_hangup(dev_phone);
+        return rc;
+    }
+    rc = devcon_add(dev_handle, dev_phone, com_area, com_size);
+    if (rc != EOK) {
+        munmap(com_area, com_size);
+        ipc_hangup(dev_phone);
+        return rc;
+    }
+    return EOK;
+}
+void block_fini(dev_handle_t dev_handle)
+{
+    devcon_t *devcon = devcon_search(dev_handle);
+    assert(devcon);
+    devcon_remove(devcon);
+    if (devcon->bb_buf)
+        free(devcon->bb_buf);
+    if (devcon->cache) {
+        hash_table_destroy(&devcon->cache->block_hash);
+        free(devcon->cache);
+    }
+    munmap(devcon->com_area, devcon->com_size);
+    ipc_hangup(devcon->dev_phone);
+    free(devcon);
+}
+int block_bb_read(dev_handle_t dev_handle, off_t off, size_t size)
+{
+    void *bb_buf;
+    int rc;
+    devcon_t *devcon = devcon_search(dev_handle);
+    if (!devcon)
+        return ENOENT;
+    if (devcon->bb_buf)
+        return EEXIST;
+    bb_buf = malloc(size);
+    if (!bb_buf)
+        return ENOMEM;
+    off_t bufpos = 0;
+    size_t buflen = 0;
+    rc = block_read(dev_handle, &bufpos, &buflen, &off,
+        bb_buf, size, size);
+    if (rc != EOK) {
+            free(bb_buf);
+        return rc;
+    }
+    devcon->bb_buf = bb_buf;
+    devcon->bb_off = off;
+    devcon->bb_size = size;
+    return EOK;
+}
+void *block_bb_get(dev_handle_t dev_handle)
+{
+    devcon_t *devcon = devcon_search(dev_handle);
+    assert(devcon);
+    return devcon->bb_buf;
+}
+static hash_index_t cache_hash(unsigned long *key)
+{
+    return *key & (CACHE_BUCKETS - 1);
+}
+static int cache_compare(unsigned long *key, hash_count_t keys, link_t *item)
+{
+    block_t *b = hash_table_get_instance(item, block_t, hash_link);
+    return b->boff == *key;
+}
+static void cache_remove_callback(link_t *item)
+{
+}
+static hash_table_operations_t cache_ops = {
+    .hash = cache_hash,
+    .compare = cache_compare,
+    .remove_callback = cache_remove_callback
+};
+int block_cache_init(dev_handle_t dev_handle, size_t size, unsigned blocks)
+{
+    devcon_t *devcon = devcon_search(dev_handle);
+    cache_t *cache;
+    if (!devcon)
+        return ENOENT;
+    if (devcon->cache)
+        return EEXIST;
+    cache = malloc(sizeof(cache_t));
+    if (!cache)
+        return ENOMEM;
+    futex_initialize(&cache->lock, 1);
+    list_initialize(&cache->free_head);
+    cache->block_size = size;
+    cache->block_count = blocks;
+    if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1,
+        &cache_ops)) {
+        free(cache);
+        return ENOMEM;
+    }
+    devcon->cache = cache;
+    return EOK;
+}
+static bool cache_can_grow(cache_t *cache)
+{
+    return true;
+}
+static void block_initialize(block_t *b)
+{
+    futex_initialize(&b->lock, 1);
+    b->refcnt = 1;
+    b->dirty = false;
+    rwlock_initialize(&b->contents_lock);
+    link_initialize(&b->free_link);
+    link_initialize(&b->hash_link);
+}
+/** Instantiate a block in memory and get a reference to it.
+ *
+ * @param dev_handle        Device handle of the block device.
+ * @param boff          Block offset.
+ * @param flags         If BLOCK_FLAGS_NOREAD is specified, block_get()
+ *              will not read the contents of the block from the
+ *              device.
+ *
+ * @return          Block structure.
+ */
+block_t *block_get(dev_handle_t dev_handle, bn_t boff, int flags)
+{
+    devcon_t *devcon;
+    cache_t *cache;
+    block_t *b;
+    link_t *l;
+    unsigned long key = boff;
+    devcon = devcon_search(dev_handle);
+    assert(devcon);
+    assert(devcon->cache);
+    cache = devcon->cache;
+    futex_down(&cache->lock);
+    l = hash_table_find(&cache->block_hash, &key);
+    if (l) {
+        /*
+         * We found the block in the cache.
+         */
+        b = hash_table_get_instance(l, block_t, hash_link);
+        futex_down(&b->lock);
+        if (b->refcnt++ == 0)
+            list_remove(&b->free_link);
+        futex_up(&b->lock);
+        futex_up(&cache->lock);
+    } else {
+        /*
+         * The block was not found in the cache.
+         */
+        int rc;
+        off_t bufpos = 0;
+        size_t buflen = 0;
+        off_t pos = boff * cache->block_size;
+        bool sync = false;
+        if (cache_can_grow(cache)) {
+            /*
+             * We can grow the cache by allocating new blocks.
+             * Should the allocation fail, we fail over and try to
+             * recycle a block from the cache.
+             */
+            b = malloc(sizeof(block_t));
+            if (!b)
+                goto recycle;
+            b->data = malloc(cache->block_size);
+            if (!b->data) {
+                free(b);
+                goto recycle;
+            }
+        } else {
+            /*
+             * Try to recycle a block from the free list.
+             */
+            unsigned long temp_key;
+recycle:
+            assert(!list_empty(&cache->free_head));
+            l = cache->free_head.next;
+            list_remove(l);
+            b = hash_table_get_instance(l, block_t, hash_link);
+            sync = b->dirty;
+            temp_key = b->boff;
+            hash_table_remove(&cache->block_hash, &temp_key, 1);
+        }
+        block_initialize(b);
+        b->dev_handle = dev_handle;
+        b->size = cache->block_size;
+        b->boff = boff;
+        hash_table_insert(&cache->block_hash, &key, &b->hash_link);
+        /*
+         * Lock the block before releasing the cache lock. Thus we don't
+         * kill concurent operations on the cache while doing I/O on the
+         * block.
+         */
+        futex_down(&b->lock);
+        futex_up(&cache->lock);
+        if (sync) {
+            /*
+             * The block is dirty and needs to be written back to
+             * the device before we can read in the new contents.
+             */
+            abort();    /* TODO: block_write() */
+        }
+        if (!(flags & BLOCK_FLAGS_NOREAD)) {
+            /*
+             * The block contains old or no data. We need to read
+             * the new contents from the device.
+             */
+            rc = block_read(dev_handle, &bufpos, &buflen, &pos,
+                b->data, cache->block_size, cache->block_size);
+            assert(rc == EOK);
+        }
+        futex_up(&b->lock);
+    }
+    return b;
+}
+/** Release a reference to a block.
+ *
+ * If the last reference is dropped, the block is put on the free list.
+ *
+ * @param block     Block of which a reference is to be released.
+ */
+void block_put(block_t *block)
+{
+    devcon_t *devcon = devcon_search(block->dev_handle);
+    cache_t *cache;
+    assert(devcon);
+    assert(devcon->cache);
+    cache = devcon->cache;
+    futex_down(&cache->lock);
+    futex_down(&block->lock);
+    if (!--block->refcnt) {
+        /*
+         * Last reference to the block was dropped, put the block on the
+         * free list.
+         */
+        list_append(&block->free_link, &cache->free_head);
+    }
+    futex_up(&block->lock);
+    futex_up(&cache->lock);
+}
+/** Read data from a block device.
+ *
+ * @param dev_handle    Device handle of the block device.
+ * @param bufpos    Pointer to the first unread valid offset within the
+ *          communication buffer.
+ * @param buflen    Pointer to the number of unread bytes that are ready in
+ *          the communication buffer.
+ * @param pos       Device position to be read.
+ * @param dst       Destination buffer.
+ * @param size      Size of the destination buffer.
+ * @param block_size    Block size to be used for the transfer.
+ *
+ * @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)
+{
+    off_t offset = 0;
+    size_t left = size;
+    devcon_t *devcon = devcon_search(dev_handle);
+    assert(devcon);
+    while (left > 0) {
+        size_t rd;
+        if (*bufpos + left < *buflen)
+            rd = left;
+        else
+            rd = *buflen - *bufpos;
+        if (rd > 0) {
+            /*
+             * Copy the contents of the communication buffer to the
+             * destination buffer.
+             */
+            memcpy(dst + offset, devcon->com_area + *bufpos, rd);
+            offset += rd;
+            *bufpos += rd;
+            *pos += rd;
+            left -= rd;
+        }
+        if (*bufpos == *buflen) {
+            /* Refill the communication buffer with a new block. */
+            ipcarg_t retval;
+            int rc = async_req_2_1(devcon->dev_phone, RD_READ_BLOCK,
+                *pos / block_size, block_size, &retval);
+            if ((rc != EOK) || (retval != EOK))
+                return (rc != EOK ? rc : retval);
+            *bufpos = 0;
+            *buflen = block_size;
+        }
+    }
+    return EOK;
+}
+/** @}
+ */

 /branches/dd/uspace/lib/libblock/Makefile
 ,0 → 1,67
+#
+# Copyright (c) 2005 Martin Decky
+# 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.
+#
+## Common compiler flags
+#
+LIBC_PREFIX = ../libc
+## Setup toolchain
+#
+include $(LIBC_PREFIX)/Makefile.toolchain
+CFLAGS += -Iinclude
+## Sources
+#
+SOURCES = \
+    libblock.c
+OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
+.PHONY: all clean depend
+all: libblock.a
+-include Makefile.depend
+clean:
+    -rm -f libblock.a Makefile.depend
+    find . -name '*.o' -follow -exec rm \{\} \;
+depend:
+    -makedepend -f - -- $(DEPEND_DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null
+libblock.a: depend $(OBJECTS)
+    $(AR) rc libblock.a $(OBJECTS)
+%.o: %.c
+    $(CC) $(DEFS) $(CFLAGS) -c $< -o $@

 /branches/dd/uspace/lib/libblock/libblock.h
 ,0 → 1,105
+/*
+ * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2008 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 libblock
+ * @{
+ */
+/**
+ * @file
+ */
+#ifndef LIBBLOCK_LIBBLOCK_H_
+#define LIBBLOCK_LIBBLOCK_H_
+#include <stdint.h>
+#include "../../srv/vfs/vfs.h"
+#include <futex.h>
+#include <rwlock.h>
+#include <libadt/hash_table.h>
+#include <libadt/list.h>
+/*
+ * Flags that can be used with block_get().
+ */
+/**
+ * This macro is a symbolic value for situations where no special flags are
+ * needed.
+ */
+#define BLOCK_FLAGS_NONE    0
+/**
+ * When the client of block_get() intends to overwrite the current contents of
+ * the block, this flag is used to avoid the unnecessary read.
+ */
+#define BLOCK_FLAGS_NOREAD  1
+typedef unsigned bn_t;  /**< Block number type. */
+typedef struct block {
+    /** Futex protecting the reference count. */
+    futex_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;
+    /** Handle of the device where the block resides. */
+    dev_handle_t dev_handle;
+    /** Block offset on the block device. Counted in 'size'-byte blocks. */
+    bn_t boff;
+    /** Size of the block. */
+    size_t size;
+    /** Link for placing the block into the free block list. */
+    link_t free_link;
+    /** Link for placing the block into the block hash table. */
+    link_t hash_link;
+    /** Buffer with the block data. */
+    void *data;
+} block_t;
+extern int block_init(dev_handle_t, size_t);
+extern void block_fini(dev_handle_t);
+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 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);
+#endif
+/** @}
+ */

 /branches/dd/uspace/lib/softint/Makefile
 ,6 → 30,7
 #
 LIBC_PREFIX = ../libc
 ## Setup toolchain
 #
 ,7 → 59,7
     find generic/ -name '*.o' -follow -exec rm \{\} \;
 depend:
-    -makedepend $(DEFS) $(CFLAGS) -f - $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend -f - -- $(DEPEMD_DEFS) $(CFLAGS) -- $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
 libsoftint.a: depend $(ARCH_OBJECTS) $(GENERIC_OBJECTS)
     $(AR) rc libsoftint.a $(ARCH_OBJECTS) $(GENERIC_OBJECTS)

 /branches/dd/uspace/lib/libc/include/align.h
 ,21 → 35,28
 #ifndef LIBC_ALIGN_H_
 #define LIBC_ALIGN_H_
-/** Align to the nearest lower address.
+/** Align to the nearest lower address which is a power of two.
  *
- * @param s Address or size to be aligned.
- * @param a Size of alignment, must be power of 2.
+ * @param s     Address or size to be aligned.
+ * @param a     Size of alignment, must be power of 2.
  */
 #define ALIGN_DOWN(s, a)    ((s) & ~((a) - 1))
-/** Align to the nearest higher address.
+/** Align to the nearest higher address which is a power of two.
  *
- * @param s Address or size to be aligned.
- * @param a Size of alignment, must be power of 2.
+ * @param s     Address or size to be aligned.
+ * @param a     Size of alignment, must be power of 2.
  */
 #define ALIGN_UP(s, a)      ((long)((s) + ((a) - 1)) & ~((long) (a) - 1))
+/** Round up to the nearest higher boundary.
+ *
+ * @param n     Number to be aligned.
+ * @param b     Boundary, arbitrary unsigned number.
+ */
+#define ROUND_UP(n, b)      (((n) / (b) + ((n) % (b) != 0)) * (b))
 #endif
 /** @}

 /branches/dd/uspace/lib/libc/include/byteorder.h
 ,6 → 52,14
 #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_be(n)     (n)
+#define host2uint32_t_be(n)     (n)
+#define host2uint64_t_be(n)     (n)
 #else
 #define uint16_t_le2host(n)     (n)
 ,6 → 70,14
 #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_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
 static inline uint64_t uint64_t_byteorder_swap(uint64_t n)

 /branches/dd/uspace/lib/libc/include/ddi.h
 ,9 → 37,10
 #include <task.h>
-extern int physmem_map(void *pf, void *vp, unsigned long pages, int flags);
-extern int iospace_enable(task_id_t id, void *ioaddr, unsigned long size);
-extern int preemption_control(int enable);
+extern int physmem_map(void *, void *, unsigned long, int);
+extern int iospace_enable(task_id_t, void *, unsigned long);
+extern int preemption_control(int);
+extern int pio_enable(void *, size_t, void **);
 #endif

 /branches/dd/uspace/lib/libc/include/console.h
 ,0 → 1,53
+/*
+ * 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_CONSOLE_H_
+#define LIBC_CONSOLE_H_
+#include <console/style.h>
+#include <console/color.h>
+extern void console_clear(void);
+extern void console_goto(int, int);
+extern void console_flush(void);
+extern int console_get_size(int *, int *);
+extern void console_set_style(int);
+extern void console_set_color(int, int, int);
+extern void console_set_rgb_color(int, int);
+extern void console_cursor_visibility(int);
+#endif
+/** @}
+ */

 /branches/dd/uspace/lib/libc/include/getopt.h
 ,0 → 1,71
+/*  $NetBSD: getopt.h,v 1.10.6.1 2008/05/18 12:30:09 yamt Exp $ */
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``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 FOUNDATION OR CONTRIBUTORS
+ * 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.
+ */
+/* Ported to HelenOS August 2008 by Tim Post <echo@echoreply.us> */
+#ifndef _GETOPT_H_
+#define _GETOPT_H_
+#include <unistd.h>
+/*
+ * Gnu like getopt_long() and BSD4.4 getsubopt()/optreset extensions
+ */
+#define no_argument        0
+#define required_argument  1
+#define optional_argument  2
+struct option {
+    /* name of long option */
+    const char *name;
+    /*
+     * one of no_argument, required_argument, and optional_argument:
+     * whether option takes an argument
+     */
+    int has_arg;
+    /* if not NULL, set *flag to val when option found */
+    int *flag;
+    /* if flag not NULL, value to set *flag to; else return value */
+    int val;
+};
+/* HelenOS Port - These need to be exposed for legacy getopt() */
+extern char *optarg;
+extern int optind, opterr, optopt;
+extern int optreset;
+int getopt_long(int, char * const *, const char *,
+    const struct option *, int *);
+/* HelenOS Port : Expose legacy getopt() */
+int  getopt(int, char * const [], const char *);
+#endif /* !_GETOPT_H_ */

/branches/dd/uspace/lib/libc/include/as.h
42,6 → 42,7

extern void as_area_create(void address, size_t size, int flags);
extern int as_area_resize(void *address, size_t size, int flags);
extern int as_area_change_flags(void *address, int flags);
extern int as_area_destroy(void *address);
extern void *set_maxheapsize(size_t mhs);
extern void * as_get_mappable_page(size_t sz);

 /branches/dd/uspace/lib/libc/include/string.h
 ,18 → 35,12
 #ifndef LIBC_STRING_H_
 #define LIBC_STRING_H_
+#include <mem.h>
 #include <sys/types.h>
-#define bzero(ptr, len) memset((ptr), 0, (len))
-extern void * memset(void *, int, size_t);
-extern void * memcpy(void *, const void *, size_t);
-extern void * memmove(void *, const void *, size_t);
-extern int bcmp(const char *, const char *, size_t);
 extern int strcmp(const char *, const char *);
 extern int strncmp(const char *, const char *, size_t);
+extern int stricmp(const char *, const char *);
 extern char *strcpy(char *, const char *);
 extern char *strncpy(char *, const char *, size_t);
 ,6 → 49,8
 extern size_t strlen(const char *);
+extern char *strdup(const char *);
 extern char *strchr(const char *, int);
 extern char *strrchr(const char *, int);
 ,6 → 57,9
 extern long int strtol(const char *, char **, int);
 extern unsigned long strtoul(const char *, char **, int);
+extern char * strtok_r(char *, const char *, char **);
+extern char * strtok(char *, const char *);
 #endif
 /** @}

 /branches/dd/uspace/lib/libc/include/vfs/vfs.h
 ,8 → 35,13
 #ifndef LIBC_VFS_H_
 #define LIBC_VFS_H_
-extern int mount(const char *, const char *, const char *);
+#include <sys/types.h>
+extern char *absolutize(const char *, size_t *);
+extern int mount(const char *, const char *, const char *,
+    const unsigned int flags);
 #endif
 /** @}

 /branches/dd/uspace/lib/libc/include/syscall.h
 ,15 → 32,28
 /**
  * @file
  * @brief   Syscall function declaration for architectures that don't
- *      inline syscalls.
+ *      inline syscalls or architectures that handle syscalls
+ *      according to the number of arguments.
  */
 #ifndef LIBC_SYSCALL_H_
 #define LIBC_SYSCALL_H_
+#ifndef LIBARCH_SYSCALL_GENERIC
+#error "You can't include this file directly."
+#endif
 #include <sys/types.h>
 #include <kernel/syscall/syscall.h>
+#define __syscall0  __syscall
+#define __syscall1  __syscall
+#define __syscall2  __syscall
+#define __syscall3  __syscall
+#define __syscall4  __syscall
+#define __syscall5  __syscall
+#define __syscall6  __syscall
 extern sysarg_t __syscall(const sysarg_t p1, const sysarg_t p2,
     const sysarg_t p3, const sysarg_t p4, const sysarg_t p5, const sysarg_t p6,
     const syscall_t id);

 /branches/dd/uspace/lib/libc/include/async.h
 ,7 → 76,7
 #define async_send_5(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);
 extern aid_t async_send_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
 ,8 → 86,8
 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,
-    ipc_call_t *call, void (*cthread)(ipc_callid_t,ipc_call_t *));
+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);
 ,7 → 118,7
 /*
  * User-friendly wrappers for async_req_fast() and async_req_slow(). The macros
  * are in the form async_req_m_n(), where m is the number of payload arguments
- * and n is the number of return arguments. The macros decidce between the fast
+ * and n is the number of return arguments. The macros decide between the fast
  * and slow verion based on m.
  */
 #define async_req_0_0(phoneid, method) \

 /branches/dd/uspace/lib/libc/include/stdio.h
 ,27 → 49,65
     int n; \
     n = snprintf(buf, sizeof(buf), fmt, ##__VA_ARGS__); \
     if (n > 0) \
-        (void) __SYSCALL3(SYS_IO, 1, (sysarg_t) buf, strlen(buf)); \
+        (void) __SYSCALL3(SYS_KLOG, 1, (sysarg_t) buf, strlen(buf)); \
 }
+typedef struct {
+    /** Underlying file descriptor. */
+    int fd;
+    /** Error indicator. */
+    int error;
+    /** End-of-file indicator. */
+    int eof;
+} FILE;
+extern FILE *stdin, *stdout, *stderr;
 extern int getchar(void);
-extern int puts(const char * str);
-extern int putchar(int c);
+extern int puts(const char *);
+extern int putchar(int);
-extern int printf(const char *fmt, ...);
-extern int sprintf(char *str, const char *fmt, ...);
-extern int snprintf(char *str, size_t size, const char *fmt, ...);
+extern int printf(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 *fmt, va_list ap);
-extern int vsprintf(char *str, const char *fmt, va_list ap);
-extern int vsnprintf(char *str, size_t size, const char *fmt, va_list ap);
+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);
-#define fprintf(f, fmt, ...) printf(fmt, ##__VA_ARGS__)
 extern int rename(const char *, const char *);
+extern FILE *fopen(const char *, 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 feof(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 int fprintf(FILE *, const char *, ...);
+extern int vfprintf(FILE *, const char *, va_list);
+#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/dd/uspace/lib/libc/include/task.h
 ,6 → 40,8
 typedef uint64_t task_id_t;
 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[]);
 #endif

 /branches/dd/uspace/lib/libc/include/unistd.h
 ,9 → 44,11
 #define getpagesize()     (PAGE_SIZE)
-#define SEEK_SET    0
-#define SEEK_CUR    1
-#define SEEK_END    2
+#ifndef SEEK_SET
+    #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);

 /branches/dd/uspace/lib/libc/include/libc.h
 ,17 → 39,22
 #include <kernel/syscall/syscall.h>
 #include <libarch/syscall.h>
-#define __SYSCALL0(id) __syscall(0, 0, 0, 0, 0, 0, id)
-#define __SYSCALL1(id, p1) __syscall(p1, 0, 0, 0, 0, 0, id)
-#define __SYSCALL2(id, p1, p2) __syscall(p1, p2, 0, 0, 0, 0, id)
-#define __SYSCALL3(id, p1, p2, p3) __syscall(p1, p2, p3, 0, 0, 0, id)
-#define __SYSCALL4(id, p1, p2, p3, p4) __syscall(p1, p2, p3, p4, 0, 0, id)
-#define __SYSCALL5(id, p1, p2, p3, p4, p5) __syscall(p1, p2, p3, p4, p5, 0, id)
+#define __SYSCALL0(id) \
+    __syscall0(0, 0, 0, 0, 0, 0, id)
+#define __SYSCALL1(id, p1) \
+    __syscall1(p1, 0, 0, 0, 0, 0, id)
+#define __SYSCALL2(id, p1, p2) \
+    __syscall2(p1, p2, 0, 0, 0, 0, id)
+#define __SYSCALL3(id, p1, p2, p3) \
+    __syscall3(p1, p2, p3, 0, 0, 0, id)
+#define __SYSCALL4(id, p1, p2, p3, p4) \
+    __syscall4(p1, p2, p3, p4, 0, 0, id)
+#define __SYSCALL5(id, p1, p2, p3, p4, p5) \
+    __syscall5(p1, p2, p3, p4, p5, 0, id)
 #define __SYSCALL6(id, p1, p2, p3, p4, p5, p6) \
-    __syscall(p1, p2, p3, p4, p5, p6,id)
+    __syscall6(p1, p2, p3, p4, p5, p6, id)
-extern void __main(void);
-extern void __io_init(void);
+extern void __main(void *pcb_ptr);
 extern void __exit(void);
 #endif

 /branches/dd/uspace/lib/libc/include/kbd/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_KBD_KEYCODE_H_
+#define LIBC_KBD_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/dd/uspace/lib/libc/include/kbd/kbd.h
 ,0 → 1,63
+/*
+ * 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_KBD_H_
+#define LIBC_KBD_H_
+typedef enum kbd_ev_type {
+    KE_PRESS,
+    KE_RELEASE
+} kbd_ev_type_t;
+/** Keyboard event structure. */
+typedef struct {
+    /** Press or release event. */
+    kbd_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. */
+    char c;
+} kbd_event_t;
+extern int kbd_get_event(kbd_event_t *);
+#endif
+/** @}
+ */

 /branches/dd/uspace/lib/libc/include/udebug.h
 ,0 → 1,58
+/*
+ * 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_UDEBUG_H_
+#define LIBC_UDEBUG_H_
+#include <kernel/udebug/udebug.h>
+#include <sys/types.h>
+#include <libarch/types.h>
+typedef sysarg_t thash_t;
+int udebug_begin(int phoneid);
+int udebug_end(int phoneid);
+int udebug_set_evmask(int phoneid, udebug_evmask_t mask);
+int udebug_thread_read(int phoneid, void *buffer, size_t n,
+    size_t *copied, size_t *needed);
+int udebug_mem_read(int phoneid, void *buffer, uintptr_t addr, size_t n);
+int udebug_args_read(int phoneid, thash_t tid, sysarg_t *buffer);
+int udebug_go(int phoneid, thash_t tid, udebug_event_t *ev_type,
+    sysarg_t *val0, sysarg_t *val1);
+int udebug_stop(int phoneid, thash_t tid);
+#endif
+/** @}
+ */

 /branches/dd/uspace/lib/libc/include/console/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_CONSOLE_COLOR_H_
+#define LIBC_CONSOLE_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/dd/uspace/lib/libc/include/console/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_CONSOLE_STYLE_H_
+#define LIBC_CONSOLE_STYLE_H_
+enum console_style {
+    STYLE_NORMAL    = 0,
+    STYLE_EMPHASIS  = 1
+};
+#endif
+/** @}
+ */

 /branches/dd/uspace/lib/libc/include/mem.h
 ,0 → 1,51
+/*
+ * 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.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_MEM_H_
+#define LIBC_MEM_H_
+#include <sys/types.h>
+#define bzero(ptr, len)  memset((ptr), 0, (len))
+extern void * memset(void *, int, size_t);
+extern void * memcpy(void *, const void *, size_t);
+extern void * memmove(void *, const void *, size_t);
+extern int bcmp(const char *, const char *, size_t);
+#endif
+/** @}
+ */
 Property changes:
 Added: svn:mergeinfo

 /branches/dd/uspace/lib/libc/include/loader/loader.h
 ,0 → 1,60
+/*
+ * 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 fs
+ * @{
+ */
+/** @file
+ * @brief Program loader interface.
+ */
+#ifndef LIBC_LOADER_H_
+#define LIBC_LOADER_H_
+#include <task.h>
+/** Abstraction of a loader connection */
+typedef struct {
+    /** ID of the phone connected to the loader. */
+    int phone_id;
+} loader_t;
+extern int loader_spawn(const char *);
+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_load_program(loader_t *);
+extern int loader_run(loader_t *);
+extern void loader_abort(loader_t *);
+#endif
+/**
+ * @}
+ */

 /branches/dd/uspace/lib/libc/include/loader/pcb.h
 ,0 → 1,75
+/*
+ * 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 fs
+ * @{
+ */
+/** @file
+ * @brief Program Control Block interface.
+ */
+#ifndef LIBC_PCB_H_
+#define LIBC_PCB_H_
+#include <sys/types.h>
+typedef void (*entry_point_t)(void);
+/** Program Control Block.
+ *
+ * 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;
+    /*
+     * ELF-specific data.
+     */
+    /** Pointer to ELF dynamic section of the program. */
+    void *dynamic;
+} pcb_t;
+/**
+ * A pointer to the program control block. Having received the PCB pointer,
+ * the C library startup code stores it here for later use.
+ */
+extern pcb_t *__pcb;
+#endif
+/**
+ * @}
+ */

 /branches/dd/uspace/lib/libc/include/io/stream.h
 ,14 → 39,16
 #define EMFILE -17
-extern void open_stdin(void);
-extern void open_stdout(void);
+extern void open_console(void);
+extern void close_console(void);
+extern void klog_update(void);
 extern ssize_t read_stdin(void *, size_t);
 extern ssize_t write_stdout(const void *, size_t);
 extern ssize_t write_stderr(const void *, size_t);
-extern int get_cons_phone(void);
+extern int get_console_phone(void);
+extern void console_wait(void);
 #endif

 /branches/dd/uspace/lib/libc/include/smc.h
 ,0 → 1,45
+/*
+ * 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_SMC_H_
+#define LIBC_SMC_H_
+#include <sys/types.h>
+extern int smc_coherence(void *address, size_t size);
+#endif
+/** @}
+ */

 /branches/dd/uspace/lib/libc/include/ctype.h
 ,6 → 76,22
     }
 }
+static inline int tolower(int c)
+{
+    if (isupper(c))
+        return (c + ('a' - 'A'));
+    else
+        return c;
+}
+static inline int toupper(int c)
+{
+    if (islower(c))
+        return (c + ('A' - 'a'));
+    else
+        return c;
+}
 #endif
 /** @}

 /branches/dd/uspace/lib/libc/include/macros.h
 ,0 → 1,50
+/*
+ * 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 libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_MACROS_H_
+#define LIBC_MACROS_H_
+#define SIZE2KB(size) ((size) >> 10)
+#define SIZE2MB(size) ((size) >> 20)
+#define KB2SIZE(kb) ((kb) << 10)
+#define MB2SIZE(mb) ((mb) << 20)
+#define STRING(arg) STRING_ARG(arg)
+#define STRING_ARG(arg) #arg
+#endif
+/** @}
+ */

 /branches/dd/uspace/lib/libc/include/ipc/bus.h
 ,0 → 1,47
+/*
+ * 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 libcipc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_BUS_H_
+#define LIBC_BUS_H_
+#include <ipc/ipc.h>
+typedef enum {
+    BUS_CLEAR_INTERRUPT = IPC_FIRST_USER_METHOD
+} bus_request_t;
+#endif
+/** @}
+ */

 /branches/dd/uspace/lib/libc/include/ipc/ipc.h
 ,8 → 47,7
 } ipc_call_t;
 typedef sysarg_t ipc_callid_t;
-typedef void (* ipc_async_callback_t)(void *private, int retval,
-    ipc_call_t *data);
+typedef void (* ipc_async_callback_t)(void *, int, ipc_call_t *);
 /*
  * User-friendly wrappers for ipc_call_sync_fast() and ipc_call_sync_slow().
 ,22 → 172,20
     ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
         (arg4), (arg5), (res1), (res2), (res3), (res4), (res5))
-extern int ipc_call_sync_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
-    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t *result1, ipcarg_t *result2,
-    ipcarg_t *result3, ipcarg_t *result4, ipcarg_t *result5);
+extern int ipc_call_sync_fast(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *);
-extern int ipc_call_sync_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
-    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5,
-    ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3, ipcarg_t *result4,
-    ipcarg_t *result5);
+extern int ipc_call_sync_slow(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t, ipcarg_t, ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *,
+    ipcarg_t *);
-extern ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags);
-extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *data, uint32_t usec);
+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 *data);
+extern ipc_callid_t ipc_trywait_for_call(ipc_call_t *);
 /*
  * User-friendly wrappers for ipc_answer_fast() and ipc_answer_slow().
 ,10 → 206,10
 #define ipc_answer_5(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 callid, ipcarg_t retval,
-    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4);
-extern ipcarg_t ipc_answer_slow(ipc_callid_t callid, ipcarg_t retval,
-    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5);
+extern ipcarg_t ipc_answer_fast(ipc_callid_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t, ipcarg_t);
+extern ipcarg_t ipc_answer_slow(ipc_callid_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t, ipcarg_t, ipcarg_t);
 /*
  * User-friendly wrappers for ipc_call_async_fast() and ipc_call_async_slow().
 ,8 → 217,7
  * arguments. The macros decide between the fast and the slow version according
  * to m.
  */
-#define ipc_call_async_0(phoneid, method, private, callback, \
-    can_preempt) \
+#define ipc_call_async_0(phoneid, method, private, callback, can_preempt) \
     ipc_call_async_fast((phoneid), (method), 0, 0, 0, 0, (private), \
         (callback), (can_preempt))
 #define ipc_call_async_1(phoneid, method, arg1, private, callback, \
 ,23 → 241,24
     ipc_call_async_slow((phoneid), (method), (arg1), (arg2), (arg3), \
         (arg4), (arg5), (private), (callback), (can_preempt))
-extern void ipc_call_async_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
-    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, void *private,
-    ipc_async_callback_t callback, int can_preempt);
-extern void ipc_call_async_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
-    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, void *private,
-    ipc_async_callback_t callback, int can_preempt);
+extern void ipc_call_async_fast(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t, void *, ipc_async_callback_t, int);
+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);
-extern int ipc_connect_to_me(int phoneid, int arg1, int arg2, int arg3,
-    ipcarg_t *phone);
-extern int ipc_connect_me_to(int phoneid, int arg1, int arg2, int arg3);
-extern int ipc_hangup(int phoneid);
-extern int ipc_register_irq(int inr, int devno, int method, irq_code_t *code);
-extern int ipc_unregister_irq(int inr, int devno);
-extern int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method,
-    ipcarg_t arg1, ipcarg_t arg2, int mode);
+#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);
+extern int ipc_hangup(int);
+extern int ipc_register_irq(int, int, int, irq_code_t *);
+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);
 /*
  * User-friendly wrappers for ipc_share_in_start().
  */
 ,20 → 271,23
 #define ipc_share_in_start_1_1(phoneid, dst, size, arg, flags) \
     ipc_share_in_start((phoneid), (dst), (size), (arg), (flags))
-extern int ipc_share_in_start(int phoneid, void *dst, size_t size, ipcarg_t arg,
-    int *flags);
-extern int ipc_share_in_receive(ipc_callid_t *callid, size_t *size);
-extern int ipc_share_in_finalize(ipc_callid_t callid, void *src, int flags);
-extern int ipc_share_out_start(int phoneid, void *src, int flags);
-extern int ipc_share_out_receive(ipc_callid_t *callid, size_t *size, int *flags);
-extern int ipc_share_out_finalize(ipc_callid_t callid, void *dst);
-extern int ipc_data_read_start(int phoneid, void *dst, size_t size);
-extern int ipc_data_read_receive(ipc_callid_t *callid, size_t *size);
-extern int ipc_data_read_finalize(ipc_callid_t callid, void *src, size_t size);
-extern int ipc_data_write_start(int phoneid, void *src, size_t size);
-extern int ipc_data_write_receive(ipc_callid_t *callid, size_t *size);
-extern int ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size);
+extern int ipc_share_in_start(int, void *, size_t, ipcarg_t, int *);
+extern int ipc_share_in_receive(ipc_callid_t *, size_t *);
+extern int ipc_share_in_finalize(ipc_callid_t, void *, int );
+extern int ipc_share_out_start(int, void *, int);
+extern int ipc_share_out_receive(ipc_callid_t *, size_t *, int *);
+extern int ipc_share_out_finalize(ipc_callid_t, void *);
+extern int ipc_data_read_start(int, void *, size_t);
+extern int ipc_data_read_receive(ipc_callid_t *, size_t *);
+extern int ipc_data_read_finalize(ipc_callid_t, const void *, size_t);
+extern int ipc_data_write_start(int, const void *, size_t);
+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/dd/uspace/lib/libc/include/ipc/devmap.h
 ,0 → 1,99
+/*
+ * Copyright (c) 2007 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 devmap
+ * @{
+ */
+#ifndef DEVMAP_DEVMAP_H_
+#define DEVMAP_DEVMAP_H_
+#include <ipc/ipc.h>
+#include <libadt/list.h>
+#define DEVMAP_NAME_MAXLEN 512
+typedef enum {
+    DEVMAP_DRIVER_REGISTER = IPC_FIRST_USER_METHOD,
+    DEVMAP_DRIVER_UNREGISTER,
+    DEVMAP_DEVICE_REGISTER,
+    DEVMAP_DEVICE_UNREGISTER,
+    DEVMAP_DEVICE_GET_NAME,
+    DEVMAP_DEVICE_GET_HANDLE
+} 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
+ *
+ */
+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 */
+    DEVMAP_CLIENT,
+        /** Create new connection to instance of device that
+         * is specified by second argument of call. */
+    DEVMAP_CONNECT_TO_DEVICE
+} devmap_interface_t;
+#endif

 /branches/dd/uspace/lib/libc/include/ipc/console.h
 ,0 → 1,56
+/*
+ * 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 libcipc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_IPC_CONSOLE_H_
+#define LIBC_IPC_CONSOLE_H_
+#include <ipc/ipc.h>
+typedef enum {
+    CONSOLE_GETKEY = IPC_FIRST_USER_METHOD,
+    CONSOLE_PUTCHAR,
+    CONSOLE_CLEAR,
+    CONSOLE_GOTO,
+    CONSOLE_GETSIZE,
+    CONSOLE_FLUSH,
+    CONSOLE_SET_STYLE,
+    CONSOLE_SET_COLOR,
+    CONSOLE_SET_RGB_COLOR,
+    CONSOLE_CURSOR_VISIBILITY
+} console_request_t;
+#endif
+/** @}
+ */
 Property changes:
 Added: svn:mergeinfo

 /branches/dd/uspace/lib/libc/include/ipc/services.h
 ,8 → 30,8
  * @{
  */
 /**
- * @file    services.h
- * @brief   List of all known services and their codes.
+ * @file  services.h
+ * @brief List of all known services and their codes.
  */
 #ifndef LIBIPC_SERVICES_H_
 ,13 → 38,15
 #define LIBIPC_SERVICES_H_
 typedef enum {
-    SERVICE_PCI = 1,
+    SERVICE_LOAD = 1,
+    SERVICE_PCI,
     SERVICE_KEYBOARD,
     SERVICE_VIDEO,
     SERVICE_CONSOLE,
-    SERVICE_RD,
     SERVICE_VFS,
-    SERVICE_DEVMAP
+    SERVICE_DEVMAP,
+    SERVICE_FHC,
+    SERVICE_OBIO
 } services_t;
 /* Memory area to be received from NS */

 /branches/dd/uspace/lib/libc/include/ipc/loader.h
 ,0 → 1,52
+/*
+ * 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 libcipc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_IPC_LOADER_H_
+#define LIBC_IPC_LOADER_H_
+#include <ipc/ipc.h>
+typedef enum {
+    LOADER_HELLO = IPC_FIRST_USER_METHOD,
+    LOADER_GET_TASKID,
+    LOADER_SET_PATHNAME,
+    LOADER_SET_ARGS,
+    LOADER_LOAD,
+    LOADER_RUN
+} loader_request_t;
+#endif
+/** @}
+ */

/branches/dd/uspace/lib/libc/include/ipc/fb.h
48,10 → 48,11
FB_VIEWPORT_CREATE,
FB_VIEWPORT_DELETE,
FB_SET_STYLE,
FB_SET_COLOR,
FB_SET_RGB_COLOR,
FB_GET_RESOLUTION,
FB_DRAW_TEXT_DATA,
FB_FLUSH,
FB_VIEWPORT_DB,
FB_DRAW_PPM,
FB_PREPARE_SHM,
FB_DROP_SHM,
59,7 → 60,6
FB_VP_DRAW_PIXMAP,
FB_VP2PIXMAP,
FB_DROP_PIXMAP,
FB_TRANS_PUTCHAR,
FB_ANIM_CREATE,
FB_ANIM_DROP,
FB_ANIM_ADDPIXMAP,
69,7 → 69,6
FB_POINTER_MOVE
} fb_request_t;


#endif

/** @}

 /branches/dd/uspace/lib/libc/include/errno.h
 ,6 → 35,10
 #ifndef LIBC_ERRNO_H_
 #define LIBC_ERRNO_H_
+/* TODO: support threads/fibrils */
+extern int _errno;
+#define errno _errno
 #include <kernel/errno.h>
 #define ENAMETOOLONG    (-256)
 ,6 → 50,8
 #define EBADF       (-262)
 #define ERANGE      (-263)
 #define EXDEV       (-264)
+#define EIO     (-265)
+#define EMLINK      (-266)
 #endif

 /branches/dd/uspace/lib/libc/include/sys/types.h
 ,6 → 42,10
 typedef long off_t;
 typedef int mode_t;
+typedef volatile uint8_t ioport8_t;
+typedef volatile uint16_t ioport16_t;
+typedef volatile uint32_t ioport32_t;
 #endif
 /** @}

 /branches/dd/uspace/lib/libc/Makefile.toolchain
 ,16 → 26,23
 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
-DEFS = -DARCH=$(ARCH)
-CFLAGS = -fno-builtin -Wall -Werror-implicit-function-declaration -Wmissing-prototypes -O3 -nostdlib -nostdinc -I$(LIBC_PREFIX)/include
+CFLAGS = -fno-builtin -Wall -Werror-implicit-function-declaration -Wmissing-prototypes -O3 -nostdlib -nostdinc -imacros $(LIBC_PREFIX)/../../../config.h -I$(LIBC_PREFIX)/include -pipe -g
 LFLAGS = -M -N $(SOFTINT_PREFIX)/libsoftint.a
 AFLAGS =
-#-Werror
+## Cross-toolchain prefix
+#
+ifndef CROSS_PREFIX
+    CROSS_PREFIX = /usr/local
+endif
 ## Setup platform configuration
 #
-include $(LIBC_PREFIX)/arch/$(ARCH)/Makefile.inc
+-include $(LIBC_PREFIX)/../../../Makefile.config
+-include $(LIBC_PREFIX)/../../../config.defs
+-include $(LIBC_PREFIX)/arch/$(UARCH)/Makefile.inc
 ## Simple detection of the host system
 #
 ,6 → 66,7
     AR = $(BINUTILS_PREFIX)ar
     OBJCOPY = $(BINUTILS_PREFIX)objcopy
     OBJDUMP = $(BINUTILS_PREFIX)objdump
+    DEPEND_DEFS = $(DEFS) $(CONFIG_DEFS)
 endif
 ifeq ($(COMPILER),icc_native)
 ,6 → 76,7
     AR = ar
     OBJCOPY = objcopy
     OBJDUMP = objdump
+    DEPEND_DEFS = $(DEFS) $(CONFIG_DEFS)
 endif
 ifeq ($(COMPILER),gcc_cross)
 ,5 → 86,5
     AR = $(TOOLCHAIN_DIR)/$(TARGET)-ar
     OBJCOPY = $(TOOLCHAIN_DIR)/$(TARGET)-objcopy
     OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump
+    DEPEND_DEFS = $(DEFS) $(CONFIG_DEFS)
 endif

 /branches/dd/uspace/lib/libc/generic/time.c
 ,6 → 47,8
 #include <as.h>
 #include <ddi.h>
+#include <time.h>
 /* Pointers to public variables with time */
 struct {
     volatile sysarg_t seconds1;

 /branches/dd/uspace/lib/libc/generic/ddi.c
 ,8 → 33,12
  */
 #include <ddi.h>
+#include <libarch/ddi.h>
 #include <libc.h>
 #include <task.h>
+#include <as.h>
+#include <align.h>
+#include <libarch/config.h>
 #include <kernel/ddi/ddi_arg.h>
 /** Map piece of physical memory to task.
 ,18 → 45,20
  *
  * Caller of this function must have the CAP_MEM_MANAGER capability.
  *
- * @param pf Physical address of the starting frame.
- * @param vp Virtual address of the sterting page.
- * @param pages Number of pages to map.
- * @param flags Flags for the new address space area.
+ * @param pf        Physical address of the starting frame.
+ * @param vp        Virtual address of the starting page.
+ * @param pages     Number of pages to map.
+ * @param flags     Flags for the new address space area.
  *
- * @return 0 on success, EPERM if the caller lacks the CAP_MEM_MANAGER capability,
- *     ENOENT if there is no task with specified ID and ENOMEM if there
- *     was some problem in creating address space area.
+ * @return      0 on success, EPERM if the caller lacks the
+ *          CAP_MEM_MANAGER capability, ENOENT if there is no task
+ *          with specified ID and ENOMEM if there was some problem
+ *          in creating address space area.
  */
 int physmem_map(void *pf, void *vp, unsigned long pages, int flags)
 {
-    return __SYSCALL4(SYS_PHYSMEM_MAP, (sysarg_t) pf, (sysarg_t) vp, pages, flags);
+    return __SYSCALL4(SYS_PHYSMEM_MAP, (sysarg_t) pf, (sysarg_t) vp, pages,
+        flags);
 }
 /** Enable I/O space range to task.
 ,13 → 65,14
  *
  * Caller of this function must have the IO_MEM_MANAGER capability.
  *
- * @param id Task ID.
- * @param ioaddr Starting address of the I/O range.
- * @param size Size of the range.
+ * @param id        Task ID.
+ * @param ioaddr    Starting address of the I/O range.
+ * @param size      Size of the range.
  *
- * @return 0 on success, EPERM if the caller lacks the CAP_IO_MANAGER capability,
- *     ENOENT if there is no task with specified ID and ENOMEM if there
- *     was some problem in allocating memory.
+ * @return      0 on success, EPERM if the caller lacks the
+ *          CAP_IO_MANAGER capability, ENOENT if there is no task
+ *          with specified ID and ENOMEM if there was some problem
+ *          in allocating memory.
  */
 int iospace_enable(task_id_t id, void *ioaddr, unsigned long size)
 {
 ,7 → 87,7
 /** Interrupt control
  *
- * @param enable 1 - enable interrupts, 0 - disable interrupts
+ * @param enable    1 - enable interrupts, 0 - disable interrupts
  */
 int preemption_control(int enable)
 {
 ,5 → 94,36
     return __SYSCALL1(SYS_PREEMPT_CONTROL, (sysarg_t) enable);
 }
+/** Enable PIO for specified I/O range.
+ *
+ * @param pio_addr  I/O start address.
+ * @param size      Size of the I/O region.
+ * @param use_addr  Address where the final address for application's PIO
+ *          will be stored.
+ *
+ * @return      Zero on success or negative error code.
+ */
+int pio_enable(void *pio_addr, size_t size, void **use_addr)
+{
+    void *phys;
+    void *virt;
+    size_t offset;
+    unsigned int pages;
+#ifdef IO_SPACE_BOUNDARY
+    if (pio_addr < IO_SPACE_BOUNDARY) {
+        *use_addr = pio_addr;
+        return iospace_enable(task_get_id(), pio_addr, size);
+    }
+#endif
+    phys = 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);
+    *use_addr = virt + offset;
+    return physmem_map(phys, virt, pages, AS_AREA_READ | AS_AREA_WRITE);
+}
 /** @}
  */

 /branches/dd/uspace/lib/libc/generic/kbd.c
 ,0 → 1,61
+/*
+ * 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
+ */
+#include <stdio.h>
+#include <io/stream.h>
+#include <kbd/kbd.h>
+#include <ipc/ipc.h>
+#include <ipc/console.h>
+#include <async.h>
+int kbd_get_event(kbd_event_t *ev)
+{
+    int console_phone = get_console_phone();
+    ipcarg_t r0, r1, r2, r3;
+    int rc;
+    rc = async_req_0_4(console_phone, CONSOLE_GETKEY, &r0, &r1, &r2, &r3);
+    if (rc < 0)
+        return -1;
+    ev->type = r0;
+    ev->key = r1;
+    ev->mods = r2;
+    ev->c = r3;
+    return 0;
+}
+/** @}
+ */

 /branches/dd/uspace/lib/libc/generic/task.c
 ,5 → 1,6
 /*
  * Copyright (c) 2006 Jakub Jermar
+ * Copyright (c) 2008 Jiri Svoboda
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,6 → 35,10
 #include <task.h>
 #include <libc.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <loader/loader.h>
+#include <string.h>
 task_id_t task_get_id(void)
 {
 ,5 → 49,74
     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.
+ */
+int task_set_name(const char *name)
+{
+    return __SYSCALL2(SYS_TASK_SET_NAME, (sysarg_t) name, strlen(name));
+}
+/** Create a new task by running an executable from the filesystem.
+ *
+ * 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.
+ */
+task_id_t task_spawn(const char *path, char *const argv[])
+{
+    loader_t *ldr;
+    task_id_t task_id;
+    int rc;
+    /* Connect to a program loader. */
+    ldr = loader_connect();
+    if (ldr == NULL)
+        return 0;
+    /* Get task ID. */
+    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);
+    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 exit */
+error:
+    loader_abort(ldr);
+    free(ldr);
+    return 0;
+}
 /** @}
  */

 /branches/dd/uspace/lib/libc/generic/tls.c
 ,7 → 116,7
     tcb_t *tcb;
     size = ALIGN_UP(size, &_tls_alignment);
-    *data = memalign(&_tls_alignment, sizeof(tcb_t) + size);
+    *data = memalign((uintptr_t) &_tls_alignment, sizeof(tcb_t) + size);
     tcb = (tcb_t *) (*data + size);
     tcb->self = tcb;

 /branches/dd/uspace/lib/libc/generic/console.c
 ,0 → 1,97
+/*
+ * 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 <async.h>
+#include <io/stream.h>
+#include <ipc/console.h>
+#include <console.h>
+void console_clear(void)
+{
+    int cons_phone = get_console_phone();
+    async_msg_0(cons_phone, CONSOLE_CLEAR);
+}
+void console_goto(int row, int col)
+{
+    int cons_phone = get_console_phone();
+    async_msg_2(cons_phone, CONSOLE_GOTO, row, col);
+}
+void console_flush(void)
+{
+    int cons_phone = get_console_phone();
+    async_msg_0(cons_phone, CONSOLE_FLUSH);
+}
+int console_get_size(int *rows, int *cols)
+{
+    int cons_phone = get_console_phone();
+    ipcarg_t r, c;
+    int rc;
+    rc = async_req_0_2(cons_phone, CONSOLE_GETSIZE, &r, &c);
+    *rows = (int) r;
+    *cols = (int) c;
+    return rc;
+}
+void console_set_style(int style)
+{
+    int cons_phone = get_console_phone();
+    async_msg_1(cons_phone, CONSOLE_SET_STYLE, style);
+}
+void console_set_color(int fg_color, int bg_color, int flags)
+{
+    int cons_phone = get_console_phone();
+    async_msg_3(cons_phone, CONSOLE_SET_COLOR, fg_color, bg_color, flags);
+}
+void console_set_rgb_color(int fg_color, int bg_color)
+{
+    int cons_phone = get_console_phone();
+    async_msg_2(cons_phone, CONSOLE_SET_RGB_COLOR, fg_color, bg_color);
+}
+void console_cursor_visibility(int show)
+{
+    int cons_phone = get_console_phone();
+    async_msg_1(cons_phone, CONSOLE_CURSOR_VISIBILITY, show != 0);
+}
+/** @}
+ */

 /branches/dd/uspace/lib/libc/generic/getopt.c
 ,0 → 1,478
+/*  $NetBSD: getopt_long.c,v 1.21.4.1 2008/01/09 01:34:14 matt Exp $    */
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``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 FOUNDATION OR CONTRIBUTORS
+ * 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.
+ */
+/* Ported to HelenOS August 2008 by Tim Post <echo@echoreply.us> */
+#include <assert.h>
+#include <stdarg.h>
+#include <err.h>
+#include <errno.h>
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+/* HelenOS Port : We're incorporating only the modern getopt_long with wrappers
+ * to keep legacy getopt() usage from breaking. All references to REPLACE_GETOPT
+ * are dropped, we just include the code */
+int opterr = 1;     /* if error message should be printed */
+int optind = 1;     /* index into parent argv vector */
+int optopt = '?';       /* character checked for validity */
+int optreset;       /* reset getopt */
+char *optarg;       /* argument associated with option */
+#define IGNORE_FIRST    (*options == '-' || *options == '+')
+#define PRINT_ERROR ((opterr) && ((*options != ':') \
+                      || (IGNORE_FIRST && options[1] != ':')))
+/*HelenOS Port - POSIXLY_CORRECT is always false */
+#define IS_POSIXLY_CORRECT 0
+#define PERMUTE         (!IS_POSIXLY_CORRECT && !IGNORE_FIRST)
+/* XXX: GNU ignores PC if *options == '-' */
+#define IN_ORDER        (!IS_POSIXLY_CORRECT && *options == '-')
+/* return values */
+#define BADCH   (int)'?'
+#define BADARG      ((IGNORE_FIRST && options[1] == ':') \
+             || (*options == ':') ? (int)':' : (int)'?')
+#define INORDER (int)1
+#define EMSG    ""
+static int getopt_internal(int, char **, const char *);
+static int gcd(int, int);
+static void permute_args(int, int, int, char **);
+static const char *place = EMSG; /* option letter processing */
+/* XXX: set optreset to 1 rather than these two */
+static int nonopt_start = -1; /* first non option argument (for permute) */
+static int nonopt_end = -1;   /* first option after non options (for permute) */
+/* Error messages */
+/* HelenOS Port: Calls to warnx() were eliminated (as we have no stderr that
+ * may be redirected) and replaced with printf. As such, error messages now
+ * end in a newline */
+static const char recargchar[] = "option requires an argument -- %c\n";
+static const char recargstring[] = "option requires an argument -- %s\n";
+static const char ambig[] = "ambiguous option -- %.*s\n";
+static const char noarg[] = "option doesn't take an argument -- %.*s\n";
+static const char illoptchar[] = "unknown option -- %c\n";
+static const char illoptstring[] = "unknown option -- %s\n";
+/*
+ * Compute the greatest common divisor of a and b.
+ */
+static int
+gcd(a, b)
+    int a;
+    int b;
+{
+    int c;
+    c = a % b;
+    while (c != 0) {
+        a = b;
+        b = c;
+        c = a % b;
+    }
+    return b;
+}
+/*
+ * Exchange the block from nonopt_start to nonopt_end with the block
+ * from nonopt_end to opt_end (keeping the same order of arguments
+ * in each block).
+ */
+static void
+permute_args(panonopt_start, panonopt_end, opt_end, nargv)
+    int panonopt_start;
+    int panonopt_end;
+    int opt_end;
+    char **nargv;
+{
+    int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
+    char *swap;
+    assert(nargv != NULL);
+    /*
+     * compute lengths of blocks and number and size of cycles
+     */
+    nnonopts = panonopt_end - panonopt_start;
+    nopts = opt_end - panonopt_end;
+    ncycle = gcd(nnonopts, nopts);
+    cyclelen = (opt_end - panonopt_start) / ncycle;
+    for (i = 0; i < ncycle; i++) {
+        cstart = panonopt_end+i;
+        pos = cstart;
+        for (j = 0; j < cyclelen; j++) {
+            if (pos >= panonopt_end)
+                pos -= nnonopts;
+            else
+                pos += nopts;
+            swap = nargv[pos];
+            nargv[pos] = nargv[cstart];
+            nargv[cstart] = swap;
+        }
+    }
+}
+/*
+ * getopt_internal --
+ *  Parse argc/argv argument vector.  Called by user level routines.
+ *  Returns -2 if -- is found (can be long option or end of options marker).
+ */
+static int
+getopt_internal(nargc, nargv, options)
+    int nargc;
+    char **nargv;
+    const char *options;
+{
+    char *oli;              /* option letter list index */
+    int optchar;
+    assert(nargv != NULL);
+    assert(options != NULL);
+    optarg = NULL;
+    /*
+     * XXX Some programs (like rsyncd) expect to be able to
+     * XXX re-initialize optind to 0 and have getopt_long(3)
+     * XXX properly function again.  Work around this braindamage.
+     */
+    if (optind == 0)
+        optind = 1;
+    if (optreset)
+        nonopt_start = nonopt_end = -1;
+start:
+    if (optreset || !*place) {      /* update scanning pointer */
+        optreset = 0;
+        if (optind >= nargc) {          /* end of argument vector */
+            place = EMSG;
+            if (nonopt_end != -1) {
+                /* do permutation, if we have to */
+                permute_args(nonopt_start, nonopt_end,
+                    optind, nargv);
+                optind -= nonopt_end - nonopt_start;
+            }
+            else if (nonopt_start != -1) {
+                /*
+                 * If we skipped non-options, set optind
+                 * to the first of them.
+                 */
+                optind = nonopt_start;
+            }
+            nonopt_start = nonopt_end = -1;
+            return -1;
+        }
+        if ((*(place = nargv[optind]) != '-')
+            || (place[1] == '\0')) {    /* found non-option */
+            place = EMSG;
+            if (IN_ORDER) {
+                /*
+                 * GNU extension:
+                 * return non-option as argument to option 1
+                 */
+                optarg = nargv[optind++];
+                return INORDER;
+            }
+            if (!PERMUTE) {
+                /*
+                 * if no permutation wanted, stop parsing
+                 * at first non-option
+                 */
+                return -1;
+            }
+            /* do permutation */
+            if (nonopt_start == -1)
+                nonopt_start = optind;
+            else if (nonopt_end != -1) {
+                permute_args(nonopt_start, nonopt_end,
+                    optind, nargv);
+                nonopt_start = optind -
+                    (nonopt_end - nonopt_start);
+                nonopt_end = -1;
+            }
+            optind++;
+            /* process next argument */
+            goto start;
+        }
+        if (nonopt_start != -1 && nonopt_end == -1)
+            nonopt_end = optind;
+        if (place[1] && *++place == '-') {  /* found "--" */
+            place++;
+            return -2;
+        }
+    }
+    if ((optchar = (int)*place++) == (int)':' ||
+        (oli = strchr(options + (IGNORE_FIRST ? 1 : 0), optchar)) == NULL) {
+        /* option letter unknown or ':' */
+        if (!*place)
+            ++optind;
+        if (PRINT_ERROR)
+            printf(illoptchar, optchar);
+        optopt = optchar;
+        return BADCH;
+    }
+    if (optchar == 'W' && oli[1] == ';') {      /* -W long-option */
+        /* XXX: what if no long options provided (called by getopt)? */
+        if (*place)
+            return -2;
+        if (++optind >= nargc) {    /* no arg */
+            place = EMSG;
+            if (PRINT_ERROR)
+                printf(recargchar, optchar);
+            optopt = optchar;
+            return BADARG;
+        } else              /* white space */
+            place = nargv[optind];
+        /*
+         * Handle -W arg the same as --arg (which causes getopt to
+         * stop parsing).
+         */
+        return -2;
+    }
+    if (*++oli != ':') {            /* doesn't take argument */
+        if (!*place)
+            ++optind;
+    } else {                /* takes (optional) argument */
+        optarg = NULL;
+        if (*place)         /* no white space */
+            optarg = *place;
+        /* XXX: disable test for :: if PC? (GNU doesn't) */
+        else if (oli[1] != ':') {   /* arg not optional */
+            if (++optind >= nargc) {    /* no arg */
+                place = EMSG;
+                if (PRINT_ERROR)
+                    printf(recargchar, optchar);
+                optopt = optchar;
+                return BADARG;
+            } else
+                optarg = nargv[optind];
+        }
+        place = EMSG;
+        ++optind;
+    }
+    /* dump back option letter */
+    return optchar;
+}
+/*
+ * getopt --
+ *  Parse argc/argv argument vector.
+ */
+int
+getopt(nargc, nargv, options)
+    int nargc;
+    char * const *nargv;
+    const char *options;
+{
+    int retval;
+    assert(nargv != NULL);
+    assert(options != NULL);
+    retval = getopt_internal(nargc, (char **)nargv, options);
+    if (retval == -2) {
+        ++optind;
+        /*
+         * We found an option (--), so if we skipped non-options,
+         * we have to permute.
+         */
+        if (nonopt_end != -1) {
+            permute_args(nonopt_start, nonopt_end, optind,
+                       (char **)nargv);
+            optind -= nonopt_end - nonopt_start;
+        }
+        nonopt_start = nonopt_end = -1;
+        retval = -1;
+    }
+    return retval;
+}
+/*
+ * getopt_long --
+ *  Parse argc/argv argument vector.
+ */
+int
+getopt_long(nargc, nargv, options, long_options, idx)
+    int nargc;
+    char * const *nargv;
+    const char *options;
+    const struct option *long_options;
+    int *idx;
+{
+    int retval;
+#define IDENTICAL_INTERPRETATION(_x, _y)                \
+    (long_options[(_x)].has_arg == long_options[(_y)].has_arg &&    \
+     long_options[(_x)].flag == long_options[(_y)].flag &&      \
+     long_options[(_x)].val == long_options[(_y)].val)
+    assert(nargv != NULL);
+    assert(options != NULL);
+    assert(long_options != NULL);
+    /* idx may be NULL */
+    retval = getopt_internal(nargc, (char **)nargv, options);
+    if (retval == -2) {
+        char *current_argv, *has_equal;
+        size_t current_argv_len;
+        int i, ambiguous, match;
+        current_argv = (char *)place;
+        match = -1;
+        ambiguous = 0;
+        optind++;
+        place = EMSG;
+        if (*current_argv == '\0') {        /* found "--" */
+            /*
+             * We found an option (--), so if we skipped
+             * non-options, we have to permute.
+             */
+            if (nonopt_end != -1) {
+                permute_args(nonopt_start, nonopt_end,
+                    optind, (char **)nargv);
+                optind -= nonopt_end - nonopt_start;
+            }
+            nonopt_start = nonopt_end = -1;
+            return -1;
+        }
+        if ((has_equal = strchr(current_argv, '=')) != NULL) {
+            /* argument found (--option=arg) */
+            current_argv_len = has_equal - current_argv;
+            has_equal++;
+        } else
+            current_argv_len = strlen(current_argv);
+        for (i = 0; long_options[i].name; i++) {
+            /* find matching long option */
+            if (strncmp(current_argv, long_options[i].name,
+                current_argv_len))
+                continue;
+            if (strlen(long_options[i].name) ==
+                (unsigned)current_argv_len) {
+                /* exact match */
+                match = i;
+                ambiguous = 0;
+                break;
+            }
+            if (match == -1)        /* partial match */
+                match = i;
+            else if (!IDENTICAL_INTERPRETATION(i, match))
+                ambiguous = 1;
+        }
+        if (ambiguous) {
+            /* ambiguous abbreviation */
+            if (PRINT_ERROR)
+                printf(ambig, (int)current_argv_len,
+                     current_argv);
+            optopt = 0;
+            return BADCH;
+        }
+        if (match != -1) {          /* option found */
+                if (long_options[match].has_arg == no_argument
+                && has_equal) {
+                if (PRINT_ERROR)
+                    printf(noarg, (int)current_argv_len,
+                         current_argv);
+                /*
+                 * XXX: GNU sets optopt to val regardless of
+                 * flag
+                 */
+                if (long_options[match].flag == NULL)
+                    optopt = long_options[match].val;
+                else
+                    optopt = 0;
+                return BADARG;
+            }
+            if (long_options[match].has_arg == required_argument ||
+                long_options[match].has_arg == optional_argument) {
+                if (has_equal)
+                    optarg = has_equal;
+                else if (long_options[match].has_arg ==
+                    required_argument) {
+                    /*
+                     * optional argument doesn't use
+                     * next nargv
+                     */
+                    optarg = nargv[optind++];
+                }
+            }
+            if ((long_options[match].has_arg == required_argument)
+                && (optarg == NULL)) {
+                /*
+                 * Missing argument; leading ':'
+                 * indicates no error should be generated
+                 */
+                if (PRINT_ERROR)
+                    printf(recargstring, current_argv);
+                /*
+                 * XXX: GNU sets optopt to val regardless
+                 * of flag
+                 */
+                if (long_options[match].flag == NULL)
+                    optopt = long_options[match].val;
+                else
+                    optopt = 0;
+                --optind;
+                return BADARG;
+            }
+        } else {            /* unknown option */
+            if (PRINT_ERROR)
+                printf(illoptstring, current_argv);
+            optopt = 0;
+            return BADCH;
+        }
+        if (long_options[match].flag) {
+            *long_options[match].flag = long_options[match].val;
+            retval = 0;
+        } else
+            retval = long_options[match].val;
+        if (idx)
+            *idx = match;
+    }
+    return retval;
+#undef IDENTICAL_INTERPRETATION
+}

 /branches/dd/uspace/lib/libc/generic/as.c
 ,6 → 85,20
     return __SYSCALL1(SYS_AS_AREA_DESTROY, (sysarg_t ) address);
 }
+/** Change address-space area flags.
+ *
+ * @param address Virtual address pointing into the address space area being
+ *  modified.
+ * @param flags New flags describing type of the area.
+ *
+ * @return Zero on success or a code from @ref errno.h on failure.
+ */
+int as_area_change_flags(void *address, int flags)
+{
+    return __SYSCALL2(SYS_AS_AREA_CHANGE_FLAGS, (sysarg_t) address,
+        (sysarg_t) flags);
+}
 static size_t heapsize = 0;
 static size_t maxheapsize = (size_t) (-1);

 /branches/dd/uspace/lib/libc/generic/pcb.c
 ,0 → 1,40
+/*
+ * 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 <loader/pcb.h>
+pcb_t *__pcb;
+/** @}
+ */

 /branches/dd/uspace/lib/libc/generic/string.c
 ,5 → 1,6
 /*
  * Copyright (c) 2005 Martin Decky
+ * Copyright (c) 2008 Jiri Svoboda
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,96 → 34,16
  */
 #include <string.h>
-#include <unistd.h>
+#include <stdlib.h>
+#include <limits.h>
 #include <ctype.h>
-#include <limits.h>
-#include <align.h>
-#include <sys/types.h>
+#include <malloc.h>
-/* Dummy implementation of mem/ functions */
-void *memset(void *s, int c, size_t n)
-{
-    char *os = s;
-    while (n--)
-        *(os++) = c;
-    return s;
-}
-struct along {
-    unsigned long n;
-} __attribute__ ((packed));
-static void *unaligned_memcpy(void *dst, const void *src, size_t n)
-{
-    int i, j;
-    struct along *adst = dst;
-    const struct along *asrc = src;
-    for (i = 0; i < n / sizeof(unsigned long); i++)
-        adst[i].n = asrc[i].n;
-    for (j = 0; j < n % sizeof(unsigned long); j++)
-        ((unsigned char *) (((unsigned long *) dst) + i))[j] = ((unsigned char *) (((unsigned long *) src) + i))[j];
-    return (char *) src;
-}
-void *memcpy(void *dst, const void *src, size_t n)
-{
-    int i, j;
-    if (((long) dst & (sizeof(long) - 1)) || ((long) src & (sizeof(long) - 1)))
-        return unaligned_memcpy(dst, src, n);
-    for (i = 0; i < n / sizeof(unsigned long); i++)
-        ((unsigned long *) dst)[i] = ((unsigned long *) src)[i];
-    for (j = 0; j < n % sizeof(unsigned long); j++)
-        ((unsigned char *) (((unsigned long *) dst) + i))[j] = ((unsigned char *) (((unsigned long *) src) + i))[j];
-    return (char *) src;
-}
-void *memmove(void *dst, const void *src, size_t n)
-{
-    int i, j;
-    if (src > dst)
-        return memcpy(dst, src, n);
-    for (j = (n % sizeof(unsigned long)) - 1; j >= 0; j--)
-        ((unsigned char *) ((unsigned long *) dst))[j] = ((unsigned char *) ((unsigned long *) src))[j];
-    for (i = n / sizeof(unsigned long) - 1; i >=0 ; i--)
-        ((unsigned long *) dst)[i] = ((unsigned long *) src)[i];
-    return (char *) src;
-}
-/** Compare two memory areas.
+/** Count the number of characters in the string, not including terminating 0.
  *
- * @param s1    Pointer to the first area to compare.
- * @param s2    Pointer to the second area to compare.
- * @param len   Size of the first area in bytes. Both areas must have the same
- *      length.
- * @return  If len is 0, return zero. If the areas match, return zero.
- *      Otherwise return non-zero.
+ * @param str       String.
+ * @return      Number of characters in string.
  */
-int bcmp(const char *s1, const char *s2, size_t len)
-{
-    for (; len && *s1++ == *s2++; len--)
-        ;
-    return len;
-}
-/** Count the number of characters in the string, not including terminating 0.
- * @param str string
- * @return number of characters in string.
- */
 size_t strlen(const char *str)
 {
     size_t counter = 0;
 ,7 → 62,6
         c++;
     return (a[c] - b[c]);
 }
 int strncmp(const char *a, const char *b, size_t n)
 ,10 → 75,22
 }
-/** Return pointer to the first occurence of character c in string
- * @param str scanned string
- * @param c searched character (taken as one byte)
- * @return pointer to the matched character or NULL if it is not found in given string.
+int stricmp(const char *a, const char *b)
+{
+    int c = 0;
+    while (a[c] && b[c] && (!(tolower(a[c]) - tolower(b[c]))))
+        c++;
+    return (tolower(a[c]) - tolower(b[c]));
+}
+/** Return pointer to the first occurence of character c in string.
+ *
+ * @param str       Scanned string.
+ * @param c     Searched character (taken as one byte).
+ * @return      Pointer to the matched character or NULL if it is not
+ *          found in given string.
  */
 char *strchr(const char *str, int c)
 {
 ,10 → 103,12
     return NULL;
 }
-/** Return pointer to the last occurence of character c in string
- * @param str scanned string
- * @param c searched character (taken as one byte)
- * @return pointer to the matched character or NULL if it is not found in given string.
+/** Return pointer to the last occurence of character c in string.
+ *
+ * @param str       Scanned string.
+ * @param c     Searched character (taken as one byte).
+ * @return      Pointer to the matched character or NULL if it is not
+ *          found in given string.
  */
 char *strrchr(const char *str, int c)
 {
 ,13 → 125,16
 /** Convert string to a number.
  * Core of strtol and strtoul functions.
- * @param nptr pointer to string
- * @param endptr if not NULL, function stores here pointer to the first invalid character
- * @param base zero or number between 2 and 36 inclusive
- * @param sgn its set to 1 if minus found
- * @return result of conversion.
+ *
+ * @param nptr      Pointer to string.
+ * @param endptr    If not NULL, function stores here pointer to the first
+ *          invalid character.
+ * @param base      Zero or number between 2 and 36 inclusive.
+ * @param sgn       It's set to 1 if minus found.
+ * @return      Result of conversion.
  */
-static unsigned long _strtoul(const char *nptr, char **endptr, int base, char *sgn)
+static unsigned long
+_strtoul(const char *nptr, char **endptr, int base, char *sgn)
 {
     unsigned char c;
     unsigned long result = 0;
 ,7 → 156,8
             /* FIXME: set errno to EINVAL */
             return 0;
         }
-        if ((base == 16) && (*str == '0') && ((str[1] == 'x') || (str[1] == 'X'))) {
+        if ((base == 16) && (*str == '0') && ((str[1] == 'x') ||
+            (str[1] == 'X'))) {
             str += 2;
         }
     } else {
 ,7 → 176,8
     while (*str) {
         c = *str;
-        c = (c >= 'a' ? c - 'a' + 10 : (c >= 'A' ? c - 'A' + 10 : (c <= '9' ? c - '0' : 0xff)));
+        c = (c >= 'a' ? c - 'a' + 10 : (c >= 'A' ? c - 'A' + 10 :
+            (c <= '9' ? c - '0' : 0xff)));
         if (c > base) {
             break;
         }
 ,7 → 196,10
     }
     if (str == tmpptr) {
-        /* no number was found => first invalid character is the first character of the string */
+        /*
+         * No number was found => first invalid character is the first
+         * character of the string.
+         */
         /* FIXME: set errno to EINVAL */
         str = nptr;
         result = 0;
 ,14 → 217,17
 }
 /** Convert initial part of string to long int according to given base.
- * The number may begin with an arbitrary number of whitespaces followed by optional sign (`+' or `-').
- * If the base is 0 or 16, the prefix `0x' may be inserted and the number will be taken as hexadecimal one.
- * If the base is 0 and the number begin with a zero, number will be taken as octal one (as with base 8).
- * Otherwise the base 0 is taken as decimal.
- * @param nptr pointer to string
- * @param endptr if not NULL, function stores here pointer to the first invalid character
- * @param base zero or number between 2 and 36 inclusive
- * @return result of conversion.
+ * The number may begin with an arbitrary number of whitespaces followed by
+ * optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
+ * inserted and the number will be taken as hexadecimal one. If the base is 0
+ * and the number begin with a zero, number will be taken as octal one (as with
+ * base 8). Otherwise the base 0 is taken as decimal.
+ *
+ * @param nptr      Pointer to string.
+ * @param endptr    If not NULL, function stores here pointer to the first
+ *          invalid character.
+ * @param base      Zero or number between 2 and 36 inclusive.
+ * @return      Result of conversion.
  */
 long int strtol(const char *nptr, char **endptr, int base)
 {
 ,14 → 250,17
 /** Convert initial part of string to unsigned long according to given base.
- * The number may begin with an arbitrary number of whitespaces followed by optional sign (`+' or `-').
- * If the base is 0 or 16, the prefix `0x' may be inserted and the number will be taken as hexadecimal one.
- * If the base is 0 and the number begin with a zero, number will be taken as octal one (as with base 8).
- * Otherwise the base 0 is taken as decimal.
- * @param nptr pointer to string
- * @param endptr if not NULL, function stores here pointer to the first invalid character
- * @param base zero or number between 2 and 36 inclusive
- * @return result of conversion.
+ * The number may begin with an arbitrary number of whitespaces followed by
+ * optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
+ * inserted and the number will be taken as hexadecimal one. If the base is 0
+ * and the number begin with a zero, number will be taken as octal one (as with
+ * base 8). Otherwise the base 0 is taken as decimal.
+ *
+ * @param nptr      Pointer to string.
+ * @param endptr    If not NULL, function stores here pointer to the first
+ *          invalid character
+ * @param base      Zero or number between 2 and 36 inclusive.
+ * @return      Result of conversion.
  */
 unsigned long strtoul(const char *nptr, char **endptr, int base)
 {
 ,5 → 301,48
     return orig;
 }
+char * strdup(const char *s1)
+{
+    size_t len = strlen(s1) + 1;
+    void *ret = malloc(len);
+    if (ret == NULL)
+        return (char *) NULL;
+    return (char *) memcpy(ret, s1, len);
+}
+char *strtok(char *s, const char *delim)
+{
+    static char *next;
+    return strtok_r(s, delim, &next);
+}
+char *strtok_r(char *s, const char *delim, char **next)
+{
+    char *start, *end;
+    if (s == NULL)
+        s = *next;
+    /* Skip over leading delimiters. */
+    while (*s && (strchr(delim, *s) != NULL)) ++s;
+    start = s;
+    /* Skip over token characters. */
+    while (*s && (strchr(delim, *s) == NULL)) ++s;
+    end = s;
+    *next = (*s ? s + 1 : s);
+    if (start == end) {
+        return NULL;    /* No more tokens. */
+    }
+    /* Overwrite delimiter with NULL terminator. */
+    *end = '\0';
+    return start;
+}
 /** @}
  */

 /branches/dd/uspace/lib/libc/generic/loader.c
 ,0 → 1,264
+/*
+ * 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 <ipc/ipc.h>
+#include <ipc/loader.h>
+#include <ipc/services.h>
+#include <libc.h>
+#include <task.h>
+#include <string.h>
+#include <stdlib.h>
+#include <async.h>
+#include <errno.h>
+#include <vfs/vfs.h>
+#include <loader/loader.h>
+/** 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).
+ */
+int loader_spawn(const char *name)
+{
+    return __SYSCALL2(SYS_PROGRAM_SPAWN_LOADER,
+        (sysarg_t) name, strlen(name));
+}
+loader_t *loader_connect(void)
+{
+    loader_t *ldr;
+    int phone_id;
+    phone_id = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_LOAD, 0, 0);
+    if (phone_id < 0)
+        return NULL;
+    ldr = malloc(sizeof(loader_t));
+    if (ldr == NULL)
+        return NULL;
+    ldr->phone_id = phone_id;
+    return ldr;
+}
+/** Get ID of the new task.
+ *
+ * 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.
+ */
+int loader_get_task_id(loader_t *ldr, task_id_t *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));
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        return rc;
+    }
+    async_wait_for(req, &retval);
+    return (int)retval;
+}
+/** Set pathname of the program to load.
+ *
+ * Sets the name of the program file to load. The name can be relative
+ * 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.
+ */
+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);
+    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);
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        return rc;
+    }
+    free(pa);
+    async_wait_for(req, &retval);
+    return (int)retval;
+}
+/** Set command-line arguments for the program.
+ *
+ * Sets the vector of command-line arguments to be passed to the loaded
+ * 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.
+ */
+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;
+    while (*ap != NULL) {
+        buffer_size += strlen(*ap) + 1;
+        ++ap;
+    }
+    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;
+    while (*ap != NULL) {
+        strcpy(dp, *ap);
+        dp += strlen(*ap) + 1;
+        ++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);
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        return rc;
+    }
+    async_wait_for(req, &rc);
+    if (rc != EOK) return rc;
+    /* Free temporary buffer */
+    free(arg_buf);
+    return EOK;
+}
+/** Instruct loader to load the program.
+ *
+ * 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.
+ */
+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;
+}
+/** Instruct loader to execute the program.
+ *
+ * Note that this function blocks until the loader actually replies
+ * so you cannot expect this function to return if you are debugging
+ * the task and its thread is stopped.
+ *
+ * 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.
+ */
+int loader_run(loader_t *ldr)
+{
+    int rc;
+    rc = async_req_0_0(ldr->phone_id, LOADER_RUN);
+    if (rc != EOK)
+        return rc;
+    return EOK;
+}
+/** Cancel the loader session.
+ *
+ * Tells the loader not to load any program and terminate.
+ * 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.
+ */
+void loader_abort(loader_t *ldr)
+{
+    ipc_hangup(ldr->phone_id);
+    ldr->phone_id = 0;
+}
+/** @}
+ */

 /branches/dd/uspace/lib/libc/generic/thread.c
 ,8 → 108,8
     uarg->uspace_thread_arg = arg;
     uarg->uspace_uarg = uarg;
-    rc = __SYSCALL3(SYS_THREAD_CREATE, (sysarg_t) uarg, (sysarg_t) name,
-        (sysarg_t) tid);
+    rc = __SYSCALL4(SYS_THREAD_CREATE, (sysarg_t) uarg, (sysarg_t) name,
+        (sysarg_t) strlen(name), (sysarg_t) tid);
     if (rc) {
         /*

 /branches/dd/uspace/lib/libc/generic/libc.c
 ,28 → 48,41
 #include <ipc/ipc.h>
 #include <async.h>
 #include <as.h>
+#include <loader/pcb.h>
 extern char _heap;
+extern int main(int argc, char *argv[]);
+int _errno;
 void _exit(int status)
 {
     thread_exit(status);
 }
-void __main(void)
+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);
-}
+    /* Save the PCB pointer */
+    __pcb = (pcb_t *)pcb_ptr;
-void __io_init(void)
-{
-    open_stdin();
-    open_stdout();
+    if (__pcb == NULL) {
+        argc = 0;
+        argv = NULL;
+    } else {
+        argc = __pcb->argc;
+        argv = __pcb->argv;
+    }
+    main(argc, argv);
 }
 void __exit(void)

 /branches/dd/uspace/lib/libc/generic/ipc.c
 ,7 → 598,7
     ipcarg_t newphid;
     int res;
-    res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
+    res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
         NULL, NULL, NULL, NULL, &newphid);
     if (res)
         return res;
 ,6 → 605,30
     return newphid;
 }
+/** Ask through phone for a new connection to some service.
+ *
+ * If the connection is not available at the moment, the
+ * call will block.
+ *
+ * @param phoneid   Phone handle used for contacting the other side.
+ * @param arg1      User defined argument.
+ * @param arg2      User defined argument.
+ * @param arg3      User defined argument.
+ *
+ * @return      New phone handle on success or a negative error code.
+ */
+int ipc_connect_me_to_blocking(int phoneid, int arg1, int arg2, int arg3)
+{
+    ipcarg_t newphid;
+    int res;
+    res = ipc_call_sync_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
+        IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid);
+    if (res)
+        return res;
+    return newphid;
+}
 /** Hang up a phone.
  *
  * @param phoneid   Handle of the phone to be hung up.
 ,6 → 690,23
         arg2, mode);
 }
+int ipc_forward_slow(ipc_callid_t callid, int phoneid, int method,
+    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5,
+    int mode)
+{
+    ipc_call_t data;
+    IPC_SET_METHOD(data, method);
+    IPC_SET_ARG1(data, arg1);
+    IPC_SET_ARG2(data, arg2);
+    IPC_SET_ARG3(data, arg3);
+    IPC_SET_ARG4(data, arg4);
+    IPC_SET_ARG5(data, arg5);
+    return __SYSCALL3(SYS_IPC_FORWARD_SLOW, callid, (sysarg_t) &data, mode);
+}
 /** Wrapper for making IPC_M_SHARE_IN calls.
  *
  * @param phoneid   Phone that will be used to contact the receiving side.
 ,7 → 723,7
 {
     int res;
     sysarg_t tmp_flags;
-    res = ipc_call_sync_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
+    res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
         (ipcarg_t) size, arg, NULL, &tmp_flags);
     if (flags)
         *flags = tmp_flags;
 ,7 → 783,7
  */
 int ipc_share_out_start(int phoneid, void *src, int flags)
 {
-    return ipc_call_sync_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
+    return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
         (ipcarg_t) flags);
 }
 ,7 → 844,7
  */
 int ipc_data_read_start(int phoneid, void *dst, size_t size)
 {
-    return ipc_call_sync_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
+    return async_req_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
         (ipcarg_t) size);
 }
 ,7 → 888,7
  *
  * @return      Zero on success or a value from @ref errno.h on failure.
  */
-int ipc_data_read_finalize(ipc_callid_t callid, void *src, size_t size)
+int ipc_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
 {
     return ipc_answer_2(callid, EOK, (ipcarg_t) src, (ipcarg_t) size);
 }
 ,9 → 901,9
  *
  * @return      Zero on success or a negative error code from errno.h.
  */
-int ipc_data_write_start(int phoneid, void *src, size_t size)
+int ipc_data_write_start(int phoneid, const void *src, size_t size)
 {
-    return ipc_call_sync_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
+    return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
         (ipcarg_t) size);
 }
 ,6 → 950,18
 {
     return ipc_answer_2(callid, EOK, (ipcarg_t) dst, (ipcarg_t) size);
 }
+#include <kernel/syscall/sysarg64.h>
+/** Connect to a task specified by id.
+ */
+int ipc_connect_kbox(task_id_t id)
+{
+    sysarg64_t arg;
+    arg.value = (unsigned long long) id;
+    return __SYSCALL1(SYS_IPC_CONNECT_KBOX, (sysarg_t) &arg);
+}
 /** @}
  */

 /branches/dd/uspace/lib/libc/generic/udebug.c
 ,0 → 1,103
+/*
+ * 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 <udebug.h>
+#include <sys/types.h>
+#include <ipc/ipc.h>
+#include <async.h>
+int udebug_begin(int phoneid)
+{
+    return async_req_1_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_BEGIN);
+}
+int udebug_end(int phoneid)
+{
+    return async_req_1_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_END);
+}
+int udebug_set_evmask(int phoneid, udebug_evmask_t mask)
+{
+    return async_req_2_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_SET_EVMASK,
+        mask);
+}
+int udebug_thread_read(int phoneid, void *buffer, size_t n,
+    size_t *copied, size_t *needed)
+{
+    ipcarg_t a_copied, a_needed;
+    int rc;
+    rc = async_req_3_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_THREAD_READ,
+        (sysarg_t)buffer, n, NULL, &a_copied, &a_needed);
+    *copied = (size_t)a_copied;
+    *needed = (size_t)a_needed;
+    return rc;
+}
+int udebug_mem_read(int phoneid, void *buffer, uintptr_t addr, size_t n)
+{
+    return async_req_4_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_MEM_READ,
+        (sysarg_t)buffer, addr, n);
+}
+int udebug_args_read(int phoneid, thash_t tid, sysarg_t *buffer)
+{
+    return async_req_3_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_ARGS_READ,
+        tid, (sysarg_t)buffer);
+}
+int udebug_go(int phoneid, thash_t tid, udebug_event_t *ev_type,
+    sysarg_t *val0, sysarg_t *val1)
+{
+    ipcarg_t a_ev_type;
+    int rc;
+    rc =  async_req_2_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_GO,
+        tid, &a_ev_type, val0, val1);
+    *ev_type = a_ev_type;
+    return rc;
+}
+int udebug_stop(int phoneid, thash_t tid)
+{
+    return async_req_2_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_STOP,
+        tid);
+}
+/** @}
+ */

 /branches/dd/uspace/lib/libc/generic/async.c
 ,7 → 483,7
 {
     connection_t *conn;
     unsigned long key;
     conn = malloc(sizeof(*conn));
     if (!conn) {
         if (callid)
 ,7 → 498,7
         conn->call = *call;
     conn->wdata.active = 1; /* We will activate the fibril ASAP */
     conn->cfibril = cfibril;
     conn->wdata.fid = fibril_create(connection_fibril, conn);
     if (!conn->wdata.fid) {
         free(conn);
 ,14 → 506,15
             ipc_answer_0(callid, ENOMEM);
         return NULL;
     }
     /* Add connection to the connection hash table */
     key = conn->in_phone_hash;
     futex_down(&async_futex);
     hash_table_insert(&conn_hash_table, &key, &conn->link);
     futex_up(&async_futex);
     fibril_add_ready(conn->wdata.fid);
     return conn->wdata.fid;
 }
 ,6 → 525,7
  *
  * @param callid    Hash of the incoming call.
  * @param call      Data of the incoming call.
+ *
  */
 static void handle_call(ipc_callid_t callid, ipc_call_t *call)
 {
 ,8 → 535,8
         (*interrupt_received)(callid, call);
         _in_interrupt_handler = 0;
         return;
-    }
+    }
     switch (IPC_GET_METHOD(*call)) {
     case IPC_M_CONNECT_ME_TO:
         /* Open new connection with fibril etc. */
 ,11 → 544,11
             client_connection);
         return;
     }
     /* Try to route the call through the connection hash table */
     if (route_call(callid, call))
         return;
     /* Unknown call from unknown phone - hang it up */
     ipc_answer_0(callid, EHANGUP);
 }
 ,23 → 741,17
     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr)
 {
     amsg_t *msg;
-    if (_in_interrupt_handler) {
-        printf("Cannot send asynchronous request in interrupt "
-            "handler.\n");
-        _exit(1);
-    }
     msg = malloc(sizeof(*msg));
     msg->done = 0;
     msg->dataptr = dataptr;
     /* We may sleep in the next method, but it will use its own mechanism */
     msg->wdata.active = 1;
     ipc_call_async_4(phoneid, method, arg1, arg2, arg3, arg4, msg,
-        reply_received, 1);
+        reply_received, !_in_interrupt_handler);
     return (aid_t) msg;
 }
 ,23 → 777,17
     ipc_call_t *dataptr)
 {
     amsg_t *msg;
-    if (_in_interrupt_handler) {
-        printf("Cannot send asynchronous request in interrupt "
-            "handler.\n");
-        _exit(1);
-    }
     msg = malloc(sizeof(*msg));
     msg->done = 0;
     msg->dataptr = dataptr;
     /* We may sleep in next method, but it will use its own mechanism */
     msg->wdata.active = 1;
     ipc_call_async_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, msg,
-        reply_received, 1);
+        reply_received, !_in_interrupt_handler);
     return (aid_t) msg;
 }
 ,21 → 874,16
 {
     amsg_t *msg;
-    if (_in_interrupt_handler) {
-        printf("Cannot call async_usleep in interrupt handler.\n");
-        _exit(1);
-    }
     msg = malloc(sizeof(*msg));
     if (!msg)
         return;
     msg->wdata.fid = fibril_get_id();
     msg->wdata.active = 0;
     gettimeofday(&msg->wdata.expires, NULL);
     tv_add(&msg->wdata.expires, timeout);
     futex_down(&async_futex);
     insert_timeout(&msg->wdata);
     /* Leave the async_futex locked when entering this function */
 ,4 → 997,3
 /** @}
  */

 /branches/dd/uspace/lib/libc/generic/vfs/vfs.c
 ,7 → 31,7
  */
 /** @file
  */
 #include <vfs/vfs.h>
 #include <vfs/canonify.h>
 #include <stdlib.h>
 ,7 → 48,8
 #include <futex.h>
 #include <errno.h>
 #include <string.h>
-#include "../../srv/vfs/vfs.h"
+#include <ipc/devmap.h>
+#include "../../../srv/vfs/vfs.h"
 int vfs_phone = -1;
 futex_t vfs_phone_futex = FUTEX_INITIALIZER;
 ,11 → 57,12
 futex_t cwd_futex = FUTEX_INITIALIZER;
 DIR *cwd_dir = NULL;
 char *cwd_path = NULL;
-size_t cwd_len = 0;
+size_t cwd_len = 0;
-static char *absolutize(const char *path, size_t *retlen)
+char *absolutize(const char *path, size_t *retlen)
 {
     char *ncwd_path;
+    char *ncwd_path_nc;
     futex_down(&cwd_futex);
     size_t len = strlen(path);
 ,65 → 71,112
             futex_up(&cwd_futex);
             return NULL;
         }
-        ncwd_path = malloc(len + cwd_len + 1);
-        if (!ncwd_path) {
+        ncwd_path_nc = malloc(cwd_len + 1 + len + 1);
+        if (!ncwd_path_nc) {
             futex_up(&cwd_futex);
             return NULL;
         }
-        strcpy(ncwd_path, cwd_path);
-        ncwd_path[cwd_len] = '/';
-        ncwd_path[cwd_len + 1] = '\0';
+        strcpy(ncwd_path_nc, cwd_path);
+        ncwd_path_nc[cwd_len] = '/';
+        ncwd_path_nc[cwd_len + 1] = '\0';
     } else {
-        ncwd_path = malloc(len + 1);
-        if (!ncwd_path) {
+        ncwd_path_nc = malloc(len + 1);
+        if (!ncwd_path_nc) {
             futex_up(&cwd_futex);
             return NULL;
         }
-        ncwd_path[0] = '\0';
+        ncwd_path_nc[0] = '\0';
     }
-    strcat(ncwd_path, path);
-    if (!canonify(ncwd_path, retlen)) {
+    strcat(ncwd_path_nc, path);
+    ncwd_path = canonify(ncwd_path_nc, retlen);
+    if (!ncwd_path) {
         futex_up(&cwd_futex);
-        free(ncwd_path);
+        free(ncwd_path_nc);
         return NULL;
     }
+    /*
+     * We need to clone ncwd_path because canonify() works in-place and thus
+     * the address in ncwd_path need not be the same as ncwd_path_nc, even
+     * though they both point into the same dynamically allocated buffer.
+     */
+    ncwd_path = strdup(ncwd_path);
+    free(ncwd_path_nc);
+    if (!ncwd_path) {
+        futex_up(&cwd_futex);
+        return NULL;
+    }
     futex_up(&cwd_futex);
     return ncwd_path;
 }
-static int vfs_connect(void)
+static void vfs_connect(void)
 {
-    if (vfs_phone < 0)
-        vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
-    return vfs_phone;
+    while (vfs_phone < 0)
+        vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
 }
-int mount(const char *fs_name, const char *mp, const char *dev)
+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, strlen(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 unsigned int flags)
+{
     int res;
     ipcarg_t rc;
     aid_t req;
-    dev_handle_t dev_handle = 0;    /* TODO */
+    dev_handle_t dev_handle;
+    res = device_get_handle(dev, &dev_handle, flags);
+    if (res != EOK)
+        return res;
     size_t mpa_len;
     char *mpa = absolutize(mp, &mpa_len);
     if (!mpa)
         return ENOMEM;
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            free(mpa);
-            return res;
-        }
-    }
-    req = async_send_1(vfs_phone, VFS_MOUNT, dev_handle, NULL);
-    rc = ipc_data_write_start(vfs_phone, (void *)fs_name, strlen(fs_name));
+    vfs_connect();
+    req = async_send_2(vfs_phone, VFS_MOUNT, dev_handle, flags, NULL);
+    rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_len);
     if (rc != EOK) {
         async_wait_for(req, NULL);
         async_serialize_end();
 ,7 → 184,8
         free(mpa);
         return (int) rc;
     }
-    rc = ipc_data_write_start(vfs_phone, (void *)mpa, mpa_len);
+    rc = ipc_data_write_start(vfs_phone, (void *) fs_name, strlen(fs_name));
     if (rc != EOK) {
         async_wait_for(req, NULL);
         async_serialize_end();
 ,16 → 193,17
         free(mpa);
         return (int) rc;
     }
     async_wait_for(req, &rc);
     async_serialize_end();
     futex_up(&vfs_phone_futex);
     free(mpa);
     return (int) rc;
 }
 static int _open(const char *path, int lflag, int oflag, ...)
 {
-    int res;
     ipcarg_t rc;
     ipc_call_t answer;
     aid_t req;
 ,15 → 215,8
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            free(pa);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);
     rc = ipc_data_write_start(vfs_phone, pa, pa_len);
     if (rc != EOK) {
 ,6 → 230,9
     async_serialize_end();
     futex_up(&vfs_phone_futex);
     free(pa);
+    if (rc != EOK)
+        return (int) rc;
     return (int) IPC_GET_ARG1(answer);
 }
 ,22 → 243,14
 int close(int fildes)
 {
-    int res;
     ipcarg_t rc;
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            return res;
-        }
-    }
+    vfs_connect();
     rc = async_req_1_0(vfs_phone, VFS_CLOSE, fildes);
     async_serialize_end();
     futex_up(&vfs_phone_futex);
 ,7 → 259,6
 ssize_t read(int fildes, void *buf, size_t nbyte)
 {
-    int res;
     ipcarg_t rc;
     ipc_call_t answer;
     aid_t req;
 ,14 → 265,8
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_1(vfs_phone, VFS_READ, fildes, &answer);
     rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
     if (rc != EOK) {
 ,12 → 281,11
     if (rc == EOK)
         return (ssize_t) IPC_GET_ARG1(answer);
     else
-        return -1;
+        return rc;
 }
 ssize_t write(int fildes, const void *buf, size_t nbyte)
 {
-    int res;
     ipcarg_t rc;
     ipc_call_t answer;
     aid_t req;
 ,14 → 292,8
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_1(vfs_phone, VFS_WRITE, fildes, &answer);
     rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
     if (rc != EOK) {
 ,23 → 313,15
 off_t lseek(int fildes, off_t offset, int whence)
 {
-    int res;
     ipcarg_t rc;
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            return res;
-        }
-    }
-    off_t newoffs;
+    vfs_connect();
+    ipcarg_t newoffs;
     rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence,
-        (ipcarg_t)&newoffs);
+        &newoffs);
     async_serialize_end();
     futex_up(&vfs_phone_futex);
 ,24 → 329,17
     if (rc != EOK)
         return (off_t) -1;
-    return newoffs;
+    return (off_t) newoffs;
 }
 int ftruncate(int fildes, off_t length)
 {
-    int res;
     ipcarg_t rc;
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            return res;
-        }
-    }
+    vfs_connect();
     rc = async_req_2_0(vfs_phone, VFS_TRUNCATE, fildes, length);
     async_serialize_end();
     futex_up(&vfs_phone_futex);
 ,7 → 381,6
 int mkdir(const char *path, mode_t mode)
 {
-    int res;
     ipcarg_t rc;
     aid_t req;
 ,18 → 388,11
     char *pa = absolutize(path, &pa_len);
     if (!pa)
         return ENOMEM;
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            free(pa);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL);
     rc = ipc_data_write_start(vfs_phone, pa, pa_len);
     if (rc != EOK) {
 ,7 → 411,6
 static int _unlink(const char *path, int lflag)
 {
-    int res;
     ipcarg_t rc;
     aid_t req;
 ,15 → 421,8
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            free(pa);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_0(vfs_phone, VFS_UNLINK, NULL);
     rc = ipc_data_write_start(vfs_phone, pa, pa_len);
     if (rc != EOK) {
 ,7 → 451,6
 int rename(const char *old, const char *new)
 {
-    int res;
     ipcarg_t rc;
     aid_t req;
 ,16 → 468,8
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            free(olda);
-            free(newa);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_0(vfs_phone, VFS_RENAME, NULL);
     rc = ipc_data_write_start(vfs_phone, olda, olda_len);
     if (rc != EOK) {
 ,6 → 522,7
     cwd_path = pa;
     cwd_len = pa_len;
     futex_up(&cwd_futex);
+    return EOK;
 }
 char *getcwd(char *buf, size_t size)

/branches/dd/uspace/lib/libc/generic/vfs/canonify.c
36,6 → 36,7
*/

#include <stdlib.h>
#include <vfs/canonify.h>

/** Token types used for tokenization of path. */
typedef enum {
125,6 → 126,7
static void set_first_slash(token_t t, token_t tfsl, token_t *tlcomp)
{
tfsl = t;
tlcomp = t;
}
static void save_component(token_t t, token_t tfsl, token_t *tlcomp)
{

 /branches/dd/uspace/lib/libc/generic/mem.c
 ,0 → 1,239
+/*
+ * Copyright (c) 2005 Martin Decky
+ * 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 <mem.h>
+#include <stdlib.h>
+#include <sys/types.h>
+/** Fill memory block with a constant value. */
+void *memset(void *dest, int b, size_t n)
+{
+    char *pb;
+    unsigned long *pw;
+    size_t word_size;
+    size_t n_words;
+    unsigned long pattern;
+    size_t i;
+    size_t fill;
+    /* Fill initial segment. */
+    word_size = sizeof(unsigned long);
+    fill = word_size - ((uintptr_t) dest & (word_size - 1));
+    if (fill > n) fill = n;
+    pb = dest;
+    i = fill;
+    while (i-- != 0)
+        *pb++ = b;
+    /* Compute remaining size. */
+    n -= fill;
+    if (n == 0) return dest;
+    n_words = n / word_size;
+    n = n % word_size;
+    pw = (unsigned long *) pb;
+    /* Create word-sized pattern for aligned segment. */
+    pattern = 0;
+    i = word_size;
+    while (i-- != 0)
+        pattern = (pattern << 8) | (uint8_t) b;
+    /* Fill aligned segment. */
+    i = n_words;
+    while (i-- != 0)
+        *pw++ = pattern;
+    pb = (char *) pw;
+    /* Fill final segment. */
+    i = n;
+    while (i-- != 0)
+        *pb++ = b;
+    return dest;
+}
+struct along {
+    unsigned long n;
+} __attribute__ ((packed));
+static void *unaligned_memcpy(void *dst, const void *src, size_t n)
+{
+    int i, j;
+    struct along *adst = dst;
+    const struct along *asrc = src;
+    for (i = 0; i < n / sizeof(unsigned long); i++)
+        adst[i].n = asrc[i].n;
+    for (j = 0; j < n % sizeof(unsigned long); j++)
+        ((unsigned char *) (((unsigned long *) dst) + i))[j] =
+            ((unsigned char *) (((unsigned long *) src) + i))[j];
+    return (char *) dst;
+}
+/** Copy memory block. */
+void *memcpy(void *dst, const void *src, size_t n)
+{
+    size_t i;
+    size_t mod, fill;
+    size_t word_size;
+    size_t n_words;
+    const unsigned long *srcw;
+    unsigned long *dstw;
+    const uint8_t *srcb;
+    uint8_t *dstb;
+    word_size = sizeof(unsigned long);
+    /*
+     * Are source and destination addresses congruent modulo word_size?
+     * If not, use unaligned_memcpy().
+     */
+    if (((uintptr_t) dst & (word_size - 1)) !=
+        ((uintptr_t) src & (word_size - 1)))
+        return unaligned_memcpy(dst, src, n);
+    /*
+     * mod is the address modulo word size. fill is the length of the
+     * initial buffer segment before the first word boundary.
+     * If the buffer is very short, use unaligned_memcpy(), too.
+     */
+    mod = (uintptr_t) dst & (word_size - 1);
+    fill = word_size - mod;
+    if (fill > n) fill = n;
+    /* Copy the initial segment. */
+    srcb = src;
+    dstb = dst;
+    i = fill;
+    while (i-- != 0)
+        *dstb++ = *srcb++;
+    /* Compute remaining length. */
+    n -= fill;
+    if (n == 0) return dst;
+    /* Pointers to aligned segment. */
+    dstw = (unsigned long *) dstb;
+    srcw = (const unsigned long *) srcb;
+    n_words = n / word_size;    /* Number of whole words to copy. */
+    n -= n_words * word_size;   /* Remaining bytes at the end. */
+    /* "Fast" copy. */
+    i = n_words;
+    while (i-- != 0)
+        *dstw++ = *srcw++;
+    /*
+     * Copy the rest.
+     */
+    srcb = (const uint8_t *) srcw;
+    dstb = (uint8_t *) dstw;
+    i = n;
+    while (i-- != 0)
+        *dstb++ = *srcb++;
+    return dst;
+}
+/** Move memory block with possible overlapping. */
+void *memmove(void *dst, const void *src, size_t n)
+{
+    const uint8_t *sp;
+    uint8_t *dp;
+    /* Nothing to do? */
+    if (src == dst)
+        return dst;
+    /* Non-overlapping? */
+    if (dst >= src + n || src >= dst + n) {
+        return memcpy(dst, src, n);
+    }
+    /* Which direction? */
+    if (src > dst) {
+        /* Forwards. */
+        sp = src;
+        dp = dst;
+        while (n-- != 0)
+            *dp++ = *sp++;
+    } else {
+        /* Backwards. */
+        sp = src + (n - 1);
+        dp = dst + (n - 1);
+        while (n-- != 0)
+            *dp-- = *sp--;
+    }
+    return dst;
+}
+/** Compare two memory areas.
+ *
+ * @param s1        Pointer to the first area to compare.
+ * @param s2        Pointer to the second area to compare.
+ * @param len       Size of the first area in bytes. Both areas must have
+ *          the same length.
+ * @return      If len is 0, return zero. If the areas match, return
+ *          zero. Otherwise return non-zero.
+ */
+int bcmp(const char *s1, const char *s2, size_t len)
+{
+    for (; len && *s1++ == *s2++; len--)
+        ;
+    return len;
+}
+/** @}
+ */
 Property changes:
 Added: svn:mergeinfo

 /branches/dd/uspace/lib/libc/generic/smc.c
 ,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
+ */
+#include <libc.h>
+#include <sys/types.h>
+#include <smc.h>
+int smc_coherence(void *address, size_t size)
+{
+    return __SYSCALL2(SYS_SMC_COHERENCE, (sysarg_t) address,
+        (sysarg_t) size);
+}
+/** @}
+ */

 /branches/dd/uspace/lib/libc/generic/io/stdio.c
 ,0 → 1,278
+/*
+ * 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
+ * @brief ANSI C Stream I/O.
+ */
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <bool.h>
+#include <stdio.h>
+FILE *stdin, *stdout, *stderr;
+/**
+ * Open a stream.
+ *
+ * @param file_name Name of the file to open.
+ * @param mode      Mode string, (r|w|a)[b|t][+].
+ */
+FILE *fopen(const char *file_name, const char *mode)
+{
+    FILE *f;
+    int flags;
+    bool plus;
+    const char *mp;
+    /* Parse mode except first character. */
+    mp = mode;
+    if (*mp++ == '\0') {
+        errno = EINVAL;
+        return NULL;
+    }
+    if (*mp == 'b' || *mp == 't') ++mp;
+    if (*mp == '+') {
+        ++mp;
+        plus = true;
+    } else {
+        plus = false;
+    }
+    if (*mp != '\0') {
+        errno = EINVAL;
+        return NULL;
+    }
+    /* 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 NULL;
+        }
+        flags = (O_APPEND | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
+    default:
+        errno = EINVAL;
+        return NULL;
+    }
+    /* Open file. */
+    f = malloc(sizeof(FILE));
+    if (f == NULL) {
+        errno = ENOMEM;
+        return NULL;
+    }
+    f->fd = open(file_name, flags, 0666);
+    if (f->fd < 0) {
+        free(f);
+        return NULL; /* errno was set by open() */
+    }
+    f->error = 0;
+    f->eof = 0;
+    return f;
+}
+/** Close a stream.
+ *
+ * @param f Pointer to stream.
+ * @return  0 on success, EOF on error.
+ */
+int fclose(FILE *f)
+{
+    int rc;
+    rc = close(f->fd);
+    free(f);
+    if (rc != 0)
+        return EOF; /* errno was set by close() */
+    return 0;
+}
+/** Read from a stream.
+ *
+ * @param buf   Destination buffer.
+ * @param size  Size of each record.
+ * @param nmemb Number of records to read.
+ * @param f Pointer to the stream.
+ */
+size_t fread(void *buf, size_t size, size_t nmemb, FILE *f)
+{
+    size_t left, done, n;
+    left = size * nmemb;
+    done = 0;
+    while (left > 0 && !f->error && !f->eof) {
+        n = read(f->fd, buf + done, left);
+        if (n < 0) {
+            f->error = 1;
+        } else if (n == 0) {
+            f->eof = 1;
+        } else {
+            left -= n;
+            done += n;
+        }
+    }
+    return done / size;
+}
+/** Write to a stream.
+ *
+ * @param buf   Source buffer.
+ * @param size  Size of each record.
+ * @param nmemb Number of records to write.
+ * @param f Pointer to the stream.
+ */
+size_t fwrite(const void *buf, size_t size, size_t nmemb, FILE *f)
+{
+    size_t left, done, n;
+    left = size * nmemb;
+    done = 0;
+    while (left > 0 && !f->error) {
+        n = write(f->fd, buf + done, left);
+        if (n <= 0) {
+            f->error = 1;
+        } else {
+            left -= n;
+            done += n;
+        }
+    }
+    return done / size;
+}
+/** Return the end-of-file indicator of a stream. */
+int feof(FILE *f)
+{
+    return f->eof;
+}
+/** Return the error indicator of a stream. */
+int ferror(FILE *f)
+{
+    return f->error;
+}
+/** Clear the error and end-of-file indicators of a stream. */
+void clearerr(FILE *f)
+{
+    f->eof = 0;
+    f->error = 0;
+}
+/** Read character from a stream. */
+int fgetc(FILE *f)
+{
+    unsigned char c;
+    size_t n;
+    n = fread(&c, sizeof(c), 1, f);
+    if (n < 1) return EOF;
+    return (int) c;
+}
+/** Write character to a stream. */
+int fputc(int c, FILE *f)
+{
+    unsigned char cc;
+    size_t n;
+    cc = (unsigned char) c;
+    n = fwrite(&cc, sizeof(cc), 1, f);
+    if (n < 1) return EOF;
+    return (int) cc;
+}
+/** Write string to a stream. */
+int fputs(const char *s, FILE *f)
+{
+    int rc;
+    rc = 0;
+    while (*s && rc >= 0) {
+        rc = fputc(*s++, f);
+    }
+    if (rc < 0) return EOF;
+    return 0;
+}
+/** Seek to position in stream. */
+int fseek(FILE *f, long offset, int origin)
+{
+    off_t rc;
+    rc = lseek(f->fd, offset, origin);
+    if (rc == (off_t) (-1)) {
+        /* errno has been set by lseek. */
+        return -1;
+    }
+    f->eof = 0;
+    return 0;
+}
+/** @}
+ */

/branches/dd/uspace/lib/libc/generic/io/sprintf.c
48,7 → 48,6

va_start(args, fmt);
ret = vsprintf(str, fmt, args);

va_end(args);

return ret;

 /branches/dd/uspace/lib/libc/generic/io/asprintf.c
 ,0 → 1,79
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * 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
+ */
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <io/printf_core.h>
+static int asprintf_prewrite(const char *str, size_t count, void *unused)
+{
+    return 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.
+ *
+ * @return      Number of characters printed or a negative error code.
+ */
+int asprintf(char **strp, const char *fmt, ...)
+{
+    struct printf_spec ps = {
+         asprintf_prewrite,
+         NULL
+    };
+    int ret;
+    va_list args;
+    va_start(args, fmt);
+    ret = printf_core(fmt, &ps, args);
+    va_end(args);
+    if (ret > 0) {
+        *strp = malloc(ret + 20);
+        if (!*strp)
+            return -1;
+        va_start(args, fmt);
+        vsprintf(*strp, fmt, args);
+        va_end(args);
+    }
+    return ret;
+}
+/** @}
+ */

 /branches/dd/uspace/lib/libc/generic/io/fprintf.c
 ,0 → 1,69
+/*
+ * 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
+ * @brief fprintf, vfprintf
+ */
+#include <stdio.h>
+#include <sys/types.h>
+#include <io/printf_core.h>
+static int vfprintf_write(const char *s, size_t count, void *f)
+{
+    return fwrite(s, 1, count, (FILE *) f);
+}
+int vfprintf(FILE *f, const char *fmt, va_list ap)
+{
+    struct printf_spec ps = {
+        (int (*)(void *, size_t, void *)) vfprintf_write,
+        (void *) f
+    };
+    return printf_core(fmt, &ps, ap);
+}
+int fprintf(FILE *f, const char *fmt, ...)
+{
+    int rv;
+    va_list args;
+    va_start(args, fmt);
+    rv = vfprintf(f, fmt, args);
+    va_end(args);
+    return rv;
+}
+/** @}
+ */

 /branches/dd/uspace/lib/libc/generic/io/vsnprintf.c
 ,22 → 38,27
 #include <io/printf_core.h>
 struct vsnprintf_data {
-    size_t size; /* total space for string */
-    size_t len; /* count of currently used characters */
-    char *string; /* destination string */
+    size_t size;    /* total space for string */
+    size_t len; /* count of currently used characters */
+    char *string;   /* destination string */
 };
 /** Write string to given buffer.
- * Write at most data->size characters including trailing zero. According to C99 has snprintf to return number
- * of characters that would have been written if enough space had been available. Hence the return value is not
- * number of really printed characters but size of input string. Number of really used characters
- * is stored in data->len.
- * @param str source string to print
- * @param count size of source string
- * @param data structure with destination string, counter of used space and total string size.
- * @return number of characters to print (not characters really printed!)
+ * Write at most data->size characters including trailing zero. According to C99
+ * has snprintf to return number of characters that would have been written if
+ * enough space had been available. Hence the return value is not number of
+ * really printed characters but size of input string. Number of really used
+ * characters is stored in data->len.
+ *
+ * @param str       Source string to print.
+ * @param count     Size of the source string.
+ * @param data      Structure with destination string, counter of used space
+ *          and total string size.
+ * @return      Number of characters to print (not characters really
+ *          printed!)
  */
-static int vsnprintf_write(const char *str, size_t count, struct vsnprintf_data *data)
+static int
+vsnprintf_write(const char *str, size_t count, struct vsnprintf_data *data)
 {
     size_t i;
     i = data->size - data->len;
 ,7 → 68,10
     }
     if (i == 1) {
-        /* We have only one free byte left in buffer => write there trailing zero */
+        /*
+         * We have only one free byte left in buffer => write there
+         * trailing zero.
+         */
         data->string[data->size - 1] = 0;
         data->len = data->size;
         return count;
 ,17 → 78,23
     }
     if (i <= count) {
-        /* We have not enought space for whole string with the trailing zero => print only a part of string */
-            memcpy((void *)(data->string + data->len), (void *)str, i - 1);
-            data->string[data->size - 1] = 0;
-            data->len = data->size;
-            return count;
+        /*
+         * We have not enought space for whole string with the trailing
+         * zero => print only a part of string.
+         */
+        memcpy((void *)(data->string + data->len), (void *)str, i - 1);
+        data->string[data->size - 1] = 0;
+        data->len = data->size;
+        return count;
     }
     /* Buffer is big enought to print whole string */
     memcpy((void *)(data->string + data->len), (void *)str, count);
     data->len += count;
-    /* Put trailing zero at end, but not count it into data->len so it could be rewritten next time */
+    /*
+     * Put trailing zero at end, but not count it into data->len so it could
+     * be rewritten next time.
+     */
     data->string[data->len] = 0;
     return count;
 ,17 → 101,22
 }
 /** 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      Bffer size.
+ * @param fmt       Format string.
  * \see For more details about format string see printf_core.
  */
 int vsnprintf(char *str, size_t size, const char *fmt, va_list ap)
 {
     struct vsnprintf_data data = {size, 0, str};
-    struct printf_spec ps = {(int(*)(void *, size_t, void *)) vsnprintf_write, &data};
+    struct printf_spec ps = {
+        (int(*)(void *, size_t, void *)) vsnprintf_write,
+        &data
+    };
-    /* Print 0 at end of string - fix the case that nothing will be printed */
+    /*
+     * Print 0 at end of string - fix the case that nothing will be printed.
+     */
     if (size > 0)
         str[0] = 0;

 /branches/dd/uspace/lib/libc/generic/io/printf_core.c
 ,12 → 94,9
     if (str == NULL)
         return printf_putnchars("(NULL)", 6, ps);
-    for (count = 0; str[count] != 0; count++);
+    count = strlen(str);
-    if (ps->write((void *) str, count, ps->data) == count)
-        return 0;
-    return EOF;
+    return ps->write((void *) str, count, ps->data);
 }
 /** Print one character to output

 /branches/dd/uspace/lib/libc/generic/io/stream.c
 ,7 → 42,8
 #include <ipc/ns.h>
 #include <ipc/fb.h>
 #include <ipc/services.h>
-#include <console.h>
+#include <ipc/console.h>
+#include <kbd/kbd.h>
 #include <unistd.h>
 #include <async.h>
 #include <sys/types.h>
 ,54 → 57,77
 ssize_t read_stdin(void *buf, size_t count)
 {
-    ipcarg_t r0, r1;
-    size_t i = 0;
+    open_console();
+    if (console_phone >= 0) {
+        kbd_event_t ev;
+        int rc;
+        size_t i = 0;
+        while (i < count) {
+            do {
+                rc = kbd_get_event(&ev);
+                if (rc < 0) return -1;
+            } while (ev.c == 0 || ev.type == KE_RELEASE);
-    while (i < count) {
-        if (async_req_0_2(console_phone, CONSOLE_GETCHAR, &r0,
-            &r1) < 0) {
-            return -1;
+            ((char *) buf)[i++] = ev.c;
         }
-        ((char *) buf)[i++] = r0;
+        return i;
+    } else {
+        return -1;
     }
-    return i;
 }
 ssize_t write_stdout(const void *buf, size_t count)
 {
-    int i;
-    for (i = 0; i < count; i++)
-        async_msg_1(console_phone, CONSOLE_PUTCHAR,
-            ((const char *) buf)[i]);
+    open_console();
+    if (console_phone >= 0) {
+        int i;
-    return count;
+        for (i = 0; i < count; i++)
+            async_msg_1(console_phone, CONSOLE_PUTCHAR,
+                ((const char *) buf)[i]);
+        return count;
+    } else
+        return __SYSCALL3(SYS_KLOG, 1, (sysarg_t) buf, count);
 }
-void open_stdin(void)
+void open_console(void)
 {
     if (console_phone < 0) {
-        while ((console_phone = ipc_connect_me_to(PHONE_NS,
-            SERVICE_CONSOLE, 0, 0)) < 0) {
-            usleep(10000);
-        }
+        int phone = ipc_connect_me_to(PHONE_NS, SERVICE_CONSOLE, 0, 0);
+        if (phone >= 0)
+            console_phone = phone;
     }
 }
-void open_stdout(void)
+void close_console(void)
 {
-    if (console_phone < 0) {
-        while ((console_phone = ipc_connect_me_to(PHONE_NS,
-            SERVICE_CONSOLE, 0, 0)) < 0) {
-            usleep(10000);
+    if (console_phone >= 0) {
+        if (ipc_hangup(console_phone) == 0) {
+            console_phone = -1;
         }
     }
 }
-int get_cons_phone(void)
+void klog_update(void)
 {
+    (void) __SYSCALL3(SYS_KLOG, 1, NULL, 0);
+}
+int get_console_phone(void)
+{
+    if (console_phone < 0)
+        console_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_CONSOLE, 0, 0);
     return console_phone;
 }
+void console_wait(void)
+{
+    while (console_phone < 0)
+        get_console_phone();
+}
 /** @}
  */

 /branches/dd/uspace/lib/libc/Makefile
 ,7 → 31,6
 LIBC_PREFIX = $(shell pwd)
 SOFTINT_PREFIX = ../softint
-CONSOLE_PREFIX = ../../srv/console
 ## Setup toolchain
 #
 ,25 → 37,30
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS += -I$(CONSOLE_PREFIX)
 ## Sources
 #
 GENERIC_SOURCES = \
     generic/libc.c \
     generic/ddi.c \
     generic/as.c \
     generic/cap.c \
+    generic/console.c \
+    generic/mem.c \
     generic/string.c \
     generic/fibril.c \
+    generic/pcb.c \
+    generic/smc.c \
     generic/thread.c \
     generic/tls.c \
     generic/task.c \
     generic/futex.c \
+    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/snprintf.c \
 ,44 → 72,49
     generic/sysinfo.c \
     generic/ipc.c \
     generic/async.c \
+    generic/loader.c \
+    generic/getopt.c \
     generic/libadt/list.o \
     generic/libadt/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 \
     generic/vfs/canonify.c
 ARCH_SOURCES += \
-    arch/$(ARCH)/src/entry.s \
-    arch/$(ARCH)/src/thread_entry.s
+    arch/$(UARCH)/src/entry.s \
+    arch/$(UARCH)/src/thread_entry.s
 GENERIC_OBJECTS := $(addsuffix .o,$(basename $(GENERIC_SOURCES)))
 ARCH_OBJECTS := $(addsuffix .o,$(basename $(ARCH_SOURCES)))
+OBJECTS := $(GENERIC_OBJECTS) $(ARCH_OBJECTS)
 .PHONY: all clean depend kerninc
-all: kerninc libc.a arch/$(ARCH)/_link.ld
+all: kerninc libc.a arch/$(UARCH)/_link.ld
 kerninc:
     ln -sfn ../../../../kernel/generic/include include/kernel
     ln -sfn kernel/arch include/arch
-    ln -sfn ../arch/$(ARCH)/include include/libarch
+    ln -sfn ../arch/$(UARCH)/include include/libarch
 -include Makefile.depend
 clean:
-    -rm -f include/kernel include/arch include/libarch libc.a arch/$(ARCH)/_link.ld Makefile.depend
-    find generic/ arch/$(ARCH)/ -name '*.o' -follow -exec rm \{\} \;
+    -rm -f include/kernel include/arch include/libarch libc.a arch/$(UARCH)/_link.ld Makefile.depend
+    find generic/ arch/$(UARCH)/ malloc -name '*.o' -follow -exec rm \{\} \;
 depend: kerninc
-    -makedepend $(DEFS) $(CFLAGS) -f - $(ARCH_SOURCES) $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend -f - -- $(DEPEND_DEFS) $(CFLAGS) -- $(ARCH_SOURCES) $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
 libc.a: depend $(ARCH_OBJECTS) $(GENERIC_OBJECTS)
     $(AR) rc libc.a $(LIBS) $(ARCH_OBJECTS) $(GENERIC_OBJECTS)
-arch/$(ARCH)/_link.ld: arch/$(ARCH)/_link.ld.in
+arch/$(UARCH)/_link.ld: arch/$(UARCH)/_link.ld.in
     $(CC) $(DEFS) $(CFLAGS) -DLIBC_PREFIX=$(LIBC_PREFIX) -E -x c $< | grep -v "^\#" > $@
 %.o: %.S

/branches/dd/uspace/lib/libc/arch/sparc64/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

 /branches/dd/uspace/lib/libc/arch/sparc64/include/syscall.h
 ,6 → 38,14
 #include <sys/types.h>
 #include <kernel/syscall/syscall.h>
+#define __syscall0  __syscall
+#define __syscall1  __syscall
+#define __syscall2  __syscall
+#define __syscall3  __syscall
+#define __syscall4  __syscall
+#define __syscall5  __syscall
+#define __syscall6  __syscall
 static inline sysarg_t
 __syscall(const sysarg_t p1, const sysarg_t p2, const sysarg_t p3,
     const sysarg_t p4, const sysarg_t p5, const sysarg_t p6, const syscall_t id)

 /branches/dd/uspace/lib/libc/arch/sparc64/include/ddi.h
 ,0 → 1,92
+/*
+ * 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.
+ */
+/** @file
+ * @ingroup libsparc64
+ */
+#ifndef LIBC_sparc64_DDI_H_
+#define LIBC_sparc64_DDI_H_
+#include <sys/types.h>
+#include <libarch/types.h>
+static inline memory_barrier(void)
+{
+    asm volatile ("membar #LoadLoad | #StoreStore\n" ::: "memory");
+}
+static inline void pio_write_8(ioport8_t *port, uint8_t v)
+{
+    *port = v;
+    memory_barrier();
+}
+static inline void pio_write_16(ioport16_t *port, uint16_t v)
+{
+    *port = v;
+    memory_barrier();
+}
+static inline void pio_write_32(ioport32_t *port, uint32_t v)
+{
+    *port = v;
+    memory_barrier();
+}
+static inline uint8_t pio_read_8(ioport8_t *port)
+{
+    uint8_t rv;
+    rv = *port;
+    memory_barrier();
+    return rv;
+}
+static inline uint16_t pio_read_16(ioport16_t *port)
+{
+    uint16_t rv;
+    rv = *port;
+    memory_barrier();
+    return rv;
+}
+static inline uint32_t pio_read_32(ioport32_t *port)
+{
+    uint32_t rv;
+    rv = *port;
+    memory_barrier();
+    return rv;
+}
+#endif

/branches/dd/uspace/lib/libc/arch/sparc64/include/config.h
37,7 → 37,6

#define PAGE_WIDTH 14
#define PAGE_SIZE (1 << PAGE_WIDTH)
#define PAGE_COLOR_BITS 0 /*< Only one page color. /

#endif

 /branches/dd/uspace/lib/libc/arch/sparc64/Makefile.inc
 ,10 → 30,10
 #
 TARGET = sparc64-linux-gnu
-TOOLCHAIN_DIR = /usr/local/sparc64/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/sparc64/bin
-ARCH_SOURCES += arch/$(ARCH)/src/fibril.S \
-        arch/$(ARCH)/src/tls.c
+ARCH_SOURCES += arch/$(UARCH)/src/fibril.S \
+    arch/$(UARCH)/src/tls.c
 CFLAGS += -mcpu=ultrasparc -m64
 LFLAGS += -no-check-sections -N

 /branches/dd/uspace/lib/libc/arch/sparc64/src/entry.s
 ,27 → 31,18
 .org 0
 .globl __entry
-.globl __entry_driver
 ## User-space task entry point
 #
+# %o0 contains uarg
+# %o1 contains pcb_ptr
 #
 __entry:
+    # Pass pcb_ptr as the first argument to __main()
+    mov %o1, %o0
     sethi %hi(_gp), %l7
     call __main
     or %l7, %lo(_gp), %l7
-    call __io_init
-    nop
-    call main
-    nop
-    call __exit
-    nop
-__entry_driver:
-    sethi %hi(_gp), %l7
-    call __main
-    or %l7, %lo(_gp), %l7
-    call main
-    nop
     call __exit
     nop

/branches/dd/uspace/lib/libc/arch/ia64/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

 /branches/dd/uspace/lib/libc/arch/ia64/include/syscall.h
 ,6 → 36,8
 #ifndef LIBC_ia64_SYSCALL_H_
 #define LIBC_ia64_SYSCALL_H_
+#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/dd/uspace/lib/libc/arch/ia64/include/ddi.h
 ,0 → 1,115
+/*
+ * Copyright (c) 2005 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 libcia64
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_ia64_DDI_H_
+#define LIBC_ia64_DDI_H_
+#include <sys/types.h>
+#include <libarch/types.h>
+#define IO_SPACE_BOUNDARY   (64 * 1024)
+uint64_t get_ia64_iospace_address(void);
+extern uint64_t ia64_iospace_address;
+#define IA64_IOSPACE_ADDRESS \
+    (ia64_iospace_address ? \
+        ia64_iospace_address : \
+        (ia64_iospace_address = get_ia64_iospace_address()))
+static inline void pio_write_8(ioport8_t *port, uint8_t v)
+{
+    uintptr_t prt = (uintptr_t) port;
+    *((uint8_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
+    asm volatile ("mf\n" ::: "memory");
+}
+static inline void pio_write_16(ioport16_t *port, uint16_t v)
+{
+    uintptr_t prt = (uintptr_t) port;
+    *((uint16_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
+    asm volatile ("mf\n" ::: "memory");
+}
+static inline void pio_write_32(ioport32_t *port, uint32_t v)
+{
+    uintptr_t prt = (uintptr_t) port;
+    *((uint32_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
+    asm volatile ("mf\n" ::: "memory");
+}
+static inline uint8_t pio_read_8(ioport8_t *port)
+{
+    uintptr_t prt = (uintptr_t) port;
+    asm volatile ("mf\n" ::: "memory");
+    return *((uint8_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12))));
+}
+static inline uint16_t pio_read_16(ioport16_t *port)
+{
+    uintptr_t prt = (uintptr_t) port;
+    asm volatile ("mf\n" ::: "memory");
+    return *((uint16_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12))));
+}
+static inline uint32_t pio_read_32(ioport32_t *port)
+{
+    uintptr_t prt = (uintptr_t) port;
+    asm volatile ("mf\n" ::: "memory");
+    return *((uint32_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12))));
+}
+#endif
+/** @}
+ */

 /branches/dd/uspace/lib/libc/arch/ia64/include/config.h
 ,8 → 36,7
 #define LIBC_ia64_CONFIG_H_
 #define PAGE_WIDTH  14
-#define PAGE_SIZE   (1<<PAGE_WIDTH)
-#define PAGE_COLOR_BITS 0        /* dummy */
+#define PAGE_SIZE   (1 << PAGE_WIDTH)
 #endif

 /branches/dd/uspace/lib/libc/arch/ia64/Makefile.inc
 ,14 → 30,15
 #
 TARGET = ia64-pc-linux-gnu
-TOOLCHAIN_DIR = /usr/local/ia64/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/ia64/bin
 CFLAGS += -fno-unwind-tables -DMALLOC_ALIGNMENT_16
 LFLAGS += -N $(SOFTINT_PREFIX)/libsoftint.a
 AFLAGS +=
-ARCH_SOURCES += arch/$(ARCH)/src/syscall.S \
-        arch/$(ARCH)/src/fibril.S \
-        arch/$(ARCH)/src/tls.c
+ARCH_SOURCES += arch/$(UARCH)/src/syscall.S \
+    arch/$(UARCH)/src/fibril.S \
+    arch/$(UARCH)/src/tls.c \
+    arch/$(UARCH)/src/ddi.c
 BFD_NAME = elf64-ia64-little
 BFD_ARCH = ia64-elf64

 /branches/dd/uspace/lib/libc/arch/ia64/src/ddi.c
 ,0 → 1,13
+#include <libarch/ddi.h>
+#include <sysinfo.h>
+uint64_t ia64_iospace_address=0;
+uint64_t get_ia64_iospace_address(void)
+{
+    return sysinfo_value("ia64_iospace.address.virtual");
+}

 /branches/dd/uspace/lib/libc/arch/ia64/src/entry.s
 ,27 → 31,17
 .org 0
 .globl __entry
-.globl __entry_driver
 ## User-space task entry point
 #
+# r2 contains the PCB pointer
 #
 __entry:
     alloc loc0 = ar.pfs, 0, 1, 2, 0
-    mov r1 = _gp
-    br.call.sptk.many b0 = __main
-:
-    br.call.sptk.many b0 = __io_init
-:
-    br.call.sptk.many b0 = main
-:
-    br.call.sptk.many b0 = __exit
+    movl r1 = _gp
-__entry_driver:
-    alloc loc0 = ar.pfs, 0, 1, 2, 0
-    mov r1 = _gp
+    # Pass PCB pointer as the first argument to __main
+    mov out0 = r2
     br.call.sptk.many b0 = __main
 :
-    br.call.sptk.many b0 = main
-:
     br.call.sptk.many b0 = __exit

 /branches/dd/uspace/lib/libc/arch/ia64/src/thread_entry.s
 ,7 → 36,7
 __thread_entry:
     alloc loc0 = ar.pfs, 0, 1, 1, 0
-    mov r1 = _gp
+    movl r1 = _gp
     #
     # r8 contains address of uarg structure.

/branches/dd/uspace/lib/libc/arch/arm32/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

 /branches/dd/uspace/lib/libc/arch/arm32/include/syscall.h
 ,12 → 30,14
  * @{
  */
 /** @file
- *  @brief Empty.
+ *  @brief
  */
 #ifndef LIBC_arm32_SYSCALL_H_
 #define LIBC_arm32_SYSCALL_H_
+#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/dd/uspace/lib/libc/arch/arm32/include/byteorder.h
 ,7 → 36,7
 #ifndef LIBC_arm32_BYTEORDER_H_
 #define LIBC_arm32_BYTEORDER_H_
-#define ARCH_IS_BIG_ENDIAN
+#define ARCH_IS_LITTLE_ENDIAN
 #endif

 /branches/dd/uspace/lib/libc/arch/arm32/include/ddi.h
 ,0 → 1,69
+/*
+ * 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.
+ */
+/** @file
+ * @ingroup libcarm32
+ */
+#ifndef LIBC_arm32_DDI_H_
+#define LIBC_arm32_DDI_H_
+#include <sys/types.h>
+#include <libarch/types.h>
+static inline void pio_write_8(ioport8_t *port, uint8_t v)
+{
+    *port = v;
+}
+static inline void pio_write_16(ioport16_t *port, uint16_t v)
+{
+    *port = v;
+}
+static inline void pio_write_32(ioport32_t *port, uint32_t v)
+{
+    *port = v;
+}
+static inline uint8_t pio_read_8(ioport8_t *port)
+{
+    return *port;
+}
+static inline uint16_t pio_read_16(ioport16_t *port)
+{
+    return *port;
+}
+static inline uint32_t pio_read_32(ioport32_t *port)
+{
+    return *port;
+}
+#endif

/branches/dd/uspace/lib/libc/arch/arm32/include/config.h
38,7 → 38,6

#define PAGE_WIDTH 12
#define PAGE_SIZE (1 << PAGE_WIDTH)
#define PAGE_COLOR_BITS 0 /* dummy */

#endif

 /branches/dd/uspace/lib/libc/arch/arm32/Makefile.inc
 ,15 → 31,15
 #
 TARGET = arm-linux-gnu
-TOOLCHAIN_DIR = /usr/local/arm/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/arm/bin
 CFLAGS += -ffixed-r9 -mtp=soft
 LFLAGS += -N $(SOFTINT_PREFIX)/libsoftint.a
-AFLAGS +=
+AFLAGS +=
-ARCH_SOURCES += arch/$(ARCH)/src/syscall.c \
-        arch/$(ARCH)/src/fibril.S \
-        arch/$(ARCH)/src/tls.c \
-        arch/$(ARCH)/src/eabi.S
+ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \
+    arch/$(UARCH)/src/fibril.S \
+    arch/$(UARCH)/src/tls.c \
+    arch/$(UARCH)/src/eabi.S
 BFD_NAME = elf32-littlearm
 BFD_ARCH = arm

 /branches/dd/uspace/lib/libc/arch/arm32/src/entry.s
 ,19 → 31,14
 .org 0
 .global __entry
-.global __entry_driver
 ## User-space task entry point
 #
+# r1 contains the PCB pointer
 #
 __entry:
+    # Pass pcb_ptr to __main as the first argument (in r0)
+    mov r0, r1
     bl __main
-    bl __io_init
-    bl main
-    bl __exit
-__entry_driver:
-    bl __main
-    bl main
     bl __exit

 /branches/dd/uspace/lib/libc/arch/mips32eb/Makefile.inc
 ,12 → 30,12
 #
 TARGET = mips-sgi-irix5
-TOOLCHAIN_DIR = /usr/local/mips/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/mips/bin
 CFLAGS += -mips3
-ARCH_SOURCES += arch/$(ARCH)/src/syscall.c \
-        arch/$(ARCH)/src/fibril.S \
-        arch/$(ARCH)/src/tls.c
+ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \
+        arch/$(UARCH)/src/fibril.S \
+        arch/$(UARCH)/src/tls.c
 LFLAGS += -N

/branches/dd/uspace/lib/libc/arch/ppc32/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

 /branches/dd/uspace/lib/libc/arch/ppc32/include/syscall.h
 ,6 → 36,8
 #ifndef LIBC_ppc32_SYSCALL_H_
 #define LIBC_ppc32_SYSCALL_H_
+#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/dd/uspace/lib/libc/arch/ppc32/include/ddi.h
 ,0 → 1,69
+/*
+ * 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.
+ */
+/** @file
+ * @ingroup libcppc32
+ */
+#ifndef LIBC_ppc32_DDI_H_
+#define LIBC_ppc32_DDI_H_
+#include <sys/types.h>
+#include <libarch/types.h>
+static inline void pio_write_8(ioport8_t *port, uint8_t v)
+{
+    *port = v;
+}
+static inline void pio_write_16(ioport16_t *port, uint16_t v)
+{
+    *port = v;
+}
+static inline void pio_write_32(ioport32_t *port, uint32_t v)
+{
+    *port = v;
+}
+static inline uint8_t pio_read_8(ioport8_t *port)
+{
+    return *port;
+}
+static inline uint16_t pio_read_16(ioport16_t *port)
+{
+    return *port;
+}
+static inline uint32_t pio_read_32(ioport32_t *port)
+{
+    return *port;
+}
+#endif

 /branches/dd/uspace/lib/libc/arch/ppc32/include/config.h
 ,8 → 36,7
 #define LIBC_ppc32_CONFIG_H_
 #define PAGE_WIDTH  12
-#define PAGE_SIZE   (1<<PAGE_WIDTH)
-#define PAGE_COLOR_BITS 0        /* dummy */
+#define PAGE_SIZE   (1 << PAGE_WIDTH)
 #endif

 /branches/dd/uspace/lib/libc/arch/ppc32/Makefile.inc
 ,11 → 30,11
 #
 TARGET = ppc-linux-gnu
-TOOLCHAIN_DIR = /usr/local/ppc/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/ppc/bin
-ARCH_SOURCES += arch/$(ARCH)/src/syscall.c \
-        arch/$(ARCH)/src/fibril.S \
-        arch/$(ARCH)/src/tls.c
+ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \
+    arch/$(UARCH)/src/fibril.S \
+    arch/$(UARCH)/src/tls.c
 CFLAGS += -mcpu=powerpc -msoft-float -m32
 AFLAGS += -a32

 /branches/dd/uspace/lib/libc/arch/ppc32/src/entry.s
 ,18 → 31,15
 .org 0
 .globl __entry
-.globl __entry_driver
 ## User-space task entry point
 #
+# r6 contains the PCB pointer
 #
 __entry:
+    # Pass the PCB pointer to __main() as the first argument.
+    # The first argument is passed in r3.
+    mr %r3, %r6
     bl __main
-    bl __io_init
-    bl main
-    bl __exit
-__entry_driver:
-    bl __main
-    bl main
     bl __exit

/branches/dd/uspace/lib/libc/arch/amd64/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

 /branches/dd/uspace/lib/libc/arch/amd64/include/syscall.h
 ,6 → 36,8
 #ifndef LIBC_amd64_SYSCALL_H_
 #define LIBC_amd64_SYSCALL_H_
+#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/dd/uspace/lib/libc/arch/amd64/include/atomic.h
 ,11 → 38,11
 #define LIBC_amd64_ATOMIC_H_
 static inline void atomic_inc(atomic_t *val) {
-    asm volatile ("lock incq %0\n" : "=m" (val->count));
+    asm volatile ("lock incq %0\n" : "+m" (val->count));
 }
 static inline void atomic_dec(atomic_t *val) {
-    asm volatile ("lock decq %0\n" : "=m" (val->count));
+    asm volatile ("lock decq %0\n" : "+m" (val->count));
 }
 static inline long atomic_postinc(atomic_t *val)
 ,7 → 52,7
     asm volatile (
         "movq $1, %0\n"
         "lock xaddq %0, %1\n"
-        : "=r" (r), "=m" (val->count)
+        : "=r" (r), "+m" (val->count)
     );
     return r;
 ,14 → 65,14
     asm volatile (
         "movq $-1, %0\n"
         "lock xaddq %0, %1\n"
-        : "=r" (r), "=m" (val->count)
+        : "=r" (r), "+m" (val->count)
     );
     return r;
 }
-#define atomic_preinc(val) (atomic_postinc(val)+1)
-#define atomic_predec(val) (atomic_postdec(val)-1)
+#define atomic_preinc(val) (atomic_postinc(val) + 1)
+#define atomic_predec(val) (atomic_postdec(val) - 1)
 #endif

 /branches/dd/uspace/lib/libc/arch/amd64/include/config.h
 ,8 → 36,7
 #define LIBC_amd64_CONFIG_H_
 #define PAGE_WIDTH  12
-#define PAGE_SIZE   (1<<PAGE_WIDTH)
-#define PAGE_COLOR_BITS 0        /* dummy */
+#define PAGE_SIZE   (1 << PAGE_WIDTH)
 #endif

 /branches/dd/uspace/lib/libc/arch/amd64/Makefile.inc
 ,11 → 30,11
 #
 TARGET = amd64-linux-gnu
-TOOLCHAIN_DIR = /usr/local/amd64/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/amd64/bin
-ARCH_SOURCES += arch/$(ARCH)/src/syscall.S \
-        arch/$(ARCH)/src/fibril.S \
-        arch/$(ARCH)/src/tls.c
+ARCH_SOURCES += arch/$(UARCH)/src/syscall.S \
+    arch/$(UARCH)/src/fibril.S \
+    arch/$(UARCH)/src/tls.c
 LFLAGS += -N

 /branches/dd/uspace/lib/libc/arch/amd64/src/entry.s
 ,18 → 31,14
 .org 0
 .globl __entry
-.globl __entry_driver
 ## User-space task entry point
 #
+# %rdi contains the PCB pointer
 #
 __entry:
+    # %rdi was deliberately chosen as the first argument is also in %rdi
+    # Pass PCB pointer to __main (no operation)
     call __main
-    call __io_init
-    call main
-    call __exit
-__entry_driver:
-    call __main
-    call main
     call __exit

/branches/dd/uspace/lib/libc/arch/mips32/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

 /branches/dd/uspace/lib/libc/arch/mips32/include/syscall.h
 ,6 → 36,8
 #ifndef LIBC_mips32_SYSCALL_H_
 #define LIBC_mips32_SYSCALL_H_
+#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/dd/uspace/lib/libc/arch/mips32/include/atomic.h
 ,13 → 59,14
     asm volatile (
         "1:\n"
         "   ll %0, %1\n"
-        "   addiu %0, %0, %3\n" /* same as addi, but never traps on overflow */
+        "   addu %0, %0, %3\n"  /* same as add, but never traps on overflow */
         "       move %2, %0\n"
         "   sc %0, %1\n"
         "   beq %0, %4, 1b\n"   /* if the atomic operation failed, try again */
         /*  nop */      /* nop is inserted automatically by compiler */
-        : "=r" (tmp), "=m" (val->count), "=r" (v)
-        : "i" (i), "i" (0)
+        "   nop\n"
+        : "=&r" (tmp), "+m" (val->count), "=&r" (v)
+        : "r" (i), "i" (0)
         );
     return v;

 /branches/dd/uspace/lib/libc/arch/mips32/include/ddi.h
 ,0 → 1,69
+/*
+ * 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.
+ */
+/** @file
+ * @ingroup libcmips32
+ */
+#ifndef LIBC_mips32_DDI_H_
+#define LIBC_mips32_DDI_H_
+#include <sys/types.h>
+#include <libarch/types.h>
+static inline void pio_write_8(ioport8_t *port, uint8_t v)
+{
+    *port = v;
+}
+static inline void pio_write_16(ioport16_t *port, uint16_t v)
+{
+    *port = v;
+}
+static inline void pio_write_32(ioport32_t *port, uint32_t v)
+{
+    *port = v;
+}
+static inline uint8_t pio_read_8(ioport8_t *port)
+{
+    return *port;
+}
+static inline uint16_t pio_read_16(ioport16_t *port)
+{
+    return *port;
+}
+static inline uint32_t pio_read_32(ioport32_t *port)
+{
+    return *port;
+}
+#endif

 /branches/dd/uspace/lib/libc/arch/mips32/include/config.h
 ,8 → 36,7
 #define LIBC_mips32_CONFIG_H_
 #define PAGE_WIDTH  14
-#define PAGE_SIZE   (1<<PAGE_WIDTH)
-#define PAGE_COLOR_BITS 0        /* dummy */
+#define PAGE_SIZE   (1 << PAGE_WIDTH)
 #endif

 /branches/dd/uspace/lib/libc/arch/mips32/Makefile.inc
 ,18 → 30,12
 #
 TARGET = mipsel-linux-gnu
-TOOLCHAIN_DIR = /usr/local/mipsel/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/mipsel/bin
 CFLAGS += -mips3
--include ../../Makefile.config
-ifeq ($(CONFIG_MIPS_FPU),y)
-    CFLAGS += -DCONFIG_MIPS_FPU
-endif
+ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \
+    arch/$(UARCH)/src/fibril.S \
+    arch/$(UARCH)/src/tls.c
-ARCH_SOURCES += arch/$(ARCH)/src/syscall.c \
-    arch/$(ARCH)/src/fibril.S \
-    arch/$(ARCH)/src/tls.c
 BFD_ARCH = mips
 BFD_NAME = elf32-tradlittlemips

 /branches/dd/uspace/lib/libc/arch/mips32/src/entry.s
 ,13 → 35,13
 ## User-space task entry point
 #
+# $a0 ($4) contains the PCB pointer
 #
 .ent __entry
 __entry:
     .frame $sp, 32, $31
     .cpload $25
     # Mips o32 may store its arguments on stack, make space (16 bytes),
     # so that it could work with -O0
     # Make space additional 16 bytes for the stack frame
 ,42 → 48,18
     addiu $sp, -32
     .cprestore 16   # Allow PIC code
-    jal __main
-    nop
-    jal __io_init
-    nop
-    jal main
-    nop
-    jal __exit
-    nop
-.end
-.ent __entry_driver
-__entry_driver:
-    .frame $sp, 32, $31
-    .cpload $25
-    # Mips o32 may store its arguments on stack, make space (16 bytes),
-    # so that it could work with -O0
-    # Make space additional 16 bytes for the stack frame
+    # Pass pcb_ptr to __main() as the first argument. pcb_ptr is already
+    # in $a0. As the first argument is passed in $a0, no operation
+    # is needed.
-    addiu $sp, -32
-    .cprestore 16   # Allow PIC code
     jal __main
     nop
-    jal main
-    nop
     jal __exit
     nop
 .end
 # Alignment of output section data to 0x4000
 .section .data
 .align 14

/branches/dd/uspace/lib/libc/arch/ia32/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

 /branches/dd/uspace/lib/libc/arch/ia32/include/syscall.h
 ,8 → 36,25
 #ifndef LIBC_ia32_SYSCALL_H_
 #define LIBC_ia32_SYSCALL_H_
-#include <syscall.h>
+#include <sys/types.h>
+#include <kernel/syscall/syscall.h>
+#define __syscall0  __syscall_sysenter
+#define __syscall1  __syscall_sysenter
+#define __syscall2  __syscall_sysenter
+#define __syscall3  __syscall_sysenter
+#define __syscall4  __syscall_sysenter
+#define __syscall5  __syscall_int
+#define __syscall6  __syscall_int
+extern sysarg_t
+__syscall_sysenter(const sysarg_t, const sysarg_t, const sysarg_t, const sysarg_t,
+     const sysarg_t, const sysarg_t, const syscall_t);
+extern sysarg_t
+__syscall_int(const sysarg_t, const sysarg_t, const sysarg_t, const sysarg_t,
+     const sysarg_t, const sysarg_t, const syscall_t);
 #endif
 /** @}

 /branches/dd/uspace/lib/libc/arch/ia32/include/atomic.h
 ,11 → 36,11
 #define LIBC_ia32_ATOMIC_H_
 static inline void atomic_inc(atomic_t *val) {
-    asm volatile ("lock incl %0\n" : "=m" (val->count));
+    asm volatile ("lock incl %0\n" : "+m" (val->count));
 }
 static inline void atomic_dec(atomic_t *val) {
-    asm volatile ("lock decl %0\n" : "=m" (val->count));
+    asm volatile ("lock decl %0\n" : "+m" (val->count));
 }
 static inline long atomic_postinc(atomic_t *val)
 ,7 → 50,7
     asm volatile (
         "movl $1, %0\n"
         "lock xaddl %0, %1\n"
-        : "=r" (r), "=m" (val->count)
+        : "=r" (r), "+m" (val->count)
     );
     return r;
 ,14 → 63,14
     asm volatile (
         "movl $-1, %0\n"
         "lock xaddl %0, %1\n"
-        : "=r" (r), "=m" (val->count)
+        : "=r" (r), "+m" (val->count)
     );
     return r;
 }
-#define atomic_preinc(val) (atomic_postinc(val)+1)
-#define atomic_predec(val) (atomic_postdec(val)-1)
+#define atomic_preinc(val) (atomic_postinc(val) + 1)
+#define atomic_predec(val) (atomic_postdec(val) - 1)
 #endif

 /branches/dd/uspace/lib/libc/arch/ia32/include/ddi.h
 ,43 → 33,72
 #ifndef LIBC_ia32_DDI_H_
 #define LIBC_ia32_DDI_H_
-static inline void outb(int16_t port, uint8_t b)
+#include <sys/types.h>
+#include <libarch/types.h>
+#define IO_SPACE_BOUNDARY   ((void *) (64 * 1024))
+static inline uint8_t pio_read_8(ioport8_t *port)
 {
-    asm volatile ("outb %0, %1\n" :: "a" (b), "d" (port));
+    uint8_t val;
+    asm volatile (
+        "inb %w[port], %b[val]\n"
+        : [val] "=a" (val)
+        : [port] "d" (port)
+    );
+    return val;
 }
-static inline void outw(int16_t port, int16_t w)
+static inline uint16_t pio_read_16(ioport16_t *port)
 {
-    asm volatile ("outw %0, %1\n" :: "a" (w), "d" (port));
+    uint16_t val;
+    asm volatile (
+        "inw %w[port], %w[val]\n"
+        : [val] "=a" (val)
+        : [port] "d" (port)
+    );
+    return val;
 }
-static inline void outl(int16_t port, uint32_t l)
+static inline uint32_t pio_read_32(ioport32_t *port)
 {
-    asm volatile ("outl %0, %1\n" :: "a" (l), "d" (port));
+    uint32_t val;
+    asm volatile (
+        "inl %w[port], %[val]\n"
+        : [val] "=a" (val)
+        : [port] "d" (port)
+    );
+    return val;
 }
-static inline uint8_t inb(int16_t port)
+static inline void pio_write_8(ioport8_t *port, uint8_t val)
 {
-    uint8_t val;
-    asm volatile ("inb %1, %0 \n" : "=a" (val) : "d"(port));
-    return val;
+    asm volatile (
+        "outb %b[val], %w[port]\n"
+        :: [val] "a" (val), [port] "d" (port)
+    );
 }
-static inline int16_t inw(int16_t port)
+static inline void pio_write_16(ioport16_t *port, uint16_t val)
 {
-    int16_t val;
-    asm volatile ("inw %1, %0 \n" : "=a" (val) : "d"(port));
-    return val;
+    asm volatile (
+        "outw %w[val], %w[port]\n"
+        :: [val] "a" (val), [port] "d" (port)
+    );
 }
-static inline uint32_t inl(int16_t port)
+static inline void pio_write_32(ioport32_t *port, uint32_t val)
 {
-    uint32_t val;
-    asm volatile ("inl %1, %0 \n" : "=a" (val) : "d"(port));
-    return val;
+    asm volatile (
+        "outl %[val], %w[port]\n"
+        :: [val] "a" (val), [port] "d" (port)
+    );
 }
 #endif

 /branches/dd/uspace/lib/libc/arch/ia32/include/config.h
 ,8 → 36,7
 #define LIBC_ia32_CONFIG_H_
 #define PAGE_WIDTH  12
-#define PAGE_SIZE   (1<<PAGE_WIDTH)
-#define PAGE_COLOR_BITS 0        /* dummy */
+#define PAGE_SIZE   (1 << PAGE_WIDTH)
 #endif

 /branches/dd/uspace/lib/libc/arch/ia32/Makefile.inc
 ,12 → 30,12
 #
 TARGET = i686-pc-linux-gnu
-TOOLCHAIN_DIR = /usr/local/i686/bin
+TOOLCHAIN_DIR = $(CROSS_PREFIX)/i686/bin
-ARCH_SOURCES += arch/$(ARCH)/src/syscall.S \
-        arch/$(ARCH)/src/fibril.S \
-        arch/$(ARCH)/src/tls.c \
-        arch/$(ARCH)/src/setjmp.S
+ARCH_SOURCES += arch/$(UARCH)/src/syscall.S \
+    arch/$(UARCH)/src/fibril.S \
+    arch/$(UARCH)/src/tls.c \
+    arch/$(UARCH)/src/setjmp.S
 LFLAGS += -N

 /branches/dd/uspace/lib/libc/arch/ia32/src/entry.s
 ,10 → 31,10
 .org 0
 .globl __entry
-.globl __entry_driver
 ## User-space task entry point
 #
+# %ebx contains the PCB pointer
 #
 __entry:
     mov %ss, %ax
 ,19 → 42,9
     mov %ax, %es
     mov %ax, %fs
     # Do not set %gs, it contains descriptor that can see TLS
+    # Pass the PCB pointer to __main as the first argument
+    pushl %ebx
     call __main
-    call __io_init
-    call main
     call __exit
-__entry_driver:
-    mov %ss, %ax
-    mov %ax, %ds
-    mov %ax, %es
-    mov %ax, %fs
-    # Do not set %gs, it contains descriptor that can see TLS
-    call __main
-    call main
-    call __exit

 /branches/dd/uspace/lib/libc/arch/ia32/src/syscall.S
 ,14 → 28,14
 .text
-/** Syscall wrapper.
+/** Syscall wrapper - INT $0x30 version.
  *
  * Mind the order of arguments. First two arguments and the syscall number go to
  * scratch registers. An optimized version of this wrapper for fewer arguments
  * could benefit from this and not save unused registers on the stack.
  */
-.global __syscall
-__syscall:
+.global __syscall_int
+__syscall_int:
     pushl %ebx
     pushl %esi
     pushl %edi
 ,3 → 54,37
     popl %ebx
     ret
+/** Syscall wrapper - SYSENTER version.
+ *
+ * This is an optimized version of syscall for four or less arguments.  Note
+ * that EBP and EDI are used to remember user stack address and the return
+ * address. The kernel part doesn't save DS, ES and FS so the handler restores
+ * these to the selector immediately following CS (it must be the flat data
+ * segment, otherwise the SYSENTER wouldn't work in the first place).
+ */
+.global __syscall_sysenter
+__syscall_sysenter:
+    pushl %ebx
+    pushl %esi
+    pushl %edi
+    pushl %ebp
+    mov %esp, %ebp
+    lea ra, %edi
+    movl 20(%esp), %edx # First argument.
+    movl 24(%esp), %ecx # Second argument.
+    movl 28(%esp), %ebx # Third argument.
+    movl 32(%esp), %esi # Fourth argument.
+    movl 44(%esp), %eax # Syscall number.
+    sysenter
+ra:
+    movw %cs, %cx
+    addw $8, %cx
+    movw %cx, %ds
+    movw %cx, %es
+    movw %cx, %fs
+    popl %ebp
+    popl %edi
+    popl %esi
+    popl %ebx
+    ret

/branches/dd/uspace/srv/kbd/arch/amd64
File deleted
\ No newline at end of file
Property changes:
Deleted: svn:special
-*
\ No newline at end of property

/branches/dd/uspace/srv/kbd/arch/mips32eb
File deleted
\ No newline at end of file
Property changes:
Deleted: svn:special
-*
\ No newline at end of property

 /branches/dd/uspace/srv/kbd/ctl/stty.c
 ,0 → 1,329
+/*
+ * 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 kbd_ctl
+ * @ingroup kbd
+ * @{
+ */
+/**
+ * @file
+ * @brief   Serial TTY-like keyboard controller driver.
+ */
+#include <kbd.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
+#include <kbd_ctl.h>
+static void parse_ds_start(int scancode);
+static void parse_ds_e(int scancode);
+static void parse_ds_e1(int scancode);
+static void parse_ds_e2(int scancode);
+static void parse_ds_e2a(int scancode);
+static void parse_ds_e2b(int scancode);
+static void parse_leaf(int scancode, int (*map)[2], size_t map_length);
+enum dec_state {
+    ds_start,
+    ds_e,
+    ds_e1,
+    ds_e2,
+    ds_e2a,
+    ds_e2b
+};
+static int map_start[][2] = {
+    [0x60] = { 0, KC_BACKTICK },
+    [0x31] = { 0, KC_1 },
+    [0x32] = { 0, KC_2 },
+    [0x33] = { 0, KC_3 },
+    [0x34] = { 0, KC_4 },
+    [0x35] = { 0, KC_5 },
+    [0x36] = { 0, KC_6 },
+    [0x37] = { 0, KC_7 },
+    [0x38] = { 0, KC_8 },
+    [0x39] = { 0, KC_9 },
+    [0x30] = { 0, KC_0 },
+    [0x2d] = { 0, KC_MINUS },
+    [0x3d] = { 0, KC_EQUALS },
+    [0x08] = { 0, KC_BACKSPACE },
+    [0x0f] = { 0, KC_TAB },
+    [0x71] = { 0, KC_Q },
+    [0x77] = { 0, KC_W },
+    [0x65] = { 0, KC_E },
+    [0x72] = { 0, KC_R },
+    [0x74] = { 0, KC_T },
+    [0x79] = { 0, KC_Y },
+    [0x75] = { 0, KC_U },
+    [0x69] = { 0, KC_I },
+    [0x6f] = { 0, KC_O },
+    [0x70] = { 0, KC_P },
+    [0x5b] = { 0, KC_LBRACKET },
+    [0x5d] = { 0, KC_RBRACKET },
+    [0x61] = { 0, KC_A },
+    [0x73] = { 0, KC_S },
+    [0x64] = { 0, KC_D },
+    [0x66] = { 0, KC_F },
+    [0x67] = { 0, KC_G },
+    [0x68] = { 0, KC_H },
+    [0x6a] = { 0, KC_J },
+    [0x6b] = { 0, KC_K },
+    [0x6c] = { 0, KC_L },
+    [0x3b] = { 0, KC_SEMICOLON },
+    [0x27] = { 0, KC_QUOTE },
+    [0x5c] = { 0, KC_BACKSLASH },
+    [0x7a] = { 0, KC_Z },
+    [0x78] = { 0, KC_X },
+    [0x63] = { 0, KC_C },
+    [0x76] = { 0, KC_V },
+    [0x62] = { 0, KC_B },
+    [0x6e] = { 0, KC_N },
+    [0x6d] = { 0, KC_M },
+    [0x2c] = { 0, KC_COMMA },
+    [0x2e] = { 0, KC_PERIOD },
+    [0x2f] = { 0, KC_SLASH },
+    [0x20] = { 0, KC_SPACE },
+    [0x1b] = { 0, KC_ESCAPE },
+    [0x0a] = { 0, KC_ENTER },
+    [0x0d] = { 0, KC_ENTER },
+    /* with Shift pressed */
+    [0x7e] = { KM_LSHIFT, KC_BACKTICK },
+    [0x21] = { KM_LSHIFT, KC_1 },
+    [0x40] = { KM_LSHIFT, KC_2 },
+    [0x23] = { KM_LSHIFT, KC_3 },
+    [0x24] = { KM_LSHIFT, KC_4 },
+    [0x25] = { KM_LSHIFT, KC_5 },
+    [0x5e] = { KM_LSHIFT, KC_6 },
+    [0x26] = { KM_LSHIFT, KC_7 },
+    [0x2a] = { KM_LSHIFT, KC_8 },
+    [0x28] = { KM_LSHIFT, KC_9 },
+    [0x29] = { KM_LSHIFT, KC_0 },
+    [0x5f] = { KM_LSHIFT, KC_MINUS },
+    [0x2b] = { KM_LSHIFT, KC_EQUALS },
+    [0x51] = { KM_LSHIFT, KC_Q },
+    [0x57] = { KM_LSHIFT, KC_W },
+    [0x45] = { KM_LSHIFT, KC_E },
+    [0x52] = { KM_LSHIFT, KC_R },
+    [0x54] = { KM_LSHIFT, KC_T },
+    [0x59] = { KM_LSHIFT, KC_Y },
+    [0x55] = { KM_LSHIFT, KC_U },
+    [0x49] = { KM_LSHIFT, KC_I },
+    [0x4f] = { KM_LSHIFT, KC_O },
+    [0x50] = { KM_LSHIFT, KC_P },
+    [0x7b] = { KM_LSHIFT, KC_LBRACKET },
+    [0x7d] = { KM_LSHIFT, KC_RBRACKET },
+    [0x41] = { KM_LSHIFT, KC_A },
+    [0x53] = { KM_LSHIFT, KC_S },
+    [0x44] = { KM_LSHIFT, KC_D },
+    [0x46] = { KM_LSHIFT, KC_F },
+    [0x47] = { KM_LSHIFT, KC_G },
+    [0x48] = { KM_LSHIFT, KC_H },
+    [0x4a] = { KM_LSHIFT, KC_J },
+    [0x4b] = { KM_LSHIFT, KC_K },
+    [0x4c] = { KM_LSHIFT, KC_L },
+    [0x3a] = { KM_LSHIFT, KC_SEMICOLON },
+    [0x22] = { KM_LSHIFT, KC_QUOTE },
+    [0x7c] = { KM_LSHIFT, KC_BACKSLASH },
+    [0x5a] = { KM_LSHIFT, KC_Z },
+    [0x58] = { KM_LSHIFT, KC_X },
+    [0x43] = { KM_LSHIFT, KC_C },
+    [0x56] = { KM_LSHIFT, KC_V },
+    [0x42] = { KM_LSHIFT, KC_B },
+    [0x4e] = { KM_LSHIFT, KC_N },
+    [0x4d] = { KM_LSHIFT, KC_M },
+    [0x3c] = { KM_LSHIFT, KC_COMMA },
+    [0x3e] = { KM_LSHIFT, KC_PERIOD },
+    [0x3f] = { KM_LSHIFT, KC_SLASH }
+};
+static int map_e1[][2] =
+{
+    [0x50] = { 0, KC_F1 },
+    [0x51] = { 0, KC_F2 },
+    [0x52] = { 0, KC_F3 },
+    [0x53] = { 0, KC_F4 },
+};
+static int map_e2[][2] =
+{
+    [0x41] = { 0, KC_UP },
+    [0x42] = { 0, KC_DOWN },
+    [0x44] = { 0, KC_LEFT },
+    [0x43] = { 0, KC_RIGHT },
+};
+static int map_e2a[][2] =
+{
+    [0x35] = { 0, KC_F5 },
+    [0x37] = { 0, KC_F6 },
+    [0x38] = { 0, KC_F7 },
+    [0x39] = { 0, KC_F8 },
+};
+static int map_e2b[][2] =
+{
+    [0x30] = { 0, KC_F9 },
+    [0x31] = { 0, KC_F10 },
+    [0x32] = { 0, KC_F11 },
+    [0x33] = { 0, KC_F12 },
+};
+static unsigned int mods_keys[][2] = {
+    { KM_LSHIFT, KC_LSHIFT },
+    { 0, 0 }
+};
+static enum dec_state ds;
+void kbd_ctl_parse_scancode(int scancode)
+{
+    switch (ds) {
+    case ds_start:  parse_ds_start(scancode); break;
+    case ds_e:  parse_ds_e(scancode); break;
+    case ds_e1: parse_ds_e1(scancode); break;
+    case ds_e2: parse_ds_e2(scancode); break;
+    case ds_e2a:    parse_ds_e2a(scancode); break;
+    case ds_e2b:    parse_ds_e2b(scancode); break;
+    }
+}
+static void parse_ds_start(int scancode)
+{
+    if (scancode == 0x1b) {
+        ds = ds_e;
+        return;
+    }
+    parse_leaf(scancode, map_start, sizeof(map_start) / (2 * sizeof(int)));
+}
+static void parse_ds_e(int scancode)
+{
+    if (scancode < 0 || scancode >= 0x80) return;
+    switch (scancode) {
+    case 0x4f: ds = ds_e1; return;
+    case 0x5b: ds = ds_e2; return;
+    case 0x1b: ds = ds_start; break;
+    default: ds = ds_start; return;
+    }
+    kbd_push_ev(KE_PRESS, KC_ESCAPE);
+}
+static void parse_ds_e1(int scancode)
+{
+    parse_leaf(scancode, map_e1, sizeof(map_e1) / (2 * sizeof(int)));
+}
+static void parse_ds_e2(int scancode)
+{
+    switch (scancode) {
+    case 0x31: ds = ds_e2a; break;
+    case 0x32: ds = ds_e2b; break;
+    default: ds = ds_start; break;
+    }
+    parse_leaf(scancode, map_e2, sizeof(map_e2) / (2 * sizeof(int)));
+}
+static void parse_ds_e2a(int scancode)
+{
+    parse_leaf(scancode, map_e2a, sizeof(map_e2a) / (2 * sizeof(int)));
+}
+static void parse_ds_e2b(int scancode)
+{
+    parse_leaf(scancode, map_e2b, sizeof(map_e2b) / (2 * sizeof(int)));
+}
+static void parse_leaf(int scancode, int (*map)[2], size_t map_length)
+{
+    unsigned int key, mod;
+    int i;
+    ds = ds_start;
+    if (scancode < 0 || scancode >= map_length)
+        return;
+    mod = map[scancode][0];
+    key = map[scancode][1];
+    /* Simulate modifier pressing. */
+    i = 0;
+    while (mods_keys[i][0] != 0) {
+        if (mod & mods_keys[i][0]) {
+            kbd_push_ev(KE_PRESS, mods_keys[i][1]);
+        }
+        ++i;
+    }
+    if (key != 0) {
+        kbd_push_ev(KE_PRESS, key);
+        kbd_push_ev(KE_RELEASE, key);
+    }
+    /* Simulate modifier releasing. */
+    i = 0;
+    while (mods_keys[i][0] != 0) {
+        if (mod & mods_keys[i][0]) {
+            kbd_push_ev(KE_RELEASE, mods_keys[i][1]);
+        }
+        ++i;
+    }
+}
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/kbd/ctl/gxe_fb.c
 ,0 → 1,322
+/*
+ * 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 kbd_ctl
+ * @ingroup kbd
+ * @{
+ */
+/**
+ * @file
+ * @brief   GXEmul framebuffer-mode keyboard controller driver.
+ */
+#include <kbd.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
+#include <kbd_ctl.h>
+static void parse_ds_start(int scancode);
+static void parse_ds_e(int scancode);
+static void parse_ds_e1(int scancode);
+static void parse_ds_e1a(int scancode);
+static void parse_ds_e1b(int scancode);
+static void parse_ds_e1c(int scancode);
+static void parse_leaf(int scancode, int (*map)[2], size_t map_length);
+enum dec_state {
+    ds_start,
+    ds_e,
+    ds_e1,
+    ds_e1a,
+    ds_e1b,
+    ds_e1c
+};
+static int map_start[][2] = {
+    [0x60] = { 0, KC_BACKTICK },
+    [0x31] = { 0, KC_1 },
+    [0x32] = { 0, KC_2 },
+    [0x33] = { 0, KC_3 },
+    [0x34] = { 0, KC_4 },
+    [0x35] = { 0, KC_5 },
+    [0x36] = { 0, KC_6 },
+    [0x37] = { 0, KC_7 },
+    [0x38] = { 0, KC_8 },
+    [0x39] = { 0, KC_9 },
+    [0x30] = { 0, KC_0 },
+    [0x2d] = { 0, KC_MINUS },
+    [0x3d] = { 0, KC_EQUALS },
+    [0x08] = { 0, KC_BACKSPACE },
+    [0x0f] = { 0, KC_TAB },
+    [0x71] = { 0, KC_Q },
+    [0x77] = { 0, KC_W },
+    [0x65] = { 0, KC_E },
+    [0x72] = { 0, KC_R },
+    [0x74] = { 0, KC_T },
+    [0x79] = { 0, KC_Y },
+    [0x75] = { 0, KC_U },
+    [0x69] = { 0, KC_I },
+    [0x6f] = { 0, KC_O },
+    [0x70] = { 0, KC_P },
+    [0x5b] = { 0, KC_LBRACKET },
+    [0x5d] = { 0, KC_RBRACKET },
+    [0x61] = { 0, KC_A },
+    [0x73] = { 0, KC_S },
+    [0x64] = { 0, KC_D },
+    [0x66] = { 0, KC_F },
+    [0x67] = { 0, KC_G },
+    [0x68] = { 0, KC_H },
+    [0x6a] = { 0, KC_J },
+    [0x6b] = { 0, KC_K },
+    [0x6c] = { 0, KC_L },
+    [0x3b] = { 0, KC_SEMICOLON },
+    [0x27] = { 0, KC_QUOTE },
+    [0x5c] = { 0, KC_BACKSLASH },
+    [0x7a] = { 0, KC_Z },
+    [0x78] = { 0, KC_X },
+    [0x63] = { 0, KC_C },
+    [0x76] = { 0, KC_V },
+    [0x62] = { 0, KC_B },
+    [0x6e] = { 0, KC_N },
+    [0x6d] = { 0, KC_M },
+    [0x2c] = { 0, KC_COMMA },
+    [0x2e] = { 0, KC_PERIOD },
+    [0x2f] = { 0, KC_SLASH },
+    [0x20] = { 0, KC_SPACE },
+    [0x1b] = { 0, KC_ESCAPE },
+    [0x0a] = { 0, KC_ENTER },
+    [0x0d] = { 0, KC_ENTER },
+    /* with Shift pressed */
+    [0x7e] = { KM_LSHIFT, KC_BACKTICK },
+    [0x21] = { KM_LSHIFT, KC_1 },
+    [0x40] = { KM_LSHIFT, KC_2 },
+    [0x23] = { KM_LSHIFT, KC_3 },
+    [0x24] = { KM_LSHIFT, KC_4 },
+    [0x25] = { KM_LSHIFT, KC_5 },
+    [0x5e] = { KM_LSHIFT, KC_6 },
+    [0x26] = { KM_LSHIFT, KC_7 },
+    [0x2a] = { KM_LSHIFT, KC_8 },
+    [0x28] = { KM_LSHIFT, KC_9 },
+    [0x29] = { KM_LSHIFT, KC_0 },
+    [0x5f] = { KM_LSHIFT, KC_MINUS },
+    [0x2b] = { KM_LSHIFT, KC_EQUALS },
+    [0x51] = { KM_LSHIFT, KC_Q },
+    [0x57] = { KM_LSHIFT, KC_W },
+    [0x45] = { KM_LSHIFT, KC_E },
+    [0x52] = { KM_LSHIFT, KC_R },
+    [0x54] = { KM_LSHIFT, KC_T },
+    [0x59] = { KM_LSHIFT, KC_Y },
+    [0x55] = { KM_LSHIFT, KC_U },
+    [0x49] = { KM_LSHIFT, KC_I },
+    [0x4f] = { KM_LSHIFT, KC_O },
+    [0x50] = { KM_LSHIFT, KC_P },
+    [0x7b] = { KM_LSHIFT, KC_LBRACKET },
+    [0x7d] = { KM_LSHIFT, KC_RBRACKET },
+    [0x41] = { KM_LSHIFT, KC_A },
+    [0x53] = { KM_LSHIFT, KC_S },
+    [0x44] = { KM_LSHIFT, KC_D },
+    [0x46] = { KM_LSHIFT, KC_F },
+    [0x47] = { KM_LSHIFT, KC_G },
+    [0x48] = { KM_LSHIFT, KC_H },
+    [0x4a] = { KM_LSHIFT, KC_J },
+    [0x4b] = { KM_LSHIFT, KC_K },
+    [0x4c] = { KM_LSHIFT, KC_L },
+    [0x3a] = { KM_LSHIFT, KC_SEMICOLON },
+    [0x22] = { KM_LSHIFT, KC_QUOTE },
+    [0x7c] = { KM_LSHIFT, KC_BACKSLASH },
+    [0x5a] = { KM_LSHIFT, KC_Z },
+    [0x58] = { KM_LSHIFT, KC_X },
+    [0x43] = { KM_LSHIFT, KC_C },
+    [0x56] = { KM_LSHIFT, KC_V },
+    [0x42] = { KM_LSHIFT, KC_B },
+    [0x4e] = { KM_LSHIFT, KC_N },
+    [0x4d] = { KM_LSHIFT, KC_M },
+    [0x3c] = { KM_LSHIFT, KC_COMMA },
+    [0x3e] = { KM_LSHIFT, KC_PERIOD },
+    [0x3f] = { KM_LSHIFT, KC_SLASH }
+};
+static int map_e1[][2] =
+{
+};
+static int map_e1a[][2] =
+{
+    [0x50] = { 0, KC_F1 },
+    [0x51] = { 0, KC_F2 },
+    [0x52] = { 0, KC_F3 },
+    [0x53] = { 0, KC_F4 },
+};
+static int map_e1b[][2] =
+{
+    [0x33] = { 0, KC_F5 },
+    [0x37] = { 0, KC_F6 },
+    [0x38] = { 0, KC_F7 },
+    [0x39] = { 0, KC_F8 },
+};
+static int map_e1c[][2] =
+{
+    [0x38] = { 0, KC_F9 },
+    [0x39] = { 0, KC_F10 },
+    [0x33] = { 0, KC_F11 },
+    [0x34] = { 0, KC_F12 },
+};
+static unsigned int mods_keys[][2] = {
+    { KM_LSHIFT, KC_LSHIFT },
+    { 0, 0 }
+};
+static enum dec_state ds = ds_start;
+void kbd_ctl_parse_scancode(int scancode)
+{
+    switch (ds) {
+    case ds_start:  parse_ds_start(scancode); break;
+    case ds_e:  parse_ds_e(scancode); break;
+    case ds_e1: parse_ds_e1(scancode); break;
+    case ds_e1a:    parse_ds_e1a(scancode); break;
+    case ds_e1b:    parse_ds_e1b(scancode); break;
+    case ds_e1c:    parse_ds_e1c(scancode); break;
+    }
+}
+static void parse_ds_start(int scancode)
+{
+    if (scancode == 0x1b) {
+        ds = ds_e;
+        return;
+    }
+    parse_leaf(scancode, map_start, sizeof(map_start) / (2 * sizeof(int)));
+}
+static void parse_ds_e(int scancode)
+{
+    switch (scancode) {
+    case 0x5b: ds = ds_e1; return;
+    case 0x1b: ds = ds_start; break;
+    default: ds = ds_start; return;
+    }
+    kbd_push_ev(KE_PRESS, KC_ESCAPE);
+}
+static void parse_ds_e1(int scancode)
+{
+    switch (scancode) {
+    case 0x4f: ds = ds_e1a; return;
+    case 0x31: ds = ds_e1b; return;
+    case 0x32: ds = ds_e1c; return;
+    default: ds = ds_start; break;
+    }
+    parse_leaf(scancode, map_e1, sizeof(map_e1) / (2 * sizeof(int)));
+}
+static void parse_ds_e1a(int scancode)
+{
+    parse_leaf(scancode, map_e1a, sizeof(map_e1a) / (2 * sizeof(int)));
+}
+static void parse_ds_e1b(int scancode)
+{
+    parse_leaf(scancode, map_e1b, sizeof(map_e1b) / (2 * sizeof(int)));
+}
+static void parse_ds_e1c(int scancode)
+{
+    parse_leaf(scancode, map_e1c, sizeof(map_e1c) / (2 * sizeof(int)));
+}
+static void parse_leaf(int scancode, int (*map)[2], size_t map_length)
+{
+    unsigned int key, mod;
+    int i;
+    ds = ds_start;
+    if (scancode < 0 || scancode >= map_length)
+        return;
+    mod = map[scancode][0];
+    key = map[scancode][1];
+    /* Simulate modifier pressing. */
+    i = 0;
+    while (mods_keys[i][0] != 0) {
+        if (mod & mods_keys[i][0]) {
+            kbd_push_ev(KE_PRESS, mods_keys[i][1]);
+        }
+        ++i;
+    }
+    if (key != 0) {
+        kbd_push_ev(KE_PRESS, key);
+        kbd_push_ev(KE_RELEASE, key);
+    }
+    /* Simulate modifier releasing. */
+    i = 0;
+    while (mods_keys[i][0] != 0) {
+        if (mod & mods_keys[i][0]) {
+            kbd_push_ev(KE_RELEASE, mods_keys[i][1]);
+        }
+        ++i;
+    }
+}
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/kbd/ctl/pc.c
 ,0 → 1,225
+/*
+ * 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 kbd_ctl
+ * @ingroup kbd
+ * @{
+ */
+/**
+ * @file
+ * @brief   PC keyboard controller driver.
+ */
+#include <kbd.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
+#include <kbd_ctl.h>
+enum dec_state {
+    ds_s,
+    ds_e
+};
+static enum dec_state ds = ds_s;
+static int scanmap_simple[] = {
+    [0x29] = KC_BACKTICK,
+    [0x02] = KC_1,
+    [0x03] = KC_2,
+    [0x04] = KC_3,
+    [0x05] = KC_4,
+    [0x06] = KC_5,
+    [0x07] = KC_6,
+    [0x08] = KC_7,
+    [0x09] = KC_8,
+    [0x0a] = KC_9,
+    [0x0b] = KC_0,
+    [0x0c] = KC_MINUS,
+    [0x0d] = KC_EQUALS,
+    [0x0e] = KC_BACKSPACE,
+    [0x0f] = KC_TAB,
+    [0x10] = KC_Q,
+    [0x11] = KC_W,
+    [0x12] = KC_E,
+    [0x13] = KC_R,
+    [0x14] = KC_T,
+    [0x15] = KC_Y,
+    [0x16] = KC_U,
+    [0x17] = KC_I,
+    [0x18] = KC_O,
+    [0x19] = KC_P,
+    [0x1a] = KC_LBRACKET,
+    [0x1b] = KC_RBRACKET,
+    [0x3a] = KC_CAPS_LOCK,
+    [0x1e] = KC_A,
+    [0x1f] = KC_S,
+    [0x20] = KC_D,
+    [0x21] = KC_F,
+    [0x22] = KC_G,
+    [0x23] = KC_H,
+    [0x24] = KC_J,
+    [0x25] = KC_K,
+    [0x26] = KC_L,
+    [0x27] = KC_SEMICOLON,
+    [0x28] = KC_QUOTE,
+    [0x2b] = KC_BACKSLASH,
+    [0x2a] = KC_LSHIFT,
+    [0x2c] = KC_Z,
+    [0x2d] = KC_X,
+    [0x2e] = KC_C,
+    [0x2f] = KC_V,
+    [0x30] = KC_B,
+    [0x31] = KC_N,
+    [0x32] = KC_M,
+    [0x33] = KC_COMMA,
+    [0x34] = KC_PERIOD,
+    [0x35] = KC_SLASH,
+    [0x36] = KC_RSHIFT,
+    [0x1d] = KC_LCTRL,
+    [0x38] = KC_LALT,
+    [0x39] = KC_SPACE,
+    [0x01] = KC_ESCAPE,
+    [0x3b] = KC_F1,
+    [0x3c] = KC_F2,
+    [0x3d] = KC_F3,
+    [0x3e] = KC_F4,
+    [0x3f] = KC_F5,
+    [0x40] = KC_F6,
+    [0x41] = KC_F7,
+    [0x42] = KC_F8,
+    [0x43] = KC_F9,
+    [0x44] = KC_F10,
+    [0x57] = KC_F11,
+    [0x58] = KC_F12,
+    [0x46] = KC_SCROLL_LOCK,
+    [0x1c] = KC_ENTER,
+    [0x45] = KC_NUM_LOCK,
+    [0x37] = KC_NTIMES,
+    [0x4a] = KC_NMINUS,
+    [0x4e] = KC_NPLUS,
+    [0x47] = KC_N7,
+    [0x48] = KC_N8,
+    [0x49] = KC_N9,
+    [0x4b] = KC_N4,
+    [0x4c] = KC_N5,
+    [0x4d] = KC_N6,
+    [0x4f] = KC_N1,
+    [0x50] = KC_N2,
+    [0x51] = KC_N3,
+    [0x52] = KC_N0,
+    [0x53] = KC_NPERIOD
+};
+static int scanmap_e0[] = {
+    [0x38] = KC_RALT,
+    [0x1d] = KC_RSHIFT,
+    [0x37] = KC_PRTSCR,
+    [0x52] = KC_INSERT,
+    [0x47] = KC_HOME,
+    [0x49] = KC_PAGE_UP,
+    [0x53] = KC_DELETE,
+    [0x4f] = KC_END,
+    [0x51] = KC_PAGE_DOWN,
+    [0x48] = KC_UP,
+    [0x4b] = KC_LEFT,
+    [0x50] = KC_DOWN,
+    [0x4d] = KC_RIGHT,
+    [0x35] = KC_NSLASH,
+    [0x1c] = KC_NENTER
+};
+void kbd_ctl_parse_scancode(int scancode)
+{
+    kbd_ev_type_t type;
+    unsigned int key;
+    int *map;
+    size_t map_length;
+    if (scancode == 0xe0) {
+        ds = ds_e;
+        return;
+    }
+    switch (ds) {
+    case ds_s:
+        map = scanmap_simple;
+        map_length = sizeof(scanmap_simple) / sizeof(int);
+        break;
+    case ds_e:
+        map = scanmap_e0;
+        map_length = sizeof(scanmap_e0) / sizeof(int);
+        break;
+    }
+    ds = ds_s;
+    if (scancode & 0x80) {
+        scancode &= ~0x80;
+        type = KE_RELEASE;
+    } else {
+        type = KE_PRESS;
+    }
+    if (scancode < 0 || scancode >= map_length)
+        return;
+    key = map[scancode];
+    if (key != 0)
+        kbd_push_ev(type, key);
+}
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/kbd/ctl/sun.c
 ,0 → 1,204
+/*
+ * 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 kbd_ctl
+ * @ingroup kbd
+ * @{
+ */
+/**
+ * @file
+ * @brief   Sun keyboard controller driver.
+ */
+#include <kbd.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
+#include <kbd_ctl.h>
+#define KBD_KEY_RELEASE     0x80
+#define KBD_ALL_KEYS_UP     0x7f
+static int scanmap_simple[];
+void kbd_ctl_parse_scancode(int scancode)
+{
+    kbd_ev_type_t type;
+    unsigned int key;
+    if (scancode < 0 || scancode >= 0x100)
+        return;
+    if (scancode == KBD_ALL_KEYS_UP)
+        return;
+    if (scancode & KBD_KEY_RELEASE) {
+        scancode &= ~KBD_KEY_RELEASE;
+        type = KE_RELEASE;
+    } else {
+        type = KE_PRESS;
+    }
+    key = scanmap_simple[scancode];
+    if (key != 0)
+        kbd_push_ev(type, key);
+}
+/** Primary meaning of scancodes. */
+static int scanmap_simple[] = {
+    [0x00] = 0,
+    [0x01] = 0,
+    [0x02] = 0,
+    [0x03] = 0,
+    [0x04] = 0,
+    [0x05] = KC_F1,
+    [0x06] = KC_F2,
+    [0x07] = KC_F10,
+    [0x08] = KC_F3,
+    [0x09] = KC_F11,
+    [0x0a] = KC_F4,
+    [0x0b] = KC_F12,
+    [0x0c] = KC_F5,
+    [0x0d] = KC_RALT,
+    [0x0e] = KC_F6,
+    [0x0f] = 0,
+    [0x10] = KC_F7,
+    [0x11] = KC_F8,
+    [0x12] = KC_F9,
+    [0x13] = KC_LALT,
+    [0x14] = KC_UP,
+    [0x15] = KC_PAUSE,
+    [0x16] = 0,
+    [0x17] = KC_SCROLL_LOCK,
+    [0x18] = KC_LEFT,
+    [0x19] = 0,
+    [0x1a] = 0,
+    [0x1b] = KC_DOWN,
+    [0x1c] = KC_RIGHT,
+    [0x1d] = KC_ESCAPE,
+    [0x1e] = KC_1,
+    [0x1f] = KC_2,
+    [0x20] = KC_3,
+    [0x21] = KC_4,
+    [0x22] = KC_5,
+    [0x23] = KC_6,
+    [0x24] = KC_7,
+    [0x25] = KC_8,
+    [0x26] = KC_9,
+    [0x27] = KC_0,
+    [0x28] = KC_MINUS,
+    [0x29] = KC_EQUALS,
+    [0x2a] = KC_BACKTICK,
+    [0x2b] = KC_BACKSPACE,
+    [0x2c] = KC_INSERT,
+    [0x2d] = 0,
+    [0x2e] = KC_NSLASH,
+    [0x2f] = KC_NTIMES,
+    [0x30] = 0,
+    [0x31] = 0,
+    [0x32] = KC_NPERIOD,
+    [0x33] = 0,
+    [0x34] = KC_HOME,
+    [0x35] = KC_TAB,
+    [0x36] = KC_Q,
+    [0x37] = KC_W,
+    [0x38] = KC_E,
+    [0x39] = KC_R,
+    [0x3a] = KC_T,
+    [0x3b] = KC_Y,
+    [0x3c] = KC_U,
+    [0x3d] = KC_I,
+    [0x3e] = KC_O,
+    [0x3f] = KC_P,
+    [0x40] = KC_LBRACKET,
+    [0x41] = KC_RBRACKET,
+    [0x42] = KC_DELETE,
+    [0x43] = 0,
+    [0x44] = KC_N7,
+    [0x45] = KC_N8,
+    [0x46] = KC_N9,
+    [0x47] = KC_NMINUS,
+    [0x48] = 0,
+    [0x49] = 0,
+    [0x4a] = KC_END,
+    [0x4b] = 0,
+    [0x4c] = KC_LCTRL,
+    [0x4d] = KC_A,
+    [0x4e] = KC_S,
+    [0x4f] = KC_D,
+    [0x50] = KC_F,
+    [0x51] = KC_G,
+    [0x52] = KC_H,
+    [0x53] = KC_J,
+    [0x54] = KC_K,
+    [0x55] = KC_L,
+    [0x56] = KC_SEMICOLON,
+    [0x57] = KC_QUOTE,
+    [0x58] = KC_BACKSLASH,
+    [0x59] = KC_ENTER,
+    [0x5a] = KC_NENTER,
+    [0x5b] = KC_N4,
+    [0x5c] = KC_N5,
+    [0x5d] = KC_N6,
+    [0x5e] = KC_N0,
+    [0x5f] = 0,
+    [0x60] = KC_PAGE_UP,
+    [0x61] = 0,
+    [0x62] = KC_NUM_LOCK,
+    [0x63] = KC_LSHIFT,
+    [0x64] = KC_Z,
+    [0x65] = KC_X,
+    [0x66] = KC_C,
+    [0x67] = KC_V,
+    [0x68] = KC_B,
+    [0x69] = KC_N,
+    [0x6a] = KC_M,
+    [0x6b] = KC_COMMA,
+    [0x6c] = KC_PERIOD,
+    [0x6d] = KC_SLASH,
+    [0x6e] = KC_RSHIFT,
+    [0x6f] = 0,
+    [0x70] = KC_N1,
+    [0x71] = KC_N2,
+    [0x72] = KC_N3,
+    [0x73] = 0,
+    [0x74] = 0,
+    [0x75] = 0,
+    [0x76] = 0,
+    [0x77] = KC_CAPS_LOCK,
+    [0x78] = 0,
+    [0x79] = KC_SPACE,
+    [0x7a] = 0,
+    [0x7b] = KC_PAGE_DOWN,
+    [0x7c] = 0,
+    [0x7d] = KC_NPLUS,
+    [0x7e] = 0,
+    [0x7f] = 0
+};
+/** @}
+ */

 /branches/dd/uspace/srv/kbd/include/layout.h
 ,0 → 1,49
+/*
+ * 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 kbdgen generic
+ * @brief   HelenOS generic uspace keyboard handler.
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ */
+#ifndef KBD_LAYOUT_H_
+#define KBD_LAYOUT_H_
+#include <kbd/kbd.h>
+extern char layout_parse_ev(kbd_event_t *);
+#endif
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/kbd/include/kbd.h
 ,10 → 39,18
 #include <key_buffer.h>
-extern int kbd_arch_init(void);
-extern int kbd_arch_process(keybuffer_t *keybuffer, ipc_call_t *call);
-extern int mouse_arch_process(int phoneid, ipc_call_t *call);
+#define KBD_EVENT   1024
+#define KBD_MS_LEFT 1025
+#define KBD_MS_RIGHT    1026
+#define KBD_MS_MIDDLE   1027
+#define KBD_MS_MOVE 1028
+extern int cir_service;
+extern int cir_phone;
+extern void kbd_push_scancode(int);
+extern void kbd_push_ev(int, unsigned int);
 #endif
 /**

 /branches/dd/uspace/srv/kbd/include/key_buffer.h
 ,23 → 38,25
 #define __KEY_BUFFER_H__
 #include <sys/types.h>
+#include <kbd/kbd.h>
 /** Size of buffer for pressed keys */
 #define KEYBUFFER_SIZE 128
 typedef struct {
-    int fifo[KEYBUFFER_SIZE];
+    kbd_event_t fifo[KEYBUFFER_SIZE];
     unsigned long head;
     unsigned long tail;
     unsigned long items;
 } keybuffer_t;
-void keybuffer_free(keybuffer_t *keybuffer);
-void keybuffer_init(keybuffer_t *keybuffer);
-int keybuffer_available(keybuffer_t *keybuffer);
-int keybuffer_empty(keybuffer_t *keybuffer);
-void keybuffer_push(keybuffer_t *keybuffer, int key);
-int keybuffer_pop(keybuffer_t *keybuffer, int *c);
+extern void keybuffer_free(keybuffer_t *);
+extern void keybuffer_init(keybuffer_t *);
+extern int keybuffer_available(keybuffer_t *);
+extern int keybuffer_empty(keybuffer_t *);
+extern void keybuffer_push(keybuffer_t *, const kbd_event_t *);
+extern void keybuffer_push0(keybuffer_t *, int c);
+extern int keybuffer_pop(keybuffer_t *, kbd_event_t *);
 #endif

 /branches/dd/uspace/srv/kbd/include/kbd_ctl.h
 ,0 → 1,47
+/*
+ * 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 kbdgen generic
+ * @brief   HelenOS generic uspace keyboard handler.
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ */
+#ifndef KBD_CTL_H_
+#define KBD_CTL_H_
+extern void kbd_ctl_parse_scancode(int);
+#endif
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/kbd/include/kbd_port.h
 ,0 → 1,47
+/*
+ * 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 kbdgen generic
+ * @brief   HelenOS generic uspace keyboard handler.
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ */
+#ifndef KBD_PORT_H_
+#define KBD_PORT_H_
+extern int kbd_port_init(void);
+#endif
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/kbd/port/ski.c
 ,0 → 1,107
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * 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 kbd_port
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ * @brief   Ski console keyboard port driver.
+ */
+#include <stdlib.h>
+#include <unistd.h>
+#include <kbd.h>
+#include <kbd_port.h>
+#include <sys/types.h>
+#include <thread.h>
+#define SKI_GETCHAR     21
+#define POLL_INTERVAL       10000
+static void *ski_thread_impl(void *arg);
+static int32_t ski_getchar(void);
+/** Initialize Ski port driver. */
+int kbd_port_init(void)
+{
+    thread_id_t tid;
+    int rc;
+    rc = thread_create(ski_thread_impl, NULL, "kbd_poll", &tid);
+    if (rc != 0) {
+        return rc;
+    }
+    return 0;
+}
+/** Thread to poll Ski for keypresses. */
+static void *ski_thread_impl(void *arg)
+{
+    int32_t c;
+    (void) arg;
+    while (1) {
+        c = ski_getchar();
+        if (c != 0)
+            kbd_push_scancode(c);
+        usleep(POLL_INTERVAL);
+    }
+}
+/** Ask Ski if a key was pressed.
+ *
+ * Use SSC (Simulator System Call) to get character from the debug console.
+ * This call is non-blocking.
+ *
+ * @return ASCII code of pressed key or 0 if no key pressed.
+ */
+static int32_t ski_getchar(void)
+{
+    uint64_t ch;
+    asm volatile (
+        "mov r15 = %1\n"
+        "break 0x80000;;\n" /* modifies r8 */
+        "mov %0 = r8;;\n"
+        : "=r" (ch)
+        : "i" (SKI_GETCHAR)
+        : "r15", "r8"
+    );
+    return (int32_t) ch;
+}
+/** @}
+ */

 /branches/dd/uspace/srv/kbd/port/ns16550.c
 ,0 → 1,115
+/*
+ * 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 kbd_port
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ * @brief   NS16550 port driver.
+ */
+#include <ipc/ipc.h>
+#include <async.h>
+#include <sysinfo.h>
+#include <kbd.h>
+#include <kbd_port.h>
+#include <ddi.h>
+/* NS16550 registers */
+#define RBR_REG     0    /** Receiver Buffer Register. */
+#define IER_REG     1   /** Interrupt Enable Register. */
+#define IIR_REG     2   /** Interrupt Ident Register (read). */
+#define FCR_REG     2   /** FIFO control register (write). */
+#define LCR_REG     3   /** Line Control register. */
+#define MCR_REG     4   /** Modem Control Register. */
+#define LSR_REG     5   /** Line Status Register. */
+#define LSR_DATA_READY  0x01
+static irq_cmd_t ns16550_cmds[] = {
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = (void *) 0, /* will be patched in run-time */
+        .dstarg = 1
+    },
+    {
+        .cmd = CMD_BTEST,
+        .value = LSR_DATA_READY,
+        .srcarg = 1,
+        .dstarg = 3
+    },
+    {
+        .cmd = CMD_PREDICATE,
+        .value = 2,
+        .srcarg = 3
+    },
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = (void *) 0, /* will be patched in run-time */
+        .dstarg = 2
+    },
+    {
+        .cmd = CMD_ACCEPT
+    }
+};
+irq_code_t ns16550_kbd = {
+    sizeof(ns16550_cmds) / sizeof(irq_cmd_t),
+    ns16550_cmds
+};
+static void ns16550_irq_handler(ipc_callid_t iid, ipc_call_t *call);
+static uintptr_t ns16550_physical;
+static uintptr_t ns16550_kernel;
+int kbd_port_init(void)
+{
+    void *vaddr;
+    async_set_interrupt_received(ns16550_irq_handler);
+    ns16550_physical = sysinfo_value("kbd.address.physical");
+    ns16550_kernel = sysinfo_value("kbd.address.kernel");
+    ns16550_kbd.cmds[0].addr = (void *) (ns16550_kernel + LSR_REG);
+    ns16550_kbd.cmds[3].addr = (void *) (ns16550_kernel + RBR_REG);
+    ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"),
+, &ns16550_kbd);
+    return pio_enable((void *) ns16550_physical, 8, &vaddr);
+}
+static void ns16550_irq_handler(ipc_callid_t iid, ipc_call_t *call)
+{
+    int scan_code = IPC_GET_ARG2(*call);
+    kbd_push_scancode(scan_code);
+}
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/kbd/port/i8042.c
 ,0 → 1,168
+/*
+ * Copyright (c) 2001-2004 Jakub Jermar
+ * 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 kbd_port
+ * @ingroup kbd
+ * @{
+ */
+/** @file
+ * @brief i8042 port driver.
+ */
+#include <ddi.h>
+#include <libarch/ddi.h>
+#include <ipc/ipc.h>
+#include <async.h>
+#include <unistd.h>
+#include <sysinfo.h>
+#include <kbd_port.h>
+#include <kbd.h>
+#include "i8042.h"
+/* Interesting bits for status register */
+#define i8042_OUTPUT_FULL  0x1
+#define i8042_INPUT_FULL   0x2
+#define i8042_MOUSE_DATA   0x20
+/* Command constants */
+#define i8042_CMD_KBD 0x60
+#define i8042_CMD_MOUSE  0xd4
+/* Keyboard cmd byte */
+#define i8042_KBD_IE        0x1
+#define i8042_MOUSE_IE      0x2
+#define i8042_KBD_DISABLE   0x10
+#define i8042_MOUSE_DISABLE 0x20
+#define i8042_KBD_TRANSLATE 0x40
+/* Mouse constants */
+#define MOUSE_OUT_INIT  0xf4
+#define MOUSE_ACK       0xfa
+static irq_cmd_t i8042_cmds[] = {
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = NULL,   /* will be patched in run-time */
+        .dstarg = 1
+    },
+    {
+        .cmd = CMD_BTEST,
+        .value = i8042_OUTPUT_FULL,
+        .srcarg = 1,
+        .dstarg = 3
+    },
+    {
+        .cmd = CMD_PREDICATE,
+        .value = 2,
+        .srcarg = 3
+    },
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = NULL,   /* will be patched in run-time */
+        .dstarg = 2
+    },
+    {
+        .cmd = CMD_ACCEPT
+    }
+};
+static irq_code_t i8042_kbd = {
+    sizeof(i8042_cmds) / sizeof(irq_cmd_t),
+    i8042_cmds
+};
+static uintptr_t i8042_physical;
+static uintptr_t i8042_kernel;
+static i8042_t * i8042;
+static void wait_ready(void) {
+    while (pio_read_8(&i8042->status) & i8042_INPUT_FULL)
+        ;
+}
+static void i8042_irq_handler(ipc_callid_t iid, ipc_call_t *call);
+int kbd_port_init(void)
+{
+    int mouseenabled = 0;
+    void *vaddr;
+    i8042_physical = sysinfo_value("kbd.address.physical");
+    i8042_kernel = sysinfo_value("kbd.address.kernel");
+    if (pio_enable((void *) i8042_physical, sizeof(i8042_t), &vaddr) != 0)
+        return -1;
+    i8042 = vaddr;
+    async_set_interrupt_received(i8042_irq_handler);
+    /* Disable kbd, enable mouse */
+    pio_write_8(&i8042->status, i8042_CMD_KBD);
+    wait_ready();
+    pio_write_8(&i8042->status, i8042_CMD_KBD);
+    wait_ready();
+    pio_write_8(&i8042->data, i8042_KBD_DISABLE);
+    wait_ready();
+    /* Flush all current IO */
+    while (pio_read_8(&i8042->status) & i8042_OUTPUT_FULL)
+        (void) pio_read_8(&i8042->data);
+    /* Enable kbd */
+    i8042_kbd.cmds[0].addr = &((i8042_t *) i8042_kernel)->status;
+    i8042_kbd.cmds[3].addr = &((i8042_t *) i8042_kernel)->data;
+    ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"), 0, &i8042_kbd);
+    int newcontrol = i8042_KBD_IE | i8042_KBD_TRANSLATE;
+    if (mouseenabled)
+        newcontrol |= i8042_MOUSE_IE;
+    pio_write_8(&i8042->status, i8042_CMD_KBD);
+    wait_ready();
+    pio_write_8(&i8042->data, newcontrol);
+    wait_ready();
+    return 0;
+}
+static void i8042_irq_handler(ipc_callid_t iid, ipc_call_t *call)
+{
+    int status = IPC_GET_ARG1(*call);
+    if ((status & i8042_MOUSE_DATA))
+        return;
+    int scan_code = IPC_GET_ARG2(*call);
+    kbd_push_scancode(scan_code);
+    return;
+}
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/kbd/port/z8530.c
 ,0 → 1,108
+/*
+ * 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.
+ */
+/** @addtogroup kbd_port
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ * @brief   Z8530 keyboard port driver.
+ */
+#include <ipc/ipc.h>
+#include <ipc/bus.h>
+#include <async.h>
+#include <sysinfo.h>
+#include <kbd.h>
+#include <kbd_port.h>
+#include <sys/types.h>
+#include <ddi.h>
+#define CHAN_A_STATUS   4
+#define CHAN_A_DATA 6
+#define RR0_RCA 1
+static irq_cmd_t z8530_cmds[] = {
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = (void *) 0, /* will be patched in run-time */
+        .dstarg = 1
+    },
+    {
+        .cmd = CMD_BTEST,
+        .value = RR0_RCA,
+        .srcarg = 1,
+        .dstarg = 3
+    },
+    {
+        .cmd = CMD_PREDICATE,
+        .value = 2,
+        .srcarg = 3
+    },
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = (void *) 0, /* will be patched in run-time */
+        .dstarg = 2
+    },
+    {
+        .cmd = CMD_ACCEPT
+    }
+};
+irq_code_t z8530_kbd = {
+    sizeof(z8530_cmds) / sizeof(irq_cmd_t),
+    z8530_cmds
+};
+static void z8530_irq_handler(ipc_callid_t iid, ipc_call_t *call);
+int kbd_port_init(void)
+{
+    async_set_interrupt_received(z8530_irq_handler);
+    z8530_cmds[0].addr = (void *) sysinfo_value("kbd.address.kernel") +
+        CHAN_A_STATUS;
+    z8530_cmds[3].addr = (void *) sysinfo_value("kbd.address.kernel") +
+        CHAN_A_DATA;
+    ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"),
+        sysinfo_value("kbd.inr"), &z8530_kbd);
+    return 0;
+}
+static void z8530_irq_handler(ipc_callid_t iid, ipc_call_t *call)
+{
+    int scan_code = IPC_GET_ARG2(*call);
+    kbd_push_scancode(scan_code);
+    if (cir_service)
+        async_msg_1(cir_phone, BUS_CLEAR_INTERRUPT,
+            IPC_GET_METHOD(*call));
+}
+/** @}
+ */

 /branches/dd/uspace/srv/kbd/port/i8042.h
 ,0 → 1,55
+/*
+ * 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 kbd_port
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ * @brief i8042 port driver.
+ */
+#ifndef KBD_PORT_i8042_H_
+#define KBD_PORT_i8042_H_
+#include <libarch/ddi.h>
+#include <libarch/types.h>
+struct i8042 {
+    ioport8_t data;
+    uint8_t pad[3];
+    ioport8_t status;
+} __attribute__ ((packed));
+typedef struct i8042 i8042_t;
+#endif
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/kbd/port/msim.c
 ,0 → 1,91
+/*
+ * 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 kbd_port
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ * @brief   Msim keyboard port driver.
+ */
+#include <ipc/ipc.h>
+#include <async.h>
+#include <sysinfo.h>
+#include <kbd_port.h>
+#include <kbd.h>
+irq_cmd_t msim_cmds[] = {
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = (void *) 0, /* will be patched in run-time */
+        .dstarg = 2
+    },
+    {
+        .cmd = CMD_ACCEPT
+    }
+};
+irq_code_t msim_kbd = {
+    sizeof(msim_cmds) / sizeof(irq_cmd_t),
+    msim_cmds
+};
+static void msim_irq_handler(ipc_callid_t iid, ipc_call_t *call);
+int kbd_port_init(void)
+{
+    async_set_interrupt_received(msim_irq_handler);
+    msim_cmds[0].addr = sysinfo_value("kbd.address.virtual");
+    ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"),
+, &msim_kbd);
+    return 0;
+}
+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/dd/uspace/srv/kbd/port/gxemul.c
 ,0 → 1,86
+/*
+ * Copyright (c) 2007 Michal Kebrt
+ * 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 kbd_port
+ * @{
+ * @ingroup  kbd
+ */
+/** @file
+ * @brief   GXEmul keyboard port driver.
+ */
+#include <ipc/ipc.h>
+#include <async.h>
+#include <sysinfo.h>
+#include <kbd_port.h>
+#include <kbd.h>
+static irq_cmd_t gxemul_cmds[] = {
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = (void *) 0,     /* will be patched in run-time */
+        .dstarg = 2,
+    },
+    {
+        .cmd = CMD_ACCEPT
+    }
+};
+static irq_code_t gxemul_kbd = {
+    sizeof(gxemul_cmds) / sizeof(irq_cmd_t),
+    gxemul_cmds
+};
+static void gxemul_irq_handler(ipc_callid_t iid, ipc_call_t *call);
+/** Initializes keyboard handler. */
+int kbd_port_init(void)
+{
+    async_set_interrupt_received(gxemul_irq_handler);
+    gxemul_cmds[0].addr = (void *) sysinfo_value("kbd.address.virtual");
+    ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"),
+, &gxemul_kbd);
+    return 0;
+}
+/** Process data sent when a key is pressed.
+ *
+ *  @param keybuffer Buffer of pressed keys.
+ *  @param call      IPC call.
+ *
+ *  @return Always 1.
+ */
+static void gxemul_irq_handler(ipc_callid_t iid, ipc_call_t *call)
+{
+    int scan_code = IPC_GET_ARG2(*call);
+    kbd_push_scancode(scan_code);
+}
+/** @}
+ */

 /branches/dd/uspace/srv/kbd/port/sgcn.c
 ,0 → 1,141
+/*
+ * Copyright (c) 2008 Pavel Rimsky
+ * 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 kbd_port
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ * @brief   SGCN (Serengeti Console) keyboard port driver.
+ */
+#include <as.h>
+#include <ddi.h>
+#include <ipc/ipc.h>
+#include <async.h>
+#include <kbd.h>
+#include <kbd_port.h>
+#include <sysinfo.h>
+#include <stdio.h>
+/**
+ * SGCN buffer header. It is placed at the very beginning of the SGCN
+ * buffer.
+ */
+typedef struct {
+    /** hard-wired to "CON" */
+    char magic[4];
+    /** we don't need this */
+    char unused[8];
+    /** offset within the SGCN buffer of the input buffer start */
+    uint32_t in_begin;
+    /** offset within the SGCN buffer of the input buffer end */
+    uint32_t in_end;
+    /** offset within the SGCN buffer of the input buffer read pointer */
+    uint32_t in_rdptr;
+    /** offset within the SGCN buffer of the input buffer write pointer */
+    uint32_t in_wrptr;
+} __attribute__ ((packed)) sgcn_buffer_header_t;
+/*
+ * Returns a pointer to the object of a given type which is placed at the given
+ * offset from the console buffer beginning.
+ */
+#define SGCN_BUFFER(type, offset) \
+        ((type *) (sram_virt_addr + sram_buffer_offset + (offset)))
+/** Returns a pointer to the console buffer header. */
+#define SGCN_BUFFER_HEADER  (SGCN_BUFFER(sgcn_buffer_header_t, 0))
+/**
+ * Virtual address mapped to SRAM.
+ */
+static uintptr_t sram_virt_addr;
+/**
+ * SGCN buffer offset within SGCN.
+ */
+static uintptr_t sram_buffer_offset;
+static void sgcn_irq_handler(ipc_callid_t iid, ipc_call_t *call);
+/**
+ * Initializes the SGCN driver.
+ * Maps the physical memory (SRAM) and registers the interrupt.
+ */
+int kbd_port_init(void)
+{
+    async_set_interrupt_received(sgcn_irq_handler);
+    sram_virt_addr = (uintptr_t) as_get_mappable_page(sysinfo_value("sram.area.size"));
+    if (physmem_map((void *) sysinfo_value("sram.address.physical"),
+        (void *) sram_virt_addr, sysinfo_value("sram.area.size") / PAGE_SIZE,
+        AS_AREA_READ | AS_AREA_WRITE) != 0) {
+        printf("SGCN: uspace driver could not map physical memory.");
+        return -1;
+    }
+    sram_buffer_offset = sysinfo_value("sram.buffer.offset");
+    ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"),
+, (void *) 0);
+    return 0;
+}
+/**
+ * Handler of the "key pressed" event. Reads codes of all the pressed keys from
+ * the buffer.
+ */
+static void sgcn_irq_handler(ipc_callid_t iid, ipc_call_t *call)
+{
+    char c;
+    uint32_t begin = SGCN_BUFFER_HEADER->in_begin;
+    uint32_t end = SGCN_BUFFER_HEADER->in_end;
+    uint32_t size = end - begin;
+    volatile char *buf_ptr = (volatile char *)
+        SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);
+    volatile uint32_t *in_wrptr_ptr = &(SGCN_BUFFER_HEADER->in_wrptr);
+    volatile uint32_t *in_rdptr_ptr = &(SGCN_BUFFER_HEADER->in_rdptr);
+    while (*in_rdptr_ptr != *in_wrptr_ptr) {
+        c = *buf_ptr;
+        *in_rdptr_ptr = (((*in_rdptr_ptr) - begin + 1) % size) + begin;
+        buf_ptr = (volatile char *)
+            SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);
+        kbd_push_scancode(c);
+    }
+}
+/** @}
+ */

 /branches/dd/uspace/srv/kbd/port/dummy.c
 ,0 → 1,46
+/*
+ * 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 kbd_port
+ * @brief   Dummy keyboard port driver.
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ */
+#include <kbd_port.h>
+#include <kbd.h>
+int kbd_port_init(void)
+{
+    return 0;
+}
+/** @}
+*/

 /branches/dd/uspace/srv/kbd/generic/kbd.c
 ,48 → 37,99
 #include <ipc/ipc.h>
 #include <ipc/services.h>
+#include <sysinfo.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <ipc/ns.h>
+#include <async.h>
 #include <errno.h>
-#include <arch/kbd.h>
+#include <libadt/fifo.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
 #include <kbd.h>
-#include <libadt/fifo.h>
 #include <key_buffer.h>
-#include <async.h>
-#include <keys.h>
+#include <kbd_port.h>
+#include <kbd_ctl.h>
+#include <layout.h>
-#define NAME "KBD"
+#define NAME "kbd"
 int cons_connected = 0;
 int phone2cons = -1;
-keybuffer_t keybuffer;
+keybuffer_t keybuffer;
-static void irq_handler(ipc_callid_t iid, ipc_call_t *call)
+/** Currently active modifiers. */
+static unsigned mods = KM_NUM_LOCK;
+/** Currently pressed lock keys. We track these to tackle autorepeat. */
+static unsigned lock_keys;
+int cir_service = 0;
+int cir_phone = -1;
+void kbd_push_scancode(int scancode)
 {
-    int chr;
+/*  printf("scancode: 0x%x\n", scancode);*/
+    kbd_ctl_parse_scancode(scancode);
+}
-#ifdef MOUSE_ENABLED
-    if (mouse_arch_process(phone2cons, call))
-        return;
-#endif
-    kbd_arch_process(&keybuffer, call);
+void kbd_push_ev(int type, unsigned int key)
+{
+    kbd_event_t ev;
+    unsigned mod_mask;
-    if (cons_connected && phone2cons != -1) {
-        /*
-         * recode to ASCII - one interrupt can produce more than one
-         * code so result is stored in fifo
-         */
-        while (!keybuffer_empty(&keybuffer)) {
-            if (!keybuffer_pop(&keybuffer, (int *)&chr))
-                break;
+    switch (key) {
+    case KC_LCTRL: mod_mask = KM_LCTRL; break;
+    case KC_RCTRL: mod_mask = KM_RCTRL; break;
+    case KC_LSHIFT: mod_mask = KM_LSHIFT; break;
+    case KC_RSHIFT: mod_mask = KM_RSHIFT; break;
+    case KC_LALT: mod_mask = KM_LALT; break;
+    case KC_RALT: mod_mask = KM_RALT; break;
+    default: mod_mask = 0; break;
+    }
-            async_msg_1(phone2cons, KBD_PUSHCHAR, chr);
+    if (mod_mask != 0) {
+        if (type == KE_PRESS)
+            mods = mods | mod_mask;
+        else
+            mods = mods & ~mod_mask;
+    }
+    switch (key) {
+    case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break;
+    case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; break;
+    case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; break;
+    default: mod_mask = 0; break;
+    }
+    if (mod_mask != 0) {
+        if (type == KE_PRESS) {
+            /*
+             * Only change lock state on transition from released
+             * to pressed. This prevents autorepeat from messing
+             * up the lock state.
+             */
+            mods = mods ^ (mod_mask & ~lock_keys);
+            lock_keys = lock_keys | mod_mask;
+        } else {
+            lock_keys = lock_keys & ~mod_mask;
         }
     }
+/*
+    printf("type: %d\n", type);
+    printf("mods: 0x%x\n", mods);
+    printf("keycode: %u\n", key);
+*/
+    ev.type = type;
+    ev.key = key;
+    ev.mods = mods;
+    ev.c = layout_parse_ev(&ev);
+    async_msg_4(phone2cons, KBD_EVENT, ev.type, ev.key, ev.mods, ev.c);
 }
 static void console_connection(ipc_callid_t iid, ipc_call_t *icall)
 ,10 → 172,24
 int main(int argc, char **argv)
 {
+    printf(NAME ": HelenOS Keyboard service\n");
     ipcarg_t phonead;
-    /* Initialize arch dependent parts */
-    if (kbd_arch_init())
+    if (sysinfo_value("kbd.cir.fhc") == 1)
+        cir_service = SERVICE_FHC;
+    else if (sysinfo_value("kbd.cir.obio") == 1)
+        cir_service = SERVICE_OBIO;
+    if (cir_service) {
+        while (cir_phone < 0) {
+            cir_phone = ipc_connect_me_to_blocking(PHONE_NS, cir_service,
+, 0);
+        }
+    }
+    /* Initialize port driver. */
+    if (kbd_port_init())
         return -1;
     /* Initialize key buffer */
 ,14 → 196,15
     keybuffer_init(&keybuffer);
     async_set_client_connection(console_connection);
-    async_set_interrupt_received(irq_handler);
-    /* Register service at nameserver */
+    /* Register service at nameserver. */
     if (ipc_connect_to_me(PHONE_NS, SERVICE_KEYBOARD, 0, 0, &phonead) != 0)
         return -1;
+    printf(NAME ": Accepting connections\n");
     async_manager();
-    /* Never reached */
+    /* Not reached. */
     return 0;
 }
 ,4 → 211,3
 /**
  * @}
  */

 /branches/dd/uspace/srv/kbd/generic/key_buffer.c
 ,7 → 40,7
 /** Clear key buffer.
  */
-void keybuffer_free(keybuffer_t *keybuffer)
+void keybuffer_free(keybuffer_t *keybuffer)
 {
     futex_down(&keybuffer_futex);
     keybuffer->head = 0;
 ,15 → 75,18
     return (keybuffer->items == 0);
 }
-/** Push key to key buffer.
- * If buffer is full, character is ignored.
- * @param key code of stored key
+/** 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, int key)
+void keybuffer_push(keybuffer_t *keybuffer, const kbd_event_t *ev)
 {
     futex_down(&keybuffer_futex);
     if (keybuffer->items < KEYBUFFER_SIZE) {
-        keybuffer->fifo[keybuffer->tail] = key;
+        keybuffer->fifo[keybuffer->tail] = *ev;
         keybuffer->tail = (keybuffer->tail + 1) % KEYBUFFER_SIZE;
         keybuffer->items++;
     }
 ,16 → 93,25
     futex_up(&keybuffer_futex);
 }
-/** Pop character from buffer.
- * @param c pointer to space where to store character from buffer.
- * @return zero on empty buffer, nonzero else
+void keybuffer_push0(keybuffer_t *keybuffer, int c)
+{
+    kbd_event_t ev;
+    ev.key = c; ev.mods = 0; ev.c = c;
+    keybuffer_push(keybuffer, &ev);
+}
+/** Pop event from buffer.
+ *
+ * @param edst  Pointer to where the event should be saved.
+ * @return  Zero on empty buffer, nonzero otherwise.
  */
-int keybuffer_pop(keybuffer_t *keybuffer, int *c)
+int keybuffer_pop(keybuffer_t *keybuffer, kbd_event_t *edst)
 {
     futex_down(&keybuffer_futex);
     if (keybuffer->items > 0) {
         keybuffer->items--;
-        *c = (keybuffer->fifo[keybuffer->head]) ;
+        *edst = (keybuffer->fifo[keybuffer->head]) ;
         keybuffer->head = (keybuffer->head + 1) % KEYBUFFER_SIZE;
         futex_up(&keybuffer_futex);
         return 1;

 /branches/dd/uspace/srv/kbd/Makefile
 ,9 → 31,9
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
-include $(LIBC_PREFIX)/Makefile.toolchain
-include ../../../Makefile.config
+include $(LIBC_PREFIX)/Makefile.toolchain
 CFLAGS += -Iinclude -I../libadt/include
 LIBS = $(LIBC_PREFIX)/libc.a
 ,65 → 46,105
     generic/kbd.c \
     generic/key_buffer.c
-ARCH_SOURCES = \
-    arch/$(ARCH)/src/kbd.c
+ARCH_SOURCES =
+GENARCH_SOURCES =
-ifeq ($(ARCH), ia32)
-    ARCH_SOURCES += \
-        arch/$(ARCH)/src/mouse.c \
-        arch/$(ARCH)/src/scanc.c
-    GENARCH_SOURCES = \
-        genarch/src/kbd.c
-    CFLAGS += -DMOUSE_ENABLED
+ifeq ($(KBD_LAYOUT), us_qwerty)
+    GENARCH_SOURCES += layout/us_qwerty.c
 endif
-ifeq ($(ARCH), amd64)
-    ARCH_SOURCES += \
-        arch/$(ARCH)/src/mouse.c \
-        arch/$(ARCH)/src/scanc.c
-    GENARCH_SOURCES = \
-        genarch/src/kbd.c
-    CFLAGS += -DMOUSE_ENABLED
+ifeq ($(KBD_LAYOUT), us_dvorak)
+    GENARCH_SOURCES += layout/us_dvorak.c
 endif
-ifeq ($(ARCH), sparc64)
-    ARCH_SOURCES += \
-        arch/$(ARCH)/src/scanc.c
-    GENARCH_SOURCES = \
-        genarch/src/kbd.c
+ifeq ($(UARCH), amd64)
+    GENARCH_SOURCES += \
+        port/i8042.c \
+        ctl/pc.c
 endif
-ifeq ($(ARCH), arm32)
-ifeq ($(MACHINE), gxemul_testarm)
-    ARCH_SOURCES += \
-        arch/$(ARCH)/src/kbd_gxemul.c
+ifeq ($(UARCH), arm32)
+    GENARCH_SOURCES += \
+        port/gxemul.c
+    ifeq ($(CONFIG_FB), y)
+        GENARCH_SOURCES += \
+            ctl/gxe_fb.c
+    else
+        GENARCH_SOURCES += \
+            ctl/stty.c
+    endif
 endif
+ifeq ($(UARCH), ia32)
+    GENARCH_SOURCES += \
+        port/i8042.c \
+        ctl/pc.c
 endif
+ifeq ($(MACHINE), i640GX)
+    GENARCH_SOURCES += \
+        port/i8042.c \
+        ctl/pc.c
+endif
+ifeq ($(MACHINE), ski)
+    GENARCH_SOURCES += \
+        port/ski.c \
+        ctl/stty.c
+endif
+ifeq ($(MACHINE), msim)
+    GENARCH_SOURCES += \
+        port/msim.c \
+        ctl/stty.c
+endif
+ifeq ($(MACHINE), lgxemul)
+    GENARCH_SOURCES += \
+        port/gxemul.c
+    ifeq ($(CONFIG_FB), y)
+        GENARCH_SOURCES += \
+            ctl/gxe_fb.c
+    else
+        GENARCH_SOURCES += \
+            ctl/stty.c
+    endif
+endif
+ifeq ($(MACHINE), bgxemul)
+    GENARCH_SOURCES += \
+        port/gxemul.c \
+        ctl/stty.c
+endif
+ifeq ($(UARCH), ppc32)
+    GENARCH_SOURCES += \
+        port/dummy.c \
+        ctl/stty.c
+endif
+ifeq ($(UARCH), sparc64)
+    GENARCH_SOURCES += \
+        port/z8530.c \
+        ctl/sun.c
+endif
 GENERIC_OBJECTS := $(addsuffix .o,$(basename $(GENERIC_SOURCES)))
 ARCH_OBJECTS := $(addsuffix .o,$(basename $(ARCH_SOURCES)))
 GENARCH_OBJECTS := $(addsuffix .o,$(basename $(GENARCH_SOURCES)))
+OBJECTS := $(ARCH_OBJECTS) $(GENERIC_OBJECTS) $(GENARCH_OBJECTS)
 .PHONY: all clean depend disasm links
-all: links $(OUTPUT) disasm
+all: $(OUTPUT) $(OUTPUT).disasm
 -include Makefile.depend
-links:
-    ln -sfn ../arch/$(ARCH)/include include/arch
-    ln -sfn ../genarch/include include/genarch
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend include/arch include/genarch
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
 depend:
     $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
-$(OUTPUT): $(ARCH_OBJECTS) $(GENERIC_OBJECTS) $(GENARCH_OBJECTS) $(LIBS)
-    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld -e __entry_driver $(GENERIC_OBJECTS) $(ARCH_OBJECTS) $(GENARCH_OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+$(OUTPUT): $(OBJECTS) $(LIBS)
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm:
-    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/dd/uspace/srv/kbd/layout/us_dvorak.c
 ,0 → 1,238
+/*
+ * 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 kbd
+ * @brief US Dvorak Simplified Keyboard layout.
+ * @{
+ */
+#include <kbd.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
+#include <layout.h>
+static char map_lcase[] = {
+    [KC_R] = 'p',
+    [KC_T] = 'y',
+    [KC_Y] = 'f',
+    [KC_U] = 'g',
+    [KC_I] = 'c',
+    [KC_O] = 'r',
+    [KC_P] = 'l',
+    [KC_A] = 'a',
+    [KC_S] = 'o',
+    [KC_D] = 'e',
+    [KC_F] = 'u',
+    [KC_G] = 'i',
+    [KC_H] = 'd',
+    [KC_J] = 'h',
+    [KC_K] = 't',
+    [KC_L] = 'n',
+    [KC_SEMICOLON] = 's',
+    [KC_X] = 'q',
+    [KC_C] = 'j',
+    [KC_V] = 'k',
+    [KC_B] = 'x',
+    [KC_N] = 'b',
+    [KC_M] = 'm',
+    [KC_COMMA] = 'w',
+    [KC_PERIOD] = 'v',
+    [KC_SLASH] = 'z',
+};
+static char map_ucase[] = {
+    [KC_R] = 'P',
+    [KC_T] = 'Y',
+    [KC_Y] = 'F',
+    [KC_U] = 'G',
+    [KC_I] = 'C',
+    [KC_O] = 'R',
+    [KC_P] = 'L',
+    [KC_A] = 'A',
+    [KC_S] = 'O',
+    [KC_D] = 'E',
+    [KC_F] = 'U',
+    [KC_G] = 'I',
+    [KC_H] = 'D',
+    [KC_J] = 'H',
+    [KC_K] = 'T',
+    [KC_L] = 'N',
+    [KC_SEMICOLON] = 'S',
+    [KC_X] = 'Q',
+    [KC_C] = 'J',
+    [KC_V] = 'K',
+    [KC_B] = 'X',
+    [KC_N] = 'B',
+    [KC_M] = 'M',
+    [KC_COMMA] = 'W',
+    [KC_PERIOD] = 'V',
+    [KC_SLASH] = 'Z',
+};
+static char map_not_shifted[] = {
+    [KC_BACKTICK] = '`',
+    [KC_1] = '1',
+    [KC_2] = '2',
+    [KC_3] = '3',
+    [KC_4] = '4',
+    [KC_5] = '5',
+    [KC_6] = '6',
+    [KC_7] = '7',
+    [KC_8] = '8',
+    [KC_9] = '9',
+    [KC_0] = '0',
+    [KC_MINUS] = '[',
+    [KC_EQUALS] = ']',
+    [KC_Q] = '\'',
+    [KC_W] = ',',
+    [KC_E] = '.',
+    [KC_LBRACKET] = '/',
+    [KC_RBRACKET] = '=',
+    [KC_QUOTE] = '-',
+    [KC_BACKSLASH] = '\\',
+    [KC_Z] = ';',
+};
+static char map_shifted[] = {
+    [KC_BACKTICK] = '~',
+    [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_Q] = '"',
+    [KC_W] = '<',
+    [KC_E] = '>',
+    [KC_LBRACKET] = '?',
+    [KC_RBRACKET] = '+',
+    [KC_QUOTE] = '_',
+    [KC_BACKSLASH] = '|',
+    [KC_Z] = ':',
+};
+static char map_neutral[] = {
+    [KC_BACKSPACE] = '\b',
+    [KC_TAB] = '\t',
+    [KC_ENTER] = '\n',
+    [KC_SPACE] = ' ',
+    [KC_NSLASH] = '/',
+    [KC_NTIMES] = '*',
+    [KC_NMINUS] = '-',
+    [KC_NPLUS] = '+',
+    [KC_NENTER] = '\n'
+};
+static char map_numeric[] = {
+    [KC_N7] = '7',
+    [KC_N8] = '8',
+    [KC_N9] = '9',
+    [KC_N4] = '4',
+    [KC_N5] = '5',
+    [KC_N6] = '6',
+    [KC_N1] = '1',
+    [KC_N2] = '2',
+    [KC_N3] = '3',
+    [KC_N0] = '0',
+    [KC_NPERIOD] = '.'
+};
+static int translate(unsigned int key, char *map, size_t map_length)
+{
+    if (key >= map_length)
+        return 0;
+    return map[key];
+}
+char layout_parse_ev(kbd_event_t *ev)
+{
+    char c;
+    /* Produce no characters when Ctrl or Alt is pressed. */
+    if ((ev->mods & (KM_CTRL | KM_ALT)) != 0)
+        return 0;
+    c = translate(ev->key, map_neutral, sizeof(map_neutral) / sizeof(char));
+    if (c != 0)
+        return c;
+    if (((ev->mods & KM_SHIFT) != 0) ^ ((ev->mods & KM_CAPS_LOCK) != 0))
+        c = translate(ev->key, map_ucase, sizeof(map_ucase) / sizeof(char));
+    else
+        c = translate(ev->key, map_lcase, sizeof(map_lcase) / sizeof(char));
+    if (c != 0)
+        return c;
+    if ((ev->mods & KM_SHIFT) != 0)
+        c = translate(ev->key, map_shifted, sizeof(map_shifted) / sizeof(char));
+    else
+        c = translate(ev->key, map_not_shifted, sizeof(map_not_shifted) / sizeof(char));
+    if (c != 0)
+        return c;
+    if ((ev->mods & KM_NUM_LOCK) != 0)
+        c = translate(ev->key, map_numeric, sizeof(map_numeric) / sizeof(char));
+    else
+        c = 0;
+    return c;
+}
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/kbd/layout/us_qwerty.c
 ,0 → 1,228
+/*
+ * 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 kbd
+ * @brief   US QWERTY leyout.
+ * @{
+ */
+#include <kbd.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
+#include <layout.h>
+static char map_lcase[] = {
+    [KC_Q] = 'q',
+    [KC_W] = 'w',
+    [KC_E] = 'e',
+    [KC_R] = 'r',
+    [KC_T] = 't',
+    [KC_Y] = 'y',
+    [KC_U] = 'u',
+    [KC_I] = 'i',
+    [KC_O] = 'o',
+    [KC_P] = 'p',
+    [KC_A] = 'a',
+    [KC_S] = 's',
+    [KC_D] = 'd',
+    [KC_F] = 'f',
+    [KC_G] = 'g',
+    [KC_H] = 'h',
+    [KC_J] = 'j',
+    [KC_K] = 'k',
+    [KC_L] = 'l',
+    [KC_Z] = 'z',
+    [KC_X] = 'x',
+    [KC_C] = 'c',
+    [KC_V] = 'v',
+    [KC_B] = 'b',
+    [KC_N] = 'n',
+    [KC_M] = 'm',
+};
+static char map_ucase[] = {
+    [KC_Q] = 'Q',
+    [KC_W] = 'W',
+    [KC_E] = 'E',
+    [KC_R] = 'R',
+    [KC_T] = 'T',
+    [KC_Y] = 'Y',
+    [KC_U] = 'U',
+    [KC_I] = 'I',
+    [KC_O] = 'O',
+    [KC_P] = 'P',
+    [KC_A] = 'A',
+    [KC_S] = 'S',
+    [KC_D] = 'D',
+    [KC_F] = 'F',
+    [KC_G] = 'G',
+    [KC_H] = 'H',
+    [KC_J] = 'J',
+    [KC_K] = 'K',
+    [KC_L] = 'L',
+    [KC_Z] = 'Z',
+    [KC_X] = 'X',
+    [KC_C] = 'C',
+    [KC_V] = 'V',
+    [KC_B] = 'B',
+    [KC_N] = 'N',
+    [KC_M] = 'M',
+};
+static char map_not_shifted[] = {
+    [KC_BACKTICK] = '`',
+    [KC_1] = '1',
+    [KC_2] = '2',
+    [KC_3] = '3',
+    [KC_4] = '4',
+    [KC_5] = '5',
+    [KC_6] = '6',
+    [KC_7] = '7',
+    [KC_8] = '8',
+    [KC_9] = '9',
+    [KC_0] = '0',
+    [KC_MINUS] = '-',
+    [KC_EQUALS] = '=',
+    [KC_LBRACKET] = '[',
+    [KC_RBRACKET] = ']',
+    [KC_SEMICOLON] = ';',
+    [KC_QUOTE] = '\'',
+    [KC_BACKSLASH] = '\\',
+    [KC_COMMA] = ',',
+    [KC_PERIOD] = '.',
+    [KC_SLASH] = '/',
+};
+static char map_shifted[] = {
+    [KC_BACKTICK] = '~',
+    [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_LBRACKET] = '{',
+    [KC_RBRACKET] = '}',
+    [KC_SEMICOLON] = ':',
+    [KC_QUOTE] = '"',
+    [KC_BACKSLASH] = '|',
+    [KC_COMMA] = '<',
+    [KC_PERIOD] = '>',
+    [KC_SLASH] = '?',
+};
+static char map_neutral[] = {
+    [KC_BACKSPACE] = '\b',
+    [KC_TAB] = '\t',
+    [KC_ENTER] = '\n',
+    [KC_SPACE] = ' ',
+    [KC_NSLASH] = '/',
+    [KC_NTIMES] = '*',
+    [KC_NMINUS] = '-',
+    [KC_NPLUS] = '+',
+    [KC_NENTER] = '\n'
+};
+static char map_numeric[] = {
+    [KC_N7] = '7',
+    [KC_N8] = '8',
+    [KC_N9] = '9',
+    [KC_N4] = '4',
+    [KC_N5] = '5',
+    [KC_N6] = '6',
+    [KC_N1] = '1',
+    [KC_N2] = '2',
+    [KC_N3] = '3',
+    [KC_N0] = '0',
+    [KC_NPERIOD] = '.'
+};
+static int translate(unsigned int key, char *map, size_t map_length)
+{
+    if (key >= map_length) return 0;
+    return map[key];
+}
+char layout_parse_ev(kbd_event_t *ev)
+{
+    char c;
+    /* Produce no characters when Ctrl or Alt is pressed. */
+    if ((ev->mods & (KM_CTRL | KM_ALT)) != 0)
+        return 0;
+    c = translate(ev->key, map_neutral, sizeof(map_neutral) / sizeof(char));
+    if (c != 0) return c;
+    if (((ev->mods & KM_SHIFT) != 0) ^ ((ev->mods & KM_CAPS_LOCK) != 0))
+        c = translate(ev->key, map_ucase, sizeof(map_ucase) / sizeof(char));
+    else
+        c = translate(ev->key, map_lcase, sizeof(map_lcase) / sizeof(char));
+    if (c != 0) return c;
+    if ((ev->mods & KM_SHIFT) != 0)
+        c = translate(ev->key, map_shifted, sizeof(map_shifted) / sizeof(char));
+    else
+        c = translate(ev->key, map_not_shifted, sizeof(map_not_shifted) / sizeof(char));
+    if (c != 0) return c;
+    if ((ev->mods & KM_NUM_LOCK) != 0)
+        c = translate(ev->key, map_numeric, sizeof(map_numeric) / sizeof(char));
+    else
+        c = 0;
+    return c;
+}
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/ns/ns.c
 ,11 → 28,11
 /** @addtogroup ns
  * @{
- */
+ */
 /**
- * @file    ns.c
- * @brief   Naming service for HelenOS IPC.
+ * @file  ns.c
+ * @brief Naming service for HelenOS IPC.
  */
 ,6 → 40,7
 #include <ipc/ns.h>
 #include <ipc/services.h>
 #include <stdio.h>
+#include <bool.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <errno.h>
 ,17 → 48,24
 #include <libadt/list.h>
 #include <libadt/hash_table.h>
 #include <sysinfo.h>
+#include <loader/loader.h>
 #include <ddi.h>
 #include <as.h>
-#define NAME    "NS"
+#define NAME  "ns"
-#define NS_HASH_TABLE_CHAINS    20
+#define NS_HASH_TABLE_CHAINS  20
 static int register_service(ipcarg_t service, ipcarg_t phone, ipc_call_t *call);
-static int connect_to_service(ipcarg_t service, 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);
 ,19 → 84,46
 /** 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. */
+    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;
-static void get_as_area(ipc_callid_t callid, ipc_call_t *call, char *name,
-    void **addr)
+/** Return true if @a service is clonable. */
+static bool service_clonable(int service)
 {
+    return (service == SERVICE_LOAD);
+}
+static void get_as_area(ipc_callid_t callid, ipc_call_t *call, char *name, void **addr)
+{
     void *ph_addr;
     if (!*addr) {
         ph_addr = (void *) sysinfo_value(name);
         if (!ph_addr) {
 ,36 → 131,76
             return;
         }
         *addr = as_get_mappable_page(PAGE_SIZE);
-        physmem_map(ph_addr, *addr, 1,
-            AS_AREA_READ | AS_AREA_CACHEABLE);
+        if (physmem_map(ph_addr, *addr, 1,
+            AS_AREA_READ | AS_AREA_CACHEABLE) != 0) {
+            ipc_answer_0(callid, ENOENT);
+            return;
+        }
     }
     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)
 {
-    ipc_call_t call;
-    ipc_callid_t callid;
+    printf(NAME ": HelenOS IPC Naming Service\n");
-    ipcarg_t retval;
     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;
     }
+    list_initialize(&pending_req);
+    list_initialize(&cs_req);
+    printf(NAME ": Accepting connections\n");
+    while (true) {
+        process_pending_req();
-    while (1) {
-        callid = ipc_wait_for_call(&call);
+        ipc_call_t call;
+        ipc_callid_t callid = ipc_wait_for_call(&call);
+        ipcarg_t retval;
         switch (IPC_GET_METHOD(call)) {
         case IPC_M_SHARE_IN:
             switch (IPC_GET_ARG3(call)) {
             case SERVICE_MEM_REALTIME:
-                get_as_area(callid, &call, "clock.faddr",
-                    &clockaddr);
+                get_as_area(callid, &call, "clock.faddr", &clockaddr);
                 break;
             case SERVICE_MEM_KLOG:
-                get_as_area(callid, &call, "klog.faddr",
-                    &klogaddr);
+                get_as_area(callid, &call, "klog.faddr", &klogaddr);
                 break;
             default:
                 ipc_answer_0(callid, ENOENT);
 ,33 → 213,50
             /*
              * Server requests service registration.
              */
-            retval = register_service(IPC_GET_ARG1(call),
-                IPC_GET_ARG5(call), &call);
+            if (service_clonable(IPC_GET_ARG1(call))) {
+                register_clonable(IPC_GET_ARG1(call),
+                    IPC_GET_ARG5(call), &call, callid);
+                continue;
+            } else {
+                retval = register_service(IPC_GET_ARG1(call),
+                    IPC_GET_ARG5(call), &call);
+            }
             break;
         case IPC_M_CONNECT_ME_TO:
             /*
              * Client requests to be connected to a service.
              */
-            retval = connect_to_service(IPC_GET_ARG1(call), &call,
-                callid);
+            if (service_clonable(IPC_GET_ARG1(call))) {
+                connect_to_clonable(IPC_GET_ARG1(call),
+                    &call, callid);
+                continue;
+            } else {
+                connect_to_service(IPC_GET_ARG1(call), &call,
+                    callid);
+                continue;
+            }
             break;
         default:
             retval = ENOENT;
             break;
         }
-        if (!(callid & IPC_CALLID_NOTIFICATION)) {
+        if (!(callid & IPC_CALLID_NOTIFICATION))
             ipc_answer_0(callid, retval);
-        }
     }
+    /* Not reached */
+    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.
+ * @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)
 {
 ,23 → 265,20
         call->in_phone_hash,
     };
-    hashed_service_t *hs;
-    if (hash_table_find(&ns_hash_table, keys)) {
+    if (hash_table_find(&ns_hash_table, keys))
         return EEXISTS;
-    }
-    hs = (hashed_service_t *) malloc(sizeof(hashed_service_t));
-    if (!hs) {
+    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;
 }
 ,36 → 285,135
 /** Connect client to service.
  *
  * @param service Service to be connected to.
- * @param call Pointer to call structure.
- * @param callid Call ID of the request.
+ * @param call    Pointer to call structure.
+ * @param callid  Call ID of the request.
  *
  * @return Zero on success or a value from @ref errno.h.
+ *
  */
-int connect_to_service(ipcarg_t service, ipc_call_t *call, ipc_callid_t callid)
+void connect_to_service(ipcarg_t service, ipc_call_t *call, ipc_callid_t callid)
 {
-    unsigned long keys[3] = { service, 0, 0 };
-    link_t *hlp;
-    hashed_service_t *hs;
+    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;
+            }
-    hlp = hash_table_find(&ns_hash_table, keys);
-    if (!hlp) {
-        return ENOENT;
+            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;
     }
-    hs = hash_table_get_instance(hlp, hashed_service_t, link);
-    return ipc_forward_fast(callid, hs->phone, IPC_GET_ARG2(*call),
-        IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
+    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);
+}
+/** 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.
+ *            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;
+    return (*key % NS_HASH_TABLE_CHAINS);
 }
 /** Compare a key with hashed item.
 ,20 → 424,20
  * value. Note that this is close to being classified
  * as a nasty hack.
  *
- * @param key Array of keys.
+ * @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)
 {
-    hashed_service_t *hs;
     assert(key);
     assert(keys <= 3);
     assert(item);
-    hs = hash_table_get_instance(item, hashed_service_t, link);
+    hashed_service_t *hs = hash_table_get_instance(item, hashed_service_t, link);
     if (keys == 2)
         return key[1] == hs->in_phone_hash;
 ,6 → 448,7
 /** 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)
 {
 ,6 → 456,6
     free(hash_table_get_instance(item, hashed_service_t, link));
 }
-/**
+/**
  * @}
  */

 /branches/dd/uspace/srv/ns/Makefile
 ,6 → 31,7
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 LIBS = $(LIBC_PREFIX)/libc.a
 ,22 → 47,24
 .PHONY: all clean depend disasm
-all: $(OUTPUT) disasm
+all: $(OUTPUT) $(OUTPUT).disasm
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -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/$(ARCH)/_link.ld -e __entry_driver $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm:
-    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/dd/uspace/srv/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/dd/uspace/srv/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/dd/uspace/srv/console/console.c
 ,27 → 35,32
 #include <libc.h>
 #include <fb.h>
 #include <ipc/ipc.h>
-#include <keys.h>
+#include <kbd.h>
+#include <kbd/keycode.h>
 #include <ipc/fb.h>
 #include <ipc/services.h>
 #include <errno.h>
 #include <key_buffer.h>
-#include <console.h>
+#include <ipc/console.h>
 #include <unistd.h>
 #include <async.h>
 #include <libadt/fifo.h>
 #include <screenbuffer.h>
 #include <sys/mman.h>
+#include <stdio.h>
+#include <sysinfo.h>
+#include "console.h"
 #include "gcons.h"
 #define MAX_KEYREQUESTS_BUFFERED 32
-#define NAME "CONSOLE"
+#define NAME "console"
 /** Index of currently used virtual console.
  */
 int active_console = 0;
+int prev_console = 0;
 /** Information about framebuffer
  */
 ,10 → 90,7
                          * faster virtual console
                          * switching */
-static int kernel_pixmap = -1;  /**< Number of fb pixmap, where kernel
-                 * console is stored */
 /** Find unused virtual console.
  *
  */
 ,27 → 110,54
     async_msg_0(fb_info.phone, FB_CLEAR);
 }
-static void curs_visibility(int v)
+static void curs_visibility(bool visible)
 {
-    async_msg_1(fb_info.phone, FB_CURSOR_VISIBILITY, v);
+    async_msg_1(fb_info.phone, FB_CURSOR_VISIBILITY, visible);
 }
+static void curs_hide_sync(void)
+{
+    ipc_call_sync_1_0(fb_info.phone, FB_CURSOR_VISIBILITY, false);
+}
 static void curs_goto(int row, int col)
 {
     async_msg_2(fb_info.phone, FB_CURSOR_GOTO, row, col);
 }
-static void set_style(style_t *style)
+static void set_style(int style)
 {
-    async_msg_2(fb_info.phone, FB_SET_STYLE, style->fg_color,
-        style->bg_color);
+    async_msg_1(fb_info.phone, FB_SET_STYLE, style);
 }
-static void set_style_col(int fgcolor, int bgcolor)
+static void set_color(int fgcolor, int bgcolor, int flags)
 {
-    async_msg_2(fb_info.phone, FB_SET_STYLE, fgcolor, bgcolor);
+    async_msg_3(fb_info.phone, FB_SET_COLOR, fgcolor, bgcolor, flags);
 }
+static void set_rgb_color(int fgcolor, int bgcolor)
+{
+    async_msg_2(fb_info.phone, FB_SET_RGB_COLOR, fgcolor, bgcolor);
+}
+static void set_attrs(attrs_t *attrs)
+{
+    switch (attrs->t) {
+    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;
+    }
+}
 static void prtchr(char c, int row, int col)
 {
     async_msg_3(fb_info.phone, FB_PUTCHAR, c, row, col);
 ,114 → 215,81
 }
-/** Save current screen to pixmap, draw old pixmap
- *
- * @param oldpixmap Old pixmap
- * @return ID of pixmap of current screen
- */
-static int switch_screens(int oldpixmap)
-{
-    int newpmap;
-    /* Save screen */
-    newpmap = async_req_0_0(fb_info.phone, FB_VP2PIXMAP);
-    if (newpmap < 0)
-        return -1;
-    if (oldpixmap != -1) {
-        /* Show old screen */
-        async_msg_2(fb_info.phone, FB_VP_DRAW_PIXMAP, 0, oldpixmap);
-        /* Drop old pixmap */
-        async_msg_1(fb_info.phone, FB_DROP_PIXMAP, oldpixmap);
-    }
-    return newpmap;
-}
 /** Switch to new console */
 static void change_console(int newcons)
 {
     connection_t *conn;
-    static int console_pixmap = -1;
     int i, j, rc;
     keyfield_t *field;
-    style_t *style;
+    attrs_t *attrs;
     if (newcons == active_console)
         return;
     if (newcons == KERNEL_CONSOLE) {
-        if (active_console == KERNEL_CONSOLE)
-            return;
-        active_console = KERNEL_CONSOLE;
-        curs_visibility(0);
         async_serialize_start();
-        if (kernel_pixmap == -1) {
-            /* store/restore unsupported */
-            set_style_col(DEFAULT_FOREGROUND, DEFAULT_BACKGROUND);
-            clrscr();
-        } else {
-            gcons_in_kernel();
-            console_pixmap = switch_screens(kernel_pixmap);
-            kernel_pixmap = -1;
-        }
+        curs_hide_sync();
+        gcons_in_kernel();
         async_serialize_end();
-        __SYSCALL0(SYS_DEBUG_ENABLE_CONSOLE);
-        return;
-    }
-    async_serialize_start();
-    if (console_pixmap != -1) {
-        kernel_pixmap = switch_screens(console_pixmap);
-        console_pixmap = -1;
+        if (__SYSCALL0(SYS_DEBUG_ENABLE_CONSOLE)) {
+            prev_console = active_console;
+            active_console = KERNEL_CONSOLE;
+        } else
+            newcons = active_console;
     }
-    active_console = newcons;
-    gcons_change_console(newcons);
-    conn = &connections[active_console];
-    set_style(&conn->screenbuffer.style);
-    curs_visibility(0);
-    if (interbuffer) {
-        for (i = 0; i < conn->screenbuffer.size_x; i++)
-            for (j = 0; j < conn->screenbuffer.size_y; j++) {
-                unsigned int size_x;
-                size_x = conn->screenbuffer.size_x;
-                interbuffer[i + j * size_x] =
-                    *get_field_at(&conn->screenbuffer, i, j);
-            }
-        /* This call can preempt, but we are already at the end */
-        rc = async_req_0_0(fb_info.phone, FB_DRAW_TEXT_DATA);
-    }
-    if ((!interbuffer) || (rc != 0)) {
-        set_style(&conn->screenbuffer.style);
-        clrscr();
-        style = &conn->screenbuffer.style;
+    if (newcons != KERNEL_CONSOLE) {
+        async_serialize_start();
+        if (active_console == KERNEL_CONSOLE)
+            gcons_redraw_console();
+        active_console = newcons;
+        gcons_change_console(newcons);
+        conn = &connections[active_console];
+        set_attrs(&conn->screenbuffer.attrs);
+        curs_visibility(false);
+        if (interbuffer) {
+            for (i = 0; i < conn->screenbuffer.size_x; i++)
+                for (j = 0; j < conn->screenbuffer.size_y; j++) {
+                    unsigned int size_x;
+                    size_x = conn->screenbuffer.size_x;
+                    interbuffer[i + j * size_x] =
+                        *get_field_at(&conn->screenbuffer, i, j);
+                }
+            /* This call can preempt, but we are already at the end */
+            rc = async_req_0_0(fb_info.phone, FB_DRAW_TEXT_DATA);
+        }
+        if ((!interbuffer) || (rc != 0)) {
+            set_attrs(&conn->screenbuffer.attrs);
+            clrscr();
+            attrs = &conn->screenbuffer.attrs;
+            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))
+                        set_attrs(&field->attrs);
+                    attrs = &field->attrs;
+                    if ((field->character == ' ') &&
+                        (attrs_same(field->attrs,
+                        conn->screenbuffer.attrs)))
+                        continue;
-        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 (!style_same(*style, field->style))
-                    set_style(&field->style);
-                style = &field->style;
-                if ((field->character == ' ') &&
-                    (style_same(field->style,
-                    conn->screenbuffer.style)))
-                    continue;
-                prtchr(field->character, j, i);
-            }
+                    prtchr(field->character, j, i);
+                }
+        }
+        curs_goto(conn->screenbuffer.position_y,
+            conn->screenbuffer.position_x);
+        curs_visibility(conn->screenbuffer.is_cursor_visible);
+        async_serialize_end();
     }
-    curs_goto(conn->screenbuffer.position_y,
-        conn->screenbuffer.position_x);
-    curs_visibility(conn->screenbuffer.is_cursor_visible);
-    async_serialize_end();
 }
 /** Handler for keyboard */
 ,7 → 298,7
     ipc_callid_t callid;
     ipc_call_t call;
     int retval;
-    int c;
+    kbd_event_t ev;
     connection_t *conn;
     int newcon;
 ,23 → 320,24
                 IPC_GET_ARG2(call));
             retval = 0;
             break;
-        case KBD_PUSHCHAR:
-            /* got key from keyboard driver */
+        case KBD_EVENT:
+            /* Got event from keyboard driver. */
+            retval = 0;
+            ev.type = IPC_GET_ARG1(call);
+            ev.key = IPC_GET_ARG2(call);
+            ev.mods = IPC_GET_ARG3(call);
+            ev.c = IPC_GET_ARG4(call);
-            retval = 0;
-            c = IPC_GET_ARG1(call);
             /* switch to another virtual console */
             conn = &connections[active_console];
-/*
- *          if ((c >= KBD_KEY_F1) && (c < KBD_KEY_F1 +
- *              CONSOLE_COUNT)) {
- */
-            if ((c >= 0x101) && (c < 0x101 + CONSOLE_COUNT)) {
-                if (c == 0x112)
+            if ((ev.key >= KC_F1) && (ev.key < KC_F1 +
+                CONSOLE_COUNT)) {
+                if (ev.key == KC_F12)
                     change_console(KERNEL_CONSOLE);
                 else
-                    change_console(c - 0x101);
+                    change_console(ev.key - KC_F1);
                 break;
             }
 ,14 → 344,14
             /* if client is awaiting key, send it */
             if (conn->keyrequest_counter > 0) {
                 conn->keyrequest_counter--;
-                ipc_answer_1(fifo_pop(conn->keyrequests), EOK,
-                    c);
+                ipc_answer_4(fifo_pop(conn->keyrequests), EOK,
+                    ev.type, ev.key, ev.mods, ev.c);
                 break;
             }
-            keybuffer_push(&conn->keybuffer, c);
+            keybuffer_push(&conn->keybuffer, &ev);
             retval = 0;
             break;
         default:
             retval = ENOENT;
 ,9 → 366,9
     ipc_callid_t callid;
     ipc_call_t call;
     int consnum;
-    ipcarg_t arg1, arg2;
+    ipcarg_t arg1, arg2, arg3, arg4;
     connection_t *conn;
     if ((consnum = find_free_connection()) == -1) {
         ipc_answer_0(iid, ELIMIT);
         return;
 ,20 → 383,23
     /* Accept the connection */
     ipc_answer_0(iid, EOK);
     while (1) {
         async_serialize_end();
         callid = async_get_call(&call);
         async_serialize_start();
         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) {
+            while (conn->keyrequest_counter > 0) {
                 conn->keyrequest_counter--;
                 ipc_answer_0(fifo_pop(conn->keyrequests),
                     ENOENT);
 ,11 → 437,26
             break;
         case CONSOLE_SET_STYLE:
             arg1 = IPC_GET_ARG1(call);
+            screenbuffer_set_style(&conn->screenbuffer, arg1);
+            if (consnum == active_console)
+                set_style(arg1);
+            break;
+        case CONSOLE_SET_COLOR:
+            arg1 = IPC_GET_ARG1(call);
             arg2 = IPC_GET_ARG2(call);
-            screenbuffer_set_style(&conn->screenbuffer, arg1,
+            arg3 = IPC_GET_ARG3(call);
+            screenbuffer_set_color(&conn->screenbuffer, arg1,
+                arg2, arg3);
+            if (consnum == active_console)
+                set_color(arg1, arg2, arg3);
+            break;
+        case CONSOLE_SET_RGB_COLOR:
+            arg1 = IPC_GET_ARG1(call);
+            arg2 = IPC_GET_ARG2(call);
+            screenbuffer_set_rgb_color(&conn->screenbuffer, arg1,
                 arg2);
             if (consnum == active_console)
-                set_style_col(arg1, arg2);
+                set_rgb_color(arg1, arg2);
             break;
         case CONSOLE_CURSOR_VISIBILITY:
             arg1 = IPC_GET_ARG1(call);
 ,7 → 464,7
             if (consnum == active_console)
                 curs_visibility(arg1);
             break;
-        case CONSOLE_GETCHAR:
+        case CONSOLE_GETKEY:
             if (keybuffer_empty(&conn->keybuffer)) {
                 /* buffer is empty -> store request */
                 if (conn->keyrequest_counter <
 ,54 → 480,66
                 }
                 continue;
             }
-            keybuffer_pop(&conn->keybuffer, (int *) &arg1);
+            kbd_event_t ev;
+            keybuffer_pop(&conn->keybuffer, &ev);
+            arg1 = ev.type;
+            arg2 = ev.key;
+            arg3 = ev.mods;
+            arg4 = ev.c;
             break;
         }
-        ipc_answer_2(callid, EOK, arg1, arg2);
+        ipc_answer_4(callid, EOK, arg1, arg2, arg3, arg4);
     }
 }
+static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
+{
+    change_console(prev_console);
+}
 int main(int argc, char *argv[])
 {
+    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(PHONE_NS, SERVICE_KEYBOARD, 0, 0);
-    while (kbd_phone < 0) {
-        usleep(10000);
-        kbd_phone = ipc_connect_me_to(PHONE_NS, SERVICE_KEYBOARD, 0, 0);
+    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;
     }
-    if (ipc_connect_to_me(kbd_phone, SERVICE_CONSOLE, 0, 0, &phonehash) != 0)
+    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;
+    }
     async_new_connection(phonehash, 0, NULL, keyboard_events);
     /* Connect to framebuffer driver */
-    fb_info.phone = ipc_connect_me_to(PHONE_NS, SERVICE_VIDEO, 0, 0);
-    while (fb_info.phone < 0) {
-        usleep(10000);
-        fb_info.phone = ipc_connect_me_to(PHONE_NS, SERVICE_VIDEO, 0, 0);
+    fb_info.phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VIDEO, 0, 0);
+    if (fb_info.phone < 0) {
+        printf(NAME ": Failed to connect to video service\n");
+        return -1;
     }
-    /* Save old kernel screen */
-    kernel_pixmap = switch_screens(-1);
+    /* Disable kernel output to the console */
+    __SYSCALL0(SYS_DEBUG_DISABLE_CONSOLE);
     /* Initialize gcons */
     gcons_init(fb_info.phone);
     /* Synchronize, the gcons can have something in queue */
     async_req_0_0(fb_info.phone, FB_FLUSH);
-    /* Enable double buffering */
-    async_msg_2(fb_info.phone, FB_VIEWPORT_DB, (sysarg_t) -1, 1);
     async_req_0_2(fb_info.phone, FB_GET_CSIZE, &fb_info.rows,
         &fb_info.cols);
-    set_style_col(DEFAULT_FOREGROUND, DEFAULT_BACKGROUND);
+    set_rgb_color(DEFAULT_FOREGROUND, DEFAULT_BACKGROUND);
     clrscr();
     /* Init virtual consoles */
 ,32 → 559,48
         }
     }
     connections[KERNEL_CONSOLE].used = 1;
-    interbuffer = mmap(NULL,
-        sizeof(keyfield_t) * fb_info.cols * fb_info.rows,
-        PROTO_READ | PROTO_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
-    if (!interbuffer) {
+    /* Set up shared memory buffer. */
+    ib_size = sizeof(keyfield_t) * fb_info.cols * fb_info.rows;
+    interbuffer = as_get_mappable_page(ib_size);
+    if (as_area_create(interbuffer, ib_size, AS_AREA_READ |
+        AS_AREA_WRITE | AS_AREA_CACHEABLE) != interbuffer) {
+        interbuffer = NULL;
+    }
+    if (interbuffer) {
         if (ipc_share_out_start(fb_info.phone, interbuffer,
             AS_AREA_READ) != EOK) {
-            munmap(interbuffer,
-                sizeof(keyfield_t) * fb_info.cols * fb_info.rows);
+            as_area_destroy(interbuffer);
             interbuffer = NULL;
         }
     }
     curs_goto(0, 0);
     curs_visibility(
         connections[active_console].screenbuffer.is_cursor_visible);
     /* Register at NS */
-    if (ipc_connect_to_me(PHONE_NS, SERVICE_CONSOLE, 0, 0, &phonehash) != 0) {
+    if (ipc_connect_to_me(PHONE_NS, SERVICE_CONSOLE, 0, 0, &phonehash) != 0)
         return -1;
+    /* Receive kernel notifications */
+    if (sysinfo_value("kconsole.present")) {
+        int devno = sysinfo_value("kconsole.devno");
+        int inr = sysinfo_value("kconsole.inr");
+        if (ipc_register_irq(inr, devno, 0, NULL) != 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");
     async_manager();
+    return 0;
+}
-    return 0;
-}
 /** @}
  */

 /branches/dd/uspace/srv/console/console.h
 ,15 → 39,6
 #define CONSOLE_COUNT 12
-#define CONSOLE_GETCHAR     1026
-#define CONSOLE_PUTCHAR     1027
-#define CONSOLE_CLEAR       1028
-#define CONSOLE_GOTO        1029
-#define CONSOLE_GETSIZE     1030
-#define CONSOLE_FLUSH       1031
-#define CONSOLE_SET_STYLE   1032
-#define CONSOLE_CURSOR_VISIBILITY   1033
 #endif
 /** @}

 /branches/dd/uspace/srv/console/screenbuffer.c
 ,6 → 33,7
  */
 #include <screenbuffer.h>
+#include <console/style.h>
 #include <malloc.h>
 #include <unistd.h>
 ,7 → 50,7
     field = get_field_at(scr, scr->position_x, scr->position_y);
     field->character = c;
-    field->style = scr->style;
+    field->attrs = scr->attrs;
 }
 /** Initilize screenbuffer. Allocate space for screen content in accordance to given size.
 ,8 → 68,8
     scr->size_x = size_x;
     scr->size_y = size_y;
-    scr->style.fg_color = DEFAULT_FOREGROUND;
-    scr->style.bg_color = DEFAULT_BACKGROUND;
+    scr->attrs.t = at_style;
+    scr->attrs.a.s.style = STYLE_NORMAL;
     scr->is_cursor_visible = 1;
     screenbuffer_clear(scr);
 ,7 → 86,7
     for (i = 0; i < (scr->size_x * scr->size_y); i++) {
         scr->buffer[i].character = ' ';
-        scr->buffer[i].style = scr->style;
+        scr->buffer[i].attrs = scr->attrs;
     }
     scr->top_line = 0;
 ,7 → 104,7
     for (i = 0; i < scr->size_x; i++) {
         scr->buffer[i + line * scr->size_x].character = ' ';
-        scr->buffer[i + line * scr->size_x].style = scr->style;
+        scr->buffer[i + line * scr->size_x].attrs = scr->attrs;
     }
 }
 ,12 → 137,37
  * @param fg_color
  * @param bg_color
  */
-void screenbuffer_set_style(screenbuffer_t *scr, unsigned int fg_color, unsigned int bg_color)
+void screenbuffer_set_style(screenbuffer_t *scr, int style)
 {
-    scr->style.fg_color = fg_color;
-    scr->style.bg_color = bg_color;
+    scr->attrs.t = at_style;
+    scr->attrs.a.s.style = style;
 }
+/** 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)
+{
+    scr->attrs.t = at_idx;
+    scr->attrs.a.i.fg_color = fg_color;
+    scr->attrs.a.i.bg_color = bg_color;
+    scr->attrs.a.i.flags = flags;
+}
+/** 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)
+{
+    scr->attrs.t = at_rgb;
+    scr->attrs.a.r.fg_color = fg_color;
+    scr->attrs.a.r.bg_color = bg_color;
+}
 /** @}
  */

 /branches/dd/uspace/srv/console/gcons.c
 ,7 → 81,7
 static void vp_switch(int vp)
 {
-    async_msg_1(fbphone,FB_VIEWPORT_SWITCH, vp);
+    async_msg_1(fbphone, FB_VIEWPORT_SWITCH, vp);
 }
 /** Create view port */
 ,15 → 97,15
     async_msg_0(fbphone, FB_CLEAR);
 }
-static void set_style(int fgcolor, int bgcolor)
+static void set_rgb_color(int fgcolor, int bgcolor)
 {
-    async_msg_2(fbphone, FB_SET_STYLE, fgcolor, bgcolor);
+    async_msg_2(fbphone, FB_SET_RGB_COLOR, fgcolor, bgcolor);
 }
 /** Transparent putchar */
 static void tran_putch(char c, int row, int col)
 {
-    async_msg_3(fbphone, FB_TRANS_PUTCHAR, c, row, col);
+    async_msg_3(fbphone, FB_PUTCHAR, c, row, col);
 }
 /** Redraw the button showing state of a given console */
 ,10 → 189,10
         console_state[consnum] = CONS_DISCONNECTED_SEL;
     else
         console_state[consnum] = CONS_DISCONNECTED;
     if (active_console == KERNEL_CONSOLE)
         return;
     redraw_state(consnum);
     vp_switch(console_vp);
 }
 ,16 → 217,10
 /** Change to kernel console */
 void gcons_in_kernel(void)
 {
-    if (console_state[active_console] == CONS_DISCONNECTED_SEL)
-        console_state[active_console] = CONS_DISCONNECTED;
-    else
-        console_state[active_console] = CONS_IDLE;
-    redraw_state(active_console);
     if (animation != -1)
         async_msg_1(fbphone, FB_ANIM_STOP, animation);
-    active_console = KERNEL_CONSOLE; /* Set to kernel console */
+    active_console = KERNEL_CONSOLE;
     vp_switch(0);
 }
 ,8 → 244,8
  */
 void gcons_mouse_move(int dx, int dy)
 {
-    mouse_x = limit(mouse_x+dx, 0, xres);
-    mouse_y = limit(mouse_y+dy, 0, yres);
+    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);
 }
 ,7 → 252,7
 static int gcons_find_conbut(int x, int y)
 {
-    int status_start = STATUS_START + (xres - 800) / 2;;
+    int status_start = STATUS_START + (xres - 800) / 2;
     if (y < STATUS_TOP || y >= STATUS_TOP + STATUS_HEIGHT)
         return -1;
 ,10 → 262,10
     if (x >= status_start + (STATUS_WIDTH + STATUS_SPACE) * CONSOLE_COUNT)
         return -1;
-    if (((x - status_start) % (STATUS_WIDTH+STATUS_SPACE)) < STATUS_SPACE)
+    if (((x - status_start) % (STATUS_WIDTH + STATUS_SPACE)) < STATUS_SPACE)
         return -1;
-    return (x - status_start) / (STATUS_WIDTH+STATUS_SPACE);
+    return (x - status_start) / (STATUS_WIDTH + STATUS_SPACE);
 }
 /** Handle mouse click
 ,22 → 336,23
 extern int _binary_helenos_ppm_size;
 extern char _binary_nameic_ppm_start[0];
 extern int _binary_nameic_ppm_size;
-/** Redraws console graphics  */
-static void gcons_redraw_console(void)
+/** Redraws console graphics */
+void gcons_redraw_console(void)
 {
     int i;
     if (!use_gcons)
         return;
     vp_switch(0);
-    set_style(MAIN_COLOR, MAIN_COLOR);
+    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);
     for (i = 0; i < CONSOLE_COUNT; i++)
         redraw_state(i);
     vp_switch(console_vp);
 ,16 → 454,16
     int rc;
     int i;
     int status_start = STATUS_START;
     fbphone = phone;
     rc = async_req_0_2(phone, FB_GET_RESOLUTION, &xres, &yres);
     if (rc)
         return;
-    if (xres < 800 || yres < 600)
+    if ((xres < 800) || (yres < 600))
         return;
     /* create console viewport */
     /* Align width & height to character size */
     console_vp = vp_create(CONSOLE_MARGIN, CONSOLE_TOP,
 ,7 → 481,7
         if (cstatus_vp[i] < 0)
             return;
         vp_switch(cstatus_vp[i]);
-        set_style(0x202020, 0xffffff);
+        set_rgb_color(0x202020, 0xffffff);
     }
     /* Initialize icons */
 ,13 → 501,12
     ic_pixmaps[CONS_DISCONNECTED_SEL] = ic_pixmaps[CONS_SELECTED];
     make_anim();
     use_gcons = 1;
     console_state[0] = CONS_DISCONNECTED_SEL;
     console_state[KERNEL_CONSOLE] = CONS_KERNEL;
     gcons_redraw_console();
 }
 /** @}
  */

/branches/dd/uspace/srv/console/gcons.h
36,6 → 36,7
#define _GCONS_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_in_kernel(void);

 /branches/dd/uspace/srv/console/screenbuffer.h
 ,28 → 35,52
 #ifndef __SCREENBUFFER_H__
 #define __SCREENBUFFER_H__
+#include <stdint.h>
 #define DEFAULT_FOREGROUND 0x0  /**< default console foreground color */
 #define DEFAULT_BACKGROUND 0xf0f0f0 /**< default console background color */
 typedef struct {
-    unsigned int bg_color;      /**< background color */
-    unsigned int fg_color;      /**< foreground color */
-} style_t;
+    uint8_t style;
+} attr_style_t;
+typedef struct {
+    uint8_t fg_color;
+    uint8_t bg_color;
+    uint8_t flags;
+} attr_idx_t;
+typedef struct {
+    uint32_t bg_color;      /**< background color */
+    uint32_t fg_color;      /**< foreground color */
+} attr_rgb_t;
+typedef struct {
+    enum {
+        at_style,
+        at_idx,
+        at_rgb
+    } t;
+    union {
+        attr_style_t s;
+        attr_idx_t i;
+        attr_rgb_t r;
+    } a;
+} attrs_t;
 /** One field on screen. It contain one character and its attributes. */
 typedef struct {
     char character;         /**< Character itself */
-    style_t style;          /**< Character`s attributes */
+    attrs_t attrs;          /**< Character`s attributes */
 } keyfield_t;
 /** Structure for buffering state of one virtual console.
  */
 typedef struct {
-    keyfield_t *buffer;         /**< Screen content - characters and its style. Used as cyclyc buffer. */
+    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 */
-    style_t style;              /**< Current style */
+    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 */
 } screenbuffer_t;
 ,14 → 96,23
     return scr->buffer + x + ((y + scr->top_line) % scr->size_y) * scr->size_x;
 }
-/** Compares two styles.
+/** Compares two sets of attributes.
  * @param s1 first style
  * @param s2 second style
  * @return nonzero on equality
  */
-static inline int style_same(style_t s1, style_t s2)
+static inline int attrs_same(attrs_t a1, attrs_t a2)
 {
-    return s1.fg_color == s2.fg_color && s1.bg_color == s2.bg_color;
+    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;
+    }
 }
 ,7 → 123,11
 void screenbuffer_clear_line(screenbuffer_t *scr, unsigned int 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, unsigned int fg_color, unsigned int bg_color);
+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);
 #endif

 /branches/dd/uspace/srv/console/Makefile
 ,8 → 31,9
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
-include $(LIBC_PREFIX)/Makefile.toolchain
+include $(LIBC_PREFIX)/Makefile.toolchain
 CFLAGS += -I. -I../kbd/include -I../fb
 LIBS = $(LIBC_PREFIX)/libc.a
 ,24 → 58,28
             $(addsuffix .o,$(basename $(IMAGES)))
 ARCH_OBJECTS := $(addsuffix .o,$(basename $(ARCH_SOURCES)))
+OBJECTS := $(GENERIC_OBJECTS) $(ARCH_OBJECTS)
 .PHONY: all clean depend disasm
-all: $(OUTPUT) disasm
+all: $(OUTPUT) $(OUTPUT).disasm
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
 depend:
     $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
-$(OUTPUT): $(ARCH_OBJECTS) $(GENERIC_OBJECTS) $(LIBS)
-    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld -e __entry_driver $(GENERIC_OBJECTS) $(ARCH_OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+$(OUTPUT): $(OBJECTS) $(LIBS)
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm:
-    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/dd/uspace/srv/rd/rd.c
 ,8 → 51,12
 #include <align.h>
 #include <async.h>
 #include <futex.h>
+#include <stdio.h>
+#include <ipc/devmap.h>
 #include "rd.h"
+#define NAME "rd"
 /** Pointer to the ramdisk's image. */
 static void *rd_addr;
 /** Size of the ramdisk. */
 ,45 → 81,24
     ipc_call_t call;
     int retval;
     void *fs_va = NULL;
-    ipcarg_t offset;
+    off_t offset;
+    size_t block_size;
+    size_t maxblock_size;
     /*
-     * We allocate VA for communication per connection.
-     * This allows us to potentionally have more clients and work
-     * concurrently.
+     * Answer the first IPC_M_CONNECT_ME_TO call.
      */
-    fs_va = as_get_mappable_page(ALIGN_UP(BLOCK_SIZE, PAGE_SIZE));
-    if (!fs_va) {
-        /*
-         * Hang up the phone if we cannot proceed any further.
-         * This is the answer to the call that opened the connection.
-         */
-        ipc_answer_0(iid, EHANGUP);
-        return;
-    } else {
-        /*
-         * Answer the first IPC_M_CONNECT_ME_TO call.
-         * Return supported block size as ARG1.
-         */
-        ipc_answer_1(iid, EOK, BLOCK_SIZE);
-    }
+    ipc_answer_0(iid, EOK);
     /*
      * Now we wait for the client to send us its communication as_area.
      */
-    size_t size;
-    if (ipc_share_out_receive(&callid, &size, NULL)) {
-        if (size >= BLOCK_SIZE) {
-            /*
-             * The client sends an as_area that can absorb the whole
-             * block.
-             */
+    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 {
-            /*
-             * The client offered as_area too small.
-             * Close the connection.
-             */
             ipc_answer_0(callid, EHANGUP);
             return;
         }
 ,8 → 124,16
             return;
         case RD_READ_BLOCK:
             offset = IPC_GET_ARG1(call);
-            if (offset * BLOCK_SIZE > rd_size - BLOCK_SIZE) {
+            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;
 ,14 → 140,22
                 break;
             }
             futex_down(&rd_futex);
-            memcpy(fs_va, rd_addr + offset, BLOCK_SIZE);
+            memcpy(fs_va, rd_addr + offset * block_size, block_size);
             futex_up(&rd_futex);
             retval = EOK;
             break;
         case RD_WRITE_BLOCK:
             offset = IPC_GET_ARG1(call);
-            if (offset * BLOCK_SIZE > rd_size - BLOCK_SIZE) {
+            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;
 ,7 → 162,7
                 break;
             }
             futex_up(&rd_futex);
-            memcpy(rd_addr + offset, fs_va, BLOCK_SIZE);
+            memcpy(rd_addr + offset * block_size, fs_va, block_size);
             futex_down(&rd_futex);
             retval = EOK;
             break;
 ,46 → 180,117
     }
 }
+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(NAME ": 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, strlen(name) + 1);
+    if (retval != EOK) {
+        async_wait_for(req, NULL);
+        return -1;
+    }
+    async_set_client_connection(rd_connection);
+    ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash);
+    async_wait_for(req, &retval);
+    return phone;
+}
+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, strlen(name) + 1);
+    if (retval != EOK) {
+        async_wait_for(req, NULL);
+        return retval;
+    }
+    async_wait_for(req, &retval);
+    if (handle != NULL)
+        *handle = -1;
+    if (EOK == retval) {
+        if (NULL != handle)
+            *handle = (int) IPC_GET_ARG1(answer);
+    }
+    return retval;
+}
 /** Prepare the ramdisk image for operation. */
 static bool rd_init(void)
 {
-    int retval, flags;
     rd_size = sysinfo_value("rd.size");
     void *rd_ph_addr = (void *) sysinfo_value("rd.address.physical");
-    if (rd_size == 0)
+    if (rd_size == 0) {
+        printf(NAME ": No RAM disk found\n");
         return false;
+    }
     rd_addr = as_get_mappable_page(rd_size);
-    flags = AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE;
-    retval = physmem_map(rd_ph_addr, rd_addr,
+    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)
+    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 driver_phone = driver_register(NAME);
+    if (driver_phone < 0) {
+        printf(NAME ": Unable to register driver\n");
+        return false;
+    }
+    int dev_handle;
+    if (EOK != device_register(driver_phone, "initrd", &dev_handle)) {
+        ipc_hangup(driver_phone);
+        printf(NAME ": Unable to register device\n");
+        return false;
+    }
     return true;
 }
 int main(int argc, char **argv)
 {
-    if (rd_init()) {
-        ipcarg_t phonead;
-        async_set_client_connection(rd_connection);
-        /* Register service at nameserver */
-        if (ipc_connect_to_me(PHONE_NS, SERVICE_RD, 0, 0, &phonead) != 0)
-            return -1;
-        async_manager();
-        /* Never reached */
-        return 0;
-    }
+    printf(NAME ": HelenOS RAM disk server\n");
-    return -1;
+    if (!rd_init())
+        return -1;
+    printf(NAME ": Accepting connections\n");
+    async_manager();
+    /* Never reached */
+    return 0;
 }
 /**

 /branches/dd/uspace/srv/rd/rd.h
 ,8 → 43,6
 #ifndef RD_RD_H_
 #define RD_RD_H_
-#define BLOCK_SIZE  1024    /**< Working block size */
 #define RD_BASE     1024
 #define RD_READ_BLOCK   (RD_BASE + 1)   /**< Method for reading block. */
 #define RD_WRITE_BLOCK  (RD_BASE + 2)   /**< Method for writing block. */

 /branches/dd/uspace/srv/rd/Makefile
 ,8 → 29,10
 ## Setup toolchain
 #
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 LIBS = $(LIBC_PREFIX)/libc.a
 ,22 → 48,24
 .PHONY: all clean depend disasm
-all: $(OUTPUT) disasm
+all: $(OUTPUT) $(OUTPUT).disasm
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -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/$(ARCH)/_link.ld -e __entry_driver $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm:
-    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/dd/uspace/srv/loader/main.c
 ,0 → 1,381
+/*
+ * 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 loader
+ * @brief Loads and runs programs from VFS.
+ * @{
+ */
+/**
+ * @file
+ * @brief Loads and runs programs from VFS.
+ *
+ * The program loader is a special init binary. Its image is used
+ * to create a new task upon a @c task_spawn syscall. The syscall
+ * returns the id of a phone connected to the newly created task.
+ *
+ * The caller uses this phone to send the pathname and various other
+ * information to the loader. This is normally done by the C library
+ * and completely hidden from applications.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <bool.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <ipc/ipc.h>
+#include <ipc/services.h>
+#include <ipc/loader.h>
+#include <loader/pcb.h>
+#include <errno.h>
+#include <async.h>
+#include <as.h>
+#include <elf.h>
+#include <elf_load.h>
+#define DPRINTF(...)
+/** Pathname of the file that will be loaded */
+static char *pathname = NULL;
+/** The Program control block */
+static pcb_t pcb;
+/** Number of arguments */
+static int argc = 0;
+/** Argument vector */
+static char **argv = NULL;
+/** Buffer holding all arguments */
+static char *arg_buf = NULL;
+static elf_info_t prog_info;
+static elf_info_t interp_info;
+static bool is_dyn_linked;
+/** Used to limit number of connections to one. */
+static bool connected;
+static void loader_get_taskid(ipc_callid_t rid, ipc_call_t *request)
+{
+    ipc_callid_t callid;
+    task_id_t task_id;
+    size_t len;
+    task_id = task_get_id();
+    if (!ipc_data_read_receive(&callid, &len)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    if (len > sizeof(task_id))
+        len = sizeof(task_id);
+    ipc_data_read_finalize(callid, &task_id, len);
+    ipc_answer_0(rid, EOK);
+}
+/** Receive a call setting pathname of the program to execute.
+ *
+ * @param rid
+ * @param request
+ */
+static void loader_set_pathname(ipc_callid_t rid, ipc_call_t *request)
+{
+    ipc_callid_t callid;
+    size_t len;
+    char *name_buf;
+    if (!ipc_data_write_receive(&callid, &len)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    name_buf = malloc(len + 1);
+    if (!name_buf) {
+        ipc_answer_0(callid, ENOMEM);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
+    ipc_data_write_finalize(callid, name_buf, len);
+    ipc_answer_0(rid, EOK);
+    if (pathname != NULL) {
+        free(pathname);
+        pathname = NULL;
+    }
+    name_buf[len] = '\0';
+    pathname = name_buf;
+}
+/** Receive a call setting arguments of the program to execute.
+ *
+ * @param rid
+ * @param request
+ */
+static void loader_set_args(ipc_callid_t rid, ipc_call_t *request)
+{
+    ipc_callid_t callid;
+    size_t buf_len, arg_len;
+    char *p;
+    int n;
+    if (!ipc_data_write_receive(&callid, &buf_len)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    if (arg_buf != NULL) {
+        free(arg_buf);
+        arg_buf = NULL;
+    }
+    if (argv != NULL) {
+        free(argv);
+        argv = NULL;
+    }
+    arg_buf = malloc(buf_len + 1);
+    if (!arg_buf) {
+        ipc_answer_0(callid, ENOMEM);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
+    ipc_data_write_finalize(callid, arg_buf, buf_len);
+    ipc_answer_0(rid, EOK);
+    arg_buf[buf_len] = '\0';
+    /*
+     * Count number of arguments
+     */
+    p = arg_buf;
+    n = 0;
+    while (p < arg_buf + buf_len) {
+        arg_len = strlen(p);
+        p = p + arg_len + 1;
+        ++n;
+    }
+    /* Allocate argv */
+    argv = malloc((n + 1) * sizeof(char *));
+    if (argv == NULL) {
+        free(arg_buf);
+        ipc_answer_0(callid, ENOMEM);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
+    /*
+     * Fill argv with argument pointers
+     */
+    p = arg_buf;
+    n = 0;
+    while (p < arg_buf + buf_len) {
+        argv[n] = p;
+        arg_len = strlen(p);
+        p = p + arg_len + 1;
+        ++n;
+    }
+    argc = n;
+    argv[n] = NULL;
+}
+/** Load the previously selected program.
+ *
+ * @param rid
+ * @param request
+ * @return 0 on success, !0 on error.
+ */
+static int loader_load(ipc_callid_t rid, ipc_call_t *request)
+{
+    int rc;
+    rc = elf_load_file(pathname, 0, &prog_info);
+    if (rc < 0) {
+        DPRINTF("Failed to load executable '%s'.\n", pathname);
+        ipc_answer_0(rid, EINVAL);
+        return 1;
+    }
+    elf_create_pcb(&prog_info, &pcb);
+    pcb.argc = argc;
+    pcb.argv = argv;
+    if (prog_info.interp == NULL) {
+        /* Statically linked program */
+        is_dyn_linked = false;
+        ipc_answer_0(rid, EOK);
+        return 0;
+    }
+    rc = elf_load_file(prog_info.interp, 0, &interp_info);
+    if (rc < 0) {
+        DPRINTF("Failed to load interpreter '%s.'\n",
+            prog_info.interp);
+        ipc_answer_0(rid, EINVAL);
+        return 1;
+    }
+    is_dyn_linked = true;
+    ipc_answer_0(rid, EOK);
+    return 0;
+}
+/** Run the previously loaded program.
+ *
+ * @param rid
+ * @param request
+ * @return 0 on success, !0 on error.
+ */
+static void loader_run(ipc_callid_t rid, ipc_call_t *request)
+{
+    const char *cp;
+    /* Set the task name. */
+    cp = strrchr(pathname, '/');
+    cp = (cp == NULL) ? pathname : (cp + 1);
+    task_set_name(cp);
+    if (is_dyn_linked == true) {
+        /* Dynamically linked program */
+        DPRINTF("Run ELF interpreter.\n");
+        DPRINTF("Entry point: 0x%lx\n", interp_info.entry);
+        close_console();
+        ipc_answer_0(rid, EOK);
+        elf_run(&interp_info, &pcb);
+    } else {
+        /* Statically linked program */
+        close_console();
+        ipc_answer_0(rid, EOK);
+        elf_run(&prog_info, &pcb);
+    }
+    /* Not reached */
+}
+/** Handle loader connection.
+ *
+ * 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)
+{
+    ipc_callid_t callid;
+    ipc_call_t call;
+    int retval;
+    /* Already have a connection? */
+    if (connected) {
+        ipc_answer_0(iid, ELIMIT);
+        return;
+    }
+    connected = true;
+    /* Accept the connection */
+    ipc_answer_0(iid, EOK);
+    /* Ignore parameters, the connection is already open */
+    (void) iid;
+    (void) icall;
+    while (1) {
+        callid = async_get_call(&call);
+        switch (IPC_GET_METHOD(call)) {
+        case IPC_M_PHONE_HUNGUP:
+            exit(0);
+        case LOADER_GET_TASKID:
+            loader_get_taskid(callid, &call);
+            continue;
+        case LOADER_SET_PATHNAME:
+            loader_set_pathname(callid, &call);
+            continue;
+        case LOADER_SET_ARGS:
+            loader_set_args(callid, &call);
+            continue;
+        case LOADER_LOAD:
+            loader_load(callid, &call);
+            continue;
+        case LOADER_RUN:
+            loader_run(callid, &call);
+            /* Not reached */
+        default:
+            retval = ENOENT;
+            break;
+        }
+        if ((callid & IPC_CALLID_NOTIFICATION) == 0 &&
+            IPC_GET_METHOD(call) != IPC_M_PHONE_HUNGUP) {
+            DPRINTF("Responding EINVAL to method %d.\n",
+                IPC_GET_METHOD(call));
+            ipc_answer_0(callid, EINVAL);
+        }
+    }
+}
+/** Program loader main function.
+ */
+int main(int argc, char *argv[])
+{
+    ipcarg_t phonead;
+    connected = false;
+    /* Set a handler of incomming connections. */
+    async_set_client_connection(loader_connection);
+    /* Register at naming service. */
+    if (ipc_connect_to_me(PHONE_NS, SERVICE_LOAD, 0, 0, &phonead) != 0)
+        return -1;
+    async_manager();
+    /* Never reached */
+    return 0;
+}
+/** @}
+ */

 /branches/dd/uspace/srv/loader/Makefile
 ,0 → 1,83
+#
+# Copyright (c) 2005 Martin Decky
+# 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.
+#
+## Setup toolchain
+#
+LIBC_PREFIX = ../../lib/libc
+SOFTINT_PREFIX = ../../lib/softint
+include $(LIBC_PREFIX)/Makefile.toolchain
+include arch/$(UARCH)/Makefile.inc
+CFLAGS += -Iinclude
+LIBS = $(LIBC_PREFIX)/libc.a $(SOFTINT_PREFIX)/libsoftint.a
+## Sources
+#
+OUTPUT = loader
+GENERIC_SOURCES = \
+    main.c \
+    elf_load.c \
+    interp.s
+SOURCES := $(GENERIC_SOURCES) $(ARCH_SOURCES)
+OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
+.PHONY: all clean depend disasm
+all: $(OUTPUT) disasm
+-include Makefile.depend
+clean:
+    -rm -f $(OUTPUT) $(OBJECTS) $(OUTPUT).map $(OUTPUT).disasm arch/$(UARCH)/_link.ld Makefile.depend
+depend:
+    $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
+$(OUTPUT): $(OBJECTS) $(LIBS) arch/$(UARCH)/_link.ld
+    $(LD) -T arch/$(UARCH)/_link.ld $(LFLAGS) $(OBJECTS) $(LIBS) -o $@ -Map $(OUTPUT).map
+disasm:
+    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
+arch/$(UARCH)/_link.ld: arch/$(UARCH)/_link.ld.in
+    $(CC) $(DEFS) $(CFLAGS) -DLIBC_PREFIX=$(LIBC_PREFIX) -E -x c $< | grep -v "^\#" > $@
+%.o: %.S
+    $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@
+%.o: %.s
+    $(AS) $(AFLAGS) $< -o $@
+%.o: %.c
+    $(CC) $(DEFS) $(CFLAGS) -c $< -o $@

 /branches/dd/uspace/srv/loader/arch/sparc64/_link.ld.in
 ,0 → 1,59
+STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
+ENTRY(__entry)
+PHDRS {
+    interp PT_INTERP;
+    text PT_LOAD FLAGS(5);
+    data PT_LOAD FLAGS(6);
+}
+SECTIONS {
+    .interp : {
+        *(.interp);
+    } :interp
+    . = 0x70004000 + SIZEOF_HEADERS;
+    .init : {
+        *(.init);
+    } :text
+    .text : {
+        *(.text);
+        *(.rodata*);
+    } :text
+    . = . + 0x4000;
+    .got : {
+         _gp = .;
+         *(.got*);
+    } :data
+    .data : {
+        *(.data);
+        *(.sdata);
+    } :data
+    .tdata : {
+        _tdata_start = .;
+        *(.tdata);
+        _tdata_end = .;
+    } :data
+    .tbss : {
+        _tbss_start = .;
+        *(.tbss);
+        _tbss_end = .;
+    } :data
+    _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
+    .bss : {
+        *(.sbss);
+        *(COMMON);
+        *(.bss);
+    } :data
+    . = ALIGN(0x4000);
+    _heap = .;
+    /DISCARD/ : {
+        *(*);
+    }
+}

 /branches/dd/uspace/srv/loader/arch/sparc64/Makefile.inc
 ,0 → 1,30
+#
+# 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.
+#
+CFLAGS += -D__64_BITS__
+ARCH_SOURCES := arch/$(UARCH)/sparc64.s

 /branches/dd/uspace/srv/loader/arch/sparc64/sparc64.s
 ,0 → 1,42
+#
+# 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.
+#
+.globl program_run
+## void program_run(void *entry_point, void *pcb);
+#
+# %o0   contains entry_point
+# %o1   contains pcb
+#
+# Jump to a program entry point
+program_run:
+    # Pass pcb pointer to entry point in %o1. As it is already
+    # there, no action is needed.
+    call %o0
+    nop
+    # fixme: use branch instead of call

 /branches/dd/uspace/srv/loader/arch/ia64/_link.ld.in
 ,0 → 1,61
+STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
+ENTRY(__entry)
+PHDRS {
+    interp PT_INTERP;
+    text PT_LOAD FLAGS(5);
+    data PT_LOAD FLAGS(6);
+}
+SECTIONS {
+    .interp : {
+        *(.interp);
+    } :interp
+    /* On Itanium code sections must be aligned to 16 bytes. */
+    . = ALIGN(0x800000000 + SIZEOF_HEADERS, 16);
+    .init : {
+        *(.init);
+    } : text
+    .text : {
+        *(.text);
+        *(.rodata*);
+    } :text
+    . = . + 0x4000;
+    .got : {
+        _gp = .;
+        *(.got*);
+    } :data
+    .data : {
+        *(.opd);
+        *(.data .data.*);
+        *(.sdata);
+    } :data
+    .tdata : {
+        _tdata_start = .;
+        *(.tdata);
+        _tdata_end = .;
+    } :data
+    .tbss : {
+        _tbss_start = .;
+        *(.tbss);
+        _tbss_end = .;
+    } :data
+    _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
+    .bss : {
+        *(.sbss);
+        *(.scommon);
+        *(COMMON);
+        *(.bss);
+    } :data
+    . = ALIGN(0x4000);
+    _heap = .;
+    /DISCARD/ : {
+        *(*);
+        }
+}

 /branches/dd/uspace/srv/loader/arch/ia64/Makefile.inc
 ,0 → 1,31
+#
+# 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.
+#
+CFLAGS += -D__64_BITS__
+ARCH_SOURCES := arch/$(UARCH)/ia64.s
+AFLAGS += -xexplicit

 /branches/dd/uspace/srv/loader/arch/ia64/ia64.s
 ,0 → 1,43
+#
+# 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.
+#
+.text
+.globl program_run
+## void program_run(void *entry_point, void *pcb);
+#
+# in0 (r32) contains entry_point
+# in1 (r33) contains pcb
+#
+# Jump to a program entry point
+program_run:
+    # Pass pcb to the entry point in r2
+    mov b6 = r32
+    mov r2 = r33 ;;
+    br b6 ;;

 /branches/dd/uspace/srv/loader/arch/arm32/_link.ld.in
 ,0 → 1,59
+/*
+ * The only difference from _link.ld.in for regular statically-linked apps
+ * is the base address.
+ */
+STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
+ENTRY(__entry)
+PHDRS {
+    interp PT_INTERP;
+    text PT_LOAD FLAGS(5);
+    data PT_LOAD FLAGS(6);
+}
+SECTIONS {
+    .interp : {
+        *(.interp);
+    } : interp
+    . = 0x70001000;
+    .init ALIGN(0x1000): SUBALIGN(0x1000) {
+        *(.init);
+    } : text
+    .text : {
+        *(.text);
+        *(.rodata*);
+    } :text
+    .data ALIGN(0x1000) : SUBALIGN(0x1000) {
+        *(.opd);
+        *(.data .data.*);
+        *(.sdata);
+    } :data
+    .tdata : {
+        _tdata_start = .;
+        *(.tdata);
+        _tdata_end = .;
+    } :data
+    .tbss : {
+        _tbss_start = .;
+        *(.tbss);
+        _tbss_end = .;
+    } :data
+    _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
+    .bss : {
+        *(.sbss);
+        *(.scommon);
+        *(COMMON);
+        *(.bss);
+    } :data
+    . = ALIGN(0x1000);
+    _heap = .;
+    /DISCARD/ : {
+        *(*);
+    }
+}

 /branches/dd/uspace/srv/loader/arch/arm32/Makefile.inc
 ,0 → 1,30
+#
+# 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.
+#
+CFLAGS += -D__32_BITS__
+ARCH_SOURCES := arch/$(UARCH)/arm32.s

 /branches/dd/uspace/srv/loader/arch/arm32/arm32.s
 ,0 → 1,39
+#
+# 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.
+#
+.globl program_run
+## void program_run(void *entry_point, void *pcb);
+#
+# r0    contains entry_point
+# r1    contains pcb
+#
+# Jump to a program entry point
+program_run:
+    # pcb is passed to the entry point in r1 (where it already is)
+    mov r15, r0

 /branches/dd/uspace/srv/loader/arch/ppc32/_link.ld.in
 ,0 → 1,57
+/*
+ * The only difference from _link.ld.in for regular statically-linked apps
+ * is the base address.
+ */
+STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
+ENTRY(__entry)
+PHDRS {
+    interp PT_INTERP;
+    text PT_LOAD FLAGS(5);
+    data PT_LOAD FLAGS(6);
+}
+SECTIONS {
+    .interp : {
+        *(.interp);
+    } :interp
+    . = 0x70001000;
+    .init ALIGN(0x1000) : SUBALIGN(0x1000) {
+        *(.init);
+    } :text
+    .text : {
+        *(.text);
+        *(.rodata*);
+    } :text
+    .data ALIGN(0x1000) : SUBALIGN(0x1000) {
+        *(.data);
+        *(.sdata);
+    } :data
+    .tdata : {
+        _tdata_start = .;
+        *(.tdata);
+        _tdata_end = .;
+    } :data
+    .tbss : {
+        _tbss_start = .;
+        *(.tbss);
+        _tbss_end = .;
+    } :data
+    _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
+    .bss : {
+        *(.sbss);
+        *(COMMON);
+        *(.bss);
+    } :data
+    . = ALIGN(0x1000);
+    _heap = .;
+    /DISCARD/ : {
+        *(*);
+    }
+}

 /branches/dd/uspace/srv/loader/arch/ppc32/Makefile.inc
 ,0 → 1,30
+#
+# 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.
+#
+CFLAGS += -D__32_BITS__
+ARCH_SOURCES := arch/$(UARCH)/ppc32.s

 /branches/dd/uspace/srv/loader/arch/ppc32/ppc32.s
 ,0 → 1,40
+#
+# 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.
+#
+.globl program_run
+## void program_run(void *entry_point, void *pcb);
+#
+# %r3   contains entry_point
+# %r4   contains pcb
+#
+# Jump to a program entry point
+program_run:
+    mtctr %r3
+    mr %r6, %r4 # Pass pcb to the entry point in %r6
+    bctr

 /branches/dd/uspace/srv/loader/arch/amd64/_link.ld.in
 ,0 → 1,52
+STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
+ENTRY(__entry)
+PHDRS {
+    interp PT_INTERP;
+    text PT_LOAD FLAGS(5);
+    data PT_LOAD FLAGS(6);
+}
+SECTIONS {
+    .interp : {
+        *(.interp);
+    } : interp
+    /* . = 0x0000700000001000;*/
+    . = 0x70001000;
+    .init ALIGN(0x1000) : SUBALIGN(0x1000) {
+        *(.init);
+    } :text
+    .text : {
+        *(.text);
+        *(.rodata*);
+    } :text
+    .data ALIGN(0x1000) : SUBALIGN(0x1000) {
+        *(.data);
+    } :data
+    .tdata : {
+        _tdata_start = .;
+        *(.tdata);
+        _tdata_end = .;
+    } :data
+    .tbss : {
+        _tbss_start = .;
+        *(.tbss);
+        _tbss_end = .;
+    } :data
+    _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
+    .bss : {
+        *(COMMON);
+        *(.bss);
+    } :data
+    . = ALIGN(0x1000);
+    _heap = .;
+    /DISCARD/ : {
+        *(*);
+    }
+}

 /branches/dd/uspace/srv/loader/arch/amd64/Makefile.inc
 ,0 → 1,30
+#
+# 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.
+#
+CFLAGS += -D__64_BITS__
+ARCH_SOURCES := arch/$(UARCH)/amd64.s

 /branches/dd/uspace/srv/loader/arch/amd64/amd64.s
 ,0 → 1,43
+#
+# 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.
+#
+.globl program_run
+## void program_run(void *entry_point, void *pcb);
+#
+# %rdi  contains entry_point
+# %rsi  contains pcb
+#
+# Jump to a program entry point
+program_run:
+    # pcb must be passed in %rdi, use %rdx as a scratch register
+    mov %rdi, %rdx
+    mov %rsi, %rdi
+    # jump to entry point
+    jmp %rdx

 /branches/dd/uspace/srv/loader/arch/mips32/_link.ld.in
 ,0 → 1,66
+/*
+ * The only difference from _link.ld.in for regular statically-linked apps
+ * is the base address.
+ */
+STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
+ENTRY(__entry)
+PHDRS {
+    interp PT_INTERP;
+    text PT_LOAD FLAGS(5);
+    data PT_LOAD FLAGS(6);
+}
+SECTIONS {
+    .interp : {
+        *(.interp);
+    } :interp
+    . = 0x70004000;
+    .init ALIGN(0x4000) : SUBALIGN(0x4000) {
+        *(.init);
+    } :text
+    .text : {
+            *(.text);
+        *(.rodata*);
+    } :text
+    .data : {
+        *(.data);
+        *(.data.rel*);
+    } :data
+    .got : {
+        _gp = .;
+        *(.got);
+    } :data
+    .tdata : {
+        _tdata_start = .;
+        *(.tdata);
+        _tdata_end = .;
+    } :data
+    .tbss : {
+        _tbss_start = .;
+        *(.tbss);
+        _tbss_end = .;
+    } :data
+    _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
+    .sbss : {
+        *(.scommon);
+        *(.sbss);
+    }
+    .bss : {
+        *(.bss);
+        *(COMMON);
+    } :data
+    . = ALIGN(0x4000);
+    _heap = .;
+    /DISCARD/ : {
+        *(*);
+    }
+}

 /branches/dd/uspace/srv/loader/arch/mips32/Makefile.inc
 ,0 → 1,30
+#
+# 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.
+#
+CFLAGS += -D__32_BITS__
+ARCH_SOURCES := arch/$(UARCH)/mips32.s

 /branches/dd/uspace/srv/loader/arch/mips32/mips32.s
 ,0 → 1,49
+#
+# 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.
+#
+.text
+.section .text
+.global program_run
+.set noreorder
+## void program_run(void *entry_point, void *pcb);
+#
+# $a0 (=$4) contains entry_point
+# $a1 (=$5) contains pcb
+#
+# Jump to a program entry point
+.ent program_run
+program_run:
+    # tmp := entry_point
+    move $25, $a0
+    # Pass pcb to the entry point in $a0
+    move $a0, $a1
+    jr $25
+    nop
+.end

 /branches/dd/uspace/srv/loader/arch/ia32/_link.ld.in
 ,0 → 1,55
+/*
+ * The difference from _link.ld.in for regular statically-linked apps
+ * is the base address and the special interp section.
+ */
+STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
+ENTRY(__entry)
+PHDRS {
+    interp PT_INTERP;
+        text PT_LOAD FILEHDR PHDRS FLAGS(5);
+    data PT_LOAD FLAGS(6);
+}
+SECTIONS {
+    .interp : {
+        *(.interp);
+    } :interp
+    . = 0x70001000;
+    .init ALIGN(0x1000) : SUBALIGN(0x1000) {
+        *(.init);
+    } :text
+    .text : {
+        *(.text);
+                *(.rodata*);
+    } :text
+    .data ALIGN(0x1000) : SUBALIGN(0x1000) {
+        *(.data);
+    } :data
+    .tdata : {
+        _tdata_start = .;
+        *(.tdata);
+        _tdata_end = .;
+    } :data
+    .tbss : {
+        _tbss_start = .;
+        *(.tbss);
+        _tbss_end = .;
+    } :data
+    _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
+    .bss : {
+                *(COMMON);
+                *(.bss);
+    } :data
+    . = ALIGN(0x1000);
+    _heap = .;
+    /DISCARD/ : {
+        *(*);
+    }
+}

 /branches/dd/uspace/srv/loader/arch/ia32/Makefile.inc
 ,0 → 1,30
+#
+# 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.
+#
+CFLAGS += -D__32_BITS__
+ARCH_SOURCES := arch/$(UARCH)/ia32.s

 /branches/dd/uspace/srv/loader/arch/ia32/ia32.s
 ,0 → 1,49
+#
+# 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.
+#
+.globl program_run
+## void program_run(void *entry_point, void *pcb);
+#
+# Jump to a program entry point
+program_run:
+    # Use standard ia32 prologue not to confuse anybody
+    push %ebp
+    movl %esp, %ebp
+    # %eax := entry_point
+    movl 0x8(%ebp), %eax
+    # %ebx := pcb
+    # pcb is passed to the entry point int %ebx
+    mov 0xc(%ebp), %ebx
+    # Save a tiny bit of stack space
+    pop %ebp
+    jmp %eax

/branches/dd/uspace/srv/loader/arch/mips32eb
0,0 → 1,0
link mips32
Property changes:
Added: svn:special
+*
\ No newline at end of property

 /branches/dd/uspace/srv/loader/elf_load.c
 ,0 → 1,469
+/*
+ * Copyright (c) 2006 Sergey Bondari
+ * Copyright (c) 2006 Jakub Jermar
+ * 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 generic
+ * @{
+ */
+/**
+ * @file
+ * @brief   Userspace ELF loader.
+ *
+ * This module allows loading ELF binaries (both executables and
+ * shared objects) from VFS. The current implementation allocates
+ * anonymous memory, fills it with segment data and then adjusts
+ * the memory areas' flags to the final value. In the future,
+ * the segments will be mapped directly from the file.
+ */
+#include <stdio.h>
+#include <sys/types.h>
+#include <align.h>
+#include <assert.h>
+#include <as.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <smc.h>
+#include <loader/pcb.h>
+#include "elf.h"
+#include "elf_load.h"
+#include "arch.h"
+#define DPRINTF(...)
+static char *error_codes[] = {
+    "no error",
+    "invalid image",
+    "address space error",
+    "incompatible image",
+    "unsupported image type",
+    "irrecoverable error"
+};
+static unsigned int elf_load(elf_ld_t *elf, size_t so_bias);
+static int segment_header(elf_ld_t *elf, elf_segment_header_t *entry);
+static int section_header(elf_ld_t *elf, elf_section_header_t *entry);
+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)
+{
+    int cnt = 0;
+    do {
+        buf += cnt;
+        len -= cnt;
+        cnt = read(fd, buf, len);
+    } while ((cnt > 0) && ((len - cnt) > 0));
+    return cnt;
+}
+/** Load ELF binary from a file.
+ *
+ * Load an ELF binary from the specified file. If the file is
+ * an executable program, it is loaded unbiased. If it is a shared
+ * object, it is loaded with the bias @a so_bias. Some information
+ * extracted from the binary is stored in a elf_info_t structure
+ * pointed to by @a info.
+ *
+ * @param file_name Path to the ELF file.
+ * @param so_bias   Bias to use if the file is a shared object.
+ * @param info      Pointer to a structure for storing information
+ *          extracted from the binary.
+ *
+ * @return EOK on success or negative error code.
+ */
+int elf_load_file(char *file_name, size_t so_bias, elf_info_t *info)
+{
+    elf_ld_t elf;
+    int fd;
+    int rc;
+    fd = open(file_name, O_RDONLY);
+    if (fd < 0) {
+        DPRINTF("failed opening file\n");
+        return -1;
+    }
+    elf.fd = fd;
+    elf.info = info;
+    rc = elf_load(&elf, so_bias);
+    close(fd);
+    return rc;
+}
+/** Run an ELF executable.
+ *
+ * Transfers control to the entry point of an ELF executable loaded
+ * earlier with elf_load_file(). This function does not return.
+ *
+ * @param info  Info structure filled earlier by elf_load_file()
+ */
+void elf_run(elf_info_t *info, pcb_t *pcb)
+{
+    program_run(info->entry, pcb);
+    /* not reached */
+}
+/** Create the program control block (PCB).
+ *
+ * Fills the program control block @a pcb with information from
+ * @a info.
+ *
+ * @param info  Program info structure
+ * @return EOK on success or negative error code
+ */
+void elf_create_pcb(elf_info_t *info, pcb_t *pcb)
+{
+    pcb->entry = info->entry;
+    pcb->dynamic = info->dynamic;
+}
+/** Load an ELF binary.
+ *
+ * The @a elf structure contains the loader state, including
+ * an open file, from which the binary will be loaded,
+ * a pointer to the @c info structure etc.
+ *
+ * @param elf       Pointer to loader state buffer.
+ * @param so_bias   Bias to use if the file is a shared object.
+ * @return EE_OK on success or EE_xx error code.
+ */
+static unsigned int elf_load(elf_ld_t *elf, size_t so_bias)
+{
+    elf_header_t header_buf;
+    elf_header_t *header = &header_buf;
+    int i, rc;
+    rc = my_read(elf->fd, header, sizeof(elf_header_t));
+    if (rc < 0) {
+        DPRINTF("Read error.\n");
+        return EE_INVALID;
+    }
+    elf->header = header;
+    /* Identify ELF */
+    if (header->e_ident[EI_MAG0] != ELFMAG0 ||
+        header->e_ident[EI_MAG1] != ELFMAG1 ||
+        header->e_ident[EI_MAG2] != ELFMAG2 ||
+        header->e_ident[EI_MAG3] != ELFMAG3) {
+        DPRINTF("Invalid header.\n");
+        return EE_INVALID;
+    }
+    /* Identify ELF compatibility */
+    if (header->e_ident[EI_DATA] != ELF_DATA_ENCODING ||
+        header->e_machine != ELF_MACHINE ||
+        header->e_ident[EI_VERSION] != EV_CURRENT ||
+        header->e_version != EV_CURRENT ||
+        header->e_ident[EI_CLASS] != ELF_CLASS) {
+        DPRINTF("Incompatible data/version/class.\n");
+        return EE_INCOMPATIBLE;
+    }
+    if (header->e_phentsize != sizeof(elf_segment_header_t)) {
+        DPRINTF("e_phentsize:%d != %d\n", header->e_phentsize,
+            sizeof(elf_segment_header_t));
+        return EE_INCOMPATIBLE;
+    }
+    if (header->e_shentsize != sizeof(elf_section_header_t)) {
+        DPRINTF("e_shentsize:%d != %d\n", header->e_shentsize,
+            sizeof(elf_section_header_t));
+        return EE_INCOMPATIBLE;
+    }
+    /* Check if the object type is supported. */
+    if (header->e_type != ET_EXEC && header->e_type != ET_DYN) {
+        DPRINTF("Object type %d is not supported\n", header->e_type);
+        return EE_UNSUPPORTED;
+    }
+    /* Shared objects can be loaded with a bias */
+    if (header->e_type == ET_DYN)
+        elf->bias = so_bias;
+    else
+        elf->bias = 0;
+    elf->info->interp = NULL;
+    elf->info->dynamic = NULL;
+    /* Walk through all segment headers and process them. */
+    for (i = 0; i < header->e_phnum; i++) {
+        elf_segment_header_t segment_hdr;
+        /* Seek to start of segment header */
+        lseek(elf->fd, header->e_phoff
+                + i * sizeof(elf_segment_header_t), SEEK_SET);
+        rc = my_read(elf->fd, &segment_hdr,
+            sizeof(elf_segment_header_t));
+        if (rc < 0) {
+            DPRINTF("Read error.\n");
+            return EE_INVALID;
+        }
+        rc = segment_header(elf, &segment_hdr);
+        if (rc != EE_OK)
+            return rc;
+    }
+    DPRINTF("Parse sections.\n");
+    /* Inspect all section headers and proccess them. */
+    for (i = 0; i < header->e_shnum; i++) {
+        elf_section_header_t section_hdr;
+        /* Seek to start of section header */
+        lseek(elf->fd, header->e_shoff
+            + i * sizeof(elf_section_header_t), SEEK_SET);
+        rc = my_read(elf->fd, &section_hdr,
+            sizeof(elf_section_header_t));
+        if (rc < 0) {
+            DPRINTF("Read error.\n");
+            return EE_INVALID;
+        }
+        rc = section_header(elf, &section_hdr);
+        if (rc != EE_OK)
+            return rc;
+    }
+    elf->info->entry =
+        (entry_point_t)((uint8_t *)header->e_entry + elf->bias);
+    DPRINTF("Done.\n");
+    return EE_OK;
+}
+/** Print error message according to error code.
+ *
+ * @param rc Return code returned by elf_load().
+ *
+ * @return NULL terminated description of error.
+ */
+char *elf_error(unsigned int rc)
+{
+    assert(rc < sizeof(error_codes) / sizeof(char *));
+    return error_codes[rc];
+}
+/** Process segment header.
+ *
+ * @param entry Segment header.
+ *
+ * @return EE_OK on success, error code otherwise.
+ */
+static int segment_header(elf_ld_t *elf, elf_segment_header_t *entry)
+{
+    switch (entry->p_type) {
+    case PT_NULL:
+    case PT_PHDR:
+        break;
+    case PT_LOAD:
+        return load_segment(elf, entry);
+        break;
+    case PT_INTERP:
+        /* Assume silently interp == "/rtld.so" */
+        elf->info->interp = "/rtld.so";
+        break;
+    case PT_DYNAMIC:
+    case PT_SHLIB:
+    case PT_NOTE:
+    case PT_LOPROC:
+    case PT_HIPROC:
+    default:
+        DPRINTF("Segment p_type %d unknown.\n", entry->p_type);
+        return EE_UNSUPPORTED;
+        break;
+    }
+    return EE_OK;
+}
+/** Load segment described by program header entry.
+ *
+ * @param elf   Loader state.
+ * @param entry Program header entry describing segment to be loaded.
+ *
+ * @return EE_OK on success, error code otherwise.
+ */
+int load_segment(elf_ld_t *elf, elf_segment_header_t *entry)
+{
+    void *a;
+    int flags = 0;
+    uintptr_t bias;
+    uintptr_t base;
+    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;
+    if (entry->p_align > 1) {
+        if ((entry->p_offset % entry->p_align) !=
+            (entry->p_vaddr % 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
+            );
+            return EE_INVALID;
+        }
+    }
+    /* Final flags that will be set for the memory area */
+    if (entry->p_flags & PF_X)
+        flags |= AS_AREA_EXEC;
+    if (entry->p_flags & PF_W)
+        flags |= AS_AREA_WRITE;
+    if (entry->p_flags & PF_R)
+        flags |= AS_AREA_READ;
+    flags |= AS_AREA_CACHEABLE;
+    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,
+    entry->p_vaddr + bias + ALIGN_UP(entry->p_memsz, PAGE_SIZE));
+    /*
+     * For the course of loading, the area needs to be readable
+     * and writeable.
+     */
+    a = as_area_create((uint8_t *)base + bias, mem_sz,
+        AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
+    if (a == (void *)(-1)) {
+        DPRINTF("Memory mapping failed.\n");
+        return EE_MEMORY;
+    }
+    DPRINTF("as_area_create(0x%lx, 0x%x, %d) -> 0x%lx\n",
+        entry->p_vaddr+bias, entry->p_memsz, flags, (uintptr_t)a);
+    /*
+     * Load segment data
+     */
+    rc = lseek(elf->fd, entry->p_offset, SEEK_SET);
+    if (rc < 0) {
+        printf("seek error\n");
+        return EE_INVALID;
+    }
+/*  rc = read(fd, (void *)(entry->p_vaddr + bias), entry->p_filesz);
+    if (rc < 0) { printf("read error\n"); return EE_INVALID; }*/
+    /* Long reads are not possible yet. Load segment piecewise. */
+    unsigned left, now;
+    uint8_t *dp;
+    left = entry->p_filesz;
+    dp = (uint8_t *)(entry->p_vaddr + bias);
+    while (left > 0) {
+        now = 16384;
+        if (now > left) now = left;
+        rc = my_read(elf->fd, dp, now);
+        if (rc < 0) {
+            DPRINTF("Read error.\n");
+            return EE_INVALID;
+        }
+        left -= now;
+        dp += now;
+    }
+    rc = as_area_change_flags((uint8_t *)entry->p_vaddr + bias, flags);
+    if (rc != 0) {
+        DPRINTF("Failed to set memory area flags.\n");
+        return EE_MEMORY;
+    }
+    if (flags & AS_AREA_EXEC) {
+        /* Enforce SMC coherence for the segment */
+        if (smc_coherence(entry->p_vaddr + bias, entry->p_filesz))
+            return EE_MEMORY;
+    }
+    return EE_OK;
+}
+/** Process section header.
+ *
+ * @param elf   Loader state.
+ * @param entry Segment header.
+ *
+ * @return EE_OK on success, error code otherwise.
+ */
+static int section_header(elf_ld_t *elf, elf_section_header_t *entry)
+{
+    switch (entry->sh_type) {
+    case SHT_PROGBITS:
+        if (entry->sh_flags & SHF_TLS) {
+            /* .tdata */
+        }
+        break;
+    case SHT_NOBITS:
+        if (entry->sh_flags & SHF_TLS) {
+            /* .tbss */
+        }
+        break;
+    case SHT_DYNAMIC:
+        /* Record pointer to dynamic section into info structure */
+        elf->info->dynamic =
+            (void *)((uint8_t *)entry->sh_addr + elf->bias);
+        DPRINTF("Dynamic section found at 0x%x.\n",
+            (uintptr_t)elf->info->dynamic);
+        break;
+    default:
+        break;
+    }
+    return EE_OK;
+}
+/** @}
+ */

/branches/dd/uspace/srv/loader/interp.s
0,0 → 1,7
#
# Provide a string to be included in a special DT_INTERP header, even though
# this is a statically-linked executable. This will mark the binary as
# the program loader.
#
.section .interp , ""
.string "kernel"

 /branches/dd/uspace/srv/loader/include/arch.h
 ,0 → 1,45
+/*
+ * 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 fs
+ * @{
+ */
+/** @file
+ * @brief
+ */
+#ifndef LOADER_ARCH_H_
+#define LOADER_ARCH_H_
+void program_run(void *entry_point, void *pcb);
+#endif
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/loader/include/elf_load.h
 ,0 → 1,83
+/*
+ * 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 generic
+ * @{
+ */
+/** @file
+ * @brief ELF loader structures and public functions.
+ */
+#ifndef ELF_LOAD_H_
+#define ELF_LOAD_H_
+#include <arch/elf.h>
+#include <sys/types.h>
+#include <loader/pcb.h>
+#include "elf.h"
+/**
+ * Some data extracted from the headers are stored here
+ */
+typedef struct {
+    /** Entry point */
+    entry_point_t entry;
+    /** ELF interpreter name or NULL if statically-linked */
+    char *interp;
+    /** Pointer to the dynamic section */
+    void *dynamic;
+} elf_info_t;
+/**
+ * Holds information about an ELF binary being loaded.
+ */
+typedef struct {
+    /** Filedescriptor of the file from which we are loading */
+    int fd;
+    /** Difference between run-time addresses and link-time addresses */
+    uintptr_t bias;
+    /** A copy of the ELF file header */
+    elf_header_t *header;
+    /** Store extracted info here */
+    elf_info_t *info;
+} elf_ld_t;
+int elf_load_file(char *file_name, size_t so_bias, elf_info_t *info);
+void elf_run(elf_info_t *info, pcb_t *pcb);
+void elf_create_pcb(elf_info_t *info, pcb_t *pcb);
+#endif
+/** @}
+ */

 /branches/dd/uspace/srv/loader/include/elf.h
 ,0 → 1,344
+/*
+ * Copyright (c) 2006 Sergey Bondari
+ * 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 generic
+ * @{
+ */
+/** @file
+ */
+#ifndef ELF_H_
+#define ELF_H_
+#include <arch/elf.h>
+#include <sys/types.h>
+/**
+ * current ELF version
+ */
+#define EV_CURRENT  1
+/**
+ * ELF types
+ */
+#define ET_NONE     0    /* No type */
+#define ET_REL      1   /* Relocatable file */
+#define ET_EXEC     2   /* Executable */
+#define ET_DYN      3   /* Shared object */
+#define ET_CORE     4   /* Core */
+#define ET_LOPROC   0xff00  /* Processor specific */
+#define ET_HIPROC   0xffff  /* Processor specific */
+/**
+ * ELF machine types
+ */
+#define EM_NO       0    /* No machine */
+#define EM_SPARC    2   /* SPARC */
+#define EM_386      3   /* i386 */
+#define EM_MIPS     8   /* MIPS RS3000 */
+#define EM_MIPS_RS3_LE  10  /* MIPS RS3000 LE */
+#define EM_PPC      20  /* PPC32 */
+#define EM_PPC64    21  /* PPC64 */
+#define EM_ARM      40  /* ARM */
+#define EM_SPARCV9  43  /* SPARC64 */
+#define EM_IA_64    50  /* IA-64 */
+#define EM_X86_64   62  /* AMD64/EMT64 */
+/**
+ * ELF identification indexes
+ */
+#define EI_MAG0     0
+#define EI_MAG1     1
+#define EI_MAG2     2
+#define EI_MAG3     3
+#define EI_CLASS    4       /* File class */
+#define EI_DATA     5       /* Data encoding */
+#define EI_VERSION  6       /* File version */
+#define EI_OSABI    7
+#define EI_ABIVERSION   8
+#define EI_PAD      9       /* Start of padding bytes */
+#define EI_NIDENT   16      /* ELF identification table size */
+/**
+ * ELF magic number
+ */
+#define ELFMAG0     0x7f
+#define ELFMAG1     'E'
+#define ELFMAG2     'L'
+#define ELFMAG3     'F'
+/**
+ * ELF file classes
+ */
+#define ELFCLASSNONE    0
+#define ELFCLASS32  1
+#define ELFCLASS64  2
+/**
+ * ELF data encoding types
+ */
+#define ELFDATANONE 0
+#define ELFDATA2LSB 1       /* Least significant byte first (little endian) */
+#define ELFDATA2MSB 2       /* Most signigicant byte first (big endian) */
+/**
+ * ELF error return codes
+ */
+#define EE_OK           0    /* No error */
+#define EE_INVALID      1   /* Invalid ELF image */
+#define EE_MEMORY       2   /* Cannot allocate address space */
+#define EE_INCOMPATIBLE     3   /* ELF image is not compatible with current architecture */
+#define EE_UNSUPPORTED      4   /* Non-supported ELF (e.g. dynamic ELFs) */
+#define EE_IRRECOVERABLE    5
+/**
+ * ELF section types
+ */
+#define SHT_NULL        0
+#define SHT_PROGBITS        1
+#define SHT_SYMTAB      2
+#define SHT_STRTAB      3
+#define SHT_RELA        4
+#define SHT_HASH        5
+#define SHT_DYNAMIC     6
+#define SHT_NOTE        7
+#define SHT_NOBITS      8
+#define SHT_REL         9
+#define SHT_SHLIB       10
+#define SHT_DYNSYM      11
+#define SHT_LOOS        0x60000000
+#define SHT_HIOS        0x6fffffff
+#define SHT_LOPROC      0x70000000
+#define SHT_HIPROC      0x7fffffff
+#define SHT_LOUSER      0x80000000
+#define SHT_HIUSER      0xffffffff
+/**
+ * ELF section flags
+ */
+#define SHF_WRITE       0x1
+#define SHF_ALLOC       0x2
+#define SHF_EXECINSTR       0x4
+#define SHF_TLS         0x400
+#define SHF_MASKPROC        0xf0000000
+/**
+ * Symbol binding
+ */
+#define STB_LOCAL       0
+#define STB_GLOBAL      1
+#define STB_WEAK        2
+#define STB_LOPROC      13
+#define STB_HIPROC      15
+/**
+ * Symbol types
+ */
+#define STT_NOTYPE      0
+#define STT_OBJECT      1
+#define STT_FUNC        2
+#define STT_SECTION     3
+#define STT_FILE        4
+#define STT_LOPROC      13
+#define STT_HIPROC      15
+/**
+ * Program segment types
+ */
+#define PT_NULL         0
+#define PT_LOAD         1
+#define PT_DYNAMIC      2
+#define PT_INTERP       3
+#define PT_NOTE         4
+#define PT_SHLIB        5
+#define PT_PHDR         6
+#define PT_LOPROC       0x70000000
+#define PT_HIPROC       0x7fffffff
+/**
+ * Program segment attributes.
+ */
+#define PF_X    1
+#define PF_W    2
+#define PF_R    4
+/**
+ * ELF data types
+ *
+ * These types are found to be identical in both 32-bit and 64-bit
+ * ELF object file specifications. They are the only types used
+ * in ELF header.
+ */
+typedef uint64_t elf_xword;
+typedef int64_t elf_sxword;
+typedef uint32_t elf_word;
+typedef int32_t elf_sword;
+typedef uint16_t elf_half;
+/**
+ * 32-bit ELF data types.
+ *
+ * These types are specific for 32-bit format.
+ */
+typedef uint32_t elf32_addr;
+typedef uint32_t elf32_off;
+/**
+ * 64-bit ELF data types.
+ *
+ * These types are specific for 64-bit format.
+ */
+typedef uint64_t elf64_addr;
+typedef uint64_t elf64_off;
+/** ELF header */
+struct elf32_header {
+    uint8_t e_ident[EI_NIDENT];
+    elf_half e_type;
+    elf_half e_machine;
+    elf_word e_version;
+    elf32_addr e_entry;
+    elf32_off e_phoff;
+    elf32_off e_shoff;
+    elf_word e_flags;
+    elf_half e_ehsize;
+    elf_half e_phentsize;
+    elf_half e_phnum;
+    elf_half e_shentsize;
+    elf_half e_shnum;
+    elf_half e_shstrndx;
+};
+struct elf64_header {
+    uint8_t e_ident[EI_NIDENT];
+    elf_half e_type;
+    elf_half e_machine;
+    elf_word e_version;
+    elf64_addr e_entry;
+    elf64_off e_phoff;
+    elf64_off e_shoff;
+    elf_word e_flags;
+    elf_half e_ehsize;
+    elf_half e_phentsize;
+    elf_half e_phnum;
+    elf_half e_shentsize;
+    elf_half e_shnum;
+    elf_half e_shstrndx;
+};
+/*
+ * ELF segment header.
+ * Segments headers are also known as program headers.
+ */
+struct elf32_segment_header {
+    elf_word p_type;
+    elf32_off p_offset;
+    elf32_addr p_vaddr;
+    elf32_addr p_paddr;
+    elf_word p_filesz;
+    elf_word p_memsz;
+    elf_word p_flags;
+    elf_word p_align;
+};
+struct elf64_segment_header {
+    elf_word p_type;
+    elf_word p_flags;
+    elf64_off p_offset;
+    elf64_addr p_vaddr;
+    elf64_addr p_paddr;
+    elf_xword p_filesz;
+    elf_xword p_memsz;
+    elf_xword p_align;
+};
+/*
+ * ELF section header
+ */
+struct elf32_section_header {
+    elf_word sh_name;
+    elf_word sh_type;
+    elf_word sh_flags;
+    elf32_addr sh_addr;
+    elf32_off sh_offset;
+    elf_word sh_size;
+    elf_word sh_link;
+    elf_word sh_info;
+    elf_word sh_addralign;
+    elf_word sh_entsize;
+};
+struct elf64_section_header {
+    elf_word sh_name;
+    elf_word sh_type;
+    elf_xword sh_flags;
+    elf64_addr sh_addr;
+    elf64_off sh_offset;
+    elf_xword sh_size;
+    elf_word sh_link;
+    elf_word sh_info;
+    elf_xword sh_addralign;
+    elf_xword sh_entsize;
+};
+/*
+ * ELF symbol table entry
+ */
+struct elf32_symbol {
+    elf_word st_name;
+    elf32_addr st_value;
+    elf_word st_size;
+    uint8_t st_info;
+    uint8_t st_other;
+    elf_half st_shndx;
+};
+struct elf64_symbol {
+    elf_word st_name;
+    uint8_t st_info;
+    uint8_t st_other;
+    elf_half st_shndx;
+    elf64_addr st_value;
+    elf_xword st_size;
+};
+#ifdef __32_BITS__
+typedef struct elf32_header elf_header_t;
+typedef struct elf32_segment_header elf_segment_header_t;
+typedef struct elf32_section_header elf_section_header_t;
+typedef struct elf32_symbol elf_symbol_t;
+#endif
+#ifdef __64_BITS__
+typedef struct elf64_header elf_header_t;
+typedef struct elf64_segment_header elf_segment_header_t;
+typedef struct elf64_section_header elf_section_header_t;
+typedef struct elf64_symbol elf_symbol_t;
+#endif
+extern char *elf_error(unsigned int rc);
+#endif
+/** @}
+ */

 /branches/dd/uspace/srv/fb/sgcn.h
 ,0 → 1,46
+/*
+ * Copyright (c) 2008 Pavel Rimsky
+ * 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.
+ */
+/** @defgroup sgcnfb SGCN
+ * @brief   userland driver of the Serengeti console output
+ * @{
+ */
+/** @file
+ */
+#ifndef FB_SGCN_H_
+#define FB_SGCN_H_
+int sgcn_init(void);
+#endif
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/fb/serial_console.c
 ,0 → 1,306
+/*
+ * Copyright (c) 2006 Ondrej Palkovsky
+ * Copyright (c) 2008 Martin Decky
+ * Copyright (c) 2008 Pavel Rimsky
+ * 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.
+ */
+/**
+ * @defgroup serial Serial console
+ * @brief    Serial console services (putc, puts, clear screen, cursor goto,...)
+ * @{
+ */
+/** @file
+ */
+#include <stdio.h>
+#include <ipc/ipc.h>
+#include <async.h>
+#include <ipc/fb.h>
+#include <bool.h>
+#include <errno.h>
+#include <console/color.h>
+#include <console/style.h>
+#include "serial_console.h"
+#define MAX_CONTROL 20
+static void serial_sgr(const unsigned int mode);
+static int width;
+static int height;
+static bool color = true;   /** True if producing color output. */
+static putc_function_t putc_function;
+/* Allow only 1 connection */
+static int client_connected = 0;
+enum sgr_color_index {
+    CI_BLACK    = 0,
+    CI_RED      = 1,
+    CI_GREEN    = 2,
+    CI_BROWN    = 3,
+    CI_BLUE     = 4,
+    CI_MAGENTA  = 5,
+    CI_CYAN     = 6,
+    CI_WHITE    = 7,
+};
+enum sgr_command {
+    SGR_RESET   = 0,
+    SGR_BOLD    = 1,
+    SGR_BLINK   = 5,
+    SGR_REVERSE = 7,
+    SGR_NORMAL_INT  = 22,
+    SGR_BLINK_OFF   = 25,
+    SGR_REVERSE_OFF = 27,
+    SGR_FGCOLOR = 30,
+    SGR_BGCOLOR = 40
+};
+static int color_map[] = {
+    [COLOR_BLACK]   = CI_BLACK,
+    [COLOR_BLUE]    = CI_RED,
+    [COLOR_GREEN]   = CI_GREEN,
+    [COLOR_CYAN]    = CI_CYAN,
+    [COLOR_RED] = CI_RED,
+    [COLOR_MAGENTA] = CI_MAGENTA,
+    [COLOR_YELLOW]  = CI_BROWN,
+    [COLOR_WHITE]   = CI_WHITE
+};
+void serial_puts(char *str)
+{
+    while (*str)
+        putc_function(*(str++));
+}
+void serial_goto(const unsigned int row, const unsigned int col)
+{
+    if ((row > height) || (col > width))
+        return;
+    char control[MAX_CONTROL];
+    snprintf(control, MAX_CONTROL, "\033[%u;%uf", row + 1, col + 1);
+    serial_puts(control);
+}
+void serial_clrscr(void)
+{
+    /* Initialize graphic rendition attributes. */
+    serial_sgr(SGR_RESET);
+    if (color) {
+        serial_sgr(SGR_FGCOLOR + CI_BLACK);
+        serial_sgr(SGR_BGCOLOR + CI_WHITE);
+    }
+    serial_puts("\033[2J");
+}
+void serial_scroll(int i)
+{
+    if (i > 0) {
+        serial_goto(height - 1, 0);
+        while (i--)
+            serial_puts("\033D");
+    } else if (i < 0) {
+        serial_goto(0, 0);
+        while (i++)
+            serial_puts("\033M");
+    }
+}
+/** ECMA-48 Set Graphics Rendition. */
+static void serial_sgr(const unsigned int mode)
+{
+    char control[MAX_CONTROL];
+    snprintf(control, MAX_CONTROL, "\033[%um", mode);
+    serial_puts(control);
+}
+/** Set scrolling region. */
+void serial_set_scroll_region(unsigned last_row)
+{
+    char control[MAX_CONTROL];
+    snprintf(control, MAX_CONTROL, "\033[0;%ur", last_row);
+    serial_puts(control);
+}
+void serial_cursor_disable(void)
+{
+    serial_puts("\033[?25l");
+}
+void serial_cursor_enable(void)
+{
+    serial_puts("\033[?25h");
+}
+void serial_console_init(putc_function_t putc_fn, uint32_t w, uint32_t h)
+{
+    width = w;
+    height = h;
+    putc_function = putc_fn;
+}
+/**
+ * Main function of the thread serving client connections.
+ */
+void serial_client_connection(ipc_callid_t iid, ipc_call_t *icall)
+{
+    int retval;
+    ipc_callid_t callid;
+    ipc_call_t call;
+    char c;
+    int lastcol = 0;
+    int lastrow = 0;
+    int newcol;
+    int newrow;
+    int fgcolor;
+    int bgcolor;
+    int style;
+    int i;
+    if (client_connected) {
+        ipc_answer_0(iid, ELIMIT);
+        return;
+    }
+    client_connected = 1;
+    ipc_answer_0(iid, EOK);
+    /* Clear the terminal, set scrolling region
+       to 0 - height rows. */
+    serial_clrscr();
+    serial_goto(0, 0);
+    serial_set_scroll_region(height);
+    while (true) {
+        callid = async_get_call(&call);
+        switch (IPC_GET_METHOD(call)) {
+        case IPC_M_PHONE_HUNGUP:
+            client_connected = 0;
+            ipc_answer_0(callid, EOK);
+            return;
+        case FB_PUTCHAR:
+            c = IPC_GET_ARG1(call);
+            newrow = IPC_GET_ARG2(call);
+            newcol = IPC_GET_ARG3(call);
+            if ((lastcol != newcol) || (lastrow != newrow))
+                serial_goto(newrow, newcol);
+            lastcol = newcol + 1;
+            lastrow = newrow;
+            (*putc_function)(c);
+            retval = 0;
+            break;
+        case FB_CURSOR_GOTO:
+            newrow = IPC_GET_ARG1(call);
+            newcol = IPC_GET_ARG2(call);
+            serial_goto(newrow, newcol);
+            lastrow = newrow;
+            lastcol = newcol;
+            retval = 0;
+            break;
+        case FB_GET_CSIZE:
+            ipc_answer_2(callid, EOK, height, width);
+            continue;
+        case FB_CLEAR:
+            serial_clrscr();
+            retval = 0;
+            break;
+        case FB_SET_STYLE:
+            style =  IPC_GET_ARG1(call);
+            if (style == STYLE_EMPHASIS) {
+                if (color) {
+                    serial_sgr(SGR_RESET);
+                    serial_sgr(SGR_FGCOLOR + CI_RED);
+                    serial_sgr(SGR_BGCOLOR + CI_WHITE);
+                }
+                serial_sgr(SGR_BOLD);
+            } else {
+                if (color) {
+                    serial_sgr(SGR_RESET);
+                    serial_sgr(SGR_FGCOLOR + CI_BLACK);
+                    serial_sgr(SGR_BGCOLOR + CI_WHITE);
+                }
+                serial_sgr(SGR_NORMAL_INT);
+            }
+            retval = 0;
+            break;
+        case FB_SET_COLOR:
+            fgcolor = IPC_GET_ARG1(call);
+            bgcolor = IPC_GET_ARG2(call);
+            if (color) {
+                serial_sgr(SGR_RESET);
+                serial_sgr(SGR_FGCOLOR + color_map[fgcolor]);
+                serial_sgr(SGR_BGCOLOR + color_map[bgcolor]);
+            } else {
+                if (fgcolor < bgcolor)
+                    serial_sgr(SGR_RESET);
+                else
+                    serial_sgr(SGR_REVERSE);
+            }
+            retval = 0;
+            break;
+        case FB_SET_RGB_COLOR:
+            fgcolor = IPC_GET_ARG1(call);
+            bgcolor = IPC_GET_ARG2(call);
+            if (fgcolor < bgcolor)
+                serial_sgr(SGR_REVERSE_OFF);
+            else
+                serial_sgr(SGR_REVERSE);
+            retval = 0;
+            break;
+        case FB_SCROLL:
+            i = IPC_GET_ARG1(call);
+            if ((i > height) || (i < -height)) {
+                retval = EINVAL;
+                break;
+            }
+            serial_scroll(i);
+            serial_goto(lastrow, lastcol);
+            retval = 0;
+            break;
+        case FB_CURSOR_VISIBILITY:
+            if(IPC_GET_ARG1(call))
+                serial_cursor_enable();
+            else
+                serial_cursor_disable();
+            retval = 0;
+            break;
+        default:
+            retval = ENOENT;
+        }
+        ipc_answer_0(callid, retval);
+    }
+}
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/fb/msim.c
 ,0 → 1,73
+/*
+ * Copyright (c) 2006 Ondrej Palkovsky
+ * Copyright (c) 2008 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.
+ */
+/** @defgroup msimfb MSIM text console
+ * @brief   HelenOS MSIM text console.
+ * @ingroup fbs
+ * @{
+ */
+/** @file
+ */
+#include <async.h>
+#include <libc.h>
+#include <sysinfo.h>
+#include <as.h>
+#include <ddi.h>
+#include "serial_console.h"
+#include "msim.h"
+#define WIDTH 80
+#define HEIGHT 25
+static char *virt_addr;
+static void msim_putc(const char c)
+{
+    *virt_addr = c;
+}
+int msim_init(void)
+{
+    void *phys_addr = (void *) sysinfo_value("fb.address.physical");
+    virt_addr = (char *) as_get_mappable_page(1);
+    if (physmem_map(phys_addr, virt_addr, 1, AS_AREA_READ | AS_AREA_WRITE) != 0)
+        return -1;
+    serial_console_init(msim_putc, WIDTH, HEIGHT);
+    async_set_client_connection(serial_client_connection);
+    return 0;
+}
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/fb/serial_console.h
 ,0 → 1,57
+/*
+ * Copyright (c) 2008 Pavel Rimsky
+ * 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.
+ */
+/**
+ * @defgroup serial Serial console
+ * @brief    Serial console services (putc, puts, clear screen, cursor goto,...)
+ * @{
+ */
+/** @file
+ */
+#ifndef FB_SERIAL_CONSOLE_H_
+#define FB_SERIAL_CONSOLE_H_
+#include <ipc/ipc.h>
+typedef void (*putc_function_t)(char);
+void serial_puts(char *str);
+void serial_goto(const unsigned int row, const unsigned int col);
+void serial_clrscr(void);
+void serial_scroll(int i);
+void serial_set_style(const unsigned int mode);
+void serial_cursor_disable(void);
+void serial_cursor_enable(void);
+void serial_set_scroll_region(unsigned height);
+void serial_console_init(putc_function_t putc_fn, uint32_t w, uint32_t h);
+void serial_client_connection(ipc_callid_t iid, ipc_call_t *icall);
+#endif

 /branches/dd/uspace/srv/fb/font-8x16.c
 ,7 → 28,7
 #include "font-8x16.h"
-unsigned char fb_font[FONT_GLIPHS * FONT_SCANLINES] = {
+unsigned char fb_font[FONT_GLYPHS * FONT_SCANLINES] = {
     /* 0 0x00 '^@' */
 x00, /* 00000000 */

 /branches/dd/uspace/srv/fb/msim.h
 ,0 → 1,47
+/*
+ * Copyright (c) 2006 Ondrej Palkovsky
+ * Copyright (c) 2008 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 msimfb
+ * @brief   HelenOS MSIM text console.
+ * @ingroup fbs
+ * @{
+ */
+/** @file
+ */
+#ifndef FB_MSIM_H_
+#define FB_MSIM_H_
+extern int msim_init(void);
+#endif
+/** @}
+ */

 /branches/dd/uspace/srv/fb/font-8x16.h
 ,9 → 29,11
 #ifndef FB_FONT_8X16_H_
 #define FB_FONT_8X16_H_
-#define FONT_GLIPHS 256
-#define FONT_SCANLINES  16
+#define FONT_GLYPHS      256
+#define FONT_WIDTH       8
+#define FONT_SCANLINES   16
-extern unsigned char fb_font[FONT_GLIPHS * FONT_SCANLINES];
+extern unsigned char fb_font[FONT_GLYPHS * FONT_SCANLINES];
 #endif

 /branches/dd/uspace/srv/fb/main.c
 ,16 → 33,21
 #include <as.h>
 #include <align.h>
 #include <errno.h>
+#include <stdio.h>
 #include "fb.h"
-#include "sysio.h"
 #include "ega.h"
+#include "msim.h"
+#include "ski.h"
+#include "sgcn.h"
 #include "main.h"
+#define NAME "fb"
 void receive_comm_area(ipc_callid_t callid, ipc_call_t *call, void **area)
 {
     void *dest;
     dest = as_get_mappable_page(IPC_GET_ARG2(*call));
     if (ipc_answer_1(callid, EOK, (sysarg_t) dest) == 0) {
         if (*area)
 ,29 → 58,51
 int main(int argc, char *argv[])
 {
+    printf(NAME ": HelenOS Framebuffer service\n");
     ipcarg_t phonead;
-    int initialized = 0;
+    bool initialized = false;
 #ifdef FB_ENABLED
     if (sysinfo_value("fb.kind") == 1) {
         if (fb_init() == 0)
-            initialized = 1;
-    }
+            initialized = true;
+    }
 #endif
 #ifdef EGA_ENABLED
-    if (!initialized && sysinfo_value("fb.kind") == 2) {
+    if ((!initialized) && (sysinfo_value("fb.kind") == 2)) {
         if (ega_init() == 0)
-            initialized = 1;
+            initialized = true;
     }
 #endif
+#ifdef MSIM_ENABLED
+    if ((!initialized) && (sysinfo_value("fb.kind") == 3)) {
+        if (msim_init() == 0)
+            initialized = true;
+    }
+#endif
+#ifdef SGCN_ENABLED
+    if ((!initialized) && (sysinfo_value("fb.kind") == 4)) {
+        if (sgcn_init() == 0)
+            initialized = true;
+    }
+#endif
+#ifdef SKI_ENABLED
+    if ((!initialized) && (sysinfo_value("fb") != true)) {
+        if (ski_init() == 0)
+            initialized = true;
+    }
+#endif
     if (!initialized)
-        sysio_init();
+        return -1;
     if (ipc_connect_to_me(PHONE_NS, SERVICE_VIDEO, 0, 0, &phonead) != 0)
         return -1;
+    printf(NAME ": Accepting connections\n");
     async_manager();
     /* Never reached */
     return 0;
 }

 /branches/dd/uspace/srv/fb/ski.c
 ,0 → 1,84
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * 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.
+ */
+/** @defgroup msimfb MSIM text console
+ * @brief   HelenOS MSIM text console.
+ * @ingroup fbs
+ * @{
+ */
+/** @file
+ */
+#include <async.h>
+#include <libc.h>
+#include <sysinfo.h>
+#include <as.h>
+#include <ddi.h>
+#include "serial_console.h"
+#include "ski.h"
+#define SKI_PUTCHAR     31
+#define WIDTH 80
+#define HEIGHT 25
+/** Display character on ski debug console
+ *
+ * Use SSC (Simulator System Call) to
+ * display character on debug console.
+ *
+ * @param ch Character to be printed.
+ */
+static void ski_putc(const char ch)
+{
+    asm volatile (
+        "mov r15 = %0\n"
+        "mov r32 = %1\n"    /* r32 is in0 */
+        "break 0x80000\n"   /* modifies r8 */
+        :
+        : "i" (SKI_PUTCHAR), "r" (ch)
+        : "r15", "in0", "r8"
+    );
+    if (ch == '\n')
+        ski_putc('\r');
+}
+int ski_init(void)
+{
+    serial_console_init(ski_putc, WIDTH, HEIGHT);
+    async_set_client_connection(serial_client_connection);
+    return 0;
+}
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/fb/fb.c
 ,4 → 1,5
 /*
+ * Copyright (c) 2008 Martin Decky
  * Copyright (c) 2006 Jakub Vana
  * Copyright (c) 2006 Ondrej Palkovsky
  * All rights reserved.
 ,7 → 33,7
  * @brief   HelenOS graphical framebuffer.
  * @ingroup fbs
  * @{
- */
+ */
 /** @file
  */
 ,6 → 51,8
 #include <ipc/services.h>
 #include <kernel/errno.h>
 #include <kernel/genarch/fb/visuals.h>
+#include <console/color.h>
+#include <console/style.h>
 #include <async.h>
 #include <bool.h>
 ,427 → 65,433
 #include "pointer.xbm"
 #include "pointer_mask.xbm"
-#define DEFAULT_BGCOLOR                0xf0f0f0
-#define DEFAULT_FGCOLOR                0x0
+#define DEFAULT_BGCOLOR  0xf0f0f0
+#define DEFAULT_FGCOLOR  0x000000
-/***************************************************************/
-/* Pixel specific fuctions */
+#define MAX_ANIM_LEN     8
+#define MAX_ANIMATIONS   4
+#define MAX_PIXMAPS      256  /**< Maximum number of saved pixmaps */
+#define MAX_VIEWPORTS    128  /**< Viewport is a rectangular area on the screen */
-typedef void (*conv2scr_fn_t)(void *, int);
-typedef int (*conv2rgb_fn_t)(void *);
+/** Function to render a pixel from a RGB value. */
+typedef void (*rgb_conv_t)(void *, uint32_t);
+/** Function to draw a glyph. */
+typedef void (*dg_t)(unsigned int x, unsigned int y, bool cursor,
+    uint8_t *glyphs, uint8_t glyph, uint32_t fg_color, uint32_t bg_color);
 struct {
-    uint8_t *fbaddress;
+    uint8_t *fb_addr;
     unsigned int xres;
     unsigned int yres;
     unsigned int scanline;
+    unsigned int glyphscanline;
     unsigned int pixelbytes;
-    unsigned int invert_colors;
-    conv2scr_fn_t rgb2scr;
-    conv2rgb_fn_t scr2rgb;
+    unsigned int glyphbytes;
+    rgb_conv_t rgb_conv;
 } screen;
+/** Backbuffer character cell. */
 typedef struct {
-    int initialized;
-    unsigned int x, y;
-    unsigned int width, height;
+    uint8_t glyph;
+    uint32_t fg_color;
+    uint32_t bg_color;
+} bb_cell_t;
+typedef struct {
+    bool initialized;
+    unsigned int x;
+    unsigned int y;
+    unsigned int width;
+    unsigned int height;
     /* Text support in window */
-    unsigned int rows, cols;
-    /* Style for text printing */
-    style_t style;
+    unsigned int cols;
+    unsigned int rows;
+    /*
+     * Style and glyphs for text printing
+     */
+    /** Current attributes. */
+    attr_rgb_t attr;
+    /** Pre-rendered mask for rendering glyphs. Different viewports
+     * might use different drawing functions depending on whether their
+     * scanlines are aligned on a word boundary.*/
+    uint8_t *glyphs;
+    uint8_t *bgpixel;
+    /** Glyph drawing function for this viewport. */
+    dg_t dglyph;
     /* Auto-cursor position */
-    int cursor_active, cur_col, cur_row;
-    int cursor_shown;
-    /* Double buffering */
-    uint8_t *dbdata;
-    unsigned int dboffset;
-    unsigned int paused;
+    bool cursor_active;
+    unsigned int cur_col;
+    unsigned int cur_row;
+    bool cursor_shown;
+    /* Back buffer */
+    bb_cell_t *backbuf;
+    unsigned int bbsize;
 } viewport_t;
-#define MAX_ANIM_LEN    8
-#define MAX_ANIMATIONS  4
 typedef struct {
-    int initialized;
-    int enabled;
+    bool initialized;
+    bool enabled;
     unsigned int vp;
     unsigned int pos;
     unsigned int animlen;
     unsigned int pixmaps[MAX_ANIM_LEN];
 } animation_t;
 static animation_t animations[MAX_ANIMATIONS];
-static int anims_enabled;
+static bool anims_enabled;
-/** Maximum number of saved pixmaps
- * Pixmap is a saved rectangle
- */
-#define MAX_PIXMAPS        256
 typedef struct {
     unsigned int width;
     unsigned int height;
     uint8_t *data;
 } pixmap_t;
 static pixmap_t pixmaps[MAX_PIXMAPS];
-/* Viewport is a rectangular area on the screen */
-#define MAX_VIEWPORTS 128
 static viewport_t viewports[128];
-/* Allow only 1 connection */
-static int client_connected = 0;
+static bool client_connected = false;  /**< Allow only 1 connection */
-#define RED(x, bits)    ((x >> (16 + 8 - bits)) & ((1 << bits) - 1))
-#define GREEN(x, bits)  ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
-#define BLUE(x, bits)   ((x >> (8 - bits)) & ((1 << bits) - 1))
+static uint32_t color_table[16] = {
+    [COLOR_BLACK]       = 0x000000,
+    [COLOR_BLUE]        = 0x0000f0,
+    [COLOR_GREEN]       = 0x00f000,
+    [COLOR_CYAN]        = 0x00f0f0,
+    [COLOR_RED]     = 0xf00000,
+    [COLOR_MAGENTA]     = 0xf000f0,
+    [COLOR_YELLOW]      = 0xf0f000,
+    [COLOR_WHITE]       = 0xf0f0f0,
-#define COL_WIDTH   8
-#define ROW_BYTES   (screen.scanline * FONT_SCANLINES)
+    [8 + COLOR_BLACK]   = 0x000000,
+    [8 + COLOR_BLUE]    = 0x0000ff,
+    [8 + COLOR_GREEN]   = 0x00ff00,
+    [8 + COLOR_CYAN]    = 0x00ffff,
+    [8 + COLOR_RED]     = 0xff0000,
+    [8 + COLOR_MAGENTA] = 0xff00ff,
+    [8 + COLOR_YELLOW]  = 0xffff00,
+    [8 + COLOR_WHITE]   = 0xffffff,
+};
-#define POINTPOS(x, y)  ((y) * screen.scanline + (x) * screen.pixelbytes)
+static int rgb_from_attr(attr_rgb_t *rgb, const attrs_t *a);
+static int rgb_from_style(attr_rgb_t *rgb, int style);
+static int rgb_from_idx(attr_rgb_t *rgb, ipcarg_t fg_color,
+    ipcarg_t bg_color, ipcarg_t flags);
-static inline int COLOR(int color)
-{
-    return screen.invert_colors ? ~color : color;
-}
+static int fb_set_color(viewport_t *vport, ipcarg_t fg_color,
+    ipcarg_t bg_color, ipcarg_t attr);
-/* Conversion routines between different color representations */
-static void
-rgb_byte0888(void *dst, int rgb)
-{
-    *(int *)dst = rgb;
-}
+static void draw_glyph_aligned(unsigned int x, unsigned int y, bool cursor,
+    uint8_t *glyphs, uint8_t glyph, uint32_t fg_color, uint32_t bg_color);
+static void draw_glyph_fallback(unsigned int x, unsigned int y, bool cursor,
+    uint8_t *glyphs, uint8_t glyph, uint32_t fg_color, uint32_t bg_color);
-static int
-byte0888_rgb(void *src)
-{
-    return (*(int *)src) & 0xffffff;
-}
+static void draw_vp_glyph(viewport_t *vport, bool cursor, unsigned int col,
+    unsigned int row);
-static void
-bgr_byte0888(void *dst, int rgb)
-{
-    *((uint32_t *) dst) = BLUE(rgb, 8) << 16 | GREEN(rgb, 8) << 8 |
-        RED(rgb, 8);
-}
-static int
-byte0888_bgr(void *src)
-{
-    int color = *(uint32_t *)(src);
-    return ((color & 0xff) << 16) | (((color >> 8) & 0xff) << 8) |
-        ((color >> 16) & 0xff);
-}
+#define RED(x, bits)                 ((x >> (8 + 8 + 8 - bits)) & ((1 << bits) - 1))
+#define GREEN(x, bits)               ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
+#define BLUE(x, bits)                ((x >> (8 - bits)) & ((1 << bits) - 1))
-static void
-rgb_byte888(void *dst, int rgb)
-{
-    uint8_t *scr = dst;
-#if defined(FB_INVERT_ENDIAN)
-    scr[0] = RED(rgb, 8);
-    scr[1] = GREEN(rgb, 8);
-    scr[2] = BLUE(rgb, 8);
-#else
-    scr[2] = RED(rgb, 8);
-    scr[1] = GREEN(rgb, 8);
-    scr[0] = BLUE(rgb, 8);
-#endif
-}
+#define COL2X(col)                   ((col) * FONT_WIDTH)
+#define ROW2Y(row)                   ((row) * FONT_SCANLINES)
-static int
-byte888_rgb(void *src)
-{
-    uint8_t *scr = src;
-#if defined(FB_INVERT_ENDIAN)
-    return scr[0] << 16 | scr[1] << 8 | scr[2];
-#else
-    return scr[2] << 16 | scr[1] << 8 | scr[0];
-#endif
-}
+#define X2COL(x)                     ((x) / FONT_WIDTH)
+#define Y2ROW(y)                     ((y) / FONT_SCANLINES)
-/**  16-bit depth (5:5:5) */
-static void
-rgb_byte555(void *dst, int rgb)
-{
-    /* 5-bit, 5-bits, 5-bits */
-    *((uint16_t *)(dst)) = RED(rgb, 5) << 10 | GREEN(rgb, 5) << 5 |
-        BLUE(rgb, 5);
-}
+#define FB_POS(x, y)                 ((y) * screen.scanline + (x) * screen.pixelbytes)
+#define BB_POS(vport, col, row)      ((row) * vport->cols + (col))
+#define GLYPH_POS(glyph, y, cursor)  (((glyph) + (cursor) * FONT_GLYPHS) * screen.glyphbytes + (y) * screen.glyphscanline)
-/** 16-bit depth (5:5:5) */
-static int
-byte555_rgb(void *src)
+/** ARGB 8:8:8:8 conversion
+ *
+ */
+static void rgb_0888(void *dst, uint32_t rgb)
 {
-    int color = *(uint16_t *)(src);
-    return (((color >> 10) & 0x1f) << (16 + 3)) |
-        (((color >> 5) & 0x1f) << (8 + 3)) | ((color & 0x1f) << 3);
+    *((uint32_t *) dst) = rgb & 0xffffff;
 }
-/**  16-bit depth (5:6:5) */
-static void
-rgb_byte565(void *dst, int rgb)
+/** ABGR 8:8:8:8 conversion
+ *
+ */
+static void bgr_0888(void *dst, uint32_t rgb)
 {
-    /* 5-bit, 6-bits, 5-bits */
-    *((uint16_t *)(dst)) = RED(rgb, 5) << 11 | GREEN(rgb, 6) << 5 |
-        BLUE(rgb, 5);
+    *((uint32_t *) dst)
+        = (BLUE(rgb, 8) << 16) | (GREEN(rgb, 8) << 8) | RED(rgb, 8);
 }
-/** 16-bit depth (5:6:5) */
-static int
-byte565_rgb(void *src)
+/** RGB 8:8:8 conversion
+ *
+ */
+static void rgb_888(void *dst, uint32_t rgb)
 {
-    int color = *(uint16_t *)(src);
-    return (((color >> 11) & 0x1f) << (16 + 3)) |
-        (((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3);
+    ((uint8_t *) dst)[0] = BLUE(rgb, 8);
+    ((uint8_t *) dst)[1] = GREEN(rgb, 8);
+    ((uint8_t *) dst)[2] = RED(rgb, 8);
 }
-/** Put pixel - 8-bit depth (3:2:3) */
-static void
-rgb_byte8(void *dst, int rgb)
+/** BGR 8:8:8 conversion
+ *
+ */
+static void bgr_888(void *dst, uint32_t rgb)
 {
-    *(uint8_t *)dst = RED(rgb, 3) << 5 | GREEN(rgb, 2) << 3 | BLUE(rgb, 3);
+    ((uint8_t *) dst)[0] = RED(rgb, 8);
+    ((uint8_t *) dst)[1] = GREEN(rgb, 8);
+    ((uint8_t *) dst)[2] = BLUE(rgb, 8);
 }
-/** Return pixel color - 8-bit depth (3:2:3) */
-static int
-byte8_rgb(void *src)
+/** RGB 5:5:5 conversion
+ *
+ */
+static void rgb_555(void *dst, uint32_t rgb)
 {
-    int color = *(uint8_t *)src;
-    return (((color >> 5) & 0x7) << (16 + 5)) |
-        (((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5);
+    *((uint16_t *) dst)
+        = (RED(rgb, 5) << 10) | (GREEN(rgb, 5) << 5) | BLUE(rgb, 5);
 }
-/** Put pixel into viewport
+/** RGB 5:6:5 conversion
  *
- * @param vport Viewport identification
- * @param x X coord relative to viewport
- * @param y Y coord relative to viewport
- * @param color RGB color
  */
-static void
-putpixel(viewport_t *vport, unsigned int x, unsigned int y, int color)
+static void rgb_565(void *dst, uint32_t rgb)
 {
-    int dx = vport->x + x;
-    int dy = vport->y + y;
-    if (! (vport->paused && vport->dbdata))
-        (*screen.rgb2scr)(&screen.fbaddress[POINTPOS(dx,dy)],
-            COLOR(color));
-    if (vport->dbdata) {
-        int dline = (y + vport->dboffset) % vport->height;
-        int doffset = screen.pixelbytes * (dline * vport->width + x);
-        (*screen.rgb2scr)(&vport->dbdata[doffset], COLOR(color));
-    }
+    *((uint16_t *) dst)
+        = (RED(rgb, 5) << 11) | (GREEN(rgb, 6) << 5) | BLUE(rgb, 5);
 }
-/** Get pixel from viewport */
-static int
-getpixel(viewport_t *vport, unsigned int x, unsigned int y)
-{
-    int dx = vport->x + x;
-    int dy = vport->y + y;
-    return COLOR((*screen.scr2rgb)(&screen.fbaddress[POINTPOS(dx, dy)]));
-}
-static inline void
-putpixel_mem(char *mem, unsigned int x, unsigned int y, int color)
+/** RGB 3:2:3
+ *
+ */
+static void rgb_323(void *dst, uint32_t rgb)
 {
-    (*screen.rgb2scr)(&mem[POINTPOS(x, y)], COLOR(color));
+    *((uint8_t *) dst)
+        = ~((RED(rgb, 3) << 5) | (GREEN(rgb, 2) << 3) | BLUE(rgb, 3));
 }
-static void
-draw_rectangle(viewport_t *vport, unsigned int sx, unsigned int sy,
-    unsigned int width, unsigned int height, int color)
+/** Draw a filled rectangle.
+ *
+ * @note Need real implementation that does not access VRAM twice.
+ */
+static void draw_filled_rect(unsigned int x0, unsigned int y0, unsigned int x1,
+    unsigned int y1, uint32_t color)
 {
     unsigned int x, y;
-    static void *tmpline;
+    unsigned int copy_bytes;
-    if (!tmpline)
-        tmpline = malloc(screen.scanline * screen.pixelbytes);
+    uint8_t *sp, *dp;
+    uint8_t cbuf[4];
-    /* Clear first line */
-    for (x = 0; x < width; x++)
-        putpixel_mem(tmpline, x, 0, color);
+    if (y0 >= y1 || x0 >= x1) return;
+    screen.rgb_conv(cbuf, color);
-    if (!vport->paused) {
-        /* Recompute to screen coords */
-        sx += vport->x;
-        sy += vport->y;
-        /* Copy the rest */
-        for (y = sy;y < sy+height; y++)
-            memcpy(&screen.fbaddress[POINTPOS(sx,y)], tmpline,
-                screen.pixelbytes * width);
+    sp = &screen.fb_addr[FB_POS(x0, y0)];
+    dp = sp;
+    /* Draw the first line. */
+    for (x = x0; x < x1; x++) {
+        memcpy(dp, cbuf, screen.pixelbytes);
+        dp += screen.pixelbytes;
     }
-    if (vport->dbdata) {
-        for (y = sy; y < sy + height; y++) {
-            int rline = (y + vport->dboffset) % vport->height;
-            int rpos = (rline * vport->width + sx) *
-                screen.pixelbytes;
-            memcpy(&vport->dbdata[rpos], tmpline,
-                screen.pixelbytes * width);
-        }
-    }
-}
+    dp = sp + screen.scanline;
+    copy_bytes = (x1 - x0) * screen.pixelbytes;
-/** Fill viewport with background color */
-static void
-clear_port(viewport_t *vport)
-{
-    draw_rectangle(vport, 0, 0, vport->width, vport->height,
-        vport->style.bg_color);
+    /* Draw the remaining lines by copying. */
+    for (y = y0 + 1; y < y1; y++) {
+        memcpy(dp, sp, copy_bytes);
+        dp += screen.scanline;
+    }
 }
-/** Scroll unbuffered viewport up/down
+/** Redraw viewport.
  *
- * @param vport Viewport to scroll
- * @param lines Positive number - scroll up, negative - scroll down
+ * @param vport Viewport to redraw
+ *
  */
-static void
-scroll_port_nodb(viewport_t *vport, int lines)
+static void vport_redraw(viewport_t *vport)
 {
-    int y;
+    unsigned int row, col;
-    if (lines > 0) {
-        for (y = vport->y; y < vport->y+vport->height - lines; y++)
-            memcpy(&screen.fbaddress[POINTPOS(vport->x,y)],
-                &screen.fbaddress[POINTPOS(vport->x,y + lines)],
-                screen.pixelbytes * vport->width);
-        draw_rectangle(vport, 0, vport->height - lines, vport->width,
-            lines, vport->style.bg_color);
-    } else if (lines < 0) {
-        lines = -lines;
-        for (y = vport->y + vport->height-1; y >= vport->y + lines; y--)
-            memcpy(&screen.fbaddress[POINTPOS(vport->x,y)],
-                &screen.fbaddress[POINTPOS(vport->x,y - lines)],
-                screen.pixelbytes * vport->width);
-        draw_rectangle(vport, 0, 0, vport->width, lines,
-            vport->style.bg_color);
+    for (row = 0; row < vport->rows; row++) {
+        for (col = 0; col < vport->cols; col++) {
+            draw_vp_glyph(vport, false, col, row);
+        }
     }
-}
-/** Refresh given viewport from double buffer */
-static void
-refresh_viewport_db(viewport_t *vport)
-{
-    unsigned int y, srcy, srcoff, dsty, dstx;
+    if (COL2X(vport->cols) < vport->width) {
+        draw_filled_rect(
+            vport->x + COL2X(vport->cols), vport->y,
+            vport->x + vport->width, vport->y + vport->height,
+            vport->attr.bg_color);
+    }
-    for (y = 0; y < vport->height; y++) {
-        srcy = (y + vport->dboffset) % vport->height;
-        srcoff = (vport->width * srcy) * screen.pixelbytes;
-        dstx = vport->x;
-        dsty = vport->y + y;
-        memcpy(&screen.fbaddress[POINTPOS(dstx,dsty)],
-            &vport->dbdata[srcoff], vport->width * screen.pixelbytes);
+    if (ROW2Y(vport->rows) < vport->height) {
+        draw_filled_rect(
+            vport->x, vport->y + ROW2Y(vport->rows),
+            vport->x + vport->width, vport->y + vport->height,
+            vport->attr.bg_color);
     }
 }
-/** Scroll viewport that has double buffering enabled */
-static void
-scroll_port_db(viewport_t *vport, int lines)
+static void backbuf_clear(bb_cell_t *backbuf, size_t len, uint32_t fg_color,
+    uint32_t bg_color)
 {
-    ++vport->paused;
-    if (lines > 0) {
-        draw_rectangle(vport, 0, 0, vport->width, lines,
-            vport->style.bg_color);
-        vport->dboffset += lines;
-        vport->dboffset %= vport->height;
-    } else if (lines < 0) {
-        lines = -lines;
-        draw_rectangle(vport, 0, vport->height-lines, vport->width,
-            lines, vport->style.bg_color);
+    unsigned i;
-        if (vport->dboffset < lines)
-            vport->dboffset += vport->height;
-        vport->dboffset -= lines;
+    for (i = 0; i < len; i++) {
+        backbuf[i].glyph = 0;
+        backbuf[i].fg_color = fg_color;
+        backbuf[i].bg_color = bg_color;
     }
-    --vport->paused;
-    refresh_viewport_db(vport);
 }
-/** Scrolls viewport given number of lines */
-static void
-scroll_port(viewport_t *vport, int lines)
+/** Clear viewport.
+ *
+ * @param vport Viewport to clear
+ *
+ */
+static void vport_clear(viewport_t *vport)
 {
-    if (vport->dbdata)
-        scroll_port_db(vport, lines);
-    else
-        scroll_port_nodb(vport, lines);
+    backbuf_clear(vport->backbuf, vport->cols * vport->rows,
+        vport->attr.fg_color, vport->attr.bg_color);
+    vport_redraw(vport);
 }
-static void
-invert_pixel(viewport_t *vport, unsigned int x, unsigned int y)
+/** Scroll viewport by the specified number of lines.
+ *
+ * @param vport Viewport to scroll
+ * @param lines Number of lines to scroll
+ *
+ */
+static void vport_scroll(viewport_t *vport, int lines)
 {
-    putpixel(vport, x, y, ~getpixel(vport, x, y));
-}
+    unsigned int row, col;
+    unsigned int x, y;
+    uint8_t glyph;
+    uint32_t fg_color;
+    uint32_t bg_color;
+    bb_cell_t *bbp, *xbp;
+    /*
+     * Redraw.
+     */
-/***************************************************************/
-/* Character-console functions */
+    y = vport->y;
+    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)) {
+                xbp = &vport->backbuf[BB_POS(vport, col, row + lines)];
+                bbp = &vport->backbuf[BB_POS(vport, col, row)];
-/** Draw character at given position
- *
- * @param vport Viewport where the character is printed
- * @param sx Coordinates of top-left of the character
- * @param sy Coordinates of top-left of the character
- * @param style Color of the character
- * @param transparent If false, print background color
- */
-static void
-draw_glyph(viewport_t *vport,uint8_t glyph, unsigned int sx, unsigned int sy,
-    style_t style, int transparent)
-{
-    int i;
-    unsigned int y;
-    unsigned int glline;
+                glyph = xbp->glyph;
+                fg_color = xbp->fg_color;
+                bg_color = xbp->bg_color;
-    for (y = 0; y < FONT_SCANLINES; y++) {
-        glline = fb_font[glyph * FONT_SCANLINES + y];
-        for (i = 0; i < 8; i++) {
-            if (glline & (1 << (7 - i)))
-                putpixel(vport, sx + i, sy + y, style.fg_color);
-            else if (!transparent)
-                putpixel(vport, sx + i, sy + y, style.bg_color);
+                if (bbp->glyph == glyph &&
+                    bbp->fg_color == xbp->fg_color &&
+                    bbp->bg_color == xbp->bg_color) {
+                    x += FONT_WIDTH;
+                    continue;
+                }
+            } else {
+                glyph = 0;
+                fg_color = vport->attr.fg_color;
+                bg_color = vport->attr.bg_color;
+            }
+            (*vport->dglyph)(x, y, false, vport->glyphs, glyph,
+                fg_color, bg_color);
+            x += FONT_WIDTH;
         }
+        y += FONT_SCANLINES;
     }
+    /*
+     * Scroll backbuffer.
+     */
+    if (lines > 0) {
+        memmove(vport->backbuf, vport->backbuf + vport->cols * lines,
+            vport->cols * (vport->rows - lines) * sizeof(bb_cell_t));
+        backbuf_clear(&vport->backbuf[BB_POS(vport, 0, vport->rows - lines)],
+            vport->cols * lines, vport->attr.fg_color, vport->attr.bg_color);
+    } else {
+        memmove(vport->backbuf - vport->cols * lines, vport->backbuf,
+            vport->cols * (vport->rows + lines) * sizeof(bb_cell_t));
+        backbuf_clear(vport->backbuf, - vport->cols * lines,
+            vport->attr.fg_color, vport->attr.bg_color);
+    }
 }
-/** Invert character at given position */
-static void
-invert_char(viewport_t *vport,unsigned int row, unsigned int col)
+/** Render glyphs
+ *
+ * Convert glyphs from device independent font
+ * description to current visual representation.
+ *
+ * @param vport Viewport
+ *
+ */
+static void render_glyphs(viewport_t* vport)
 {
-    unsigned int x;
-    unsigned int y;
-    for (x = 0; x < COL_WIDTH; x++)
-        for (y = 0; y < FONT_SCANLINES; y++)
-            invert_pixel(vport, col * COL_WIDTH + x, row *
-                FONT_SCANLINES + y);
+    unsigned int glyph;
+    for (glyph = 0; glyph < FONT_GLYPHS; glyph++) {
+        unsigned int y;
+        for (y = 0; y < FONT_SCANLINES; y++) {
+            unsigned int x;
+            for (x = 0; x < FONT_WIDTH; x++) {
+                screen.rgb_conv(&vport->glyphs[GLYPH_POS(glyph, y, false) + x * screen.pixelbytes],
+                    (fb_font[glyph * FONT_SCANLINES + y] & (1 << (7 - x)))
+                    ? 0xffffff : 0x000000);
+                screen.rgb_conv(&vport->glyphs[GLYPH_POS(glyph, y, true) + x * screen.pixelbytes],
+                    (fb_font[glyph * FONT_SCANLINES + y] & (1 << (7 - x)))
+                    ? 0x000000 : 0xffffff);
+            }
+        }
+    }
+    screen.rgb_conv(vport->bgpixel, vport->attr.bg_color);
 }
-/***************************************************************/
-/* Stdout specific functions */
 /** Create new viewport
  *
- * @return New viewport number
+ * @param x      Origin of the viewport (x).
+ * @param y      Origin of the viewport (y).
+ * @param width  Width of the viewport.
+ * @param height Height of the viewport.
+ *
+ * @return New viewport number.
+ *
  */
-static int
-viewport_create(unsigned int x, unsigned int y,unsigned int width,
-    unsigned int height)
+static int vport_create(unsigned int x, unsigned int y,
+    unsigned int width, unsigned int height)
 {
-    int i;
+    unsigned int i;
     for (i = 0; i < MAX_VIEWPORTS; i++) {
         if (!viewports[i].initialized)
             break;
 ,75 → 498,124
     }
     if (i == MAX_VIEWPORTS)
         return ELIMIT;
+    unsigned int cols = width / FONT_WIDTH;
+    unsigned int rows = height / FONT_SCANLINES;
+    unsigned int bbsize = cols * rows * sizeof(bb_cell_t);
+    unsigned int glyphsize = 2 * FONT_GLYPHS * screen.glyphbytes;
+    unsigned int word_size = sizeof(unsigned long);
+    bb_cell_t *backbuf = (bb_cell_t *) malloc(bbsize);
+    if (!backbuf)
+        return ENOMEM;
+    uint8_t *glyphs = (uint8_t *) malloc(glyphsize);
+    if (!glyphs) {
+        free(backbuf);
+        return ENOMEM;
+    }
+    uint8_t *bgpixel = (uint8_t *) malloc(screen.pixelbytes);
+    if (!bgpixel) {
+        free(glyphs);
+        free(backbuf);
+        return ENOMEM;
+    }
+    backbuf_clear(backbuf, cols * rows, DEFAULT_FGCOLOR, DEFAULT_BGCOLOR);
+    memset(glyphs, 0, glyphsize);
+    memset(bgpixel, 0, screen.pixelbytes);
     viewports[i].x = x;
     viewports[i].y = y;
     viewports[i].width = width;
     viewports[i].height = height;
-    viewports[i].rows = height / FONT_SCANLINES;
-    viewports[i].cols = width / COL_WIDTH;
+    viewports[i].cols = cols;
+    viewports[i].rows = rows;
+    viewports[i].attr.bg_color = DEFAULT_BGCOLOR;
+    viewports[i].attr.fg_color = DEFAULT_FGCOLOR;
+    viewports[i].glyphs = glyphs;
+    viewports[i].bgpixel = bgpixel;
-    viewports[i].style.bg_color = DEFAULT_BGCOLOR;
-    viewports[i].style.fg_color = DEFAULT_FGCOLOR;
+    /*
+     * Conditions necessary  to select aligned version:
+     *
+     *   - word size is divisible by pixelbytes
+     *   - cell scanline size is divisible by word size
+     *   - cell scanlines are word-aligned
+     */
+    if ((word_size % screen.pixelbytes) == 0 &&
+        (FONT_WIDTH * screen.pixelbytes) % word_size == 0 &&
+        (x * screen.pixelbytes) % word_size == 0 &&
+        screen.scanline % word_size == 0) {
+        viewports[i].dglyph = draw_glyph_aligned;
+    } else {
+        viewports[i].dglyph = draw_glyph_fallback;
+    }
     viewports[i].cur_col = 0;
     viewports[i].cur_row = 0;
-    viewports[i].cursor_active = 0;
-    viewports[i].initialized = 1;
+    viewports[i].cursor_active = false;
+    viewports[i].cursor_shown = false;
+    viewports[i].bbsize = bbsize;
+    viewports[i].backbuf = backbuf;
+    viewports[i].initialized = true;
+    render_glyphs(&viewports[i]);
     return i;
 }
 /** Initialize framebuffer as a chardev output device
  *
- * @param addr          Address of theframebuffer
- * @param xres          Screen width in pixels
- * @param yres          Screen height in pixels
- * @param visual        Bits per pixel (8, 16, 24, 32)
- * @param scan          Bytes per one scanline
- * @param invert_colors Inverted colors.
+ * @param addr   Address of the framebuffer
+ * @param xres   Screen width in pixels
+ * @param yres   Screen height in pixels
+ * @param visual Bits per pixel (8, 16, 24, 32)
+ * @param scan   Bytes per one scanline
  *
  */
-static bool
-screen_init(void *addr, unsigned int xres, unsigned int yres,
-    unsigned int scan, unsigned int visual, bool invert_colors)
+static bool screen_init(void *addr, unsigned int xres, unsigned int yres,
+    unsigned int scan, unsigned int visual)
 {
     switch (visual) {
     case VISUAL_INDIRECT_8:
-        screen.rgb2scr = rgb_byte8;
-        screen.scr2rgb = byte8_rgb;
+        screen.rgb_conv = rgb_323;
         screen.pixelbytes = 1;
         break;
     case VISUAL_RGB_5_5_5:
-        screen.rgb2scr = rgb_byte555;
-        screen.scr2rgb = byte555_rgb;
+        screen.rgb_conv = rgb_555;
         screen.pixelbytes = 2;
         break;
     case VISUAL_RGB_5_6_5:
-        screen.rgb2scr = rgb_byte565;
-        screen.scr2rgb = byte565_rgb;
+        screen.rgb_conv = rgb_565;
         screen.pixelbytes = 2;
         break;
     case VISUAL_RGB_8_8_8:
-        screen.rgb2scr = rgb_byte888;
-        screen.scr2rgb = byte888_rgb;
+        screen.rgb_conv = rgb_888;
         screen.pixelbytes = 3;
         break;
+    case VISUAL_BGR_8_8_8:
+        screen.rgb_conv = bgr_888;
+        screen.pixelbytes = 3;
+        break;
     case VISUAL_RGB_8_8_8_0:
-        screen.rgb2scr = rgb_byte888;
-        screen.scr2rgb = byte888_rgb;
+        screen.rgb_conv = rgb_888;
         screen.pixelbytes = 4;
         break;
     case VISUAL_RGB_0_8_8_8:
-        screen.rgb2scr = rgb_byte0888;
-        screen.scr2rgb = byte0888_rgb;
+        screen.rgb_conv = rgb_0888;
         screen.pixelbytes = 4;
         break;
     case VISUAL_BGR_0_8_8_8:
-        screen.rgb2scr = bgr_byte0888;
-        screen.scr2rgb = byte0888_bgr;
+        screen.rgb_conv = bgr_0888;
         screen.pixelbytes = 4;
         break;
     default:
 ,72 → 622,239
         return false;
     }
-    screen.fbaddress = (unsigned char *) addr;
+    screen.fb_addr = (unsigned char *) addr;
     screen.xres = xres;
     screen.yres = yres;
     screen.scanline = scan;
-    screen.invert_colors = invert_colors;
+    screen.glyphscanline = FONT_WIDTH * screen.pixelbytes;
+    screen.glyphbytes = screen.glyphscanline * FONT_SCANLINES;
     /* Create first viewport */
-    viewport_create(0, 0, xres, yres);
+    vport_create(0, 0, xres, yres);
     return true;
 }
-/** Hide cursor if it is shown */
-static void
-cursor_hide(viewport_t *vport)
+/** Draw a glyph, takes advantage of alignment.
+ *
+ * This version can only be used if the following conditions are met:
+ *
+ *   - word size is divisible by pixelbytes
+ *   - cell scanline size is divisible by word size
+ *   - cell scanlines are word-aligned
+ *
+ * It makes use of the pre-rendered mask to process (possibly) several
+ * pixels at once (word size / pixelbytes pixels at a time are processed)
+ * making it very fast. Most notably this version is not applicable at 24 bits
+ * per pixel.
+ *
+ * @param x     x coordinate of top-left corner on screen.
+ * @param y     y coordinate of top-left corner on screen.
+ * @param cursor    Draw glyph with cursor
+ * @param glyphs    Pointer to font bitmap.
+ * @param glyph     Code of the glyph to draw.
+ * @param fg_color  Foreground color.
+ * @param bg_color  Backgroudn color.
+ */
+static void draw_glyph_aligned(unsigned int x, unsigned int y, bool cursor,
+    uint8_t *glyphs, uint8_t glyph, uint32_t fg_color, uint32_t bg_color)
 {
-    if (vport->cursor_active && vport->cursor_shown) {
-        invert_char(vport, vport->cur_row, vport->cur_col);
-        vport->cursor_shown = 0;
+    unsigned int i, yd;
+    unsigned long fg_buf, bg_buf;
+    unsigned long *maskp, *dp;
+    unsigned long mask;
+    unsigned int ww, d_add;
+    /*
+     * Prepare a pair of words, one filled with foreground-color
+     * pattern and the other filled with background-color pattern.
+     */
+    for (i = 0; i < sizeof(unsigned long) / screen.pixelbytes; i++) {
+        screen.rgb_conv(&((uint8_t *)&fg_buf)[i * screen.pixelbytes],
+            fg_color);
+        screen.rgb_conv(&((uint8_t *)&bg_buf)[i * screen.pixelbytes],
+            bg_color);
     }
+    /* Pointer to the current position in the mask. */
+    maskp = (unsigned long *) &glyphs[GLYPH_POS(glyph, 0, cursor)];
+    /* Pointer to the current position on the screen. */
+    dp = (unsigned long *) &screen.fb_addr[FB_POS(x, y)];
+    /* Width of the character cell in words. */
+    ww = FONT_WIDTH * screen.pixelbytes / sizeof(unsigned long);
+    /* Offset to add when moving to another screen scanline. */
+    d_add = screen.scanline - FONT_WIDTH * screen.pixelbytes;
+    for (yd = 0; yd < FONT_SCANLINES; yd++) {
+        /*
+         * Now process the cell scanline, combining foreground
+         * and background color patters using the pre-rendered mask.
+         */
+        for (i = 0; i < ww; i++) {
+            mask = *maskp++;
+            *dp++ = (fg_buf & mask) | (bg_buf & ~mask);
+        }
+        /* Move to the beginning of the next scanline of the cell. */
+        dp = (unsigned long *) ((uint8_t *) dp + d_add);
+    }
 }
-/** Show cursor if cursor showing is enabled */
-static void
-cursor_print(viewport_t *vport)
+/** Draw a glyph, fallback version.
+ *
+ * This version does not make use of the pre-rendered mask, it uses
+ * the font bitmap directly. It works always, but it is slower.
+ *
+ * @param x     x coordinate of top-left corner on screen.
+ * @param y     y coordinate of top-left corner on screen.
+ * @param cursor    Draw glyph with cursor
+ * @param glyphs    Pointer to font bitmap.
+ * @param glyph     Code of the glyph to draw.
+ * @param fg_color  Foreground color.
+ * @param bg_color  Backgroudn color.
+ */
+void draw_glyph_fallback(unsigned int x, unsigned int y, bool cursor,
+    uint8_t *glyphs, uint8_t glyph, uint32_t fg_color, uint32_t bg_color)
 {
+    unsigned int i, j, yd;
+    uint8_t fg_buf[4], bg_buf[4];
+    uint8_t *dp, *sp;
+    unsigned int d_add;
+    uint8_t b;
+    /* Pre-render 1x the foreground and background color pixels. */
+    if (cursor) {
+        screen.rgb_conv(fg_buf, bg_color);
+        screen.rgb_conv(bg_buf, fg_color);
+    } else {
+        screen.rgb_conv(fg_buf, fg_color);
+        screen.rgb_conv(bg_buf, bg_color);
+    }
+    /* Pointer to the current position on the screen. */
+    dp = (uint8_t *) &screen.fb_addr[FB_POS(x, y)];
+    /* Offset to add when moving to another screen scanline. */
+    d_add = screen.scanline - FONT_WIDTH * screen.pixelbytes;
+    for (yd = 0; yd < FONT_SCANLINES; yd++) {
+        /* Byte containing bits of the glyph scanline. */
+        b = fb_font[glyph * FONT_SCANLINES + yd];
+        for (i = 0; i < FONT_WIDTH; i++) {
+            /* Choose color based on the current bit. */
+            sp = (b & 0x80) ? fg_buf : bg_buf;
+            /* Copy the pixel. */
+            for (j = 0; j < screen.pixelbytes; j++) {
+                *dp++ = *sp++;
+            }
+            /* Move to the next bit. */
+            b = b << 1;
+        }
+        /* Move to the beginning of the next scanline of the cell. */
+        dp += d_add;
+    }
+}
+/** Draw glyph at specified position in viewport.
+ *
+ * @param vport  Viewport identification
+ * @param cursor Draw glyph with cursor
+ * @param col    Screen position relative to viewport
+ * @param row    Screen position relative to viewport
+ *
+ */
+static void draw_vp_glyph(viewport_t *vport, bool cursor, unsigned int col,
+    unsigned int row)
+{
+    unsigned int x = vport->x + COL2X(col);
+    unsigned int y = vport->y + ROW2Y(row);
+    uint8_t glyph;
+    uint32_t fg_color;
+    uint32_t bg_color;
+    glyph = vport->backbuf[BB_POS(vport, col, row)].glyph;
+    fg_color = vport->backbuf[BB_POS(vport, col, row)].fg_color;
+    bg_color = vport->backbuf[BB_POS(vport, col, row)].bg_color;
+    (*vport->dglyph)(x, y, cursor, vport->glyphs, glyph,
+        fg_color, bg_color);
+}
+/** Hide cursor if it is shown
+ *
+ */
+static void cursor_hide(viewport_t *vport)
+{
+    if ((vport->cursor_active) && (vport->cursor_shown)) {
+        draw_vp_glyph(vport, false, vport->cur_col, vport->cur_row);
+        vport->cursor_shown = false;
+    }
+}
+/** Show cursor if cursor showing is enabled
+ *
+ */
+static void cursor_show(viewport_t *vport)
+{
     /* Do not check for cursor_shown */
     if (vport->cursor_active) {
-        invert_char(vport, vport->cur_row, vport->cur_col);
-        vport->cursor_shown = 1;
+        draw_vp_glyph(vport, true, vport->cur_col, vport->cur_row);
+        vport->cursor_shown = true;
     }
 }
-/** Invert cursor, if it is enabled */
-static void
-cursor_blink(viewport_t *vport)
+/** Invert cursor, if it is enabled
+ *
+ */
+static void cursor_blink(viewport_t *vport)
 {
     if (vport->cursor_shown)
         cursor_hide(vport);
     else
-        cursor_print(vport);
+        cursor_show(vport);
 }
-/** Draw character at given position relative to viewport
- *
- * @param vport Viewport identification
- * @param c Character to print
- * @param row Screen position relative to viewport
- * @param col Screen position relative to viewport
- * @param transparent If false, print background color with character
+/** Draw character at given position relative to viewport
+ *
+ * @param vport  Viewport identification
+ * @param c      Character to draw
+ * @param col    Screen position relative to viewport
+ * @param row    Screen position relative to viewport
+ *
  */
-static void
-draw_char(viewport_t *vport, char c, unsigned int row, unsigned int col,
-    style_t style, int transparent)
+static void draw_char(viewport_t *vport, uint8_t c, unsigned int col, unsigned int row)
 {
-    /* Optimize - do not hide cursor if we are going to overwrite it */
-    if (vport->cursor_active && vport->cursor_shown &&
-        (vport->cur_col != col || vport->cur_row != row))
-        invert_char(vport, vport->cur_row, vport->cur_col);
+    bb_cell_t *bbp;
+    /* Do not hide cursor if we are going to overwrite it */
+    if ((vport->cursor_active) && (vport->cursor_shown) &&
+        ((vport->cur_col != col) || (vport->cur_row != row)))
+        cursor_hide(vport);
+    bbp = &vport->backbuf[BB_POS(vport, col, row)];
+    bbp->glyph = c;
+    bbp->fg_color = vport->attr.fg_color;
+    bbp->bg_color = vport->attr.bg_color;
+    draw_vp_glyph(vport, false, col, row);
-    draw_glyph(vport, c, col * COL_WIDTH, row * FONT_SCANLINES, style,
-        transparent);
     vport->cur_col = col;
     vport->cur_row = row;
     vport->cur_col++;
     if (vport->cur_col >= vport->cols) {
         vport->cur_col = 0;
 ,65 → 862,91
         if (vport->cur_row >= vport->rows)
             vport->cur_row--;
     }
-    cursor_print(vport);
+    cursor_show(vport);
 }
 /** Draw text data to viewport
  *
  * @param vport Viewport id
- * @param data Text data fitting exactly into viewport
+ * @param data  Text data fitting exactly into viewport
+ *
  */
-static void
-draw_text_data(viewport_t *vport, keyfield_t *data)
+static void draw_text_data(viewport_t *vport, keyfield_t *data)
 {
-    int i;
-    int col,row;
+    unsigned int i;
+    bb_cell_t *bbp;
+    attrs_t *a;
+    attr_rgb_t rgb;
+    for (i = 0; i < vport->cols * vport->rows; i++) {
+        unsigned int col = i % vport->cols;
+        unsigned int row = i / vport->cols;
+        bbp = &vport->backbuf[BB_POS(vport, col, row)];
+        uint8_t glyph = bbp->glyph;
-    clear_port(vport);
-    for (i = 0; i < vport->cols * vport->rows; i++) {
-        if (data[i].character == ' ' && style_same(data[i].style,
-            vport->style))
-            continue;
-        col = i % vport->cols;
-        row = i / vport->cols;
-        draw_glyph(vport, data[i].character, col * COL_WIDTH, row *
-            FONT_SCANLINES, data[i].style, style_same(data[i].style,
-            vport->style));
+        a = &data[i].attrs;
+        rgb_from_attr(&rgb, a);
+        bbp->glyph = data[i].character;
+        bbp->fg_color = rgb.fg_color;
+        bbp->bg_color = rgb.bg_color;
+        draw_vp_glyph(vport, false, col, row);
     }
-    cursor_print(vport);
+    cursor_show(vport);
 }
-/** Return first free pixmap */
-static int
-find_free_pixmap(void)
+static void putpixel_pixmap(void *data, unsigned int x, unsigned int y, uint32_t color)
 {
-    int i;
+    int pm = *((int *) data);
+    pixmap_t *pmap = &pixmaps[pm];
+    unsigned int pos = (y * pmap->width + x) * screen.pixelbytes;
-    for (i = 0;i < MAX_PIXMAPS;i++)
+    screen.rgb_conv(&pmap->data[pos], color);
+}
+static void putpixel(void *data, unsigned int x, unsigned int y, uint32_t color)
+{
+    viewport_t *vport = (viewport_t *) data;
+    unsigned int dx = vport->x + x;
+    unsigned int dy = vport->y + y;
+    screen.rgb_conv(&screen.fb_addr[FB_POS(dx, dy)], color);
+}
+/** Return first free pixmap
+ *
+ */
+static int find_free_pixmap(void)
+{
+    unsigned int i;
+    for (i = 0; i < MAX_PIXMAPS; i++)
         if (!pixmaps[i].data)
             return i;
     return -1;
 }
-static void
-putpixel_pixmap(int pm, unsigned int x, unsigned int y, int color)
-{
-    pixmap_t *pmap = &pixmaps[pm];
-    int pos = (y * pmap->width + x) * screen.pixelbytes;
-    (*screen.rgb2scr)(&pmap->data[pos],COLOR(color));
-}
-/** Create a new pixmap and return appropriate ID */
-static int
-shm2pixmap(unsigned char *shm, size_t size)
+/** Create a new pixmap and return appropriate ID
+ *
+ */
+static int shm2pixmap(unsigned char *shm, size_t size)
 {
     int pm;
     pixmap_t *pmap;
     pm = find_free_pixmap();
     if (pm == -1)
         return ELIMIT;
     pmap = &pixmaps[pm];
     if (ppm_get_data(shm, size, &pmap->width, &pmap->height))
 ,19 → 955,19
     pmap->data = malloc(pmap->width * pmap->height * screen.pixelbytes);
     if (!pmap->data)
         return ENOMEM;
-    ppm_draw(shm, size, 0, 0, pmap->width, pmap->height,
-        (putpixel_cb_t)putpixel_pixmap, (void *)pm);
+    ppm_draw(shm, size, 0, 0, pmap->width, pmap->height, putpixel_pixmap, (void *) &pm);
     return pm;
 }
 /** Handle shared memory communication calls
  *
  * Protocol for drawing pixmaps:
  * - FB_PREPARE_SHM(client shm identification)
  * - IPC_M_AS_AREA_SEND
- * - FB_DRAW_PPM(startx,starty)
+ * - FB_DRAW_PPM(startx, starty)
  * - FB_DROP_SHM
  *
  * Protocol for text drawing
 ,28 → 975,30
  * - FB_DRAW_TEXT_DATA
  *
  * @param callid Callid of the current call
- * @param call Current call data
- * @param vp Active viewport
- * @return 0 if the call was not handled byt this function, 1 otherwise
+ * @param call   Current call data
+ * @param vp     Active viewport
  *
- * note: this function is not threads safe, you would have
+ * @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
+ *
  */
-static int
-shm_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
+static bool shm_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
 {
     static keyfield_t *interbuffer = NULL;
     static size_t intersize = 0;
     static unsigned char *shm = NULL;
     static ipcarg_t shm_id = 0;
     static size_t shm_size;
-    int handled = 1;
-    int retval = 0;
+    bool handled = true;
+    int retval = EOK;
     viewport_t *vport = &viewports[vp];
-    unsigned int x, y;
+    unsigned int x;
+    unsigned int y;
     switch (IPC_GET_METHOD(*call)) {
     case IPC_M_SHARE_OUT:
         /* We accept one area for data interchange */
 ,19 → 1005,20
         if (IPC_GET_ARG1(*call) == shm_id) {
             void *dest = as_get_mappable_page(IPC_GET_ARG2(*call));
             shm_size = IPC_GET_ARG2(*call);
-            if (!ipc_answer_1(callid, EOK, (sysarg_t) dest))
+            if (!ipc_answer_1(callid, EOK, (sysarg_t) dest))
                 shm = dest;
             else
                 shm_id = 0;
             if (shm[0] != 'P')
-                while (1)
-                    ;
-            return 1;
+                return false;
+            return true;
         } else {
             intersize = IPC_GET_ARG2(*call);
             receive_comm_area(callid, call, (void *) &interbuffer);
         }
-        return 1;
+        return true;
     case FB_PREPARE_SHM:
         if (shm_id)
             retval = EBUSY;
 ,7 → 1033,7
         }
         shm_id = 0;
         break;
     case FB_SHM2PIXMAP:
         if (!shm) {
             retval = EINVAL;
 ,14 → 1048,14
         }
         x = IPC_GET_ARG1(*call);
         y = IPC_GET_ARG2(*call);
-        if (x > vport->width || y > vport->height) {
+        if ((x > vport->width) || (y > vport->height)) {
             retval = EINVAL;
             break;
         }
         ppm_draw(shm, shm_size, IPC_GET_ARG1(*call),
-            IPC_GET_ARG2(*call), vport->width - x, vport->height - y,
-            (putpixel_cb_t)putpixel, vport);
+            IPC_GET_ARG2(*call), vport->width - x, vport->height - y, putpixel, (void *) vport);
         break;
     case FB_DRAW_TEXT_DATA:
         if (!interbuffer) {
 ,8 → 1062,7
             retval = EINVAL;
             break;
         }
-        if (intersize < vport->cols * vport->rows *
-            sizeof(*interbuffer)) {
+        if (intersize < vport->cols * vport->rows * sizeof(*interbuffer)) {
             retval = EINVAL;
             break;
         }
 ,7 → 1069,7
         draw_text_data(vport, interbuffer);
         break;
     default:
-        handled = 0;
+        handled = false;
     }
     if (handled)
 ,41 → 1077,39
     return handled;
 }
-static void
-copy_vp_to_pixmap(viewport_t *vport, pixmap_t *pmap)
+static void copy_vp_to_pixmap(viewport_t *vport, pixmap_t *pmap)
 {
-    int y;
-    int tmp, srcrowsize;
-    int realwidth, realheight, realrowsize;
-    int width = vport->width;
-    int height = vport->height;
+    unsigned int width = vport->width;
+    unsigned int height = vport->height;
     if (width + vport->x > screen.xres)
         width = screen.xres - vport->x;
     if (height + vport->y > screen.yres)
         height = screen.yres - vport->y;
-    realwidth = pmap->width <= width ? pmap->width : width;
-    realheight = pmap->height <= height ? pmap->height : height;
-    srcrowsize = vport->width * screen.pixelbytes;
-    realrowsize = realwidth * screen.pixelbytes;
+    unsigned int realwidth = pmap->width <= width ? pmap->width : width;
+    unsigned int realheight = pmap->height <= height ? pmap->height : height;
+    unsigned int srcrowsize = vport->width * screen.pixelbytes;
+    unsigned int realrowsize = realwidth * screen.pixelbytes;
+    unsigned int y;
     for (y = 0; y < realheight; y++) {
-        tmp = (vport->y + y) * screen.scanline +
-            vport->x * screen.pixelbytes;
-        memcpy(pmap->data + srcrowsize * y, screen.fbaddress + tmp,
-            realrowsize);
+        unsigned int tmp = (vport->y + y) * screen.scanline + vport->x * screen.pixelbytes;
+        memcpy(pmap->data + srcrowsize * y, screen.fb_addr + tmp, realrowsize);
     }
 }
-/** Save viewport to pixmap */
-static int
-save_vp_to_pixmap(viewport_t *vport)
+/** Save viewport to pixmap
+ *
+ */
+static int save_vp_to_pixmap(viewport_t *vport)
 {
     int pm;
     pixmap_t *pmap;
     pm = find_free_pixmap();
     if (pm == -1)
         return ELIMIT;
 ,58 → 1118,60
     pmap->data = malloc(screen.pixelbytes * vport->width * vport->height);
     if (!pmap->data)
         return ENOMEM;
     pmap->width = vport->width;
     pmap->height = vport->height;
     copy_vp_to_pixmap(vport, pmap);
     return pm;
 }
 /** Draw pixmap on screen
  *
  * @param vp Viewport to draw on
  * @param pm Pixmap identifier
+ *
  */
 static int draw_pixmap(int vp, int pm)
 {
     pixmap_t *pmap = &pixmaps[pm];
     viewport_t *vport = &viewports[vp];
-    int y;
-    int tmp, srcrowsize;
-    int realwidth, realheight, realrowsize;
-    int width = vport->width;
-    int height = vport->height;
+    unsigned int width = vport->width;
+    unsigned int height = vport->height;
     if (width + vport->x > screen.xres)
         width = screen.xres - vport->x;
     if (height + vport->y > screen.yres)
         height = screen.yres - vport->y;
     if (!pmap->data)
         return EINVAL;
-    realwidth = pmap->width <= width ? pmap->width : width;
-    realheight = pmap->height <= height ? pmap->height : height;
-    srcrowsize = vport->width * screen.pixelbytes;
-    realrowsize = realwidth * screen.pixelbytes;
+    unsigned int realwidth = pmap->width <= width ? pmap->width : width;
+    unsigned int realheight = pmap->height <= height ? pmap->height : height;
+    unsigned int srcrowsize = vport->width * screen.pixelbytes;
+    unsigned int realrowsize = realwidth * screen.pixelbytes;
+    unsigned int y;
     for (y = 0; y < realheight; y++) {
-        tmp = (vport->y + y) * screen.scanline +
-            vport->x * screen.pixelbytes;
-        memcpy(screen.fbaddress + tmp, pmap->data + y * srcrowsize,
-            realrowsize);
+        unsigned int tmp = (vport->y + y) * screen.scanline + vport->x * screen.pixelbytes;
+        memcpy(screen.fb_addr + tmp, pmap->data + y * srcrowsize, realrowsize);
     }
-    return 0;
+    return EOK;
 }
-/** Tick animation one step forward */
-static void
-anims_tick(void)
+/** Tick animation one step forward
+ *
+ */
+static void anims_tick(void)
 {
-    int i;
+    unsigned int i;
     static int counts = 0;
     /* Limit redrawing */
 ,37 → 1180,36
         return;
     for (i = 0; i < MAX_ANIMATIONS; i++) {
-        if (!animations[i].animlen || !animations[i].initialized ||
-            !animations[i].enabled)
+        if ((!animations[i].animlen) || (!animations[i].initialized) ||
+            (!animations[i].enabled))
             continue;
-        draw_pixmap(animations[i].vp,
-            animations[i].pixmaps[animations[i].pos]);
-        animations[i].pos = (animations[i].pos + 1) %
-            animations[i].animlen;
+        draw_pixmap(animations[i].vp, animations[i].pixmaps[animations[i].pos]);
+        animations[i].pos = (animations[i].pos + 1) % animations[i].animlen;
     }
 }
-static int pointer_x, pointer_y;
-static int pointer_shown, pointer_enabled;
+static unsigned int pointer_x;
+static unsigned int pointer_y;
+static bool pointer_shown, pointer_enabled;
 static int pointer_vport = -1;
 static int pointer_pixmap = -1;
-static void
-mouse_show(void)
+static void mouse_show(void)
 {
     int i, j;
     int visibility;
     int color;
     int bytepos;
-    if (pointer_shown || !pointer_enabled)
+    if ((pointer_shown) || (!pointer_enabled))
         return;
-    /* Save image under the cursor */
+    /* Save image under the pointer. */
     if (pointer_vport == -1) {
-        pointer_vport = viewport_create(pointer_x, pointer_y,
-            pointer_width, pointer_height);
+        pointer_vport = vport_create(pointer_x, pointer_y, pointer_width, pointer_height);
         if (pointer_vport < 0)
             return;
     } else {
 ,14 → 1216,13
         viewports[pointer_vport].x = pointer_x;
         viewports[pointer_vport].y = pointer_y;
     }
     if (pointer_pixmap == -1)
         pointer_pixmap = save_vp_to_pixmap(&viewports[pointer_vport]);
     else
-        copy_vp_to_pixmap(&viewports[pointer_vport],
-            &pixmaps[pointer_pixmap]);
-    /* Draw cursor */
+        copy_vp_to_pixmap(&viewports[pointer_vport], &pixmaps[pointer_pixmap]);
+    /* Draw mouse pointer. */
     for (i = 0; i < pointer_height; i++)
         for (j = 0; j < pointer_width; j++) {
             bytepos = i * ((pointer_width - 1) / 8 + 1) + j / 8;
 ,10 → 1240,10
     pointer_shown = 1;
 }
-static void
-mouse_hide(void)
+static void mouse_hide(void)
 {
-    /* Restore image under the cursor */
+    /* Restore image under the pointer. */
     if (pointer_shown) {
         draw_pixmap(pointer_vport, pointer_pixmap);
         pointer_shown = 0;
 ,8 → 1250,8
     }
 }
-static void
-mouse_move(unsigned int x, unsigned int y)
+static void mouse_move(unsigned int x, unsigned int y)
 {
     mouse_hide();
     pointer_x = x;
 ,14 → 1259,14
     mouse_show();
 }
-static int
-anim_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
+static int anim_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
 {
-    int handled = 1;
-    int retval = 0;
-    int i,nvp;
+    bool handled = true;
+    int retval = EOK;
+    int i, nvp;
     int newval;
     switch (IPC_GET_METHOD(*call)) {
     case FB_ANIM_CREATE:
         nvp = IPC_GET_ARG1(*call);
 ,14 → 1356,16
     return handled;
 }
-/** Handler for messages concerning pixmap handling */
-static int
-pixmap_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
+/** Handler for messages concerning pixmap handling
+ *
+ */
+static int pixmap_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
 {
-    int handled = 1;
-    int retval = 0;
-    int i,nvp;
+    bool handled = true;
+    int retval = EOK;
+    int i, nvp;
     switch (IPC_GET_METHOD(*call)) {
     case FB_VP_DRAW_PIXMAP:
         nvp = IPC_GET_ARG1(*call);
 ,7 → 1403,7
     default:
         handled = 0;
     }
     if (handled)
         ipc_answer_0(callid, retval);
     return handled;
 ,35 → 1410,99
 }
+static int rgb_from_style(attr_rgb_t *rgb, int style)
+{
+    switch (style) {
+    case STYLE_NORMAL:
+        rgb->fg_color = color_table[COLOR_BLACK];
+        rgb->bg_color = color_table[COLOR_WHITE];
+        break;
+    case STYLE_EMPHASIS:
+        rgb->fg_color = color_table[COLOR_RED];
+        rgb->bg_color = color_table[COLOR_WHITE];
+        break;
+    default:
+        return EINVAL;
+    }
+    return EOK;
+}
+static int rgb_from_idx(attr_rgb_t *rgb, ipcarg_t fg_color,
+    ipcarg_t bg_color, ipcarg_t flags)
+{
+    fg_color = (fg_color & 7) | ((flags & CATTR_BRIGHT) ? 8 : 0);
+    bg_color = (bg_color & 7) | ((flags & CATTR_BRIGHT) ? 8 : 0);
+    rgb->fg_color = color_table[fg_color];
+    rgb->bg_color = color_table[bg_color];
+    return EOK;
+}
+static int rgb_from_attr(attr_rgb_t *rgb, const attrs_t *a)
+{
+    int rc;
+    switch (a->t) {
+    case at_style:
+        rc = rgb_from_style(rgb, a->a.s.style);
+        break;
+    case at_idx:
+        rc = rgb_from_idx(rgb, a->a.i.fg_color,
+            a->a.i.bg_color, a->a.i.flags);
+        break;
+    case at_rgb:
+        *rgb = a->a.r;
+        rc = EOK;
+        break;
+    }
+    return rc;
+}
+static int fb_set_style(viewport_t *vport, ipcarg_t style)
+{
+    return rgb_from_style(&vport->attr, (int) style);
+}
+static int fb_set_color(viewport_t *vport, ipcarg_t fg_color,
+    ipcarg_t bg_color, ipcarg_t flags)
+{
+    return rgb_from_idx(&vport->attr, fg_color, bg_color, flags);
+}
 /** Function for handling connections to FB
  *
  */
-static void
-fb_client_connection(ipc_callid_t iid, ipc_call_t *icall)
+static void fb_client_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
-    ipc_callid_t callid;
-    ipc_call_t call;
-    int retval;
-    int i;
-    unsigned int row,col;
-    char c;
-    int vp = 0;
-    viewport_t *vport = &viewports[0];
+    unsigned int vp = 0;
+    viewport_t *vport = &viewports[vp];
     if (client_connected) {
         ipc_answer_0(iid, ELIMIT);
         return;
     }
-    client_connected = 1;
-    ipc_answer_0(iid, EOK); /* Accept connection */
-    while (1) {
-        if (vport->cursor_active || anims_enabled)
+    /* Accept connection */
+    client_connected = true;
+    ipc_answer_0(iid, EOK);
+    while (true) {
+        ipc_callid_t callid;
+        ipc_call_t call;
+        int retval;
+        unsigned int i;
+        int scroll;
+        uint8_t glyph;
+        unsigned int row, col;
+        if ((vport->cursor_active) || (anims_enabled))
             callid = async_get_call_timeout(&call, 250000);
         else
             callid = async_get_call(&call);
         mouse_hide();
         if (!callid) {
             cursor_blink(vport);
 ,105 → 1510,89
             mouse_show();
             continue;
         }
         if (shm_handle(callid, &call, vp))
             continue;
         if (pixmap_handle(callid, &call, vp))
             continue;
         if (anim_handle(callid, &call, vp))
             continue;
-        switch (IPC_GET_METHOD(call)) {
+        switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
-            client_connected = 0;
-            /* cleanup other viewports */
+            client_connected = false;
+            /* Cleanup other viewports */
             for (i = 1; i < MAX_VIEWPORTS; i++)
-                vport->initialized = 0;
-            return; /* Exit thread */
+                vport->initialized = false;
+            /* Exit thread */
+            return;
         case FB_PUTCHAR:
-        case FB_TRANS_PUTCHAR:
-            c = IPC_GET_ARG1(call);
+            glyph = IPC_GET_ARG1(call);
             row = IPC_GET_ARG2(call);
             col = IPC_GET_ARG3(call);
-            if (row >= vport->rows || col >= vport->cols) {
+            if ((col >= vport->cols) || (row >= vport->rows)) {
                 retval = EINVAL;
                 break;
             }
             ipc_answer_0(callid, EOK);
-            draw_char(vport, c, row, col, vport->style,
-                IPC_GET_METHOD(call) == FB_TRANS_PUTCHAR);
-            continue; /* msg already answered */
+            draw_char(vport, glyph, col, row);
+            /* Message already answered */
+            continue;
         case FB_CLEAR:
-            clear_port(vport);
-            cursor_print(vport);
-            retval = 0;
+            vport_clear(vport);
+            cursor_show(vport);
+            retval = EOK;
             break;
-        case FB_CURSOR_GOTO:
+        case FB_CURSOR_GOTO:
             row = IPC_GET_ARG1(call);
             col = IPC_GET_ARG2(call);
-            if (row >= vport->rows || col >= vport->cols) {
+            if ((col >= vport->cols) || (row >= vport->rows)) {
                 retval = EINVAL;
                 break;
             }
-            retval = 0;
+            retval = EOK;
             cursor_hide(vport);
             vport->cur_col = col;
             vport->cur_row = row;
-            cursor_print(vport);
-            break;
+            cursor_show(vport);
+            break;
         case FB_CURSOR_VISIBILITY:
             cursor_hide(vport);
             vport->cursor_active = IPC_GET_ARG1(call);
-            cursor_print(vport);
-            retval = 0;
+            cursor_show(vport);
+            retval = EOK;
             break;
         case FB_GET_CSIZE:
             ipc_answer_2(callid, EOK, vport->rows, vport->cols);
             continue;
         case FB_SCROLL:
-            i = IPC_GET_ARG1(call);
-            if (i > vport->rows || i < (- (int)vport->rows)) {
+            scroll = IPC_GET_ARG1(call);
+            if ((scroll > (int) vport->rows) || (scroll < (-(int) vport->rows))) {
                 retval = EINVAL;
                 break;
             }
             cursor_hide(vport);
-            scroll_port(vport, i*FONT_SCANLINES);
-            cursor_print(vport);
-            retval = 0;
+            vport_scroll(vport, scroll);
+            cursor_show(vport);
+            retval = EOK;
             break;
-        case FB_VIEWPORT_DB:
-            /* Enable double buffering */
-            i = IPC_GET_ARG1(call);
-            if (i == -1)
-                i = vp;
-            if (i < 0 || i >= MAX_VIEWPORTS) {
-                retval = EINVAL;
-                break;
-            }
-            if (!viewports[i].initialized ) {
-                retval = EADDRNOTAVAIL;
-                break;
-            }
-            viewports[i].dboffset = 0;
-            if (IPC_GET_ARG2(call) == 1 && !viewports[i].dbdata)
-                viewports[i].dbdata =
-                    malloc(screen.pixelbytes *
-                    viewports[i].width * viewports[i].height);
-            else if (IPC_GET_ARG2(call) == 0 &&
-                viewports[i].dbdata) {
-                free(viewports[i].dbdata);
-                viewports[i].dbdata = NULL;
-            }
-            retval = 0;
-            break;
         case FB_VIEWPORT_SWITCH:
             i = IPC_GET_ARG1(call);
-            if (i < 0 || i >= MAX_VIEWPORTS) {
+            if (i >= MAX_VIEWPORTS) {
                 retval = EINVAL;
                 break;
             }
-            if (! viewports[i].initialized ) {
+            if (!viewports[i].initialized) {
                 retval = EADDRNOTAVAIL;
                 break;
             }
 ,11 → 1599,11
             cursor_hide(vport);
             vp = i;
             vport = &viewports[vp];
-            cursor_print(vport);
-            retval = 0;
+            cursor_show(vport);
+            retval = EOK;
             break;
         case FB_VIEWPORT_CREATE:
-            retval = viewport_create(IPC_GET_ARG1(call) >> 16,
+            retval = vport_create(IPC_GET_ARG1(call) >> 16,
                 IPC_GET_ARG1(call) & 0xffff,
                 IPC_GET_ARG2(call) >> 16,
                 IPC_GET_ARG2(call) & 0xffff);
 ,33 → 1610,42
             break;
         case FB_VIEWPORT_DELETE:
             i = IPC_GET_ARG1(call);
-            if (i < 0 || i >= MAX_VIEWPORTS) {
+            if (i >= MAX_VIEWPORTS) {
                 retval = EINVAL;
                 break;
             }
-            if (! viewports[i].initialized ) {
+            if (!viewports[i].initialized) {
                 retval = EADDRNOTAVAIL;
                 break;
             }
-            viewports[i].initialized = 0;
-            if (viewports[i].dbdata) {
-                free(viewports[i].dbdata);
-                viewports[i].dbdata = NULL;
-            }
-            retval = 0;
+            viewports[i].initialized = false;
+            if (viewports[i].glyphs)
+                free(viewports[i].glyphs);
+            if (viewports[i].bgpixel)
+                free(viewports[i].bgpixel);
+            if (viewports[i].backbuf)
+                free(viewports[i].backbuf);
+            retval = EOK;
             break;
         case FB_SET_STYLE:
-            vport->style.fg_color = IPC_GET_ARG1(call);
-            vport->style.bg_color = IPC_GET_ARG2(call);
-            retval = 0;
+            retval = fb_set_style(vport, IPC_GET_ARG1(call));
             break;
+        case FB_SET_COLOR:
+            retval = fb_set_color(vport, IPC_GET_ARG1(call),
+                IPC_GET_ARG2(call), IPC_GET_ARG3(call));
+            break;
+        case FB_SET_RGB_COLOR:
+            vport->attr.fg_color = IPC_GET_ARG1(call);
+            vport->attr.bg_color = IPC_GET_ARG2(call);
+            retval = EOK;
+            break;
         case FB_GET_RESOLUTION:
             ipc_answer_2(callid, EOK, screen.xres, screen.yres);
             continue;
         case FB_POINTER_MOVE:
-            pointer_enabled = 1;
+            pointer_enabled = true;
             mouse_move(IPC_GET_ARG1(call), IPC_GET_ARG2(call));
-            retval = 0;
+            retval = EOK;
             break;
         default:
             retval = ENOENT;
 ,41 → 1654,33
     }
 }
-/** Initialization of framebuffer */
-int
-fb_init(void)
+/** Initialization of framebuffer
+ *
+ */
+int fb_init(void)
 {
-    void *fb_ph_addr;
-    unsigned int fb_width;
-    unsigned int fb_height;
-    unsigned int fb_scanline;
-    unsigned int fb_visual;
-    bool fb_invert_colors;
-    void *fb_addr;
-    size_t asz;
     async_set_client_connection(fb_client_connection);
-    fb_ph_addr = (void *) sysinfo_value("fb.address.physical");
-    fb_width = sysinfo_value("fb.width");
-    fb_height = sysinfo_value("fb.height");
-    fb_scanline = sysinfo_value("fb.scanline");
-    fb_visual = sysinfo_value("fb.visual");
-    fb_invert_colors = sysinfo_value("fb.invert-colors");
-    asz = fb_scanline * fb_height;
-    fb_addr = as_get_mappable_page(asz);
-    physmem_map(fb_ph_addr, fb_addr, ALIGN_UP(asz, PAGE_SIZE) >>
-        PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
-    if (screen_init(fb_addr, fb_width, fb_height, fb_scanline, fb_visual,
-        fb_invert_colors))
+    void *fb_ph_addr = (void *) sysinfo_value("fb.address.physical");
+    unsigned int fb_offset = sysinfo_value("fb.offset");
+    unsigned int fb_width = sysinfo_value("fb.width");
+    unsigned int fb_height = sysinfo_value("fb.height");
+    unsigned int fb_scanline = sysinfo_value("fb.scanline");
+    unsigned int fb_visual = sysinfo_value("fb.visual");
+    unsigned int fbsize = fb_scanline * fb_height;
+    void *fb_addr = as_get_mappable_page(fbsize);
+    if (physmem_map(fb_ph_addr + fb_offset, fb_addr,
+        ALIGN_UP(fbsize, PAGE_SIZE) >> PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE) != 0)
+        return -1;
+    if (screen_init(fb_addr, fb_width, fb_height, fb_scanline, fb_visual))
         return 0;
     return -1;
 }
-/**
+/**
  * @}
  */

 /branches/dd/uspace/srv/fb/sgcn.c
 ,0 → 1,142
+/*
+ * Copyright (c) 2006 Ondrej Palkovsky
+ * Copyright (c) 2008 Martin Decky
+ * Copyright (c) 2008 Pavel Rimsky
+ * 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.
+ */
+/** @defgroup sgcnfb SGCN
+ * @brief   userland driver of the Serengeti console output
+ * @{
+ */
+/** @file
+ */
+#include <async.h>
+#include <sysinfo.h>
+#include <as.h>
+#include <errno.h>
+#include <stdio.h>
+#include <ddi.h>
+#include "serial_console.h"
+#include "sgcn.h"
+#define WIDTH 80
+#define HEIGHT 24
+/**
+ * Virtual address mapped to SRAM.
+ */
+static uintptr_t sram_virt_addr;
+/**
+ * SGCN buffer offset within SGCN.
+ */
+static uintptr_t sram_buffer_offset;
+/**
+ * SGCN buffer header. It is placed at the very beginning of the SGCN
+ * buffer.
+ */
+typedef struct {
+    /** hard-wired to "CON" */
+    char magic[4];
+    /** we don't need this */
+    char unused[24];
+    /** offset within the SGCN buffer of the output buffer start */
+    uint32_t out_begin;
+    /** offset within the SGCN buffer of the output buffer end */
+    uint32_t out_end;
+    /** offset within the SGCN buffer of the output buffer read pointer */
+    uint32_t out_rdptr;
+    /** offset within the SGCN buffer of the output buffer write pointer */
+    uint32_t out_wrptr;
+} __attribute__ ((packed)) sgcn_buffer_header_t;
+/*
+ * Returns a pointer to the object of a given type which is placed at the given
+ * offset from the console buffer beginning.
+ */
+#define SGCN_BUFFER(type, offset) \
+        ((type *) (sram_virt_addr + sram_buffer_offset + (offset)))
+/** Returns a pointer to the console buffer header. */
+#define SGCN_BUFFER_HEADER  (SGCN_BUFFER(sgcn_buffer_header_t, 0))
+/**
+ * Pushes the character to the SGCN serial.
+ * @param c character to be pushed
+ */
+static void sgcn_putc(char c)
+{
+    uint32_t begin = SGCN_BUFFER_HEADER->out_begin;
+    uint32_t end = SGCN_BUFFER_HEADER->out_end;
+    uint32_t size = end - begin;
+    /* we need pointers to volatile variables */
+    volatile char *buf_ptr = (volatile char *)
+        SGCN_BUFFER(char, SGCN_BUFFER_HEADER->out_wrptr);
+    volatile uint32_t *out_wrptr_ptr = &(SGCN_BUFFER_HEADER->out_wrptr);
+    volatile uint32_t *out_rdptr_ptr = &(SGCN_BUFFER_HEADER->out_rdptr);
+    uint32_t new_wrptr = (((*out_wrptr_ptr) - begin + 1) % size) + begin;
+    while (*out_rdptr_ptr == new_wrptr)
+        ;
+    *buf_ptr = c;
+    *out_wrptr_ptr = new_wrptr;
+}
+/**
+ * Initializes the SGCN serial driver.
+ */
+int sgcn_init(void)
+{
+    sram_virt_addr = (uintptr_t) as_get_mappable_page(sysinfo_value("sram.area.size"));
+    if (physmem_map((void *) sysinfo_value("sram.address.physical"),
+        (void *) sram_virt_addr, sysinfo_value("sram.area.size") / PAGE_SIZE,
+        AS_AREA_READ | AS_AREA_WRITE) != 0)
+        return -1;
+    serial_console_init(sgcn_putc, WIDTH, HEIGHT);
+    sram_buffer_offset = sysinfo_value("sram.buffer.offset");
+    async_set_client_connection(serial_client_connection);
+    return 0;
+}
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/fb/ski.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 skifb
+ * @brief   HelenOS ski text console.
+ * @ingroup fbs
+ * @{
+ */
+/** @file
+ */
+#ifndef FB_SKI_H_
+#define FB_SKI_H_
+extern int ski_init(void);
+#endif
+/** @}
+ */

 /branches/dd/uspace/srv/fb/ppm.c
 ,23 → 92,23
     int i;
     unsigned int color;
     unsigned int coef;
     /* Read magic */
-    if (data[0] != 'P' || data[1] != '6')
+    if ((data[0] != 'P') || (data[1] != '6'))
         return EINVAL;
-    data+=2;
+    data += 2;
     skip_whitespace(&data);
     read_num(&data, &width);
     skip_whitespace(&data);
-    read_num(&data,&height);
+    read_num(&data, &height);
     skip_whitespace(&data);
-    read_num(&data,&maxcolor);
+    read_num(&data, &maxcolor);
     data++;
-    if (maxcolor == 0 || maxcolor > 255 || width * height > datasz) {
+    if ((maxcolor == 0) || (maxcolor > 255) || (width * height > datasz))
         return EINVAL;
-    }
     coef = 255 / maxcolor;
     if (coef * maxcolor > 255)
         coef -= 1;
 ,6 → 125,6
         (*putpixel)(vport, sx + (i % width), sy + (i / width), color);
         data += 3;
     }
     return 0;
 }

 /branches/dd/uspace/srv/fb/fb.h
 ,7 → 29,7
 /** @addtogroup fb
  * @ingroup fbs
  * @{
- */
+ */
 /** @file
  */
 ,8 → 36,10
 #ifndef FB_FB_H_
 #define FB_FB_H_
-typedef void (* putpixel_cb_t)(void *, unsigned int, unsigned int, int);
+#include <stdint.h>
+typedef void (* putpixel_cb_t)(void *, unsigned int, unsigned int, uint32_t);
 extern int fb_init(void);
 #endif

 /branches/dd/uspace/srv/fb/ega.c
 ,6 → 49,9
 #include <ipc/ns.h>
 #include <ipc/services.h>
 #include <libarch/ddi.h>
+#include <console/style.h>
+#include <console/color.h>
+#include <sys/types.h>
 #include "ega.h"
 #include "../console/screenbuffer.h"
 ,13 → 64,14
 saved_screen saved_screens[MAX_SAVED_SCREENS];
-#define EGA_IO_ADDRESS 0x3d4
+#define EGA_IO_BASE ((ioport8_t *) 0x3d4)
 #define EGA_IO_SIZE 2
-#define NORMAL_COLOR       0x0f
-#define INVERTED_COLOR     0xf0
+int ega_normal_color = 0x0f;
+int ega_inverted_color = 0xf0;
-#define EGA_STYLE(fg,bg) ((fg) > (bg) ? NORMAL_COLOR : INVERTED_COLOR)
+#define NORMAL_COLOR        ega_normal_color
+#define INVERTED_COLOR      ega_inverted_color
 /* Allow only 1 connection */
 static int client_connected = 0;
 ,8 → 80,10
 static unsigned int scr_height;
 static char *scr_addr;
-static unsigned int style = NORMAL_COLOR;
+static unsigned int style;
+static unsigned attr_to_ega_style(const attrs_t *a);
 static void clrscr(void)
 {
     int i;
 ,10 → 100,10
     ega_cursor = col + scr_width * row;
-    outb(EGA_IO_ADDRESS, 0xe);
-    outb(EGA_IO_ADDRESS + 1, (ega_cursor >> 8) & 0xff);
-    outb(EGA_IO_ADDRESS, 0xf);
-    outb(EGA_IO_ADDRESS + 1, ega_cursor & 0xff);
+    pio_write_8(EGA_IO_BASE, 0xe);
+    pio_write_8(EGA_IO_BASE + 1, (ega_cursor >> 8) & 0xff);
+    pio_write_8(EGA_IO_BASE, 0xf);
+    pio_write_8(EGA_IO_BASE + 1, ega_cursor & 0xff);
 }
 static void cursor_disable(void)
 ,10 → 110,10
 {
     uint8_t stat;
-    outb(EGA_IO_ADDRESS, 0xa);
-    stat=inb(EGA_IO_ADDRESS + 1);
-    outb(EGA_IO_ADDRESS, 0xa);
-    outb(EGA_IO_ADDRESS + 1, stat | (1 << 5));
+    pio_write_8(EGA_IO_BASE, 0xa);
+    stat = pio_read_8(EGA_IO_BASE + 1);
+    pio_write_8(EGA_IO_BASE, 0xa);
+    pio_write_8(EGA_IO_BASE + 1, stat | (1 << 5));
 }
 static void cursor_enable(void)
 ,10 → 120,10
 {
     uint8_t stat;
-    outb(EGA_IO_ADDRESS, 0xa);
-    stat=inb(EGA_IO_ADDRESS + 1);
-    outb(EGA_IO_ADDRESS, 0xa);
-    outb(EGA_IO_ADDRESS + 1, stat & (~(1 << 5)));
+    pio_write_8(EGA_IO_BASE, 0xa);
+    stat = pio_read_8(EGA_IO_BASE + 1);
+    pio_write_8(EGA_IO_BASE, 0xa);
+    pio_write_8(EGA_IO_BASE + 1, stat & (~(1 << 5)));
 }
 static void scroll(int rows)
 ,13 → 130,13
 {
     int i;
     if (rows > 0) {
-        memcpy(scr_addr, ((char *) scr_addr) + rows * scr_width * 2,
+        memmove(scr_addr, ((char *) scr_addr) + rows * scr_width * 2,
             scr_width * scr_height * 2 - rows * scr_width * 2);
         for (i = 0; i < rows * scr_width; i++)
             (((short *) scr_addr) + scr_width * scr_height - rows *
                 scr_width)[i] = ((style << 8) + ' ');
     } else if (rows < 0) {
-        memcpy(((char *)scr_addr) - rows * scr_width * 2, scr_addr,
+        memmove(((char *)scr_addr) - rows * scr_width * 2, scr_addr,
             scr_width * scr_height * 2 + rows * scr_width * 2);
         for (i = 0; i < -rows * scr_width; i++)
             ((short *)scr_addr)[i] = ((style << 8 ) + ' ');
 ,8 → 157,7
     for (i = 0; i < scr_width * scr_height; i++) {
         scr_addr[i * 2] = data[i].character;
-        scr_addr[i * 2 + 1] = EGA_STYLE(data[i].style.fg_color,
-            data[i].style.bg_color);
+        scr_addr[i * 2 + 1] = attr_to_ega_style(&data[i].attrs);
     }
 }
 ,7 → 186,51
     return i;
 }
+static int style_to_ega_style(int style)
+{
+    unsigned int ega_style;
+    switch (style) {
+    case STYLE_NORMAL:
+        ega_style = INVERTED_COLOR;
+        break;
+    case STYLE_EMPHASIS:
+        ega_style = INVERTED_COLOR | 4;
+        break;
+    default:
+        return INVERTED_COLOR;
+    }
+    return ega_style;
+}
+static unsigned int color_to_ega_style(int fg_color, int bg_color, int attr)
+{
+    unsigned int style;
+    style = (fg_color & 7) | ((bg_color & 7) << 4);
+    if (attr & CATTR_BRIGHT)
+        style = style | 0x08;
+    return style;
+}
+static unsigned int rgb_to_ega_style(uint32_t fg, uint32_t bg)
+{
+    return (fg > bg) ? NORMAL_COLOR : INVERTED_COLOR;
+}
+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;
+    }
+}
 static void ega_client_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
     int retval;
 ,7 → 238,8
     ipc_call_t call;
     char c;
     unsigned int row, col;
-    int bgcolor,fgcolor;
+    int bg_color, fg_color, attr;
+    uint32_t bg_rgb, fg_rgb;
     keyfield_t *interbuf = NULL;
     size_t intersize = 0;
     int i;
 ,7 → 315,7
             retval = 0;
             break;
         case FB_CURSOR_VISIBILITY:
-            if(IPC_GET_ARG1(call))
+            if (IPC_GET_ARG1(call))
                 cursor_enable();
             else
                 cursor_disable();
 ,11 → 322,22
             retval = 0;
             break;
         case FB_SET_STYLE:
-            fgcolor = IPC_GET_ARG1(call);
-            bgcolor = IPC_GET_ARG2(call);
-            style = EGA_STYLE(fgcolor, bgcolor);
+            style = style_to_ega_style(IPC_GET_ARG1(call));
             retval = 0;
             break;
+        case FB_SET_COLOR:
+            fg_color = IPC_GET_ARG1(call);
+            bg_color = IPC_GET_ARG2(call);
+            attr = IPC_GET_ARG3(call);
+            style = color_to_ega_style(fg_color, bg_color, attr);
+            retval = 0;
+            break;
+        case FB_SET_RGB_COLOR:
+            fg_rgb = IPC_GET_ARG1(call);
+            bg_rgb = IPC_GET_ARG2(call);
+            style = rgb_to_ega_style(fg_rgb, bg_rgb);
+            retval = 0;
+            break;
         case FB_VP_DRAW_PIXMAP:
             i = IPC_GET_ARG2(call);
             retval = print_screen(i);
 ,13 → 373,22
     ega_ph_addr = (void *) sysinfo_value("fb.address.physical");
     scr_width = sysinfo_value("fb.width");
     scr_height = sysinfo_value("fb.height");
-    iospace_enable(task_get_id(), (void *) EGA_IO_ADDRESS, 2);
+    if (sysinfo_value("fb.blinking")) {
+        ega_normal_color &= 0x77;
+        ega_inverted_color &= 0x77;
+    }
+    style = NORMAL_COLOR;
+    iospace_enable(task_get_id(), (void *) EGA_IO_BASE, 2);
     sz = scr_width * scr_height * 2;
     scr_addr = as_get_mappable_page(sz);
-    physmem_map(ega_ph_addr, scr_addr, ALIGN_UP(sz, PAGE_SIZE) >>
-        PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
+    if (physmem_map(ega_ph_addr, scr_addr, ALIGN_UP(sz, PAGE_SIZE) >>
+        PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE) != 0)
+        return -1;
     async_set_client_connection(ega_client_connection);
 ,6 → 396,6
 }
-/**
+/**
  * @}
  */

 /branches/dd/uspace/srv/fb/Makefile
 ,6 → 31,7
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 CFLAGS += -I../libipc/include
 ,50 → 44,69
 OUTPUT = fb
 SOURCES = \
     main.c \
-    sysio.c \
     ppm.c
-ifneq ($(ARCH), ia64)
+ifneq ($(UARCH),ia64)
     SOURCES += fb.c \
         font-8x16.c
     CFLAGS += -DFB_ENABLED
 endif
-ifeq ($(ARCH), ia32)
+ifeq ($(UARCH),ia32)
     SOURCES += ega.c
     CFLAGS += -DEGA_ENABLED
 endif
-ifeq ($(ARCH), amd64)
+ifeq ($(UARCH),ia64)
+    SOURCES += ega.c \
+        ski.c \
+        serial_console.c
+    CFLAGS += -DSKI_ENABLED
+    CFLAGS += -DEGA_ENABLED
+endif
+ifeq ($(UARCH),amd64)
     SOURCES += ega.c
     CFLAGS += -DEGA_ENABLED
 endif
-ifeq ($(ARCH), mips32)
-    CFLAGS += -DFB_INVERT_ENDIAN
+ifeq ($(UARCH),mips32)
+    SOURCES += msim.c \
+        serial_console.c
+    CFLAGS += -DMSIM_ENABLED
 endif
-CFLAGS += -D$(ARCH)
+ifeq ($(UARCH),sparc64)
+    SOURCES += sgcn.c \
+        serial_console.c
+    CFLAGS += -DSGCN_ENABLED
+endif
+CFLAGS += -D$(UARCH)
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
 .PHONY: all clean depend disasm
-all: $(OUTPUT) disasm
+all: $(OUTPUT) $(OUTPUT).disasm
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -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/$(ARCH)/_link.ld -e __entry_driver $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm:
-    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/dd/uspace/srv/fs/tmpfs/tmpfs.h
 ,8 → 40,16
 #include <bool.h>
 #include <libadt/hash_table.h>
+#ifndef dprintf
 #define dprintf(...)    printf(__VA_ARGS__)
+#endif
+typedef enum {
+    TMPFS_NONE,
+    TMPFS_FILE,
+    TMPFS_DIRECTORY
+} tmpfs_dentry_type_t;
 typedef struct tmpfs_dentry {
     fs_index_t index;   /**< TMPFS node index. */
     link_t dh_link;     /**< Dentries hash table link. */
 ,11 → 56,7
     struct tmpfs_dentry *sibling;
     struct tmpfs_dentry *child;
     hash_table_t names; /**< All names linking to this TMPFS node. */
-    enum {
-        TMPFS_NONE,
-        TMPFS_FILE,
-        TMPFS_DIRECTORY
-    } type;
+    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. */
 ,6 → 64,9
 extern fs_reg_t tmpfs_reg;
+extern libfs_ops_t tmpfs_libfs_ops;
+extern void tmpfs_mounted(ipc_callid_t, ipc_call_t *);
 extern void tmpfs_mount(ipc_callid_t, ipc_call_t *);
 extern void tmpfs_lookup(ipc_callid_t, ipc_call_t *);
 extern void tmpfs_read(ipc_callid_t, ipc_call_t *);
 ,6 → 74,8
 extern void tmpfs_truncate(ipc_callid_t, ipc_call_t *);
 extern void tmpfs_destroy(ipc_callid_t, ipc_call_t *);
+extern bool tmpfs_restore(dev_handle_t);
 #endif
 /**

 /branches/dd/uspace/srv/fs/tmpfs/tmpfs_dump.c
 ,0 → 1,197
+/*
+ * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2008 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    tmpfs_dump.c
+ * @brief   Support for loading TMPFS file system dump.
+ */
+#include "tmpfs.h"
+#include "../../vfs/vfs.h"
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <as.h>
+#include <libblock.h>
+#include <byteorder.h>
+#define TMPFS_BLOCK_SIZE    1024
+struct rdentry {
+    uint8_t type;
+    uint32_t len;
+} __attribute__((packed));
+static bool
+tmpfs_restore_recursion(int dev, off_t *bufpos, size_t *buflen, off_t *pos,
+    tmpfs_dentry_t *parent)
+{
+    struct rdentry entry;
+    libfs_ops_t *ops = &tmpfs_libfs_ops;
+    int rc;
+    do {
+        char *fname;
+        tmpfs_dentry_t *node;
+        uint32_t size;
+        if (block_read(dev, bufpos, buflen, pos, &entry, sizeof(entry),
+            TMPFS_BLOCK_SIZE) != EOK)
+            return false;
+        entry.len = uint32_t_le2host(entry.len);
+        switch (entry.type) {
+        case TMPFS_NONE:
+            break;
+        case TMPFS_FILE:
+            fname = malloc(entry.len + 1);
+            if (fname == NULL)
+                return false;
+            node = (tmpfs_dentry_t *) ops->create(dev, L_FILE);
+            if (node == NULL) {
+                free(fname);
+                return false;
+            }
+            if (block_read(dev, bufpos, buflen, pos, fname,
+                entry.len, TMPFS_BLOCK_SIZE) != EOK) {
+                ops->destroy((void *) node);
+                free(fname);
+                return false;
+            }
+            fname[entry.len] = 0;
+            rc = ops->link((void *) parent, (void *) node, fname);
+            if (rc != EOK) {
+                ops->destroy((void *) node);
+                free(fname);
+                return false;
+            }
+            free(fname);
+            if (block_read(dev, bufpos, buflen, pos, &size,
+                sizeof(size), TMPFS_BLOCK_SIZE) != EOK)
+                return false;
+            size = uint32_t_le2host(size);
+            node->data = malloc(size);
+            if (node->data == NULL)
+                return false;
+            node->size = size;
+            if (block_read(dev, bufpos, buflen, pos, node->data,
+                size, TMPFS_BLOCK_SIZE) != EOK)
+                return false;
+            break;
+        case TMPFS_DIRECTORY:
+            fname = malloc(entry.len + 1);
+            if (fname == NULL)
+                return false;
+            node = (tmpfs_dentry_t *) ops->create(dev, L_DIRECTORY);
+            if (node == NULL) {
+                free(fname);
+                return false;
+            }
+            if (block_read(dev, bufpos, buflen, pos, fname,
+                entry.len, TMPFS_BLOCK_SIZE) != EOK) {
+                ops->destroy((void *) node);
+                free(fname);
+                return false;
+            }
+            fname[entry.len] = 0;
+            rc = ops->link((void *) parent, (void *) node, fname);
+            if (rc != EOK) {
+                ops->destroy((void *) node);
+                free(fname);
+                return false;
+            }
+            free(fname);
+            if (!tmpfs_restore_recursion(dev, bufpos, buflen, pos,
+                node))
+                return false;
+            break;
+        default:
+            return false;
+        }
+    } while (entry.type != TMPFS_NONE);
+    return true;
+}
+bool tmpfs_restore(dev_handle_t dev)
+{
+    libfs_ops_t *ops = &tmpfs_libfs_ops;
+    int rc;
+    rc = block_init(dev, TMPFS_BLOCK_SIZE);
+    if (rc != EOK)
+        return false;
+    off_t bufpos = 0;
+    size_t buflen = 0;
+    off_t pos = 0;
+    char tag[6];
+    if (block_read(dev, &bufpos, &buflen, &pos, tag, 5,
+        TMPFS_BLOCK_SIZE) != EOK)
+        goto error;
+    tag[5] = 0;
+    if (strcmp(tag, "TMPFS") != 0)
+        goto error;
+    if (!tmpfs_restore_recursion(dev, &bufpos, &buflen, &pos,
+        ops->root_get(dev)))
+        goto error;
+    block_fini(dev);
+    return true;
+error:
+    block_fini(dev);
+    return false;
+}
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/fs/tmpfs/tmpfs.c
 ,18 → 50,11
 #include <libfs.h>
 #include "../../vfs/vfs.h"
+#define NAME "tmpfs"
 vfs_info_t tmpfs_vfs_info = {
     .name = "tmpfs",
-    .ops = {
-        [IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_READ)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_WRITE)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_TRUNCATE)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] = VFS_OP_NULL,
-        [IPC_METHOD_TO_VFS_OP(VFS_DESTROY)] = VFS_OP_DEFINED,
-    }
 };
 fs_reg_t tmpfs_reg;
 ,6 → 96,9
         callid = async_get_call(&call);
         switch  (IPC_GET_METHOD(call)) {
+        case VFS_MOUNTED:
+            tmpfs_mounted(callid, &call);
+            break;
         case VFS_MOUNT:
             tmpfs_mount(callid, &call);
             break;
 ,27 → 126,22
 int main(int argc, char **argv)
 {
-    int vfs_phone;
-    printf("TMPFS: HelenOS TMPFS file system server.\n");
-    vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
-    while (vfs_phone < EOK) {
-        usleep(10000);
-        vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
+    printf(NAME ": HelenOS TMPFS file system server\n");
+    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;
-    rc = fs_register(vfs_phone, &tmpfs_reg, &tmpfs_vfs_info,
+    int rc = fs_register(vfs_phone, &tmpfs_reg, &tmpfs_vfs_info,
         tmpfs_connection);
     if (rc != EOK) {
-        printf("Failed to register the TMPFS file system (%d)\n", rc);
+        printf(NAME ": Failed to register file system (%d)\n", rc);
         return rc;
     }
-    dprintf("TMPFS filesystem registered, fs_handle=%d.\n",
-        tmpfs_reg.fs_handle);
+    printf(NAME ": Accepting connections\n");
     async_manager();
     /* not reached */
     return 0;

 /branches/dd/uspace/srv/fs/tmpfs/tmpfs_ops.c
 ,6 → 64,8
  */
 static tmpfs_dentry_t *root;
+#define TMPFS_DEV       0    /**< Dummy device handle for TMPFS */
 /*
  * Implementation of the libfs interface.
  */
 ,8 → 74,8
 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(int);
-static bool tmpfs_link_node(void *, void *, const char *);
+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 *);
 ,12 → 230,12
 {
     if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops))
         return false;
-    root = (tmpfs_dentry_t *) tmpfs_create_node(L_DIRECTORY);
+    root = (tmpfs_dentry_t *) tmpfs_create_node(TMPFS_DEV, L_DIRECTORY);
     if (!root) {
         hash_table_destroy(&dentries);
         return false;
     }
-    root->lnkcnt = 1;
+    root->lnkcnt = 0;   /* FS root is not linked */
     return true;
 }
 ,7 → 284,7
     /* nothing to do */
 }
-void *tmpfs_create_node(int lflag)
+void *tmpfs_create_node(dev_handle_t dev_handle, int lflag)
 {
     assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
 ,7 → 308,7
     return (void *) node;
 }
-bool tmpfs_link_node(void *prnt, void *chld, const char *nm)
+int tmpfs_link_node(void *prnt, void *chld, const char *nm)
 {
     tmpfs_dentry_t *parentp = (tmpfs_dentry_t *) prnt;
     tmpfs_dentry_t *childp = (tmpfs_dentry_t *) chld;
 ,13 → 317,13
     tmpfs_name_t *namep = malloc(sizeof(tmpfs_name_t));
     if (!namep)
-        return false;
+        return ENOMEM;
     tmpfs_name_initialize(namep);
     size_t len = strlen(nm);
     namep->name = malloc(len + 1);
     if (!namep->name) {
         free(namep);
-        return false;
+        return ENOMEM;
     }
     strcpy(namep->name, nm);
     namep->parent = parentp;
 ,7 → 343,7
         parentp->child = childp;
     }
-    return true;
+    return EOK;
 }
 int tmpfs_unlink_node(void *prnt, void *chld)
 ,28 → 395,39
     return EOK;
 }
-void tmpfs_mount(ipc_callid_t rid, ipc_call_t *request)
+void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request)
 {
-    dev_handle_t mr_dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
-    fs_index_t mr_index = (fs_index_t)IPC_GET_ARG2(*request);
-    fs_handle_t mp_fs_handle = (fs_handle_t)IPC_GET_ARG3(*request);
-    dev_handle_t mp_dev_handle = (dev_handle_t)IPC_GET_ARG4(*request);
-    fs_index_t mp_index = (fs_index_t)IPC_GET_ARG5(*request);
-    if ((mr_index == root->index) &&
-        (mp_fs_handle == tmpfs_reg.fs_handle) &&
-        (mp_index == mr_index))
-        ipc_answer_0(rid, EOK);
-    else
-        ipc_answer_0(rid, ENOTSUP);
-}
+    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
-void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)
-{
     /* Initialize TMPFS. */
     if (!root && !tmpfs_init()) {
         ipc_answer_0(rid, ENOMEM);
         return;
     }
+    if (dev_handle >= 0) {
+        if (tmpfs_restore(dev_handle))
+            ipc_answer_3(rid, EOK, root->index, root->size,
+                root->lnkcnt);
+        else
+            ipc_answer_0(rid, ELIMIT);
+    } else {
+        ipc_answer_3(rid, EOK, root->index, root->size, root->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);
+}
+void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)
+{
     libfs_lookup(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
 }

 /branches/dd/uspace/srv/fs/tmpfs/Makefile
 ,12 → 31,17
 LIBC_PREFIX = ../../../lib/libc
 LIBFS_PREFIX = ../../../lib/libfs
+LIBBLOCK_PREFIX = ../../../lib/libblock
 SOFTINT_PREFIX = ../../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS += -I $(LIBFS_PREFIX)
+CFLAGS += -I $(LIBFS_PREFIX) -I $(LIBBLOCK_PREFIX)
-LIBS = $(LIBC_PREFIX)/libc.a $(LIBFS_PREFIX)/libfs.a
+LIBS = \
+    $(LIBFS_PREFIX)/libfs.a \
+    $(LIBBLOCK_PREFIX)/libblock.a \
+    $(LIBC_PREFIX)/libc.a
 ## Sources
 #
 ,28 → 49,31
 OUTPUT = tmpfs
 SOURCES = \
     tmpfs.c \
-    tmpfs_ops.c
+    tmpfs_ops.c \
+    tmpfs_dump.c
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
 .PHONY: all clean depend disasm
-all: $(OUTPUT) disasm
+all: $(OUTPUT) $(OUTPUT).disasm
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -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/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm:
-    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/dd/uspace/srv/fs/fat/fat_idx.c
 ,6 → 74,32
 /** List of unused structures. */
 static LIST_INITIALIZE(unused_head);
+static void unused_initialize(unused_t *u, dev_handle_t dev_handle)
+{
+    link_initialize(&u->link);
+    u->dev_handle = dev_handle;
+    u->next = 0;
+    u->remaining = ((uint64_t)((fs_index_t)-1)) + 1;
+    list_initialize(&u->freed_head);
+}
+static unused_t *unused_find(dev_handle_t dev_handle, bool lock)
+{
+    unused_t *u;
+    link_t *l;
+    if (lock)
+        futex_down(&unused_futex);
+    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)
+            return u;
+    }
+    if (lock)
+        futex_up(&unused_futex);
+    return NULL;
+}
 /** Futex protecting the up_hash and ui_hash. */
 static futex_t used_futex = FUTEX_INITIALIZER;
 ,24 → 214,15
 };
 /** Allocate a VFS index which is not currently in use. */
-static bool fat_idx_alloc(dev_handle_t dev_handle, fs_index_t *index)
+static bool fat_index_alloc(dev_handle_t dev_handle, fs_index_t *index)
 {
-    link_t *l;
     unused_t *u;
     assert(index);
-    futex_down(&unused_futex);
-    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)
-            goto hit;
-    }
-    futex_up(&unused_futex);
-    /* dev_handle not found */
-    return false;
+    u = unused_find(dev_handle, true);
+    if (!u)
+        return false;
-hit:
     if (list_empty(&u->freed_head)) {
         if (u->remaining) {
             /*
 ,23 → 276,13
 }
 /** Free a VFS index, which is no longer in use. */
-static void fat_idx_free(dev_handle_t dev_handle, fs_index_t index)
+static void fat_index_free(dev_handle_t dev_handle, fs_index_t index)
 {
-    link_t *l;
     unused_t *u;
-    futex_down(&unused_futex);
-    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)
-            goto hit;
-    }
-    futex_up(&unused_futex);
+    u = unused_find(dev_handle, true);
+    assert(u);
-    /* should not happen */
-    assert(0);
-hit:
     if (u->next == index + 1) {
         /* The index can be returned directly to the counter. */
         u->next--;
 ,6 → 338,52
     futex_up(&unused_futex);
 }
+static fat_idx_t *fat_idx_create(dev_handle_t dev_handle)
+{
+    fat_idx_t *fidx;
+    fidx = (fat_idx_t *) malloc(sizeof(fat_idx_t));
+    if (!fidx)
+        return NULL;
+    if (!fat_index_alloc(dev_handle, &fidx->index)) {
+        free(fidx);
+        return NULL;
+    }
+    link_initialize(&fidx->uph_link);
+    link_initialize(&fidx->uih_link);
+    futex_initialize(&fidx->lock, 1);
+    fidx->dev_handle = dev_handle;
+    fidx->pfc = FAT_CLST_RES0;  /* no parent yet */
+    fidx->pdi = 0;
+    fidx->nodep = NULL;
+    return fidx;
+}
+fat_idx_t *fat_idx_get_new(dev_handle_t dev_handle)
+{
+    fat_idx_t *fidx;
+    futex_down(&used_futex);
+    fidx = fat_idx_create(dev_handle);
+    if (!fidx) {
+        futex_up(&used_futex);
+        return NULL;
+    }
+    unsigned long ikey[] = {
+        [UIH_DH_KEY] = dev_handle,
+        [UIH_INDEX_KEY] = fidx->index,
+    };
+    hash_table_insert(&ui_hash, ikey, &fidx->uih_link);
+    futex_down(&fidx->lock);
+    futex_up(&used_futex);
+    return fidx;
+}
 fat_idx_t *
 fat_idx_get_by_pos(dev_handle_t dev_handle, fat_cluster_t pfc, unsigned pdi)
 {
 ,16 → 400,11
     if (l) {
         fidx = hash_table_get_instance(l, fat_idx_t, uph_link);
     } else {
-        fidx = (fat_idx_t *) malloc(sizeof(fat_idx_t));
+        fidx = fat_idx_create(dev_handle);
         if (!fidx) {
             futex_up(&used_futex);
             return NULL;
         }
-        if (!fat_idx_alloc(dev_handle, &fidx->index)) {
-            free(fidx);
-            futex_up(&used_futex);
-            return NULL;
-        }
         unsigned long ikey[] = {
             [UIH_DH_KEY] = dev_handle,
 ,13 → 411,8
             [UIH_INDEX_KEY] = fidx->index,
         };
-        link_initialize(&fidx->uph_link);
-        link_initialize(&fidx->uih_link);
-        futex_initialize(&fidx->lock, 1);
-        fidx->dev_handle = dev_handle;
         fidx->pfc = pfc;
         fidx->pdi = pdi;
-        fidx->nodep = NULL;
         hash_table_insert(&up_hash, pkey, &fidx->uph_link);
         hash_table_insert(&ui_hash, ikey, &fidx->uih_link);
 ,6 → 423,32
     return fidx;
 }
+void fat_idx_hashin(fat_idx_t *idx)
+{
+    unsigned long pkey[] = {
+        [UPH_DH_KEY] = idx->dev_handle,
+        [UPH_PFC_KEY] = idx->pfc,
+        [UPH_PDI_KEY] = idx->pdi,
+    };
+    futex_down(&used_futex);
+    hash_table_insert(&up_hash, pkey, &idx->uph_link);
+    futex_up(&used_futex);
+}
+void fat_idx_hashout(fat_idx_t *idx)
+{
+    unsigned long pkey[] = {
+        [UPH_DH_KEY] = idx->dev_handle,
+        [UPH_PFC_KEY] = idx->pfc,
+        [UPH_PDI_KEY] = idx->pdi,
+    };
+    futex_down(&used_futex);
+    hash_table_remove(&up_hash, pkey, 3);
+    futex_up(&used_futex);
+}
 fat_idx_t *
 fat_idx_get_by_index(dev_handle_t dev_handle, fs_index_t index)
 {
 ,3 → 470,87
     return fidx;
 }
+/** Destroy the index structure.
+ *
+ * @param idx       The index structure to be destroyed.
+ */
+void fat_idx_destroy(fat_idx_t *idx)
+{
+    unsigned long ikey[] = {
+        [UIH_DH_KEY] = idx->dev_handle,
+        [UIH_INDEX_KEY] = idx->index,
+    };
+    assert(idx->pfc == FAT_CLST_RES0);
+    futex_down(&used_futex);
+    /*
+     * Since we can only free unlinked nodes, the index structure is not
+     * present in the position hash (uph). We therefore hash it out from
+     * the index hash only.
+     */
+    hash_table_remove(&ui_hash, ikey, 2);
+    futex_up(&used_futex);
+    /* Release the VFS index. */
+    fat_index_free(idx->dev_handle, idx->index);
+    /* Deallocate the structure. */
+    free(idx);
+}
+int fat_idx_init(void)
+{
+    if (!hash_table_create(&up_hash, UPH_BUCKETS, 3, &uph_ops))
+        return ENOMEM;
+    if (!hash_table_create(&ui_hash, UIH_BUCKETS, 2, &uih_ops)) {
+        hash_table_destroy(&up_hash);
+        return ENOMEM;
+    }
+    return EOK;
+}
+void fat_idx_fini(void)
+{
+    /* We assume the hash tables are empty. */
+    hash_table_destroy(&up_hash);
+    hash_table_destroy(&ui_hash);
+}
+int fat_idx_init_by_dev_handle(dev_handle_t dev_handle)
+{
+    unused_t *u;
+    int rc = EOK;
+    u = (unused_t *) malloc(sizeof(unused_t));
+    if (!u)
+        return ENOMEM;
+    unused_initialize(u, dev_handle);
+    futex_down(&unused_futex);
+    if (!unused_find(dev_handle, false))
+        list_append(&u->link, &unused_head);
+    else
+        rc = EEXIST;
+    futex_up(&unused_futex);
+    return rc;
+}
+void fat_idx_fini_by_dev_handle(dev_handle_t dev_handle)
+{
+    unused_t *u;
+    u = unused_find(dev_handle, true);
+    assert(u);
+    list_remove(&u->link);
+    futex_up(&unused_futex);
+    while (!list_empty(&u->freed_head)) {
+        freed_t *f;
+        f = list_get_instance(u->freed_head.next, freed_t, link);
+        list_remove(&f->link);
+        free(f);
+    }
+    free(u);
+}
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/fs/fat/fat.h
 ,6 → 33,7
 #ifndef FAT_FAT_H_
 #define FAT_FAT_H_
+#include "fat_fat.h"
 #include <ipc/ipc.h>
 #include <libfs.h>
 #include <atomic.h>
 ,9 → 41,16
 #include <bool.h>
 #include "../../vfs/vfs.h"
+#ifndef dprintf
 #define dprintf(...)    printf(__VA_ARGS__)
+#endif
-typedef struct {
+#define min(a, b)       ((a) < (b) ? (a) : (b))
+#define BS_BLOCK        0
+#define BS_SIZE         512
+typedef struct fat_bs {
     uint8_t     ji[3];      /**< Jump instruction. */
     uint8_t     oem_name[8];
     /* BIOS Parameter Block */
 ,34 → 121,6
     };
 } __attribute__ ((packed)) fat_bs_t;
-#define FAT_ATTR_RDONLY     (1 << 0)
-#define FAT_ATTR_VOLLABEL   (1 << 3)
-#define FAT_ATTR_SUBDIR     (1 << 4)
-typedef struct {
-    uint8_t     name[8];
-    uint8_t     ext[3];
-    uint8_t     attr;
-    uint8_t     reserved;
-    uint8_t     ctime_fine;
-    uint16_t    ctime;
-    uint16_t    cdate;
-    uint16_t    adate;
-    union {
-        uint16_t    eaidx;      /* FAT12/FAT16 */
-        uint16_t    firstc_hi;  /* FAT32 */
-    };
-    uint16_t    mtime;
-    uint16_t    mdate;
-    union {
-        uint16_t    firstc;     /* FAT12/FAT16 */
-        uint16_t    firstc_lo;  /* FAT32 */
-    };
-    uint32_t    size;
-} __attribute__ ((packed)) fat_dentry_t;
-typedef uint16_t fat_cluster_t;
 typedef enum {
     FAT_INVALID,
     FAT_DIRECTORY,
 ,11 → 197,26
 extern fs_reg_t fat_reg;
+extern void fat_mounted(ipc_callid_t, ipc_call_t *);
+extern void fat_mount(ipc_callid_t, ipc_call_t *);
 extern void fat_lookup(ipc_callid_t, ipc_call_t *);
+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_destroy(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);
 extern fat_idx_t *fat_idx_get_by_index(dev_handle_t, fs_index_t);
+extern void fat_idx_destroy(fat_idx_t *);
+extern void fat_idx_hashin(fat_idx_t *);
+extern void fat_idx_hashout(fat_idx_t *);
+extern int fat_idx_init(void);
+extern void fat_idx_fini(void);
+extern int fat_idx_init_by_dev_handle(dev_handle_t);
+extern void fat_idx_fini_by_dev_handle(dev_handle_t);
 #endif
 /**

 /branches/dd/uspace/srv/fs/fat/fat_dentry.c
 ,0 → 1,204
+/*
+ * 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 fs
+ * @{
+ */
+/**
+ * @file    fat_dentry.c
+ * @brief   Functions that work with FAT directory entries.
+ */
+#include "fat_dentry.h"
+#include <ctype.h>
+#include <string.h>
+static bool is_d_char(const char ch)
+{
+    if (isalnum(ch) || ch == '_')
+        return true;
+    else
+        return false;
+}
+/** Compare path component with the name read from the dentry.
+ *
+ * This function compares the path component with the name read from the dentry.
+ * The comparison is case insensitive and tolerates a mismatch on the trailing
+ * dot character at the end of the name (i.e. when there is a dot, but no
+ * extension).
+ *
+ * @param name      Node name read from the dentry.
+ * @param component Path component.
+ *
+ * @return      Zero on match, non-zero otherwise.
+ */
+int fat_dentry_namecmp(char *name, const char *component)
+{
+    int rc;
+    if (!(rc = stricmp(name, component)))
+        return rc;
+    if (!strchr(name, '.')) {
+        /*
+         * There is no '.' in the name, so we know that there is enough
+         * space for appending an extra '.' to name.
+         */
+        name[strlen(name)] = '.';
+        name[strlen(name) + 1] = '\0';
+        rc = stricmp(name, component);
+    }
+    return rc;
+}
+bool fat_dentry_name_verify(const char *name)
+{
+    unsigned i, dot;
+    bool dot_found = false;
+    for (i = 0; name[i]; i++) {
+        if (name[i] == '.') {
+            if (dot_found) {
+                return false;
+            } else {
+                dot_found = true;
+                dot = i;
+            }
+        } else {
+            if (!is_d_char(name[i]))
+                return false;
+        }
+    }
+    if (dot_found) {
+        if (dot > FAT_NAME_LEN)
+            return false;
+        if (i - dot > FAT_EXT_LEN + 1)
+            return false;
+    } else {
+        if (i > FAT_NAME_LEN)
+            return false;
+    }
+    return true;
+}
+void fat_dentry_name_get(const fat_dentry_t *d, char *buf)
+{
+    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];
+    }
+    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];
+    }
+    *buf = '\0';
+}
+void fat_dentry_name_set(fat_dentry_t *d, const char *name)
+{
+    int i;
+    const char fake_ext[] = "   ";
+    for (i = 0; i < FAT_NAME_LEN; i++) {
+        switch ((uint8_t) *name) {
+        case 0xe5:
+            d->name[i] = FAT_DENTRY_E5_ESC;
+            name++;
+            break;
+        case '\0':
+        case '.':
+            d->name[i] = FAT_PAD;
+            break;
+        default:
+            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:
+            d->ext[i] = FAT_DENTRY_E5_ESC;
+            name++;
+            break;
+        case '\0':
+            d->ext[i] = FAT_PAD;
+            break;
+        default:
+            d->ext[i] = toupper(*name++);
+            break;
+        }
+    }
+}
+fat_dentry_clsf_t fat_classify_dentry(const fat_dentry_t *d)
+{
+    if (d->attr & FAT_ATTR_VOLLABEL) {
+        /* volume label entry */
+        return FAT_DENTRY_SKIP;
+    }
+    if (d->name[0] == FAT_DENTRY_ERASED) {
+        /* not-currently-used entry */
+        return FAT_DENTRY_FREE;
+    }
+    if (d->name[0] == FAT_DENTRY_UNUSED) {
+        /* never used entry */
+        return FAT_DENTRY_LAST;
+    }
+    if (d->name[0] == FAT_DENTRY_DOT) {
+        /*
+         * Most likely '.' or '..'.
+         * It cannot occur in a regular file name.
+         */
+        return FAT_DENTRY_SKIP;
+    }
+    return FAT_DENTRY_VALID;
+}
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/fs/fat/fat_dentry.h
 ,0 → 1,96
+/*
+ * 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 fs
+ * @{
+ */
+#ifndef FAT_FAT_DENTRY_H_
+#define FAT_FAT_DENTRY_H_
+#include <stdint.h>
+#include <bool.h>
+#define FAT_NAME_LEN        8
+#define FAT_EXT_LEN     3
+#define FAT_NAME_DOT        ".       "
+#define FAT_NAME_DOT_DOT    "..      "
+#define FAT_EXT_PAD     "   "
+#define FAT_ATTR_RDONLY     (1 << 0)
+#define FAT_ATTR_VOLLABEL   (1 << 3)
+#define FAT_ATTR_SUBDIR     (1 << 4)
+#define FAT_PAD         ' '
+#define FAT_DENTRY_UNUSED   0x00
+#define FAT_DENTRY_E5_ESC   0x05
+#define FAT_DENTRY_DOT      0x2e
+#define FAT_DENTRY_ERASED   0xe5
+typedef enum {
+    FAT_DENTRY_SKIP,
+    FAT_DENTRY_LAST,
+    FAT_DENTRY_FREE,
+    FAT_DENTRY_VALID
+} fat_dentry_clsf_t;
+typedef struct {
+    uint8_t     name[8];
+    uint8_t     ext[3];
+    uint8_t     attr;
+    uint8_t     reserved;
+    uint8_t     ctime_fine;
+    uint16_t    ctime;
+    uint16_t    cdate;
+    uint16_t    adate;
+    union {
+        uint16_t    eaidx;      /* FAT12/FAT16 */
+        uint16_t    firstc_hi;  /* FAT32 */
+    } __attribute__ ((packed));
+    uint16_t    mtime;
+    uint16_t    mdate;
+    union {
+        uint16_t    firstc;     /* FAT12/FAT16 */
+        uint16_t    firstc_lo;  /* FAT32 */
+    } __attribute__ ((packed));
+    uint32_t    size;
+} __attribute__ ((packed)) fat_dentry_t;
+extern int fat_dentry_namecmp(char *, const char *);
+extern bool fat_dentry_name_verify(const char *);
+extern void fat_dentry_name_get(const fat_dentry_t *, char *);
+extern void fat_dentry_name_set(fat_dentry_t *, const char *);
+extern fat_dentry_clsf_t fat_classify_dentry(const fat_dentry_t *);
+#endif
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/fs/fat/fat_fat.c
 ,0 → 1,454
+/*
+ * 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 fs
+ * @{
+ */
+/**
+ * @file    fat_fat.c
+ * @brief   Functions that manipulate the File Allocation Tables.
+ */
+#include "fat_fat.h"
+#include "fat_dentry.h"
+#include "fat.h"
+#include "../../vfs/vfs.h"
+#include <libfs.h>
+#include <libblock.h>
+#include <errno.h>
+#include <byteorder.h>
+#include <align.h>
+#include <assert.h>
+#include <futex.h>
+/**
+ * The fat_alloc_lock futex 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;
+/** Walk the cluster chain.
+ *
+ * @param bs        Buffer holding the boot sector for the file.
+ * @param dev_handle    Device handle of the device with the file.
+ * @param firstc    First cluster to start the walk with.
+ * @param lastc     If non-NULL, output argument hodling the last cluster number visited.
+ * @param max_clusters  Maximum number of clusters to visit.
+ *
+ * @return      Number of clusters seen during the walk.
+ */
+uint16_t
+fat_cluster_walk(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc,
+    fat_cluster_t *lastc, uint16_t max_clusters)
+{
+    block_t *b;
+    unsigned bps;
+    unsigned rscnt;     /* block address of the first FAT */
+    uint16_t clusters = 0;
+    fat_cluster_t clst = firstc;
+    bps = uint16_t_le2host(bs->bps);
+    rscnt = uint16_t_le2host(bs->rscnt);
+    if (firstc == FAT_CLST_RES0) {
+        /* No space allocated to the file. */
+        if (lastc)
+            *lastc = firstc;
+        return 0;
+    }
+    while (clst < FAT_CLST_LAST1 && clusters < max_clusters) {
+        bn_t fsec;  /* sector offset relative to FAT1 */
+        unsigned fidx;  /* FAT1 entry index */
+        assert(clst >= FAT_CLST_FIRST);
+        if (lastc)
+            *lastc = clst;  /* remember the last cluster number */
+        fsec = (clst * sizeof(fat_cluster_t)) / bps;
+        fidx = clst % (bps / sizeof(fat_cluster_t));
+        /* read FAT1 */
+        b = block_get(dev_handle, rscnt + fsec, BLOCK_FLAGS_NONE);
+        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
+        assert(clst != FAT_CLST_BAD);
+        block_put(b);
+        clusters++;
+    }
+    if (lastc && clst < FAT_CLST_LAST1)
+        *lastc = clst;
+    return clusters;
+}
+/** Read block from file located on a FAT file system.
+ *
+ * @param bs        Buffer holding the boot sector of the file system.
+ * @param dev_handle    Device handle of the file system.
+ * @param firstc    First cluster used by the file. Can be zero if the file
+ *          is empty.
+ * @param bn        Block number.
+ * @param flags     Flags passed to libblock.
+ *
+ * @return      Block structure holding the requested block.
+ */
+block_t *
+_fat_block_get(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc,
+    bn_t bn, int flags)
+{
+    block_t *b;
+    unsigned bps;
+    unsigned rscnt;     /* block address of the first FAT */
+    unsigned rde;
+    unsigned rds;       /* root directory size */
+    unsigned sf;
+    unsigned ssa;       /* size of the system area */
+    unsigned clusters, max_clusters;
+    fat_cluster_t lastc;
+    bps = uint16_t_le2host(bs->bps);
+    rscnt = uint16_t_le2host(bs->rscnt);
+    rde = uint16_t_le2host(bs->root_ent_max);
+    sf = uint16_t_le2host(bs->sec_per_fat);
+    rds = (sizeof(fat_dentry_t) * rde) / bps;
+    rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
+    ssa = rscnt + bs->fatcnt * sf + rds;
+    if (firstc == FAT_CLST_ROOT) {
+        /* root directory special case */
+        assert(bn < rds);
+        b = block_get(dev_handle, rscnt + bs->fatcnt * sf + bn, flags);
+        return b;
+    }
+    max_clusters = bn / bs->spc;
+    clusters = fat_cluster_walk(bs, dev_handle, firstc, &lastc,
+        max_clusters);
+    assert(clusters == max_clusters);
+    b = block_get(dev_handle, ssa + (lastc - FAT_CLST_FIRST) * bs->spc +
+        bn % bs->spc, flags);
+    return b;
+}
+/** Fill the gap between EOF and a new file position.
+ *
+ * @param bs        Buffer holding the boot sector for nodep.
+ * @param nodep     FAT node with the gap.
+ * @param mcl       First cluster in an independent cluster chain that will
+ *          be later appended to the end of the node's own cluster
+ *          chain. If pos is still in the last allocated cluster,
+ *          this argument is ignored.
+ * @param pos       Position in the last node block.
+ */
+void fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, off_t pos)
+{
+    uint16_t bps;
+    unsigned spc;
+    block_t *b;
+    off_t o, boundary;
+    bps = uint16_t_le2host(bs->bps);
+    spc = bs->spc;
+    boundary = ROUND_UP(nodep->size, bps * spc);
+    /* zero out already allocated space */
+    for (o = nodep->size; o < pos && o < boundary;
+        o = ALIGN_DOWN(o + bps, bps)) {
+            int flags = (o % bps == 0) ?
+            BLOCK_FLAGS_NOREAD : BLOCK_FLAGS_NONE;
+        b = fat_block_get(bs, nodep, o / bps, flags);
+        memset(b->data + o % bps, 0, bps - o % bps);
+        b->dirty = true;        /* need to sync node */
+        block_put(b);
+    }
+    if (o >= pos)
+        return;
+    /* zero out the initial part of the new cluster chain */
+    for (o = boundary; o < pos; o += bps) {
+        b = _fat_block_get(bs, nodep->idx->dev_handle, mcl,
+            (o - boundary) / bps, BLOCK_FLAGS_NOREAD);
+        memset(b->data, 0, min(bps, pos - o));
+        b->dirty = true;        /* need to sync node */
+        block_put(b);
+    }
+}
+/** Get cluster from the first FAT.
+ *
+ * @param bs        Buffer holding the boot sector for the file system.
+ * @param dev_handle    Device handle for the file system.
+ * @param clst      Cluster which to get.
+ *
+ * @return      Value found in the cluster.
+ */
+fat_cluster_t
+fat_get_cluster(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t clst)
+{
+    block_t *b;
+    uint16_t bps;
+    uint16_t rscnt;
+    fat_cluster_t *cp, value;
+    bps = uint16_t_le2host(bs->bps);
+    rscnt = uint16_t_le2host(bs->rscnt);
+    b = block_get(dev_handle, rscnt + (clst * sizeof(fat_cluster_t)) / bps,
+        BLOCK_FLAGS_NONE);
+    cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t));
+    value = uint16_t_le2host(*cp);
+    block_put(b);
+    return value;
+}
+/** Set cluster in one instance of FAT.
+ *
+ * @param bs        Buffer holding the boot sector for the file system.
+ * @param dev_handle    Device handle for the file system.
+ * @param fatno     Number of the FAT instance where to make the change.
+ * @param clst      Cluster which is to be set.
+ * @param value     Value to set the cluster with.
+ */
+void
+fat_set_cluster(fat_bs_t *bs, dev_handle_t dev_handle, unsigned fatno,
+    fat_cluster_t clst, fat_cluster_t value)
+{
+    block_t *b;
+    uint16_t bps;
+    uint16_t rscnt;
+    uint16_t sf;
+    fat_cluster_t *cp;
+    bps = uint16_t_le2host(bs->bps);
+    rscnt = uint16_t_le2host(bs->rscnt);
+    sf = uint16_t_le2host(bs->sec_per_fat);
+    assert(fatno < bs->fatcnt);
+    b = block_get(dev_handle, rscnt + sf * fatno +
+        (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE);
+    cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t));
+    *cp = host2uint16_t_le(value);
+    b->dirty = true;        /* need to sync block */
+    block_put(b);
+}
+/** Replay the allocatoin of clusters in all shadow instances of FAT.
+ *
+ * @param bs        Buffer holding the boot sector of the file system.
+ * @param dev_handle    Device handle of the file system.
+ * @param lifo      Chain of allocated clusters.
+ * @param nclsts    Number of clusters in the lifo chain.
+ */
+void fat_alloc_shadow_clusters(fat_bs_t *bs, dev_handle_t dev_handle,
+    fat_cluster_t *lifo, unsigned nclsts)
+{
+    uint8_t fatno;
+    unsigned c;
+    for (fatno = FAT1 + 1; fatno < bs->fatcnt; fatno++) {
+        for (c = 0; c < nclsts; c++) {
+            fat_set_cluster(bs, dev_handle, fatno, lifo[c],
+                c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);
+        }
+    }
+}
+/** Allocate clusters in all copies of FAT.
+ *
+ * This function will attempt to allocate the requested number of clusters in
+ * all instances of the FAT.  The FAT will be altered so that the allocated
+ * clusters form an independent chain (i.e. a chain which does not belong to any
+ * file yet).
+ *
+ * @param bs        Buffer holding the boot sector of the file system.
+ * @param dev_handle    Device handle of the file system.
+ * @param nclsts    Number of clusters to allocate.
+ * @param mcl       Output parameter where the first cluster in the chain
+ *          will be returned.
+ * @param lcl       Output parameter where the last cluster in the chain
+ *          will be returned.
+ *
+ * @return      EOK on success, a negative error code otherwise.
+ */
+int
+fat_alloc_clusters(fat_bs_t *bs, dev_handle_t dev_handle, unsigned nclsts,
+    fat_cluster_t *mcl, fat_cluster_t *lcl)
+{
+    uint16_t bps;
+    uint16_t rscnt;
+    uint16_t sf;
+    block_t *blk;
+    fat_cluster_t *lifo;    /* stack for storing free cluster numbers */
+    unsigned found = 0; /* top of the free cluster number stack */
+    unsigned b, c, cl;
+    lifo = (fat_cluster_t *) malloc(nclsts * sizeof(fat_cluster_t));
+    if (!lifo)
+        return ENOMEM;
+    bps = uint16_t_le2host(bs->bps);
+    rscnt = uint16_t_le2host(bs->rscnt);
+    sf = uint16_t_le2host(bs->sec_per_fat);
+    /*
+     * Search FAT1 for unused clusters.
+     */
+    futex_down(&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++) {
+            fat_cluster_t *clst = (fat_cluster_t *)blk->data + c;
+            if (uint16_t_le2host(*clst) == FAT_CLST_RES0) {
+                /*
+                 * The cluster is free. Put it into our stack
+                 * of found clusters and mark it as non-free.
+                 */
+                lifo[found] = cl;
+                *clst = (found == 0) ?
+                    host2uint16_t_le(FAT_CLST_LAST1) :
+                    host2uint16_t_le(lifo[found - 1]);
+                blk->dirty = true;  /* need to sync block */
+                if (++found == nclsts) {
+                    /* we are almost done */
+                    block_put(blk);
+                    /* update the shadow copies of FAT */
+                    fat_alloc_shadow_clusters(bs,
+                        dev_handle, lifo, nclsts);
+                    *mcl = lifo[found - 1];
+                    *lcl = lifo[0];
+                    free(lifo);
+                    futex_up(&fat_alloc_lock);
+                    return EOK;
+                }
+            }
+        }
+        block_put(blk);
+    }
+    futex_up(&fat_alloc_lock);
+    /*
+     * We could not find enough clusters. Now we need to free the clusters
+     * we have allocated so far.
+     */
+    while (found--) {
+        fat_set_cluster(bs, dev_handle, FAT1, lifo[found],
+            FAT_CLST_RES0);
+    }
+    free(lifo);
+    return ENOSPC;
+}
+/** Free clusters forming a cluster chain in all copies of FAT.
+ *
+ * @param bs        Buffer hodling the boot sector of the file system.
+ * @param dev_handle    Device handle of the file system.
+ * @param firstc    First cluster in the chain which is to be freed.
+ */
+void
+fat_free_clusters(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc)
+{
+    unsigned fatno;
+    fat_cluster_t nextc;
+    /* Mark all clusters in the chain as free in all copies of FAT. */
+    while (firstc < FAT_CLST_LAST1) {
+        assert(firstc >= FAT_CLST_FIRST && firstc < FAT_CLST_BAD);
+        nextc = fat_get_cluster(bs, dev_handle, firstc);
+        for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
+            fat_set_cluster(bs, dev_handle, fatno, firstc,
+                FAT_CLST_RES0);
+        firstc = nextc;
+    }
+}
+/** Append a cluster chain to the last file cluster in all FATs.
+ *
+ * @param bs        Buffer holding the boot sector of the file system.
+ * @param nodep     Node representing the file.
+ * @param mcl       First cluster of the cluster chain to append.
+ */
+void fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl)
+{
+    dev_handle_t dev_handle = nodep->idx->dev_handle;
+    fat_cluster_t lcl;
+    uint8_t fatno;
+    if (fat_cluster_walk(bs, dev_handle, nodep->firstc, &lcl,
+        (uint16_t) -1) == 0) {
+        /* No clusters allocated to the node yet. */
+        nodep->firstc = mcl;
+        nodep->dirty = true;        /* need to sync node */
+        return;
+    }
+    for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
+        fat_set_cluster(bs, nodep->idx->dev_handle, fatno, lcl, mcl);
+}
+/** Chop off node clusters in all copies of FAT.
+ *
+ * @param bs        Buffer holding the boot sector of the file system.
+ * @param nodep     FAT node where the chopping will take place.
+ * @param lastc     Last cluster which will remain in the node. If this
+ *          argument is FAT_CLST_RES0, then all clusters will
+ *          be chopped off.
+ */
+void fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lastc)
+{
+    dev_handle_t dev_handle = nodep->idx->dev_handle;
+    if (lastc == FAT_CLST_RES0) {
+        /* The node will have zero size and no clusters allocated. */
+        fat_free_clusters(bs, dev_handle, nodep->firstc);
+        nodep->firstc = FAT_CLST_RES0;
+        nodep->dirty = true;        /* need to sync node */
+    } else {
+        fat_cluster_t nextc;
+        unsigned fatno;
+        nextc = fat_get_cluster(bs, dev_handle, lastc);
+        /* Terminate the cluster chain in all copies of FAT. */
+        for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
+            fat_set_cluster(bs, dev_handle, fatno, lastc, FAT_CLST_LAST1);
+        /* Free all following clusters. */
+        fat_free_clusters(bs, dev_handle, nextc);
+    }
+}
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/fs/fat/fat_fat.h
 ,0 → 1,91
+/*
+ * 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 fs
+ * @{
+ */
+#ifndef FAT_FAT_FAT_H_
+#define FAT_FAT_FAT_H_
+#include "../../vfs/vfs.h"
+#include <stdint.h>
+#include <libblock.h>
+#define FAT1        0
+#define FAT_CLST_RES0   0x0000
+#define FAT_CLST_RES1   0x0001
+#define FAT_CLST_FIRST  0x0002
+#define FAT_CLST_BAD    0xfff7
+#define FAT_CLST_LAST1  0xfff8
+#define FAT_CLST_LAST8  0xffff
+/* internally used to mark root directory's parent */
+#define FAT_CLST_ROOTPAR    FAT_CLST_RES0
+/* internally used to mark root directory */
+#define FAT_CLST_ROOT       FAT_CLST_RES1
+/* forward declarations */
+struct block;
+struct fat_node;
+struct fat_bs;
+typedef uint16_t fat_cluster_t;
+#define fat_clusters_get(bs, dh, fc) \
+    fat_cluster_walk((bs), (dh), (fc), NULL, (uint16_t) -1)
+extern uint16_t fat_cluster_walk(struct fat_bs *, dev_handle_t, fat_cluster_t,
+    fat_cluster_t *, uint16_t);
+#define fat_block_get(bs, np, bn, flags) \
+    _fat_block_get((bs), (np)->idx->dev_handle, (np)->firstc, (bn), (flags))
+extern struct block *_fat_block_get(struct fat_bs *, dev_handle_t,
+    fat_cluster_t, bn_t, int);
+extern void fat_append_clusters(struct fat_bs *, struct fat_node *,
+    fat_cluster_t);
+extern void fat_chop_clusters(struct fat_bs *, struct fat_node *,
+    fat_cluster_t);
+extern int fat_alloc_clusters(struct fat_bs *, dev_handle_t, unsigned,
+    fat_cluster_t *, fat_cluster_t *);
+extern void fat_free_clusters(struct fat_bs *, dev_handle_t, fat_cluster_t);
+extern void fat_alloc_shadow_clusters(struct fat_bs *, dev_handle_t,
+    fat_cluster_t *, unsigned);
+extern fat_cluster_t fat_get_cluster(struct fat_bs *, dev_handle_t, fat_cluster_t);
+extern void fat_set_cluster(struct fat_bs *, dev_handle_t, unsigned,
+    fat_cluster_t, fat_cluster_t);
+extern void fat_fill_gap(struct fat_bs *, struct fat_node *, fat_cluster_t,
+    off_t);
+#endif
+/**
+ * @}
+ */

 /branches/dd/uspace/srv/fs/fat/fat.c
 ,14 → 49,6
 vfs_info_t fat_vfs_info = {
     .name = "fat",
-    .ops = {
-        [IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_READ)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_WRITE)] = VFS_OP_NULL,
-        [IPC_METHOD_TO_VFS_OP(VFS_TRUNCATE)] = VFS_OP_NULL,
-        [IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] = VFS_OP_NULL,
-        [IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] = VFS_OP_NULL,
-    }
 };
 fs_reg_t fat_reg;
 ,9 → 89,27
         callid = async_get_call(&call);
         switch  (IPC_GET_METHOD(call)) {
+        case VFS_MOUNTED:
+            fat_mounted(callid, &call);
+            break;
+        case VFS_MOUNT:
+            fat_mount(callid, &call);
+            break;
         case VFS_LOOKUP:
             fat_lookup(callid, &call);
             break;
+        case VFS_READ:
+            fat_read(callid, &call);
+            break;
+        case VFS_WRITE:
+            fat_write(callid, &call);
+            break;
+        case VFS_TRUNCATE:
+            fat_truncate(callid, &call);
+            break;
+        case VFS_DESTROY:
+            fat_destroy(callid, &call);
+            break;
         default:
             ipc_answer_0(callid, ENOTSUP);
             break;
 ,20 → 120,24
 int main(int argc, char **argv)
 {
     int vfs_phone;
+    int rc;
-    printf("FAT: HelenOS FAT file system server.\n");
+    printf("fat: HelenOS FAT file system server.\n");
-    vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
-    while (vfs_phone < EOK) {
-        usleep(10000);
-        vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
+    rc = fat_idx_init();
+    if (rc != EOK)
+        goto err;
+    vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
+    if (vfs_phone < EOK) {
+        printf("fat: failed to connect to VFS\n");
+        return -1;
     }
-    int rc;
     rc = fs_register(vfs_phone, &fat_reg, &fat_vfs_info, fat_connection);
     if (rc != EOK) {
-        printf("Failed to register the FAT file system (%d)\n", rc);
-        return rc;
+        fat_idx_fini();
+        goto err;
     }
     dprintf("FAT filesystem registered, fs_handle=%d.\n",
 ,6 → 146,10
     async_manager();
     /* not reached */
     return 0;
+err:
+    printf("Failed to register the FAT file system (%d)\n", rc);
+    return rc;
 }
 /**

 /branches/dd/uspace/srv/fs/fat/fat_ops.c
 ,9 → 36,14
  */
 #include "fat.h"
+#include "fat_dentry.h"
+#include "fat_fat.h"
 #include "../../vfs/vfs.h"
 #include <libfs.h>
+#include <libblock.h>
 #include <ipc/ipc.h>
+#include <ipc/services.h>
+#include <ipc/devmap.h>
 #include <async.h>
 #include <errno.h>
 #include <string.h>
 ,9 → 52,9
 #include <libadt/list.h>
 #include <assert.h>
 #include <futex.h>
+#include <sys/mman.h>
+#include <align.h>
-#define BS_BLOCK        0
 /** Futex protecting the list of cached free FAT nodes. */
 static futex_t ffn_futex = FUTEX_INITIALIZER;
 ,130 → 61,6
 /** List of cached free FAT nodes. */
 static LIST_INITIALIZE(ffn_head);
-#define FAT_NAME_LEN        8
-#define FAT_EXT_LEN     3
-#define FAT_PAD         ' '
-#define FAT_DENTRY_UNUSED   0x00
-#define FAT_DENTRY_E5_ESC   0x05
-#define FAT_DENTRY_DOT      0x2e
-#define FAT_DENTRY_ERASED   0xe5
-static void dentry_name_canonify(fat_dentry_t *d, char *buf)
-{
-    int i;
-    for (i = 0; i < FAT_NAME_LEN; i++) {
-        if (d->name[i] == FAT_PAD) {
-            buf++;
-            break;
-        }
-        if (d->name[i] == FAT_DENTRY_E5_ESC)
-            *buf++ = 0xe5;
-        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];
-    }
-}
-/* TODO move somewhere else */
-typedef struct {
-    void *data;
-} block_t;
-static block_t *block_get(dev_handle_t dev_handle, off_t offset)
-{
-    return NULL;    /* TODO */
-}
-static void block_put(block_t *block)
-{
-    /* TODO */
-}
-#define FAT_BS(b)       ((fat_bs_t *)((b)->data))
-#define FAT_CLST_RES0   0x0000
-#define FAT_CLST_RES1   0x0001  /* internally used to mark root directory */
-#define FAT_CLST_FIRST  0x0002
-#define FAT_CLST_BAD    0xfff7
-#define FAT_CLST_LAST1  0xfff8
-#define FAT_CLST_LAST8  0xffff
-#define fat_block_get(np, off) \
-    _fat_block_get((np)->idx->dev_handle, (np)->firstc, (off))
-static block_t *
-_fat_block_get(dev_handle_t dev_handle, fat_cluster_t firstc, off_t offset)
-{
-    block_t *bb;
-    block_t *b;
-    unsigned bps;
-    unsigned spc;
-    unsigned rscnt;     /* block address of the first FAT */
-    unsigned fatcnt;
-    unsigned rde;
-    unsigned rds;       /* root directory size */
-    unsigned sf;
-    unsigned ssa;       /* size of the system area */
-    unsigned clusters;
-    fat_cluster_t clst = firstc;
-    unsigned i;
-    bb = block_get(dev_handle, BS_BLOCK);
-    bps = uint16_t_le2host(FAT_BS(bb)->bps);
-    spc = FAT_BS(bb)->spc;
-    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
-    fatcnt = FAT_BS(bb)->fatcnt;
-    rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
-    sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
-    block_put(bb);
-    rds = (sizeof(fat_dentry_t) * rde) / bps;
-    rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
-    ssa = rscnt + fatcnt * sf + rds;
-    if (firstc == FAT_CLST_RES1) {
-        /* root directory special case */
-        assert(offset < rds);
-        b = block_get(dev_handle, rscnt + fatcnt * sf + offset);
-        return b;
-    }
-    clusters = offset / spc;
-    for (i = 0; i < clusters; i++) {
-        unsigned fsec;  /* sector offset relative to FAT1 */
-        unsigned fidx;  /* FAT1 entry index */
-        assert(clst >= FAT_CLST_FIRST && clst < FAT_CLST_BAD);
-        fsec = (clst * sizeof(fat_cluster_t)) / bps;
-        fidx = clst % (bps / sizeof(fat_cluster_t));
-        /* read FAT1 */
-        b = block_get(dev_handle, rscnt + fsec);
-        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
-        assert(clst != FAT_CLST_BAD);
-        assert(clst < FAT_CLST_LAST1);
-        block_put(b);
-    }
-    b = block_get(dev_handle, ssa + (clst - FAT_CLST_FIRST) * spc +
-        offset % spc);
-    return b;
-}
 static void fat_node_initialize(fat_node_t *node)
 {
     futex_initialize(&node->lock, 1);
 ,84 → 73,43
     node->dirty = false;
 }
-static uint16_t fat_bps_get(dev_handle_t dev_handle)
+static void fat_node_sync(fat_node_t *node)
 {
-    block_t *bb;
+    block_t *b;
+    fat_bs_t *bs;
+    fat_dentry_t *d;
     uint16_t bps;
+    unsigned dps;
-    bb = block_get(dev_handle, BS_BLOCK);
-    assert(bb != NULL);
-    bps = uint16_t_le2host(FAT_BS(bb)->bps);
-    block_put(bb);
+    assert(node->dirty);
-    return bps;
-}
+    bs = block_bb_get(node->idx->dev_handle);
+    bps = uint16_t_le2host(bs->bps);
+    dps = bps / sizeof(fat_dentry_t);
+    /* Read the block that contains the dentry of interest. */
+    b = _fat_block_get(bs, node->idx->dev_handle, node->idx->pfc,
+        (node->idx->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
-typedef enum {
-    FAT_DENTRY_SKIP,
-    FAT_DENTRY_LAST,
-    FAT_DENTRY_VALID
-} fat_dentry_clsf_t;
+    d = ((fat_dentry_t *)b->data) + (node->idx->pdi % dps);
-static fat_dentry_clsf_t fat_classify_dentry(fat_dentry_t *d)
-{
-    if (d->attr & FAT_ATTR_VOLLABEL) {
-        /* volume label entry */
-        return FAT_DENTRY_SKIP;
+    d->firstc = host2uint16_t_le(node->firstc);
+    if (node->type == FAT_FILE) {
+        d->size = host2uint32_t_le(node->size);
+    } else if (node->type == FAT_DIRECTORY) {
+        d->attr = FAT_ATTR_SUBDIR;
     }
-    if (d->name[0] == FAT_DENTRY_ERASED) {
-        /* not-currently-used entry */
-        return FAT_DENTRY_SKIP;
-    }
-    if (d->name[0] == FAT_DENTRY_UNUSED) {
-        /* never used entry */
-        return FAT_DENTRY_LAST;
-    }
-    if (d->name[0] == FAT_DENTRY_DOT) {
-        /*
-         * Most likely '.' or '..'.
-         * It cannot occur in a regular file name.
-         */
-        return FAT_DENTRY_SKIP;
-    }
-    return FAT_DENTRY_VALID;
+    /* TODO: update other fields? (e.g time fields) */
+    b->dirty = true;        /* need to sync block */
+    block_put(b);
 }
-static void fat_node_sync(fat_node_t *node)
+static fat_node_t *fat_node_get_new(void)
 {
-    /* TODO */
-}
-/** Internal version of fat_node_get().
- *
- * @param idxp      Locked index structure.
- */
-static void *fat_node_get_core(fat_idx_t *idxp)
-{
-    block_t *b;
-    fat_dentry_t *d;
     fat_node_t *nodep;
-    unsigned bps;
-    unsigned dps;
-    if (idxp->nodep) {
-        /*
-         * We are lucky.
-         * The node is already instantiated in memory.
-         */
-        futex_down(&idxp->nodep->lock);
-        if (!idxp->nodep->refcnt++)
-            list_remove(&nodep->ffn_link);
-        futex_up(&idxp->nodep->lock);
-        return idxp->nodep;
-    }
-    /*
-     * We must instantiate the node from the file system.
-     */
-    assert(idxp->pfc);
     futex_down(&ffn_futex);
     if (!list_empty(&ffn_head)) {
         /* Try to use a cached free node structure. */
 ,13 → 138,54
             return NULL;
     }
     fat_node_initialize(nodep);
+    return nodep;
+}
-    bps = fat_bps_get(idxp->dev_handle);
+/** Internal version of fat_node_get().
+ *
+ * @param idxp      Locked index structure.
+ */
+static void *fat_node_get_core(fat_idx_t *idxp)
+{
+    block_t *b;
+    fat_bs_t *bs;
+    fat_dentry_t *d;
+    fat_node_t *nodep = NULL;
+    unsigned bps;
+    unsigned spc;
+    unsigned dps;
+    if (idxp->nodep) {
+        /*
+         * We are lucky.
+         * The node is already instantiated in memory.
+         */
+        futex_down(&idxp->nodep->lock);
+        if (!idxp->nodep->refcnt++)
+            list_remove(&idxp->nodep->ffn_link);
+        futex_up(&idxp->nodep->lock);
+        return idxp->nodep;
+    }
+    /*
+     * We must instantiate the node from the file system.
+     */
+    assert(idxp->pfc);
+    nodep = fat_node_get_new();
+    if (!nodep)
+        return NULL;
+    bs = block_bb_get(idxp->dev_handle);
+    bps = uint16_t_le2host(bs->bps);
+    spc = bs->spc;
     dps = bps / sizeof(fat_dentry_t);
     /* Read the block that contains the dentry of interest. */
-    b = _fat_block_get(idxp->dev_handle, idxp->pfc,
-        (idxp->pdi * sizeof(fat_dentry_t)) / bps);
+    b = _fat_block_get(bs, idxp->dev_handle, idxp->pfc,
+        (idxp->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
     assert(b);
     d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);
 ,11 → 196,18
          * and initialized elsewhere.
          */
         nodep->type = FAT_DIRECTORY;
+        /*
+         * Unfortunately, the 'size' field of the FAT dentry is not
+         * defined for the directory entry type. We must determine the
+         * size of the directory by walking the FAT.
+         */
+        nodep->size = bps * spc * fat_clusters_get(bs, idxp->dev_handle,
+            uint16_t_le2host(d->firstc));
     } else {
         nodep->type = FAT_FILE;
+        nodep->size = uint32_t_le2host(d->size);
     }
     nodep->firstc = uint16_t_le2host(d->firstc);
-    nodep->size = uint32_t_le2host(d->size);
     nodep->lnkcnt = 1;
     nodep->refcnt = 1;
 ,8 → 220,31
     return nodep;
 }
+/*
+ * 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 char fat_plb_get_char(unsigned);
+static bool fat_is_directory(void *);
+static bool fat_is_file(void *node);
+/*
+ * FAT libfs operations.
+ */
 /** Instantiate a FAT in-core node. */
-static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
+void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
 {
     void *node;
     fat_idx_t *idxp;
 ,41 → 258,318
     return node;
 }
-static void fat_node_put(void *node)
+void fat_node_put(void *node)
 {
     fat_node_t *nodep = (fat_node_t *)node;
+    bool destroy = false;
     futex_down(&nodep->lock);
     if (!--nodep->refcnt) {
-        futex_down(&ffn_futex);
-        list_append(&nodep->ffn_link, &ffn_head);
-        futex_up(&ffn_futex);
+        if (nodep->idx) {
+            futex_down(&ffn_futex);
+            list_append(&nodep->ffn_link, &ffn_head);
+            futex_up(&ffn_futex);
+        } else {
+            /*
+             * The node does not have any index structure associated
+             * with itself. This can only mean that we are releasing
+             * the node after a failed attempt to allocate the index
+             * structure for it.
+             */
+            destroy = true;
+        }
     }
     futex_up(&nodep->lock);
+    if (destroy)
+        free(node);
 }
-static void *fat_create(int flags)
+void *fat_create_node(dev_handle_t dev_handle, int flags)
 {
-    return NULL;    /* not supported at the moment */
+    fat_idx_t *idxp;
+    fat_node_t *nodep;
+    fat_bs_t *bs;
+    fat_cluster_t mcl, lcl;
+    uint16_t bps;
+    int rc;
+    bs = block_bb_get(dev_handle);
+    bps = uint16_t_le2host(bs->bps);
+    if (flags & L_DIRECTORY) {
+        /* allocate a cluster */
+        rc = fat_alloc_clusters(bs, dev_handle, 1, &mcl, &lcl);
+        if (rc != EOK)
+            return NULL;
+    }
+    nodep = fat_node_get_new();
+    if (!nodep) {
+        fat_free_clusters(bs, dev_handle, mcl);
+        return NULL;
+    }
+    idxp = fat_idx_get_new(dev_handle);
+    if (!idxp) {
+        fat_free_clusters(bs, dev_handle, mcl);
+        fat_node_put(nodep);
+        return NULL;
+    }
+    /* idxp->lock held */
+    if (flags & L_DIRECTORY) {
+        int i;
+        block_t *b;
+        /*
+         * Populate the new cluster with unused dentries.
+         */
+        for (i = 0; i < bs->spc; i++) {
+            b = _fat_block_get(bs, dev_handle, mcl, i,
+                BLOCK_FLAGS_NOREAD);
+            /* mark all dentries as never-used */
+            memset(b->data, 0, bps);
+            b->dirty = false;
+            block_put(b);
+        }
+        nodep->type = FAT_DIRECTORY;
+        nodep->firstc = mcl;
+        nodep->size = bps * bs->spc;
+    } else {
+        nodep->type = FAT_FILE;
+        nodep->firstc = FAT_CLST_RES0;
+        nodep->size = 0;
+    }
+    nodep->lnkcnt = 0;  /* not linked anywhere */
+    nodep->refcnt = 1;
+    nodep->dirty = true;
+    nodep->idx = idxp;
+    idxp->nodep = nodep;
+    futex_up(&idxp->lock);
+    return nodep;
 }
-static int fat_destroy(void *node)
+int fat_destroy_node(void *node)
 {
-    return ENOTSUP; /* not supported at the moment */
+    fat_node_t *nodep = (fat_node_t *)node;
+    fat_bs_t *bs;
+    /*
+     * The node is not reachable from the file system. This means that the
+     * link count should be zero and that the index structure cannot be
+     * found in the position hash. Obviously, we don't need to lock the node
+     * nor its index structure.
+     */
+    assert(nodep->lnkcnt == 0);
+    /*
+     * The node may not have any children.
+     */
+    assert(fat_has_children(node) == false);
+    bs = block_bb_get(nodep->idx->dev_handle);
+    if (nodep->firstc != FAT_CLST_RES0) {
+        assert(nodep->size);
+        /* Free all clusters allocated to the node. */
+        fat_free_clusters(bs, nodep->idx->dev_handle, nodep->firstc);
+    }
+    fat_idx_destroy(nodep->idx);
+    free(nodep);
+    return EOK;
 }
-static bool fat_link(void *prnt, void *chld, const char *name)
+int fat_link(void *prnt, void *chld, const char *name)
 {
-    return false;   /* not supported at the moment */
+    fat_node_t *parentp = (fat_node_t *)prnt;
+    fat_node_t *childp = (fat_node_t *)chld;
+    fat_dentry_t *d;
+    fat_bs_t *bs;
+    block_t *b;
+    int i, j;
+    uint16_t bps;
+    unsigned dps;
+    unsigned blocks;
+    fat_cluster_t mcl, lcl;
+    int rc;
+    futex_down(&childp->lock);
+    if (childp->lnkcnt == 1) {
+        /*
+         * On FAT, we don't support multiple hard links.
+         */
+        futex_up(&childp->lock);
+        return EMLINK;
+    }
+    assert(childp->lnkcnt == 0);
+    futex_up(&childp->lock);
+    if (!fat_dentry_name_verify(name)) {
+        /*
+         * Attempt to create unsupported name.
+         */
+        return ENOTSUP;
+    }
+    /*
+     * Get us an unused parent node's dentry or grow the parent and allocate
+     * a new one.
+     */
+    futex_down(&parentp->idx->lock);
+    bs = block_bb_get(parentp->idx->dev_handle);
+    bps = uint16_t_le2host(bs->bps);
+    dps = bps / sizeof(fat_dentry_t);
+    blocks = parentp->size / bps;
+    for (i = 0; i < blocks; i++) {
+        b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
+        for (j = 0; j < dps; j++) {
+            d = ((fat_dentry_t *)b->data) + j;
+            switch (fat_classify_dentry(d)) {
+            case FAT_DENTRY_SKIP:
+            case FAT_DENTRY_VALID:
+                /* skipping used and meta entries */
+                continue;
+            case FAT_DENTRY_FREE:
+            case FAT_DENTRY_LAST:
+                /* found an empty slot */
+                goto hit;
+            }
+        }
+        block_put(b);
+    }
+    j = 0;
+    /*
+     * We need to grow the parent in order to create a new unused dentry.
+     */
+    if (parentp->idx->pfc == FAT_CLST_ROOT) {
+        /* Can't grow the root directory. */
+        futex_up(&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);
+        return rc;
+    }
+    fat_append_clusters(bs, parentp, mcl);
+    b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NOREAD);
+    d = (fat_dentry_t *)b->data;
+    /*
+     * Clear all dentries in the block except for the first one (the first
+     * dentry will be cleared in the next step).
+     */
+    memset(d + 1, 0, bps - sizeof(fat_dentry_t));
+hit:
+    /*
+     * At this point we only establish the link between the parent and the
+     * child.  The dentry, except of the name and the extension, will remain
+     * uninitialized until the corresponding node is synced. Thus the valid
+     * dentry data is kept in the child node structure.
+     */
+    memset(d, 0, sizeof(fat_dentry_t));
+    fat_dentry_name_set(d, name);
+    b->dirty = true;        /* need to sync block */
+    block_put(b);
+    futex_up(&parentp->idx->lock);
+    futex_down(&childp->idx->lock);
+    /*
+     * If possible, create the Sub-directory Identifier Entry and the
+     * Sub-directory Parent Pointer Entry (i.e. "." and ".."). These entries
+     * are not mandatory according to Standard ECMA-107 and HelenOS VFS does
+     * not use them anyway, so this is rather a sign of our good will.
+     */
+    b = fat_block_get(bs, childp, 0, BLOCK_FLAGS_NONE);
+    d = (fat_dentry_t *)b->data;
+    if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
+        strcmp(d->name, FAT_NAME_DOT) == 0) {
+        memset(d, 0, sizeof(fat_dentry_t));
+        strcpy(d->name, FAT_NAME_DOT);
+        strcpy(d->ext, FAT_EXT_PAD);
+        d->attr = FAT_ATTR_SUBDIR;
+        d->firstc = host2uint16_t_le(childp->firstc);
+        /* TODO: initialize also the date/time members. */
+    }
+    d++;
+    if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
+        strcmp(d->name, FAT_NAME_DOT_DOT) == 0) {
+        memset(d, 0, sizeof(fat_dentry_t));
+        strcpy(d->name, FAT_NAME_DOT_DOT);
+        strcpy(d->ext, FAT_EXT_PAD);
+        d->attr = FAT_ATTR_SUBDIR;
+        d->firstc = (parentp->firstc == FAT_CLST_ROOT) ?
+            host2uint16_t_le(FAT_CLST_RES0) :
+            host2uint16_t_le(parentp->firstc);
+        /* TODO: initialize also the date/time members. */
+    }
+    b->dirty = true;        /* need to sync block */
+    block_put(b);
+    childp->idx->pfc = parentp->firstc;
+    childp->idx->pdi = i * dps + j;
+    futex_up(&childp->idx->lock);
+    futex_down(&childp->lock);
+    childp->lnkcnt = 1;
+    childp->dirty = true;       /* need to sync node */
+    futex_up(&childp->lock);
+    /*
+     * Hash in the index structure into the position hash.
+     */
+    fat_idx_hashin(childp->idx);
+    return EOK;
 }
-static int fat_unlink(void *prnt, void *chld)
+int fat_unlink(void *prnt, void *chld)
 {
-    return ENOTSUP; /* not supported at the moment */
+    fat_node_t *parentp = (fat_node_t *)prnt;
+    fat_node_t *childp = (fat_node_t *)chld;
+    fat_bs_t *bs;
+    fat_dentry_t *d;
+    uint16_t bps;
+    block_t *b;
+    futex_down(&parentp->lock);
+    futex_down(&childp->lock);
+    assert(childp->lnkcnt == 1);
+    futex_down(&childp->idx->lock);
+    bs = block_bb_get(childp->idx->dev_handle);
+    bps = uint16_t_le2host(bs->bps);
+    b = _fat_block_get(bs, childp->idx->dev_handle, childp->idx->pfc,
+        (childp->idx->pdi * sizeof(fat_dentry_t)) / bps,
+        BLOCK_FLAGS_NONE);
+    d = (fat_dentry_t *)b->data +
+        (childp->idx->pdi % (bps / sizeof(fat_dentry_t)));
+    /* mark the dentry as not-currently-used */
+    d->name[0] = FAT_DENTRY_ERASED;
+    b->dirty = true;        /* need to sync block */
+    block_put(b);
+    /* remove the index structure from the position hash */
+    fat_idx_hashout(childp->idx);
+    /* clear position information */
+    childp->idx->pfc = FAT_CLST_RES0;
+    childp->idx->pdi = 0;
+    futex_up(&childp->idx->lock);
+    childp->lnkcnt = 0;
+    childp->dirty = true;
+    futex_up(&childp->lock);
+    futex_up(&parentp->lock);
+    return EOK;
 }
-static void *fat_match(void *prnt, const char *component)
+void *fat_match(void *prnt, const char *component)
 {
+    fat_bs_t *bs;
     fat_node_t *parentp = (fat_node_t *)prnt;
     char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
     unsigned i, j;
 ,20 → 580,17
     block_t *b;
     futex_down(&parentp->idx->lock);
-    bps = fat_bps_get(parentp->idx->dev_handle);
+    bs = block_bb_get(parentp->idx->dev_handle);
+    bps = uint16_t_le2host(bs->bps);
     dps = bps / sizeof(fat_dentry_t);
-    blocks = parentp->size / bps + (parentp->size % bps != 0);
+    blocks = parentp->size / bps;
     for (i = 0; i < blocks; i++) {
-        unsigned dentries;
-        b = fat_block_get(parentp, i);
-        dentries = (i == blocks - 1) ?
-            parentp->size % sizeof(fat_dentry_t) :
-            dps;
-        for (j = 0; j < dentries; j++) {
+        b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
+        for (j = 0; j < dps; j++) {
             d = ((fat_dentry_t *)b->data) + j;
             switch (fat_classify_dentry(d)) {
             case FAT_DENTRY_SKIP:
+            case FAT_DENTRY_FREE:
                 continue;
             case FAT_DENTRY_LAST:
                 block_put(b);
 ,10 → 598,10
                 return NULL;
             default:
             case FAT_DENTRY_VALID:
-                dentry_name_canonify(d, name);
+                fat_dentry_name_get(d, name);
                 break;
             }
-            if (strcmp(name, component) == 0) {
+            if (fat_dentry_namecmp(name, component) == 0) {
                 /* hit */
                 void *node;
                 /*
 ,11 → 630,12
         }
         block_put(b);
     }
     futex_up(&parentp->idx->lock);
     return NULL;
 }
-static fs_index_t fat_index_get(void *node)
+fs_index_t fat_index_get(void *node)
 {
     fat_node_t *fnodep = (fat_node_t *)node;
     if (!fnodep)
 ,18 → 643,19
     return fnodep->idx->index;
 }
-static size_t fat_size_get(void *node)
+size_t fat_size_get(void *node)
 {
     return ((fat_node_t *)node)->size;
 }
-static unsigned fat_lnkcnt_get(void *node)
+unsigned fat_lnkcnt_get(void *node)
 {
     return ((fat_node_t *)node)->lnkcnt;
 }
-static bool fat_has_children(void *node)
+bool fat_has_children(void *node)
 {
+    fat_bs_t *bs;
     fat_node_t *nodep = (fat_node_t *)node;
     unsigned bps;
     unsigned dps;
 ,25 → 665,23
     if (nodep->type != FAT_DIRECTORY)
         return false;
     futex_down(&nodep->idx->lock);
-    bps = fat_bps_get(nodep->idx->dev_handle);
+    bs = block_bb_get(nodep->idx->dev_handle);
+    bps = uint16_t_le2host(bs->bps);
     dps = bps / sizeof(fat_dentry_t);
-    blocks = nodep->size / bps + (nodep->size % bps != 0);
+    blocks = nodep->size / bps;
     for (i = 0; i < blocks; i++) {
-        unsigned dentries;
         fat_dentry_t *d;
-        b = fat_block_get(nodep, i);
-        dentries = (i == blocks - 1) ?
-            nodep->size % sizeof(fat_dentry_t) :
-            dps;
-        for (j = 0; j < dentries; j++) {
+        b = fat_block_get(bs, nodep, i, BLOCK_FLAGS_NONE);
+        for (j = 0; j < dps; j++) {
             d = ((fat_dentry_t *)b->data) + j;
             switch (fat_classify_dentry(d)) {
             case FAT_DENTRY_SKIP:
+            case FAT_DENTRY_FREE:
                 continue;
             case FAT_DENTRY_LAST:
                 block_put(b);
 ,22 → 704,22
     return false;
 }
-static void *fat_root_get(dev_handle_t dev_handle)
+void *fat_root_get(dev_handle_t dev_handle)
 {
-    return NULL;    /* TODO */
+    return fat_node_get(dev_handle, 0);
 }
-static char fat_plb_get_char(unsigned pos)
+char fat_plb_get_char(unsigned pos)
 {
     return fat_reg.plb_ro[pos % PLB_SIZE];
 }
-static bool fat_is_directory(void *node)
+bool fat_is_directory(void *node)
 {
     return ((fat_node_t *)node)->type == FAT_DIRECTORY;
 }
-static bool fat_is_file(void *node)
+bool fat_is_file(void *node)
 {
     return ((fat_node_t *)node)->type == FAT_FILE;
 }
 ,8 → 729,8
     .match = fat_match,
     .node_get = fat_node_get,
     .node_put = fat_node_put,
-    .create = fat_create,
-    .destroy = fat_destroy,
+    .create = fat_create_node,
+    .destroy = fat_destroy_node,
     .link = fat_link,
     .unlink = fat_unlink,
     .index_get = fat_index_get,
 ,11 → 743,388
     .is_file = fat_is_file
 };
+/*
+ * VFS operations.
+ */
+void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
+{
+    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+    fat_bs_t *bs;
+    uint16_t bps;
+    uint16_t rde;
+    int rc;
+    /* initialize libblock */
+    rc = block_init(dev_handle, BS_SIZE);
+    if (rc != EOK) {
+        ipc_answer_0(rid, rc);
+        return;
+    }
+    /* prepare the boot block */
+    rc = block_bb_read(dev_handle, BS_BLOCK * BS_SIZE, BS_SIZE);
+    if (rc != EOK) {
+        block_fini(dev_handle);
+        ipc_answer_0(rid, rc);
+        return;
+    }
+    /* get the buffer with the boot sector */
+    bs = block_bb_get(dev_handle);
+    /* Read the number of root directory entries. */
+    bps = uint16_t_le2host(bs->bps);
+    rde = uint16_t_le2host(bs->root_ent_max);
+    if (bps != BS_SIZE) {
+        block_fini(dev_handle);
+        ipc_answer_0(rid, ENOTSUP);
+        return;
+    }
+    /* Initialize the block cache */
+    rc = block_cache_init(dev_handle, bps, 0 /* XXX */);
+    if (rc != EOK) {
+        block_fini(dev_handle);
+        ipc_answer_0(rid, rc);
+        return;
+    }
+    rc = fat_idx_init_by_dev_handle(dev_handle);
+    if (rc != EOK) {
+        block_fini(dev_handle);
+        ipc_answer_0(rid, rc);
+        return;
+    }
+    /* Initialize the root node. */
+    fat_node_t *rootp = (fat_node_t *)malloc(sizeof(fat_node_t));
+    if (!rootp) {
+        block_fini(dev_handle);
+        fat_idx_fini_by_dev_handle(dev_handle);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
+    fat_node_initialize(rootp);
+    fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
+    if (!ridxp) {
+        block_fini(dev_handle);
+        free(rootp);
+        fat_idx_fini_by_dev_handle(dev_handle);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
+    assert(ridxp->index == 0);
+    /* ridxp->lock held */
+    rootp->type = FAT_DIRECTORY;
+    rootp->firstc = FAT_CLST_ROOT;
+    rootp->refcnt = 1;
+    rootp->lnkcnt = 0;  /* FS root is not linked */
+    rootp->size = rde * sizeof(fat_dentry_t);
+    rootp->idx = ridxp;
+    ridxp->nodep = rootp;
+    futex_up(&ridxp->lock);
+    ipc_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
+}
+void fat_mount(ipc_callid_t rid, ipc_call_t *request)
+{
+    ipc_answer_0(rid, ENOTSUP);
+}
 void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
 {
     libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
 }
+void fat_read(ipc_callid_t rid, ipc_call_t *request)
+{
+    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);
+    fat_bs_t *bs;
+    uint16_t bps;
+    size_t bytes;
+    block_t *b;
+    if (!nodep) {
+        ipc_answer_0(rid, ENOENT);
+        return;
+    }
+    ipc_callid_t callid;
+    size_t len;
+    if (!ipc_data_read_receive(&callid, &len)) {
+        fat_node_put(nodep);
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    bs = block_bb_get(dev_handle);
+    bps = uint16_t_le2host(bs->bps);
+    if (nodep->type == FAT_FILE) {
+        /*
+         * Our strategy for regular file reads is to read one block at
+         * most and make use of the possibility to return less data than
+         * requested. This keeps the code very simple.
+         */
+        if (pos >= nodep->size) {
+            /* reading beyond the EOF */
+            bytes = 0;
+            (void) ipc_data_read_finalize(callid, NULL, 0);
+        } else {
+            bytes = min(len, bps - pos % bps);
+            bytes = min(bytes, nodep->size - pos);
+            b = fat_block_get(bs, nodep, pos / bps,
+                BLOCK_FLAGS_NONE);
+            (void) ipc_data_read_finalize(callid, b->data + pos % bps,
+                bytes);
+            block_put(b);
+        }
+    } else {
+        unsigned bnum;
+        off_t spos = pos;
+        char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
+        fat_dentry_t *d;
+        assert(nodep->type == FAT_DIRECTORY);
+        assert(nodep->size % bps == 0);
+        assert(bps % sizeof(fat_dentry_t) == 0);
+        /*
+         * Our strategy for readdir() is to use the position pointer as
+         * an index into the array of all dentries. On entry, it points
+         * to the first unread dentry. If we skip any dentries, we bump
+         * the position pointer accordingly.
+         */
+        bnum = (pos * sizeof(fat_dentry_t)) / bps;
+        while (bnum < nodep->size / bps) {
+            off_t o;
+            b = fat_block_get(bs, nodep, bnum, BLOCK_FLAGS_NONE);
+            for (o = pos % (bps / sizeof(fat_dentry_t));
+                o < bps / sizeof(fat_dentry_t);
+                o++, pos++) {
+                d = ((fat_dentry_t *)b->data) + o;
+                switch (fat_classify_dentry(d)) {
+                case FAT_DENTRY_SKIP:
+                case FAT_DENTRY_FREE:
+                    continue;
+                case FAT_DENTRY_LAST:
+                    block_put(b);
+                    goto miss;
+                default:
+                case FAT_DENTRY_VALID:
+                    fat_dentry_name_get(d, name);
+                    block_put(b);
+                    goto hit;
+                }
+            }
+            block_put(b);
+            bnum++;
+        }
+miss:
+        fat_node_put(nodep);
+        ipc_answer_0(callid, ENOENT);
+        ipc_answer_1(rid, ENOENT, 0);
+        return;
+hit:
+        (void) ipc_data_read_finalize(callid, name, strlen(name) + 1);
+        bytes = (pos - spos) + 1;
+    }
+    fat_node_put(nodep);
+    ipc_answer_1(rid, EOK, (ipcarg_t)bytes);
+}
+void fat_write(ipc_callid_t rid, ipc_call_t *request)
+{
+    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);
+    fat_bs_t *bs;
+    size_t bytes;
+    block_t *b;
+    uint16_t bps;
+    unsigned spc;
+    unsigned bpc;       /* bytes per cluster */
+    off_t boundary;
+    int flags = BLOCK_FLAGS_NONE;
+    if (!nodep) {
+        ipc_answer_0(rid, ENOENT);
+        return;
+    }
+    ipc_callid_t callid;
+    size_t len;
+    if (!ipc_data_write_receive(&callid, &len)) {
+        fat_node_put(nodep);
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    bs = block_bb_get(dev_handle);
+    bps = uint16_t_le2host(bs->bps);
+    spc = bs->spc;
+    bpc = bps * spc;
+    /*
+     * In all scenarios, we will attempt to write out only one block worth
+     * of data at maximum. There might be some more efficient approaches,
+     * but this one greatly simplifies fat_write(). Note that we can afford
+     * to do this because the client must be ready to handle the return
+     * value signalizing a smaller number of bytes written.
+     */
+    bytes = min(len, bps - pos % bps);
+    if (bytes == bps)
+        flags |= BLOCK_FLAGS_NOREAD;
+    boundary = ROUND_UP(nodep->size, bpc);
+    if (pos < boundary) {
+        /*
+         * This is the easier case - we are either overwriting already
+         * existing contents or writing behind the EOF, but still within
+         * the limits of the last cluster. The node size may grow to the
+         * next block size boundary.
+         */
+        fat_fill_gap(bs, nodep, FAT_CLST_RES0, pos);
+        b = fat_block_get(bs, nodep, pos / bps, flags);
+        (void) ipc_data_write_finalize(callid, b->data + pos % bps,
+            bytes);
+        b->dirty = true;        /* need to sync block */
+        block_put(b);
+        if (pos + bytes > nodep->size) {
+            nodep->size = pos + bytes;
+            nodep->dirty = true;    /* need to sync node */
+        }
+        ipc_answer_2(rid, EOK, bytes, nodep->size);
+        fat_node_put(nodep);
+        return;
+    } else {
+        /*
+         * This is the more difficult case. We must allocate new
+         * clusters for the node and zero them out.
+         */
+        int status;
+        unsigned nclsts;
+        fat_cluster_t mcl, lcl;
+        nclsts = (ROUND_UP(pos + bytes, bpc) - boundary) / bpc;
+        /* create an independent chain of nclsts clusters in all FATs */
+        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);
+            ipc_answer_0(callid, status);
+            ipc_answer_0(rid, status);
+            return;
+        }
+        /* zero fill any gaps */
+        fat_fill_gap(bs, nodep, mcl, pos);
+        b = _fat_block_get(bs, dev_handle, lcl, (pos / bps) % spc,
+            flags);
+        (void) ipc_data_write_finalize(callid, b->data + pos % bps,
+            bytes);
+        b->dirty = true;        /* need to sync block */
+        block_put(b);
+        /*
+         * Append the cluster chain starting in mcl to the end of the
+         * node's cluster chain.
+         */
+        fat_append_clusters(bs, nodep, mcl);
+        nodep->size = pos + bytes;
+        nodep->dirty = true;        /* need to sync node */
+        ipc_answer_2(rid, EOK, bytes, nodep->size);
+        fat_node_put(nodep);
+        return;
+    }
+}
+void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
+{
+    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);
+    fat_bs_t *bs;
+    uint16_t bps;
+    uint8_t spc;
+    unsigned bpc;   /* bytes per cluster */
+    int rc;
+    if (!nodep) {
+        ipc_answer_0(rid, ENOENT);
+        return;
+    }
+    bs = block_bb_get(dev_handle);
+    bps = uint16_t_le2host(bs->bps);
+    spc = bs->spc;
+    bpc = bps * spc;
+    if (nodep->size == size) {
+        rc = EOK;
+    } else if (nodep->size < size) {
+        /*
+         * The standard says we have the freedom to grow the node.
+         * For now, we simply return an error.
+         */
+        rc = EINVAL;
+    } else if (ROUND_UP(nodep->size, bpc) == ROUND_UP(size, bpc)) {
+        /*
+         * The node will be shrunk, but no clusters will be deallocated.
+         */
+        nodep->size = size;
+        nodep->dirty = true;        /* need to sync node */
+        rc = EOK;
+    } else {
+        /*
+         * The node will be shrunk, clusters will be deallocated.
+         */
+        if (size == 0) {
+            fat_chop_clusters(bs, nodep, FAT_CLST_RES0);
+        } else {
+            fat_cluster_t lastc;
+            (void) fat_cluster_walk(bs, dev_handle, nodep->firstc,
+                &lastc, (size - 1) / bpc);
+            fat_chop_clusters(bs, nodep, lastc);
+        }
+        nodep->size = size;
+        nodep->dirty = true;        /* need to sync node */
+        rc = EOK;
+    }
+    fat_node_put(nodep);
+    ipc_answer_0(rid, rc);
+    return;
+}
+void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
+{
+    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
+    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) {
+        ipc_answer_0(rid, ENOENT);
+        return;
+    }
+    rc = fat_destroy_node(nodep);
+    ipc_answer_0(rid, rc);
+}
 /**
  * @}
  */

 /branches/dd/uspace/srv/fs/fat/Makefile
 ,12 → 31,17
 LIBC_PREFIX = ../../../lib/libc
 LIBFS_PREFIX = ../../../lib/libfs
+LIBBLOCK_PREFIX = ../../../lib/libblock
 SOFTINT_PREFIX = ../../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS += -I $(LIBFS_PREFIX)
+CFLAGS += -I $(LIBFS_PREFIX) -I $(LIBBLOCK_PREFIX)
-LIBS = $(LIBC_PREFIX)/libc.a $(LIBFS_PREFIX)/libfs.a
+LIBS = \
+    $(LIBFS_PREFIX)/libfs.a \
+    $(LIBBLOCK_PREFIX)/libblock.a \
+    $(LIBC_PREFIX)/libc.a
 ## Sources
 #
 ,28 → 50,32
 SOURCES = \
     fat.c \
     fat_ops.c \
-    fat_idx.c
+    fat_idx.c \
+    fat_dentry.c \
+    fat_fat.c
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
 .PHONY: all clean depend disasm
-all: $(OUTPUT) disasm
+all: $(OUTPUT) $(OUTPUT).disasm
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -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/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm:
-    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/dd/uspace/srv/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/dd/uspace/srv/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/dd/uspace/srv/pci/update-ids
 ,15 → 2,14
 wget http://pciids.sourceforge.net/v2.2/pci.ids
-cat >pci_ids.h <<EOF
+cat > pci_ids.h <<EOF
 /* DO NOT EDIT, THIS FILE IS AUTOMATICALLY GENERATED */
 char *pci_ids[] = {
 EOF
-cat pci.ids | grep -v '^#.*' | grep -v '^$' | tr \" \' | sed -n 's/\(.*\)/"\1",/p' >>pci_ids.h
+cat pci.ids | grep -v '^#.*' | grep -v '^$' | tr \" \' | sed -n 's/\(.*\)/"\1",/p' >> pci_ids.h
-cat >>pci_ids.h <<EOF
+cat >> pci_ids.h <<EOF
 ""
 };
 EOF

 /branches/dd/uspace/srv/pci/Makefile
 ,6 → 31,7
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 ,7 → 53,7
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
     $(MAKE) -C libpci clean
 depend:
 ,7 → 61,7
 $(OUTPUT): $(OBJECTS) $(LIBS)
     $(MAKE) -C libpci
-    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
 disasm:
     $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm

 /branches/dd/uspace/srv/devmap/Makefile
 ,6 → 31,7
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 CFLAGS += -I../libipc/include
 ,28 → 45,30
 SOURCES = \
     devmap.c
-CFLAGS += -D$(ARCH)
+CFLAGS += -D$(UARCH)
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
 .PHONY: all clean depend disasm
-all: $(OUTPUT) disasm
+all: $(OUTPUT) $(OUTPUT).disasm
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -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/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm:
-    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/dd/uspace/srv/devmap/devmap.c
 ,9 → 28,9
 /**
  * @defgroup devmap Device mapper.
- * @brief   HelenOS device mapper.
+ * @brief HelenOS device mapper.
  * @{
- */
+ */
 /** @file
  */
 ,18 → 44,26
 #include <futex.h>
 #include <stdlib.h>
 #include <string.h>
+#include <ipc/devmap.h>
-#include "devmap.h"
+#define NAME  "devmap"
+/** Pending lookup structure. */
+typedef struct {
+    link_t link;
+    char *name;              /**< Device name */
+    ipc_callid_t callid;     /**< Call ID waiting for the lookup */
+} pending_req_t;
 LIST_INITIALIZE(devices_list);
 LIST_INITIALIZE(drivers_list);
+LIST_INITIALIZE(pending_req);
-/* order of locking:
- * drivers_list_futex
- * devices_list_futex
- * (devmap_driver_t *)->devices_futex
- * create_handle_futex
+/* Locking order:
+ *  drivers_list_futex
+ *  devices_list_futex
+ *  (devmap_driver_t *)->devices_futex
+ *  create_handle_futex
  **/
 static atomic_t devices_list_futex = FUTEX_INITIALIZER;
 ,27 → 70,28
 static atomic_t drivers_list_futex = FUTEX_INITIALIZER;
 static atomic_t create_handle_futex = FUTEX_INITIALIZER;
 static int 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
+     */
     /* FIXME: overflow */
-    futex_down(&create_handle_futex);
+    futex_down(&create_handle_futex);
     last_handle += 1;
     handle = last_handle;
-    futex_up(&create_handle_futex);
+    futex_up(&create_handle_futex);
     return handle;
 }
-/** Initialize device mapper.
+/** Initialize device mapper.
  *
  *
  */
 ,7 → 98,7
 static int devmap_init()
 {
     /* TODO: */
     return EOK;
 }
 ,169 → 107,153
  */
 static devmap_device_t *devmap_device_find_name(const char *name)
 {
-    link_t *item;
+    link_t *item = devices_list.next;
     devmap_device_t *device = NULL;
-    item = devices_list.next;
     while (item != &devices_list) {
         device = list_get_instance(item, devmap_device_t, devices);
-        if (0 == strcmp(device->name, name)) {
+        if (0 == strcmp(device->name, name))
             break;
-        }
         item = item->next;
     }
-    if (item == &devices_list) {
-        printf("DEVMAP: no device named %s.\n", name);
+    if (item == &devices_list)
         return NULL;
-    }
     device = list_get_instance(item, devmap_device_t, devices);
     return device;
 }
 /** Find device with given handle.
+ *
  * @todo: use hash table
+ *
  */
 static devmap_device_t *devmap_device_find_handle(int handle)
 {
-    link_t *item;
+    futex_down(&devices_list_futex);
+    link_t *item = (&devices_list)->next;
     devmap_device_t *device = NULL;
-    futex_down(&devices_list_futex);
-    item = (&devices_list)->next;
     while (item != &devices_list) {
         device = list_get_instance(item, devmap_device_t, devices);
-        if (device->handle == handle) {
+        if (device->handle == handle)
             break;
-        }
         item = item->next;
     }
     if (item == &devices_list) {
         futex_up(&devices_list_futex);
         return NULL;
     }
     device = list_get_instance(item, devmap_device_t, devices);
     futex_up(&devices_list_futex);
     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)
 {
     list_remove(&(device->devices));
     list_remove(&(device->driver_devices));
-    free(device->name);
+    free(device->name);
     free(device);
     return EOK;
 }
 /**
+ *
  * Read info about new driver and add it into linked list of registered
  * drivers.
+ *
  */
 static void devmap_driver_register(devmap_driver_t **odriver)
 {
-    size_t name_size;
-    ipc_callid_t callid;
-    ipc_call_t call;
-    devmap_driver_t *driver;
-    ipc_callid_t iid;
-    ipc_call_t icall;
     *odriver = NULL;
-    iid = async_get_call(&icall);
+    ipc_call_t icall;
+    ipc_callid_t iid = async_get_call(&icall);
     if (IPC_GET_METHOD(icall) != DEVMAP_DRIVER_REGISTER) {
         ipc_answer_0(iid, EREFUSED);
         return;
-    }
-    if (NULL ==
-        (driver = (devmap_driver_t *)malloc(sizeof(devmap_driver_t)))) {
+    }
+    devmap_driver_t *driver = (devmap_driver_t *) malloc(sizeof(devmap_driver_t));
+    if (driver == NULL) {
         ipc_answer_0(iid, ENOMEM);
         return;
     }
-    /*
+    /*
      * Get driver name
      */
+    ipc_callid_t callid;
+    size_t name_size;
     if (!ipc_data_write_receive(&callid, &name_size)) {
-        printf("Unexpected request.\n");
         free(driver);
         ipc_answer_0(callid, EREFUSED);
         ipc_answer_0(iid, EREFUSED);
         return;
     }
     if (name_size > DEVMAP_NAME_MAXLEN) {
-        printf("Too logn name: %u: maximum is %u.\n", name_size,
-            DEVMAP_NAME_MAXLEN);
         free(driver);
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(iid, EREFUSED);
         return;
     }
     /*
      * Allocate buffer for device name.
      */
-    if (NULL == (driver->name = (char *)malloc(name_size + 1))) {
-        printf("Cannot allocate space for driver name.\n");
+    driver->name = (char *) malloc(name_size + 1);
+    if (driver->name == NULL) {
         free(driver);
         ipc_answer_0(callid, ENOMEM);
         ipc_answer_0(iid, EREFUSED);
         return;
-    }
+    }
     /*
      * Send confirmation to sender and get data into buffer.
      */
     if (EOK != ipc_data_write_finalize(callid, driver->name, name_size)) {
-        printf("Cannot read driver name.\n");
         free(driver->name);
         free(driver);
         ipc_answer_0(iid, EREFUSED);
         return;
     }
     driver->name[name_size] = 0;
-    printf("Read driver name: '%s'.\n", driver->name);
     /* Initialize futex for list of devices owned by this driver */
     futex_initialize(&(driver->devices_futex), 1);
-    /*
+    /*
      * Initialize list of asociated devices
      */
     list_initialize(&(driver->devices));
-    /*
+    /*
      * Create connection to the driver
      */
+    ipc_call_t call;
     callid = async_get_call(&call);
     if (IPC_M_CONNECT_TO_ME != IPC_GET_METHOD(call)) {
-        printf("DEVMAP: Unexpected method: %u.\n",
-            IPC_GET_METHOD(call));
         ipc_answer_0(callid, ENOTSUP);
         free(driver->name);
 ,78 → 261,92
         ipc_answer_0(iid, ENOTSUP);
         return;
     }
     driver->phone = IPC_GET_ARG5(call);
     ipc_answer_0(callid, EOK);
     list_initialize(&(driver->drivers));
-    futex_down(&drivers_list_futex);
+    futex_down(&drivers_list_futex);
     /* TODO:
      * check that no driver with name equal to driver->name is registered
      */
-    /*
+    /*
      * Insert new driver into list of registered drivers
      */
     list_append(&(driver->drivers), &drivers_list);
-    futex_up(&drivers_list_futex);
+    futex_up(&drivers_list_futex);
     ipc_answer_0(iid, EOK);
-    printf("Driver registered.\n");
     *odriver = driver;
-    return;
 }
-/** Unregister device driver, unregister all its devices and free driver
+/**
+ * Unregister device driver, unregister all its devices and free driver
  * structure.
+ *
  */
 static int devmap_driver_unregister(devmap_driver_t *driver)
 {
-    devmap_device_t *device;
-    if (NULL == driver) {
-        printf("Error: driver == NULL.\n");
+    if (driver == NULL)
         return EEXISTS;
-    }
-    printf("Unregister driver '%s'.\n", driver->name);
-    futex_down(&drivers_list_futex);
+    futex_down(&drivers_list_futex);
     ipc_hangup(driver->phone);
     /* remove it from list of drivers */
     list_remove(&(driver->drivers));
     /* unregister all its devices */
-    futex_down(&devices_list_futex);
+    futex_down(&devices_list_futex);
     futex_down(&(driver->devices_futex));
     while (!list_empty(&(driver->devices))) {
-        device = list_get_instance(driver->devices.next,
+        devmap_device_t *device = list_get_instance(driver->devices.next,
             devmap_device_t, driver_devices);
-        printf("Unregister device '%s'.\n", device->name);
         devmap_device_unregister_core(device);
     }
     futex_up(&(driver->devices_futex));
-    futex_up(&devices_list_futex);
-    futex_up(&drivers_list_futex);
+    futex_up(&devices_list_futex);
+    futex_up(&drivers_list_futex);
     /* free name and driver */
-    if (NULL != driver->name) {
+    if (NULL != driver->name)
         free(driver->name);
-    }
     free(driver);
+    return EOK;
+}
-    printf("Driver unregistered.\n");
-    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;
+    }
 }
 ,45 → 356,38
 static void devmap_device_register(ipc_callid_t iid, ipc_call_t *icall,
     devmap_driver_t *driver)
 {
-    ipc_callid_t callid;
-    size_t size;
-    devmap_device_t *device;
-    if (NULL == driver) {
-        printf("Invalid driver registration.\n");
+    if (driver == NULL) {
         ipc_answer_0(iid, EREFUSED);
         return;
     }
     /* Create new device entry */
-    if (NULL ==
-        (device = (devmap_device_t *)malloc(sizeof(devmap_device_t)))) {
-        printf("Cannot allocate new device.\n");
+    devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
+    if (device == NULL) {
         ipc_answer_0(iid, ENOMEM);
         return;
     }
     /* Get device name */
+    ipc_callid_t callid;
+    size_t size;
     if (!ipc_data_write_receive(&callid, &size)) {
         free(device);
-        printf("Cannot read device name.\n");
         ipc_answer_0(iid, EREFUSED);
         return;
     }
     if (size > DEVMAP_NAME_MAXLEN) {
-        printf("Too long device name: %u.\n", size);
         free(device);
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(iid, EREFUSED);
         return;
     }
-        /* +1 for terminating \0 */
-    device->name = (char *)malloc(size + 1);
-    if (NULL == device->name) {
-        printf("Cannot read device name.\n");
+    /* +1 for terminating \0 */
+    device->name = (char *) malloc(size + 1);
+    if (device->name == NULL) {
         free(device);
         ipc_answer_0(callid, ENOMEM);
         ipc_answer_0(iid, EREFUSED);
 ,15 → 396,15
     ipc_data_write_finalize(callid, device->name, size);
     device->name[size] = 0;
     list_initialize(&(device->devices));
     list_initialize(&(device->driver_devices));
-    futex_down(&devices_list_futex);
+    futex_down(&devices_list_futex);
     /* Check that device with such name is not already registered */
     if (NULL != devmap_device_find_name(device->name)) {
-        printf("Device '%s' already registered.\n", device->name);
+        printf(NAME ": Device '%s' already registered\n", device->name);
         futex_up(&devices_list_futex);
         free(device->name);
         free(device);
 ,27 → 411,26
         ipc_answer_0(iid, EEXISTS);
         return;
     }
     /* Get unique device handle */
-    device->handle = devmap_create_handle();
+    device->handle = devmap_create_handle();
     device->driver = driver;
     /* Insert device into list of all devices  */
     list_append(&device->devices, &devices_list);
     /* Insert device into list of devices that belog to one driver */
     futex_down(&device->driver->devices_futex);
     list_append(&device->driver_devices, &device->driver->devices);
-    futex_up(&device->driver->devices_futex);
-    futex_up(&devices_list_futex);
-    printf("Device '%s' registered.\n", device->name);
+    futex_up(&device->driver->devices_futex);
+    futex_up(&devices_list_futex);
     ipc_answer_1(iid, EOK, device->handle);
-    return;
+    process_pending_lookup();
 }
 /**
 ,179 → 440,174
     devmap_driver_t *driver)
 {
     /* TODO */
     return EOK;
 }
 /** Connect client to the device.
+ *
  * Find device driver owning requested device and forward
  * the message to it.
+ *
  */
 static void devmap_forward(ipc_callid_t callid, ipc_call_t *call)
 {
-    devmap_device_t *dev;
-    int handle;
     /*
      * Get handle from request
      */
-    handle = IPC_GET_ARG2(*call);
-    dev = devmap_device_find_handle(handle);
+    int handle = IPC_GET_ARG2(*call);
+    devmap_device_t *dev = devmap_device_find_handle(handle);
     if (NULL == dev) {
-        printf("DEVMAP: No registered device with handle %d.\n",
-            handle);
         ipc_answer_0(callid, ENOENT);
         return;
-    }
+    }
     ipc_forward_fast(callid, dev->driver->phone, (ipcarg_t)(dev->handle),
         IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
-    return;
 }
 /** Find handle for device instance identified by name.
+ *
  * In answer will be send EOK and device handle in arg1 or a error
- * code from errno.h.
+ * code from errno.h.
+ *
  */
 static void devmap_get_handle(ipc_callid_t iid, ipc_call_t *icall)
 {
-    char *name = NULL;
-    size_t name_size;
-    const devmap_device_t *dev;
-    ipc_callid_t callid;
-    ipcarg_t retval;
-    /*
+    /*
      * Wait for incoming message with device name (but do not
      * read the name itself until the buffer is allocated).
      */
-    if (!ipc_data_write_receive(&callid, &name_size)) {
+    ipc_callid_t callid;
+    size_t size;
+    if (!ipc_data_write_receive(&callid, &size)) {
         ipc_answer_0(callid, EREFUSED);
         ipc_answer_0(iid, EREFUSED);
         return;
     }
-    if (name_size > DEVMAP_NAME_MAXLEN) {
+    if ((size < 1) || (size > DEVMAP_NAME_MAXLEN)) {
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(iid, EREFUSED);
         return;
     }
     /*
      * Allocate buffer for device name.
      */
-    if (NULL == (name = (char *)malloc(name_size))) {
+    char *name = (char *) malloc(size);
+    if (name == NULL) {
         ipc_answer_0(callid, ENOMEM);
         ipc_answer_0(iid, EREFUSED);
         return;
-    }
+    }
     /*
      * Send confirmation to sender and get data into buffer.
      */
-    if (EOK != (retval = ipc_data_write_finalize(callid, name,
-        name_size))) {
+    ipcarg_t retval = ipc_data_write_finalize(callid, name, size);
+    if (retval != EOK) {
         ipc_answer_0(iid, EREFUSED);
+        free(name);
         return;
     }
+    name[size] = '\0';
     /*
      * Find device name in linked list of known devices.
      */
-    dev = devmap_device_find_name(name);
+    const devmap_device_t *dev = devmap_device_find_name(name);
     /*
      * Device was not found.
      */
-    if (NULL == dev) {
-        printf("DEVMAP: device %s has not been registered.\n", name);
+    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;
+        }
         ipc_answer_0(iid, ENOENT);
+        free(name);
         return;
     }
-    printf("DEVMAP: device %s has handler %d.\n", name, dev->handle);
     ipc_answer_1(iid, EOK, dev->handle);
-    return;
+    free(name);
 }
-/** Find name of device identified by id and send it to caller.
+/** 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)
 {
-    const devmap_device_t *device;
-    size_t name_size;
-    device = devmap_device_find_handle(IPC_GET_ARG1(*icall));
+    const devmap_device_t *device = devmap_device_find_handle(IPC_GET_ARG1(*icall));
     /*
      * Device not found.
      */
-    if (NULL == device) {
+    if (device == NULL) {
         ipc_answer_0(iid, ENOENT);
         return;
-    }
+    }
     ipc_answer_0(iid, EOK);
-    name_size = strlen(device->name);
-/*  FIXME:
-    we have no channel from DEVMAP to client ->
-    sending must be initiated by client
-    int rc = ipc_data_write_send(phone, device->name, name_size);
-    if (rc != EOK) {
-        async_wait_for(req, NULL);
-        return rc;
-    }
-*/
+    size_t name_size = strlen(device->name);
+    /* FIXME:
+     * We have no channel from DEVMAP to client, therefore
+     * sending must be initiated by client.
+     *
+     * int rc = ipc_data_write_send(phone, device->name, name_size);
+     * if (rc != EOK) {
+     *     async_wait_for(req, NULL);
+     *     return rc;
+     * }
+     */
     /* TODO: send name in response */
-    return;
 }
 /** Handle connection with device driver.
  *
  */
-static void
-devmap_connection_driver(ipc_callid_t iid, ipc_call_t *icall)
+static void devmap_connection_driver(ipc_callid_t iid, ipc_call_t *icall)
 {
-    ipc_callid_t callid;
-    ipc_call_t call;
-    bool cont = true;
+    /* Accept connection */
+    ipc_answer_0(iid, EOK);
     devmap_driver_t *driver = NULL;
-    ipc_answer_0(iid, EOK);
     devmap_driver_register(&driver);
-    if (NULL == driver) {
-        printf("DEVMAP: driver registration failed.\n");
+    if (NULL == driver)
         return;
-    }
+    bool cont = true;
     while (cont) {
-        callid = async_get_call(&call);
-        switch (IPC_GET_METHOD(call)) {
+        ipc_call_t call;
+        ipc_callid_t callid = async_get_call(&call);
+        switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
-            printf("DEVMAP: connection hung up.\n");
             cont = false;
-            continue; /* Exit thread */
+            /* Exit thread */
+            continue;
         case DEVMAP_DRIVER_UNREGISTER:
-            printf("DEVMAP: unregister driver.\n");
-            if (NULL == driver) {
-                printf("DEVMAP: driver was not registered!\n");
+            if (NULL == driver)
                 ipc_answer_0(callid, ENOENT);
-            } else {
+            else
                 ipc_answer_0(callid, EOK);
-            }
             break;
         case DEVMAP_DEVICE_REGISTER:
             /* Register one instance of device */
 ,46 → 624,40
             devmap_get_handle(callid, &call);
             break;
         default:
-            if (!(callid & IPC_CALLID_NOTIFICATION)) {
+            if (!(callid & IPC_CALLID_NOTIFICATION))
                 ipc_answer_0(callid, ENOENT);
-            }
         }
     }
     if (NULL != driver) {
-        /*
+        /*
          * Unregister the device driver and all its devices.
          */
         devmap_driver_unregister(driver);
         driver = NULL;
     }
 }
 /** Handle connection with device client.
  *
  */
-static void
-devmap_connection_client(ipc_callid_t iid, ipc_call_t *icall)
+static void devmap_connection_client(ipc_callid_t iid, ipc_call_t *icall)
 {
-    ipc_callid_t callid;
-    ipc_call_t call;
+    /* Accept connection */
+    ipc_answer_0(iid, EOK);
     bool cont = true;
-    ipc_answer_0(iid, EOK); /* Accept connection */
     while (cont) {
-        callid = async_get_call(&call);
-        switch (IPC_GET_METHOD(call)) {
+        ipc_call_t call;
+        ipc_callid_t callid = async_get_call(&call);
+        switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
-            printf("DEVMAP: connection hung up.\n");
             cont = false;
-            continue; /* Exit thread */
+            /* Exit thread */
+            continue;
         case DEVMAP_DEVICE_GET_HANDLE:
-            devmap_get_handle(callid, &call);
+            devmap_get_handle(callid, &call);
             break;
         case DEVMAP_DEVICE_GET_NAME:
             /* TODO */
 ,24 → 664,19
             devmap_get_name(callid, &call);
             break;
         default:
-            if (!(callid & IPC_CALLID_NOTIFICATION)) {
+            if (!(callid & IPC_CALLID_NOTIFICATION))
                 ipc_answer_0(callid, ENOENT);
-            }
         }
     }
 }
-/** Function for handling connections to devmap
+/** Function for handling connections to devmap
  *
  */
-static void
-devmap_connection(ipc_callid_t iid, ipc_call_t *icall)
+static void devmap_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
-    printf("DEVMAP: new connection.\n");
-        /* Select interface */
-    switch ((ipcarg_t)(IPC_GET_ARG1(*icall))) {
+    /* Select interface */
+    switch ((ipcarg_t) (IPC_GET_ARG1(*icall))) {
     case DEVMAP_DRIVER:
         devmap_connection_driver(iid, icall);
         break;
 ,21 → 684,13
         devmap_connection_client(iid, icall);
         break;
     case DEVMAP_CONNECT_TO_DEVICE:
-            /* Connect client to selected device */
-        printf("DEVMAP: connect to device %d.\n",
-            IPC_GET_ARG2(*icall));
+        /* Connect client to selected device */
         devmap_forward(iid, icall);
         break;
     default:
-        ipc_answer_0(iid, ENOENT); /* No such interface */
-        printf("DEVMAP: Unknown interface %u.\n",
-            (ipcarg_t)(IPC_GET_ARG1(*icall)));
+        /* No such interface */
+        ipc_answer_0(iid, ENOENT);
     }
-    /* Cleanup */
-    printf("DEVMAP: connection closed.\n");
-    return;
 }
 /**
 ,23 → 698,24
  */
 int main(int argc, char *argv[])
 {
-    ipcarg_t phonead;
-    printf("DEVMAP: HelenOS device mapper.\n");
+    printf(NAME ": HelenOS Device Mapper\n");
     if (devmap_init() != 0) {
-        printf("Error while initializing DEVMAP service.\n");
+        printf(NAME ": Error while initializing service\n");
         return -1;
     }
-        /* Set a handler of incomming connections */
+    /* 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)
         return -1;
+    printf(NAME ": Accepting connections\n");
     async_manager();
     /* Never reached */
     return 0;
 }
 ,4 → 723,3
 /**
  * @}
  */

 /branches/dd/uspace/srv/vfs/vfs.c
 ,11 → 28,11
 /** @addtogroup fs
  * @{
- */
+ */
 /**
- * @file    vfs.c
- * @brief   VFS service for HelenOS.
+ * @file vfs.c
+ * @brief VFS service for HelenOS.
  */
 #include <ipc/ipc.h>
 ,20 → 47,18
 #include <atomic.h>
 #include "vfs.h"
-#define dprintf(...)    printf(__VA_ARGS__)
+#define NAME "vfs"
 static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
-    bool keep_on_going = 1;
-    printf("Connection opened from %p\n", icall->in_phone_hash);
+    bool keep_on_going = true;
     /*
      * The connection was opened via the IPC_CONNECT_ME_TO call.
      * This call needs to be answered.
      */
     ipc_answer_0(iid, EOK);
     /*
      * Here we enter the main connection fibril loop.
      * The logic behind this loop and the protocol is that we'd like to keep
 ,20 → 70,38
      * connection later.
      */
     while (keep_on_going) {
-        ipc_callid_t callid;
         ipc_call_t call;
-        callid = async_get_call(&call);
-        printf("Received call, method=%d\n", IPC_GET_METHOD(call));
+        ipc_callid_t callid = async_get_call(&call);
+        fs_handle_t fs_handle;
+        int phone;
         switch (IPC_GET_METHOD(call)) {
         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_on_going = false;
+            /*
+             * 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.
+             */
             break;
         case VFS_MOUNT:
             vfs_mount(callid, &call);
 ,30 → 138,27
             break;
         }
     }
     /* TODO: cleanup after the client */
 }
 int main(int argc, char **argv)
 {
-    ipcarg_t phonead;
-    printf("VFS: HelenOS VFS server\n");
+    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()) {
-        printf("Failed to initialize the VFS node hash table.\n");
+        printf(NAME ": Failed to initialize VFS node hash table\n");
         return ENOMEM;
     }
     /*
      * Allocate and initialize the Path Lookup Buffer.
      */
 ,12 → 165,13
     list_initialize(&plb_head);
     plb = as_get_mappable_page(PLB_SIZE);
     if (!plb) {
-        printf("Cannot allocate a mappable piece of address space\n");
+        printf(NAME ": Cannot allocate a mappable piece of address space\n");
         return ENOMEM;
     }
     if (as_area_create(plb, PLB_SIZE, AS_AREA_READ | AS_AREA_WRITE |
         AS_AREA_CACHEABLE) != plb) {
-        printf("Cannot create address space area.\n");
+        printf(NAME ": Cannot create address space area\n");
         return ENOMEM;
     }
     memset(plb, 0, PLB_SIZE);
 ,15 → 180,17
      * Set a connectio handling function/fibril.
      */
     async_set_client_connection(vfs_connection);
     /*
      * Register at the naming service.
      */
+    ipcarg_t phonead;
     ipc_connect_to_me(PHONE_NS, SERVICE_VFS, 0, 0, &phonead);
     /*
      * Start accepting connections.
      */
+    printf(NAME ": Accepting connections\n");
     async_manager();
     return 0;
 }
 ,4 → 197,4
 /**
  * @}
- */
+ */

 /branches/dd/uspace/srv/vfs/vfs_ops.c
 ,11 → 28,11
 /** @addtogroup fs
  * @{
- */
+ */
 /**
- * @file    vfs_ops.c
- * @brief   Operations that VFS offers to its clients.
+ * @file vfs_ops.c
+ * @brief Operations that VFS offers to its clients.
  */
 #include "vfs.h"
 ,6 → 55,18
 /* 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 */
+    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.
 ,161 → 74,48
 RWLOCK_INITIALIZE(namespace_rwlock);
 futex_t rootfs_futex = FUTEX_INITIALIZER;
-vfs_triplet_t rootfs = {
+vfs_pair_t rootfs = {
     .fs_handle = 0,
-    .dev_handle = 0,
-    .index = 0,
+    .dev_handle = 0
 };
-static int
-lookup_root(fs_handle_t fs_handle, dev_handle_t dev_handle,
-    vfs_lookup_res_t *result)
+static void vfs_mount_internal(ipc_callid_t rid, dev_handle_t dev_handle,
+    fs_handle_t fs_handle, char *mp)
 {
-    vfs_pair_t altroot = {
-        .fs_handle = fs_handle,
-        .dev_handle = dev_handle,
-    };
-    return vfs_lookup_internal("/", L_DIRECTORY, result, &altroot);
-}
-void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
-{
-    dev_handle_t dev_handle;
+    /* Resolve the path to the mountpoint. */
+    vfs_lookup_res_t mp_res;
     vfs_node_t *mp_node = NULL;
     int rc;
     int phone;
-    /*
-     * We expect the library to do the device-name to device-handle
-     * translation for us, thus the device handle will arrive as ARG1
-     * in the request.
-     */
-    dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
-    /*
-     * For now, don't make use of ARG2 and ARG3, but they can be used to
-     * carry mount options in the future.
-     */
-    ipc_callid_t callid;
-    size_t size;
-    /*
-     * Now, we expect the client to send us data with the name of the file
-     * system.
-     */
-    if (!ipc_data_write_receive(&callid, &size)) {
-        ipc_answer_0(callid, EINVAL);
-        ipc_answer_0(rid, EINVAL);
-        return;
-    }
-    /*
-     * Don't receive more than is necessary for storing a full file system
-     * name.
-     */
-    if (size < 1 || size > FS_NAME_MAXLEN) {
-        ipc_answer_0(callid, EINVAL);
-        ipc_answer_0(rid, EINVAL);
-        return;
-    }
-    /* Deliver the file system name. */
-    char fs_name[FS_NAME_MAXLEN + 1];
-    (void) ipc_data_write_finalize(callid, fs_name, size);
-    fs_name[size] = '\0';
-    /*
-     * 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);
-    if (!fs_handle) {
-        ipc_answer_0(rid, ENOENT);
-        return;
-    }
-    /* Now, we want the client to send us the mount point. */
-    if (!ipc_data_write_receive(&callid, &size)) {
-        ipc_answer_0(callid, EINVAL);
-        ipc_answer_0(rid, EINVAL);
-        return;
-    }
-    /* Check whether size is reasonable wrt. the mount point. */
-    if (size < 1 || size > MAX_PATH_LEN) {
-        ipc_answer_0(callid, EINVAL);
-        ipc_answer_0(rid, EINVAL);
-        return;
-    }
-    /* Allocate buffer for the mount point data being received. */
-    uint8_t *buf;
-    buf = malloc(size + 1);
-    if (!buf) {
-        ipc_answer_0(callid, ENOMEM);
-        ipc_answer_0(rid, ENOMEM);
-        return;
-    }
-    /* Deliver the mount point. */
-    (void) ipc_data_write_finalize(callid, buf, size);
-    buf[size] = '\0';
-    /*
-     * Lookup the root node of the filesystem being mounted.
-     * In this case, we don't need to take the namespace_futex as the root
-     * node cannot be removed. However, we do take a reference to it so
-     * that we can track how many times it has been mounted.
-     */
-    vfs_lookup_res_t mr_res;
-    rc = lookup_root(fs_handle, dev_handle, &mr_res);
-    if (rc != EOK) {
-        free(buf);
-        ipc_answer_0(rid, rc);
-        return;
-    }
-    vfs_node_t *mr_node = vfs_node_get(&mr_res);
-    if (!mr_node) {
-        free(buf);
-        ipc_answer_0(rid, ENOMEM);
-        return;
-    }
-    /* Finally, we need to resolve the path to the mountpoint. */
-    vfs_lookup_res_t mp_res;
     futex_down(&rootfs_futex);
     if (rootfs.fs_handle) {
         /* We already have the root FS. */
         rwlock_write_lock(&namespace_rwlock);
-        if ((size == 1) && (buf[0] == '/')) {
+        if ((strlen(mp) == 1) && (mp[0] == '/')) {
             /* Trying to mount root FS over root FS */
             rwlock_write_unlock(&namespace_rwlock);
             futex_up(&rootfs_futex);
-            vfs_node_put(mr_node);
-            free(buf);
             ipc_answer_0(rid, EBUSY);
             return;
         }
-        rc = vfs_lookup_internal(buf, L_DIRECTORY, &mp_res, NULL);
+        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);
-            vfs_node_put(mr_node);  /* failed -> drop reference */
-            free(buf);
             ipc_answer_0(rid, rc);
             return;
         }
         mp_node = vfs_node_get(&mp_res);
         if (!mp_node) {
             rwlock_write_unlock(&namespace_rwlock);
             futex_up(&rootfs_futex);
-            vfs_node_put(mr_node);  /* failed -> drop reference */
-            free(buf);
             ipc_answer_0(rid, ENOMEM);
             return;
         }
         /*
          * Now we hold a reference to mp_node.
          * It will be dropped upon the corresponding VFS_UNMOUNT.
 ,29 → 124,45
         rwlock_write_unlock(&namespace_rwlock);
     } else {
         /* We still don't have the root file system mounted. */
-        if ((size == 1) && (buf[0] == '/')) {
+        if ((strlen(mp) == 1) && (mp[0] == '/')) {
+            vfs_lookup_res_t mr_res;
+            vfs_node_t *mr_node;
+            ipcarg_t rindex;
+            ipcarg_t rsize;
+            ipcarg_t rlnkcnt;
             /*
              * For this simple, but important case,
              * we are almost done.
              */
-            free(buf);
-            /* Inform the mount point about the root mount. */
-            phone = vfs_grab_phone(mr_res.triplet.fs_handle);
-            rc = async_req_5_0(phone, VFS_MOUNT,
-                (ipcarg_t) mr_res.triplet.dev_handle,
-                (ipcarg_t) mr_res.triplet.index,
-                (ipcarg_t) mr_res.triplet.fs_handle,
-                (ipcarg_t) mr_res.triplet.dev_handle,
-                (ipcarg_t) mr_res.triplet.index);
+            /* Tell the mountee that it is being mounted. */
+            phone = vfs_grab_phone(fs_handle);
+            rc = async_req_1_3(phone, VFS_MOUNTED,
+                (ipcarg_t) dev_handle, &rindex, &rsize, &rlnkcnt);
             vfs_release_phone(phone);
-            if (rc == EOK)
-                rootfs = mr_res.triplet;
-            else
-                vfs_node_put(mr_node);
+            if (rc != EOK) {
+                futex_up(&rootfs_futex);
+                ipc_answer_0(rid, rc);
+                return;
+            }
+            mr_res.triplet.fs_handle = fs_handle;
+            mr_res.triplet.dev_handle = dev_handle;
+            mr_res.triplet.index = (fs_index_t) rindex;
+            mr_res.size = (size_t) rsize;
+            mr_res.lnkcnt = (unsigned) rlnkcnt;
+            mr_res.type = VFS_NODE_DIRECTORY;
+            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);
             ipc_answer_0(rid, rc);
             return;
         } else {
 ,8 → 171,6
              * being mounted first.
              */
             futex_up(&rootfs_futex);
-            free(buf);
-            vfs_node_put(mr_node);  /* failed -> drop reference */
             ipc_answer_0(rid, ENOENT);
             return;
         }
 ,30 → 177,21
     }
     futex_up(&rootfs_futex);
-    free(buf);  /* The buffer is not needed anymore. */
     /*
      * At this point, we have all necessary pieces: file system and device
-     * handles, and we know the mount point VFS node and also the root node
-     * of the file system being mounted.
+     * handles, and we know the mount point VFS node.
      */
-    /**
-     * @todo
-     * Add more IPC parameters so that we can send mount mode/flags.
-     */
     phone = vfs_grab_phone(mp_res.triplet.fs_handle);
-    rc = async_req_5_0(phone, VFS_MOUNT,
+    rc = async_req_4_0(phone, VFS_MOUNT,
         (ipcarg_t) mp_res.triplet.dev_handle,
         (ipcarg_t) mp_res.triplet.index,
-        (ipcarg_t) mr_res.triplet.fs_handle,
-        (ipcarg_t) mr_res.triplet.dev_handle,
-        (ipcarg_t) mr_res.triplet.index);
+        (ipcarg_t) fs_handle,
+        (ipcarg_t) dev_handle);
     vfs_release_phone(phone);
     if (rc != EOK) {
-        /* Mount failed, drop references to mr_node and mp_node. */
-        vfs_node_put(mr_node);
+        /* Mount failed, drop reference to mp_node. */
         if (mp_node)
             vfs_node_put(mp_node);
     }
 ,6 → 199,170
     ipc_answer_0(rid, rc);
 }
+/** 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);
+        free(pr->fs_name);
+        free(pr->mp);
+        list_remove(cur);
+        free(pr);
+        goto loop;
+    }
+}
+void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
+{
+    /*
+     * We expect the library to do the device-name to device-handle
+     * translation for us, thus the device handle will arrive as ARG1
+     * in the request.
+     */
+    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+    /*
+     * Mount flags are passed as ARG2.
+     */
+    unsigned int flags = (unsigned int) IPC_GET_ARG2(*request);
+    /*
+     * For now, don't make use of ARG3, but it can be used to
+     * carry mount options in the future.
+     */
+    /* We want the client to send us the mount point. */
+    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;
+    }
+    /* Check whether size is reasonable wrt. the mount point. */
+    if ((size < 1) || (size > MAX_PATH_LEN)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    /* Allocate buffer for the mount point data being received. */
+    char *mp = malloc(size + 1);
+    if (!mp) {
+        ipc_answer_0(callid, ENOMEM);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
+    /* Deliver the mount point. */
+    ipcarg_t retval = ipc_data_write_finalize(callid, mp, size);
+    if (retval != EOK) {
+        ipc_answer_0(rid, EREFUSED);
+        free(mp);
+        return;
+    }
+    mp[size] = '\0';
+    /*
+     * Now, we expect the client to send us data with the name of the file
+     * system.
+     */
+    if (!ipc_data_write_receive(&callid, &size)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        free(mp);
+        return;
+    }
+    /*
+     * Don't receive more than is necessary for storing a full file system
+     * name.
+     */
+    if ((size < 1) || (size > FS_NAME_MAXLEN)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        free(mp);
+        return;
+    }
+    /*
+     * Allocate buffer for file system name.
+     */
+    char *fs_name = (char *) malloc(size + 1);
+    if (fs_name == NULL) {
+        ipc_answer_0(callid, ENOMEM);
+        ipc_answer_0(rid, EREFUSED);
+        free(mp);
+        return;
+    }
+    /* Deliver the file system name. */
+    retval = ipc_data_write_finalize(callid, fs_name, size);
+    if (retval != EOK) {
+        ipc_answer_0(rid, EREFUSED);
+        free(mp);
+        free(fs_name);
+        return;
+    }
+    fs_name[size] = '\0';
+    /*
+     * 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);
+    if (!fs_handle) {
+        if (flags & IPC_FLAG_BLOCKING) {
+            /* Blocking mount, add to pending list */
+            pending_req_t *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);
+                return;
+            }
+            pr->fs_name = fs_name;
+            pr->mp = mp;
+            pr->callid = callid;
+            pr->rid = rid;
+            pr->dev_handle = dev_handle;
+            list_append(&pr->link, &pending_req);
+            return;
+        }
+        ipc_answer_0(callid, ENOENT);
+        ipc_answer_0(rid, ENOENT);
+        free(mp);
+        free(fs_name);
+        return;
+    }
+    /* Acknowledge that we know fs_name. */
+    ipc_answer_0(callid, EOK);
+    /* Do the mount */
+    vfs_mount_internal(rid, dev_handle, fs_handle, mp);
+    free(mp);
+    free(fs_name);
+}
 void vfs_open(ipc_callid_t rid, ipc_call_t *request)
 {
     if (!vfs_files_init()) {
 ,6 → 383,16
     int mode = IPC_GET_ARG3(*request);
     size_t len;
+    /*
+     * Make sure that we are called with exactly one of L_FILE and
+     * L_DIRECTORY.
+     */
+    if ((lflag & (L_FILE | L_DIRECTORY)) == 0 ||
+        (lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY)) {
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
     if (oflag & O_CREAT)
         lflag |= L_CREATE;
     if (oflag & O_EXCL)
 ,12 → 500,8
 void vfs_close(ipc_callid_t rid, ipc_call_t *request)
 {
     int fd = IPC_GET_ARG1(*request);
-    if (fd >= MAX_OPEN_FILES) {
-        ipc_answer_0(rid, EBADF);
-        return;
-    }
-    vfs_fd_free(fd);
-    ipc_answer_0(rid, EOK);
+    int rc = vfs_fd_free(fd);
+    ipc_answer_0(rid, rc);
 }
 static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)
 ,7 → 518,7
      */
     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) {
 ,7 → 525,7
         ipc_answer_0(rid, ENOENT);
         return;
     }
     /*
      * Now we need to receive a call with client's
      * IPC_M_DATA_READ/IPC_M_DATA_WRITE request.
 ,7 → 541,7
         ipc_answer_0(rid, EINVAL);
         return;
     }
     /*
      * Lock the open file structure so that no other thread can manipulate
      * the same open file at a time.
 ,6 → 557,15
     else
         rwlock_write_lock(&file->node->contents_rwlock);
+    if (file->node->type == VFS_NODE_DIRECTORY) {
+        /*
+         * Make sure that no one is modifying the namespace
+         * while we are in readdir().
+         */
+        assert(read);
+        rwlock_read_lock(&namespace_rwlock);
+    }
     int fs_phone = vfs_grab_phone(file->node->fs_handle);
     /* Make a VFS_READ/VFS_WRITE request at the destination FS server. */
 ,14 → 583,17
      * don't have to bother.
      */
     ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     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);
     /* Unlock the VFS node. */
     if (read)
         rwlock_read_unlock(&file->node->contents_rwlock);
 ,12 → 603,12
             file->node->size = IPC_GET_ARG2(answer);
         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);
     /*
      * FS server's reply is the final result of the whole operation we
      * return to the client.

 /branches/dd/uspace/srv/vfs/vfs_register.c
 ,10 → 28,10
 /** @addtogroup fs
  * @{
- */
+ */
 /**
- * @file    vfs_register.c
+ * @file vfs_register.c
  * @brief
  */
 ,30 → 98,6
         return false;
     }
-    /*
-     * Check if the FS implements mandatory VFS operations.
-     */
-    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] != VFS_OP_DEFINED) {
-        dprintf("Operation VFS_LOOKUP not defined by the client.\n");
-        return false;
-    }
-    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_READ)] != VFS_OP_DEFINED) {
-        dprintf("Operation VFS_READ not defined by the client.\n");
-        return false;
-    }
-    /*
-     * Check if each operation is either not defined, defined or default.
-     */
-    for (i = VFS_FIRST; i < VFS_LAST_CLNT; i++) {
-        if ((info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_NULL) &&
-            (info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_DEFAULT) &&
-            (info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_DEFINED)) {
-            dprintf("Operation info not understood.\n");
-            return false;
-        }
-    }
     return true;
 }
 ,6 → 278,11
     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.

 /branches/dd/uspace/srv/vfs/vfs.h
 ,12 → 40,13
 #include <sys/types.h>
 #include <bool.h>
-#define dprintf(...)    printf(__VA_ARGS__)
+// FIXME: according to CONFIG_DEBUG
+// #define dprintf(...) printf(__VA_ARGS__)
+#define dprintf(...)
 #define VFS_FIRST   IPC_FIRST_USER_METHOD
-#define IPC_METHOD_TO_VFS_OP(m) ((m) - VFS_FIRST)
 /* Basic types. */
 typedef int16_t fs_handle_t;
 typedef int16_t dev_handle_t;
 ,6 → 63,7
 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;
 ,32 → 79,16
     VFS_LAST_SRV,   /* keep this the last member of this enum */
 } vfs_request_srv_t;
-/**
- * An instance of this structure is associated with a particular FS operation.
- * It tells VFS if the FS supports the operation or maybe if a default one
- * should be used.
- */
-typedef enum {
-    VFS_OP_NULL = 0,
-    VFS_OP_DEFAULT,
-    VFS_OP_DEFINED
-} vfs_op_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. More importantly, through this structure, the FS announces
- * what operations it supports.
+ * registered FS.
  */
 typedef struct {
     /** Unique identifier of the fs. */
     char name[FS_NAME_MAXLEN + 1];
-    /** Operations. */
-    vfs_op_t ops[VFS_LAST_CLNT - VFS_FIRST];
 } vfs_info_t;
 /**
 ,8 → 172,15
  */
 #define L_PARENT    64
+typedef enum vfs_node_type {
+    VFS_NODE_UNKNOWN,
+    VFS_NODE_FILE,
+    VFS_NODE_DIRECTORY,
+} vfs_node_type_t;
 typedef struct {
     vfs_triplet_t triplet;
+    vfs_node_type_t type;
     size_t size;
     unsigned lnkcnt;
 } vfs_lookup_res_t;
 ,6 → 202,9
     unsigned lnkcnt;
     link_t nh_link;     /**< Node hash-table link. */
+    vfs_node_type_t type;   /**< Partial info about the node type. */
     size_t size;        /**< Cached size if the node is a file. */
     /**
 ,7 → 237,7
 extern link_t fs_head;      /**< List of registered file systems. */
-extern vfs_triplet_t rootfs;    /**< Root node of the root file system. */
+extern vfs_pair_t rootfs;   /**< Root file system. */
 #define MAX_PATH_LEN        (64 * 1024)
 ,7 → 274,7
 extern bool vfs_files_init(void);
 extern vfs_file_t *vfs_file_get(int);
 extern int vfs_fd_alloc(void);
-extern void vfs_fd_free(int);
+extern int vfs_fd_free(int);
 extern void vfs_file_addref(vfs_file_t *);
 extern void vfs_file_delref(vfs_file_t *);
 ,6 → 282,7
 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 *);

 /branches/dd/uspace/srv/vfs/vfs_node.c
 ,15 → 175,22
         node->index = result->triplet.index;
         node->size = result->size;
         node->lnkcnt = result->lnkcnt;
+        node->type = result->type;
         link_initialize(&node->nh_link);
         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);
+        if (node->type == VFS_NODE_UNKNOWN &&
+            result->type != VFS_NODE_UNKNOWN) {
+            /* Upgrade the node type. */
+            node->type = result->type;
+        }
     }
     assert(node->size == result->size);
     assert(node->lnkcnt == result->lnkcnt);
+    assert(node->type == result->type || result->type == VFS_NODE_UNKNOWN);
     _vfs_node_addref(node);
     futex_up(&nodes_futex);

 /branches/dd/uspace/srv/vfs/vfs_lookup.c
 ,7 → 72,7
     if (altroot)
         root = altroot;
     else
-        root = (vfs_pair_t *) &rootfs;
+        root = &rootfs;
     if (!root->fs_handle)
         return ENOENT;
 ,6 → 182,12
         result->triplet.index = (fs_index_t) IPC_GET_ARG3(answer);
         result->size = (size_t) IPC_GET_ARG4(answer);
         result->lnkcnt = (unsigned) IPC_GET_ARG5(answer);
+        if (lflag & L_FILE)
+            result->type = VFS_NODE_FILE;
+        else if (lflag & L_DIRECTORY)
+            result->type = VFS_NODE_DIRECTORY;
+        else
+            result->type = VFS_NODE_UNKNOWN;
     }
     return rc;

 /branches/dd/uspace/srv/vfs/Makefile
 ,6 → 32,7
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 LIBS = $(LIBC_PREFIX)/libc.a
 ,22 → 53,24
 .PHONY: all clean depend disasm
-all: $(OUTPUT) disasm
+all: $(OUTPUT) $(OUTPUT).disasm
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -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/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm:
-    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/dd/uspace/srv/vfs/vfs_file.c
 ,13 → 97,17
 /** Release file descriptor.
  *
  * @param fd        File descriptor being released.
+ *
+ * @return      EOK on success or EBADF if fd is an invalid file
+ *          descriptor.
  */
-void vfs_fd_free(int fd)
+int vfs_fd_free(int fd)
 {
-    assert(fd < MAX_OPEN_FILES);
-    assert(files[fd] != NULL);
+    if ((fd >= MAX_OPEN_FILES) || (files[fd] == NULL))
+        return EBADF;
     vfs_file_delref(files[fd]);
     files[fd] = NULL;
+    return EOK;
 }
 /** Increment reference count of VFS file structure.

 /branches/dd/uspace/Makefile
 ,14 → 29,16
 ## Include configuration
 #
--include Makefile.config
+-include ../Makefile.config
 DIRS = \
     lib/libc \
     lib/libfs \
+    lib/libblock \
     lib/softint \
     lib/softfloat \
     srv/ns \
+    srv/loader \
     srv/fb \
     srv/kbd \
     srv/console \
 ,48 → 49,36
     srv/devmap \
     app/tetris \
     app/tester \
+    app/trace \
     app/klog \
-    app/init
+    app/init \
+    app/bdsh
-ifeq ($(ARCH), amd64)
+ifeq ($(UARCH),amd64)
     DIRS += srv/pci
 endif
-ifeq ($(ARCH), ia32)
+ifeq ($(UARCH),ia32)
     DIRS += srv/pci
 endif
-ifeq ($(ARCH), mips32)
-    CFLAGS += -DCONFIG_MIPS_FPU
+ifeq ($(UARCH),sparc64)
+    DIRS += \
+        srv/fhc \
+        srv/obio
 endif
-ifeq ($(ARCH), mips32eb)
-    CFLAGS += -DCONFIG_MIPS_FPU
-endif
 BUILDS := $(addsuffix .build,$(DIRS))
 CLEANS := $(addsuffix .clean,$(DIRS))
-.PHONY: all config build $(BUILDS) $(CLEANS) clean distclean
+.PHONY: all $(BUILDS) $(CLEANS) clean
-all:
-    ../tools/config.py uspace.config default $(ARCH) $(COMPILER) $(CONFIG_DEBUG)
-    $(MAKE) -C . build
+all: ../Makefile.config ../config.h ../config.defs $(BUILDS)
-config:
-    ../tools/config.py uspace.config
-build: $(BUILDS)
 clean: $(CLEANS)
-    find $(DIRS) -name '*.o' -follow -exec rm \{\} \;
-    find lib/libc -name "_link.ld" -exec rm \{\} \;
-distclean: clean
-    -rm Makefile.config
 $(CLEANS):
-    -$(MAKE) -C $(basename $@) clean ARCH=$(ARCH)
+    -$(MAKE) -C $(basename $@) clean
 $(BUILDS):
-    $(MAKE) -C $(basename $@) all ARCH=$(ARCH) COMPILER=$(COMPILER)
+    $(MAKE) -C $(basename $@) all

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3022 → Rev 4055