Changeset c6588ce in mainline for uspace/app

Timestamp:

2012-05-05T08:12:17Z (14 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

ee04c28

Parents:

2cc7f16 (diff), d21e935c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

Location:

uspace/app

Files:

• bdsh/cmds/modules/cat/cat.c (modified) (10 diffs)
• bdsh/cmds/modules/cat/cat.h (modified) (1 diff)
• bdsh/cmds/modules/ls/ls.c (modified) (15 diffs)
• bdsh/cmds/modules/ls/ls.h (added)
• bdsh/cmds/modules/touch/entry.h (modified) (1 diff)
• bdsh/cmds/modules/touch/touch.c (modified) (5 diffs)
• bdsh/cmds/modules/touch/touch.h (modified) (1 diff)
• bdsh/cmds/modules/touch/touch_def.h (modified) (1 diff)
• binutils/Makefile (modified) (1 diff)
• getterm/Makefile (modified) (1 diff)
• getterm/version.c (modified) (2 diffs)
• inetcfg/Makefile (moved) (moved from uspace/srv/net/il/ip/Makefile ) (2 diffs)
• inetcfg/inetcfg.c (added)
• init/init.c (modified) (2 diffs)
• mkexfat/Makefile (moved) (moved from uspace/srv/net/il/arp/Makefile ) (2 diffs)
• mkexfat/exfat.h (added)
• mkexfat/mkexfat.c (added)
• mkexfat/upcase.h (added)
• netecho/netecho.c (modified) (1 diff)
• netecho/print_error.c (modified) (2 diffs)
• ping/Makefile (modified) (2 diffs)
• ping/ping.c (modified) (2 diffs)
• ping/print_error.c (deleted)
• ping/print_error.h (deleted)
• sbi/src/run_texpr.c (modified) (3 diffs)
• sportdmp/sportdmp.c (modified) (5 diffs)
• sysinfo/sysinfo.c (modified) (4 diffs)
• tester/Makefile (modified) (1 diff)
• tester/fault/fault2.c (modified) (1 diff)
• tester/hw/serial/serial1.c (modified) (5 diffs)
• tester/ipc/starve.c (moved) (moved from uspace/lib/c/generic/net/icmp_common.c ) (2 diffs)
• tester/ipc/starve.def (added)
• tester/print/print1.c (modified) (2 diffs)
• tester/tester.c (modified) (1 diff)
• tester/tester.h (modified) (1 diff)
• top/screen.c (modified) (15 diffs)
• top/screen.h (modified) (1 diff)
• top/top.c (modified) (7 diffs)
• top/top.h (modified) (4 diffs)
• trace/ipc_desc.c (modified) (1 diff)
• websrv/websrv.c (modified) (1 diff)

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

@@ -52 +52 @@
 #define CAT_VERSION "0.0.1"
 #define CAT_DEFAULT_BUFLEN 1024
-
-static const char *cat_oops = "That option is not yet supported\n";
+#define CAT_FULL_FILE 0
+
 static const char *hexchars = "0123456789abcdef";
 
@@ -163 +163 @@
 }
 
-static unsigned int cat_file(const char *fname, size_t blen, bool hex)
+static unsigned int cat_file(const char *fname, size_t blen, bool hex,
+    off64_t head, off64_t tail, bool tail_first)
 {
         int fd, bytes = 0, count = 0, reads = 0;
         char *buff = NULL;
         int i;
-        size_t offset = 0;
+        size_t offset = 0, copied_bytes = 0;
+        off64_t file_size = 0, length = 0;
 
         fd = open(fname, O_RDONLY);
@@ -183 +185 @@
         }
 
+        if (tail != CAT_FULL_FILE) {
+                file_size = lseek(fd, 0, SEEK_END);
+                if (head == CAT_FULL_FILE) {
+                        head = file_size;
+                        length = tail;
+                } else if (tail_first) {
+                        length = head;
+                } else {
+                        if (tail > head)
+                                tail = head;
+                        length = tail;
+                }
+
+                if (tail_first) {
+                        lseek(fd, (tail >= file_size) ? 0 : (file_size - tail), SEEK_SET);
+                } else {
+                        lseek(fd, ((head - tail) >= file_size) ? 0 : (head - tail), SEEK_SET);
+                }
+        } else
+                length = head;
+
         do {
-                bytes = read(fd, buff, blen);
+                bytes = read(fd, buff + copied_bytes, (
+                        (length != CAT_FULL_FILE && length - (off64_t)count <= (off64_t)(blen - copied_bytes)) ?
+                        (size_t)(length - count) :
+                        (blen - copied_bytes) ) );
+                bytes += copied_bytes;
+                copied_bytes = 0;
+
                 if (bytes > 0) {
-                        count += bytes;
                         buff[bytes] = '\0';
                         offset = 0;
@@ -193 +221 @@
                                         paged_char(hexchars[((uint8_t)buff[i])/16]);
                                         paged_char(hexchars[((uint8_t)buff[i])%16]);
+                                        paged_char(((count+i+1) & 0xf) == 0 ? '\n' : ' ');
                                 }
                                 else {
@@ -199 +228 @@
                                                 /* Reached end of string */
                                                 break;
+                                        } else if (c == U_SPECIAL && offset + 2 >= (size_t)bytes) {
+                                                /* If an extended character is cut off due to the size of the buffer,
+                                                   we will copy it over to the next buffer so it can be read correctly. */
+                                                copied_bytes = bytes - offset + 1;
+                                                memcpy(buff, buff + offset - 1, copied_bytes);
+                                                break;
                                         }
                                         paged_char(c);
@@ -204 +239 @@
                                 
                         }
+                        count += bytes;
                         reads++;
                 }
-        } while (bytes > 0 && !should_quit);
+        } while (bytes > 0 && !should_quit && (count < length || length == CAT_FULL_FILE));
 
         close(fd);
@@ -223 +259 @@
 int cmd_cat(char **argv)
 {
-        unsigned int argc, i, ret = 0, buffer = 0;
+        unsigned int argc, i, ret = 0;
+        size_t buffer = 0;
         int c, opt_ind;
+        aoff64_t head = CAT_FULL_FILE, tail = CAT_FULL_FILE;
         bool hex = false;
         bool more = false;
+        bool tailFirst = false;
         sysarg_t rows, cols;
         int rc;
@@ -254 +293 @@
                         return CMD_SUCCESS;
                 case 'H':
-                        printf("%s", cat_oops);
-                        return CMD_FAILURE;
+                        if (!optarg || str_uint64_t(optarg, NULL, 10, false, &head) != EOK ) {
+                                puts("Invalid head size\n");
+                                return CMD_FAILURE;
+                        }
+                        break;
                 case 't':
-                        printf("%s", cat_oops);
-                        return CMD_FAILURE;
+                        if (!optarg || str_uint64_t(optarg, NULL, 10, false, &tail) != EOK ) {
+                                puts("Invalid tail size\n");
+                                return CMD_FAILURE;
+                        }
+                        if (head == CAT_FULL_FILE)
+                                tailFirst = true;
+                        break;
                 case 'b':
-                        printf("%s", cat_oops);
+                        if (!optarg || str_size_t(optarg, NULL, 10, false, &buffer) != EOK ) {
+                                puts("Invalid buffer size\n");
+                                return CMD_FAILURE;
+                        }
                         break;
                 case 'm':
@@ -279 +329 @@
         }
 
-        if (buffer <= 0)
+        if (buffer < 4)
                 buffer = CAT_DEFAULT_BUFLEN;
         
@@ -295 +345 @@
 
         for (i = optind; argv[i] != NULL && !should_quit; i++)
-                ret += cat_file(argv[i], buffer, hex);
+                ret += cat_file(argv[i], buffer, hex, head, tail, tailFirst);
 
         if (ret)

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

@@ -4 +4 @@
 /* Prototypes for the cat command, excluding entry points */
 
-static unsigned int cat_file(const char *, size_t, bool);
+static unsigned int cat_file(const char *, size_t, bool, off64_t, off64_t, bool);
 
 #endif /* CAT_H */

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

@@ -42 +42 @@
 #include <sort.h>
 
+#include "ls.h"
 #include "errors.h"
 #include "config.h"
@@ -48 +49 @@
 #include "cmds.h"
 
-/* Various values that can be returned by ls_scope() */
-#define LS_BOGUS 0
-#define LS_FILE  1
-#define LS_DIR   2
-
-/** Structure to represent a directory entry.
- *
- * Useful to keep together important information
- * for sorting directory entries.
- */
-struct dir_elem_t {
-        char *name;
-        struct stat s;
-};
-
 static const char *cmdname = "ls";
+
+static ls_job_t ls;
 
 static struct option const long_options[] = {
         { "help", no_argument, 0, 'h' },
         { "unsort", no_argument, 0, 'u' },
+        { "recursive", no_argument, 0, 'r' },
         { 0, 0, 0, 0 }
 };
+
+/* Prototypes for the ls command, excluding entry points. */
+static unsigned int ls_start(ls_job_t *);
+static void ls_print(struct dir_elem_t *);
+static int ls_cmp(void *, void *, void *);
+static signed int ls_scan_dir(const char *, DIR *, struct dir_elem_t **);
+static unsigned int ls_recursive(const char *, DIR *);
+static unsigned int ls_scope(const char *, struct dir_elem_t *);
+
+static unsigned int ls_start(ls_job_t *ls)
+{
+        ls->recursive = 0;
+        ls->sort = 1;
+
+        return 1;
+}
 
 /** Print an entry.
@@ -92 +97 @@
 }
 
-
 /** Compare 2 directory elements.
  *
@@ -127 +131 @@
  *                              0 otherwise.
  */
-static void ls_scan_dir(const char *d, DIR *dirp, int sort)
+static signed int ls_scan_dir(const char *d, DIR *dirp, 
+    struct dir_elem_t **dir_list_ptr)
 {
         int alloc_blocks = 20;
@@ -140 +145 @@
         
         if (!dirp)
-                return;
+                return -1;
 
         buff = (char *) malloc(PATH_MAX);
         if (!buff) {
                 cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
-                return;
+                return -1;
         }
         
@@ -152 +157 @@
                 cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
                 free(buff);
-                return;
+                return -1;
         }
         
@@ -187 +192 @@
         }
         
-        if (sort) {
+        if (ls.sort) {
                 if (!qsort(&tosort[0], nbdirs, sizeof(struct dir_elem_t),
                     ls_cmp, NULL)) {
@@ -196 +201 @@
         for (i = 0; i < nbdirs; i++)
                 ls_print(&tosort[i]);
+
+        /* Populate the directory list. */
+        if (ls.recursive) {
+                tmp = (struct dir_elem_t *) realloc(*dir_list_ptr, 
+                    nbdirs * sizeof(struct dir_elem_t));
+                if (!tmp) {
+                        cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
+                        goto out;
+                } 
+                *dir_list_ptr = tmp;
+
+                for (i = 0; i < nbdirs; i++) {
+                        (*dir_list_ptr)[i].name = str_dup(tosort[i].name);
+                        if (!(*dir_list_ptr)[i].name) {
+                                cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
+                                goto out;
+                        }
+                }
+        }
         
 out:
@@ -202 +226 @@
         free(tosort);
         free(buff);
+
+        return nbdirs;
+}
+
+/** Visit a directory recursively.
+ *
+ * ls_recursive visits all the subdirectories recursively and
+ * prints the files and directories in them.
+ *
+ * @param path  Path the current directory being visited.
+ * @param dirp  Directory stream.
+ */
+static unsigned int ls_recursive(const char *path, DIR *dirp)
+{
+        int i, nbdirs, ret;
+        unsigned int scope;
+        char *subdir_path;
+        DIR *subdirp;
+        struct dir_elem_t *dir_list;
+        
+        const char * const trailing_slash = "/";
+
+        nbdirs = 0;
+        dir_list = (struct dir_elem_t *) malloc(sizeof(struct dir_elem_t));
+
+        printf("\n%s:\n", path);
+
+        subdir_path = (char *) malloc(PATH_MAX);
+        if (!subdir_path) {
+                ret = CMD_FAILURE;
+                goto out;
+        }
+
+        nbdirs = ls_scan_dir(path, dirp, &dir_list); 
+        if (nbdirs == -1) {
+                ret = CMD_FAILURE;
+                goto out;
+        }
+
+        for (i = 0; i < nbdirs; ++i) {
+                memset(subdir_path, 0, PATH_MAX);
+
+                if (str_size(subdir_path) + str_size(path) + 1 <= PATH_MAX)
+                        str_append(subdir_path, PATH_MAX, path);
+                if (path[str_size(path)-1] != '/' &&
+                    str_size(subdir_path) + str_size(trailing_slash) + 1 <= PATH_MAX)
+                        str_append(subdir_path, PATH_MAX, trailing_slash);
+                if (str_size(subdir_path) +
+                    str_size(dir_list[i].name) + 1 <= PATH_MAX)
+                        str_append(subdir_path, PATH_MAX, dir_list[i].name);
+
+                scope = ls_scope(subdir_path, &dir_list[i]);
+                switch (scope) {
+                case LS_FILE:
+                        break;
+                case LS_DIR:
+                        subdirp = opendir(subdir_path);
+                        if (!subdirp) {
+                                /* May have been deleted between scoping it and opening it */
+                                cli_error(CL_EFAIL, "Could not stat %s", dir_list[i].name);
+                                ret = CMD_FAILURE;
+                                goto out;
+                        }
+
+                        ret = ls_recursive(subdir_path, subdirp);
+                        closedir(subdirp);
+                        if (ret == CMD_FAILURE)
+                                goto out;
+                        break;
+                case LS_BOGUS:
+                        ret = CMD_FAILURE;
+                        goto out;
+                }       
+        }
+   
+        ret = CMD_SUCCESS; 
+
+out:
+        for (i = 0; i < nbdirs; i++)
+                free(dir_list[i].name);
+        free(dir_list);
+        free(subdir_path);
+
+        return ret;
+}
+
+static unsigned int ls_scope(const char *path, struct dir_elem_t *de)
+{
+        if (stat(path, &de->s)) {
+                cli_error(CL_ENOENT, path);
+                return LS_BOGUS;
+        }
+
+        if (de->s.is_file)
+                return LS_FILE;
+        else if (de->s.is_directory)
+                return LS_DIR;
+
+        return LS_BOGUS;
 }
 
@@ -215 +338 @@
                 "Options:\n"
                 "  -h, --help       A short option summary\n"
-                "  -u, --unsort     Do not sort directory entries\n",
+                "  -u, --unsort     Do not sort directory entries\n"
+                "  -r, --recursive  List subdirectories recursively\n",
                 cmdname);
         }
@@ -228 +352 @@
         DIR *dirp;
         int c, opt_ind;
-        int sort = 1;
+        int ret = 0;
+        unsigned int scope;
+
+        if (!ls_start(&ls)) {
+                cli_error(CL_EFAIL, "%s: Could not initialize", cmdname);
+                return CMD_FAILURE;
+        }
 
         argc = cli_count_args(argv);
         
         for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
-                c = getopt_long(argc, argv, "hu", long_options, &opt_ind);
+                c = getopt_long(argc, argv, "hur", long_options, &opt_ind);
                 switch (c) {
                 case 'h':
@@ -239 +369 @@
                         return CMD_SUCCESS;
                 case 'u':
-                        sort = 0;
+                        ls.sort = 0;
+                        break;
+                case 'r':
+                        ls.recursive = 1;
                         break;
                 }
@@ -251 +384 @@
                 return CMD_FAILURE;
         }
-        memset(de.name, 0, sizeof(PATH_MAX));
+        memset(de.name, 0, PATH_MAX);
         
         if (argc == 0)
@@ -257 +390 @@
         else
                 str_cpy(de.name, PATH_MAX, argv[optind]);
-        
-        if (stat(de.name, &de.s)) {
-                cli_error(CL_ENOENT, de.name);
-                free(de.name);
-                return CMD_FAILURE;
-        }
-
-        if (de.s.is_file) {
+
+        scope = ls_scope(de.name, &de);
+        switch (scope) {
+        case LS_FILE:
                 ls_print(&de);
-        } else {
+                break;
+        case LS_DIR:
                 dirp = opendir(de.name);
                 if (!dirp) {
@@ -274 +404 @@
                         return CMD_FAILURE;
                 }
-                ls_scan_dir(de.name, dirp, sort);
+                if (ls.recursive)
+                        ret = ls_recursive(de.name, dirp);
+                else  
+                        ret = ls_scan_dir(de.name, dirp, NULL);
+
                 closedir(dirp);
+                break;
+        case LS_BOGUS:
+                return CMD_FAILURE;
         }
 
         free(de.name);
 
-        return CMD_SUCCESS;
-}
-
+        if (ret == -1 || ret == CMD_FAILURE)
+                return CMD_FAILURE;
+        else
+                return CMD_SUCCESS;
+}
+

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

@@ -7 +7 @@
 
 #endif /* TOUCH_ENTRY_H */
-

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

@@ -27 +27 @@
  */
 
-/* TODO: Options that people would expect, such as not creating the file if
- * it doesn't exist, specifying the access time, etc */
+/*
+ * TODO: Options that people would expect, such as specifying the access time,
+ * etc.
+ */
 
 #include <stdio.h>
@@ -37 +39 @@
 #include <sys/types.h>
 #include <str.h>
+#include <getopt.h>
+#include <sys/stat.h>
+#include <errno.h>
 
 #include "config.h"
@@ -47 +52 @@
 static const char *cmdname = "touch";
 
+static struct option const long_options[] = {
+        { "no-create", no_argument, 0, 'c' },
+        { 0, 0, 0, 0 }
+};
+
 /* Dispays help for touch in various levels */
 void help_cmd_touch(unsigned int level)
 {
         if (level == HELP_SHORT) {
-                printf("`%s' updates access times for files\n", cmdname);
+                printf("`%s' updates access times of files\n", cmdname);
         } else {
                 help_cmd_touch(HELP_SHORT);
-                printf("  `%s' <file>, if the file does not exist it will be "
-                                "created\n", cmdname);
+                printf("Usage: `%s' [-c|--no-create] <file>...\n\n"
+                    "If the file does not exist it will be created empty,\n"
+                    "unless -c (--no-create) is supplied.\n\n"
+                    "Options:\n"
+                    "   -c, --no-create  Do not create new files\n",
+                    cmdname);
         }
-
+        
         return;
 }
@@ -64 +78 @@
 int cmd_touch(char **argv)
 {
-        unsigned int argc, i = 0, ret = 0;
-        int fd;
+        unsigned int argc = cli_count_args(argv);
+        unsigned int i = 0;
+        unsigned int ret = 0;
+        int c;
+        int longind;
+        bool no_create = false;
+        struct stat file_stat;
+        int fd = -1;
         char *buff = NULL;
-
+        
         DIR *dirp;
-
-        argc = cli_count_args(argv);
-
-        if (argc == 1) {
-                printf("%s - incorrect number of arguments. Try `help %s extended'\n",
-                        cmdname, cmdname);
+        
+        for (c = 0, optind = 0, longind = 0; c != -1; ) {
+                c = getopt_long(argc, argv, "c", long_options, &longind);
+                switch (c) {
+                case 'c':
+                        no_create = true;
+                        break;
+                }
+        }
+        
+        if (argc - optind < 1) {
+                printf("%s: Incorrect number of arguments. Try `help %s extended'\n",
+                    cmdname, cmdname);
                 return CMD_FAILURE;
         }
-
-        for (i = 1; i < argc; i ++) {
+        
+        for (i = optind; argv[i] != NULL; i++) {
                 buff = str_dup(argv[i]);
+                if (buff == NULL) {
+                        cli_error(CL_ENOMEM, "Out of memory");
+                        ret++;
+                        continue;
+                }
+                
                 dirp = opendir(buff);
                 if (dirp) {
-                        cli_error(CL_ENOTSUP, "%s is a directory", buff);
+                        cli_error(CL_ENOTSUP, "`%s' is a directory", buff);
                         closedir(dirp);
-                        ret ++;
+                        free(buff);
+                        ret++;
                         continue;
                 }
-
-                fd = open(buff, O_RDWR | O_CREAT);
+                
+                /* Check whether file exists if -c (--no-create) option is given */
+                if ((!no_create) || ((no_create) && (stat(buff, &file_stat) == EOK)))
+                        fd = open(buff, O_RDWR | O_CREAT);
+                
                 if (fd < 0) {
-                        cli_error(CL_EFAIL, "Could not update / create %s ", buff);
-                        ret ++;
+                        cli_error(CL_EFAIL, "Could not update or create `%s'", buff);
+                        free(buff);
+                        ret++;
                         continue;
-                } else
+                } else {
                         close(fd);
-
+                        fd = -1;
+                }
+                
                 free(buff);
         }
-
+        
         if (ret)
                 return CMD_FAILURE;
@@ -104 +144 @@
                 return CMD_SUCCESS;
 }
-

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

@@ -4 +4 @@
 /* Prototypes for the touch command, excluding entry points */
 
-
 #endif /* TOUCH_H */
-

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

@@ -5 +5 @@
         &help_cmd_touch,
 },
-

uspace/app/binutils/Makefile

@@ -112 +112 @@
 endif
 ifeq ($(PLATFORM),arm32)
-TARGET = arm-linux-gnu
+TARGET = arm-linux-gnueabi
 endif
 ifeq ($(PLATFORM),ia32)

uspace/app/getterm/Makefile

@@ -29 +29 @@
 
 USPACE_PREFIX = ../..
-DEFS = -DRELEASE=$(RELEASE) "-DNAME=$(NAME)"
+DEFS = -DRELEASE=$(RELEASE) "-DCOPYRIGHT=$(COPYRIGHT)" "-DNAME=$(NAME)"
 BINARY = getterm
 

uspace/app/getterm/version.c

@@ -40 +40 @@
 #include "version.h"
 
+static const char *copyright = STRING(COPYRIGHT);
 static const char *release = STRING(RELEASE);
 static const char *name = STRING(NAME);
@@ -61 +62 @@
         printf("HelenOS release %s (%s)%s%s\n", release, name, revision, timestamp);
         printf("Running on %s (%s)\n", arch, term);
-        printf("Copyright (c) 2001-2011 HelenOS project\n\n");
+        printf("%s\n\n", copyright);
 }
 

uspace/app/inetcfg/Makefile

@@ -1 +1 @@
 #
-# Copyright (c) 2005 Martin Decky
-# Copyright (c) 2007 Jakub Jermar
+# Copyright (c) 2012 Jiri Svoboda
 # All rights reserved.
 #
@@ -28 +27 @@
 #
 
-USPACE_PREFIX = ../../../..
-LIBS = $(LIBNET_PREFIX)/libnet.a
-EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
-BINARY = ip
+USPACE_PREFIX = ../..
+BINARY = inetcfg
 
 SOURCES = \
-        ip.c
+        inetcfg.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/app/init/init.c

@@ -302 +302 @@
         spawn("/srv/obio");
         srv_start("/srv/cuda_adb");
-        srv_start("/srv/s3c24ser");
-        srv_start("/srv/s3c24ts");
-        
-        spawn("/srv/net");
+        srv_start("/srv/s3c24xx_uart");
+        srv_start("/srv/s3c24xx_ts");
+        
+        spawn("/srv/loopip");
+        spawn("/srv/ethip");
+        spawn("/srv/inet");
+        spawn("/srv/tcp");
+        spawn("/srv/udp");
         
         spawn("/srv/fb");
@@ -311 +315 @@
         console("hid/input", "hid/fb0");
         
-        spawn("/srv/clip");
+        spawn("/srv/clipboard");
         spawn("/srv/remcons");
         

uspace/app/mkexfat/Makefile

@@ -1 +1 @@
 #
-# Copyright (c) 2005 Martin Decky
-# Copyright (c) 2007 Jakub Jermar
+# Copyright (c) 2012 Maurizio Lombardi
 # All rights reserved.
 #
@@ -28 +27 @@
 #
 
-USPACE_PREFIX = ../../../..
-LIBS = $(LIBNET_PREFIX)/libnet.a
-EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
-BINARY = arp
+USPACE_PREFIX = ../..
+LIBS = $(LIBBLOCK_PREFIX)/libblock.a
+EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX)
+BINARY = mkexfat
 
 SOURCES = \
-        arp.c
+        mkexfat.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/app/netecho/netecho.c

@@ -373 +373 @@
                 address_in.sin_family = AF_INET;
                 address_in.sin_port = htons(port);
+                address_in.sin_addr.s_addr = INADDR_ANY;
                 address = (struct sockaddr *) &address_in;
                 addrlen = sizeof(address_in);

uspace/app/netecho/print_error.c

@@ -40 +40 @@
 #include <errno.h>
 
-#include <net/icmp_codes.h>
-
-/** Prints the specific ICMP error description.
- *
- * @param[in] output The description output stream. May be NULL.
- * @param[in] error_code The ICMP error code.
- * @param[in] prefix The error description prefix. May be NULL.
- * @param[in] suffix The error description suffix. May be NULL.
- */
-void icmp_print_error(FILE *output, int error_code, const char *prefix, const char *suffix)
-{
-        if (!output)
-                return;
-        
-        if (prefix)
-                fprintf(output, "%s", prefix);
-                
-        switch (error_code) {
-        case ICMP_DEST_UNREACH:
-                fprintf(output, "ICMP Destination Unreachable (%d) error", error_code);
-                break;
-        case ICMP_SOURCE_QUENCH:
-                fprintf(output, "ICMP Source Quench (%d) error", error_code);
-                break;
-        case ICMP_REDIRECT:
-                fprintf(output, "ICMP Redirect (%d) error", error_code);
-                break;
-        case ICMP_ALTERNATE_ADDR:
-                fprintf(output, "ICMP Alternate Host Address (%d) error", error_code);
-                break;
-        case ICMP_ROUTER_ADV:
-                fprintf(output, "ICMP Router Advertisement (%d) error", error_code);
-                break;
-        case ICMP_ROUTER_SOL:
-                fprintf(output, "ICMP Router Solicitation (%d) error", error_code);
-                break;
-        case ICMP_TIME_EXCEEDED:
-                fprintf(output, "ICMP Time Exceeded (%d) error", error_code);
-                break;
-        case ICMP_PARAMETERPROB:
-                fprintf(output, "ICMP Paramenter Problem (%d) error", error_code);
-                break;
-        case ICMP_CONVERSION_ERROR:
-                fprintf(output, "ICMP Datagram Conversion Error (%d) error", error_code);
-                break;
-        case ICMP_REDIRECT_MOBILE:
-                fprintf(output, "ICMP Mobile Host Redirect (%d) error", error_code);
-                break;
-        case ICMP_SKIP:
-                fprintf(output, "ICMP SKIP (%d) error", error_code);
-                break;
-        case ICMP_PHOTURIS:
-                fprintf(output, "ICMP Photuris (%d) error", error_code);
-                break;
-        default:
-                fprintf(output, "Other (%d) error", error_code);
-        }
-
-        if (suffix)
-                fprintf(output, "%s", suffix);
-}
-
 /** Prints the error description.
  *
- * Supports ICMP and socket error codes.
+ * Supports socket error codes.
  *
  * @param[in] output The description output stream. May be NULL.
@@ -113 +51 @@
 void print_error(FILE *output, int error_code, const char *prefix, const char *suffix)
 {
-        if (IS_ICMP_ERROR(error_code))
-                icmp_print_error(output, error_code, prefix, suffix);
-        else if(IS_SOCKET_ERROR(error_code))
+        if(IS_SOCKET_ERROR(error_code))
                 socket_print_error(output, error_code, prefix, suffix);
 }

uspace/app/ping/Makefile

@@ -1 +1 @@
 #
-# Copyright (c) 2005 Martin Decky
-# Copyright (c) 2007 Jakub Jermar
+# Copyright (c) 2012 Jiri Svoboda
 # All rights reserved.
 #
@@ -29 +28 @@
 
 USPACE_PREFIX = ../..
-LIBS = 
-EXTRA_CFLAGS = 
 BINARY = ping
 
 SOURCES = \
-        ping.c \
-        print_error.c
+        ping.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/app/ping/ping.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2009 Lukas Mejdrech
+ * Copyright (c) 2012 Jiri Svoboda
  * All rights reserved.
  *
@@ -30 +30 @@
  * @{
  */
-
-/** @file
- * Packet Internet Network Grouper.
+/** @file ICMP echo utility.
  */
 
 #include <async.h>
+#include <bool.h>
+#include <errno.h>
+#include <fibril_synch.h>
+#include <inet/inetping.h>
+#include <io/console.h>
 #include <stdio.h>
-#include <str.h>
-#include <task.h>
-#include <time.h>
-#include <ipc/services.h>
-#include <str_error.h>
-#include <errno.h>
-#include <arg_parse.h>
-
-#include <net/icmp_api.h>
-#include <net/in.h>
-#include <net/in6.h>
-#include <net/inet.h>
-#include <net/socket_parse.h>
-#include <net/ip_codes.h>
-
-#include "print_error.h"
-
-#define NAME  "ping"
-
-#define CL_OK           0
-#define CL_USAGE        -1
-#define CL_MISSING      -2
-#define CL_INVALID      -3
-#define CL_UNSUPPORTED  -4
-#define CL_ERROR        -5
-
-/** Ping configuration
- *
- */
-typedef struct {
-        bool verbose;               /**< Verbose printouts. */
-        size_t size;                /**< Outgoing packet size. */
-        unsigned int count;         /**< Number of packets to send. */
-        suseconds_t timeout;        /**< Reply wait timeout. */
-        int af;                     /**< Address family. */
-        ip_tos_t tos;               /**< Type of service. */
-        ip_ttl_t ttl;               /**< Time-to-live. */
-        bool fragments;             /**< Fragmentation. */
-        
-        char *dest_addr;            /**< Destination address. */
-        struct sockaddr_in dest;    /**< IPv4 destionation. */
-        struct sockaddr_in6 dest6;  /**< IPv6 destionation. */
-        
-        struct sockaddr *dest_raw;  /**< Raw destination address. */
-        socklen_t dest_len;         /**< Raw destination address length. */
-        
-        /** Converted address string. */
-        char dest_str[INET6_ADDRSTRLEN];
-} ping_config_t;
-
-
-static void usage(void)
-{
-        printf(
-            "Usage: ping [-c count] [-s size] [-W timeout] [-f family] [-t ttl]\n" \
-            "            [-Q tos] [--dont_fragment] destination\n" \
-            "\n" \
-            "Options:\n" \
-            "\t-c count\n" \
-            "\t--count=count\n" \
-            "\t\tNumber of outgoing packets (default: 4)\n" \
-            "\n" \
-            "\t-s size\n" \
-            "\t--size=bytes\n" \
-            "\t\tOutgoing packet size (default: 56 bytes)\n" \
-            "\n" \
-            "\t-W timeout\n" \
-            "\t--timeout=ms\n" \
-            "\t\tReply wait timeout (default: 3000 ms)\n" \
-            "\n" \
-            "\t-f family\n" \
-            "\t--family=family\n" \
-            "\t\tDestination address family, AF_INET or AF_INET6 (default: AF_INET)\n" \
-            "\n" \
-            "\t-t ttl\n" \
-            "\t--ttl=ttl\n" \
-            "\t\tOutgoing packet time-to-live (default: 0)\n" \
-            "\n" \
-            "\t-Q tos\n" \
-            "\t--tos=tos\n" \
-            "\t\tOutgoing packet type of service (default: 0)\n" \
-            "\n" \
-            "\t--dont_fragment\n" \
-            "\t\tDisable packet fragmentation (default: enabled)\n" \
-            "\n" \
-            "\t-v\n" \
-            "\t--verbose\n" \
-            "\t\tVerbose operation\n" \
-            "\n" \
-            "\t-h\n" \
-            "\t--help\n" \
-            "\t\tPrint this usage information\n"
-        );
-}
-
-static int args_parse(int argc, char *argv[], ping_config_t *config)
-{
-        if (argc < 2)
-                return CL_USAGE;
-        
+#include <stdlib.h>
+#include <sys/types.h>
+
+#define NAME "ping"
+
+/** Delay between subsequent ping requests in microseconds */
+#define PING_DELAY (1000 * 1000)
+
+/** Ping request timeout in microseconds */
+#define PING_TIMEOUT (1000 * 1000)
+
+static int ping_ev_recv(inetping_sdu_t *);
+
+static bool done = false;
+static FIBRIL_CONDVAR_INITIALIZE(done_cv);
+static FIBRIL_MUTEX_INITIALIZE(done_lock);
+
+static inetping_ev_ops_t ev_ops = {
+        .recv = ping_ev_recv
+};
+
+static inet_addr_t src_addr;
+static inet_addr_t dest_addr;
+
+static bool ping_repeat = false;
+
+static void print_syntax(void)
+{
+        printf("syntax: " NAME " [-r] <addr>\n");
+}
+
+static int addr_parse(const char *text, inet_addr_t *addr)
+{
+        unsigned long a[4];
+        char *cp = (char *)text;
         int i;
-        int ret;
-        
-        for (i = 1; i < argc; i++) {
-                
-                /* Not an option */
-                if (argv[i][0] != '-')
+
+        for (i = 0; i < 3; i++) {
+                a[i] = strtoul(cp, &cp, 10);
+                if (*cp != '.')
+                        return EINVAL;
+                ++cp;
+        }
+
+        a[3] = strtoul(cp, &cp, 10);
+        if (*cp != '\0')
+                return EINVAL;
+
+        addr->ipv4 = 0;
+        for (i = 0; i < 4; i++) {
+                if (a[i] > 255)
+                        return EINVAL;
+                addr->ipv4 = (addr->ipv4 << 8) | a[i];
+        }
+
+        return EOK;
+}
+
+static int addr_format(inet_addr_t *addr, char **bufp)
+{
+        int rc;
+
+        rc = asprintf(bufp, "%d.%d.%d.%d", addr->ipv4 >> 24,
+            (addr->ipv4 >> 16) & 0xff, (addr->ipv4 >> 8) & 0xff,
+            addr->ipv4 & 0xff);
+
+        if (rc < 0)
+                return ENOMEM;
+
+        return EOK;
+}
+
+static void ping_signal_done(void)
+{
+        fibril_mutex_lock(&done_lock);
+        done = true;
+        fibril_mutex_unlock(&done_lock);
+        fibril_condvar_broadcast(&done_cv);
+}
+
+static int ping_ev_recv(inetping_sdu_t *sdu)
+{
+        char *asrc, *adest;
+        int rc;
+
+        rc = addr_format(&sdu->src, &asrc);
+        if (rc != EOK)
+                return ENOMEM;
+
+        rc = addr_format(&sdu->dest, &adest);
+        if (rc != EOK) {
+                free(asrc);
+                return ENOMEM;
+        }
+        printf("Received ICMP echo reply: from %s to %s, seq. no %u, "
+            "payload size %zu\n", asrc, adest, sdu->seq_no, sdu->size);
+
+        if (!ping_repeat) {
+                ping_signal_done();
+        }
+
+        free(asrc);
+        free(adest);
+        return EOK;
+}
+
+static int ping_send(uint16_t seq_no)
+{
+        inetping_sdu_t sdu;
+        int rc;
+
+        sdu.src = src_addr;
+        sdu.dest = dest_addr;
+        sdu.seq_no = seq_no;
+        sdu.data = (void *) "foo";
+        sdu.size = 3;
+
+        rc = inetping_send(&sdu);
+        if (rc != EOK) {
+                printf(NAME ": Failed sending echo request (%d).\n", rc);
+                return rc;
+        }
+
+        return EOK;
+}
+
+static int transmit_fibril(void *arg)
+{
+        uint16_t seq_no = 0;
+
+        while (true) {
+                fibril_mutex_lock(&done_lock);
+                if (done) {
+                        fibril_mutex_unlock(&done_lock);
+                        return 0;
+                }
+                fibril_mutex_unlock(&done_lock);
+
+                (void) ping_send(++seq_no);
+                async_usleep(PING_DELAY);
+        }
+
+        return 0;
+}
+
+static int input_fibril(void *arg)
+{
+        console_ctrl_t *con;
+        kbd_event_t ev;
+
+        con = console_init(stdin, stdout);
+        printf("[Press Ctrl-Q to quit]\n");
+
+        while (true) {
+                if (!console_get_kbd_event(con, &ev))
                         break;
-                
-                /* Options terminator */
-                if (str_cmp(argv[i], "--") == 0) {
-                        i++;
-                        break;
-                }
-                
-                int off;
-                
-                /* Usage */
-                if ((off = arg_parse_short_long(argv[i], "-h", "--help")) != -1)
-                        return CL_USAGE;
-                
-                /* Verbose */
-                if ((off = arg_parse_short_long(argv[i], "-v", "--verbose")) != -1) {
-                        config->verbose = true;
-                        continue;
-                }
-                
-                /* Don't fragment */
-                if (str_cmp(argv[i], "--dont_fragment") == 0) {
-                        config->fragments = false;
-                        continue;
-                }
-                
-                /* Count */
-                if ((off = arg_parse_short_long(argv[i], "-c", "--count=")) != -1) {
-                        int tmp;
-                        ret = arg_parse_int(argc, argv, &i, &tmp, off);
-                        
-                        if ((ret != EOK) || (tmp < 0))
-                                return i;
-                        
-                        config->count = (unsigned int) tmp;
-                        continue;
-                }
-                
-                /* Outgoing packet size */
-                if ((off = arg_parse_short_long(argv[i], "-s", "--size=")) != -1) {
-                        int tmp;
-                        ret = arg_parse_int(argc, argv, &i, &tmp, off);
-                        
-                        if ((ret != EOK) || (tmp < 0))
-                                return i;
-                        
-                        config->size = (size_t) tmp;
-                        continue;
-                }
-                
-                /* Reply wait timeout */
-                if ((off = arg_parse_short_long(argv[i], "-W", "--timeout=")) != -1) {
-                        int tmp;
-                        ret = arg_parse_int(argc, argv, &i, &tmp, off);
-                        
-                        if ((ret != EOK) || (tmp < 0))
-                                return i;
-                        
-                        config->timeout = (suseconds_t) tmp;
-                        continue;
-                }
-                
-                /* Address family */
-                if ((off = arg_parse_short_long(argv[i], "-f", "--family=")) != -1) {
-                        ret = arg_parse_name_int(argc, argv, &i, &config->af, off,
-                            socket_parse_address_family);
-                        
-                        if (ret != EOK)
-                                return i;
-                        
-                        continue;
-                }
-                
-                /* Type of service */
-                if ((off = arg_parse_short_long(argv[i], "-Q", "--tos=")) != -1) {
-                        int tmp;
-                        ret = arg_parse_name_int(argc, argv, &i, &tmp, off,
-                            socket_parse_address_family);
-                        
-                        if ((ret != EOK) || (tmp < 0))
-                                return i;
-                        
-                        config->tos = (ip_tos_t) tmp;
-                        continue;
-                }
-                
-                /* Time to live */
-                if ((off = arg_parse_short_long(argv[i], "-t", "--ttl=")) != -1) {
-                        int tmp;
-                        ret = arg_parse_name_int(argc, argv, &i, &tmp, off,
-                            socket_parse_address_family);
-                        
-                        if ((ret != EOK) || (tmp < 0))
-                                return i;
-                        
-                        config->ttl = (ip_ttl_t) tmp;
-                        continue;
-                }
-        }
-        
-        if (i >= argc)
-                return CL_MISSING;
-        
-        config->dest_addr = argv[i];
-        
-        /* Resolve destionation address */
-        switch (config->af) {
-        case AF_INET:
-                config->dest_raw = (struct sockaddr *) &config->dest;
-                config->dest_len = sizeof(config->dest);
-                config->dest.sin_family = config->af;
-                ret = inet_pton(config->af, config->dest_addr,
-                    (uint8_t *) &config->dest.sin_addr.s_addr);
-                break;
-        case AF_INET6:
-                config->dest_raw = (struct sockaddr *) &config->dest6;
-                config->dest_len = sizeof(config->dest6);
-                config->dest6.sin6_family = config->af;
-                ret = inet_pton(config->af, config->dest_addr,
-                    (uint8_t *) &config->dest6.sin6_addr.s6_addr);
-                break;
-        default:
-                return CL_UNSUPPORTED;
-        }
-        
-        if (ret != EOK)
-                return CL_INVALID;
-        
-        /* Convert destination address back to string */
-        switch (config->af) {
-        case AF_INET:
-                ret = inet_ntop(config->af,
-                    (uint8_t *) &config->dest.sin_addr.s_addr,
-                    config->dest_str, sizeof(config->dest_str));
-                break;
-        case AF_INET6:
-                ret = inet_ntop(config->af,
-                    (uint8_t *) &config->dest6.sin6_addr.s6_addr,
-                    config->dest_str, sizeof(config->dest_str));
-                break;
-        default:
-                return CL_UNSUPPORTED;
-        }
-        
-        if (ret != EOK)
-                return CL_ERROR;
-        
-        return CL_OK;
+
+                if (ev.type == KEY_PRESS && (ev.mods & (KM_ALT | KM_SHIFT)) ==
+                    0 && (ev.mods & KM_CTRL) != 0) {
+                        /* Ctrl+key */
+                        if (ev.key == KC_Q) {
+                                ping_signal_done();
+                                return 0;
+                        }
+                }
+        }
+
+        return 0;
 }
 
 int main(int argc, char *argv[])
 {
-        ping_config_t config;
-        
-        /* Default configuration */
-        config.verbose = false;
-        config.size = 56;
-        config.count = 4;
-        config.timeout = 3000;
-        config.af = AF_INET;
-        config.tos = 0;
-        config.ttl = 0;
-        config.fragments = true;
-        
-        int ret = args_parse(argc, argv, &config);
-        
-        switch (ret) {
-        case CL_OK:
-                break;
-        case CL_USAGE:
-                usage();
-                return 0;
-        case CL_MISSING:
-                fprintf(stderr, "%s: Destination address missing\n", NAME);
-                return 1;
-        case CL_INVALID:
-                fprintf(stderr, "%s: Destination address '%s' invalid or malformed\n",
-                    NAME, config.dest_addr);
-                return 2;
-        case CL_UNSUPPORTED:
-                fprintf(stderr, "%s: Destination address '%s' unsupported\n",
-                    NAME, config.dest_addr);
-                return 3;
-        case CL_ERROR:
-                fprintf(stderr, "%s: Destination address '%s' error\n",
-                    NAME, config.dest_addr);
-                return 4;
-        default:
-                fprintf(stderr, "%s: Unknown or invalid option '%s'\n", NAME,
-                    argv[ret]);
-                return 5;
-        }
-        
-        printf("PING %s (%s) %zu(%zu) bytes of data\n", config.dest_addr,
-            config.dest_str, config.size, config.size);
-        
-        async_sess_t *sess = icmp_connect_module();
-        if (!sess) {
-                fprintf(stderr, "%s: Unable to connect to ICMP service (%s)\n", NAME,
-                    str_error(errno));
-                return errno;
-        }
-        
-        unsigned int seq;
-        for (seq = 0; seq < config.count; seq++) {
-                struct timeval t0;
-                ret = gettimeofday(&t0, NULL);
-                if (ret != EOK) {
-                        fprintf(stderr, "%s: gettimeofday failed (%s)\n", NAME,
-                            str_error(ret));
-                        
-                        async_hangup(sess);
-                        return ret;
-                }
-                
-                /* Ping! */
-                int result = icmp_echo_msg(sess, config.size, config.timeout,
-                    config.ttl, config.tos, !config.fragments, config.dest_raw,
-                    config.dest_len);
-                
-                struct timeval t1;
-                ret = gettimeofday(&t1, NULL);
-                if (ret != EOK) {
-                        fprintf(stderr, "%s: gettimeofday failed (%s)\n", NAME,
-                            str_error(ret));
-                        
-                        async_hangup(sess);
-                        return ret;
-                }
-                
-                suseconds_t elapsed = tv_sub(&t1, &t0);
-                
-                switch (result) {
-                case ICMP_ECHO:
-                        printf("%zu bytes from ? (?): icmp_seq=%u ttl=? time=%ld.%04ld\n",
-                                config.size, seq, elapsed / 1000, elapsed % 1000);
-                        break;
-                case ETIMEOUT:
-                        printf("%zu bytes from ? (?): icmp_seq=%u Timed out\n",
-                                config.size, seq);
-                        break;
-                default:
-                        print_error(stdout, result, NULL, "\n");
-                }
-        }
-        
-        async_hangup(sess);
-        
+        int rc;
+        int argi;
+
+        rc = inetping_init(&ev_ops);
+        if (rc != EOK) {
+                printf(NAME ": Failed connecting to internet ping service "
+                    "(%d).\n", rc);
+                return 1;
+        }
+
+        argi = 1;
+        if (argi < argc && str_cmp(argv[argi], "-r") == 0) {
+                ping_repeat = true;
+                ++argi;
+        } else {
+                ping_repeat = false;
+        }
+
+        if (argc - argi != 1) {
+                print_syntax();
+                return 1;
+        }
+
+        /* Parse destination address */
+        rc = addr_parse(argv[argi], &dest_addr);
+        if (rc != EOK) {
+                printf(NAME ": Invalid address format.\n");
+                print_syntax();
+                return 1;
+        }
+
+        /* Determine source address */
+        rc = inetping_get_srcaddr(&dest_addr, &src_addr);
+        if (rc != EOK) {
+                printf(NAME ": Failed determining source address.\n");
+                return 1;
+        }
+
+        fid_t fid;
+
+        if (ping_repeat) {
+                fid = fibril_create(transmit_fibril, NULL);
+                if (fid == 0) {
+                        printf(NAME ": Failed creating transmit fibril.\n");
+                        return 1;
+                }
+
+                fibril_add_ready(fid);
+
+                fid = fibril_create(input_fibril, NULL);
+                if (fid == 0) {
+                        printf(NAME ": Failed creating input fibril.\n");
+                        return 1;
+                }
+
+                fibril_add_ready(fid);
+        } else {
+                ping_send(1);
+        }
+
+        fibril_mutex_lock(&done_lock);
+        rc = EOK;
+        while (!done && rc != ETIMEOUT) {
+                rc = fibril_condvar_wait_timeout(&done_cv, &done_lock,
+                        ping_repeat ? 0 : PING_TIMEOUT);
+        }
+        fibril_mutex_unlock(&done_lock);
+
+        if (rc == ETIMEOUT) {
+                printf(NAME ": Echo request timed out.\n");
+                return 1;
+        }
+
         return 0;
 }

uspace/app/sbi/src/run_texpr.c

@@ -98 +98 @@
 {
         stree_symbol_t *sym;
-        tdata_item_t *targ_i;
-        tdata_item_t *titem;
+        tdata_item_t *targ_i = NULL;
+        tdata_item_t *titem = NULL;;
         tdata_object_t *tobject;
         tdata_deleg_t *tdeleg;
@@ -139 +139 @@
                 return;
         }
-
-        /* Make compiler happy. */
-        titem = NULL;
 
         switch (sym->sc) {
@@ -222 +219 @@
     stree_tindex_t *tindex, tdata_item_t **res)
 {
-        tdata_item_t *base_ti;
+        tdata_item_t *base_ti = NULL;
         tdata_item_t *titem;
         tdata_array_t *tarray;

uspace/app/sportdmp/sportdmp.c

@@ -27 +27 @@
  */
 
+#include <device/char_dev.h>
 #include <errno.h>
+#include <ipc/serial_ctl.h>
+#include <loc.h>
 #include <stdio.h>
-#include <devman.h>
-#include <ipc/devman.h>
-#include <device/char_dev.h>
-#include <ipc/serial_ctl.h>
 
 #define BUF_SIZE 1
 
-static void syntax_print() {
-        fprintf(stderr, "Usage: sportdmp <baud> <device_path>\n");
+static void syntax_print(void)
+{
+        fprintf(stderr, "Usage: sportdmp <baud> <device_service>\n");
 }
 
 int main(int argc, char **argv)
 {
-        const char* devpath = "/hw/pci0/00:01.0/com1/a";
+        const char* svc_path = "devices/\\hw\\pci0\\00:01.0\\com1\\a";
         sysarg_t baud = 9600;
         
@@ -56 +56 @@
         
         if (argc > 2) {
-                devpath = argv[2];
+                svc_path = argv[2];
         }
         
@@ -64 +64 @@
         }
         
-        devman_handle_t device;
-        int rc = devman_fun_get_handle(devpath, &device, IPC_FLAG_BLOCKING);
+        service_id_t svc_id;
+        int rc = loc_service_get_id(svc_path, &svc_id, IPC_FLAG_BLOCKING);
         if (rc != EOK) {
-                fprintf(stderr, "Cannot open device %s\n", devpath);
+                fprintf(stderr, "Cannot find device service %s\n", svc_path);
                 return 1;
         }
         
-        async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE, device,
+        async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id,
             IPC_FLAG_BLOCKING);
         if (!sess) {
-                fprintf(stderr, "Cannot connect device\n");
+                fprintf(stderr, "Failed connecting to service %s\n", svc_path);
         }
         
@@ -83 +83 @@
         
         if (rc != EOK) {
-                fprintf(stderr, "Cannot set serial properties\n");
+                fprintf(stderr, "Failed setting serial properties\n");
                 return 2;
         }
@@ -89 +89 @@
         uint8_t *buf = (uint8_t *) malloc(BUF_SIZE);
         if (buf == NULL) {
-                fprintf(stderr, "Cannot allocate buffer\n");
+                fprintf(stderr, "Failed allocating buffer\n");
                 return 3;
         }

uspace/app/sysinfo/sysinfo.c

@@ -37 +37 @@
 #include <stdio.h>
 #include <sysinfo.h>
+#include <malloc.h>
 #include <sys/types.h>
 
-static int print_item_val(char *ipath);
-static int print_item_data(char *ipath);
-
-static void dump_bytes_hex(char *data, size_t size);
-static void dump_bytes_text(char *data, size_t size);
-
-static void print_syntax(void);
-
-int main(int argc, char *argv[])
-{
-        int rc;
-        char *ipath;
-        sysinfo_item_val_type_t tag;
-
-        if (argc != 2) {
-                print_syntax();
-                return 1;
-        }
-
-        ipath = argv[1];
-
-        tag = sysinfo_get_val_type(ipath);
-
-        /* Silence warning */
-        rc = EOK;
-
-        switch (tag) {
-        case SYSINFO_VAL_UNDEFINED:
-                printf("Error: Sysinfo item '%s' not defined.\n", ipath);
-                rc = 2;
-                break;
-        case SYSINFO_VAL_VAL:
-                rc = print_item_val(ipath);
-                break;
-        case SYSINFO_VAL_DATA:
-                rc = print_item_data(ipath);
-                break;
-        default:
-                printf("Error: Sysinfo item '%s' with unknown value type.\n",
-                    ipath);
-                rc = 2;
-                break;
-        }
-
-        return rc;
+static void dump_bytes_hex(char *data, size_t size)
+{
+        for (size_t i = 0; i < size; i++) {
+                if (i > 0)
+                        putchar(' ');
+                printf("0x%02x", (uint8_t) data[i]);
+        }
+}
+
+static void dump_bytes_text(char *data, size_t size)
+{
+        size_t offset = 0;
+        
+        while (offset < size) {
+                wchar_t c = str_decode(data, &offset, size);
+                printf("%lc", (wint_t) c);
+        }
 }
 
@@ -89 +62 @@
 {
         sysarg_t value;
-        int rc;
-
-        rc = sysinfo_get_value(ipath, &value);
+        int rc = sysinfo_get_value(ipath, &value);
         if (rc != EOK) {
                 printf("Error reading item '%s'.\n", ipath);
                 return rc;
         }
-
+        
         printf("%s -> %" PRIu64 " (0x%" PRIx64 ")\n", ipath,
             (uint64_t) value, (uint64_t) value);
-
+        
         return EOK;
 }
@@ -105 +76 @@
 static int print_item_data(char *ipath)
 {
-        void *data;
         size_t size;
-
-        data = sysinfo_get_data(ipath, &size);
+        void *data = sysinfo_get_data(ipath, &size);
         if (data == NULL) {
                 printf("Error reading item '%s'.\n", ipath);
                 return -1;
         }
-
+        
         printf("%s -> ", ipath);
         dump_bytes_hex(data, size);
@@ -119 +88 @@
         dump_bytes_text(data, size);
         fputs("')\n", stdout);
-
+        
         return EOK;
 }
 
-static void dump_bytes_hex(char *data, size_t size)
-{
-        size_t i;
-
-        for (i = 0; i < size; ++i) {
-                if (i > 0) putchar(' ');
-                printf("0x%02x", (uint8_t) data[i]);
-        }
-}
-
-static void dump_bytes_text(char *data, size_t size)
-{
-        wchar_t c;
-        size_t offset;
-
-        offset = 0;
-
-        while (offset < size) {
-                c = str_decode(data, &offset, size);
-                printf("%lc", (wint_t) c);
-        }
-}
-
-
-static void print_syntax(void)
-{
-        printf("Syntax: sysinfo <item_path>\n");
+static int print_item_property(char *ipath, char *iprop)
+{
+        size_t size;
+        void *data = sysinfo_get_property(ipath, iprop, &size);
+        if (data == NULL) {
+                printf("Error reading property '%s' of item '%s'.\n", iprop,
+                    ipath);
+                return -1;
+        }
+        
+        printf("%s property %s -> ", ipath, iprop);
+        dump_bytes_hex(data, size);
+        fputs(" ('", stdout);
+        dump_bytes_text(data, size);
+        fputs("')\n", stdout);
+        
+        return EOK;
+}
+
+static void print_spaces(size_t spaces)
+{
+        for (size_t i = 0; i < spaces; i++)
+                printf(" ");
+}
+
+static void print_keys(const char *path, size_t spaces)
+{
+        size_t size;
+        char *keys = sysinfo_get_keys(path, &size);
+        if ((keys == NULL) || (size == 0))
+                return;
+        
+        size_t pos = 0;
+        while (pos < size) {
+                /* Process each key with sanity checks */
+                size_t cur_size = str_nsize(keys + pos, size - pos);
+                if (keys[pos + cur_size] != 0)
+                        break;
+                
+                size_t path_size = str_size(path) + cur_size + 2;
+                char *cur_path = (char *) malloc(path_size);
+                if (cur_path == NULL)
+                        break;
+                
+                size_t length;
+                
+                if (path[0] != 0) {
+                        print_spaces(spaces);
+                        printf(".%s\n", keys + pos);
+                        length = str_length(keys + pos) + 1;
+                        
+                        snprintf(cur_path, path_size, "%s.%s", path, keys + pos);
+                } else {
+                        printf("%s\n", keys + pos);
+                        length = str_length(keys + pos);
+                        
+                        snprintf(cur_path, path_size, "%s", keys + pos);
+                }
+                
+                print_keys(cur_path, spaces + length);
+                
+                free(cur_path);
+                pos += cur_size + 1;
+        }
+        
+        free(keys);
+}
+
+int main(int argc, char *argv[])
+{
+        int rc = 0;
+        
+        if (argc < 2) {
+                /* Print keys */
+                print_keys("", 0);
+                return rc;
+        }
+        
+        char *ipath = argv[1];
+        
+        if (argc < 3) {
+                sysinfo_item_val_type_t tag = sysinfo_get_val_type(ipath);
+                
+                switch (tag) {
+                case SYSINFO_VAL_UNDEFINED:
+                        printf("Error: Sysinfo item '%s' not defined.\n", ipath);
+                        rc = 2;
+                        break;
+                case SYSINFO_VAL_VAL:
+                        rc = print_item_val(ipath);
+                        break;
+                case SYSINFO_VAL_DATA:
+                        rc = print_item_data(ipath);
+                        break;
+                default:
+                        printf("Error: Sysinfo item '%s' with unknown value type.\n",
+                            ipath);
+                        rc = 2;
+                        break;
+                }
+                
+                return rc;
+        }
+        
+        char *iprop = argv[2];
+        rc = print_item_property(ipath, iprop);
+        return rc;
 }
 

uspace/app/tester/Makefile

@@ -50 +50 @@
         vfs/vfs1.c \
         ipc/ping_pong.c \
+        ipc/starve.c \
         loop/loop1.c \
         mm/common.c \

uspace/app/tester/fault/fault2.c

@@ -35 +35 @@
 const char *test_fault2(void)
 {
-        volatile long long var;
-        volatile int var1;
-        
-        var1 = *((aliasing_int *) (((char *) (&var)) + 1));
+        volatile long long var = 0;
+        volatile int var1 = *((aliasing_int *) (((char *) (&var)) + 1));
         printf("Read %d\n", var1);
         

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

@@ -42 +42 @@
 #include <async.h>
 #include <ipc/services.h>
-#include <ipc/devman.h>
-#include <devman.h>
+#include <loc.h>
 #include <device/char_dev.h>
 #include <str.h>
@@ -71 +70 @@
                 }
         
-        devman_handle_t handle;
-        int res = devman_fun_get_handle("/hw/pci0/00:01.0/com1/a", &handle,
-            IPC_FLAG_BLOCKING);
+        service_id_t svc_id;
+        int res = loc_service_get_id("devices/\\hw\\pci0\\00:01.0\\com1\\a",
+            &svc_id, IPC_FLAG_BLOCKING);
         if (res != EOK)
-                return "Could not get serial device handle";
-        
-        async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
+                return "Failed getting serial port service ID";
+        
+        async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id,
             IPC_FLAG_BLOCKING);
         if (!sess)
-                return "Unable to connect to serial device";
+                return "Failed connecting to serial device";
         
         char *buf = (char *) malloc(cnt + 1);
         if (buf == NULL) {
                 async_hangup(sess);
-                return "Failed to allocate input buffer";
+                return "Failed allocating input buffer";
         }
         
@@ -112 +111 @@
                 free(buf);
                 async_hangup(sess);
-                return "Failed to set serial communication parameters";
-        }
-        
-        TPRINTF("Trying to read %zu characters from serial device "
-            "(handle=%" PRIun ")\n", cnt, handle);
+                return "Failed setting serial communication parameters";
+        }
+        
+        TPRINTF("Trying reading %zu characters from serial device "
+            "(svc_id=%" PRIun ")\n", cnt, svc_id);
         
         size_t total = 0;
@@ -130 +129 @@
                         free(buf);
                         async_hangup(sess);
-                        return "Failed read from serial device";
+                        return "Failed reading from serial device";
                 }
                 
@@ -165 +164 @@
                                 free(buf);
                                 async_hangup(sess);
-                                return "Failed write to serial device";
+                                return "Failed writing to serial device";
                         }
                         

uspace/app/tester/ipc/starve.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2009 Lukas Mejdrech
+ * Copyright (c) 2012 Vojtech Horky
  * All rights reserved.
  *
@@ -27 +27 @@
  */
 
-/** @addtogroup libc
- *  @{
- */
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <io/console.h>
+#include <async.h>
+#include "../tester.h"
 
-/** @file
- * ICMP common interface implementation.
- * @see icmp_common.h
- */
+#define DURATION_SECS      30
 
-#include <net/modules.h>
-#include <net/icmp_common.h>
-#include <ipc/services.h>
-#include <ipc/icmp.h>
-#include <sys/time.h>
-#include <async.h>
+const char *test_starve_ipc(void)
+{
+        const char *err = NULL;
+        console_ctrl_t *console = console_init(stdin, stdout);
+        if (console == NULL) {
+                return "Failed to init connection with console.";
+        }
+        
+        struct timeval start;
+        if (gettimeofday(&start, NULL) != 0) {
+                err = "Failed getting the time";
+                goto leave;
+        }
+        
+        TPRINTF("Intensive computation shall be imagined (for %ds)...\n", DURATION_SECS);
+        TPRINTF("Press a key to terminate prematurely...\n");
+        while (true) {
+                struct timeval now;
+                if (gettimeofday(&now, NULL) != 0) {
+                        err = "Failed getting the time";
+                        goto leave;
+                }
+                
+                if (tv_sub(&now, &start) >= DURATION_SECS * 1000000L)
+                        break;
+                
+                kbd_event_t ev;
+                suseconds_t timeout = 0;
+                bool has_event = console_get_kbd_event_timeout(console, &ev, &timeout);
+                if (has_event && (ev.type == KEY_PRESS)) {
+                        TPRINTF("Key %d pressed, terminating.\n", ev.key);
+                        break;
+                }
+        }
 
-/** Connect to the ICMP module.
- *
- * @return ICMP module session.
- *
- */
-async_sess_t *icmp_connect_module(void)
-{
-        return connect_to_service(SERVICE_ICMP);
+        // FIXME - unless a key was pressed, the answer leaked as no one
+        // will wait for it.
+        // We cannot use async_forget() directly, though. Something like
+        // console_forget_pending_kbd_event() shall come here.
+
+        TPRINTF("Terminating...\n");
+
+leave:
+        console_done(console);
+
+        return err;
 }
-
-/** @}
- */

uspace/app/tester/print/print1.c

@@ -42 +42 @@
         
         TPRINTF("Testing printf(\"%%8.10s\", \"text\"):\n");
-        TPRINTF("Expected output: \"text\"\n");
+        TPRINTF("Expected output: \"    text\"\n");
         TPRINTF("Real output:     \"%8.10s\"\n\n", "text");
         
@@ -49 +49 @@
         TPRINTF("Real output:     \"%8.10s\"\n\n", "very long text");
         
+        TPRINTF("Testing printf(\"%%-*.*s\", 7, 7, \"text\"):\n");
+        TPRINTF("Expected output: \"text   \"\n");
+        TPRINTF("Real output:     \"%-*.*s\"\n\n", 7, 7, "text");
+        
         return NULL;
 }

uspace/app/tester/tester.c

@@ -60 +60 @@
 #include "vfs/vfs1.def"
 #include "ipc/ping_pong.def"
+#include "ipc/starve.def"
 #include "loop/loop1.def"
 #include "mm/malloc1.def"

uspace/app/tester/tester.h

@@ -93 +93 @@
 extern const char *test_vfs1(void);
 extern const char *test_ping_pong(void);
+extern const char *test_starve_ipc(void);
 extern const char *test_loop1(void);
 extern const char *test_malloc1(void);

uspace/app/top/screen.c

@@ -37 +37 @@
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <io/console.h>
 #include <io/style.h>
@@ -43 +44 @@
 #include <stats.h>
 #include <inttypes.h>
+#include <macros.h>
 #include "screen.h"
 #include "top.h"
@@ -48 +50 @@
 #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 sysarg_t warning_col = 0;
+static sysarg_t warning_row = 0;
+static suseconds_t warning_timeleft = 0;
+static char *warning_text = NULL;
+
 static void screen_style_normal(void)
 {
@@ -64 +69 @@
         console_flush(console);
         console_set_style(console, STYLE_INVERTED);
+}
+
+static void screen_style_emphasis(void)
+{
+        console_flush(console);
+        console_set_style(console, STYLE_EMPHASIS);
 }
 
@@ -126 +137 @@
 void screen_done(void)
 {
+        free(warning_text);
+        warning_text = NULL;
+
         screen_restart(true);
         
@@ -277 +291 @@
 }
 
-static inline void print_tasks_head(void)
+static inline void print_help_head(void)
 {
         screen_style_inverted();
-        printf("[taskid] [thrds] [resident] [%%resi] [virtual] [%%virt]"
-            " [%%user] [%%kern] [name");
+        printf("Help");
         screen_newline();
         screen_style_normal();
 }
 
-static inline void print_tasks(data_t *data)
-{
-        sysarg_t cols;
-        sysarg_t rows;
-        screen_get_size(&cols, &rows);
+static inline void print_help(void)
+{
+        sysarg_t cols;
+        sysarg_t rows;
+        screen_get_size(&cols, &rows);
+        
+        screen_newline();
+        
+        printf("Operation modes:");
+        screen_newline();
+        
+        printf(" t .. tasks statistics");
+        screen_newline();
+        
+        printf(" i .. IPC statistics");
+        screen_newline();
+        
+        printf(" e .. exceptions statistics");
+        screen_newline();
+        
+        printf("      a .. toggle display of all/hot exceptions");
+        screen_newline();
+
+        printf(" h .. toggle this help screen");
+        screen_newline();
+
+        screen_newline();
+
+        printf("Other keys:");
+        screen_newline();
+        
+        printf(" s .. choose column to sort by");
+        screen_newline();
+        
+        printf(" r .. toggle reversed sorting");
+        screen_newline();
+        
+        printf(" q .. quit");
+        screen_newline();
         
         sysarg_t col;
@@ -296 +343 @@
         screen_get_pos(&col, &row);
         
-        size_t i;
-        for (i = 0; (i < data->tasks_count) && (row < rows); i++, row++) {
-                stats_task_t *task = data->tasks + data->tasks_map[i];
-                perc_task_t *perc = data->tasks_perc + data->tasks_map[i];
-                
-                uint64_t resmem;
-                const char *resmem_suffix;
-                bin_order_suffix(task->resmem, &resmem, &resmem_suffix, true);
-                
-                uint64_t virtmem;
-                const char *virtmem_suffix;
-                bin_order_suffix(task->virtmem, &virtmem, &virtmem_suffix, true);
-                
-                printf("%-8" PRIu64 " %7zu %7" PRIu64 "%s ",
-                    task->task_id, task->threads, resmem, resmem_suffix);
-                print_percent(perc->resmem, 2);
-                printf(" %6" PRIu64 "%s ", virtmem, virtmem_suffix);
-                print_percent(perc->virtmem, 2);
-                puts(" ");
-                print_percent(perc->ucycles, 2);
-                puts(" ");
-                print_percent(perc->kcycles, 2);
-                puts(" ");
-                print_string(task->name);
-                
-                screen_newline();
-        }
-        
         while (row < rows) {
                 screen_newline();
@@ -330 +349 @@
 }
 
-static inline void print_ipc_head(void)
-{
+static inline void print_table_head(const table_t *table)
+{
+        sysarg_t cols;
+        sysarg_t rows;
+        screen_get_size(&cols, &rows);
+
         screen_style_inverted();
-        printf("[taskid] [cls snt] [cls rcv] [ans snt]"
-            " [ans rcv] [irq rcv] [forward] [name");
+        for (size_t i = 0; i < table->num_columns; i++) {
+                const char *name = table->columns[i].name;
+                int width = table->columns[i].width;
+                if (i != 0) {
+                        puts(" ");
+                }
+                if (width == 0) {
+                        sysarg_t col;
+                        sysarg_t row;
+                        screen_get_pos(&col, &row);
+                        width = cols - col - 1;
+                }
+                printf("[%-*.*s]", width - 2, width - 2, name);
+        }
         screen_newline();
         screen_style_normal();
 }
 
-static inline void print_ipc(data_t *data)
+static inline void print_table(const table_t *table)
 {
         sysarg_t cols;
@@ -350 +385 @@
         
         size_t i;
-        for (i = 0; (i < data->tasks_count) && (row < rows); i++, row++) {
-                uint64_t call_sent;
-                uint64_t call_received;
-                uint64_t answer_sent;
-                uint64_t answer_received;
-                uint64_t irq_notif_received;
-                uint64_t forwarded;
-                
-                char call_sent_suffix;
-                char call_received_suffix;
-                char answer_sent_suffix;
-                char answer_received_suffix;
-                char irq_notif_received_suffix;
-                char forwarded_suffix;
-                
-                order_suffix(data->tasks[i].ipc_info.call_sent, &call_sent,
-                    &call_sent_suffix);
-                order_suffix(data->tasks[i].ipc_info.call_received,
-                    &call_received, &call_received_suffix);
-                order_suffix(data->tasks[i].ipc_info.answer_sent,
-                    &answer_sent, &answer_sent_suffix);
-                order_suffix(data->tasks[i].ipc_info.answer_received,
-                    &answer_received, &answer_received_suffix);
-                order_suffix(data->tasks[i].ipc_info.irq_notif_received,
-                    &irq_notif_received, &irq_notif_received_suffix);
-                order_suffix(data->tasks[i].ipc_info.forwarded, &forwarded,
-                    &forwarded_suffix);
-                
-                printf("%-8" PRIu64 " %8" PRIu64 "%c %8" PRIu64 "%c"
-                     " %8" PRIu64 "%c %8" PRIu64 "%c %8" PRIu64 "%c"
-                     " %8" PRIu64 "%c ", data->tasks[i].task_id,
-                     call_sent, call_sent_suffix,
-                     call_received, call_received_suffix,
-                     answer_sent, answer_sent_suffix,
-                     answer_received, answer_received_suffix,
-                     irq_notif_received, irq_notif_received_suffix,
-                     forwarded, forwarded_suffix);
-                print_string(data->tasks[i].name);
-                
-                screen_newline();
+        for (i = 0; (i < table->num_fields) && (row < rows); i++) {
+                size_t column_index = i % table->num_columns;
+                int width = table->columns[column_index].width;
+                field_t *field = &table->fields[i];
+
+                if (column_index != 0) {
+                        puts(" ");
+                }
+
+                if (width == 0) {
+                        screen_get_pos(&col, &row);
+                        width = cols - col - 1;
+                }
+
+                switch (field->type) {
+                case FIELD_EMPTY:
+                        printf("%*s", width, "");
+                        break;
+                case FIELD_UINT:
+                        printf("%*" PRIu64, width, field->uint);
+                        break;
+                case FIELD_UINT_SUFFIX_BIN: {
+                        uint64_t val = field->uint;
+                        const char *suffix;
+                        width -= 3;
+                        bin_order_suffix(val, &val, &suffix, true);
+                        printf("%*" PRIu64 "%s", width, val, suffix);
+                        break;
+                }
+                case FIELD_UINT_SUFFIX_DEC: {
+                        uint64_t val = field->uint;
+                        char suffix;
+                        width -= 1;
+                        order_suffix(val, &val, &suffix);
+                        printf("%*" PRIu64 "%c", width, val, suffix);
+                        break;
+                }
+                case FIELD_PERCENT:
+                        width -= 5; /* nnn.% */
+                        if (width > 2) {
+                                printf("%*s", width - 2, "");
+                                width = 2;
+                        }
+                        print_percent(field->fixed, width);
+                        break;
+                case FIELD_STRING:
+                        printf("%-*.*s", width, width, field->string);
+                        break;
+                }
+
+                if (column_index == table->num_columns - 1) {
+                        screen_newline();
+                        row++;
+                }
         }
         
@@ -398 +447 @@
 }
 
-static inline void print_excs_head(void)
-{
-        screen_style_inverted();
-        printf("[exc   ] [count   ] [%%count] [cycles  ] [%%cycles] [description");
-        screen_newline();
-        screen_style_normal();
-}
-
-static inline void print_excs(data_t *data)
+static inline void print_sort(table_t *table)
 {
         sysarg_t cols;
@@ -415 +456 @@
         sysarg_t row;
         screen_get_pos(&col, &row);
-        
-        size_t i;
-        for (i = 0; (i < data->exceptions_count) && (row < rows); i++) {
-                /* Filter-out cold exceptions if not instructed otherwise */
-                if ((!excs_all) && (!data->exceptions[i].hot))
-                        continue;
-                
-                uint64_t count;
-                uint64_t cycles;
-                
-                char count_suffix;
-                char cycles_suffix;
-                
-                order_suffix(data->exceptions[i].count, &count, &count_suffix);
-                order_suffix(data->exceptions[i].cycles, &cycles, &cycles_suffix);
-                
-                printf("%-8u %9" PRIu64 "%c  ",
-                     data->exceptions[i].id, count, count_suffix);
-                print_percent(data->exceptions_perc[i].count, 2);
-                printf(" %9" PRIu64 "%c   ", cycles, cycles_suffix);
-                print_percent(data->exceptions_perc[i].cycles, 2);
-                puts(" ");
-                print_string(data->exceptions[i].desc);
-                
+
+        size_t num = min(table->num_columns, rows - row);
+        for (size_t i = 0; i < num; i++) {
+                printf("%c - %s", table->columns[i].key, table->columns[i].name);
                 screen_newline();
                 row++;
@@ -449 +470 @@
 }
 
-static void print_help(void)
-{
-        sysarg_t cols;
-        sysarg_t rows;
-        screen_get_size(&cols, &rows);
-        
-        sysarg_t col;
-        sysarg_t row;
-        screen_get_pos(&col, &row);
-        
-        screen_newline();
-        
-        printf("Operation modes:");
-        screen_newline();
-        
-        printf(" t .. tasks statistics");
-        screen_newline();
-        
-        printf(" i .. IPC statistics");
-        screen_newline();
-        
-        printf(" e .. exceptions statistics");
-        screen_newline();
-        
-        printf("      a .. toggle display of all/hot exceptions");
-        screen_newline();
-        
-        row += 6;
-        
-        while (row < rows) {
-                screen_newline();
-                row++;
-        }
+static inline void print_warning(void)
+{
+        screen_get_pos(&warning_col, &warning_row);
+        if (warning_timeleft > 0) {
+                screen_style_emphasis();
+                print_string(warning_text);
+                screen_style_normal();
+        } else {
+                free(warning_text);
+                warning_text = NULL;
+        }
+        screen_newline();
 }
 
@@ -492 +492 @@
         print_cpu_info(data);
         print_physmem_info(data);
-        
-        /* Empty row for warnings */
-        screen_get_pos(&warn_col, &warn_row);
-        screen_newline();
-        
-        switch (op_mode) {
-        case OP_TASKS:
-                print_tasks_head();
-                print_tasks(data);
+        print_warning();
+        
+        switch (screen_mode) {
+        case SCREEN_TABLE:
+                print_table_head(&data->table);
+                print_table(&data->table);
                 break;
-        case OP_IPC:
-                print_ipc_head();
-                print_ipc(data);
+        case SCREEN_SORT:
+                print_sort(&data->table);
                 break;
-        case OP_EXCS:
-                print_excs_head();
-                print_excs(data);
-                break;
-        case OP_HELP:
-                print_tasks_head();
+        case SCREEN_HELP:
+                print_help_head();
                 print_help();
         }
@@ -518 +510 @@
 }
 
-void print_warning(const char *fmt, ...)
-{
-        screen_moveto(warn_col, warn_row);
-        
+void show_warning(const char *fmt, ...)
+{
+        sysarg_t cols;
+        sysarg_t rows;
+        screen_get_size(&cols, &rows);
+
+        size_t warning_text_size = 1 + cols * sizeof(*warning_text);
+        free(warning_text);
+        warning_text = malloc(warning_text_size);
+        if (!warning_text)
+                return;
+
         va_list args;
         va_start(args, fmt);
-        vprintf(fmt, args);
+        vsnprintf(warning_text, warning_text_size, fmt, args);
         va_end(args);
         
-        screen_newline();
+        warning_timeleft = 2 * USEC_COUNT;
+
+        screen_moveto(warning_col, warning_row);
+        print_warning();
         console_flush(console);
 }
@@ -555 +558 @@
                 kbd_event_t event;
                 
+                warning_timeleft -= timeleft;
                 if (!console_get_kbd_event_timeout(console, &event, &timeleft)) {
                         timeleft = 0;
                         return -1;
                 }
+                warning_timeleft += timeleft;
                 
                 if (event.type == KEY_PRESS)

uspace/app/top/screen.h

@@ -43 +43 @@
 extern void screen_done(void);
 extern void print_data(data_t *);
-extern void print_warning(const char *, ...);
+extern void show_warning(const char *, ...);
 
 extern int tgetchar(unsigned int);

uspace/app/top/top.c

@@ -55 +55 @@
 #define MINUTE  60
 
-op_mode_t op_mode = OP_TASKS;
-sort_mode_t sort_mode = SORT_TASK_CYCLES;
-bool excs_all = false;
+typedef enum {
+        OP_TASKS,
+        OP_IPC,
+        OP_EXCS,
+} op_mode_t;
+
+static const column_t task_columns[] = {
+        {"taskid",   't',  8},
+        {"thrds",    'h',  7},
+        {"resident", 'r', 10},
+        {"%resi",    'R',  7},
+        {"virtual",  'v',  9},
+        {"%virt",    'V',  7},
+        {"%user",    'U',  7},
+        {"%kern",    'K',  7},
+        {"name",     'd',  0},
+};
+
+enum {
+        TASK_COL_ID = 0,
+        TASK_COL_NUM_THREADS,
+        TASK_COL_RESIDENT,
+        TASK_COL_PERCENT_RESIDENT,
+        TASK_COL_VIRTUAL,
+        TASK_COL_PERCENT_VIRTUAL,
+        TASK_COL_PERCENT_USER,
+        TASK_COL_PERCENT_KERNEL,
+        TASK_COL_NAME,
+        TASK_NUM_COLUMNS,
+};
+
+static const column_t ipc_columns[] = {
+        {"taskid",  't', 8},
+        {"cls snt", 'c', 9},
+        {"cls rcv", 'C', 9},
+        {"ans snt", 'a', 9},
+        {"ans rcv", 'A', 9},
+        {"forward", 'f', 9},
+        {"name",    'd', 0},
+};
+
+enum {
+        IPC_COL_TASKID = 0,
+        IPC_COL_CLS_SNT,
+        IPC_COL_CLS_RCV,
+        IPC_COL_ANS_SNT,
+        IPC_COL_ANS_RCV,
+        IPC_COL_FORWARD,
+        IPC_COL_NAME,
+        IPC_NUM_COLUMNS,
+};
+
+static const column_t exception_columns[] = {
+        {"exc",         'e',  8},
+        {"count",       'n', 10},
+        {"%count",      'N',  8},
+        {"cycles",      'c', 10},
+        {"%cycles",     'C',  9},
+        {"description", 'd',  0},
+};
+
+enum {
+        EXCEPTION_COL_ID = 0,
+        EXCEPTION_COL_COUNT,
+        EXCEPTION_COL_PERCENT_COUNT,
+        EXCEPTION_COL_CYCLES,
+        EXCEPTION_COL_PERCENT_CYCLES,
+        EXCEPTION_COL_DESCRIPTION,
+        EXCEPTION_NUM_COLUMNS,
+};
+
+screen_mode_t screen_mode = SCREEN_TABLE;
+static op_mode_t op_mode = OP_TASKS;
+static size_t sort_column = TASK_COL_PERCENT_USER;
+static int sort_reverse = -1;
+static bool excs_all = false;
 
 static const char *read_data(data_t *target)
@@ -67 +140 @@
         target->tasks = NULL;
         target->tasks_perc = NULL;
-        target->tasks_map = NULL;
         target->threads = NULL;
         target->exceptions = NULL;
@@ -76 +148 @@
         target->ecycles_diff = NULL;
         target->ecount_diff = NULL;
+        target->table.name = NULL;
+        target->table.num_columns = 0;
+        target->table.columns = NULL;
+        target->table.num_fields = 0;
+        target->table.fields = NULL;
         
         /* Get current time */
@@ -117 +194 @@
         if (target->tasks_perc == NULL)
                 return "Not enough memory for task utilization";
-        
-        target->tasks_map =
-            (size_t *) calloc(target->tasks_count, sizeof(size_t));
-        if (target->tasks_map == NULL)
-                return "Not enough memory for task map";
         
         /* Get threads */
@@ -289 +361 @@
 static int cmp_data(void *a, void *b, void *arg)
 {
-        size_t ia = *((size_t *) a);
-        size_t ib = *((size_t *) b);
-        data_t *data = (data_t *) arg;
-        
-        uint64_t acycles = data->ucycles_diff[ia] + data->kcycles_diff[ia];
-        uint64_t bcycles = data->ucycles_diff[ib] + data->kcycles_diff[ib];
-        
-        if (acycles > bcycles)
-                return -1;
-        
-        if (acycles < bcycles)
-                return 1;
-        
+        field_t *fa = (field_t *)a + sort_column;
+        field_t *fb = (field_t *)b + sort_column;
+        
+        if (fa->type > fb->type)
+                return 1 * sort_reverse;
+
+        if (fa->type < fb->type)
+                return -1 * sort_reverse;
+
+        switch (fa->type) {
+        case FIELD_EMPTY:
+                return 0;
+        case FIELD_UINT_SUFFIX_BIN: /* fallthrough */
+        case FIELD_UINT_SUFFIX_DEC: /* fallthrough */
+        case FIELD_UINT:
+                if (fa->uint > fb->uint)
+                        return 1 * sort_reverse;
+                if (fa->uint < fb->uint)
+                        return -1 * sort_reverse;
+                return 0;
+        case FIELD_PERCENT:
+                if (fa->fixed.upper * fb->fixed.lower
+                    > fb->fixed.upper * fa->fixed.lower)
+                        return 1 * sort_reverse;
+                if (fa->fixed.upper * fb->fixed.lower
+                    < fb->fixed.upper * fa->fixed.lower)
+                        return -1 * sort_reverse;
+                return 0;
+        case FIELD_STRING:
+                return str_cmp(fa->string, fb->string) * sort_reverse;
+        }
+
         return 0;
 }
 
-static void sort_data(data_t *data)
-{
-        size_t i;
-        
-        for (i = 0; i < data->tasks_count; i++)
-                data->tasks_map[i] = i;
-        
-        qsort((void *) data->tasks_map, data->tasks_count,
-            sizeof(size_t), cmp_data, (void *) data);
+static void sort_table(table_t *table)
+{
+        if (sort_column >= table->num_columns)
+                sort_column = 0;
+        /* stable sort is probably best, so we use gsort */
+        gsort((void *) table->fields, table->num_fields / table->num_columns,
+            sizeof(field_t) * table->num_columns, cmp_data, NULL);
+}
+
+static const char *fill_task_table(data_t *data)
+{
+        data->table.name = "Tasks";
+        data->table.num_columns = TASK_NUM_COLUMNS;
+        data->table.columns = task_columns;
+        data->table.num_fields = data->tasks_count * TASK_NUM_COLUMNS;
+        data->table.fields = calloc(data->table.num_fields,
+            sizeof(field_t));
+        if (data->table.fields == NULL)
+                return "Not enough memory for table fields";
+
+        field_t *field = data->table.fields;
+        for (size_t i = 0; i < data->tasks_count; i++) {
+                stats_task_t *task = &data->tasks[i];
+                perc_task_t *perc = &data->tasks_perc[i];
+                field[TASK_COL_ID].type = FIELD_UINT;
+                field[TASK_COL_ID].uint = task->task_id;
+                field[TASK_COL_NUM_THREADS].type = FIELD_UINT;
+                field[TASK_COL_NUM_THREADS].uint = task->threads;
+                field[TASK_COL_RESIDENT].type = FIELD_UINT_SUFFIX_BIN;
+                field[TASK_COL_RESIDENT].uint = task->resmem;
+                field[TASK_COL_PERCENT_RESIDENT].type = FIELD_PERCENT;
+                field[TASK_COL_PERCENT_RESIDENT].fixed = perc->resmem;
+                field[TASK_COL_VIRTUAL].type = FIELD_UINT_SUFFIX_BIN;
+                field[TASK_COL_VIRTUAL].uint = task->virtmem;
+                field[TASK_COL_PERCENT_VIRTUAL].type = FIELD_PERCENT;
+                field[TASK_COL_PERCENT_VIRTUAL].fixed = perc->virtmem;
+                field[TASK_COL_PERCENT_USER].type = FIELD_PERCENT;
+                field[TASK_COL_PERCENT_USER].fixed = perc->ucycles;
+                field[TASK_COL_PERCENT_KERNEL].type = FIELD_PERCENT;
+                field[TASK_COL_PERCENT_KERNEL].fixed = perc->kcycles;
+                field[TASK_COL_NAME].type = FIELD_STRING;
+                field[TASK_COL_NAME].string = task->name;
+                field += TASK_NUM_COLUMNS;
+        }
+
+        return NULL;
+}
+
+static const char *fill_ipc_table(data_t *data)
+{
+        data->table.name = "IPC";
+        data->table.num_columns = IPC_NUM_COLUMNS;
+        data->table.columns = ipc_columns;
+        data->table.num_fields = data->tasks_count * IPC_NUM_COLUMNS;
+        data->table.fields = calloc(data->table.num_fields,
+            sizeof(field_t));
+        if (data->table.fields == NULL)
+                return "Not enough memory for table fields";
+
+        field_t *field = data->table.fields;
+        for (size_t i = 0; i < data->tasks_count; i++) {
+                field[IPC_COL_TASKID].type = FIELD_UINT;
+                field[IPC_COL_TASKID].uint = data->tasks[i].task_id;
+                field[IPC_COL_CLS_SNT].type = FIELD_UINT_SUFFIX_DEC;
+                field[IPC_COL_CLS_SNT].uint = data->tasks[i].ipc_info.call_sent;
+                field[IPC_COL_CLS_RCV].type = FIELD_UINT_SUFFIX_DEC;
+                field[IPC_COL_CLS_RCV].uint = data->tasks[i].ipc_info.call_received;
+                field[IPC_COL_ANS_SNT].type = FIELD_UINT_SUFFIX_DEC;
+                field[IPC_COL_ANS_SNT].uint = data->tasks[i].ipc_info.answer_sent;
+                field[IPC_COL_ANS_RCV].type = FIELD_UINT_SUFFIX_DEC;
+                field[IPC_COL_ANS_RCV].uint = data->tasks[i].ipc_info.answer_received;
+                field[IPC_COL_FORWARD].type = FIELD_UINT_SUFFIX_DEC;
+                field[IPC_COL_FORWARD].uint = data->tasks[i].ipc_info.forwarded;
+                field[IPC_COL_NAME].type = FIELD_STRING;
+                field[IPC_COL_NAME].string = data->tasks[i].name;
+                field += IPC_NUM_COLUMNS;
+        }
+
+        return NULL;
+}
+
+static const char *fill_exception_table(data_t *data)
+{
+        data->table.name = "Exceptions";
+        data->table.num_columns = EXCEPTION_NUM_COLUMNS;
+        data->table.columns = exception_columns;
+        data->table.num_fields = data->exceptions_count *
+            EXCEPTION_NUM_COLUMNS;
+        data->table.fields = calloc(data->table.num_fields, sizeof(field_t));
+        if (data->table.fields == NULL)
+                return "Not enough memory for table fields";
+
+        field_t *field = data->table.fields;
+        for (size_t i = 0; i < data->exceptions_count; i++) {
+                if (!excs_all && !data->exceptions[i].hot)
+                        continue;
+                field[EXCEPTION_COL_ID].type = FIELD_UINT;
+                field[EXCEPTION_COL_ID].uint = data->exceptions[i].id;
+                field[EXCEPTION_COL_COUNT].type = FIELD_UINT_SUFFIX_DEC;
+                field[EXCEPTION_COL_COUNT].uint = data->exceptions[i].count;
+                field[EXCEPTION_COL_PERCENT_COUNT].type = FIELD_PERCENT;
+                field[EXCEPTION_COL_PERCENT_COUNT].fixed = data->exceptions_perc[i].count;
+                field[EXCEPTION_COL_CYCLES].type = FIELD_UINT_SUFFIX_DEC;
+                field[EXCEPTION_COL_CYCLES].uint = data->exceptions[i].cycles;
+                field[EXCEPTION_COL_PERCENT_CYCLES].type = FIELD_PERCENT;
+                field[EXCEPTION_COL_PERCENT_CYCLES].fixed = data->exceptions_perc[i].cycles;
+                field[EXCEPTION_COL_DESCRIPTION].type = FIELD_STRING;
+                field[EXCEPTION_COL_DESCRIPTION].string = data->exceptions[i].desc;
+                field += EXCEPTION_NUM_COLUMNS;
+        }
+
+        /* in case any cold exceptions were ignored */
+        data->table.num_fields = field - data->table.fields;
+
+        return NULL;
+}
+
+static const char *fill_table(data_t *data)
+{
+        if (data->table.fields != NULL) {
+                free(data->table.fields);
+                data->table.fields = NULL;
+        }
+
+        switch (op_mode) {
+        case OP_TASKS:
+                return fill_task_table(data);
+        case OP_IPC:
+                return fill_ipc_table(data);
+        case OP_EXCS:
+                return fill_exception_table(data);
+        }
+        return NULL;
 }
 
@@ -356 +571 @@
         if (target->ecount_diff != NULL)
                 free(target->ecount_diff);
+
+        if (target->table.fields != NULL)
+                free(target->table.fields);
 }
 
@@ -367 +585 @@
         printf("Reading initial data...\n");
         
-        if ((ret = read_data(&data_prev)) != NULL)
+        if ((ret = read_data(&data)) != NULL)
                 goto out;
         
         /* Compute some rubbish to have initialised values */
-        compute_percentages(&data_prev, &data_prev);
+        compute_percentages(&data, &data);
         
         /* And paint screen until death */
         while (true) {
                 int c = tgetchar(UPDATE_INTERVAL);
-                if (c < 0) {
+
+                if (c < 0) { /* timeout */
+                        data_prev = data;
                         if ((ret = read_data(&data)) != NULL) {
-                                free_data(&data);
+                                free_data(&data_prev);
                                 goto out;
                         }
                         
                         compute_percentages(&data_prev, &data);
-                        sort_data(&data);
-                        print_data(&data);
                         free_data(&data_prev);
-                        data_prev = data;
-                        
-                        continue;
-                }
-                
+
+                        c = -1;
+                }
+
+                if (screen_mode == SCREEN_HELP && c >= 0) {
+                        if (c == 'h' || c == '?')
+                                c = -1;
+                        /* go back to table and handle the key */
+                        screen_mode = SCREEN_TABLE;
+                }
+
+                if (screen_mode == SCREEN_SORT && c >= 0) {
+                        for (size_t i = 0; i < data.table.num_columns; i++) {
+                                if (data.table.columns[i].key == c) {
+                                        sort_column = i;
+                                        screen_mode = SCREEN_TABLE;
+                                }
+                        }
+
+                        c = -1;
+                }
+
                 switch (c) {
-                        case 't':
-                                print_warning("Showing task statistics");
-                                op_mode = OP_TASKS;
+                case -1: /* do nothing */
+                        break;
+                case 't':
+                        op_mode = OP_TASKS;
+                        break;
+                case 'i':
+                        op_mode = OP_IPC;
+                        break;
+                case 'e':
+                        op_mode = OP_EXCS;
+                        break;
+                case 's':
+                        screen_mode = SCREEN_SORT;
+                        break;
+                case 'r':
+                        sort_reverse = -sort_reverse;
+                        break;
+                case 'h':
+                case '?':
+                        screen_mode = SCREEN_HELP;
+                        break;
+                case 'q':
+                        goto out;
+                case 'a':
+                        if (op_mode == OP_EXCS) {
+                                excs_all = !excs_all;
+                                if (excs_all)
+                                        show_warning("Showing all exceptions");
+                                else
+                                        show_warning("Showing only hot exceptions");
                                 break;
-                        case 'i':
-                                print_warning("Showing IPC statistics");
-                                op_mode = OP_IPC;
-                                break;
-                        case 'e':
-                                print_warning("Showing exception statistics");
-                                op_mode = OP_EXCS;
-                                break;
-                        case 'h':
-                                print_warning("Showing help");
-                                op_mode = OP_HELP;
-                                break;
-                        case 'q':
-                                goto out;
-                        case 'a':
-                                if (op_mode == OP_EXCS) {
-                                        excs_all = !excs_all;
-                                        if (excs_all)
-                                                print_warning("Showing all exceptions");
-                                        else
-                                                print_warning("Showing only hot exceptions");
-                                        break;
-                                }
-                        default:
-                                print_warning("Unknown command \"%c\", use \"h\" for help", c);
-                                break;
-                }
+                        }
+                        /* fallthrough */
+                default:
+                        show_warning("Unknown command \"%c\", use \"h\" for help", c);
+                        continue; /* don't redraw */
+                }
+
+                if ((ret = fill_table(&data)) != NULL) {
+                        goto out;
+                }
+                sort_table(&data.table);
+                print_data(&data);
         }
         
 out:
         screen_done();
-        free_data(&data_prev);
+        free_data(&data);
         
         if (ret != NULL) {

uspace/app/top/top.h

@@ -51 +51 @@
 
 typedef enum {
-        OP_TASKS,
-        OP_IPC,
-        OP_EXCS,
-        OP_HELP
-} op_mode_t;
+        SCREEN_TABLE,
+        SCREEN_SORT,
+        SCREEN_HELP,
+} screen_mode_t;
 
-typedef enum {
-        SORT_TASK_CYCLES
-} sort_mode_t;
-
-extern op_mode_t op_mode;
-extern sort_mode_t sort_mode;
-extern bool excs_all;
+extern screen_mode_t screen_mode;
 
 typedef struct {
@@ -87 +80 @@
 } perc_exc_t;
 
+typedef enum {
+        FIELD_EMPTY, FIELD_UINT, FIELD_UINT_SUFFIX_BIN, FIELD_UINT_SUFFIX_DEC,
+        FIELD_PERCENT, FIELD_STRING
+} field_type_t;
+
+typedef struct {
+        field_type_t type;
+        union {
+                fixed_float fixed;
+                uint64_t uint;
+                const char *string;
+        };
+} field_t;
+
+typedef struct {
+        const char *name;
+        char key;
+        int width;
+} column_t;
+
+typedef struct {
+        const char *name;
+        size_t num_columns;
+        const column_t *columns;
+        size_t num_fields;
+        field_t *fields;
+} table_t;
+
 typedef struct {
         time_t hours;
@@ -107 +128 @@
         stats_task_t *tasks;
         perc_task_t *tasks_perc;
-        size_t *tasks_map;
         
         size_t threads_count;
@@ -122 +142 @@
         uint64_t *ecycles_diff;
         uint64_t *ecount_diff;
+
+        table_t table;
 } data_t;
 

uspace/app/trace/ipc_desc.c

@@ -39 +39 @@
 ipc_m_desc_t ipc_methods[] = {
         /* System methods */
-        { 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" },
+        { IPC_M_PHONE_HUNGUP,     "PHONE_HUNGUP" },
+        { IPC_M_CONNECTION_CLONE, "CONNECTION_CLONE" },
+        { IPC_M_CLONE_ESTABLISH,  "CLONE_ESTABLISH" },
+        { 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 */

uspace/app/websrv/websrv.c

@@ -200 +200 @@
 {
         if (str_cmp(uri, "/") == 0)
-                uri = "/index.htm";
+                uri = "/index.html";
         
         char *fname;