Changeset 8cc4ddb in mainline for uspace/app

Timestamp:

2011-08-28T21:16:54Z (14 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

0f0f8bc

Parents:

1a5b252 (diff), 36e2b55 (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/Makefile (modified) (1 diff)
• bdsh/cmds/modules/help/help.c (modified) (3 diffs)
• bdsh/compl.c (modified) (7 diffs)
• bdsh/input.c (modified) (3 diffs)
• mkfat/fat.h (modified) (1 diff)
• mkfat/mkfat.c (modified) (20 diffs)
• sysinfo/sysinfo.c (modified) (3 diffs)
• tester/print/print2.c (modified) (1 diff)
• tester/stdio/stdio1.c (modified) (1 diff)
• trace/syscalls.c (modified) (1 diff)

uspace/app/bdsh/Makefile

@@ -29 +29 @@
 
 USPACE_PREFIX = ../..
-LIBS = $(LIBBLOCK_PREFIX)/libblock.a $(LIBCLUI_PREFIX)/libclui.a
-EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -I$(LIBCLUI_PREFIX) -I. -Icmds/ \
-        -Icmds/builtins -Icmds/modules
+LIBS = $(LIBBLOCK_PREFIX)/libblock.a $(LIBCLUI_PREFIX)/libclui.a \
+        $(LIBFMTUTIL_PREFIX)/libfmtutil.a
+EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -I$(LIBCLUI_PREFIX) \
+        -I$(LIBFMTUTIL_PREFIX) -I. -Icmds/ -Icmds/builtins -Icmds/modules
 BINARY = bdsh
 

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2008 Tim Post
+ * Copyright (c) 2011 Martin Sucha
  * All rights reserved.
  *
@@ -30 +31 @@
 #include <stdlib.h>
 #include <str.h>
+#include <fmtutil.h>
 
 #include "config.h"
@@ -128 +130 @@
 static void help_survival(void)
 {
-        printf("Don't panic!\n\n");
-
-        printf("This is Bdsh, the Brain dead shell, currently "
+        print_wrapped_console(
+            "Don't panic!\n\n"
+
+            "This is Bdsh, the Brain dead shell, currently "
             "the primary user interface to HelenOS. Bdsh allows you to enter "
             "commands and supports history (Up, Down arrow keys), "
             "line editing (Left Arrow, Right Arrow, Home, End, Backspace), "
             "selection (Shift + movement keys), copy and paste (Ctrl-C, "
-            "Ctrl-V), similar to common desktop environments.\n\n");
-
-        printf("The most basic filesystem commands are Bdsh builtins. Type "
+            "Ctrl-V), similar to common desktop environments.\n\n"
+
+            "The most basic filesystem commands are Bdsh builtins. Type "
             "'help commands' [Enter] to see the list of Bdsh builtin commands. "
             "Other commands are external executables located in the /app and "
             "/srv directories. Type 'ls /app' [Enter] and 'ls /srv' [Enter] "
             "to see their list. You can execute an external command simply "
-            "by entering its name (e.g. type 'tetris' [Enter]).\n\n");
-
-        printf("HelenOS has virtual consoles (VCs). You can switch between "
-            "these using the F1-F11 keys.\n\n");
-
-        printf("This is but a small glimpse of what you can do with HelenOS. "
+            "by entering its name (e.g. type 'tetris' [Enter]).\n\n"
+
+            "HelenOS has virtual consoles (VCs). You can switch between "
+            "these using the F1-F11 keys.\n\n"
+
+            "This is but a small glimpse of what you can do with HelenOS. "
             "To learn more please point your browser to the HelenOS User's "
-            "Guide: http://trac.helenos.org/trac.fcgi/wiki/UsersGuide\n\n");
+            "Guide: http://trac.helenos.org/wiki/UsersGuide\n\n",
+            ALIGN_LEFT);
 }
 

uspace/app/bdsh/compl.c

@@ -90 +90 @@
 {
         compl_t *cs = NULL;
-        size_t pref_size;
         char *stext = NULL;
         char *prefix = NULL;
         char *dirname = NULL;
+        int retval;
+        
+        token_t *tokens = calloc(WORD_MAX, sizeof(token_t));
+        if (tokens == NULL) {
+                retval = ENOMEM;
+                goto error;
+        }
+        
+        size_t pref_size;
         char *rpath_sep;
         static const char *dirlist_arg[] = { ".", NULL };
-        int retval;
         tokenizer_t tok;
-        token_t tokens[WORD_MAX];
-        unsigned int current_token;
+        ssize_t current_token;
         size_t tokens_length;
-
+        
         cs = calloc(1, sizeof(compl_t));
         if (!cs) {
@@ -107 +113 @@
                 goto error;
         }
-
+        
         /* Convert text buffer to string */
         stext = wstr_to_astr(text);
@@ -127 +133 @@
         
         /* Find the current token */
-        for (current_token = 0; current_token < tokens_length; current_token++) {
+        for (current_token = 0; current_token < (ssize_t) tokens_length;
+            current_token++) {
                 token_t *t = &tokens[current_token];
                 size_t end = t->char_start + t->char_length;
-                /* Check if the caret lies inside the token or immediately
+                
+                /*
+                 * Check if the caret lies inside the token or immediately
                  * after it
                  */
@@ -138 +147 @@
         }
         
-        if (tokens[current_token].type != TOKTYPE_SPACE) {
+        if (tokens_length == 0)
+                current_token = -1;
+        
+        if ((current_token >= 0) && (tokens[current_token].type != TOKTYPE_SPACE))
                 *cstart = tokens[current_token].char_start;
-        }
-        else {
+        else
                 *cstart = pos;
-        }
-        
-        /* Extract the prefix being completed
+        
+        /*
+         * Extract the prefix being completed
          * XXX: handle strings, etc.
          */
@@ -154 +165 @@
                 goto error;
         }
-
-        str_ncpy(prefix, pref_size + 1, stext +
-            tokens[current_token].byte_start, pref_size);
+        prefix[pref_size] = 0;
+
+        if (current_token >= 0) {
+                str_ncpy(prefix, pref_size + 1, stext +
+                    tokens[current_token].byte_start, pref_size);
+        }
 
         /*
@@ -165 +179 @@
 
         /* Skip any whitespace before current token */
-        int prev_token = current_token - 1;
-        if (prev_token != -1 && tokens[prev_token].type == TOKTYPE_SPACE) {
+        ssize_t prev_token = current_token - 1;
+        if ((prev_token >= 0) && (tokens[prev_token].type == TOKTYPE_SPACE))
                 prev_token--;
-        }
-
+        
         /*
          * It is a command if it is the first token or if it immediately
          * follows a pipe token.
          */
-        if (prev_token == -1 || tokens[prev_token].type == TOKTYPE_SPACE)
+        if ((prev_token < 0) || (tokens[prev_token].type == TOKTYPE_SPACE))
                 cs->is_command = true;
         else
@@ -249 +262 @@
         if (cs != NULL)
                 free(cs);
+        if (tokens != NULL)
+                free(tokens);
 
         return retval;

uspace/app/bdsh/input.c

@@ -67 +67 @@
 int process_input(cliuser_t *usr)
 {
+        token_t *tokens = calloc(WORD_MAX, sizeof(token_t));
+        if (tokens == NULL)
+                return ENOMEM;
+        
         char *cmd[WORD_MAX];
-        token_t tokens_space[WORD_MAX];
-        token_t *tokens = tokens_space;
         int rc = 0;
         tokenizer_t tok;
@@ -77 +79 @@
         char *redir_to = NULL;
 
-        if (NULL == usr->line)
+        if (usr->line == NULL) {
+                free(tokens);
                 return CL_EFAIL;
+        }
 
         rc = tok_init(&tok, usr->line, tokens, WORD_MAX);
@@ -209 +213 @@
         }
         tok_fini(&tok);
+        free(tokens);
 
         return rc;

uspace/app/mkfat/fat.h

@@ -38 +38 @@
 #define BS_BLOCK                0
 #define BS_SIZE                 512
+#define DIRENT_SIZE             32
 
-#define DIRENT_SIZE             32
+#define FAT12_CLST_MAX    4085
+#define FAT16_CLST_MAX    65525
+
+#define FAT12   12
+#define FAT16   16
+#define FAT32   32
+
+#define FAT_CLUSTER_DOUBLE_SIZE(a) ((a) / 4)
 
 typedef struct fat_bs {

uspace/app/mkfat/mkfat.c

@@ -35 +35 @@
  * @brief       Tool for creating new FAT file systems.
  *
- * Currently we can only create 16-bit FAT.
+ * Currently we can create 12/16/32-bit FAT.
  */
 
@@ -55 +55 @@
 #define div_round_up(a, b) (((a) + (b) - 1) / (b))
 
-/** Predefined file-system parameters */
+/** Default file-system parameters */
 enum {
-        sector_size             = 512,
-        sectors_per_cluster     = 8,
-        fat_count               = 2,
-        reserved_clusters       = 2,
-        media_descriptor        = 0xF8 /**< fixed disk */
+        default_sector_size             = 512,
+        default_sectors_per_cluster     = 4,
+        default_fat_count               = 2,
+        default_reserved_clusters       = 2,
+        default_media_descriptor        = 0xF8 /**< fixed disk */
 };
 
 /** Configurable file-system parameters */
 typedef struct fat_cfg {
+        int fat_type; /* FAT12 = 12, FAT16 = 16, FAT32 = 32 */
+        size_t sector_size;
         uint32_t total_sectors;
         uint16_t root_ent_max;
-        uint16_t addt_res_sectors;
+        uint32_t addt_res_sectors;
+        uint8_t sectors_per_cluster;
+
+        uint16_t reserved_sectors;
+        uint32_t rootdir_sectors;
+        uint32_t fat_sectors;
+        uint32_t total_clusters;
+        uint8_t fat_count;
 } fat_cfg_t;
 
-/** Derived file-system parameters */
-typedef struct fat_params {
-        struct fat_cfg cfg;
-        uint16_t reserved_sectors;
-        uint16_t rootdir_sectors;
-        uint32_t fat_sectors;
-        uint16_t total_clusters;
-} fat_params_t;
-
 static void syntax_print(void);
 
-static int fat_params_compute(struct fat_cfg const *cfg,
-    struct fat_params *par);
-static int fat_blocks_write(struct fat_params const *par,
-    service_id_t service_id);
-static void fat_bootsec_create(struct fat_params const *par, struct fat_bs *bs);
+static int fat_params_compute(struct fat_cfg *cfg);
+static int fat_blocks_write(struct fat_cfg const *cfg, service_id_t service_id);
+static void fat_bootsec_create(struct fat_cfg const *cfg, struct fat_bs *bs);
 
 int main(int argc, char **argv)
 {
-        struct fat_params par;
         struct fat_cfg cfg;
 
@@ -96 +93 @@
         char *dev_path;
         service_id_t service_id;
-        size_t block_size;
         char *endptr;
         aoff64_t dev_nblocks;
 
+        cfg.sector_size = default_sector_size;
+        cfg.sectors_per_cluster = default_sectors_per_cluster;
+        cfg.fat_count = default_fat_count;
         cfg.total_sectors = 0;
         cfg.addt_res_sectors = 0;
         cfg.root_ent_max = 128;
+        cfg.fat_type = FAT16;
 
         if (argc < 2) {
@@ -111 +111 @@
 
         --argc; ++argv;
-
         if (str_cmp(*argv, "--size") == 0) {
                 --argc; ++argv;
@@ -130 +129 @@
         }
 
+        if (str_cmp(*argv, "--type") == 0) {
+                --argc; ++argv;
+                if (*argv == NULL) {
+                        printf(NAME ": Error, argument missing.\n");
+                        syntax_print();
+                        return 1;
+                }
+
+                cfg.fat_type = strtol(*argv, &endptr, 10);
+                if (*endptr != '\0') {
+                        printf(NAME ": Error, invalid argument.\n");
+                        syntax_print();
+                        return 1;
+                }
+
+                --argc; ++argv;
+        }
+
         if (argc != 1) {
                 printf(NAME ": Error, unexpected argument.\n");
@@ -137 +154 @@
 
         dev_path = *argv;
+        printf("Device: %s\n", dev_path);
 
         rc = loc_service_get_id(dev_path, &service_id, 0);
@@ -150 +168 @@
         }
 
-        rc = block_get_bsize(service_id, &block_size);
+        rc = block_get_bsize(service_id, &cfg.sector_size);
         if (rc != EOK) {
                 printf(NAME ": Error determining device block size.\n");
@@ -162 +180 @@
                 printf(NAME ": Block device has %" PRIuOFF64 " blocks.\n",
                     dev_nblocks);
-                cfg.total_sectors = dev_nblocks;
-        }
-
-        if (block_size != 512) {
-                printf(NAME ": Error. Device block size is not 512 bytes.\n");
-                return 2;
+                if (!cfg.total_sectors || dev_nblocks < cfg.total_sectors)
+                        cfg.total_sectors = dev_nblocks;
         }
 
@@ -175 +189 @@
         }
 
-        printf(NAME ": Creating FAT filesystem on device %s.\n", dev_path);
-
-        rc = fat_params_compute(&cfg, &par);
+        if (cfg.fat_type != FAT12 && cfg.fat_type != FAT16 && cfg.fat_type != FAT32) {
+                printf(NAME ": Error. Unknown FAT type.\n");
+                return 2;
+        }
+
+        printf(NAME ": Creating FAT%d filesystem on device %s.\n", cfg.fat_type, dev_path);
+
+        rc = fat_params_compute(&cfg);
         if (rc != EOK) {
                 printf(NAME ": Invalid file-system parameters.\n");
@@ -183 +202 @@
         }
 
-        rc = fat_blocks_write(&par, service_id);
+        rc = fat_blocks_write(&cfg, service_id);
         if (rc != EOK) {
                 printf(NAME ": Error writing device.\n");
@@ -197 +216 @@
 static void syntax_print(void)
 {
-        printf("syntax: mkfat [--size <num_blocks>] <device_name>\n");
+        printf("syntax: mkfat [--size <sectors>] [--type 12|16|32] <device_name>\n");
 }
 
@@ -205 +224 @@
  * file system params.
  */
-static int fat_params_compute(struct fat_cfg const *cfg, struct fat_params *par)
+static int fat_params_compute(struct fat_cfg *cfg)
 {
         uint32_t fat_bytes;
@@ -211 +230 @@
 
         /*
-         * Make a conservative guess on the FAT size needed for the file
-         * system. The optimum could be potentially smaller since we
-         * do not subtract size of the FAT itself when computing the
-         * size of the data region.
-         */
-
-        par->reserved_sectors = 1 + cfg->addt_res_sectors;
-        par->rootdir_sectors = div_round_up(cfg->root_ent_max * DIRENT_SIZE,
-            sector_size);
-        non_data_sectors_lb = par->reserved_sectors + par->rootdir_sectors;
-
-        par->total_clusters = div_round_up(cfg->total_sectors - non_data_sectors_lb,
-            sectors_per_cluster);
-
-        fat_bytes = (par->total_clusters + 2) * 2;
-        par->fat_sectors = div_round_up(fat_bytes, sector_size);
-
-        par->cfg = *cfg;
+         * Make a conservative guess on the FAT size needed for the file
+         * system. The optimum could be potentially smaller since we
+         * do not subtract size of the FAT itself when computing the
+         * size of the data region.
+         */
+
+        cfg->reserved_sectors = 1 + cfg->addt_res_sectors;
+        if (cfg->fat_type != FAT32) {
+                cfg->rootdir_sectors = div_round_up(cfg->root_ent_max * DIRENT_SIZE,
+                        cfg->sector_size);
+        } else
+                cfg->rootdir_sectors = 0;
+        non_data_sectors_lb = cfg->reserved_sectors + cfg->rootdir_sectors;
+
+        cfg->total_clusters = div_round_up(cfg->total_sectors - non_data_sectors_lb,
+            cfg->sectors_per_cluster);
+
+        if ((cfg->fat_type == FAT12 && cfg->total_clusters > FAT12_CLST_MAX) ||
+            (cfg->fat_type == FAT16 && (cfg->total_clusters <= FAT12_CLST_MAX ||
+            cfg->total_clusters > FAT16_CLST_MAX)) ||
+            (cfg->fat_type == FAT32 && cfg->total_clusters <= FAT16_CLST_MAX))
+                return ENOSPC;
+
+        fat_bytes = div_round_up((cfg->total_clusters + 2) *
+            FAT_CLUSTER_DOUBLE_SIZE(cfg->fat_type), 2);
+        cfg->fat_sectors = div_round_up(fat_bytes, cfg->sector_size);
 
         return EOK;
@@ -234 +261 @@
 
 /** Create file system with the given parameters. */
-static int fat_blocks_write(struct fat_params const *par, service_id_t service_id)
+static int fat_blocks_write(struct fat_cfg const *cfg, service_id_t service_id)
 {
         aoff64_t addr;
@@ -243 +270 @@
         struct fat_bs bs;
 
-        fat_bootsec_create(par, &bs);
+        fat_bootsec_create(cfg, &bs);
 
         rc = block_write_direct(service_id, BS_BLOCK, 1, &bs);
@@ -251 +278 @@
         addr = BS_BLOCK + 1;
 
-        buffer = calloc(sector_size, 1);
+        buffer = calloc(cfg->sector_size, 1);
         if (buffer == NULL)
                 return ENOMEM;
+        memset(buffer, 0, cfg->sector_size);
 
         /* Reserved sectors */
-        for (i = 0; i < par->reserved_sectors - 1; ++i) {
+        for (i = 0; i < cfg->reserved_sectors - 1; ++i) {
                 rc = block_write_direct(service_id, addr, 1, buffer);
                 if (rc != EOK)
@@ -265 +293 @@
 
         /* File allocation tables */
-        for (i = 0; i < fat_count; ++i) {
+        for (i = 0; i < cfg->fat_count; ++i) {
                 printf("Writing allocation table %d.\n", i + 1);
 
-                for (j = 0; j < par->fat_sectors; ++j) {
-                        memset(buffer, 0, sector_size);
+                for (j = 0; j < cfg->fat_sectors; ++j) {
+                        memset(buffer, 0, cfg->sector_size);
                         if (j == 0) {
-                                buffer[0] = media_descriptor;
+                                buffer[0] = default_media_descriptor;
                                 buffer[1] = 0xFF;
                                 buffer[2] = 0xFF;
-                                buffer[3] = 0xFF;
+                                if (cfg->fat_type == FAT16) {
+                                        buffer[3] = 0xFF;
+                                } else if (cfg->fat_type == FAT32) {
+                                        buffer[3] = 0x0F;
+                                        buffer[4] = 0xFF;
+                                        buffer[5] = 0xFF;
+                                        buffer[6] = 0xFF;
+                                        buffer[7] = 0x0F;
+                                        buffer[8] = 0xF8;
+                                        buffer[9] = 0xFF;
+                                        buffer[10] = 0xFF;
+                                        buffer[11] = 0x0F;
+                                }
                         }
 
@@ -285 +325 @@
         }
 
+        /* Root directory */
         printf("Writing root directory.\n");
-
-        memset(buffer, 0, sector_size);
-
-        /* Root directory */
-        for (i = 0; i < par->rootdir_sectors; ++i) {
-                rc = block_write_direct(service_id, addr, 1, buffer);
-                if (rc != EOK)
-                        return EIO;
-
-                ++addr;
+        memset(buffer, 0, cfg->sector_size);
+        if (cfg->fat_type != FAT32) {
+                size_t idx;
+                for (idx = 0; idx < cfg->rootdir_sectors; ++idx) {
+                        rc = block_write_direct(service_id, addr, 1, buffer);
+                        if (rc != EOK)
+                                return EIO;
+
+                        ++addr;
+                }
+        } else {
+                for (i = 0; i < cfg->sectors_per_cluster; i++) {
+                        rc = block_write_direct(service_id, addr, 1, buffer);
+                        if (rc != EOK)
+                                return EIO;
+
+                        ++addr;
+                }       
         }
 
@@ -304 +353 @@
 
 /** Construct boot sector with the given parameters. */
-static void fat_bootsec_create(struct fat_params const *par, struct fat_bs *bs)
+static void fat_bootsec_create(struct fat_cfg const *cfg, struct fat_bs *bs)
 {
         memset(bs, 0, sizeof(*bs));
@@ -315 +364 @@
 
         /* BIOS Parameter Block */
-        bs->bps = host2uint16_t_le(sector_size);
-        bs->spc = sectors_per_cluster;
-        bs->rscnt = host2uint16_t_le(par->reserved_sectors);
-        bs->fatcnt = fat_count;
-        bs->root_ent_max = host2uint16_t_le(par->cfg.root_ent_max);
-
-        if (par->cfg.total_sectors < 0x10000)
-                bs->totsec16 = host2uint16_t_le(par->cfg.total_sectors);
-        else
-                bs->totsec16 = host2uint16_t_le(0);
-
-        bs->mdesc = media_descriptor;
-        bs->sec_per_fat = host2uint16_t_le(par->fat_sectors);
+        bs->bps = host2uint16_t_le(cfg->sector_size);
+        bs->spc = cfg->sectors_per_cluster;
+        bs->rscnt = host2uint16_t_le(cfg->reserved_sectors);
+        bs->fatcnt = cfg->fat_count;
+        bs->root_ent_max = host2uint16_t_le(cfg->root_ent_max);
+
+        if (cfg->total_sectors < 0x10000) {
+                bs->totsec16 = host2uint16_t_le(cfg->total_sectors);
+                bs->totsec32 = 0;
+        } else {
+                bs->totsec16 = 0;
+                bs->totsec32 = host2uint32_t_le(cfg->total_sectors);
+        }
+
+        bs->mdesc = default_media_descriptor;
         bs->sec_per_track = host2uint16_t_le(63);
+        bs->signature = host2uint16_t_be(0x55AA);
         bs->headcnt = host2uint16_t_le(6);
         bs->hidden_sec = host2uint32_t_le(0);
 
-        if (par->cfg.total_sectors >= 0x10000)
-                bs->totsec32 = host2uint32_t_le(par->cfg.total_sectors);
-        else
-                bs->totsec32 = host2uint32_t_le(0);
-
-        /* Extended BPB */
-        bs->pdn = 0x80;
-        bs->ebs = 0x29;
-        bs->id = host2uint32_t_be(0x12345678);
-
-        memcpy(bs->label, "HELENOS_NEW", 11);
-        memcpy(bs->type, "FAT16   ", 8);
-        bs->signature = host2uint16_t_be(0x55AA);
+        if (cfg->fat_type == FAT32) {
+                bs->sec_per_fat = 0;
+                bs->fat32.sectors_per_fat = host2uint32_t_le(cfg->fat_sectors);
+
+                bs->fat32.pdn = 0x80;
+                bs->fat32.ebs = 0x29;
+                bs->fat32.id = host2uint32_t_be(0x12345678);
+                bs->fat32.root_cluster = 2;
+
+                memcpy(bs->fat32.label, "HELENOS_NEW", 11);
+                memcpy(bs->fat32.type, "FAT32   ", 8);
+        } else {
+                bs->sec_per_fat = host2uint16_t_le(cfg->fat_sectors);
+                bs->pdn = 0x80;
+                bs->ebs = 0x29;
+                bs->id = host2uint32_t_be(0x12345678);
+
+                memcpy(bs->label, "HELENOS_NEW", 11);
+                memcpy(bs->type, "FAT   ", 8);
+        }
 }
 

uspace/app/sysinfo/sysinfo.c

@@ -51 +51 @@
         int rc;
         char *ipath;
-        sysinfo_item_tag_t tag;
+        sysinfo_item_val_type_t tag;
 
         if (argc != 2) {
@@ -60 +60 @@
         ipath = argv[1];
 
-        tag = sysinfo_get_tag(ipath);
+        tag = sysinfo_get_val_type(ipath);
 
         /* Silence warning */
@@ -75 +75 @@
         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;
         }

uspace/app/tester/print/print2.c

@@ -45 +45 @@
         TPRINTF("Real output:     [%d] [%3.2d] [%-3.2d] [%2.3d] [%-2.3d]\n\n", -1, -2, -3, -4, -5);
         
+        TPRINTF("Testing printf(\"%%lld %%3.2lld %%-3.2lld %%2.3lld %%-2.3lld\", (long long) -1, (long long) -2, (long long) -3, (long long) -4, (long long) -5):\n");
+        TPRINTF("Expected output: [-1] [-02] [-03] [-004] [-005]\n");
+        TPRINTF("Real output:     [%lld] [%3.2lld] [%-3.2lld] [%2.3lld] [%-2.3lld]\n\n", (long long) -1, (long long) -2, (long long) -3, (long long) -4, (long long) -5);
+        
         TPRINTF("Testing printf(\"%%#x %%5.3#x %%-5.3#x %%3.5#x %%-3.5#x\", 17, 18, 19, 20, 21):\n");
         TPRINTF("Expected output: [0x11] [0x012] [0x013] [0x00014] [0x00015]\n");

uspace/app/tester/stdio/stdio1.c

@@ -39 +39 @@
 {
         FILE *file;
-        const char *file_name = "/readme";
+        const char *file_name = "/textdemo";
         
         TPRINTF("Open file \"%s\"...", file_name);

uspace/app/trace/syscalls.c

@@ -75 +75 @@
     [SYS_UNREGISTER_IRQ] = { "unregister_irq",  2,      V_ERRNO },
 
-    [SYS_SYSINFO_GET_TAG] = { "sysinfo_get_tag",                2,      V_INTEGER },
+    [SYS_SYSINFO_GET_VAL_TYPE] = { "sysinfo_get_val_type",              2,      V_INTEGER },
     [SYS_SYSINFO_GET_VALUE] = { "sysinfo_get_value",            3,      V_ERRNO },
     [SYS_SYSINFO_GET_DATA_SIZE] = { "sysinfo_get_data_size",    3,      V_ERRNO },