Changeset a33f0a6 for uspace/app – HelenOS

uspace/app/bdsh/Makefile

-              r52a79081
+              ra33f0a6
         cmds/mod_cmds.c \
         cmds/builtin_cmds.c \
+        compl.c \
         errors.c \
         input.c \
         util.c \
         exec.c \
+        scli.c
+        scli.c \
+        tok.c
 include $(USPACE_PREFIX)/Makefile.common

uspace/app/bdsh/cmds/builtin_cmds.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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 "cmds.h"
 #include "builtin_aliases.h"
+#include "scli.h"
 extern volatile unsigned int cli_interactive;
 …
                 cmd->help(extended);
                 return CL_EOK;
         } else
+        } else {
                 return CL_ENOENT;
+        }
+}
 int run_builtin(int builtin, char *argv[], cliuser_t *usr)
+int run_builtin(int builtin, char *argv[], cliuser_t *usr, iostate_t *new_iostate)
+{
+        int rc;
         builtin_t *cmd = builtins;
         cmd += builtin;
+        iostate_t *old_iostate = get_iostate();
+        set_iostate(new_iostate);
+        if (NULL != cmd->entry) {
+                rc = ((int)cmd->entry(argv, usr));
+        } else {
+                rc = CL_ENOENT;
+        }
+        set_iostate(old_iostate);
+        if (NULL != cmd->entry)
+                return((int)cmd->entry(argv, usr));
+        return CL_ENOENT;
+        return rc;
+}

uspace/app/bdsh/cmds/builtins/cd/cd.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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.
  */

uspace/app/bdsh/cmds/builtins/exit/exit.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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.
  */

uspace/app/bdsh/cmds/cmds.h

-              r52a79081
+              ra33f0a6
+/*
+ * Copyright (c) 2008 Tim Post
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - 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.
+ */
 #ifndef CMDS_H
 #define CMDS_H
 …
 extern char *alias_for_module(const char *);
 extern int help_module(int, unsigned int);
 extern int run_module(int, char *[]);
+extern int run_module(int, char *[], iostate_t *);
 /* Prototypes for builtin launchers */
 …
 extern char *alias_for_builtin(const char *);
 extern int help_builtin(int, unsigned int);
 extern int run_builtin(int, char *[], cliuser_t *);
+extern int run_builtin(int, char *[], cliuser_t *, iostate_t *);
 #endif

uspace/app/bdsh/cmds/mod_cmds.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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.
  */
 …
                 mod->help(extended);
                 return CL_EOK;
         } else
+        } else {
                 return CL_ENOENT;
+        }
+}
 /* Invokes the module entry point modules[module], passing argv[] as an argument
  * stack. */
 int run_module(int module, char *argv[])
+int run_module(int module, char *argv[], iostate_t *new_iostate)
+{
+        int rc;
         module_t *mod = modules;
         mod += module;
+        iostate_t *old_iostate = get_iostate();
+        set_iostate(new_iostate);
+        if (NULL != mod->entry)
+                return ((int)mod->entry(argv));
+        if (NULL != mod->entry) {
+                rc = ((int)mod->entry(argv));
+        } else {
+                rc = CL_ENOENT;
+        }
+        set_iostate(old_iostate);
         return CL_ENOENT;
+        return rc;
+}

uspace/app/bdsh/cmds/modules/bdd/bdd.c

r52a79081	ra33f0a6
102	102	}
103	103
104		rc = block_init(handle, 2048);
	104	rc = block_init(EXCHANGE_SERIALIZE, handle, 2048);
105	105	if (rc != EOK) {
106	106	printf("%s: Error initializing libblock.\n", cmdname);

uspace/app/bdsh/cmds/modules/cat/cat.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * Copyright (c) 2011, Martin Sucha
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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.
  */
 …
 static sysarg_t console_rows = 0;
 static bool should_quit = false;
+static console_ctrl_t *console = NULL;
 static struct option const long_options[] = {
 …
 static void waitprompt()
+{
+        console_set_pos(fphone(stdout), 0, console_rows-1);
+        console_set_color(fphone(stdout), COLOR_BLUE, COLOR_WHITE, 0);
+        console_set_pos(console, 0, console_rows-1);
+        console_set_color(console, COLOR_BLUE, COLOR_WHITE, 0);
         printf("ENTER/SPACE/PAGE DOWN - next page, "
                "ESC/Q - quit, C - continue unpaged");
         fflush(stdout);
+        console_set_style(fphone(stdout), STYLE_NORMAL);
+        console_set_style(console, STYLE_NORMAL);
+}
 static void waitkey()
+{
         console_event_t ev;
+        kbd_event_t ev;
         while (true) {
                 if (!console_get_event(fphone(stdin), &ev)) {
+                if (!console_get_kbd_event(console, &ev)) {
                         return;
+                }
 …
 static void newpage()
+{
         console_clear(fphone(stdout));
+        console_clear(console);
         chars_remaining = console_cols;
         lines_remaining = console_rows-1;
+        lines_remaining = console_rows - 1;
+}
 …
         console_rows = 0;
         should_quit = false;
+        console = console_init(stdin, stdout);
         argc = cli_count_args(argv);
 …
         if (more) {
                 rc = console_get_size(fphone(stdout), &cols, &rows);
+                rc = console_get_size(console, &cols, &rows);
                 if (rc != EOK) {
                         printf("%s - cannot get console size\n", cmdname);

uspace/app/bdsh/cmds/modules/cp/cp.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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.
  */
 …
         size_t blen, int vb)
+{
         int fd1, fd2, bytes = 0;
         off64_t total = 0;
+        int fd1, fd2, bytes;
+        off64_t total;
         int64_t copied = 0;
         char *buff = NULL;
 …
+        }
+        for (;;) {
+                ssize_t res;
+                size_t written = 0;
+                bytes = read(fd1, buff, blen);
+                if (bytes <= 0)
+        while ((bytes = read_all(fd1, buff, blen)) > 0) {
+                if ((bytes = write_all(fd2, buff, 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 + written, res);
-                        if (bytes < 0)
-                                goto err;
-                        written += bytes;
-                        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%zd 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;

uspace/app/bdsh/cmds/modules/help/help.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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.
  */

uspace/app/bdsh/cmds/modules/kcon/kcon.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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 <stdlib.h>
 #include <io/console.h>
-#include <vfs/vfs.h>
 #include "config.h"
 #include "util.h"
 …
 static const char *cmdname = "kcon";
 /* Dispays help for kcon in various levels */
+/* Display help for kcon in various levels */
 void help_cmd_kcon(unsigned int level)
+{
         printf("`kcon' switches to the kernel debug console.\n");
+        if (level != HELP_SHORT) {
+                printf("Usage:  %s\n", cmdname);
+        }
+        if (level != HELP_SHORT)
+                printf("Usage: %s\n", cmdname);
         return;
+}
 …
 int cmd_kcon(char **argv)
+{
+        unsigned int argc;
+        argc = cli_count_args(argv);
+        unsigned int argc = cli_count_args(argv);
         if (argc != 1) {
                 printf("%s - incorrect number of arguments. Try `%s --help'\n",
                         cmdname, cmdname);
+                    cmdname, cmdname);
                 return CMD_FAILURE;
+        }
+        console_kcon_enable(fphone(stdout));
+        return CMD_SUCCESS;
+        if (console_kcon())
+                return CMD_SUCCESS;
+        else
+                return CMD_FAILURE;
+}

uspace/app/bdsh/cmds/modules/ls/ls.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * 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.
  */
 …
                 /* fill the name field */
                 tosort[nbdirs].name = (char *) malloc(str_length(dp->d_name) + 1);
+                tosort[nbdirs].name = (char *) malloc(str_size(dp->d_name) + 1);
                 if (!tosort[nbdirs].name) {
                         cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
                         goto out;
+                }
                 str_cpy(tosort[nbdirs].name, str_length(dp->d_name) + 1, dp->d_name);
+                str_cpy(tosort[nbdirs].name, str_size(dp->d_name) + 1, dp->d_name);
                 len = snprintf(buff, PATH_MAX - 1, "%s/%s", d, tosort[nbdirs].name);
                 buff[len] = '\0';

uspace/app/bdsh/cmds/modules/mkdir/mkdir.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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>

uspace/app/bdsh/cmds/modules/mkfile/mkfile.c

r52a79081	ra33f0a6
26	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	27	*/
28
29	28
30	29	#include <stdio.h>

uspace/app/bdsh/cmds/modules/module_aliases.h

-              r52a79081
+              ra33f0a6
+/*
+ * Copyright (c) 2008 Tim Post
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - 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.
+ */
 #ifndef MODULE_ALIASES_H
 #define MODULE_ALIASES_H

uspace/app/bdsh/cmds/modules/modules.h

-              r52a79081
+              ra33f0a6
+/*
+ * Copyright (c) 2008 Tim Post
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - 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.
+ */
 #ifndef MODULES_H
 #define MODULES_H

uspace/app/bdsh/cmds/modules/mount/mount.c

-              r52a79081
+              ra33f0a6
+{
         static char helpfmt[] =
             "Usage:  %s <fstype> <mp> <dev> [<moptions>]\n";
+            "Usage:  %s <fstype> <mp> [dev] [<moptions>]\n";
         if (level == HELP_SHORT) {
                 printf("'%s' mounts a file system.\n", cmdname);
 …
         unsigned int argc;
         const char *mopts = "";
+        const char *dev = "";
         int rc, c, opt_ind;
 …
+        }
         if ((argc < 4) || (argc > 5)) {
+        if ((argc < 3) || (argc > 5)) {
                 printf("%s: invalid number of arguments. Try `mount --help'\n",
                     cmdname);
                 return CMD_FAILURE;
+        }
+        if (argc > 3)
+                dev = argv[3];
         if (argc == 5)
                 mopts = argv[4];
         rc = mount(argv[1], argv[2], argv[3], mopts, 0);
+        rc = mount(argv[1], argv[2], dev, mopts, 0);
         if (rc != EOK) {
                 printf("Unable to mount %s filesystem to %s on %s (rc=%d)\n",

uspace/app/bdsh/cmds/modules/pwd/pwd.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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.
  */

uspace/app/bdsh/cmds/modules/rm/rm.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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.
  */

uspace/app/bdsh/cmds/modules/sleep/sleep.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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.
  */

uspace/app/bdsh/cmds/modules/touch/touch.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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.
  */

uspace/app/bdsh/compl.h

-              r52a79081
+              ra33f0a6
 /*
  * Copyright (c) 2009 Martin Decky
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
 …
  */
+#include <test.h>
+#ifndef COMPL_H
+#define COMPL_H
+const char *test_sse1(void)
+{
+        return NULL;
+}
+#include <tinput.h>
+extern tinput_compl_ops_t compl_ops;
+#endif

uspace/app/bdsh/config.h

-              r52a79081
+              ra33f0a6
+/*
+ * Copyright (c) 2008 Tim Post
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - 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.
+ */
 /* Various things that are used in many places including a few
  * tidbits left over from autoconf prior to the HelenOS port */
 …
 #define EXIT_FAILURE 1
 #endif
-/* Work around for getenv() */
-#define PATH "/srv:/app"
-#define PATH_DELIM ":"
 /* Used in many places */

uspace/app/bdsh/errors.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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 "errors.h"
 #include "errstr.h"
+#include "scli.h"
 volatile int cli_errno = CL_EOK;

uspace/app/bdsh/errors.h

-              r52a79081
+              ra33f0a6
+/*
+ * Copyright (c) 2008 Tim Post
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - 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.
+ */
 #ifndef ERRORS_H
 #define ERRORS_H

uspace/app/bdsh/errstr.h

-              r52a79081
+              ra33f0a6
+/*
+ * Copyright (c) 2008 Tim Post
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - 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.
+ */
 #ifndef ERRSTR_H
 #define ERRSTR_H

uspace/app/bdsh/exec.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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.
  */
 …
 static int try_access(const char *);
+const char *search_dir[] = { "/app", "/srv", NULL };
 /* work-around for access() */
 static int try_access(const char *f)
 …
 static char *find_command(char *cmd)
+{
+        char *path_tok;
+        char *path[PATH_MAX];
+        int n = 0, i = 0;
+        size_t x = str_size(cmd) + 2;
+        size_t i;
         found = (char *)malloc(PATH_MAX);
 …
+        }
-        path_tok = str_dup(PATH);
-        /* Extract the PATH env to a path[] array */
-        path[n] = strtok(path_tok, PATH_DELIM);
-        while (NULL != path[n]) {
-                if ((str_size(path[n]) + x ) > PATH_MAX) {
-                        cli_error(CL_ENOTSUP,
-                                "Segment %d of path is too large, search ends at segment %d",
-                                n, n-1);
-                        break;
+                }
-                path[++n] = strtok(NULL, PATH_DELIM);
+        }
         /* We now have n places to look for the command */
         for (i=0; path[i]; i++) {
+        for (i = 0; search_dir[i] != NULL; i++) {
                 memset(found, 0, sizeof(found));
                 snprintf(found, PATH_MAX, "%s/%s", path[i], cmd);
+                snprintf(found, PATH_MAX, "%s/%s", search_dir[i], cmd);
                 if (-1 != try_access(found)) {
-                        free(path_tok);
                         return (char *) found;
+                }
 …
         /* We didn't find it, just give it back as-is. */
-        free(path_tok);
         return (char *) cmd;
+}
 unsigned int try_exec(char *cmd, char **argv)
+unsigned int try_exec(char *cmd, char **argv, iostate_t *io)
+{
         task_id_t tid;
         task_exit_t texit;
         char *tmp;
+        int rc, retval;
+        int rc, retval, i;
+        fdi_node_t file_nodes[3];
+        fdi_node_t *file_nodes_p[4];
+        FILE *files[3];
         tmp = str_dup(find_command(cmd));
         free(found);
+        files[0] = io->stdin;
+        files[1] = io->stdout;
+        files[2] = io->stderr;
+        for (i = 0; i < 3 && files[i] != NULL; i++) {
+                if (fnode(files[i], &file_nodes[i]) == EOK) {
+                        file_nodes_p[i] = &file_nodes[i];
+                }
+                else {
+                        file_nodes_p[i] = NULL;
+                }
+        }
+        file_nodes_p[i] = NULL;
         rc = task_spawnv(&tid, tmp, (const char **) argv);
+        rc = task_spawnvf(&tid, tmp, (const char **) argv, file_nodes_p);
         free(tmp);

uspace/app/bdsh/exec.h

-              r52a79081
+              ra33f0a6
+/*
+ * Copyright (c) 2008 Tim Post
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - 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.
+ */
 #ifndef EXEC_H
 #define EXEC_H
 #include <task.h>
+#include "scli.h"
+extern unsigned int try_exec(char *, char **);
+extern const char *search_dir[];
+extern unsigned int try_exec(char *, char **, iostate_t *);
 #endif

uspace/app/bdsh/input.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
+ * Copyright (c) 2011 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:
+ * 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 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.
+ *
+ * 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.
+ * 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 "config.h"
+#include "compl.h"
 #include "util.h"
 #include "scli.h"
 …
 #include "errors.h"
 #include "exec.h"
+#include "tok.h"
 extern volatile unsigned int cli_quit;
 …
 /** Text input field. */
 static tinput_t *tinput;
+/* Private helpers */
+static int run_command(char **, cliuser_t *, iostate_t *);
+static void print_pipe_usage(void);
 /* Tokenizes input from console, sees if the first word is a built-in, if so
  * invokes the built-in entry point (a[0]) passing all arguments in a[] to
  * the handler */
 int tok_input(cliuser_t *usr)
+int process_input(cliuser_t *usr)
+{
         char *cmd[WORD_MAX];
-        int n = 0, i = 0;
         int rc = 0;
+        char *tmp;
+        tokenizer_t tok;
+        int i, pipe_count, processed_pipes;
+        int pipe_pos[2];
+        char **actual_cmd;
+        char *redir_from = NULL;
+        char *redir_to = NULL;
         if (NULL == usr->line)
                 return CL_EFAIL;
+        tmp = str_dup(usr->line);
+        cmd[n] = strtok(tmp, " ");
+        while (cmd[n] && n < WORD_MAX) {
+                cmd[++n] = strtok(NULL, " ");
+        }
+        /* We have rubbish */
+        if (NULL == cmd[0]) {
+                rc = CL_ENOENT;
+                goto finit;
+        }
+        /* Its a builtin command ? */
+        if ((i = (is_builtin(cmd[0]))) > -1) {
+                rc = run_builtin(i, cmd, usr);
+                goto finit;
+        /* Its a module ? */
+        } else if ((i = (is_module(cmd[0]))) > -1) {
+                rc = run_module(i, cmd);
+                goto finit;
+        }
+        /* See what try_exec thinks of it */
+        rc = try_exec(cmd[0], cmd);
+        rc = tok_init(&tok, usr->line, cmd, WORD_MAX);
+        if (rc != EOK) {
+                goto finit;
+        }
+        rc = tok_tokenize(&tok);
+        if (rc != EOK) {
+                goto finit;
+        }
+        /* Until full support for pipes is implemented, allow for a simple case:
+         * [from <file> |] command [| to <file>]
+         *
+         * First find the pipes and check that there are no more
+         */
+        int cmd_length = 0;
+        for (i = 0, pipe_count = 0; cmd[i] != NULL; i++, cmd_length++) {
+                if (cmd[i][0] == '|') {
+                        if (pipe_count >= 2) {
+                                print_pipe_usage();
+                                rc = ENOTSUP;
+                                goto finit;
+                        }
+                        pipe_pos[pipe_count] = i;
+                        pipe_count++;
+                }
+        }
+        actual_cmd = cmd;
+        processed_pipes = 0;
+        /* Check if the first part (from <file> |) is present */
+        if (pipe_count > 0 && pipe_pos[0] == 2 && str_cmp(cmd[0], "from") == 0) {
+                /* Ignore the first three tokens (from, file, pipe) and set from */
+                redir_from = cmd[1];
+                actual_cmd = cmd + 3;
+                processed_pipes++;
+        }
+        /* Check if the second part (| to <file>) is present */
+        if ((pipe_count - processed_pipes) > 0 &&
+            pipe_pos[processed_pipes] == cmd_length - 3 &&
+            str_cmp(cmd[cmd_length-2], "to") == 0) {
+                /* Ignore the last three tokens (pipe, to, file) and set to */
+                redir_to = cmd[cmd_length-1];
+                cmd[cmd_length-3] = NULL;
+                cmd_length -= 3;
+                processed_pipes++;
+        }
+        if (processed_pipes != pipe_count) {
+                print_pipe_usage();
+                rc = ENOTSUP;
+                goto finit;
+        }
+        if (actual_cmd[0] == NULL) {
+                print_pipe_usage();
+                rc = ENOTSUP;
+                goto finit;
+        }
+        iostate_t new_iostate = {
+                .stdin = stdin,
+                .stdout = stdout,
+                .stderr = stderr
+        };
+        FILE *from = NULL;
+        FILE *to = NULL;
+        if (redir_from) {
+                from = fopen(redir_from, "r");
+                if (from == NULL) {
+                        printf("Cannot open file %s\n", redir_from);
+                        rc = errno;
+                        goto finit_with_files;
+                }
+                new_iostate.stdin = from;
+        }
+        if (redir_to) {
+                to = fopen(redir_to, "w");
+                if (to == NULL) {
+                        printf("Cannot open file %s\n", redir_to);
+                        rc = errno;
+                        goto finit_with_files;
+                }
+                new_iostate.stdout = to;
+        }
+        rc = run_command(actual_cmd, usr, &new_iostate);
+finit_with_files:
+        if (from != NULL) {
+                fclose(from);
+        }
+        if (to != NULL) {
+                fclose(to);
+        }
 finit:
         if (NULL != usr->line) {
 …
                 usr->line = (char *) NULL;
+        }
+        if (NULL != tmp)
+                free(tmp);
+        tok_fini(&tok);
         return rc;
+}
+void print_pipe_usage()
+{
+        printf("Invalid syntax!\n");
+        printf("Usage of redirection (pipes in the future):\n");
+        printf("from filename | command ...\n");
+        printf("from filename | command ... | to filename\n");
+        printf("command ... | to filename\n");
+}
+int run_command(char **cmd, cliuser_t *usr, iostate_t *new_iostate)
+{
+        int id = 0;
+        /* We have rubbish */
+        if (NULL == cmd[0]) {
+                return CL_ENOENT;
+        }
+        /* Is it a builtin command ? */
+        if ((id = (is_builtin(cmd[0]))) > -1) {
+                return run_builtin(id, cmd, usr, new_iostate);
+        }
+        /* Is it a module ? */
+        if ((id = (is_module(cmd[0]))) > -1) {
+                return run_module(id, cmd, new_iostate);
+        }
+        /* See what try_exec thinks of it */
+        return try_exec(cmd[0], cmd, new_iostate);
+}
 …
         char *str;
         int rc;
+        fflush(stdout);
+        console_set_style(fphone(stdout), STYLE_EMPHASIS);
+        printf("%s", usr->prompt);
+        fflush(stdout);
+        console_set_style(fphone(stdout), STYLE_NORMAL);
+        tinput_set_prompt(tinput, usr->prompt);
         rc = tinput_read(tinput, &str);
 …
+        }
+        tinput_set_compl_ops(tinput, &compl_ops);
         return 0;
+}

uspace/app/bdsh/input.h

-              r52a79081
+              ra33f0a6
+/*
+ * Copyright (c) 2008 Tim Post
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - 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.
+ */
 #ifndef INPUT_H
 #define INPUT_H
 …
 extern void get_input(cliuser_t *);
 extern int tok_input(cliuser_t *);
+extern int process_input(cliuser_t *);
 extern int input_init(void);

uspace/app/bdsh/scli.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+/*
+ * Copyright (c) 2008 Tim Post
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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.
  */
 …
 /* See scli.h */
 static cliuser_t usr;
+static iostate_t *iostate;
+static iostate_t stdiostate;
 /* Globals that are modified during start-up that modules/builtins
 …
+}
+iostate_t *get_iostate(void)
+{
+        return iostate;
+}
+void set_iostate(iostate_t *ios)
+{
+        iostate = ios;
+        stdin = ios->stdin;
+        stdout = ios->stdout;
+        stderr = ios->stderr;
+}
 int main(int argc, char *argv[])
+{
         int ret = 0;
+        stdiostate.stdin = stdin;
+        stdiostate.stdout = stdout;
+        stdiostate.stderr = stderr;
+        iostate = &stdiostate;
         if (cli_init(&usr))
 …
                 get_input(&usr);
                 if (NULL != usr.line) {
                         ret = tok_input(&usr);
+                        ret = process_input(&usr);
                         cli_set_prompt(&usr);
                         usr.lasterr = ret;

uspace/app/bdsh/scli.h

-              r52a79081
+              ra33f0a6
+/*
+ * Copyright (c) 2008 Tim Post
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - 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.
+ */
 #ifndef SCLI_H
 #define SCLI_H
 …
 #include "config.h"
 #include <stdint.h>
+#include <stdio.h>
 typedef struct {
 …
 } cliuser_t;
+typedef struct {
+        FILE *stdin;
+        FILE *stdout;
+        FILE *stderr;
+} iostate_t;
 extern const char *progname;
+extern iostate_t *get_iostate(void);
+extern void set_iostate(iostate_t *);
 #endif

uspace/app/bdsh/util.c

-              r52a79081
+              ra33f0a6
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com> - All rights reserved
+/*
+ * Copyright (c) 2008 Tim Post
+ * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 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 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.
+ *
+ * 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.
+ * 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.
  */
 …
         return 0;
+}

uspace/app/bdsh/util.h

-              r52a79081
+              ra33f0a6
+/*
+ * Copyright (c) 2008 Tim Post
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - 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.
+ */
 #ifndef UTIL_H
 #define UTIL_H

uspace/app/blkdump/Makefile

-              r52a79081
+              ra33f0a6
+#
+USPACE_PREFIX = ../../..
+EXTRA_CFLAGS = -Iinclude
+BINARY = char_ms
+USPACE_PREFIX = ../..
+LIBS = $(LIBBLOCK_PREFIX)/libblock.a
+EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX)
+BINARY = blkdump
 SOURCES = \
+        proto/ps2.c \
+        char_mouse.c \
+        chardev.c
+        blkdump.c
 include $(USPACE_PREFIX)/Makefile.common

uspace/app/bnchmark/Makefile

-              r52a79081
+              ra33f0a6
+#
+# Copyright (c) 2005 Martin Decky
+# Copyright (c) 2007 Jakub Jermar
+# Copyright (c) 2011 Martin Sucha
 # All rights reserved.
+#
 …
+#
 USPACE_PREFIX = ../../../..
 BINARY = fhc
+USPACE_PREFIX = ../..
+BINARY = bnchmark
 SOURCES = \
         fhc.c
+        bnchmark.c
 include $(USPACE_PREFIX)/Makefile.common

uspace/app/edit/edit.c

-              r52a79081
+              ra33f0a6
 } doc_t;
 static int con;
+static console_ctrl_t *con;
 static doc_t doc;
 static bool done;
 …
 static void cursor_setvis(bool visible);
 static void key_handle_unmod(console_event_t const *ev);
 static void key_handle_ctrl(console_event_t const *ev);
 static void key_handle_shift(console_event_t const *ev);
+static void key_handle_unmod(kbd_event_t const *ev);
+static void key_handle_ctrl(kbd_event_t const *ev);
+static void key_handle_shift(kbd_event_t const *ev);
 static void key_handle_movement(unsigned int key, bool shift);
 …
 int main(int argc, char *argv[])
+{
         console_event_t ev;
+        kbd_event_t ev;
         coord_t coord;
         bool new_file;
 …
         spt_t pt;
         con = fphone(stdout);
+        con = console_init(stdin, stdout);
         console_clear(con);
 …
         while (!done) {
                 console_get_event(con, &ev);
+                console_get_kbd_event(con, &ev);
                 pane.rflags = 0;
 …
 /** Handle key without modifier. */
 static void key_handle_unmod(console_event_t const *ev)
+static void key_handle_unmod(kbd_event_t const *ev)
+{
         switch (ev->key) {
 …
 /** Handle Shift-key combination. */
 static void key_handle_shift(console_event_t const *ev)
+static void key_handle_shift(kbd_event_t const *ev)
+{
         switch (ev->key) {
 …
 /** Handle Ctrl-key combination. */
 static void key_handle_ctrl(console_event_t const *ev)
+static void key_handle_ctrl(kbd_event_t const *ev)
+{
         switch (ev->key) {
 …
 static char *filename_prompt(char const *prompt, char const *init_value)
+{
         console_event_t ev;
+        kbd_event_t ev;
         char *str;
         wchar_t buffer[INFNAME_MAX_LEN + 1];
 …
         while (!done) {
                 console_get_event(con, &ev);
+                console_get_kbd_event(con, &ev);
                 if (ev.type == KEY_PRESS) {
 …
                                         if (nc > 0) {
                                                 putchar('\b');
                                                 fflush(stdout);
+                                                console_flush(con);
                                                 --nc;
+                                        }
 …
                                         if (ev.c >= 32 && nc < max_len) {
                                                 putchar(ev.c);
                                                 fflush(stdout);
+                                                console_flush(con);
                                                 buffer[nc++] = ev.c;
+                                        }
 …
                 for (j = 0; j < scr_columns; ++j)
                         putchar(' ');
                 fflush(stdout);
+                console_flush(con);
+        }
 …
                 if (coord_cmp(&csel_start, &rbc) <= 0 &&
                     coord_cmp(&rbc, &csel_end) < 0) {
                         fflush(stdout);
+                        console_flush(con);
                         console_set_style(con, STYLE_SELECTED);
                         fflush(stdout);
+                        console_flush(con);
+                }
 …
                 while (pos < size) {
                         if ((csel_start.row == rbc.row) && (csel_start.column == s_column)) {
                                 fflush(stdout);
+                                console_flush(con);
                                 console_set_style(con, STYLE_SELECTED);
                                 fflush(stdout);
+                                console_flush(con);
+                        }
                         if ((csel_end.row == rbc.row) && (csel_end.column == s_column)) {
                                 fflush(stdout);
+                                console_flush(con);
                                 console_set_style(con, STYLE_NORMAL);
                                 fflush(stdout);
+                                console_flush(con);
+                        }
 …
                 if ((csel_end.row == rbc.row) && (csel_end.column == s_column)) {
                         fflush(stdout);
+                        console_flush(con);
                         console_set_style(con, STYLE_NORMAL);
                         fflush(stdout);
+                        console_flush(con);
+                }
 …
                 for (j = 0; j < fill; ++j)
                         putchar(' ');
                 fflush(stdout);
+                console_flush(con);
                 console_set_style(con, STYLE_NORMAL);
+        }
 …
         int pos = scr_columns - 1 - n;
         printf("%*s", pos, "");
         fflush(stdout);
+        console_flush(con);
         console_set_style(con, STYLE_NORMAL);
 …
         int pos = -(scr_columns - 3);
         printf(" %*s ", pos, str);
         fflush(stdout);
+        console_flush(con);
         console_set_style(con, STYLE_NORMAL);

uspace/app/edit/sheet.c

-              r52a79081
+              ra33f0a6
                 return ENOMEM;
         list_initialize(&sh->tags_head);
+        list_initialize(&sh->tags);
         return EOK;
 …
         char *ipp;
         size_t sz;
-        link_t *link;
         tag_t *tag;
         char *newp;
 …
         /* Adjust tags. */
+        link = sh->tags_head.next;
+        while (link != &sh->tags_head) {
+        list_foreach(sh->tags, link) {
                 tag = list_get_instance(link, tag_t, link);
 …
                 else if (tag->b_off == pos->b_off && dir == dir_before)
                         tag->b_off += sz;
-                link = link->next;
+        }
 …
         char *spp;
         size_t sz;
-        link_t *link;
         tag_t *tag;
         char *newp;
 …
         /* Adjust tags. */
+        link = sh->tags_head.next;
+        while (link != &sh->tags_head) {
+        list_foreach(sh->tags, link) {
                 tag = list_get_instance(link, tag_t, link);
 …
                 else if (tag->b_off >= spos->b_off)
                         tag->b_off = spos->b_off;
-                link = link->next;
+        }
 …
         tag->b_off = pt->b_off;
         tag->sh = sh;
         list_append(&tag->link, &sh->tags_head);
+        list_append(&tag->link, &sh->tags);
+}

uspace/app/edit/sheet.h

-              r52a79081
+              ra33f0a6
         char *data;
         link_t tags_head;
+        list_t tags;
 } sheet_t;
 …
         /* Note: This structure is opaque for the user. */
         /** Link to list of all tags in the sheet (see sheet_t.tags_head) */
+        /** Link to list of all tags in the sheet (see sheet_t.tags) */
         link_t link;
         sheet_t *sh;

uspace/app/getterm/version.c

r52a79081	ra33f0a6
61	61	printf("HelenOS release %s (%s)%s%s\n", release, name, revision, timestamp);
62	62	printf("Running on %s (%s)\n", arch, term);
63		printf("Copyright (c) 2001-2010 HelenOS project\n\n");
	63	printf("Copyright (c) 2001-2011 HelenOS project\n\n");
64	64	}
65	65

uspace/app/init/Makefile

r52a79081	ra33f0a6
30	30	USPACE_PREFIX = ../..
31	31	BINARY = init
	32	STATIC_NEEDED = y
32	33
33	34	SOURCES = \

uspace/app/init/init.c

-              r52a79081
+              ra33f0a6
 static void console(const char *dev)
+{
+        char hid_in[DEVMAP_NAME_MAXLEN];
+        int rc;
+        snprintf(hid_in, DEVMAP_NAME_MAXLEN, "%s/%s", DEVFS_MOUNT_POINT, dev);
+        printf("%s: Spawning %s %s\n", NAME, SRV_CONSOLE, hid_in);
+        printf("%s: Spawning %s %s\n", NAME, SRV_CONSOLE, dev);
         /* Wait for the input device to be ready */
         devmap_handle_t handle;
         rc = devmap_device_get_handle(dev, &handle, IPC_FLAG_BLOCKING);
         if (rc != EOK) {
                 printf("%s: Error waiting on %s (%s)\n", NAME, hid_in,
                     str_error(rc));
                 return;
+        }
         rc = task_spawnl(NULL, SRV_CONSOLE, SRV_CONSOLE, hid_in, NULL);
+        int rc = devmap_device_get_handle(dev, &handle, IPC_FLAG_BLOCKING);
+        if (rc != EOK) {
+                printf("%s: Error waiting on %s (%s)\n", NAME, dev,
+                    str_error(rc));
+                return;
+        }
+        rc = task_spawnl(NULL, SRV_CONSOLE, SRV_CONSOLE, dev, NULL);
         if (rc != EOK) {
                 printf("%s: Error spawning %s %s (%s)\n", NAME, SRV_CONSOLE,
                     hid_in, str_error(rc));
+                    dev, str_error(rc));
+        }
+}
 …
         mount_tmpfs();
-#ifdef CONFIG_START_DEVMAN
         spawn("/srv/devman");
-#endif
         spawn("/srv/apic");
         spawn("/srv/i8259");
-        spawn("/srv/fhc");
         spawn("/srv/obio");
         srv_start("/srv/cuda_adb");
         srv_start("/srv/i8042");
         srv_start("/srv/s3c24ser");
-        srv_start("/srv/adb_ms");
-        srv_start("/srv/char_ms");
         srv_start("/srv/s3c24ts");
         spawn("/srv/fb");
         spawn("/srv/kbd");
         console("hid_in/kbd");
+        spawn("/srv/input");
+        console("hid/input");
         spawn("/srv/clip");
 …
 #ifdef CONFIG_MOUNT_DATA
+        /* Make sure fat is running. */
+        if (str_cmp(STRING(RDFMT), "fat") != 0) {
+                srv_start("/srv/fat");
+        }
         mount_data();
 #else

uspace/app/klog/klog.c

-              r52a79081
+              ra33f0a6
 #include <io/klog.h>
 #include <sysinfo.h>
+#include <malloc.h>
+#include <fibril_synch.h>
+#include <adt/list.h>
+#include <adt/prodcons.h>
 #define NAME       "klog"
 #define LOG_FNAME  "/log/klog"
+/* Producer/consumer buffers */
+typedef struct {
+        link_t link;
+        size_t length;
+        wchar_t *data;
+} item_t;
+static prodcons_t pc;
 /* Pointer to klog area */
 …
 static size_t klog_length;
+static FILE *log;
+static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
+{
+/* Notification mutex */
+static FIBRIL_MUTEX_INITIALIZE(mtx);
+/** Klog producer
+ *
+ * Copies the contents of a character buffer to local
+ * producer/consumer queue.
+ *
+ * @param length Number of characters to copy.
+ * @param data   Pointer to the kernel klog buffer.
+ *
+ */
+static void producer(size_t length, wchar_t *data)
+{
+        item_t *item = (item_t *) malloc(sizeof(item_t));
+        if (item == NULL)
+                return;
+        size_t sz = sizeof(wchar_t) * length;
+        wchar_t *buf = (wchar_t *) malloc(sz);
+        if (data == NULL) {
+                free(item);
+                return;
+        }
+        memcpy(buf, data, sz);
+        link_initialize(&item->link);
+        item->length = length;
+        item->data = buf;
+        prodcons_produce(&pc, &item->link);
+}
+/** Klog consumer
+ *
+ * Waits in an infinite loop for the character data created by
+ * the producer and outputs them to stdout and optionally into
+ * a file.
+ *
+ * @param data Unused.
+ *
+ * @return Always EOK (unreachable).
+ *
+ */
+static int consumer(void *data)
+{
+        FILE *log = fopen(LOG_FNAME, "a");
+        if (log == NULL)
+                printf("%s: Unable to create log file %s (%s)\n", NAME, LOG_FNAME,
+                    str_error(errno));
+        while (true) {
+                link_t *link = prodcons_consume(&pc);
+                item_t *item = list_get_instance(link, item_t, link);
+                for (size_t i = 0; i < item->length; i++)
+                        putchar(item->data[i]);
+                if (log != NULL) {
+                        for (size_t i = 0; i < item->length; i++)
+                                fputc(item->data[i], log);
+                        fflush(log);
+                        fsync(fileno(log));
+                }
+                free(item->data);
+                free(item);
+        }
+        fclose(log);
+        return EOK;
+}
+/** Kernel notification handler
+ *
+ * Receives kernel klog notifications.
+ *
+ * @param callid IPC call ID
+ * @param call   IPC call structure
+ * @param arg    Local argument
+ *
+ */
+static void notification_received(ipc_callid_t callid, ipc_call_t *call)
+{
+        /*
+         * Make sure we process only a single notification
+         * at any time to limit the chance of the consumer
+         * starving.
+         *
+         * Note: Usually the automatic masking of the klog
+         * notifications on the kernel side does the trick
+         * of limiting the chance of accidentally copying
+         * the same data multiple times. However, due to
+         * the non-blocking architecture of klog notifications,
+         * this possibility cannot be generally avoided.
+         */
+        fibril_mutex_lock(&mtx);
         size_t klog_start = (size_t) IPC_GET_ARG1(*call);
         size_t klog_len = (size_t) IPC_GET_ARG2(*call);
         size_t klog_stored = (size_t) IPC_GET_ARG3(*call);
+        size_t i;
+        for (i = klog_len - klog_stored; i < klog_len; i++) {
+                wchar_t ch = klog[(klog_start + i) % klog_length];
+                putchar(ch);
+                if (log != NULL)
+                        fputc(ch, log);
+        }
+        if (log != NULL) {
+                fflush(log);
+                fsync(fileno(log));
+        }
+        size_t offset = (klog_start + klog_len - klog_stored) % klog_length;
+        /* Copy data from the ring buffer */
+        if (offset + klog_stored >= klog_length) {
+                size_t split = klog_length - offset;
+                producer(split, klog + offset);
+                producer(klog_stored - split, klog);
+        } else
+                producer(klog_stored, klog + offset);
+        event_unmask(EVENT_KLOG);
+        fibril_mutex_unlock(&mtx);
+}
 …
+        }
+        prodcons_initialize(&pc);
+        async_set_interrupt_received(notification_received);
         rc = event_subscribe(EVENT_KLOG, 0);
         if (rc != EOK) {
 …
+        }
+        log = fopen(LOG_FNAME, "a");
+        if (log == NULL)
+                printf("%s: Unable to create log file %s (%s)\n", NAME, LOG_FNAME,
+                    str_error(errno));
+        async_set_interrupt_received(interrupt_received);
+        fid_t fid = fibril_create(consumer, NULL);
+        if (!fid) {
+                fprintf(stderr, "%s: Unable to create consumer fibril\n",
+                    NAME);
+                return ENOMEM;
+        }
+        fibril_add_ready(fid);
+        event_unmask(EVENT_KLOG);
         klog_update();
+        task_retval(0);
         async_manager();

uspace/app/mkfat/mkfat.c

r52a79081	ra33f0a6
144	144	}
145	145
146		rc = block_init(handle, 2048);
	146	rc = block_init(EXCHANGE_SERIALIZE, handle, 2048);
147	147	if (rc != EOK) {
148	148	printf(NAME ": Error initializing libblock.\n");

uspace/app/ping/ping.c

-              r52a79081
+              ra33f0a6
             config.dest_str, config.size, config.size);
         int icmp_phone = icmp_connect_module(ICMP_CONNECT_TIMEOUT);
         if (icmp_phone < 0) {
+        async_sess_t *sess = icmp_connect_module();
+        if (!sess) {
                 fprintf(stderr, "%s: Unable to connect to ICMP service (%s)\n", NAME,
                     str_error(icmp_phone));
                 return icmp_phone;
+                    str_error(errno));
+                return errno;
+        }
 …
                             str_error(ret));
                         async_hangup(icmp_phone);
+                        async_hangup(sess);
                         return ret;
+                }
                 /* Ping! */
                 int result = icmp_echo_msg(icmp_phone, config.size, config.timeout,
+                int result = icmp_echo_msg(sess, config.size, config.timeout,
                     config.ttl, config.tos, !config.fragments, config.dest_raw,
                     config.dest_len);
 …
                             str_error(ret));
                         async_hangup(icmp_phone);
+                        async_hangup(sess);
                         return ret;
+                }
 …
+        }
         async_hangup(icmp_phone);
+        async_hangup(sess);
         return 0;

uspace/app/redir/redir.c

-              r52a79081
+              ra33f0a6
 static void usage(void)
+{
         printf("Usage: %s [-i <stdin>] [-o <stdout>] [-e <stderr>] -- <cmd> [args ...]\n",
+        fprintf(stderr, "Usage: %s [-i <stdin>] [-o <stdout>] [-e <stderr>] -- <cmd> [args ...]\n",
             NAME);
+}
 …
         args = (const char **) calloc(argc + 1, sizeof(char *));
         if (!args) {
                 printf("No memory available\n");
+                fprintf(stderr, "No memory available\n");
                 return 0;
+        }
 …
         if (rc != EOK) {
                 printf("%s: Error spawning %s (%s)\n", NAME, argv[0],
+                fprintf(stderr, "%s: Error spawning %s (%s)\n", NAME, argv[0],
                     str_error(rc));
+                return 0;
+        }

uspace/app/sbi/src/compat.h

-              r52a79081
+              ra33f0a6
 #ifdef __HELENOS__
+#define list sbi_list
+#define list_t sbi_list_t
 /*
  * Avoid name conflicts with ADT library.
 …
 #define list_prepend sbi_list_prepend
 #define list_remove sbi_list_remove
+#define list_first sbi_list_first
+#define list_last sbi_list_last
 #endif

uspace/app/sbi/src/input.c

-              r52a79081
+              ra33f0a6
 int input_get_line(input_t *input, char **line)
+{
+        const char *prompt;
         const char *sp;
         char *dp;
 …
                 /* Interactive mode */
                 if (input->line_no == 0)
                         printf("sbi> ");
+                        prompt = "sbi> ";
                 else
                         printf("...  ");
+                        prompt = "...  ";
                 fflush(stdout);
                 if (os_input_line(&line_p) != EOK)
+                if (os_input_line(prompt, &line_p) != EOK)
                         return EIO;

uspace/app/sbi/src/list_t.h

r52a79081	ra33f0a6
30	30	#define LIST_T_H_
31	31
	32	#include "compat.h"
	33
32	34	typedef struct list_node {
33	35	struct list_node prev, next;

uspace/app/sbi/src/os/helenos.c

-              r52a79081
+              ra33f0a6
  * @param ptr   Place to store pointer to new string.
  */
 int os_input_line(char **ptr)
+int os_input_line(const char *prompt, char **ptr)
+{
         char *line;
 …
                 if (tinput == NULL)
                         return EIO;
+                tinput_set_prompt(tinput, prompt);
+        }

uspace/app/sbi/src/os/os.h

r52a79081	ra33f0a6
38	38	char *os_chr_to_astr(wchar_t chr);
39	39	void os_input_disp_help(void);
40		int os_input_line(char **ptr);
	40	int os_input_line(const char prompt, char *ptr);
41	41	int os_exec(char * const cmd[]);
42	42

uspace/app/sbi/src/os/posix.c

-              r52a79081
+              ra33f0a6
  * @param ptr   Place to store pointer to new string.
  */
+int os_input_line(char **ptr)
+{
+int os_input_line(const char *prompt, char **ptr)
+{
+        printf("%s", prompt);
         if (fgets(os_input_buffer, OS_INPUT_BUFFER_SIZE, stdin) == NULL)
                 os_input_buffer[0] = '\0';

uspace/app/taskdump/elf_core.c

-              r52a79081
+              ra33f0a6
 /*
  * Copyright (c) 2010 Jiri Svoboda
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
+ *
 …
  * Looking at core files produced by Linux, these don't have section headers,
  * only program headers, although objdump shows them as having sections.
+ * Basically at the beginning there should be a note segment (which we
+ * do not write) and one loadable segment per memory area (which we do write).
+ *
+ * The note segment probably contains register state, etc. -- we don't
+ * deal with these yet. Nevertheless you can use these core files with
+ * objdump or gdb.
+ */
+ * Basically at the beginning there should be a note segment followed
+ * by one loadable segment per memory area.
+ *
+ * The note segment contains a series of records with register state,
+ * process info etc. We only write one record NT_PRSTATUS which contains
+ * process/register state (anything which is not register state we fill
+ * with zeroes).
+ */
+#include <align.h>
+#include <elf/elf.h>
+#include <elf/elf_linux.h>
 #include <stdio.h>
 #include <stdlib.h>
 …
 #include <udebug.h>
 #include <macros.h>
+#include <elf.h>
 #include "include/elf_core.h"
 static off64_t align_foff_up(off64_t foff, uintptr_t vaddr, size_t page_size);
 static int write_all(int fd, void *data, size_t len);
 static int write_mem_area(int fd, as_area_info_t *area, int phoneid);
+#include <libarch/istate.h>
+#include "elf_core.h"
+static off64_t align_foff_up(off64_t, uintptr_t, size_t);
+static int align_pos(int, size_t);
+static int write_mem_area(int, as_area_info_t *, async_sess_t *);
 #define BUFFER_SIZE 0x1000
 …
 /** Save ELF core file.
+ *
+ * @param file_name     Name of file to save to.
+ * @param ainfo         Array of @a n memory area info structures.
+ * @param n             Number of memory areas.
+ * @param phoneid       Debugging phone.
+ *
+ * @return              EOK on sucess, ENOENT if file cannot be created,
+ *                      ENOMEM on out of memory, EIO on write error.
+ */
+int elf_core_save(const char *file_name, as_area_info_t *ainfo, unsigned int n, int phoneid)
+ * @param file_name Name of file to save to.
+ * @param ainfo     Array of @a n memory area info structures.
+ * @param n         Number of memory areas.
+ * @param sess      Debugging session.
+ *
+ * @return EOK on sucess.
+ * @return ENOENT if file cannot be created.
+ * @return ENOMEM on out of memory.
+ * @return EIO on write error.
+ *
+ */
+int elf_core_save(const char *file_name, as_area_info_t *ainfo, unsigned int n,
+    async_sess_t *sess, istate_t *istate)
+{
         elf_header_t elf_hdr;
 …
         elf_word flags;
         elf_segment_header_t *p_hdr;
+        elf_prstatus_t pr_status;
+        elf_note_t note;
+        size_t word_size;
         int fd;
         int rc;
+        ssize_t rc;
         unsigned int i;
+        n_ph = n;
+        p_hdr = malloc(sizeof(elf_segment_header_t) * n);
+#ifdef __32_BITS__
+        word_size = 4;
+#endif
+#ifdef __64_BITS__
+        /*
+         * This should be 8 per the 64-bit ELF spec, but the Linux kernel
+         * screws up and uses 4 anyway (and screws up elf_note_t as well)
+         * and we are trying to be compatible with Linux GDB target. Sigh.
+         */
+        word_size = 4;
+#endif
+        memset(&pr_status, 0, sizeof(pr_status));
+        istate_to_elf_regs(istate, &pr_status.regs);
+        n_ph = n + 1;
+        p_hdr = malloc(sizeof(elf_segment_header_t) * n_ph);
         if (p_hdr == NULL) {
                 printf("Failed allocating memory.\n");
 …
          *      ELF header
          *      program headers
+         *      note segment
          * repeat:
          *      (pad for alignment)
          *      segment data
+         *      core segment
          * end repeat
          */
 …
         foff = elf_hdr.e_phoff + n_ph * sizeof(elf_segment_header_t);
+        for (i = 1; i <= n; ++i) {
+                foff = align_foff_up(foff, ainfo[i - 1].start_addr, PAGE_SIZE);
+        memset(&p_hdr[0], 0, sizeof(p_hdr[0]));
+        p_hdr[0].p_type = PT_NOTE;
+        p_hdr[0].p_offset = foff;
+        p_hdr[0].p_vaddr = 0;
+        p_hdr[0].p_paddr = 0;
+        p_hdr[0].p_filesz = sizeof(elf_note_t)
+            + ALIGN_UP((str_size("CORE") + 1), word_size)
+            + ALIGN_UP(sizeof(elf_prstatus_t), word_size);
+        p_hdr[0].p_memsz = 0;
+        p_hdr[0].p_flags = 0;
+        p_hdr[0].p_align = 1;
+        foff += p_hdr[0].p_filesz;
+        for (i = 0; i < n; ++i) {
+                foff = align_foff_up(foff, ainfo[i].start_addr, PAGE_SIZE);
                 flags = 0;
                 if (ainfo[i - 1].flags & AS_AREA_READ)
+                if (ainfo[i].flags & AS_AREA_READ)
                         flags |= PF_R;
                 if (ainfo[i - 1].flags & AS_AREA_WRITE)
+                if (ainfo[i].flags & AS_AREA_WRITE)
                         flags |= PF_W;
                 if (ainfo[i - 1].flags & AS_AREA_EXEC)
+                if (ainfo[i].flags & AS_AREA_EXEC)
                         flags |= PF_X;
                 memset(&p_hdr[i - 1], 0, sizeof(p_hdr[i - 1]));
                 p_hdr[i - 1].p_type = PT_LOAD;
                 p_hdr[i - 1].p_offset = foff;
                 p_hdr[i - 1].p_vaddr = ainfo[i - 1].start_addr;
                 p_hdr[i - 1].p_paddr = 0;
                 p_hdr[i - 1].p_filesz = ainfo[i - 1].size;
                 p_hdr[i - 1].p_memsz = ainfo[i - 1].size;
                 p_hdr[i - 1].p_flags = flags;
                 p_hdr[i - 1].p_align = PAGE_SIZE;
                 foff += ainfo[i - 1].size;
+                memset(&p_hdr[i + 1], 0, sizeof(p_hdr[i + 1]));
+                p_hdr[i + 1].p_type = PT_LOAD;
+                p_hdr[i + 1].p_offset = foff;
+                p_hdr[i + 1].p_vaddr = ainfo[i].start_addr;
+                p_hdr[i + 1].p_paddr = 0;
+                p_hdr[i + 1].p_filesz = ainfo[i].size;
+                p_hdr[i + 1].p_memsz = ainfo[i].size;
+                p_hdr[i + 1].p_flags = flags;
+                p_hdr[i + 1].p_align = PAGE_SIZE;
+                foff += ainfo[i].size;
+        }
         rc = write_all(fd, &elf_hdr, sizeof(elf_hdr));
         if (rc != EOK) {
+        if (rc != sizeof(elf_hdr)) {
                 printf("Failed writing ELF header.\n");
                 free(p_hdr);
 …
         for (i = 0; i < n_ph; ++i) {
                 rc = write_all(fd, &p_hdr[i], sizeof(p_hdr[i]));
                 if (rc != EOK) {
+                if (rc != sizeof(p_hdr[i])) {
                         printf("Failed writing program header.\n");
                         free(p_hdr);
 …
+        }
+        for (i = 0; i < n_ph; ++i) {
+        if (lseek(fd, p_hdr[0].p_offset, SEEK_SET) == (off64_t) -1) {
+                printf("Failed writing memory data.\n");
+                free(p_hdr);
+                return EIO;
+        }
+        /*
+         * Write note header
+         */
+        note.namesz = str_size("CORE") + 1;
+        note.descsz = sizeof(elf_prstatus_t);
+        note.type = NT_PRSTATUS;
+        rc = write_all(fd, &note, sizeof(elf_note_t));
+        if (rc != sizeof(elf_note_t)) {
+                printf("Failed writing note header.\n");
+                free(p_hdr);
+                return EIO;
+        }
+        rc = write_all(fd, "CORE", note.namesz);
+        if (rc != (ssize_t) note.namesz) {
+                printf("Failed writing note header.\n");
+                free(p_hdr);
+                return EIO;
+        }
+        rc = align_pos(fd, word_size);
+        if (rc != EOK) {
+                printf("Failed writing note header.\n");
+                free(p_hdr);
+                return EIO;
+        }
+        rc = write_all(fd, &pr_status, sizeof(elf_prstatus_t));
+        if (rc != sizeof(elf_prstatus_t)) {
+                printf("Failed writing register data.\n");
+                free(p_hdr);
+                return EIO;
+        }
+        for (i = 1; i < n_ph; ++i) {
                 if (lseek(fd, p_hdr[i].p_offset, SEEK_SET) == (off64_t) -1) {
                         printf("Failed writing memory data.\n");
 …
                         return EIO;
+                }
                 if (write_mem_area(fd, &ainfo[i], phoneid) != EOK) {
+                if (write_mem_area(fd, &ainfo[i - 1], sess) != EOK) {
                         printf("Failed writing memory data.\n");
                         free(p_hdr);
 …
         off64_t rva = vaddr % page_size;
         off64_t rfo = foff % page_size;
         if (rva >= rfo)
                 return (foff + (rva - rfo));
         return (foff + (page_size + (rva - rfo)));
+}
 …
 /** Write memory area from application to core file.
+ *
+ * @param fd            File to write to.
+ * @param area          Memory area info structure.
+ * @param phoneid       Debugging phone.
+ *
+ * @return              EOK on success, EIO on failure.
+ */
+static int write_mem_area(int fd, as_area_info_t *area, int phoneid)
+ * @param fd   File to write to.
+ * @param area Memory area info structure.
+ * @param sess Debugging session.
+ *
+ * @return EOK on success, EIO on failure.
+ *
+ */
+static int write_mem_area(int fd, as_area_info_t *area, async_sess_t *sess)
+{
         size_t to_copy;
         size_t total;
         uintptr_t addr;
         int rc;
+        ssize_t rc;
         addr = area->start_addr;
 …
         while (total < area->size) {
                 to_copy = min(area->size - total, BUFFER_SIZE);
                 rc = udebug_mem_read(phoneid, buffer, addr, to_copy);
+                rc = udebug_mem_read(sess, buffer, addr, to_copy);
                 if (rc < 0) {
                         printf("Failed reading task memory.\n");
 …
                 rc = write_all(fd, buffer, to_copy);
                 if (rc != EOK) {
+                if (rc != (ssize_t) to_copy) {
                         printf("Failed writing memory contents.\n");
                         return EIO;
 …
+}
+/** Write until the buffer is written in its entirety.
+ *
+ * This function fails if it cannot write exactly @a len bytes to the file.
+ *
+ * @param fd            The file to write to.
+ * @param buf           Data, @a len bytes long.
+ * @param len           Number of bytes to write.
+ *
+ * @return              EOK on error, return value from write() if writing
+ *                      failed.
+ */
+static int write_all(int fd, void *data, size_t len)
+static int align_pos(int fd, size_t align)
+{
         int cnt = 0;
+        do {
                 data += cnt;
                 len -= cnt;
                 cnt = write(fd, data, len);
+        } while (cnt > 0 && (len - cnt) > 0);
         if (cnt < 0)
+                return cnt;
         if (len - cnt > 0)
                 return EIO;
+        off64_t cur_pos;
+        size_t rem, adv;
+        cur_pos = lseek(fd, 0, SEEK_CUR);
+        if (cur_pos < 0)
+                return -1;
+        rem = cur_pos % align;
+        adv = align - rem;
+        cur_pos = lseek(fd, adv, SEEK_CUR);
+        if (cur_pos < 0)
+                return -1;
         return EOK;
+}
 /** @}
  */

uspace/app/taskdump/include/elf_core.h

-              r52a79081
+              ra33f0a6
 #define ELF_CORE_H_
+int elf_core_save(const char *file_name, as_area_info_t *ainfo, unsigned int n, int phoneid);
+#include <async.h>
+#include <elf/elf_linux.h>
+#include <libarch/istate.h>
+extern int elf_core_save(const char *, as_area_info_t *, unsigned int,
+    async_sess_t *, istate_t *);
 #endif

uspace/app/taskdump/include/symtab.h

-              r52a79081
+              ra33f0a6
 #define SYMTAB_H_
+#include <elf/elf.h>
 #include <sys/types.h>
-#include <elf.h>
 typedef struct {

uspace/app/taskdump/symtab.c

-              r52a79081
+              ra33f0a6
  */
+#include <elf/elf.h>
 #include <stdio.h>
 #include <stdlib.h>
 …
 #include <fcntl.h>
-#include <elf.h>
 #include "include/symtab.h"
 …
     elf_section_header_t *shdr);
 static int chunk_load(int fd, off64_t start, size_t size, void **ptr);
-static int read_all(int fd, void *buf, size_t len);
 /** Load symbol table from an ELF file.
 …
         rc = read_all(fd, &elf_hdr, sizeof(elf_header_t));
         if (rc != EOK) {
+        if (rc != sizeof(elf_header_t)) {
                 printf("failed reading elf header\n");
                 free(stab);
 …
         rc = read_all(fd, sec_hdr, sizeof(elf_section_header_t));
         if (rc != EOK)
+        if (rc != sizeof(elf_section_header_t))
                 return EIO;
 …
 static int chunk_load(int fd, off64_t start, size_t size, void **ptr)
+{
+        int rc;
+        rc = lseek(fd, start, SEEK_SET);
+        if (rc == (off64_t) -1) {
+        ssize_t rc;
+        off64_t offs;
+        offs = lseek(fd, start, SEEK_SET);
+        if (offs == (off64_t) -1) {
                 printf("failed seeking chunk\n");
                 *ptr = NULL;
 …
         rc = read_all(fd, *ptr, size);
         if (rc != EOK) {
+        if (rc != (ssize_t) size) {
                 printf("failed reading chunk\n");
                 free(*ptr);
 …
+}
-/** Read until the buffer is read in its entirety.
+ *
- * This function fails if it cannot read exactly @a len bytes from the file.
+ *
- * @param fd            The file to read from.
- * @param buf           Buffer for storing data, @a len bytes long.
- * @param len           Number of bytes to read.
+ *
- * @return              EOK on error, EIO if file is short or return value
- *                      from read() if reading failed.
- */
-static int read_all(int fd, void *buf, size_t len)
+{
-        int cnt = 0;
-        do {
-                buf += cnt;
-                len -= cnt;
-                cnt = read(fd, buf, len);
-        } while (cnt > 0 && (len - cnt) > 0);
-        if (cnt < 0)
-                return cnt;
-        if (len - cnt > 0)
-                return EIO;
-        return EOK;
+}
 /** @}
  */

uspace/app/taskdump/taskdump.c

-              r52a79081
+              ra33f0a6
 #include <async.h>
+#include <elf/elf_linux.h>
 #include <stdio.h>
 #include <stdlib.h>
 …
 #define LINE_BYTES 16
 static int phoneid;
+static async_sess_t *sess;
 static task_id_t task_id;
 static bool write_core_file;
 …
 static char *fmt_sym_address(uintptr_t addr);
+static istate_t reg_state;
 int main(int argc, char *argv[])
+{
 …
                 printf("Failed dumping address space areas.\n");
         udebug_end(phoneid);
         async_hangup(phoneid);
+        udebug_end(sess);
+        async_hangup(sess);
         return 0;
 …
 static int connect_task(task_id_t task_id)
+{
+        int rc;
+        rc = async_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) {
+        async_sess_t *ksess = async_connect_kbox(task_id);
+        if (!ksess) {
+                if (errno == 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 errno;
+                }
                 printf("Error connecting\n");
+                printf("async_connect_kbox(%" PRIu64 ") -> %d ", task_id, rc);
+                return rc;
+        }
+        phoneid = rc;
+        rc = udebug_begin(phoneid);
+                printf("async_connect_kbox(%" PRIu64 ") -> %d ", task_id, errno);
+                return errno;
+        }
+        int rc = udebug_begin(ksess);
         if (rc < 0) {
                 printf("udebug_begin() -> %d\n", rc);
                 return rc;
+        }
+        sess = ksess;
         return 0;
+}
 …
         /* TODO: See why NULL does not work. */
         rc = udebug_thread_read(phoneid, &dummy_buf, 0, &copied, &needed);
+        rc = udebug_thread_read(sess, &dummy_buf, 0, &copied, &needed);
         if (rc < 0) {
                 printf("udebug_thread_read() -> %d\n", rc);
 …
         thash_buf = malloc(buf_size);
         rc = udebug_thread_read(phoneid, thash_buf, buf_size, &copied, &needed);
+        rc = udebug_thread_read(sess, thash_buf, buf_size, &copied, &needed);
         if (rc < 0) {
                 printf("udebug_thread_read() -> %d\n", rc);
 …
         int rc;
         rc = udebug_areas_read(phoneid, &dummy_buf, 0, &copied, &needed);
+        rc = udebug_areas_read(sess, &dummy_buf, 0, &copied, &needed);
         if (rc < 0) {
                 printf("udebug_areas_read() -> %d\n", rc);
 …
         ainfo_buf = malloc(buf_size);
         rc = udebug_areas_read(phoneid, ainfo_buf, buf_size, &copied, &needed);
+        rc = udebug_areas_read(sess, ainfo_buf, buf_size, &copied, &needed);
         if (rc < 0) {
                 printf("udebug_areas_read() -> %d\n", rc);
 …
         if (write_core_file) {
                 printf("Writing core file '%s'\n", core_file_name);
+                rc = elf_core_save(core_file_name, ainfo_buf, n_areas, phoneid);
+                rc = elf_core_save(core_file_name, ainfo_buf, n_areas, sess,
+                    &reg_state);
                 if (rc != EOK) {
                         printf("Failed writing core file.\n");
 …
         int rc;
         rc = udebug_regs_read(phoneid, thash, &istate);
+        rc = udebug_regs_read(sess, thash, &istate);
         if (rc < 0) {
                 printf("Failed reading registers (%d).\n", rc);
 …
         pc = istate_get_pc(&istate);
         fp = istate_get_fp(&istate);
+        /* Save register state for dumping to core file later. */
+        reg_state = istate;
         sym_pc = fmt_sym_address(pc);
 …
         (void) arg;
         rc = udebug_mem_read(phoneid, &data, addr, sizeof(data));
+        rc = udebug_mem_read(sess, &data, addr, sizeof(data));
         if (rc < 0) {
                 printf("Warning: udebug_mem_read() failed.\n");
 …
         int rc;
         rc = udebug_name_read(phoneid, &dummy_buf, 0, &copied, &needed);
+        rc = udebug_name_read(sess, &dummy_buf, 0, &copied, &needed);
         if (rc < 0)
                 return NULL;
 …
         name_size = needed;
         name = malloc(name_size + 1);
         rc = udebug_name_read(phoneid, name, name_size, &copied, &needed);
+        rc = udebug_name_read(sess, name, name_size, &copied, &needed);
         if (rc < 0) {
                 free(name);

uspace/app/tester/Makefile

-              r52a79081
+              ra33f0a6
 USPACE_PREFIX = ../..
+LIBS = $(LIBEXT2_PREFIX)/libext2.a $(LIBBLOCK_PREFIX)/libblock.a
+EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -I$(LIBEXT2_PREFIX)
 BINARY = tester
 SOURCES = \
         tester.c \
+        util.c \
         thread/thread1.c \
         print/print1.c \
 …
         ipc/ping_pong.c \
         loop/loop1.c \
+        mm/common.c \
         mm/malloc1.c \
         mm/malloc2.c \
+        mm/malloc3.c \
+        mm/mapping1.c \
         devs/devman1.c \
+        devs/devman2.c \
         hw/misc/virtchar1.c \
+        hw/serial/serial1.c
+        hw/serial/serial1.c \
+        libext2/libext2_1.c
 include $(USPACE_PREFIX)/Makefile.common

uspace/app/tester/console/console1.c

-              r52a79081
+              ra33f0a6
+{
         if (!test_quiet) {
+                console_ctrl_t *console = console_init(stdin, stdout);
                 printf("Style test: ");
                 fflush(stdout);
                 console_set_style(fphone(stdout), STYLE_NORMAL);
+                console_flush(console);
+                console_set_style(console, STYLE_NORMAL);
                 printf(" normal ");
                 fflush(stdout);
                 console_set_style(fphone(stdout), STYLE_EMPHASIS);
+                console_flush(console);
+                console_set_style(console, STYLE_EMPHASIS);
                 printf(" emphasized ");
                 fflush(stdout);
                 console_set_style(fphone(stdout), STYLE_INVERTED);
+                console_flush(console);
+                console_set_style(console, STYLE_INVERTED);
                 printf(" inverted ");
                 fflush(stdout);
                 console_set_style(fphone(stdout), STYLE_SELECTED);
+                console_flush(console);
+                console_set_style(console, STYLE_SELECTED);
                 printf(" selected ");
                 fflush(stdout);
                 console_set_style(fphone(stdout), STYLE_NORMAL);
+                console_flush(console);
+                console_set_style(console, STYLE_NORMAL);
                 printf("\n");
 …
                 for (j = 0; j < 2; j++) {
                         for (i = COLOR_BLACK; i <= COLOR_WHITE; i++) {
                                 fflush(stdout);
                                 console_set_color(fphone(stdout), i, COLOR_WHITE,
+                                console_flush(console);
+                                console_set_color(console, i, COLOR_WHITE,
                                     j ? CATTR_BRIGHT : 0);
                                 printf(" %s ", color_name[i]);
+                        }
                         fflush(stdout);
                         console_set_style(fphone(stdout), STYLE_NORMAL);
+                        console_flush(console);
+                        console_set_style(console, STYLE_NORMAL);
                         putchar('\n');
+                }
 …
                 for (j = 0; j < 2; j++) {
                         for (i = COLOR_BLACK; i <= COLOR_WHITE; i++) {
                                 fflush(stdout);
                                 console_set_color(fphone(stdout), COLOR_WHITE, i,
+                                console_flush(console);
+                                console_set_color(console, COLOR_WHITE, i,
                                     j ? CATTR_BRIGHT : 0);
                                 printf(" %s ", color_name[i]);
+                        }
                         fflush(stdout);
                         console_set_style(fphone(stdout), STYLE_NORMAL);
+                        console_flush(console);
+                        console_set_style(console, STYLE_NORMAL);
                         putchar('\n');
+                }
 …
                 for (i = 0; i < 255; i += 16) {
                         fflush(stdout);
                         console_set_rgb_color(fphone(stdout), (255 - i) << 16, i << 16);
+                        console_flush(console);
+                        console_set_rgb_color(console, (255 - i) << 16, i << 16);
                         putchar('X');
+                }
                 fflush(stdout);
                 console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0);
+                console_flush(console);
+                console_set_color(console, COLOR_BLACK, COLOR_WHITE, 0);
                 putchar('\n');
                 for (i = 0; i < 255; i += 16) {
                         fflush(stdout);
                         console_set_rgb_color(fphone(stdout), (255 - i) << 8, i << 8);
+                        console_flush(console);
+                        console_set_rgb_color(console, (255 - i) << 8, i << 8);
                         putchar('X');
+                }
                 fflush(stdout);
                 console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0);
+                console_flush(console);
+                console_set_color(console, COLOR_BLACK, COLOR_WHITE, 0);
                 putchar('\n');
                 for (i = 0; i < 255; i += 16) {
                         fflush(stdout);
                         console_set_rgb_color(fphone(stdout), 255 - i, i);
+                        console_flush(console);
+                        console_set_rgb_color(console, 255 - i, i);
                         putchar('X');
+                }
                 fflush(stdout);
                 console_set_style(fphone(stdout), STYLE_NORMAL);
+                console_flush(console);
+                console_set_style(console, STYLE_NORMAL);
                 putchar('\n');
+        }

uspace/app/tester/hw/misc/virtchar1.c

-              r52a79081
+              ra33f0a6
 #include <str.h>
 #include <vfs/vfs.h>
+#include <vfs/vfs_sess.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 …
         TPRINTF("   ...file handle %d\n", fd);
         TPRINTF(" Asking for phone...\n");
         int phone = fd_phone(fd);
         if (phone < 0) {
+        TPRINTF(" Asking for session...\n");
+        async_sess_t *sess = fd_session(EXCHANGE_SERIALIZE, fd);
+        if (!sess) {
                 close(fd);
                 TPRINTF("   ...error: %s\n", str_error(phone));
                 return "Failed to get phone to device";
+                TPRINTF("   ...error: %s\n", str_error(errno));
+                return "Failed to get session to device";
+        }
         TPRINTF("   ...phone is %d\n", phone);
+        TPRINTF("   ...session is %p\n", sess);
         TPRINTF(" Will try to read...\n");
         size_t i;
         char buffer[BUFFER_SIZE];
         char_dev_read(phone, buffer, BUFFER_SIZE);
+        char_dev_read(sess, buffer, BUFFER_SIZE);
         TPRINTF(" ...verifying that we read zeroes only...\n");
         for (i = 0; i < BUFFER_SIZE; i++) {
 …
         /* Clean-up. */
         TPRINTF(" Closing phones and file descriptors\n");
         async_hangup(phone);
+        TPRINTF(" Closing session and file descriptor\n");
+        async_hangup(sess);
         close(fd);

uspace/app/tester/hw/serial/serial1.c

-              r52a79081
+              ra33f0a6
+                }
-        int res = devman_get_phone(DEVMAN_CLIENT, IPC_FLAG_BLOCKING);
         devman_handle_t handle;
         res = devman_device_get_handle("/hw/pci0/00:01.0/com1/a", &handle,
+        int res = devman_device_get_handle("/hw/pci0/00:01.0/com1/a", &handle,
             IPC_FLAG_BLOCKING);
         if (res != EOK)
                 return "Could not get serial device handle";
         int phone = devman_device_connect(handle, IPC_FLAG_BLOCKING);
         if (phone < 0) {
                 devman_hangup_phone(DEVMAN_CLIENT);
+        async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
+            IPC_FLAG_BLOCKING);
+        if (!sess)
                 return "Unable to connect to serial device";
+        }
         char *buf = (char *) malloc(cnt + 1);
         if (buf == NULL) {
+                async_hangup(phone);
+                devman_hangup_phone(DEVMAN_CLIENT);
+                async_hangup(sess);
                 return "Failed to allocate input buffer";
+        }
 …
         sysarg_t old_word_size;
+        res = async_req_0_4(phone, SERIAL_GET_COM_PROPS, &old_baud,
+        async_exch_t *exch = async_exchange_begin(sess);
+        res = async_req_0_4(exch, SERIAL_GET_COM_PROPS, &old_baud,
             &old_par, &old_word_size, &old_stop);
+        async_exchange_end(exch);
         if (res != EOK) {
                 free(buf);
+                async_hangup(phone);
+                devman_hangup_phone(DEVMAN_CLIENT);
+                async_hangup(sess);
                 return "Failed to get old serial communication parameters";
+        }
+        res = async_req_4_0(phone, SERIAL_SET_COM_PROPS, 1200,
+        exch = async_exchange_begin(sess);
+        res = async_req_4_0(exch, SERIAL_SET_COM_PROPS, 1200,
             SERIAL_NO_PARITY, 8, 1);
+        async_exchange_end(exch);
         if (EOK != res) {
                 free(buf);
+                async_hangup(phone);
+                devman_hangup_phone(DEVMAN_CLIENT);
+                async_hangup(sess);
                 return "Failed to set serial communication parameters";
+        }
 …
         size_t total = 0;
         while (total < cnt) {
                 ssize_t read = char_dev_read(phone, buf, cnt - total);
+                ssize_t read = char_dev_read(sess, buf, cnt - total);
                 if (read < 0) {
+                        async_req_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
+                        exch = async_exchange_begin(sess);
+                        async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
                             old_par, old_word_size, old_stop);
+                        async_exchange_end(exch);
                         free(buf);
+                        async_hangup(phone);
+                        devman_hangup_phone(DEVMAN_CLIENT);
+                        async_hangup(sess);
                         return "Failed read from serial device";
+                }
                 if ((size_t) read > cnt - total) {
+                        async_req_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
+                        exch = async_exchange_begin(sess);
+                        async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
                             old_par, old_word_size, old_stop);
+                        async_exchange_end(exch);
                         free(buf);
+                        async_hangup(phone);
+                        devman_hangup_phone(DEVMAN_CLIENT);
+                        async_hangup(sess);
                         return "Read more data than expected";
+                }
 …
                          * direction of data transfer.
                          */
                         ssize_t written = char_dev_write(phone, buf, read);
+                        ssize_t written = char_dev_write(sess, buf, read);
                         if (written < 0) {
+                                async_req_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
+                                exch = async_exchange_begin(sess);
+                                async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
                                     old_par, old_word_size, old_stop);
+                                async_exchange_end(exch);
                                 free(buf);
+                                async_hangup(phone);
+                                devman_hangup_phone(DEVMAN_CLIENT);
+                                async_hangup(sess);
                                 return "Failed write to serial device";
+                        }
                         if (written != read) {
+                                async_req_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
+                                exch = async_exchange_begin(sess);
+                                async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
                                     old_par, old_word_size, old_stop);
+                                async_exchange_end(exch);
                                 free(buf);
+                                async_hangup(phone);
+                                devman_hangup_phone(DEVMAN_CLIENT);
+                                async_hangup(sess);
                                 return "Written less data than read from serial device";
+                        }
 …
         size_t eot_size = str_size(EOT);
+        ssize_t written = char_dev_write(phone, (void *) EOT, eot_size);
+        async_req_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
+        ssize_t written = char_dev_write(sess, (void *) EOT, eot_size);
+        exch = async_exchange_begin(sess);
+        async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
             old_par, old_word_size, old_stop);
+        async_exchange_end(exch);
         free(buf);
+        async_hangup(phone);
+        devman_hangup_phone(DEVMAN_CLIENT);
+        async_hangup(sess);
         if (written < 0)

uspace/app/tester/ipc/ping_pong.c

-              r52a79081
+              ra33f0a6
 #include <stdlib.h>
 #include <sys/time.h>
 #include <ipc/ns.h>
+#include <ns.h>
 #include <async.h>
 #include <errno.h>
 …
                 size_t i;
                 for (i = 0; i < COUNT_GRANULARITY; i++) {
                         int retval = async_req_0_0(PHONE_NS, NS_PING);
+                        int retval = ns_ping();
                         if (retval != EOK) {

uspace/app/tester/mm/malloc1.c

-              r52a79081
+              ra33f0a6
 #include <stdio.h>
-#include <unistd.h>
 #include <stdlib.h>
 #include <malloc.h>
+#include "common.h"
 #include "../tester.h"
 …
  */
-/**
- * sizeof_array
- * @array array to determine the size of
+ *
- * Returns the size of @array in array elements.
- */
-#define sizeof_array(array) \
-        (sizeof(array) / sizeof((array)[0]))
-#define MAX_ALLOC (16 * 1024 * 1024)
-/*
- * Subphase control structures: subphase termination conditions,
- * probabilities of individual actions, subphase control structure.
- */
-typedef struct {
-        unsigned int max_cycles;
-        unsigned int no_memory;
-        unsigned int no_allocated;
-} sp_term_cond_s;
-typedef struct {
-        unsigned int alloc;
-        unsigned int free;
-} sp_action_prob_s;
-typedef struct {
-        const char *name;
-        sp_term_cond_s cond;
-        sp_action_prob_s prob;
-} subphase_s;
-/*
- * Phase control structures: The minimum and maximum block size that
- * can be allocated during the phase execution, phase control structure.
- */
-typedef struct {
-        size_t min_block_size;
-        size_t max_block_size;
-} ph_alloc_size_s;
-typedef struct {
-        const char *name;
-        ph_alloc_size_s alloc;
-        subphase_s *subphases;
-} phase_s;
 /*
  * Subphases are defined separately here. This is for two reasons:
 …
  * how many subphases a phase contains.
  */
 static subphase_s subphases_32B[] = {
+static subphase_t subphases_32B[] = {
+        {
                 .name = "Allocation",
 …
 };
 static subphase_s subphases_128K[] = {
+static subphase_t subphases_128K[] = {
+        {
                 .name = "Allocation",
 …
 };
 static subphase_s subphases_default[] = {
+static subphase_t subphases_default[] = {
+        {
                 .name = "Allocation",
 …
+        }
 };
 /*
  * Phase definitions.
  */
 static phase_s phases[] = {
+static phase_t phases[] = {
+        {
                 .name = "32 B memory blocks",
 …
 };
+/*
+ * Global error flag. The flag is set if an error
+ * is encountered (overlapping blocks, inconsistent
+ * block data, etc.)
+ */
+static bool error_flag = false;
+/*
+ * Memory accounting: the amount of allocated memory and the
+ * number and list of allocated blocks.
+ */
+static size_t mem_allocated;
+static size_t mem_blocks_count;
+static LIST_INITIALIZE(mem_blocks);
+typedef struct {
+        /* Address of the start of the block */
+        void *addr;
+        /* Size of the memory block */
+        size_t size;
+        /* link to other blocks */
+        link_t link;
+} mem_block_s;
+typedef mem_block_s *mem_block_t;
+/** init_mem
+ *
+ * Initializes the memory accounting structures.
+ *
+ */
+static void init_mem(void)
+static void do_subphase(phase_t *phase, subphase_t *subphase)
+{
+        mem_allocated = 0;
+        mem_blocks_count = 0;
+}
+static bool overlap_match(link_t *entry, void *addr, size_t size)
+{
+        mem_block_t mblk = list_get_instance(entry, mem_block_s, link);
+        /* Entry block control structure <mbeg, mend) */
+        uint8_t *mbeg = (uint8_t *) mblk;
+        uint8_t *mend = (uint8_t *) mblk + sizeof(mem_block_s);
+        /* Entry block memory <bbeg, bend) */
+        uint8_t *bbeg = (uint8_t *) mblk->addr;
+        uint8_t *bend = (uint8_t *) mblk->addr + mblk->size;
+        /* Data block <dbeg, dend) */
+        uint8_t *dbeg = (uint8_t *) addr;
+        uint8_t *dend = (uint8_t *) addr + size;
+        /* Check for overlaps */
+        if (((mbeg >= dbeg) && (mbeg < dend)) ||
+                ((mend > dbeg) && (mend <= dend)) ||
+                ((bbeg >= dbeg) && (bbeg < dend)) ||
+                ((bend > dbeg) && (bend <= dend)))
+                return true;
+        return false;
+}
+/** test_overlap
+ *
+ * Test whether a block starting at @addr overlaps with another, previously
+ * allocated memory block or its control structure.
+ *
+ * @param addr Initial address of the block
+ * @param size Size of the block
+ *
+ * @return false if the block does not overlap.
+ *
+ */
+static int test_overlap(void *addr, size_t size)
+{
+        link_t *entry;
+        bool fnd = false;
+        for (entry = mem_blocks.next; entry != &mem_blocks; entry = entry->next) {
+                if (overlap_match(entry, addr, size)) {
+                        fnd = true;
+                        break;
+                }
+        }
+        return fnd;
+}
+/** checked_malloc
+ *
+ * Allocate @size bytes of memory and check whether the chunk comes
+ * from the non-mapped memory region and whether the chunk overlaps
+ * with other, previously allocated, chunks.
+ *
+ * @param size Amount of memory to allocate
+ *
+ * @return NULL if the allocation failed. Sets the global error_flag to
+ *         true if the allocation succeeded but is illegal.
+ *
+ */
+static void *checked_malloc(size_t size)
+{
+        void *data;
+        /* Allocate the chunk of memory */
+        data = malloc(size);
+        if (data == NULL)
+                return NULL;
+        /* Check for overlaps with other chunks */
+        if (test_overlap(data, size)) {
+                TPRINTF("\nError: Allocated block overlaps with another "
+                        "previously allocated block.\n");
+                error_flag = true;
+        }
+        return data;
+}
+/** alloc_block
+ *
+ * Allocate a block of memory of @size bytes and add record about it into
+ * the mem_blocks list. Return a pointer to the block holder structure or
+ * NULL if the allocation failed.
+ *
+ * If the allocation is illegal (e.g. the memory does not come from the
+ * right region or some of the allocated blocks overlap with others),
+ * set the global error_flag.
+ *
+ * @param size Size of the memory block
+ *
+ */
+static mem_block_t alloc_block(size_t size)
+{
+        /* Check for allocation limit */
+        if (mem_allocated >= MAX_ALLOC)
+                return NULL;
+        /* Allocate the block holder */
+        mem_block_t block = (mem_block_t) checked_malloc(sizeof(mem_block_s));
+        if (block == NULL)
+                return NULL;
+        link_initialize(&block->link);
+        /* Allocate the block memory */
+        block->addr = checked_malloc(size);
+        if (block->addr == NULL) {
+                free(block);
+                return NULL;
+        }
+        block->size = size;
+        /* Register the allocated block */
+        list_append(&block->link, &mem_blocks);
+        mem_allocated += size + sizeof(mem_block_s);
+        mem_blocks_count++;
+        return block;
+}
+/** free_block
+ *
+ * Free the block of memory and the block control structure allocated by
+ * alloc_block. Set the global error_flag if an error occurs.
+ *
+ * @param block Block control structure
+ *
+ */
+static void free_block(mem_block_t block)
+{
+        /* Unregister the block */
+        list_remove(&block->link);
+        mem_allocated -= block->size + sizeof(mem_block_s);
+        mem_blocks_count--;
+        /* Free the memory */
+        free(block->addr);
+        free(block);
+}
+/** expected_value
+ *
+ * Compute the expected value of a byte located at @pos in memory
+ * block described by @blk.
+ *
+ * @param blk Memory block control structure
+ * @param pos Position in the memory block data area
+ *
+ */
+static inline uint8_t expected_value(mem_block_t blk, uint8_t *pos)
+{
+        return ((unsigned long) blk ^ (unsigned long) pos) & 0xff;
+}
+/** fill_block
+ *
+ * Fill the memory block controlled by @blk with data.
+ *
+ * @param blk Memory block control structure
+ *
+ */
+static void fill_block(mem_block_t blk)
+{
+        uint8_t *pos;
+        uint8_t *end;
+        for (pos = blk->addr, end = pos + blk->size; pos < end; pos++)
+                *pos = expected_value(blk, pos);
+}
+/** check_block
+ *
+ * Check whether the block @blk contains the data it was filled with.
+ * Set global error_flag if an error occurs.
+ *
+ * @param blk Memory block control structure
+ *
+ */
+static void check_block(mem_block_t blk)
+{
+        uint8_t *pos;
+        uint8_t *end;
+        for (pos = blk->addr, end = pos + blk->size; pos < end; pos++) {
+                if (*pos != expected_value (blk, pos)) {
+                        TPRINTF("\nError: Corrupted content of a data block.\n");
+                        error_flag = true;
+                        return;
+                }
+        }
+}
+static link_t *list_get_nth(link_t *list, unsigned int i)
+{
+        unsigned int cnt = 0;
+        link_t *entry;
+        for (entry = list->next; entry != list; entry = entry->next) {
+                if (cnt == i)
+                        return entry;
+                cnt++;
+        }
+        return NULL;
+}
+/** get_random_block
+ *
+ * Select a random memory block from the list of allocated blocks.
+ *
+ * @return Block control structure or NULL if the list is empty.
+ *
+ */
+static mem_block_t get_random_block(void)
+{
+        if (mem_blocks_count == 0)
+                return NULL;
+        unsigned int blkidx = rand() % mem_blocks_count;
+        link_t *entry = list_get_nth(&mem_blocks, blkidx);
+        if (entry == NULL) {
+                TPRINTF("\nError: Corrupted list of allocated memory blocks.\n");
+                error_flag = true;
+        }
+        return list_get_instance(entry, mem_block_s, link);
+}
+#define RETURN_IF_ERROR \
+{ \
+        if (error_flag) \
+                return; \
+}
+static void do_subphase(phase_s *phase, subphase_s *subphase)
+{
+        unsigned int cycles;
+        for (cycles = 0; /* always */; cycles++) {
+                if (subphase->cond.max_cycles &&
+                        cycles >= subphase->cond.max_cycles) {
+        for (unsigned int cycles = 0; /* always */; cycles++) {
+                if ((subphase->cond.max_cycles) &&
+                    (cycles >= subphase->cond.max_cycles)) {
                         /*
                          * We have performed the required number of
 …
                 unsigned int rnd = rand() % 100;
                 if (rnd < subphase->prob.alloc) {
+                        /* Compute a random number lying in interval <min_block_size, max_block_size> */
+                        /*
+                         * Compute a random number lying in interval
+                         * <min_block_size, max_block_size>
+                         */
                         int alloc = phase->alloc.min_block_size +
                             (rand() % (phase->alloc.max_block_size - phase->alloc.min_block_size + 1));
                         mem_block_t blk = alloc_block(alloc);
+                        mem_block_t *blk = alloc_block(alloc);
                         RETURN_IF_ERROR;
 …
                                         break;
+                                }
                         } else {
                                 TPRINTF("A");
                                 fill_block(blk);
+                                RETURN_IF_ERROR;
+                        }
                 } else if (rnd < subphase->prob.free) {
                         mem_block_t blk = get_random_block();
+                        mem_block_t *blk = get_random_block();
                         if (blk == NULL) {
                                 TPRINTF("F(R)");
 …
                                         break;
+                                }
                         } else {
                                 TPRINTF("R");
 …
+}
+static void do_phase(phase_s *phase)
+static void do_phase(phase_t *phase)
+{
+        unsigned int subno;
+        for (subno = 0; subno < 3; subno++) {
+                subphase_s *subphase = & phase->subphases [subno];
+        for (unsigned int subno = 0; subno < 3; subno++) {
+                subphase_t *subphase = &phase->subphases[subno];
                 TPRINTF(".. Sub-phase %u (%s)\n", subno + 1, subphase->name);
 …
         init_mem();
         unsigned int phaseno;
         for (phaseno = 0; phaseno < sizeof_array(phases); phaseno++) {
                 phase_s *phase = &phases[phaseno];
+        for (unsigned int phaseno = 0; phaseno < sizeof_array(phases);
+            phaseno++) {
+                phase_t *phase = &phases[phaseno];
                 TPRINTF("Entering phase %u (%s)\n", phaseno + 1, phase->name);
 …
+        }
+        TPRINTF("Cleaning up.\n");
+        done_mem();
         if (error_flag)
                 return "Test failed";

uspace/app/tester/tester.c

-              r52a79081
+              ra33f0a6
 #include "mm/malloc1.def"
 #include "mm/malloc2.def"
+#include "mm/malloc3.def"
+#include "mm/mapping1.def"
 #include "hw/serial/serial1.def"
 #include "hw/misc/virtchar1.def"
+#include "libext2/libext2_1.def"
 #include "devs/devman1.def"
+#include "devs/devman2.def"
         {NULL, NULL, NULL, false}
 };

uspace/app/tester/tester.h

-              r52a79081
+              ra33f0a6
 #include <sys/types.h>
 #include <bool.h>
+#include <stacktrace.h>
 #define IPC_TEST_SERVICE  10240
 …
 extern char **test_argv;
+/**
+ * sizeof_array
+ * @array array to determine the size of
+ *
+ * Returns the size of @array in array elements.
+ */
+#define sizeof_array(array) \
+        (sizeof(array) / sizeof((array)[0]))
 #define TPRINTF(format, ...) \
         { \
+        do { \
                 if (!test_quiet) { \
                         fprintf(stderr, format, ##__VA_ARGS__); \
+                        fprintf(stderr, (format), ##__VA_ARGS__); \
                 } \
+        }
+        } while (0)
+#define TSTACKTRACE() \
+        do { \
+                if (!test_quiet) { \
+                        stacktrace_print(); \
+                } \
+        } while (0)
 typedef const char *(*test_entry_t)(void);
 …
 extern const char *test_malloc1(void);
 extern const char *test_malloc2(void);
+extern const char *test_malloc3(void);
+extern const char *test_mapping1(void);
 extern const char *test_serial1(void);
 extern const char *test_virtchar1(void);
+extern const char *test_libext2_1(void);
 extern const char *test_devman1(void);
+extern const char *test_devman2(void);
 extern test_t tests[];

uspace/app/tetris/Makefile

r52a79081	ra33f0a6
34	34	shapes.c \
35	35	scores.c \
36		~~input.c \~~
37	36	tetris.c \
38	37	screen.c

uspace/app/tetris/scores.c

-              r52a79081
+              ra33f0a6
+/*      $OpenBSD: scores.c,v 1.11 2006/04/20 03:25:36 ray Exp $ */
+/*      $NetBSD: scores.c,v 1.2 1995/04/22 07:42:38 cgd Exp $   */
+/*-
+ * Copyright (c) 1992, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek and Darren F. Provine.
+/*
+ * Copyright (c) 2011 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:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University 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 REGENTS 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 REGENTS 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.
+ *
+ *      @(#)scores.c    8.1 (Berkeley) 5/31/93
+ *
+ * - 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.
+ */
+/** Attributations
+ *
+ * scores.c 8.1 (Berkeley) 5/31/93
+ * NetBSD: scores.c,v 1.2 1995/04/22 07:42:38 cgd
+ * OpenBSD: scores.c,v 1.11 2006/04/20 03:25:36 ray
+ *
+ * Based upon BSD Tetris
+ *
+ * Copyright (c) 1992, 1993
+ *      The Regents of the University of California.
+ *      Distributed under BSD license.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek and Darren F. Provine.
+ *
  */
 …
 #include <err.h>
 #include <time.h>
 #include "screen.h"
 #include "tetris.h"
 …
         int j;
         size_t off;
         console_event_t ev;
+        kbd_event_t ev;
         clear_screen();
 …
         while (1) {
                 fflush(stdout);
                 if (!console_get_event(fphone(stdin), &ev))
+                console_flush(console);
+                if (!console_get_kbd_event(console, &ev))
                         exit(1);

uspace/app/tetris/scores.h

-              r52a79081
+              ra33f0a6
+/*      $OpenBSD: scores.h,v 1.5 2003/06/03 03:01:41 millert Exp $      */
+/*      $NetBSD: scores.h,v 1.2 1995/04/22 07:42:40 cgd Exp $   */
+/*
+ * Copyright (c) 2011 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.
+ */
+/*-
+/** Attributations
+ *
+ * scores.h 8.1 (Berkeley) 5/31/93
+ * NetBSD: scores.h,v 1.2 1995/04/22 07:42:40 cgd
+ * OpenBSD: scores.h,v 1.5 2003/06/03 03:01:41 millert
+ *
+ * Based upon BSD Tetris
+ *
  * Copyright (c) 1992, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *      The Regents of the University of California.
+ *      Distributed under BSD license.
+ *
  * This code is derived from software contributed to Berkeley by
  * Chris Torek and Darren F. Provine.
+ *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the University 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 REGENTS 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 REGENTS 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.
+ *
- *      @(#)scores.h    8.1 (Berkeley) 5/31/93
  */
 …
 /** @file
  */
 /*

uspace/app/tetris/screen.c

-              r52a79081
+              ra33f0a6
+/*      $OpenBSD: screen.c,v 1.13 2006/04/20 03:25:36 ray Exp $ */
+/*      $NetBSD: screen.c,v 1.4 1995/04/29 01:11:36 mycroft Exp $       */
+/*-
+ * Copyright (c) 1992, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek and Darren F. Provine.
+/*
+ * Copyright (c) 2011 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:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University 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 REGENTS 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 REGENTS 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.
+ *
+ *      @(#)screen.c    8.1 (Berkeley) 5/31/93
+ *
+ * - 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.
+ */
+/** Attributations
+ *
+ * screen.c 8.1 (Berkeley) 5/31/93
+ * NetBSD: screen.c,v 1.4 1995/04/29 01:11:36 mycroft
+ * OpenBSD: screen.c,v 1.13 2006/04/20 03:25:36 ray
+ *
+ * Based upon BSD Tetris
+ *
+ * Copyright (c) 1992, 1993
+ *      The Regents of the University of California.
+ *      Distributed under BSD license.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek and Darren F. Provine.
+ *
  */
 …
 static const struct shape *lastshape;
+static suseconds_t timeleft = 0;
+console_ctrl_t *console;
 /*
 …
 static void start_standout(uint32_t color)
+{
         fflush(stdout);
         console_set_rgb_color(fphone(stdout), 0xffffff,
+        console_flush(console);
+        console_set_rgb_color(console, 0xffffff,
             use_color ? color : 0x000000);
+}
 …
 static void resume_normal(void)
+{
         fflush(stdout);
         console_set_style(fphone(stdout), STYLE_NORMAL);
+        console_flush(console);
+        console_set_style(console, STYLE_NORMAL);
+}
 void clear_screen(void)
+{
         console_clear(fphone(stdout));
+        console_clear(console);
         moveto(0, 0);
+}
 …
+{
         resume_normal();
         console_clear(fphone(stdout));
+        console_clear(console);
         curscore = -1;
         memset(curscreen, 0, sizeof(curscreen));
 …
 void scr_init(void)
+{
         console_cursor_visibility(fphone(stdout), 0);
+        console_cursor_visibility(console, 0);
         resume_normal();
         scr_clear();
 …
 void moveto(sysarg_t r, sysarg_t c)
+{
         fflush(stdout);
         console_set_pos(fphone(stdout), c, r);
+        console_flush(console);
+        console_set_pos(console, c, r);
+}
 …
 static int get_display_size(winsize_t *ws)
+{
         return console_get_size(fphone(stdout), &ws->ws_col, &ws->ws_row);
+        return console_get_size(console, &ws->ws_col, &ws->ws_row);
+}
 …
+{
         sysarg_t ccap;
         int rc = console_get_color_cap(fphone(stdout), &ccap);
+        int rc = console_get_color_cap(console, &ccap);
         if (rc != 0)
 …
 void scr_end(void)
+{
         console_cursor_visibility(fphone(stdout), 1);
+        console_cursor_visibility(console, 1);
+}
 …
                 resume_normal();
         fflush(stdout);
+        console_flush(console);
+}
 …
+}
+/** Sleep for the current turn time
+ *
+ * Eat any input that might be available.
+ *
+ */
+void tsleep(void)
+{
+        suseconds_t timeout = fallrate;
+        while (timeout > 0) {
+                kbd_event_t event;
+                if (!console_get_kbd_event_timeout(console, &event, &timeout))
+                        break;
+        }
+}
+/** Get char with timeout
+ *
+ */
+int tgetchar(void)
+{
+        /*
+         * Reset timeleft to fallrate whenever it is not positive
+         * and increase speed.
+         */
+        if (timeleft <= 0) {
+                faster();
+                timeleft = fallrate;
+        }
+        /*
+         * Wait to see if there is any input. If so, take it and
+         * update timeleft so that the next call to tgetchar()
+         * will not wait as long. If there is no input,
+         * make timeleft zero and return -1.
+         */
+        wchar_t c = 0;
+        while (c == 0) {
+                kbd_event_t event;
+                if (!console_get_kbd_event_timeout(console, &event, &timeleft)) {
+                        timeleft = 0;
+                        return -1;
+                }
+                if (event.type == KEY_PRESS)
+                        c = event.c;
+        }
+        return (int) c;
+}
+/** Get char without timeout
+ *
+ */
+int twait(void)
+{
+        wchar_t c = 0;
+        while (c == 0) {
+                kbd_event_t event;
+                if (!console_get_kbd_event(console, &event))
+                        return -1;
+                if (event.type == KEY_PRESS)
+                        c = event.c;
+        }
+        return (int) c;
+}
 /** @}
  */

uspace/app/tetris/screen.h

-              r52a79081
+              ra33f0a6
+/*      $OpenBSD: screen.h,v 1.5 2003/06/03 03:01:41 millert Exp $      */
+/*      $NetBSD: screen.h,v 1.2 1995/04/22 07:42:42 cgd Exp $   */
+/*
+ * Copyright (c) 2011 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.
+ */
+/*-
+/** Attributations
+ *
+ * screen.h 8.1 (Berkeley) 5/31/93
+ * NetBSD: screen.h,v 1.2 1995/04/22 07:42:42 cgd
+ * OpenBSD: screen.h,v 1.5 2003/06/03 03:01:41 millert
+ *
+ * Based upon BSD Tetris
+ *
  * Copyright (c) 1992, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *      The Regents of the University of California.
+ *      Distributed under BSD license.
+ *
  * This code is derived from software contributed to Berkeley by
  * Chris Torek and Darren F. Provine.
+ *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the University 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 REGENTS 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 REGENTS 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.
+ *
- *      @(#)screen.h    8.1 (Berkeley) 5/31/93
  */
 …
 #include <sys/types.h>
+#include <io/console.h>
 #include <async.h>
 #include <bool.h>
 …
 } winsize_t;
+extern console_ctrl_t *console;
 extern winsize_t winsize;
 …
 extern void clear_screen(void);
-/* just calls putchar; for tputs */
 extern int put(int);
 extern void scr_clear(void);
 …
 extern void scr_update(void);
+extern void tsleep(void);
+extern int tgetchar(void);
+extern int twait(void);
 /** @}
  */

uspace/app/tetris/shapes.c

-              r52a79081
+              ra33f0a6
+/*      $OpenBSD: shapes.c,v 1.8 2004/07/10 07:26:24 deraadt Exp $      */
+/*      $NetBSD: shapes.c,v 1.2 1995/04/22 07:42:44 cgd Exp $   */
+/*
+ * Copyright (c) 2011 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.
+ */
+/*-
+/** Attributations
+ *
+ * shapes.c 8.1 (Berkeley) 5/31/93
+ * NetBSD: shapes.c,v 1.2 1995/04/22 07:42:44 cgd
+ * OpenBSD: shapes.c,v 1.8 2004/07/10 07:26:24 deraadt
+ *
+ * Based upon BSD Tetris
+ *
  * Copyright (c) 1992, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *      The Regents of the University of California.
+ *      Distributed under BSD license.
+ *
  * This code is derived from software contributed to Berkeley by
  * Chris Torek and Darren F. Provine.
+ *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the University 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 REGENTS 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 REGENTS 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.
+ *
- *      @(#)shapes.c    8.1 (Berkeley) 5/31/93
  */

uspace/app/tetris/tetris.c

-              r52a79081
+              ra33f0a6
+/*      $OpenBSD: tetris.c,v 1.21 2006/04/20 03:24:12 ray Exp $ */
+/*      $NetBSD: tetris.c,v 1.2 1995/04/22 07:42:47 cgd Exp $   */
+/*-
+ * Copyright (c) 1992, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek and Darren F. Provine.
+/*
+ * Copyright (c) 2011 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:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University 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 REGENTS 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 REGENTS 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.
+ *
+ *      @(#)tetris.c    8.1 (Berkeley) 5/31/93
+ *
+ * - 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.
+ */
+/** Attributations
+ *
+ * tetris.c 8.1 (Berkeley) 5/31/93
+ * NetBSD: tetris.c,v 1.2 1995/04/22 07:42:47 cgd
+ * OpenBSD: tetris.c,v 1.21 2006/04/20 03:24:12 ray
+ *
+ * Based upon BSD Tetris
+ *
+ * Copyright (c) 1992, 1993
+ *      The Regents of the University of California.
+ *      Distributed under BSD license.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek and Darren F. Provine.
+ *
  */
 …
 #include <unistd.h>
 #include <getopt.h>
-#include "input.h"
 #include "scores.h"
 #include "screen.h"
 …
         int ch;
+        console = console_init(stdin, stdout);
         keys = "jkl pq";
         classic = 0;
         showpreview = 1;
+        showpreview = 1;
         while ((ch = getopt(argc, argv, "ck:ps")) != -1)
 …
                                         scr_msg(key_msg, 0);
                                         scr_msg(msg, 1);
                                         (void) fflush(stdout);
                                 } while (rwait((struct timeval *) NULL) == -1);
+                                        console_flush(console);
+                                } while (!twait());
                                 scr_msg(msg, 0);

uspace/app/tetris/tetris.h

-              r52a79081
+              ra33f0a6
+/*      $OpenBSD: tetris.h,v 1.9 2003/06/03 03:01:41 millert Exp $      */
+/*      $NetBSD: tetris.h,v 1.2 1995/04/22 07:42:48 cgd Exp $   */
+/*
+ * Copyright (c) 2011 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.
+ */
+/*-
+/** Attributations
+ *
+ * tetris.h 8.1 (Berkeley) 5/31/93
+ * NetBSD: tetris.h,v 1.2 1995/04/22 07:42:48 cgd
+ * OpenBSD: tetris.h,v 1.9 2003/06/03 03:01:41 millert
+ *
+ * Based upon BSD Tetris
+ *
  * Copyright (c) 1992, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *      The Regents of the University of California.
+ *      Distributed under BSD license.
+ *
  * This code is derived from software contributed to Berkeley by
  * Chris Torek and Darren F. Provine.
+ *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the University 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 REGENTS 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 REGENTS 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.
+ *
- *      @(#)tetris.h    8.1 (Berkeley) 5/31/93
  */

uspace/app/top/Makefile

-              r52a79081
+              ra33f0a6
 SOURCES = \
         top.c \
+        screen.c \
+        input.c
+        screen.c
 include $(USPACE_PREFIX)/Makefile.common

uspace/app/top/screen.c

-              r52a79081
+              ra33f0a6
 #include "top.h"
+#define USEC_COUNT  1000000
 static sysarg_t warn_col = 0;
 static sysarg_t warn_row = 0;
+static suseconds_t timeleft = 0;
+console_ctrl_t *console;
 static void screen_style_normal(void)
+{
         fflush(stdout);
         console_set_style(fphone(stdout), STYLE_NORMAL);
+        console_flush(console);
+        console_set_style(console, STYLE_NORMAL);
+}
 static void screen_style_inverted(void)
+{
         fflush(stdout);
         console_set_style(fphone(stdout), STYLE_INVERTED);
+        console_flush(console);
+        console_set_style(console, STYLE_INVERTED);
+}
 static void screen_moveto(sysarg_t col, sysarg_t row)
+{
         fflush(stdout);
         console_set_pos(fphone(stdout), col, row);
+        console_flush(console);
+        console_set_pos(console, col, row);
+}
 static void screen_get_pos(sysarg_t *col, sysarg_t *row)
+{
         fflush(stdout);
         console_get_pos(fphone(stdout), col, row);
+        console_flush(console);
+        console_get_pos(console, col, row);
+}
 static void screen_get_size(sysarg_t *col, sysarg_t *row)
+{
         fflush(stdout);
         console_get_size(fphone(stdout), col, row);
+        console_flush(console);
+        console_get_size(console, col, row);
+}
 …
         if (clear) {
                 fflush(stdout);
                 console_clear(fphone(stdout));
+                console_flush(console);
+                console_clear(console);
+        }
 …
 void screen_init(void)
+{
+        fflush(stdout);
+        console_cursor_visibility(fphone(stdout), false);
+        console = console_init(stdin, stdout);
+        console_flush(console);
+        console_cursor_visibility(console, false);
         screen_restart(true);
 …
         screen_restart(true);
         fflush(stdout);
         console_cursor_visibility(fphone(stdout), true);
+        console_flush(console);
+        console_cursor_visibility(console, true);
+}
 …
+        }
         fflush(stdout);
+        console_flush(console);
+}
 …
         screen_newline();
+        fflush(stdout);
+        console_flush(console);
+}
+/** Get char with timeout
+ *
+ */
+int tgetchar(unsigned int sec)
+{
+        /*
+         * Reset timeleft whenever it is not positive.
+         */
+        if (timeleft <= 0)
+                timeleft = sec * USEC_COUNT;
+        /*
+         * Wait to see if there is any input. If so, take it and
+         * update timeleft so that the next call to tgetchar()
+         * will not wait as long. If there is no input,
+         * make timeleft zero and return -1.
+         */
+        wchar_t c = 0;
+        while (c == 0) {
+                kbd_event_t event;
+                if (!console_get_kbd_event_timeout(console, &event, &timeleft)) {
+                        timeleft = 0;
+                        return -1;
+                }
+                if (event.type == KEY_PRESS)
+                        c = event.c;
+        }
+        return (int) c;
+}

uspace/app/top/screen.h

-              r52a79081
+              ra33f0a6
 #define TOP_SCREEN_H_
+#include <io/console.h>
 #include "top.h"
+extern console_ctrl_t *console;
 extern void screen_init(void);
 …
 extern void print_warning(const char *, ...);
+extern int tgetchar(unsigned int);
 #endif

uspace/app/top/top.c

r52a79081	ra33f0a6
46	46	#include <sort.h>
47	47	#include "screen.h"
48		~~#include "input.h"~~
49	48	#include "top.h"
50	49

uspace/app/trace/ipc_desc.c

-              r52a79081
+              ra33f0a6
  */
+#include <ipc/common.h>
+#include <kernel/ipc/ipc.h>
+#include <kernel/ipc/ipc_methods.h>
 #include <stdlib.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" },
+        { IPC_M_PHONE_HUNGUP,  "PHONE_HUNGUP" },
+        { IPC_M_CONNECT_ME,    "CONNECT_ME" },
+        { IPC_M_CONNECT_ME_TO, "CONNECT_ME_TO" },
+        { IPC_M_CONNECT_TO_ME, "CONNECT_TO_ME" },
+        { 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,         "DEBUG" },
         /* Terminating entry */
         { 0, NULL }

uspace/app/trace/ipcp.c

-              r52a79081
+              ra33f0a6
 #include <adt/hash_table.h>
 #include <sys/typefmt.h>
+#include <kernel/ipc/ipc_methods.h>
 #include "ipc_desc.h"
 #include "proto.h"
 …
         proto_t *proto;
         int cphone;
         sysarg_t *resp;
         oper_t *oper;
         int i;
+//      printf("parse_answer\n");
         phone = pcall->phone_hash;
         method = IPC_GET_IMETHOD(pcall->question);
         retval = IPC_GET_RETVAL(*answer);
         resp = answer->args;
         if ((display_mask & DM_IPC) != 0) {
                 printf("Response to %p: retval=%" PRIdn ", args = (%" PRIun ", "
 …
                     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)) {
+                if ((oper != NULL) &&
+                    ((oper->rv_type != V_VOID) || (oper->respc > 0))) {
                         printf("->");
                         if (oper->rv_type != V_VOID) {
                                 putchar(' ');
 …
                                 putchar('(');
                                 for (i = 1; i <= oper->respc; ++i) {
+                                        if (i > 1) printf(", ");
+                                        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) {
+        if ((phone == PHONE_NS) && (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;
+                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);
+                }
+                    proto->name);
+                }
                 ipcp_connection_set(cphone, 0, proto);
+        }
 …
         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 */
 …
                 return;
+        }
         hash = hash & ~IPC_CALLID_ANSWERED;
         key[0] = hash;
         item = hash_table_find(&pending_calls, key);
+        if (item == NULL) return; // No matching question found
+        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);

uspace/app/trace/syscalls.c

-              r52a79081
+              ra33f0a6
     [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_SYSINFO_GET_DATA] = { "sysinfo_get_data",              5,      V_ERRNO },
     [SYS_DEBUG_ENABLE_CONSOLE] = { "debug_enable_console", 0,   V_ERRNO },
+    [SYS_DEBUG_ACTIVATE_CONSOLE] = { "debug_activate_console", 0,       V_ERRNO },
     [SYS_IPC_CONNECT_KBOX] = { "ipc_connect_kbox",      1,      V_ERRNO }
 };

uspace/app/trace/trace.c

-              r52a79081
+              ra33f0a6
 ipc_call_t thread_ipc_req[THBUF_SIZE];
 int phoneid;
+async_sess_t *sess;
 bool abort_trace;
 …
 static bool cev_valid;
 static console_event_t cev;
+static kbd_event_t cev;
 void thread_trace_start(uintptr_t thread_hash);
 …
 static int connect_task(task_id_t task_id)
+{
+        int rc;
+        rc = async_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) {
+        async_sess_t *ksess = async_connect_kbox(task_id);
+        if (!ksess) {
+                if (errno == 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 errno;
+                }
                 printf("Error connecting\n");
+                printf("ipc_connect_task(%" PRIu64 ") -> %d ", task_id, rc);
+                return rc;
+        }
+        phoneid = rc;
+        rc = udebug_begin(phoneid);
+                printf("ipc_connect_task(%" PRIu64 ") -> %d ", task_id, errno);
+                return errno;
+        }
+        int rc = udebug_begin(ksess);
         if (rc < 0) {
                 printf("udebug_begin() -> %d\n", rc);
                 return rc;
+        }
         rc = udebug_set_evmask(phoneid, UDEBUG_EM_ALL);
+        rc = udebug_set_evmask(ksess, UDEBUG_EM_ALL);
         if (rc < 0) {
                 printf("udebug_set_evmask(0x%x) -> %d\n ", UDEBUG_EM_ALL, rc);
                 return rc;
+        }
+        sess = ksess;
         return 0;
+}
 …
         int i;
         rc = udebug_thread_read(phoneid, thread_hash_buf,
+        rc = udebug_thread_read(sess, thread_hash_buf,
                 THBUF_SIZE*sizeof(unsigned), &tb_copied, &tb_needed);
         if (rc < 0) {
 …
         memset(&call, 0, sizeof(call));
         rc = udebug_mem_read(phoneid, &call.args, sc_args[1], sizeof(call.args));
+        rc = udebug_mem_read(sess, &call.args, sc_args[1], sizeof(call.args));
         if (rc >= 0) {
 …
         ipc_call_t question, reply;
         int rc;
+        int phoneidx;
+//      printf("sc_ipc_call_sync_fast()\n");
+        phoneidx = sc_args[0];
+        int phoneid;
+        phoneid = sc_args[0];
         IPC_SET_IMETHOD(question, sc_args[1]);
 …
         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);
+        rc = udebug_mem_read(sess, &reply.args, sc_args[5], sizeof(reply.args));
+        if (rc < 0)
+                return;
+        ipcp_call_sync(phoneid, &question, &reply);
+}
 …
         memset(&question, 0, sizeof(question));
         rc = udebug_mem_read(phoneid, &question.args, sc_args[1],
+        rc = udebug_mem_read(sess, &question.args, sc_args[1],
             sizeof(question.args));
 …
         memset(&reply, 0, sizeof(reply));
         rc = udebug_mem_read(phoneid, &reply.args, sc_args[2],
+        rc = udebug_mem_read(sess, &reply.args, sc_args[2],
             sizeof(reply.args));
 …
         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) {
+        rc = udebug_mem_read(sess, &call, sc_args[0], sizeof(call));
+        if (rc >= 0)
                 ipcp_call_in(&call, sc_rc);
+        }
+}
 …
         /* Read syscall arguments */
+        rc = udebug_args_read(phoneid, thread_hash, sc_args);
+        async_serialize_start();
+//      printf("[%d] ", thread_id);
+        rc = udebug_args_read(sess, thread_hash, sc_args);
         if (rc < 0) {
                 printf("error\n");
-                async_serialize_end();
                 return;
+        }
 …
                 break;
+        }
-        async_serialize_end();
+}
 …
         /* Read syscall arguments */
+        rc = udebug_args_read(phoneid, thread_hash, sc_args);
+        async_serialize_start();
+        rc = udebug_args_read(sess, thread_hash, sc_args);
 //      printf("[%d] ", thread_id);
 …
         if (rc < 0) {
                 printf("error\n");
-                async_serialize_end();
                 return;
+        }
 …
                 break;
+        }
-        async_serialize_end();
+}
 static void event_thread_b(uintptr_t hash)
+{
-        async_serialize_start();
         printf("New thread, hash %p\n", (void *) hash);
-        async_serialize_end();
         thread_trace_start(hash);
+}
 …
                 /* Run thread until an event occurs */
                 rc = udebug_go(phoneid, thread_hash,
+                rc = udebug_go(sess, thread_hash,
                     &ev_type, &val0, &val1);
 …
+{
         (void) arg;
+        console_ctrl_t *console = console_init(stdin, stdout);
         while (true) {
                 fibril_mutex_lock(&state_lock);
 …
                         fibril_condvar_wait(&state_cv, &state_lock);
                 fibril_mutex_unlock(&state_lock);
                 if (!console_get_event(fphone(stdin), &cev))
+                if (!console_get_kbd_event(console, &cev))
                         return -1;
                 fibril_mutex_lock(&state_lock);
                 cev_valid = true;
                 fibril_condvar_broadcast(&state_cv);
                 fibril_mutex_unlock(&state_lock);
+                fibril_mutex_unlock(&state_lock);
+        }
+}
 …
 static void trace_task(task_id_t task_id)
+{
         console_event_t ev;
+        kbd_event_t ev;
         bool done;
         int i;
 …
                 case KC_P:
                         printf("Pause...\n");
                         rc = udebug_stop(phoneid, thash);
+                        rc = udebug_stop(sess, thash);
                         if (rc != EOK)
                                 printf("Error: stop -> %d\n", rc);
 …
         printf("\nTerminate debugging session...\n");
         abort_trace = true;
         udebug_end(phoneid);
         async_hangup(phoneid);
+        udebug_end(sess);
+        async_hangup(sess);
         ipcp_cleanup();
 …
         proto_register(SERVICE_VFS, p);
+#if 0
         p = proto_new("console");
 …
         proto_console = p;
         proto_register(SERVICE_CONSOLE, p);
+#endif
+}

Context Navigation

Changeset a33f0a6 in mainline for uspace/app

Legend:

Download in other formats: