WebSVN – HelenOS – Path Comparison – / – /branches/tracing/uspace/app/ Rev 4376 and /branches/tracing/uspace/app/ Rev 4377

Ignore whitespace Rev 4376 → Rev 4377

 /branches/tracing/uspace/app/bdsh/input.c
 ,6 → 33,11
 #include <stdlib.h>
 #include <string.h>
 #include <io/stream.h>
+#include <console.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
+#include <errno.h>
+#include <bool.h>
 #include "config.h"
 #include "util.h"
 ,21 → 46,8
 #include "errors.h"
 #include "exec.h"
-extern volatile unsigned int cli_interactive;
-/* Not exposed in input.h */
-static void cli_restricted(char *);
 static void read_line(char *, int);
-/* More than a macro than anything */
-static void cli_restricted(char *cmd)
-{
-    printf("%s is not available in %s mode\n", cmd,
-        cli_interactive ? "interactive" : "non-interactive");
-    return;
-}
 /* 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 */
 ,14 → 61,11
     if (NULL == usr->line)
         return CL_EFAIL;
-    tmp = cli_strdup(usr->line);
+    tmp = str_dup(usr->line);
-    /* Break up what the user typed, space delimited */
-    /* TODO: Protect things in quotes / ticks, expand wildcards */
-    cmd[n] = cli_strtok(tmp, " ");
+    cmd[n] = strtok(tmp, " ");
     while (cmd[n] && n < WORD_MAX) {
-        cmd[++n] = cli_strtok(NULL, " ");
+        cmd[++n] = strtok(NULL, " ");
     }
     /* We have rubbish */
 ,39 → 74,19
         goto finit;
     }
-    /* Its a builtin command */
+    /* Its a builtin command ? */
     if ((i = (is_builtin(cmd[0]))) > -1) {
-        /* Its not available in this mode, see what try_exec() thinks */
-        if (builtin_is_restricted(i)) {
-                rc = try_exec(cmd[0], cmd);
-                if (rc)
-                    /* No external matching it could be found, tell the
-                     * user that the command does exist, but is not
-                     * available in this mode. */
-                    cli_restricted(cmd[0]);
-                goto finit;
-        }
-        /* Its a builtin, its available, run it */
         rc = run_builtin(i, cmd, usr);
         goto finit;
-    /* We repeat the same dance for modules */
+    /* Its a module ? */
     } else if ((i = (is_module(cmd[0]))) > -1) {
-        if (module_is_restricted(i)) {
-            rc = try_exec(cmd[0], cmd);
-            if (rc)
-                cli_restricted(cmd[0]);
-            goto finit;
-        }
         rc = run_module(i, cmd);
         goto finit;
-    } else {
-        /* Its not a module or builtin, restricted or otherwise.
-         * See what try_exec() thinks of it and just pass its return
-         * value back to the caller */
-        rc = try_exec(cmd[0], cmd);
-        goto finit;
     }
+    /* See what try_exec thinks of it */
+    rc = try_exec(cmd[0], cmd);
 finit:
     if (NULL != usr->line) {
         free(usr->line);
 ,31 → 98,46
     return rc;
 }
-/* Borrowed from Jiri Svoboda's 'cli' uspace app */
 static void read_line(char *buffer, int n)
 {
-    char c;
-    int chars;
+    kbd_event_t ev;
+    size_t offs, otmp;
+    wchar_t dec;
-    chars = 0;
-    while (chars < n - 1) {
-        c = getchar();
-        if (c < 0)
+    offs = 0;
+    while (true) {
+        fflush(stdout);
+        if (kbd_get_event(&ev) < 0)
             return;
-        if (c == '\n')
+        if (ev.type == KE_RELEASE)
+            continue;
+        if (ev.key == KC_ENTER || ev.key == KC_NENTER)
             break;
-        if (c == '\b') {
-            if (chars > 0) {
+        if (ev.key == KC_BACKSPACE) {
+            if (offs > 0) {
+                /*
+                 * Back up until we reach valid start of
+                 * character.
+                 */
+                while (offs > 0) {
+                    --offs; otmp = offs;
+                    dec = str_decode(buffer, &otmp, n);
+                    if (dec != U_SPECIAL)
+                        break;
+                }
                 putchar('\b');
-                --chars;
             }
             continue;
         }
-        putchar(c);
-        buffer[chars++] = c;
+        if (ev.c >= ' ') {
+            //putchar(ev.c);
+            if (chr_encode(ev.c, buffer, &offs, n - 1) == EOK)
+                console_putchar(ev.c);
+        }
     }
     putchar('\n');
-    buffer[chars] = '\0';
+    buffer[offs] = '\0';
 }
 /* TODO:
 ,15 → 146,16
 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')
+    if (str_cmp(line, "") == 0 || str_cmp(line, "\n") == 0)
         return;
-    usr->line = cli_strdup(line);
+    usr->line = str_dup(line);
     return;
 }

 /branches/tracing/uspace/app/bdsh/AUTHORS
 ,9 → 8,6
 * Based on the HelenOS testing sub-system written by Martin Decky
-* cli_strtok() and cli_strtok_r() (util.c) were adapted from the FreeBSD
-  strtok() and strtok_r() functions written by Wes Peters.
 * read_line() (input.c) was written by Jiri Svoboda
 Individual author copyrights are listed in the headers of each file.

 /branches/tracing/uspace/app/bdsh/cmds/mknewcmd
 ,8 → 46,6
   -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)
-  -r, --restrict     Restriction level (interactive, non-interactive, both)
-                     (def: module is both, builtin is interactive only)
   -t, --type         Type of command (module or builtin) (def: module)
   -H, --help         This help summary
   -V, --version      Print $PROGNAME version and exit normally
 ,8 → 65,7
     $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' and available in either interactive or noninteractive
-  mode.
+  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.
 ,7 → 94,6
     "${CMDDESC}",
     &${CMDENTRY},
     &${HELPENTRY},
-    ${CMDRESTRICT}
 },
 EOF
 ,7 → 103,6
     NULL,
     &${CMDENTRY},
     &${HELPENTRY},
-    ${CMDRESTRICT}
 },
 EOF
 ,7 → 162,7
 #include "${CMDNAME}.h"
 #include "cmds.h"
-static char *cmdname = "${CMDNAME}";
+static const char *cmdname = "${CMDNAME}";
 /* Dispays help for ${CMDNAME} in various levels */
 void ${HELPENTRY}(unsigned int level)
 ,8 → 229,8
 # We need at least one
 [ $# = 0 ] && usage && exit 1;
-TEMP=$(getopt -o n:d:e:h:a:r:t:HV \
---long name:,desc:,entry:,help-entry:,alias:,restrict:,type:,help,version \
+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"
 }
 ,11 → 264,6
         shift 2
         continue
     ;;
-    -r | --restrict)
-        CMDRESTRICT="$2"
-        shift 2
-        continue
-    ;;
     -t | --type)
         CMDTYPE="$2"
         shift 2
 ,30 → 295,7
 [ -n "$CMDTYPE" ] || CMDTYPE="module"
 [ -n "$OUTDIR" ] || OUTDIR="${CMDTYPE}s/${CMDNAME}"
-# Builtins typically only need to be available in interactive mode,
-# set the default accordingly.
-[ -n "$CMDRESTRICT" ] || {
-    [ "$CMDTYPE" = "module" ] && CMDRESTRICT="both"
-    [ "$CMDTYPE" = "builtin" ] && CMDRESTRICT="interactive"
-}
-# Set the restriction level as the structure expects to see it
-case "$CMDRESTRICT" in
-| both)
-        CMDRESTRICT="0"
-    ;;
-| non-interactive)
-        CMDRESTRICT="1"
-    ;;
-    -1 | interactive)
-        CMDRESTRICT="-1"
-    ;;
-    *)
-        usage
-        exit 1
-    ;;
-esac
 # Do a little sanity
 [ -d $OUTDIR ] && {
     echo "$OUTDIR already exists, remove it to proceed."

 /branches/tracing/uspace/app/bdsh/cmds/mod_cmds.c
 ,26 → 53,6
 extern volatile unsigned int cli_interactive;
-int module_is_restricted(int pos)
-{
-    /* Restriction Levels:
-     * -1 -> Available only in interactive mode
-     *  0 -> Available in any mode
-     *  1 -> Available only in non-interactive mode */
-    module_t *mod = modules;
-    mod += pos;
-    /* We're interactive, and the module is OK to run */
-    if (cli_interactive && mod->restricted <= 0)
-        return 0;
-    /* We're not interactive, and the module is OK to run */
-    if (!cli_interactive && mod->restricted >= 0)
-        return 0;
-    /* Anything else is just a big fat no :) */
-    return 1;
-}
 /* 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)
 ,7 → 64,7
         return -2;
     for (mod = modules; mod->name != NULL; mod++, i++) {
-        if (!strcmp(mod->name, command))
+        if (!str_cmp(mod->name, command))
             return i;
     }
 ,7 → 81,7
         return -1;
     for(i=0; mod_aliases[i] != NULL; i+=2) {
-        if (!strcmp(mod_aliases[i], command))
+        if (!str_cmp(mod_aliases[i], command))
             return 1;
     }
 ,7 → 97,7
         return (char *)NULL;
     for(i=0; mod_aliases[i] != NULL; i++) {
-        if (!strcmp(mod_aliases[i], command))
+        if (!str_cmp(mod_aliases[i], command))
             return (char *)mod_aliases[++i];
         i++;
     }

/branches/tracing/uspace/app/bdsh/cmds/modules/quit/quit.c
File deleted

/branches/tracing/uspace/app/bdsh/cmds/modules/quit/quit_def.h
File deleted

/branches/tracing/uspace/app/bdsh/cmds/modules/quit/entry.h
File deleted

/branches/tracing/uspace/app/bdsh/cmds/modules/quit/quit.h
File deleted

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

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

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

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

 /branches/tracing/uspace/app/bdsh/cmds/modules/touch/touch.c
 ,6 → 37,7
 #include <fcntl.h>
 #include <dirent.h>
 #include <sys/types.h>
+#include <string.h>
 #include "config.h"
 #include "errors.h"
 ,7 → 80,7
     }
     for (i = 1; i < argc; i ++) {
-        buff = cli_strdup(argv[i]);
+        buff = str_dup(argv[i]);
         dirp = opendir(buff);
         if (dirp) {
             cli_error(CL_ENOTSUP, "%s is a directory", buff);

/branches/tracing/uspace/app/bdsh/cmds/modules/touch/touch_def.h
3,6 → 3,5
"Create files or update access times",
&cmd_touch,
&help_cmd_touch,
0
},

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

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

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

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

 /branches/tracing/uspace/app/bdsh/cmds/modules/cp/cp.c
 ,7 → 34,6
 #include <getopt.h>
 #include <string.h>
 #include <fcntl.h>
-#include <assert.h>
 #include "config.h"
 #include "util.h"
 #include "errors.h"
 ,7 → 69,8
     return (int) t1;
 }
-static int64_t copy_file(const char *src, const char *dest, size_t blen, int vb)
+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;
 ,12 → 124,19
                 goto err;
             res -= bytes;
         } while (res > 0);
-        assert(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("Error copying %s, (%d)\n", src, bytes);
+        printf("\nError copying %s, (%d)\n", src, bytes);
         copied = bytes;
     }

/branches/tracing/uspace/app/bdsh/cmds/modules/cp/cp_def.h
3,6 → 3,5
"Copy files and directories",
&cmd_cp,
&help_cmd_cp,
0
},

 /branches/tracing/uspace/app/bdsh/cmds/modules/mkdir/mkdir.c
 ,7 → 93,7
     /* Its a good idea to allocate path, plus we (may) need a copy of
      * path to tokenize if parents are specified */
-    if (NULL == (tmp = cli_strdup(path))) {
+    if (NULL == (tmp = str_dup(path))) {
         cli_error(CL_ENOMEM, "%s: path too big?", cmdname);
         return 1;
     }
 ,9 → 128,9
         absolute = 1;
     /* TODO: Canonify the path prior to tokenizing it, see below */
-    dirs[i] = cli_strtok(tmp, "/");
+    dirs[i] = strtok(tmp, "/");
     while (dirs[i] && i < 255)
-        dirs[++i] = cli_strtok(NULL, "/");
+        dirs[++i] = strtok(NULL, "/");
     if (NULL == dirs[0])
         return 1;
 ,7 → 149,7
     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 (!str_cmp(dirs[i], "..") || !str_cmp(dirs[i], ".")) {
             if (0 != (chdir(dirs[i]))) {
                 cli_error(CL_EFAIL, "%s: impossible path: %s",
                     cmdname, path);

 /branches/tracing/uspace/app/bdsh/cmds/modules/mkdir/mkdir_def.h
 ,14 → 3,6
     "Create new directories",
     &cmd_mkdir,
     &help_cmd_mkdir,
 },
-{
-    "md",
-    NULL,
-    &cmd_mkdir,
-    &help_cmd_mkdir,
-},

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

/branches/tracing/uspace/app/bdsh/cmds/modules/cat/cat_def.h
3,6 → 3,5
"Show the contents of a file",
&cmd_cat,
&help_cmd_cat,
0
},

/branches/tracing/uspace/app/bdsh/cmds/modules/help/help.c
107,7 → 107,7
}

if (argc == 3) {
if (!strcmp("extended", argv[2]))
if (!str_cmp("extended", argv[2]))
level = HELP_LONG;
else
level = HELP_SHORT;
133,13 → 133,11

/* First, show a list of built in commands that are available in this mode */
for (cmd = builtins; cmd->name != NULL; cmd++, i++) {
if (!builtin_is_restricted(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;
146,13 → 144,11

/* Now, show a list of module commands that are available in this mode */
for (mod = modules; mod->name != NULL; mod++, i++) {
if (!module_is_restricted(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",

/branches/tracing/uspace/app/bdsh/cmds/modules/help/help_def.h
3,5 → 3,4
"Show help for commands",
&cmd_help,
&help_cmd_help,
0
},

/branches/tracing/uspace/app/bdsh/cmds/modules/sleep/sleep_def.h
3,6 → 3,5
"Pause for given time interval (in seconds)",
&cmd_sleep,
&help_cmd_sleep,
0
},

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

 /branches/tracing/uspace/app/bdsh/cmds/modules/kcon/entry.h
 ,0 → 1,9
+#ifndef KCON_ENTRY_H
+#define KCON_ENTRY_H
+/* Entry points for the kcon command */
+extern int cmd_kcon(char **);
+extern void help_cmd_kcon(unsigned int);
+#endif /* KCON_ENTRY_H */

 /branches/tracing/uspace/app/bdsh/cmds/modules/kcon/kcon.c
 ,0 → 1,72
+/* 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 <console.h>
+#include "config.h"
+#include "util.h"
+#include "errors.h"
+#include "entry.h"
+#include "kcon.h"
+#include "cmds.h"
+static char *cmdname = "kcon";
+/* Dispays help for kcon in various levels */
+void help_cmd_kcon(unsigned int level)
+{
+    printf("`kcon' switches to the kernel debug console.\n");
+    if (level != HELP_SHORT) {
+        printf("Usage:  %s\n", cmdname);
+    }
+    return;
+}
+/* Main entry point for kcon, accepts an array of arguments */
+int cmd_kcon(char **argv)
+{
+    unsigned int argc;
+    argc = cli_count_args(argv);
+    if (argc != 1) {
+        printf("%s - incorrect number of arguments. Try `%s --help'\n",
+            cmdname, cmdname);
+        return CMD_FAILURE;
+    }
+    console_kcon_enable();
+    return CMD_SUCCESS;
+}

/branches/tracing/uspace/app/bdsh/cmds/modules/kcon/kcon_def.h
0,0 → 1,7
{
"kcon",
"Switch to kernel console",
&cmd_kcon,
&help_cmd_kcon,
},

/branches/tracing/uspace/app/bdsh/cmds/modules/pwd/pwd_def.h
3,5 → 3,4
"Prints the current working directory",
&cmd_pwd,
&help_cmd_pwd,
-1
},

 /branches/tracing/uspace/app/bdsh/cmds/modules/module_aliases.h
 ,10 → 12,7
  * the entry point being reached. */
 char *mod_aliases[] = {
-    "exit", "quit",
-    "md", "mkdir",
-    "del", "rm",
-    "dir", "ls",
+    "ren", "mv",
     NULL, NULL
 };

 /branches/tracing/uspace/app/bdsh/cmds/modules/modules.h
 ,7 → 18,6
 /* Prototypes for each module's entry (help/exec) points */
 #include "help/entry.h"
-#include "quit/entry.h"
 #include "mkdir/entry.h"
 #include "rm/entry.h"
 #include "cat/entry.h"
 ,6 → 26,9
 #include "pwd/entry.h"
 #include "sleep/entry.h"
 #include "cp/entry.h"
+#include "mv/entry.h"
+#include "mount/entry.h"
+#include "kcon/entry.h"
 /* Each .def function fills the module_t struct with the individual name, entry
  * point, help entry point, etc. You can use config.h to control what modules
 ,7 → 36,6
 module_t modules[] = {
 #include "help/help_def.h"
-#include "quit/quit_def.h"
 #include "mkdir/mkdir_def.h"
 #include "rm/rm_def.h"
 #include "cat/cat_def.h"
 ,6 → 44,10
 #include "pwd/pwd_def.h"
 #include "sleep/sleep_def.h"
 #include "cp/cp_def.h"
+#include "mv/mv_def.h"
+#include "mount/mount_def.h"
+#include "kcon/kcon_def.h"
     {NULL, NULL, NULL, NULL}
 };

 /branches/tracing/uspace/app/bdsh/cmds/modules/rm/rm.c
 ,7 → 33,6
 #include <unistd.h>
 #include <fcntl.h>
 #include <dirent.h>
-#include <assert.h>
 #include <getopt.h>
 #include "config.h"
 ,9 → 216,13
     i = optind;
     while (NULL != argv[i]) {
-        len = strlen(argv[i]) + 2;
+        len = str_size(argv[i]) + 2;
         buff = (char *) realloc(buff, len);
-        assert(buff != NULL);
+        if (buff == NULL) {
+            printf("rm: out of memory\n");
+            ret = 1;
+            break;
+        }
         memset(buff, 0, sizeof(buff));
         snprintf(buff, len, argv[i]);

 /branches/tracing/uspace/app/bdsh/cmds/modules/rm/rm_def.h
 ,14 → 3,5
     "Remove files and directories",
     &cmd_rm,
     &help_cmd_rm,
 },
-{
-    "del",
-    NULL,
-    &cmd_rm,
-    &help_cmd_rm,
-},

 /branches/tracing/uspace/app/bdsh/cmds/modules/ls/ls.c
 ,6 → 50,24
 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;
 ,7 → 114,7
             ls_print_dir(dp->d_name);
             break;
         case LS_FILE:
-            ls_print_file(dp->d_name);
+            ls_print_file(dp->d_name, buff);
             break;
         case LS_BOGUS:
             /* Odd chance it was deleted from the time readdir() found
 ,14 → 138,14
 static void ls_print_dir(const char *d)
 {
-    printf("%-40s\t<DIR>\n", d);
+    printf("%-40s\t<dir>\n", d);
     return;
 }
-static void ls_print_file(const char *f)
+static void ls_print_file(const char *name, const char *pathname)
 {
-    printf("%-40s\n", f);
+    printf("%-40s\t%llu\n", name, (long long) flen(pathname));
     return;
 }
 ,7 → 182,7
     if (argc == 1)
         getcwd(buff, PATH_MAX);
     else
-        strncpy(buff, argv[1], PATH_MAX);
+        str_cpy(buff, PATH_MAX, argv[1]);
     scope = ls_scope(buff);
 ,7 → 192,7
         free(buff);
         return CMD_FAILURE;
     case LS_FILE:
-        ls_print_file(buff);
+        ls_print_file(buff, buff);
         break;
     case LS_DIR:
         dirp = opendir(buff);

 /branches/tracing/uspace/app/bdsh/cmds/modules/ls/ls_def.h
 ,14 → 3,4
     "List files and directories",
     &cmd_ls,
     &help_cmd_ls,
 },
-{
-    "dir",
-    NULL,
-    &cmd_ls,
-    &help_cmd_ls,
-},

 /branches/tracing/uspace/app/bdsh/cmds/modules/ls/ls.h
 ,7 → 10,7
 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 *);
+static void ls_print_file(const char *, const char *);
 #endif /* LS_H */

/branches/tracing/uspace/app/bdsh/cmds/builtins/builtins.h
4,9 → 4,11
#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}
};

 /branches/tracing/uspace/app/bdsh/cmds/builtins/cd/cd_def.h
 ,12 → 3,4
     "Change the current working directory",
     &cmd_cd,
     &help_cmd_cd,
-    -1
 },
-{
-    "chdir",
-    NULL,
-    &cmd_cd,
-    &help_cmd_cd,
-    -1
-},

/branches/tracing/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/tracing/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/tracing/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/tracing/uspace/app/bdsh/cmds/builtins/exit/exit_def.h
0,0 → 1,6
{
"exit",
"Exit the shell",
&cmd_exit,
&help_cmd_exit,
},

/branches/tracing/uspace/app/bdsh/cmds/builtins/builtin_aliases.h
4,7 → 4,6
/* See modules/module_aliases.h for an explanation of this file */

char *builtin_aliases[] = {
"chdir", "cd",
NULL, NULL
};

/branches/tracing/uspace/app/bdsh/cmds/cmds.h
36,7 → 36,6
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;

/* Builtin structure, same as modules except different types of entry points */

 /branches/tracing/uspace/app/bdsh/cmds/builtin_cmds.c
 ,19 → 40,6
 extern volatile unsigned int cli_interactive;
-int builtin_is_restricted(int pos)
-{
-    builtin_t *cmd = builtins;
-    cmd += pos;
-    if (cli_interactive && cmd->restricted <= 0)
-        return 0;
-    if (!cli_interactive && cmd->restricted >= 0)
-        return 0;
-    return 1;
-}
 int is_builtin(const char *command)
 {
     builtin_t *cmd;
 ,7 → 49,7
         return -2;
     for (cmd = builtins; cmd->name != NULL; cmd++, i++) {
-        if (!strcmp(cmd->name, command))
+        if (!str_cmp(cmd->name, command))
             return i;
     }
 ,7 → 64,7
         return -1;
     for(i=0; builtin_aliases[i] != NULL; i+=2) {
-        if (!strcmp(builtin_aliases[i], command))
+        if (!str_cmp(builtin_aliases[i], command))
             return 1;
     }
 ,7 → 79,7
         return (char *)NULL;
     for(i=0; builtin_aliases[i] != NULL; i++) {
-        if (!strcmp(builtin_aliases[i], command))
+        if (!str_cmp(builtin_aliases[i], command))
             return (char *)builtin_aliases[++i];
         i++;
     }

 /branches/tracing/uspace/app/bdsh/util.c
 ,7 → 1,4
-/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
- * Copyright (C) 1998 by Wes Peters <wes@softweyr.com>
- * Copyright (c) 1988, 1993 The Regents of the University of California.
- * All rights reserved by all copyright holders.
+/* 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:
 ,18 → 27,6
  * POSSIBILITY OF SUCH DAMAGE.
  */
-/* NOTES:
- * 1 - Various functions were adapted from FreeBSD (copyright holders noted above)
- *     these functions are identified with comments.
- *
- * 2 - Some of these have since appeared in libc. They remain here for various
- *     reasons, such as the eventual integration of garbage collection for things
- *     that allocate memory and don't automatically free it.
- *
- * 3 - Things that expect a pointer to an allocated string do _no_ sanity checking
- *     if developing on a simulator with no debugger, take care :)
- */
 #include <stdio.h>
 #include <string.h>
 #include <stdarg.h>
 ,71 → 39,6
 extern volatile int cli_errno;
-/* some platforms do not have strdup, implement it here.
- * Returns a pointer to an allocated string or NULL on failure */
-char * cli_strdup(const char *s1)
-{
-    size_t len = strlen(s1) + 1;
-    void *ret = malloc(len);
-    if (ret == NULL) {
-        cli_errno = CL_ENOMEM;
-        return (char *) NULL;
-    }
-    cli_errno = CL_EOK;
-    return (char *) memcpy(ret, s1, len);
-}
-/* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
-char * cli_strtok_r(char *s, const char *delim, char **last)
-{
-    char *spanp, *tok;
-    int c, sc;
-    if (s == NULL && (s = *last) == NULL) {
-        cli_errno = CL_EFAIL;
-        return (NULL);
-    }
-cont:
-    c = *s++;
-    for (spanp = (char *)delim; (sc = *spanp++) != 0;) {
-        if (c == sc)
-            goto cont;
-    }
-    if (c == 0) {       /* no non-delimiter characters */
-        *last = NULL;
-        return (NULL);
-    }
-    tok = s - 1;
-    for (;;) {
-        c = *s++;
-        spanp = (char *)delim;
-        do {
-            if ((sc = *spanp++) == c) {
-                if (c == 0)
-                    s = NULL;
-                else
-                    s[-1] = '\0';
-                *last = s;
-                return (tok);
-            }
-        } while (sc != 0);
-    }
-}
-/* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
-char * cli_strtok(char *s, const char *delim)
-{
-    static char *last;
-    return (cli_strtok_r(s, delim, &last));
-}
 /* Count and return the # of elements in an array */
 unsigned int cli_count_args(char **args)
 {

 /branches/tracing/uspace/app/bdsh/util.h
 ,11 → 3,6
 #include "scli.h"
-/* Internal string handlers */
-extern char * cli_strdup(const char *);
-extern char * cli_strtok_r(char *, const char *, char **);
-extern char * cli_strtok(char *, const char *);
 /* Utility functions */
 extern unsigned int cli_count_args(char **);
 extern unsigned int cli_set_prompt(cliuser_t *usr);

 /branches/tracing/uspace/app/bdsh/exec.c
 ,7 → 71,7
     char *path_tok;
     char *path[PATH_MAX];
     int n = 0, i = 0;
-    size_t x = strlen(cmd) + 2;
+    size_t x = str_size(cmd) + 2;
     found = (char *)malloc(PATH_MAX);
 ,18 → 80,18
         return (char *) cmd;
     }
-    path_tok = cli_strdup(PATH);
+    path_tok = str_dup(PATH);
     /* Extract the PATH env to a path[] array */
-    path[n] = cli_strtok(path_tok, PATH_DELIM);
+    path[n] = strtok(path_tok, PATH_DELIM);
     while (NULL != path[n]) {
-        if ((strlen(path[n]) + x ) > PATH_MAX) {
+        if ((str_size(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] = cli_strtok(NULL, PATH_DELIM);
+        path[++n] = strtok(NULL, PATH_DELIM);
     }
     /* We now have n places to look for the command */
 ,7 → 114,7
     task_id_t tid;
     char *tmp;
-    tmp = cli_strdup(find_command(cmd));
+    tmp = str_dup(find_command(cmd));
     free(found);
     tid = task_spawn((const char *)tmp, argv);
 ,7 → 121,7
     free(tmp);
     if (tid == 0) {
-        cli_error(CL_EEXEC, "Can not spawn %s", cmd);
+        cli_error(CL_EEXEC, "Cannot spawn `%s'.", cmd);
         return 1;
     } else {
         return 0;

/branches/tracing/uspace/app/bdsh/scli.c
45,7 → 45,6
/* Globals that are modified during start-up that modules/builtins
* should be aware of. */
volatile unsigned int cli_quit = 0;
volatile unsigned int cli_interactive = 1;
volatile unsigned int cli_verbocity = 1;

/* The official name of this program

 /branches/tracing/uspace/app/bdsh/Makefile
 ,25 → 30,17
 # POSSIBILITY OF SUCH DAMAGE.
 include ../../../version
-include ../../Makefile.config
 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=\"$(TIMESTAMP)\""
-endif
-ifdef TIMESTAMP
-    DEFS += "-DTIMESTAMP=\"$(TIMESTAMP)\""
-endif
 PROGRAM = bdsh
 # Any directory that cleaning targets should know about
 ,7 → 49,6
     cmds/ \
     cmds/modules/ \
     cmds/modules/help/ \
-    cmds/modules/quit/ \
     cmds/modules/mkdir/ \
     cmds/modules/rm/ \
     cmds/modules/cat/ \
 ,12 → 57,15
     cmds/modules/pwd/ \
     cmds/modules/sleep/ \
     cmds/modules/cp/ \
+    cmds/modules/mv/ \
+    cmds/modules/mount \
+    cmds/modules/kcon/ \
     cmds/builtins/ \
+    cmds/builtins/exit/\
     cmds/builtins/cd/
 SOURCES = \
     cmds/modules/help/help.c \
-    cmds/modules/quit/quit.c \
     cmds/modules/mkdir/mkdir.c \
     cmds/modules/rm/rm.c \
     cmds/modules/cat/cat.c \
 ,6 → 74,10
     cmds/modules/pwd/pwd.c \
     cmds/modules/sleep/sleep.c \
     cmds/modules/cp/cp.c \
+    cmds/modules/mv/mv.c \
+    cmds/modules/mount/mount.c \
+    cmds/modules/kcon/kcon.c \
+    cmds/builtins/exit/exit.c \
     cmds/builtins/cd/cd.c \
     cmds/mod_cmds.c \
     cmds/builtin_cmds.c \
 ,7 → 110,7
     @$(CC) -M $(CFLAGS) $(INC) $*.c > $*.d
 $(PROGRAM): $(OBJECTS) $(LIBS)
-    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(PROGRAM).map
+    $(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

 /branches/tracing/uspace/app/init/init.c
 ,9 → 27,9
  */
 /** @addtogroup init Init
- * @brief   Init process for testing purposes.
+ * @brief Init process for user space environment configuration.
  * @{
- */
+ */
 /**
  * @file
  */
 ,6 → 36,7
 #include <stdio.h>
 #include <unistd.h>
+#include <ipc/ipc.h>
 #include <vfs/vfs.h>
 #include <bool.h>
 #include <errno.h>
 ,22 → 43,23
 #include <fcntl.h>
 #include <task.h>
 #include <malloc.h>
+#include <macros.h>
+#include <console.h>
+#include <string.h>
 #include "init.h"
 #include "version.h"
-static void console_wait(void)
-{
-    while (get_cons_phone() < 0)
-        usleep(50000);  // FIXME
-}
 static bool mount_fs(const char *fstype)
 {
     int rc = -1;
+    char *opts = "";
+    if (str_cmp(fstype, "tmpfs") == 0)
+        opts = "restore";
     while (rc < 0) {
-        rc = mount(fstype, "/", "initrd");
+        rc = mount(fstype, "/", "initrd", opts, IPC_FLAG_BLOCKING);
         switch (rc) {
         case EOK:
             printf(NAME ": Root filesystem mounted\n");
 ,8 → 73,6
         case ENOENT:
             printf(NAME ": Unknown filesystem type (%s)\n", fstype);
             return false;
-        default:
-            sleep(5);   // FIXME
         }
     }
 ,24 → 82,21
 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) != 0) {
-        /* Success */
-        sleep(1);
-    }
+    if (!task_spawn(fname, argv))
+        printf(NAME ": Error spawning %s\n", fname);
 }
 int main(int argc, char *argv[])
 {
     info_print();
-    sleep(5);   // FIXME
-    if (!mount_fs("tmpfs") && !mount_fs("fat")) {
+    if (!mount_fs(STRING(RDFMT))) {
         printf(NAME ": Exiting\n");
         return -1;
     }
 ,6 → 105,8
     spawn("/srv/fb");
     spawn("/srv/kbd");
     spawn("/srv/console");
+    spawn("/srv/fhc");
+    spawn("/srv/obio");
     console_wait();
     version_print();

 /branches/tracing/uspace/app/init/version.c
 ,19 → 35,20
 #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
 ,7 → 61,8
 /** Print version information. */
 void version_print(void)
 {
-    printf("HelenOS init\nRelease %s%s%s\nCopyright (c) 2006 HelenOS project\n", release, revision, timestamp);
+    printf("HelenOS init\nRelease %s%s%s\n", release, revision, timestamp);
+    printf("Copyright (c) 2001-2009 HelenOS project\n");
 }
 /** @}

 /branches/tracing/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
 #
 ,13 → 58,13
 -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: $(OUTPUT).disasm

 /branches/tracing/uspace/app/debug/main.c
 ,7 → 178,7
     int idx_found;
     int num_found;
-    len = strlen(cmd_argv[0]);
+    len = str_length(cmd_argv[0]);
     cmp_len = 1;
     /* Silence warnings */
 ,7 → 190,7
         num_found = 0;
         i = 0;
         while (cmd_table[i].name != NULL) {
-            if (strncmp(cmd_table[i].name, cmd_argv[0], cmp_len) == 0) {
+            if (str_lcmp(cmd_table[i].name, cmd_argv[0], cmp_len) == 0) {
                 idx_found = i;
                 ++num_found;
             }

 /branches/tracing/uspace/app/debug/Makefile
 ,8 → 32,9
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
-include arch/$(ARCH)/Makefile.inc
+include arch/$(UARCH)/Makefile.inc
 include genarch/Makefile.inc
 CFLAGS += -I../../srv/kbd/include -Igenarch/idec
 ,7 → 59,7
 all: inc $(OUTPUT) disasm
 inc:
-    ln -sfn ../arch/$(ARCH)/include include/arch
+    ln -sfn ../arch/$(UARCH)/include include/arch
 -include Makefile.depend
 ,7 → 71,7
     $(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

/branches/tracing/uspace/app/debug/arch/arm32/Makefile.inc
27,6 → 27,6
#

ARCH_SOURCES := \
arch/$(ARCH)/src/arm32.c
arch/$(UARCH)/src/arm32.c

CONFIG_IDEC = y

/branches/tracing/uspace/app/debug/arch/ppc32/Makefile.inc
27,6 → 27,6
#

ARCH_SOURCES := \
arch/$(ARCH)/src/ppc32.c
arch/$(UARCH)/src/ppc32.c

CONFIG_IDEC = y

/branches/tracing/uspace/app/debug/arch/mips32/Makefile.inc
27,6 → 27,6
#

ARCH_SOURCES := \
arch/$(ARCH)/src/mips32.c
arch/$(UARCH)/src/mips32.c

CONFIG_IDEC = y

/branches/tracing/uspace/app/debug/arch/ia32/Makefile.inc
26,4 → 26,4
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#

ARCH_SOURCES := arch/$(ARCH)/src/ia32.c
ARCH_SOURCES := arch/$(UARCH)/src/ia32.c

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

 /branches/tracing/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/tracing/uspace/app/tester/stdio/stdio1.def
0,0 → 1,6
{
"stdio1",
"ANSI C streams reading test",
&test_stdio1,
true
},

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

 /branches/tracing/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/tracing/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/tracing/uspace/app/tester/tester.c
 ,6 → 47,7
 test_t tests[] = {
 #include "thread/thread1.def"
 #include "print/print1.def"
+#include "print/print4.def"
 #include "fault/fault1.def"
 #include "fault/fault2.def"
 #include "ipc/register.def"
 ,6 → 59,9
 #include "devmap/devmap1.def"
 #include "loop/loop1.def"
 #include "vfs/vfs1.def"
+#include "console/console1.def"
+#include "stdio/stdio1.def"
+#include "stdio/stdio2.def"
 #include "debug/debug1.def"
     {NULL, NULL, NULL}
 };

 /branches/tracing/uspace/app/tester/devmap/devmap1.c
 ,17 → 132,15
     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);
-    retval = ipc_data_write_start(phone, (char *)name, strlen(name) + 1);
+    retval = ipc_data_write_start(phone, (char *)name, str_size(name) + 1);
     if (retval != EOK) {
         async_wait_for(req, NULL);
 ,7 → 173,7
     req = async_send_2(driver_phone, DEVMAP_DEVICE_GET_HANDLE, 0, 0,
         &answer);
-    retval = ipc_data_write_start(driver_phone, name, strlen(name) + 1);
+    retval = ipc_data_write_start(driver_phone, name, str_size(name) + 1);
     if (retval != EOK) {
         printf("Failed to send device name '%s'.\n", name);
 ,7 → 215,7
     req = async_send_2(driver_phone, DEVMAP_DEVICE_REGISTER, 0, 0, &answer);
     retval = ipc_data_write_start(driver_phone, (char *)name,
-        strlen(name) + 1);
+        str_size(name) + 1);
     if (retval != EOK) {
         printf("Failed to send device name '%s'.\n", name);

 /branches/tracing/uspace/app/tester/print/print4.c
 ,0 → 1,92
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <stdio.h>
+#include <unistd.h>
+#include "../tester.h"
+#define PRIx8 "x"
+char *test_print4(bool quiet)
+{
+    if (!quiet) {
+        printf("ASCII printable characters (32 - 127) using printf(\"%%c\") and printf(\"%%lc\"):\n");
+        uint8_t group;
+        for (group = 1; group < 4; group++) {
+            printf("%#" PRIx8 ": ", group << 5);
+            uint8_t index;
+            for (index = 0; index < 32; index++)
+                printf("%c", (char) ((group << 5) + index));
+            printf("  ");
+            for (index = 0; index < 32; index++)
+                printf("%lc", (wchar_t) ((group << 5) + index));
+            printf("\n");
+        }
+        printf("\nExtended ASCII characters (128 - 255) using printf(\"%%lc\"):\n");
+        for (group = 4; group < 8; group++) {
+            printf("%#" PRIx8 ": ", group << 5);
+            uint8_t index;
+            for (index = 0; index < 32; index++)
+                printf("%lc", (wchar_t) ((group << 5) + index));
+            printf("\n");
+        }
+        printf("\nUTF-8 strings using printf(\"%%s\"):\n");
+        printf("English:  %s\n", "Quick brown fox jumps over the lazy dog");
+        printf("Czech:    %s\n", "Příliš žluťoučký kůň úpěl ďábelské ódy");
+        printf("Greek:    %s\n", "á½® Î¾Îµá¿–Î½â€™, á¼€Î³Î³ÎÎ»Î»ÎµÎ¹Î½ Î›Î±ÎºÎµÎ´Î±Î¹Î¼Î¿Î½Î¯Î¿Î¹Ï‚ á½…Ï„Î¹ Ï„á¿‡Î´Îµ");
+        printf("Hebrew:   %s\n", "משוואת ברנולי היא משוואה בהידרודינמיקה");
+        printf("Arabic:   %s\n", "التوزيع الجغرافي للحمل العنقودي");
+        printf("Russian:  %s\n", "Леннон познакомился с художницей-авангардисткой");
+        printf("Armenian: %s\n", "ÕÕ¯Õ½Õ¥Ö Õ°Ö€Õ¡Õ¿Õ¡Ö€Õ¡Õ¯Õ¾Õ¥Õ¬ ÔµÖ€Õ¸Ö‚Õ½Õ¡Õ²Õ¥Õ´Õ« Õ°Õ¡ÕµÕ¯Õ¡Õ¯Õ¡Õ¶");
+        printf("\nUTF-32 strings using printf(\"%%ls\"):\n");
+        printf("English:  %ls\n", L"Quick brown fox jumps over the lazy dog");
+        printf("Czech:    %ls\n", L"Příliš žluťoučký kůň úpěl ďábelské ódy");
+        printf("Greek:    %ls\n", L"á½® Î¾Îµá¿–Î½â€™, á¼€Î³Î³ÎÎ»Î»ÎµÎ¹Î½ Î›Î±ÎºÎµÎ´Î±Î¹Î¼Î¿Î½Î¯Î¿Î¹Ï‚ á½…Ï„Î¹ Ï„á¿‡Î´Îµ");
+        printf("Hebrew:   %ls\n", L"משוואת ברנולי היא משוואה בהידרודינמיקה");
+        printf("Arabic:   %ls\n", L"التوزيع الجغرافي للحمل العنقودي");
+        printf("Russian:  %ls\n", L"Леннон познакомился с художницей-авангардисткой");
+        printf("Armenian: %ls\n", L"ÕÕ¯Õ½Õ¥Ö Õ°Ö€Õ¡Õ¿Õ¡Ö€Õ¡Õ¯Õ¾Õ¥Õ¬ ÔµÖ€Õ¸Ö‚Õ½Õ¡Õ²Õ¥Õ´Õ« Õ°Õ¡ÕµÕ¯Õ¡Õ¯Õ¡Õ¶");
+        printf("Test: [%d] '%lc'\n", L'\x0161', L'\x0161');
+    }
+    printf("[Press a key]\n");
+    getchar();
+    return NULL;
+}

/branches/tracing/uspace/app/tester/print/print4.def
0,0 → 1,6
{
"print4",
"Unicode test",
&test_print4,
true
},

 /branches/tracing/uspace/app/tester/tester.h
 ,6 → 60,7
 extern char * test_thread1(bool quiet);
 extern char * test_print1(bool quiet);
+extern char * test_print4(bool quiet);
 extern char * test_fault1(bool quiet);
 extern char * test_fault2(bool quiet);
 extern char * test_register(bool quiet);
 ,6 → 72,9
 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 char * test_debug1(bool quiet);
 extern test_t tests[];

 /branches/tracing/uspace/app/tester/Makefile
 ,10 → 29,9
 ## Setup toolchain
 #
-include ../../Makefile.config
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 CFLAGS += -I../../srv/kbd/include -ggdb
 ,6 → 45,7
 SOURCES = tester.c \
     thread/thread1.c \
     print/print1.c \
+    print/print4.c \
     fault/fault1.c \
     fault/fault2.c \
     ipc/register.c \
 ,6 → 56,9
     ipc/hangup.c \
     loop/loop1.c \
     devmap/devmap1.c \
+    console/console1.c \
+    stdio/stdio1.c \
+    stdio/stdio2.c \
     vfs/vfs1.c \
     debug/debug1.c
 ,13 → 71,13
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OBJECTS) $(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: $(OUTPUT).disasm

 /branches/tracing/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/tracing/uspace/app/tetris/scores.c
 ,6 → 55,9
 #include <stdio.h>
 /* #include <stdlib.h> */
 #include <string.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
+#include <stdlib.h>
 /* #include <time.h> */
 /* #include <term.h> */
 /* #include <unistd.h> */
 ,7 → 117,8
  */
 static void copyhiscore(int dest, int src)
 {
-    strcpy(scores[dest].hs_name, scores[src].hs_name);
+    str_cpy(scores[dest].hs_name, STR_BOUNDS(MAXLOGNAME) + 1,
+        scores[src].hs_name);
     scores[dest].hs_score = scores[src].hs_score;
     scores[dest].hs_level = scores[src].hs_level;
 }
 ,32 → 126,58
 void insertscore(int score, int level)
 {
     int i,j;
-    int key;
+    size_t off;
+    kbd_event_t ev;
     clear_screen();
     moveto(10 , 10);
     puts("Insert your name: ");
-    strncpy(scores[NUMSPOTS - 1].hs_name, "Player", MAXLOGNAME);
-    i = 6;
+    str_cpy(scores[NUMSPOTS - 1].hs_name, STR_BOUNDS(MAXLOGNAME) + 1,
+        "Player");
+    i = 6; off = 6;
     moveto(10 , 28);
     printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");
-    key = getchar();
-    while(key != '\n') {
-        if (key == '\b') {
-            if (i > 0)
-                scores[NUMSPOTS - 1].hs_name[--i] = '\0';
-        } else {
-            if (i < (MAXLOGNAME - 1))
-                scores[NUMSPOTS - 1].hs_name[i++] = key;
-                scores[NUMSPOTS - 1].hs_name[i] = '\0';
+    while (1) {
+        fflush(stdout);
+        if (kbd_get_event(&ev) != EOK)
+            exit(1);
+        if (ev.type == KE_RELEASE)
+            continue;
+        if (ev.key == KC_ENTER || ev.key == KC_NENTER)
+            break;
+        if (ev.key == KC_BACKSPACE) {
+            if (i > 0) {
+                wchar_t uc;
+                --i;
+                while (off > 0) {
+                    --off;
+                    size_t otmp = off;
+                    uc = str_decode(scores[NUMSPOTS - 1].hs_name,
+                        &otmp, STR_BOUNDS(MAXLOGNAME) + 1);
+                    if (uc != U_SPECIAL)
+                        break;
+                }
+                scores[NUMSPOTS - 1].hs_name[off] = '\0';
+            }
+        } else if (ev.c != '\0') {
+            if (i < (MAXLOGNAME - 1)) {
+                if (chr_encode(ev.c, scores[NUMSPOTS - 1].hs_name,
+                    &off, STR_BOUNDS(MAXLOGNAME) + 1) == EOK) {
+                    ++i;
+                }
+                scores[NUMSPOTS - 1].hs_name[off] = '\0';
+            }
         }
         moveto(10 , 28);
         printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");
-        key = getchar();
     }
     scores[NUMSPOTS - 1].hs_score = score;
 ,7 → 197,7
 {
     int i;
     for(i = 0; i < NUMSPOTS; i++) {
-        strncpy(scores[i].hs_name, "HelenOS Team", MAXLOGNAME);
+        str_cpy(scores[i].hs_name, STR_BOUNDS(MAXLOGNAME) + 1, "HelenOS Team");
         scores[i].hs_score = (NUMSPOTS - i) * 200;
         scores[i].hs_level = (i + 1 > MAXLEVEL?MAXLEVEL:i + 1);
     }
 ,7 → 291,7
 /*  change = 0; */
 /*  me = thisuser(); */
 /*  for (i = 0, sp = &scores[0]; i < nscores; i++, sp++) { */
-/*      if (sp->hs_level != level || strcmp(sp->hs_name, me) != 0) */
+/*      if (sp->hs_level != level || str_cmp(sp->hs_name, me) != 0) */
 /*          continue; */
 /*      if (score > sp->hs_score) { */
 /*          (void)printf("%s bettered %s %d score of %d!\n", */
 ,7 → 419,7
 /*       * This is O(n^2), but do you think we care? */
 /*       *\/ */
 /*      for (j = 0, pu = count; j < numnames; j++, pu++) */
-/*          if (strcmp(sp->hs_name, pu->name) == 0) */
+/*          if (str_cmp(sp->hs_name, pu->name) == 0) */
 /*              break; */
 /*      if (j == numnames) { */
 /*          /\* */
 ,7 → 556,7
 /*      if (me != NULL && */
 /*          sp->hs_level == level && */
 /*          sp->hs_score == score && */
-/*          strcmp(sp->hs_name, me) == 0) { */
+/*          str_cmp(sp->hs_name, me) == 0) { */
 /*          putpad(SOstr); */
 /*          highlight = 1; */
 /*      } */

 /branches/tracing/uspace/app/tetris/input.c
 ,7 → 57,9
 #include "tetris.h"
 #include <async.h>
-#include "../../srv/console/console.h"
+#include <ipc/console.h>
+#include <console.h>
+#include <kbd/kbd.h>
 /* return true iff the given timeval is positive */
 #define TV_POS(tv) \
 ,10 → 113,11
         s = NULL;
     if (!lastchar) {
+again:
         if (!getchar_inprog) {
-            cons_phone = get_cons_phone();
+            cons_phone = console_open(true);
             getchar_inprog = async_send_2(cons_phone,
-                CONSOLE_GETCHAR, 0, 0, &charcall);
+                CONSOLE_GETKEY, 0, 0, &charcall);
         }
         if (!s)
             async_wait_for(getchar_inprog, &rc);
 ,7 → 130,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/tracing/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();
 }
 ,20 → 114,14
 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);
-}
 winsize_t winsize;
 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);
 }
 /*
 ,7 → 269,7
     }
     if (cur_so)
         resume_normal();
-    fflush();
+    fflush(stdout);
 }
 /*
 ,7 → 280,7
 scr_msg(char *s, int set)
 {
-    int l = strlen(s);
+    int l = str_size(s);
     moveto(Rows - 2, ((Cols - l) >> 1) - 1);
     if (set)

 /branches/tracing/uspace/app/tetris/scores.h
 ,9 → 45,11
  * Tetris scores.
  */
 #include <sys/time.h>
+#include <string.h>
 #define MAXLOGNAME 16
 struct highscore {
-    char    hs_name[MAXLOGNAME + 1];    /* login name */
+    char    hs_name[STR_BOUNDS(MAXLOGNAME) + 1];    /* login name */
     int hs_score;   /* raw score */
     int hs_level;   /* play level */
 //  time_t  hs_time;    /* time at game end */

 /branches/tracing/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/tracing/uspace/app/tetris/tetris.c
 ,7 → 277,7
 /*          classic = 1; */
 /*          break; */
 /*      case 'k': */
-/*          if (strlen(keys = optarg) != 6) */
+/*          if (str_size(keys = optarg) != 6) */
 /*              usage(); */
 /*          break; */
 /*      case 'l': */
 ,7 → 311,7
                 errx(1, "duplicate command keys specified.");
         }
         if (keys[i] == ' ')
-            strncpy(key_write[i], "<space>", sizeof key_write[i]);
+            str_cpy(key_write[i], sizeof key_write[i], "<space>");
         else {
             key_write[i][0] = keys[i];
             key_write[i][1] = '\0';
 ,7 → 390,7
                     scr_update();
                     scr_msg(key_msg, 0);
                     scr_msg(msg, 1);
-    //              (void) fflush(stdout);
+                    (void) fflush(stdout);
                 } while (rwait((struct timeval *)NULL) == -1);
                 scr_msg(msg, 0);
                 scr_msg(key_msg, 1);

 /branches/tracing/uspace/app/tetris/Makefile
 ,7 → 1,6
-include ../../Makefile.config
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 LIBS = $(LIBC_PREFIX)/libc.a
 ,7 → 19,7
     $(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

 /branches/tracing/uspace/app/klog/Makefile
 ,10 → 29,9
 ## Setup toolchain
 #
-include ../../Makefile.config
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 LIBS = $(LIBC_PREFIX)/libc.a
 ,13 → 53,13
 -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: $(OUTPUT).disasm

 /branches/tracing/uspace/app/klog/klog.c
 ,9 → 27,9
  */
 /** @addtogroup klog KLog
- * @brief   HelenOS KLog
+ * @brief HelenOS KLog
  * @{
- */
+ */
 /**
  * @file
  */
 ,31 → 41,27
 #include <as.h>
 #include <sysinfo.h>
 #include <io/stream.h>
+#include <console.h>
+#include <event.h>
 #include <errno.h>
 #define NAME "klog"
-#define KLOG_SIZE PAGE_SIZE
 /* Pointer to klog area */
-static char *klog;
+static wchar_t *klog;
+static count_t klog_length;
-static void console_wait(void)
-{
-    while (get_cons_phone() < 0)
-        usleep(50000);  // FIXME
-}
 static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
 {
     async_serialize_start();
-    size_t klog_start = (size_t) IPC_GET_ARG1(*call);
-    size_t klog_len = (size_t) IPC_GET_ARG2(*call);
-    size_t klog_stored = (size_t) IPC_GET_ARG3(*call);
-    size_t i;
+    count_t klog_start = (count_t) IPC_GET_ARG1(*call);
+    count_t klog_len = (count_t) IPC_GET_ARG2(*call);
+    count_t klog_stored = (count_t) IPC_GET_ARG3(*call);
+    count_t i;
     for (i = klog_len - klog_stored; i < klog_len; i++)
-        putchar(klog[(klog_start + i) % KLOG_SIZE]);
+        putchar(klog[(klog_start + i) % klog_length]);
     async_serialize_end();
 }
 ,22 → 70,24
 {
     console_wait();
-    klog = (char *) as_get_mappable_page(KLOG_SIZE);
+    count_t klog_pages = sysinfo_value("klog.pages");
+    size_t klog_size = klog_pages * PAGE_SIZE;
+    klog_length = klog_size / sizeof(wchar_t);
+    klog = (wchar_t *) as_get_mappable_page(klog_pages);
     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);
+    int res = ipc_share_in_start_1_0(PHONE_NS, (void *) klog,
+        klog_size, SERVICE_MEM_KLOG);
     if (res != EOK) {
         printf(NAME ": Error initializing memory area\n");
         return -1;
     }
-    int inr = sysinfo_value("klog.inr");
-    int devno = sysinfo_value("klog.devno");
-    if (ipc_register_irq(inr, devno, 0, NULL) != EOK) {
+    if (event_subscribe(EVENT_KLOG, 0) != EOK) {
         printf(NAME ": Error registering klog notifications\n");
         return -1;
     }
 ,7 → 95,7
     async_set_interrupt_received(interrupt_received);
     klog_update();
     async_manager();
     return 0;
 }

 /branches/tracing/uspace/app/trace/trace.c
 ,7 → 49,7
 #include "proto.h"
 #include <ipc/services.h>
 #include "../../srv/vfs/vfs.h"
-#include "../../srv/console/console.h"
+#include <ipc/console.h>
 #include "syscalls.h"
 #include "ipcp.h"
 ,7 → 519,7
     int rc;
     /* Spawn a program loader */
-    ldr = loader_spawn(path);
+    ldr = loader_connect();
     if (ldr == NULL)
         return 0;
 ,7 → 623,7
         V_INTEGER,
         V_INTEGER,
         V_INTEGER,
-        V_INTEGER
+        V_INTEGER
     };
     next_thread_id = 1;
 ,17 → 642,32
     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_CHAR;
-    o = oper_new("getchar", 0, arg_def, V_INTEGER, 2, resp_def);
-    proto_add_oper(p, CONSOLE_GETCHAR, o);
+    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("write", 0, arg_def, V_VOID, 0, resp_def);
+    proto_add_oper(p, CONSOLE_WRITE, o);
     o = oper_new("clear", 0, arg_def, V_VOID, 0, resp_def);
     proto_add_oper(p, CONSOLE_CLEAR, o);
 ,9 → 681,15
     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_style", 2, arg_def, V_INTEGER, 0, resp_def);
-    proto_add_oper(p, CONSOLE_SET_STYLE, o);
+    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);

 /branches/tracing/uspace/app/trace/Makefile
 ,10 → 29,9
 ## Setup toolchain
 #
-include ../../Makefile.config
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 CFLAGS += -I../../srv/kbd/include
 ,7 → 64,7
     $(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

 /branches/tracing/uspace/app/trace/syscalls.c
 ,11 → 59,14
     [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_EVENT_SUBSCRIBE] = { "event_subscribe",    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 },

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4376 → Rev 4377