WebSVN – HelenOS – Path Comparison – / – /branches/network/uspace/app/ Rev 4152 and /branches/network/uspace/app/ Rev 4153

Ignore whitespace Rev 4152 → Rev 4153

 /branches/network/uspace/app/bdsh/input.c
 ,6 → 33,7
 #include <stdlib.h>
 #include <string.h>
 #include <io/stream.h>
+#include <console.h>
 #include "config.h"
 #include "util.h"
 ,21 → 42,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 → 57,11
     if (NULL == usr->line)
         return CL_EFAIL;
-    tmp = cli_strdup(usr->line);
+    tmp = strdup(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 → 70,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);
 ,7 → 94,6
     return rc;
 }
-/* Borrowed from Jiri Svoboda's 'cli' uspace app */
 static void read_line(char *buffer, int n)
 {
     char c;
 ,8 → 113,10
             }
             continue;
         }
-        putchar(c);
-        buffer[chars++] = c;
+        if (c >= ' ') {
+            putchar(c);
+            buffer[chars++] = c;
+        }
     }
     putchar('\n');
     buffer[chars] = '\0';
 ,13 → 130,16
     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 = cli_strdup(line);
+    usr->line = strdup(line);
     return;
 }

 /branches/network/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/network/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
 ,8 → 115,8
 EOF
     [ "${CMDTYPE}" = "module" ] && cat << EOF >> ${OUTDIR}/entry.h
 /* Entry points for the ${CMDNAME} command */
-extern int * ${CMDENTRY}(char **);
-extern void * ${HELPENTRY}(unsigned int);
+extern int ${CMDENTRY}(char **);
+extern void ${HELPENTRY}(unsigned int);
 #endif /* ${defname}_ENTRY_H */
 ,25 → 162,25
 #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)
+void ${HELPENTRY}(unsigned int level)
 {
     printf("This is the %s help for '%s'.\n",
         level ? EXT_HELP : SHORT_HELP, cmdname);
-    return CMD_VOID;
+    return;
 }
 EOF
     [ "${CMDTYPE}" = "module" ] && cat << EOF >> ${OUTDIR}/${CMDNAME}.c
 /* Main entry point for ${CMDNAME}, accepts an array of arguments */
-int * ${CMDENTRY}(char **argv)
+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)
+int ${CMDENTRY}(char **argv, cliuser_t *usr)
 EOF
     cat << EOF >> ${OUTDIR}/${CMDNAME}.c
 {
 ,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/network/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)

 /branches/network/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 → 49,7
 static char *cmdname = "touch";
 /* Dispays help for touch in various levels */
-void * help_cmd_touch(unsigned int level)
+void help_cmd_touch(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' updates access times for files\n", cmdname);
 ,11 → 59,11
                 "created\n", cmdname);
     }
-    return CMD_VOID;
+    return;
 }
 /* Main entry point for touch, accepts an array of arguments */
-int * cmd_touch(char **argv)
+int cmd_touch(char **argv)
 {
     unsigned int argc, i = 0, ret = 0;
     int fd;
 ,7 → 80,7
     }
     for (i = 1; i < argc; i ++) {
-        buff = cli_strdup(argv[i]);
+        buff = strdup(argv[i]);
         dirp = opendir(buff);
         if (dirp) {
             cli_error(CL_ENOTSUP, "%s is a directory", buff);

/branches/network/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/network/uspace/app/bdsh/cmds/modules/touch/entry.h
 ,8 → 2,8
 #define TOUCH_ENTRY_H
 /* Entry points for the touch command */
-extern int * cmd_touch(char **);
-extern void * help_cmd_touch(unsigned int);
+extern int cmd_touch(char **);
+extern void help_cmd_touch(unsigned int);
 #endif /* TOUCH_ENTRY_H */

 /branches/network/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/network/uspace/app/bdsh/cmds/modules/cp/cp_def.h
0,0 → 1,7
{
"cp",
"Copy files and directories",
&cmd_cp,
&help_cmd_cp,
},

 /branches/network/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/network/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/network/uspace/app/bdsh/cmds/modules/mkdir/entry.h
 ,8 → 2,8
 #define MKDIR_ENTRY_H
 /* Entry points for the mkdir command */
-extern int * cmd_mkdir(char **);
-extern void * help_cmd_mkdir(unsigned int);
+extern int cmd_mkdir(char **);
+extern void help_cmd_mkdir(unsigned int);
 #endif /* MKDIR_ENTRY_H */

 /branches/network/uspace/app/bdsh/cmds/modules/mkdir/mkdir.c
 ,7 → 60,7
 };
-void * help_cmd_mkdir(unsigned int level)
+void help_cmd_mkdir(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' creates a new directory\n", cmdname);
 ,7 → 79,7
         cmdname, cmdname);
     }
-    return CMD_VOID;
+    return;
 }
 /* This is kind of clunky, but effective for now */
 ,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 = strdup(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 → 181,7
     return ret;
 }
-int * cmd_mkdir(char **argv)
+int cmd_mkdir(char **argv)
 {
     unsigned int argc, create_parents = 0, i, ret = 0, follow = 0;
     unsigned int verbose = 0;

 /branches/network/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/network/uspace/app/bdsh/cmds/modules/cat/entry.h
 ,8 → 2,8
 #define CAT_ENTRY_H
 /* Entry points for the cat command */
-extern int * cmd_cat(char **);
-extern void * help_cmd_cat(unsigned int);
+extern int cmd_cat(char **);
+extern void help_cmd_cat(unsigned int);
 #endif /* CAT_ENTRY_H */

 /branches/network/uspace/app/bdsh/cmds/modules/cat/cat.c
 ,7 → 59,7
 };
 /* Dispays help for cat in various levels */
-void * help_cmd_cat(unsigned int level)
+void help_cmd_cat(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' shows the contents of files\n", cmdname);
 ,7 → 78,7
         cmdname, cmdname);
     }
-    return CMD_VOID;
+    return;
 }
 static unsigned int cat_file(const char *fname, size_t blen)
 ,13 → 103,11
     }
     do {
-        memset(buff, 0, sizeof(buff));
         bytes = read(fd, buff, blen);
         if (bytes > 0) {
             count += bytes;
-            if (bytes < blen)
-                buff[bytes] = '\0';
-            printf(buff);
+            buff[bytes] = '\0';
+            printf("%s", buff);
             reads++;
         }
     } while (bytes > 0);
 ,12 → 119,6
         return 1;
     }
-    /* Debug stuff, newline not added purposefully */
-    printf("** %s is a file with the size of %ld bytes\n",
-        fname, total);
-    printf( "** %d bytes were read in a buffer of %d bytes in %d reads\n",
-        count, blen, reads);
-    printf("** Read %s\n", count == total ? "Succeeded" : "Failed");
     free(buff);
     return 0;
 ,7 → 125,7
 }
 /* Main entry point for cat, accepts an array of arguments */
-int * cmd_cat(char **argv)
+int cmd_cat(char **argv)
 {
     unsigned int argc, i, ret = 0, buffer = 0;
     int c, opt_ind;

/branches/network/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/network/uspace/app/bdsh/cmds/modules/help/entry.h
 ,7 → 2,7
 #define HELP_ENTRY_H_
 /* Entry points for the help command */
-extern void * help_cmd_help(unsigned int);
-extern int * cmd_help(char *[]);
+extern void help_cmd_help(unsigned int);
+extern int cmd_help(char *[]);
 #endif

 /branches/network/uspace/app/bdsh/cmds/modules/help/help.c
 ,7 → 69,7
     return HELP_IS_RUBBISH;
 }
-void *help_cmd_help(unsigned int level)
+void help_cmd_help(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf(
 ,10 → 86,10
         cmdname, cmdname, cmdname, cmdname);
     }
-    return CMD_VOID;
+    return;
 }
-int *cmd_help(char *argv[])
+int cmd_help(char *argv[])
 {
     module_t *mod;
     builtin_t *cmd;
 ,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;
 ,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/network/uspace/app/bdsh/cmds/modules/help/help_def.h
3,5 → 3,4
"Show help for commands",
&cmd_help,
&help_cmd_help,
0
},

/branches/network/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/network/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/network/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/network/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/network/uspace/app/bdsh/cmds/modules/pwd/entry.h
 ,8 → 4,8
 #include "scli.h"
 /* Entry points for the pwd command */
-extern void * help_cmd_pwd(unsigned int);
-extern int * cmd_pwd(char **);
+extern void help_cmd_pwd(unsigned int);
+extern int cmd_pwd(char **);
 #endif

 /branches/network/uspace/app/bdsh/cmds/modules/pwd/pwd.c
 ,13 → 39,13
 static char * cmdname = "pwd";
-void * help_cmd_pwd(unsigned int level)
+void help_cmd_pwd(unsigned int level)
 {
     printf("`%s' prints your current working directory.\n", cmdname);
-    return CMD_VOID;
+    return;
 }
-int * cmd_pwd(char *argv[])
+int cmd_pwd(char *argv[])
 {
     char *buff;

/branches/network/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/network/uspace/app/bdsh/cmds/modules/module_aliases.h
 ,10 → 12,6
  * the entry point being reached. */
 char *mod_aliases[] = {
-    "exit", "quit",
-    "md", "mkdir",
-    "del", "rm",
-    "dir", "ls",
     NULL, NULL
 };

 /branches/network/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
 ,19 → 138,19
 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;
 }
-void * help_cmd_ls(unsigned int level)
+void help_cmd_ls(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' lists files and directories.\n", cmdname);
 ,10 → 160,10
                 "working directory is used.\n", cmdname);
     }
-    return CMD_VOID;
+    return;
 }
-int * cmd_ls(char **argv)
+int cmd_ls(char **argv)
 {
     unsigned int argc;
     unsigned int scope;
 ,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/network/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/network/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/network/uspace/app/bdsh/cmds/modules/ls/entry.h
 ,8 → 2,8
 #define LS_ENTRY_H
 /* Entry points for the ls command */
-extern int * cmd_ls(char **);
-extern void * help_cmd_ls(unsigned int);
+extern int cmd_ls(char **);
+extern void help_cmd_ls(unsigned int);
 #endif /* LS_ENTRY_H */

 /branches/network/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 → 24,8
 #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
 ,7 → 33,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 → 39,8
 #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}
 };

 /branches/network/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"
 ,7 → 143,7
 }
 /* Dispays help for rm in various levels */
-void * help_cmd_rm(unsigned int level)
+void help_cmd_rm(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' removes files and directories.\n", cmdname);
 ,11 → 160,11
         "Currently, %s is under development, some options don't work.\n",
         cmdname, cmdname);
     }
-    return CMD_VOID;
+    return;
 }
 /* Main entry point for rm, accepts an array of arguments */
-int * cmd_rm(char **argv)
+int cmd_rm(char **argv)
 {
     unsigned int argc;
     unsigned int i, scope, ret = 0;
 ,7 → 218,11
     while (NULL != argv[i]) {
         len = strlen(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/network/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/network/uspace/app/bdsh/cmds/modules/rm/entry.h
 ,8 → 2,8
 #define RM_ENTRY_H
 /* Entry points for the rm command */
-extern int * cmd_rm(char **);
-extern void * help_cmd_rm(unsigned int);
+extern int cmd_rm(char **);
+extern void help_cmd_rm(unsigned int);
 #endif /* RM_ENTRY_H */

/branches/network/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/network/uspace/app/bdsh/cmds/builtins/cd/cd.c
 ,7 → 42,7
 static char * cmdname = "cd";
-void * help_cmd_cd(unsigned int level)
+void help_cmd_cd(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' changes the current working directory.\n", cmdname);
 ,12 → 53,12
             cmdname, cmdname);
     }
-    return CMD_VOID;
+    return;
 }
 /* This is a very rudamentary 'cd' command. It is not 'link smart' (yet) */
-int * cmd_cd(char **argv, cliuser_t *usr)
+int cmd_cd(char **argv, cliuser_t *usr)
 {
     int argc, rc = 0;

 /branches/network/uspace/app/bdsh/cmds/builtins/cd/entry.h
 ,8 → 4,8
 #include "scli.h"
 /* Entry points for the cd command */
-extern void * help_cmd_cd(unsigned int);
-extern int * cmd_cd(char **, cliuser_t *);
+extern void help_cmd_cd(unsigned int);
+extern int cmd_cd(char **, cliuser_t *);
 #endif

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

/branches/network/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/network/uspace/app/bdsh/cmds/cmds.h
 ,17 → 19,16
 #define BUFF_SMALL  255
 /* Return macros for int type entry points */
-#define CMD_FAILURE (int*)1
+#define CMD_FAILURE 1
 #define CMD_SUCCESS 0
-#define CMD_VOID (void *)NULL
 /* Types for module command entry and help */
-typedef int * (* mod_entry_t)(char **);
-typedef void * (* mod_help_t)(unsigned int);
+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);
+typedef int (* builtin_entry_t)(char **, cliuser_t *);
+typedef void (* builtin_help_t)(unsigned int);
 /* Module structure */
 typedef struct {
 ,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/network/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;

 /branches/network/uspace/app/bdsh/config.h
 ,15 → 1,18
-/* Various things that are used in many files
- * Various temporary port work-arounds are addressed in __HELENOS__ , this
- * serves as a convenience and later as a guide to make "phony.h" for future
- * ports */
+/* 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 0
+#define EXIT_FAILURE 1
+#endif
 /* Work around for getenv() */
-#define PATH "/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin"
+#define PATH "/srv:/app"
 #define PATH_DELIM ":"
 /* Used in many places */
 ,7 → 29,7
 #define PACKAGE_BUGREPORT "echo@echoreply.us"
 #define PACKAGE_NAME "bdsh"
 #define PACKAGE_STRING "The brain dead shell"
-#define PACKAGE_TARNAME "scli"
+#define PACKAGE_TARNAME "bdsh"
 #define PACKAGE_VERSION "0.0.1"

 /branches/network/uspace/app/bdsh/README
 ,12 → 57,12
 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);
+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);
+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.
 ,9 → 153,7
 : Change your "usage()" command as shown:
      -- void usage(...)
-     ++ void * help_cmd_foo(unsigned int level)
-     -- return;
-     ++ retrn CMD_VOID;
+     ++ 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
 ,33 → 161,19
 : Change the programs "main()" as shown:
      -- int main(int argc, char **argv)
-     ++ int * cmd_foo(char **argv)
+     ++ int cmd_foo(char **argv)
      -- return 1;
      ++ return CMD_FAILURE;
      -- return 0;
      ++ return CMD_SUCCESS;
-     If main() returns an int that is not 1 or 0 (e.g. 127), cast it as
-     such:
-     -- return 127;
-     ++ return (int *) 127;
-     NOTE: _ONLY_ the main and help entry points need to return int * or
-     void *, respectively. Also take note that argc has changed. The type
-     for entry points may soon change.
      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)
+     ++ int cmd_foo(char **argv)
-     Similararly, do not try to return CMD_VOID within the modules main
-     entry point. If somehow you escape the compiler yelling at you, you
-     will surely see pretty blue and yellow fireworks once its reached.
 : Don't expose more than the entry and help points:
      -- void my_function(int n)
      ++ static void my_function(int n)

 /branches/network/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>
 ,190 → 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);
-}
-/*
- * Take a previously allocated string (s1), re-size it to accept s2 and copy
- * the contents of s2 into s1.
- * Return -1 on failure, or the length of the copied string on success.
- */
-int cli_redup(char **s1, const char *s2)
-{
-    size_t len = strlen(s2) + 1;
-    if (! len)
-        return -1;
-    *s1 = realloc(*s1, len);
-    if (*s1 == NULL) {
-        cli_errno = CL_ENOMEM;
-        return -1;
-    }
-    memset(*s1, 0, sizeof(*s1));
-    memcpy(*s1, s2, len);
-    cli_errno = CL_EOK;
-    return (int) len;
-}
-/* An asprintf() for formatting paths, similar to asprintf() but ensures
- * the returned allocated string is <= PATH_MAX. On failure, an attempt
- * is made to return the original string (if not null) unmodified.
- *
- * Returns: Length of the new string on success, 0 if the string was handed
- * back unmodified, -1 on failure. On failure, cli_errno is set.
- *
- * We do not use POSIX_PATH_MAX, as it is typically much smaller than the
- * PATH_MAX defined by the kernel.
- *
- * Use this like:
- * if (1 > cli_psprintf(&char, "%s/%s", foo, bar)) {
- *   cli_error(cli_errno, "Failed to format path");
- *   stop_what_your_doing_as_your_out_of_memory();
- * }
- */
-int cli_psprintf(char **s1, const char *fmt, ...)
-{
-    va_list ap;
-    size_t needed, base = PATH_MAX + 1;
-    int skipped = 0;
-    char *orig = NULL;
-    char *tmp = (char *) malloc(base);
-    /* Don't even touch s1, not enough memory */
-    if (NULL == tmp) {
-        cli_errno = CL_ENOMEM;
-        return -1;
-    }
-    /* If re-allocating s1, save a copy in case we fail */
-    if (NULL != *s1)
-        orig = cli_strdup(*s1);
-    /* Print the string to tmp so we can determine the size that
-     * we actually need */
-    memset(tmp, 0, sizeof(tmp));
-    va_start(ap, fmt);
-    /* vsnprintf will return the # of bytes not written */
-    skipped = vsnprintf(tmp, base, fmt, ap);
-    va_end(ap);
-    /* realloc/alloc s1 to be just the size that we need */
-    needed = strlen(tmp) + 1;
-    *s1 = realloc(*s1, needed);
-    if (NULL == *s1) {
-        /* No string lived here previously, or we failed to
-         * make a copy of it, either way there's nothing we
-         * can do. */
-        if (NULL == *orig) {
-            cli_errno = CL_ENOMEM;
-            return -1;
-        }
-        /* We can't even allocate enough size to restore the
-         * saved copy, just give up */
-        *s1 = realloc(*s1, strlen(orig) + 1);
-        if (NULL == *s1) {
-            free(tmp);
-            free(orig);
-            cli_errno = CL_ENOMEM;
-            return -1;
-        }
-        /* Give the string back as we found it */
-        memset(*s1, 0, sizeof(*s1));
-        memcpy(*s1, orig, strlen(orig) + 1);
-        free(tmp);
-        free(orig);
-        cli_errno = CL_ENOMEM;
-        return 0;
-    }
-    /* Ok, great, we have enough room */
-    memset(*s1, 0, sizeof(*s1));
-    memcpy(*s1, tmp, needed);
-    free(tmp);
-    /* Free tmp only if s1 was reallocated instead of allocated */
-    if (NULL != orig)
-        free(orig);
-    if (skipped) {
-        /* s1 was bigger than PATH_MAX when expanded, however part
-         * of the string was printed. Tell the caller not to use it */
-        cli_errno = CL_ETOOBIG;
-        return -1;
-    }
-    /* Success! */
-    cli_errno = CL_EOK;
-    return (int) needed;
-}
-/* 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)
 {
 ,10 → 74,7
     if (NULL == usr->cwd)
         snprintf(usr->cwd, PATH_MAX, "(unknown)");
-    if (1 < cli_psprintf(&usr->prompt, "%s # ", usr->cwd)) {
-        cli_error(cli_errno, "Failed to set prompt");
-        return 1;
-    }
+    asprintf(&usr->prompt, "%s # ", usr->cwd);
     return 0;
 }

 /branches/network/uspace/app/bdsh/util.h
 ,13 → 3,6
 #include "scli.h"
-/* Internal string handlers */
-extern char * cli_strdup(const char *);
-extern int cli_redup(char **, const char *);
-extern int cli_psprintf(char **, 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/network/uspace/app/bdsh/exec.c
 ,13 → 46,13
 #include "errors.h"
 /* FIXME: Just have find_command() return an allocated string */
-char *found;
+static char *found;
 static char *find_command(char *);
-static unsigned int try_access(const char *);
+static int try_access(const char *);
 /* work-around for access() */
-static unsigned int try_access(const char *f)
+static int try_access(const char *f)
 {
     int fd;
 ,10 → 80,10
         return (char *) cmd;
     }
-    path_tok = cli_strdup(PATH);
+    path_tok = strdup(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) {
             cli_error(CL_ENOTSUP,
 ,7 → 91,7
                 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 */
 ,14 → 114,14
     task_id_t tid;
     char *tmp;
-    tmp = cli_strdup(find_command(cmd));
+    tmp = strdup(find_command(cmd));
     free(found);
-    tid = task_spawn((const char *)tmp, (const char **)argv);
+    tid = task_spawn((const char *)tmp, argv);
     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/network/uspace/app/bdsh/scli.c
 ,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
 ,8 → 52,8
 const char *progname = PACKAGE_NAME;
 /* These are not exposed, even to builtins */
-static int cli_init(cliuser_t *usr);
-static void cli_finit(cliuser_t *usr);
+static int cli_init(cliuser_t *);
+static void cli_finit(cliuser_t *);
 /* Constructor */
 static int cli_init(cliuser_t *usr)
 ,6 → 93,7
         get_input(&usr);
         if (NULL != usr.line) {
             ret = tok_input(&usr);
+            cli_set_prompt(&usr);
             usr.lasterr = ret;
         }
     }

 /branches/network/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 → 55,14
     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/quit/quit.c \
     cmds/modules/mkdir/mkdir.c \
     cmds/modules/rm/rm.c \
     cmds/modules/cat/cat.c \
 ,6 → 69,9
     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 \
 ,7 → 104,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/network/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,17
 #include <fcntl.h>
 #include <task.h>
 #include <malloc.h>
+#include <macros.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;
     while (rc < 0) {
-        rc = mount(fstype, "/", "initrd");
+        rc = mount(fstype, "/", "initrd", IPC_FLAG_BLOCKING);
         switch (rc) {
         case EOK:
             printf(NAME ": Root filesystem mounted\n");
 ,8 → 67,6
         case ENOENT:
             printf(NAME ": Unknown filesystem type (%s)\n", fstype);
             return false;
-        default:
-            sleep(5);   // FIXME
         }
     }
 ,15 → 76,17
 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)) {
+        /* Add reasonable delay to avoid intermixed klog output. */
+        usleep(10000);
+    } else {
+        printf(NAME ": Error spawning %s\n", fname);
     }
 }
 ,23 → 93,25
 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;
     }
-    // FIXME: spawn("/sbin/pci");
-    spawn("/sbin/fb");
-    spawn("/sbin/kbd");
+    // FIXME: spawn("/srv/pci");
+    spawn("/srv/fb");
+    spawn("/srv/kbd");
     spawn("/sbin/networking_startup");
-    spawn("/sbin/console");
+    spawn("/srv/console");
+    spawn("/srv/fhc");
+    spawn("/srv/obio");
     console_wait();
     version_print();
-    spawn("/sbin/bdsh");
+    spawn("/app/klog");
+    spawn("/app/bdsh");
     return 0;
 }

 /branches/network/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/network/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/network/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/network/uspace/app/tester/console/console1.def
0,0 → 1,6
{
"console1",
"Console color test",
&test_console1,
true
},

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

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

 /branches/network/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/network/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/network/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}
 };
 ,7 → 137,7
                 if (c == 'a')
                     break;
-            if (c > 'a')
+            if (test->name == NULL)
                 printf("Unknown test\n\n");
             else
                 run_test(test);
 ,6 → 151,8
         }
     }
+    return 0;
 }
 /** @}

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

 /branches/network/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/network/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/network/uspace/app/tester/devmap/devmap1.c
 ,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/network/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/network/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)))
 ,13 → 69,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/network/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/network/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) \
 ,10 → 112,11
         s = NULL;
     if (!lastchar) {
+again:
         if (!getchar_inprog) {
-            cons_phone = get_cons_phone();
+            cons_phone = get_console_phone();
             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 → 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/network/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/network/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/network/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 → 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/network/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
 ,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/network/uspace/app/klog/klog.c
 ,9 → 27,9
  */
 /** @addtogroup klog KLog
- * @brief   HelenOS KLog
+ * @brief HelenOS KLog
  * @{
- */
+ */
 /**
  * @file
  */
 ,12 → 50,6
 /* Pointer to klog area */
 static char *klog;
-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();
 ,14 → 80,13
         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) {
-        printf(NAME ": Error registering klog notifications\n");
-        return -1;
-    }
+//  int inr = sysinfo_value("klog.inr");
+//  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();

 /branches/network/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/network/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/network/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/network/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/network/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/network/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/network/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/network/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/network/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/network/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/network/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/network/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/network/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." }
+};
+/** @}
+ */

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4152 → Rev 4153