Changeset b910455 in mainline for uspace/app


Ignore:
Timestamp:
2011-04-07T09:46:11Z (15 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
6639ae1
Parents:
f6bffee (diff), 8e80d3f (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:
1 added
1 deleted
12 edited
1 moved

Legend:

Unmodified
Added
Removed

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

    rf6bffee rb910455  
    11/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
     2 * Copyright (c) 2011, Martin Sucha
    23 * All rights reserved.
    34 *
    … …  
    3536#include <str.h>
    3637#include <fcntl.h>
     38#include <io/console.h>
     39#include <io/color.h>
     40#include <io/style.h>
     41#include <io/keycode.h>
     42#include <errno.h>
     43#include <vfs/vfs.h>
     44#include <assert.h>
    3745
    3846#include "config.h"
    … …  
    4856
    4957static const char *cat_oops = "That option is not yet supported\n";
     58static const char *hexchars = "0123456789abcdef";
     59
     60static bool paging_enabled = false;
     61static size_t chars_remaining = 0;
     62static size_t lines_remaining = 0;
     63static sysarg_t console_cols = 0;
     64static sysarg_t console_rows = 0;
     65static bool should_quit = false;
    5066
    5167static struct option const long_options[] = {
    … …  
    5672        { "buffer", required_argument, 0, 'b' },
    5773        { "more", no_argument, 0, 'm' },
     74        { "hex", no_argument, 0, 'x' },
    5875        { 0, 0, 0, 0 }
    5976};
    … …  
    7592                "  -b, --buffer ##  Set the read buffer size to ##\n"
    7693                "  -m, --more       Pause after each screen full\n"
     94                "  -x, --hex        Print bytes as hex values\n"
    7795                "Currently, %s is under development, some options don't work.\n",
    7896                cmdname, cmdname);
    … …  
    82100}
    83101
    84 static unsigned int cat_file(const char *fname, size_t blen)
     102static void waitprompt()
     103{
     104        console_set_pos(fphone(stdout), 0, console_rows-1);
     105        console_set_color(fphone(stdout), COLOR_BLUE, COLOR_WHITE, 0);
     106        printf("ENTER/SPACE/PAGE DOWN - next page, "
     107               "ESC/Q - quit, C - continue unpaged");
     108        fflush(stdout);
     109        console_set_style(fphone(stdout), STYLE_NORMAL);
     110}
     111
     112static void waitkey()
     113{
     114        console_event_t ev;
     115       
     116        while (true) {
     117                if (!console_get_event(fphone(stdin), &ev)) {
     118                        return;
     119                }
     120                if (ev.type == KEY_PRESS) {
     121                        if (ev.key == KC_ESCAPE || ev.key == KC_Q) {
     122                                should_quit = true;
     123                                return;
     124                        }
     125                        if (ev.key == KC_C) {
     126                                paging_enabled = false;
     127                                return;
     128                        }
     129                        if (ev.key == KC_ENTER || ev.key == KC_SPACE ||
     130                            ev.key == KC_PAGE_DOWN) {
     131                                return;
     132                        }
     133                }
     134        }
     135        assert(false);
     136}
     137
     138static void newpage()
     139{
     140        console_clear(fphone(stdout));
     141        chars_remaining = console_cols;
     142        lines_remaining = console_rows-1;
     143}
     144
     145static void paged_char(wchar_t c)
     146{
     147        putchar(c);
     148        if (paging_enabled) {
     149                chars_remaining--;
     150                if (c == '\n' || chars_remaining == 0) {
     151                        chars_remaining = console_cols;
     152                        lines_remaining--;
     153                }
     154                if (lines_remaining == 0) {
     155                        fflush(stdout);
     156                        waitprompt();
     157                        waitkey();
     158                        newpage();
     159                }
     160        }
     161}
     162
     163static unsigned int cat_file(const char *fname, size_t blen, bool hex)
    85164{
    86165        int fd, bytes = 0, count = 0, reads = 0;
    87         off64_t total = 0;
    88166        char *buff = NULL;
     167        int i;
     168        size_t offset = 0;
    89169
    90170        fd = open(fname, O_RDONLY);
    … …  
    93173                return 1;
    94174        }
    95 
    96         total = lseek(fd, 0, SEEK_END);
    97         lseek(fd, 0, SEEK_SET);
    98175
    99176        if (NULL == (buff = (char *) malloc(blen + 1))) {
    … …  
    109186                        count += bytes;
    110187                        buff[bytes] = '\0';
    111                         printf("%s", buff);
     188                        offset = 0;
     189                        for (i = 0; i < bytes && !should_quit; i++) {
     190                                if (hex) {
     191                                        paged_char(hexchars[((uint8_t)buff[i])/16]);
     192                                        paged_char(hexchars[((uint8_t)buff[i])%16]);
     193                                }
     194                                else {
     195                                        wchar_t c = str_decode(buff, &offset, bytes);
     196                                        if (c == 0) {
     197                                                /* Reached end of string */
     198                                                break;
     199                                        }
     200                                        paged_char(c);
     201                                }
     202                               
     203                        }
    112204                        reads++;
    113205                }
    114         } while (bytes > 0);
     206        } while (bytes > 0 && !should_quit);
    115207
    116208        close(fd);
    … …  
    131223        unsigned int argc, i, ret = 0, buffer = 0;
    132224        int c, opt_ind;
     225        bool hex = false;
     226        bool more = false;
     227        sysarg_t rows, cols;
     228        int rc;
     229       
     230        /*
     231         * reset global state
     232         * TODO: move to structure?
     233         */
     234        paging_enabled = false;
     235        chars_remaining = 0;
     236        lines_remaining = 0;
     237        console_cols = 0;
     238        console_rows = 0;
     239        should_quit = false;
    133240
    134241        argc = cli_count_args(argv);
    135242
    136243        for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
    137                 c = getopt_long(argc, argv, "hvmH:t:b:", long_options, &opt_ind);
     244                c = getopt_long(argc, argv, "xhvmH:t:b:", long_options, &opt_ind);
    138245                switch (c) {
    139246                case 'h':
    … …  
    153260                        break;
    154261                case 'm':
    155                         printf("%s", cat_oops);
    156                         return CMD_FAILURE;
     262                        more = true;
     263                        break;
     264                case 'x':
     265                        hex = true;
     266                        break;
    157267                }
    158268        }
    … …  
    168278        if (buffer <= 0)
    169279                buffer = CAT_DEFAULT_BUFLEN;
    170 
    171         for (i = optind; argv[i] != NULL; i++)
    172                 ret += cat_file(argv[i], buffer);
     280       
     281        if (more) {
     282                rc = console_get_size(fphone(stdout), &cols, &rows);
     283                if (rc != EOK) {
     284                        printf("%s - cannot get console size\n", cmdname);
     285                        return CMD_FAILURE;
     286                }
     287                console_cols = cols;
     288                console_rows = rows;
     289                paging_enabled = true;
     290                newpage();
     291        }
     292
     293        for (i = optind; argv[i] != NULL && !should_quit; i++)
     294                ret += cat_file(argv[i], buffer, hex);
    173295
    174296        if (ret)

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

    rf6bffee rb910455  
    44/* Prototypes for the cat command, excluding entry points */
    55
    6 static unsigned int cat_file(const char *, size_t);
     6static unsigned int cat_file(const char *, size_t, bool);
    77
    88#endif /* CAT_H */

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

    rf6bffee rb910455  
    3838#include <dirent.h>
    3939#include <fcntl.h>
     40#include <getopt.h>
    4041#include <sys/types.h>
    4142#include <sys/stat.h>
    4243#include <str.h>
     44#include <sort.h>
    4345
    4446#include "errors.h"
    … …  
    4648#include "util.h"
    4749#include "entry.h"
    48 #include "ls.h"
    4950#include "cmds.h"
    5051
     52/* Various values that can be returned by ls_scope() */
     53#define LS_BOGUS 0
     54#define LS_FILE  1
     55#define LS_DIR   2
     56
     57/** Structure to represent a directory entry.
     58 *
     59 * Useful to keep together important information
     60 * for sorting directory entries.
     61 */
     62struct dir_elem_t {
     63        char *name;
     64        struct stat s;
     65};
     66
    5167static const char *cmdname = "ls";
    5268
    53 static void ls_scan_dir(const char *d, DIR *dirp)
    54 {
     69static struct option const long_options[] = {
     70        { "help", no_argument, 0, 'h' },
     71        { "unsort", no_argument, 0, 'u' },
     72        { 0, 0, 0, 0 }
     73};
     74
     75/** Print an entry.
     76 *
     77 * ls_print currently does nothing more than print the entry.
     78 * In the future, we will likely pass the absolute path, and
     79 * some sort of ls_options structure that controls how each
     80 * entry is printed and what is printed about it.
     81 *
     82 * Now we just print basic DOS style lists.
     83 *
     84 * @param de            Directory element.
     85 */
     86static void ls_print(struct dir_elem_t *de)
     87{
     88        if (de->s.is_file)
     89                printf("%-40s\t%llu\n", de->name, (long long) de->s.size);
     90        else if (de->s.is_directory)
     91                printf("%-40s\t<dir>\n", de->name);
     92        else
     93                printf("%-40s\n", de->name);
     94}
     95
     96
     97/** Compare 2 directory elements.
     98 *
     99 * It compares 2 elements of a directory : a file is considered
     100 * as bigger than a directory, and if they have the same type,
     101 * they are compared alphabetically.
     102 *
     103 * @param a             Pointer to the structure of the first element.
     104 * @param b             Pointer to the structure of the second element.
     105 * @param arg           Pointer for an other and optionnal argument.
     106 *
     107 * @return              -1 if a < b, 1 otherwise.
     108 */
     109static int ls_cmp(void *a, void *b, void *arg)
     110{
     111        struct dir_elem_t *da = a;
     112        struct dir_elem_t *db = b;
     113       
     114        if ((da->s.is_directory && db->s.is_file) ||
     115            ((da->s.is_directory == db->s.is_directory) &&
     116            str_cmp(da->name, db->name) < 0))
     117                return -1;
     118        else
     119                return 1;
     120}
     121
     122/** Scan a directory.
     123 *
     124 * Scan the content of a directory and print it.
     125 *
     126 * @param d             Name of the directory.
     127 * @param dirp  Directory stream.
     128 * @param sort  1 if the output must be sorted,
     129 *                              0 otherwise.
     130 */
     131static void ls_scan_dir(const char *d, DIR *dirp, int sort)
     132{
     133        int alloc_blocks = 20;
     134        int i;
     135        int nbdirs = 0;
     136        int rc;
     137        int len;
     138        char *buff;
     139        struct dir_elem_t *tmp;
     140        struct dir_elem_t *tosort;
    55141        struct dirent *dp;
    56         char *buff;
    57 
    58         if (! dirp)
     142       
     143        if (!dirp)
    59144                return;
    60145
    61         buff = (char *)malloc(PATH_MAX);
    62         if (NULL == buff) {
     146        buff = (char *) malloc(PATH_MAX);
     147        if (!buff) {
    63148                cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
    64149                return;
    65150        }
    66 
     151       
     152        tosort = (struct dir_elem_t *) malloc(alloc_blocks * sizeof(*tosort));
     153        if (!tosort) {
     154                cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
     155                free(buff);
     156                return;
     157        }
     158       
    67159        while ((dp = readdir(dirp))) {
    68                 memset(buff, 0, sizeof(buff));
    69                 /* Don't worry if inserting a double slash, this will be fixed by
    70                  * absolutize() later with subsequent calls to open() or readdir() */
    71                 snprintf(buff, PATH_MAX - 1, "%s/%s", d, dp->d_name);
    72                 ls_print(dp->d_name, buff);
    73         }
    74 
     160                if (nbdirs + 1 > alloc_blocks) {
     161                        alloc_blocks += alloc_blocks;
     162                       
     163                        tmp = (struct dir_elem_t *) realloc(tosort,
     164                            alloc_blocks * sizeof(struct dir_elem_t));
     165                        if (!tmp) {
     166                                cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
     167                                goto out;
     168                        }
     169                        tosort = tmp;
     170                }
     171               
     172                /* fill the name field */
     173                tosort[nbdirs].name = (char *) malloc(str_length(dp->d_name) + 1);
     174                if (!tosort[nbdirs].name) {
     175                        cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
     176                        goto out;
     177                }
     178               
     179                str_cpy(tosort[nbdirs].name, str_length(dp->d_name) + 1, dp->d_name);
     180                len = snprintf(buff, PATH_MAX - 1, "%s/%s", d, tosort[nbdirs].name);
     181                buff[len] = '\0';
     182
     183                rc = stat(buff, &tosort[nbdirs++].s);
     184                if (rc != 0) {
     185                        printf("ls: skipping bogus node %s\n", buff);
     186                        printf("rc=%d\n", rc);
     187                        goto out;
     188                }
     189        }
     190       
     191        if (sort) {
     192                if (!qsort(&tosort[0], nbdirs, sizeof(struct dir_elem_t),
     193                    ls_cmp, NULL)) {
     194                        printf("Sorting error.\n");
     195                }
     196        }
     197       
     198        for (i = 0; i < nbdirs; i++)
     199                ls_print(&tosort[i]);
     200       
     201out:
     202        for(i = 0; i < nbdirs; i++)
     203                free(tosort[i].name);
     204        free(tosort);
    75205        free(buff);
    76 
    77         return;
    78 }
    79 
    80 /* ls_print currently does nothing more than print the entry.
    81  * in the future, we will likely pass the absolute path, and
    82  * some sort of ls_options structure that controls how each
    83  * entry is printed and what is printed about it.
    84  *
    85  * Now we just print basic DOS style lists */
    86 
    87 static void ls_print(const char *name, const char *pathname)
    88 {
    89         struct stat s;
    90         int rc;
    91 
    92         rc = stat(pathname, &s);
    93         if (rc != 0) {
    94                 /* Odd chance it was deleted from the time readdir() found it */
    95                 printf("ls: skipping bogus node %s\n", pathname);
    96                 printf("rc=%d\n", rc);
    97                 return;
    98         }
    99        
    100         if (s.is_file)
    101                 printf("%-40s\t%llu\n", name, (long long) s.size);
    102         else if (s.is_directory)
    103                 printf("%-40s\t<dir>\n", name);
    104         else
    105                 printf("%-40s\n", name);
    106 
    107         return;
    108206}
    109207
    … …  
    114212        } else {
    115213                help_cmd_ls(HELP_SHORT);
    116                 printf("  `%s' [path], if no path is given the current "
    117                                 "working directory is used.\n", cmdname);
     214                printf(
     215                "Usage:  %s [options] [path]\n"
     216                "If not path is given, the current working directory is used.\n"
     217                "Options:\n"
     218                "  -h, --help       A short option summary\n"
     219                "  -u, --unsort     Do not sort directory entries\n",
     220                cmdname);
    118221        }
    119222
    … …  
    124227{
    125228        unsigned int argc;
    126         struct stat s;
    127         char *buff;
     229        struct dir_elem_t de;
    128230        DIR *dirp;
     231        int c, opt_ind;
     232        int sort = 1;
    129233
    130234        argc = cli_count_args(argv);
    131 
    132         buff = (char *) malloc(PATH_MAX);
    133         if (NULL == buff) {
     235       
     236        for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
     237                c = getopt_long(argc, argv, "hu", long_options, &opt_ind);
     238                switch (c) {
     239                case 'h':
     240                        help_cmd_ls(HELP_LONG);
     241                        return CMD_SUCCESS;
     242                case 'u':
     243                        sort = 0;
     244                        break;
     245                }
     246        }
     247       
     248        argc -= optind;
     249       
     250        de.name = (char *) malloc(PATH_MAX);
     251        if (!de.name) {
    134252                cli_error(CL_ENOMEM, "%s: ", cmdname);
    135253                return CMD_FAILURE;
    136254        }
    137         memset(buff, 0, sizeof(buff));
    138 
    139         if (argc == 1)
    140                 getcwd(buff, PATH_MAX);
     255        memset(de.name, 0, sizeof(PATH_MAX));
     256       
     257        if (argc == 0)
     258                getcwd(de.name, PATH_MAX);
    141259        else
    142                 str_cpy(buff, PATH_MAX, argv[1]);
    143 
    144         if (stat(buff, &s)) {
    145                 cli_error(CL_ENOENT, buff);
    146                 free(buff);
     260                str_cpy(de.name, PATH_MAX, argv[optind]);
     261       
     262        if (stat(de.name, &de.s)) {
     263                cli_error(CL_ENOENT, de.name);
     264                free(de.name);
    147265                return CMD_FAILURE;
    148266        }
    149267
    150         if (s.is_file) {
    151                 ls_print(buff, buff);
     268        if (de.s.is_file) {
     269                ls_print(&de);
    152270        } else {
    153                 dirp = opendir(buff);
     271                dirp = opendir(de.name);
    154272                if (!dirp) {
    155273                        /* May have been deleted between scoping it and opening it */
    156                         cli_error(CL_EFAIL, "Could not stat %s", buff);
    157                         free(buff);
     274                        cli_error(CL_EFAIL, "Could not stat %s", de.name);
     275                        free(de.name);
    158276                        return CMD_FAILURE;
    159277                }
    160                 ls_scan_dir(buff, dirp);
     278                ls_scan_dir(de.name, dirp, sort);
    161279                closedir(dirp);
    162280        }
    163281
    164         free(buff);
     282        free(de.name);
    165283
    166284        return CMD_SUCCESS;

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

    rf6bffee rb910455  
    101101}
    102102
     103static unsigned int rm_recursive_not_empty_dirs(const char *path)
     104{
     105        DIR *dirp;
     106        struct dirent *dp;
     107        char buff[PATH_MAX];
     108        unsigned int scope;
     109        unsigned int ret = 0;
     110
     111        dirp = opendir(path);
     112        if (!dirp) {
     113                /* May have been deleted between scoping it and opening it */
     114                cli_error(CL_EFAIL, "Could not open %s", path);
     115                return ret;
     116        }
     117
     118        memset(buff, 0, sizeof(buff));
     119        while ((dp = readdir(dirp))) {
     120                snprintf(buff, PATH_MAX - 1, "%s/%s", path, dp->d_name);
     121                scope = rm_scope(buff);
     122                switch (scope) {
     123                case RM_BOGUS:
     124                        break;
     125                case RM_FILE:
     126                        ret += rm_single(buff);
     127                        break;
     128                case RM_DIR:
     129                        ret += rm_recursive(buff);
     130                        break;
     131                }
     132        }
     133       
     134        return ret;
     135}
     136
    103137static unsigned int rm_recursive(const char *path)
    104138{
    105139        int rc;
     140        unsigned int ret = 0;
    106141
    107142        /* First see if it will just go away */
    … …  
    111146
    112147        /* Its not empty, recursively scan it */
    113         cli_error(CL_ENOTSUP,
    114                 "Can not remove %s, directory not empty", path);
    115         return 1;
     148        ret = rm_recursive_not_empty_dirs(path);
     149
     150        /* Delete directory */
     151        rc = rmdir(path);
     152        if (rc == 0)
     153                return ret;
     154
     155        cli_error(CL_ENOTSUP, "Can not remove %s", path);
     156
     157        return ret + 1;
    116158}
    117159

  • uspace/app/init/init.c

    rf6bffee rb910455  
    272272        mount_tmpfs();
    273273       
     274#ifdef CONFIG_START_DEVMAN
     275        spawn("/srv/devman");
     276#endif
    274277        spawn("/srv/apic");
    275278        spawn("/srv/i8259");

  • uspace/app/sbi/src/run_expr.c

    rf6bffee rb910455  
    25292529        if (rc1 == EOK)
    25302530                rc2 = os_str_get_char(string->value, elem_index, &cval);
     2531        else
     2532                rc2 = EOK;
    25312533
    25322534        if (rc1 != EOK || rc2 != EOK) {

  • uspace/app/stats/stats.c

    rf6bffee rb910455  
    265265                /* Threads */
    266266                if ((off = arg_parse_short_long(argv[i], "-t", "--task=")) != -1) {
    267                         // TODO: Support for 64b range
     267                        /* TODO: Support for 64b range */
    268268                        int tmp;
    269269                        int ret = arg_parse_int(argc, argv, &i, &tmp, off);

  • uspace/app/tester/Makefile

    rf6bffee rb910455  
    4949        loop/loop1.c \
    5050        mm/malloc1.c \
     51        devs/devman1.c \
    5152        hw/misc/virtchar1.c \
    5253        hw/serial/serial1.c

  • uspace/app/tester/devs/devman1.c

    rf6bffee rb910455  
    11/*
    2  * Copyright (c) 2005 Sergey Bondari
     2 * Copyright (c) 2011 Vojtech Horky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup arm32
     29/** @addtogroup tester
     30 * @brief Test devman service.
    3031 * @{
    3132 */
    32 /** @file
    33  *  @brief Memory manipulating functions declarations.
     33/**
     34 * @file
    3435 */
    3536
    36 #ifndef KERN_arm32_MEMSTR_H_
    37 #define KERN_arm32_MEMSTR_H_
     37#include <inttypes.h>
     38#include <errno.h>
     39#include <str_error.h>
     40#include <sys/types.h>
     41#include <async.h>
     42#include <devman.h>
     43#include <str.h>
     44#include <vfs/vfs.h>
     45#include <sys/stat.h>
     46#include <fcntl.h>
     47#include "../tester.h"
    3848
    39 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
     49#define DEVICE_PATH_NORMAL "/virt/null/a"
     50#define DEVICE_CLASS "virt-null"
     51#define DEVICE_CLASS_NAME "1"
     52#define DEVICE_PATH_CLASSES DEVICE_CLASS "/" DEVICE_CLASS_NAME
    4053
    41 extern void memsetw(void *, size_t, uint16_t);
    42 extern void memsetb(void *, size_t, uint8_t);
     54const char *test_devman1(void)
     55{
     56        devman_handle_t handle_primary;
     57        devman_handle_t handle_class;
     58       
     59        int rc;
     60       
     61        TPRINTF("Asking for handle of `%s'...\n", DEVICE_PATH_NORMAL);
     62        rc = devman_device_get_handle(DEVICE_PATH_NORMAL, &handle_primary, 0);
     63        if (rc != EOK) {
     64                TPRINTF(" ...failed: %s.\n", str_error(rc));
     65                if (rc == ENOENT) {
     66                        TPRINTF("Have you compiled the test drivers?\n");
     67                }
     68                return "Failed getting device handle";
     69        }
    4370
    44 #endif
     71        TPRINTF("Asking for handle of `%s' by class..\n", DEVICE_PATH_CLASSES);
     72        rc = devman_device_get_handle_by_class(DEVICE_CLASS, DEVICE_CLASS_NAME,
     73            &handle_class, 0);
     74        if (rc != EOK) {
     75                TPRINTF(" ...failed: %s.\n", str_error(rc));
     76                return "Failed getting device class handle";
     77        }
     78
     79        TPRINTF("Received handles %" PRIun " and %" PRIun ".\n",
     80            handle_primary, handle_class);
     81        if (handle_primary != handle_class) {
     82                return "Retrieved different handles for the same device";
     83        }
     84
     85        return NULL;
     86}
    4587
    4688/** @}

  • uspace/app/tester/fault/fault2.c

    rf6bffee rb910455  
    2929
    3030#include "../tester.h"
     31#include <stdio.h>
    3132
    3233typedef int __attribute__((may_alias)) aliasing_int;
    … …  
    3839       
    3940        var1 = *((aliasing_int *) (((char *) (&var)) + 1));
     41        printf("Read %d\n", var1);
    4042       
    4143        return "Survived unaligned read";

  • uspace/app/tester/tester.c

    rf6bffee rb910455  
    6464#include "hw/serial/serial1.def"
    6565#include "hw/misc/virtchar1.def"
     66#include "devs/devman1.def"
    6667        {NULL, NULL, NULL, false}
    6768};

  • uspace/app/tester/tester.h

    rf6bffee rb910455  
    8080extern const char *test_serial1(void);
    8181extern const char *test_virtchar1(void);
     82extern const char *test_devman1(void);
    8283
    8384extern test_t tests[];

  • uspace/app/trace/trace.c

    rf6bffee rb910455  
    5353#include <libc.h>
    5454
    55 // Temporary: service and method names
     55/* Temporary: service and method names */
    5656#include "proto.h"
    5757#include <ipc/services.h>
    … …  
    872872static display_mask_t parse_display_mask(const char *text)
    873873{
    874         display_mask_t dm;
     874        display_mask_t dm = 0;
    875875        const char *c = text;
    876876       
Note: See TracChangeset for help on using the changeset viewer.