Changeset 3317724 in mainline for uspace


Ignore:
Timestamp:
2011-03-29T19:32:53Z (15 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
eea1dd5
Parents:
2cf95e8 (diff), 93ebe4e (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
Files:
1 deleted
34 edited

Legend:

Unmodified
Added
Removed

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

    r2cf95e8 r3317724  
    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;
    87166        off64_t total = 0;
    88167        char *buff = NULL;
     168        int i;
     169        size_t offset = 0;
    89170
    90171        fd = open(fname, O_RDONLY);
    … …  
    109190                        count += bytes;
    110191                        buff[bytes] = '\0';
    111                         printf("%s", buff);
     192                        offset = 0;
     193                        for (i = 0; i < bytes && !should_quit; i++) {
     194                                if (hex) {
     195                                        paged_char(hexchars[((uint8_t)buff[i])/16]);
     196                                        paged_char(hexchars[((uint8_t)buff[i])%16]);
     197                                }
     198                                else {
     199                                        wchar_t c = str_decode(buff, &offset, bytes);
     200                                        if (c == 0) {
     201                                                // reached end of string
     202                                                break;
     203                                        }
     204                                        paged_char(c);
     205                                }
     206                               
     207                        }
    112208                        reads++;
    113209                }
    114         } while (bytes > 0);
     210        } while (bytes > 0 && !should_quit);
    115211
    116212        close(fd);
    … …  
    131227        unsigned int argc, i, ret = 0, buffer = 0;
    132228        int c, opt_ind;
     229        bool hex = false;
     230        bool more = false;
     231        sysarg_t rows, cols;
     232        int rc;
     233       
     234        // reset global state
     235        // TODO: move to structure?
     236        paging_enabled = false;
     237        chars_remaining = 0;
     238        lines_remaining = 0;
     239        console_cols = 0;
     240        console_rows = 0;
     241        should_quit = false;
    133242
    134243        argc = cli_count_args(argv);
    135244
    136245        for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
    137                 c = getopt_long(argc, argv, "hvmH:t:b:", long_options, &opt_ind);
     246                c = getopt_long(argc, argv, "xhvmH:t:b:", long_options, &opt_ind);
    138247                switch (c) {
    139248                case 'h':
    … …  
    144253                        return CMD_SUCCESS;
    145254                case 'H':
    146                         printf(cat_oops);
     255                        printf("%s", cat_oops);
    147256                        return CMD_FAILURE;
    148257                case 't':
    149                         printf(cat_oops);
     258                        printf("%s", cat_oops);
    150259                        return CMD_FAILURE;
    151260                case 'b':
    152                         printf(cat_oops);
     261                        printf("%s", cat_oops);
    153262                        break;
    154263                case 'm':
    155                         printf(cat_oops);
    156                         return CMD_FAILURE;
     264                        more = true;
     265                        break;
     266                case 'x':
     267                        hex = true;
     268                        break;
    157269                }
    158270        }
    … …  
    168280        if (buffer <= 0)
    169281                buffer = CAT_DEFAULT_BUFLEN;
    170 
    171         for (i = optind; argv[i] != NULL; i++)
    172                 ret += cat_file(argv[i], buffer);
     282       
     283        if (more) {
     284                rc = console_get_size(fphone(stdout), &cols, &rows);
     285                if (rc != EOK) {
     286                        printf("%s - cannot get console size\n", cmdname);
     287                        return CMD_FAILURE;
     288                }
     289                console_cols = cols;
     290                console_rows = rows;
     291                paging_enabled = true;
     292                newpage();
     293        }
     294
     295        for (i = optind; argv[i] != NULL && !should_quit; i++)
     296                ret += cat_file(argv[i], buffer, hex);
    173297
    174298        if (ret)

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

    r2cf95e8 r3317724  
    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/cp/cp.c

    r2cf95e8 r3317724  
    108108        for (;;) {
    109109                ssize_t res;
     110                size_t written = 0;
    110111
    111112                bytes = read(fd1, buff, blen);
    … …  
    120121                         * returned less data than requested.
    121122                         */
    122                         bytes = write(fd2, buff, res);
     123                        bytes = write(fd2, buff + written, res);
    123124                        if (bytes < 0)
    124125                                goto err;
     126                        written += bytes;
    125127                        res -= bytes;
    126128                } while (res > 0);

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

    r2cf95e8 r3317724  
    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
    … …  
    227269                }
    228270                memset(buff, 0, sizeof(buff));
    229                 snprintf(buff, len, argv[i]);
     271                snprintf(buff, len, "%s", argv[i]);
    230272
    231273                scope = rm_scope(buff);

  • uspace/lib/c/generic/net/packet.c

    r2cf95e8 r3317724  
    190190                }
    191191        }
    192         gpm_destroy(&pm_globals.packet_map);
     192        gpm_destroy(&pm_globals.packet_map, free);
    193193        /* leave locked */
    194194}

  • uspace/lib/c/generic/net/socket_client.c

    r2cf95e8 r3317724  
    749749        dyn_fifo_destroy(&socket->received);
    750750        dyn_fifo_destroy(&socket->accepted);
    751         sockets_exclude(socket_get_sockets(), socket->socket_id);
     751        sockets_exclude(socket_get_sockets(), socket->socket_id, free);
    752752}
    753753

  • uspace/lib/c/include/adt/generic_char_map.h

    r2cf95e8 r3317724  
    4747#define GENERIC_CHAR_MAP_MAGIC_VALUE    0x12345622
    4848
     49/** Generic destructor function pointer. */
     50#define DTOR_T(identifier) \
     51        void (*identifier)(const void *)
     52
    4953/** Character string to generic type map declaration.
    5054 *  @param[in] name     Name of the map.
    … …  
    6468        int name##_add(name##_t *, const uint8_t *, const size_t, type *); \
    6569        int name##_count(name##_t *); \
    66         void name##_destroy(name##_t *); \
    67         void name##_exclude(name##_t *, const uint8_t *, const size_t); \
     70        void name##_destroy(name##_t *, DTOR_T()); \
     71        void name##_exclude(name##_t *, const uint8_t *, const size_t, DTOR_T()); \
    6872        type *name##_find(name##_t *, const uint8_t *, const size_t); \
    6973        int name##_initialize(name##_t *); \
    … …  
    8488             type *value) \
    8589        { \
    86                 int rc; \
    8790                int index; \
    8891                if (!name##_is_valid(map)) \
    … …  
    9194                if (index < 0) \
    9295                        return index; \
    93                 rc = char_map_add(&map->names, name, length, index); \
    94                 if (rc != EOK) { \
    95                         name##_items_exclude_index(&map->values, index); \
    96                         return rc; \
    97                 } \
    98                 return EOK; \
     96                return char_map_add(&map->names, name, length, index); \
    9997        } \
    10098        \
    … …  
    105103        } \
    106104        \
    107         void name##_destroy(name##_t *map) \
     105        void name##_destroy(name##_t *map, DTOR_T(dtor)) \
    108106        { \
    109107                if (name##_is_valid(map)) { \
    110108                        char_map_destroy(&map->names); \
    111                         name##_items_destroy(&map->values); \
     109                        name##_items_destroy(&map->values, dtor); \
    112110                } \
    113111        } \
    114112        \
    115113        void name##_exclude(name##_t *map, const uint8_t *name, \
    116             const size_t length) \
     114            const size_t length, DTOR_T(dtor)) \
    117115        { \
    118116                if (name##_is_valid(map)) { \
    … …  
    121119                        if (index != CHAR_MAP_NULL) \
    122120                                name##_items_exclude_index(&map->values, \
    123                                      index); \
     121                                     index, dtor); \
    124122                } \
    125123        } \

  • uspace/lib/c/include/adt/generic_field.h

    r2cf95e8 r3317724  
    4646#define GENERIC_FIELD_MAGIC_VALUE               0x55667788
    4747
     48/** Generic destructor function pointer. */
     49#define DTOR_T(identifier) \
     50        void (*identifier)(const void *)
     51
    4852/** Generic type field declaration.
    4953 *
    … …  
    6367        int name##_add(name##_t *, type *); \
    6468        int name##_count(name##_t *); \
    65         void name##_destroy(name##_t *); \
    66         void name##_exclude_index(name##_t *, int); \
     69        void name##_destroy(name##_t *, DTOR_T()); \
     70        void name##_exclude_index(name##_t *, int, DTOR_T()); \
    6771        type **name##_get_field(name##_t *); \
    6872        type *name##_get_index(name##_t *, int); \
    … …  
    103107        } \
    104108        \
    105         void name##_destroy(name##_t *field) \
     109        void name##_destroy(name##_t *field, DTOR_T(dtor)) \
    106110        { \
    107111                if (name##_is_valid(field)) { \
    108112                        int index; \
    109113                        field->magic = 0; \
    110                         for (index = 0; index < field->next; index++) { \
    111                                 if (field->items[index]) \
    112                                         free(field->items[index]); \
     114                        if (dtor) { \
     115                                for (index = 0; index < field->next; index++) { \
     116                                        if (field->items[index]) \
     117                                                dtor(field->items[index]); \
     118                                } \
    113119                        } \
    114120                        free(field->items); \
    … …  
    116122        } \
    117123         \
    118         void name##_exclude_index(name##_t *field, int index) \
     124        void name##_exclude_index(name##_t *field, int index, DTOR_T(dtor)) \
    119125        { \
    120126                if (name##_is_valid(field) && (index >= 0) && \
    121127                    (index < field->next) && (field->items[index])) { \
    122                         free(field->items[index]); \
     128                        if (dtor) \
     129                                dtor(field->items[index]); \
    123130                        field->items[index] = NULL; \
    124131                } \

  • uspace/lib/c/include/adt/int_map.h

    r2cf95e8 r3317724  
    4949#define INT_MAP_ITEM_MAGIC_VALUE        0x55667788
    5050
     51/** Generic destructor function pointer. */
     52#define DTOR_T(identifier) \
     53        void (*identifier)(const void *)
     54
    5155/** Integer to generic type map declaration.
    5256 *
    … …  
    7276        \
    7377        int name##_add(name##_t *, int, type *); \
    74         void name##_clear(name##_t *); \
     78        void name##_clear(name##_t *, DTOR_T()); \
    7579        int name##_count(name##_t *); \
    76         void name##_destroy(name##_t *); \
    77         void name##_exclude(name##_t *, int); \
    78         void name##_exclude_index(name##_t *, int); \
     80        void name##_destroy(name##_t *, DTOR_T()); \
     81        void name##_exclude(name##_t *, int, DTOR_T()); \
     82        void name##_exclude_index(name##_t *, int, DTOR_T()); \
    7983        type *name##_find(name##_t *, int); \
    8084        int name##_update(name##_t *, int, int); \
    … …  
    8286        int name##_initialize(name##_t *); \
    8387        int name##_is_valid(name##_t *); \
    84         void name##_item_destroy(name##_item_t *); \
     88        void name##_item_destroy(name##_item_t *, DTOR_T()); \
    8589        int name##_item_is_valid(name##_item_t *);
    8690
    … …  
    115119        } \
    116120        \
    117         void name##_clear(name##_t *map) \
     121        void name##_clear(name##_t *map, DTOR_T(dtor)) \
    118122        { \
    119123                if (name##_is_valid(map)) { \
    … …  
    122126                                if (name##_item_is_valid(&map->items[index])) { \
    123127                                        name##_item_destroy( \
    124                                             &map->items[index]); \
     128                                            &map->items[index], dtor); \
    125129                                } \
    126130                        } \
    … …  
    135139        } \
    136140        \
    137         void name##_destroy(name##_t *map) \
     141        void name##_destroy(name##_t *map, DTOR_T(dtor)) \
    138142        { \
    139143                if (name##_is_valid(map)) { \
    … …  
    143147                                if (name##_item_is_valid(&map->items[index])) { \
    144148                                        name##_item_destroy( \
    145                                             &map->items[index]); \
     149                                            &map->items[index], dtor); \
    146150                                } \
    147151                        } \
    … …  
    150154        } \
    151155        \
    152         void name##_exclude(name##_t *map, int key) \
     156        void name##_exclude(name##_t *map, int key, DTOR_T(dtor)) \
    153157        { \
    154158                if (name##_is_valid(map)) { \
    … …  
    158162                                    (map->items[index].key == key)) { \
    159163                                        name##_item_destroy( \
    160                                             &map->items[index]); \
    161                                 } \
    162                         } \
    163                 } \
    164         } \
    165         \
    166         void name##_exclude_index(name##_t *map, int index) \
     164                                            &map->items[index], dtor); \
     165                                } \
     166                        } \
     167                } \
     168        } \
     169        \
     170        void name##_exclude_index(name##_t *map, int index, DTOR_T(dtor)) \
    167171        { \
    168172                if (name##_is_valid(map) && (index >= 0) && \
    169173                    (index < map->next) && \
    170174                    name##_item_is_valid(&map->items[index])) { \
    171                         name##_item_destroy(&map->items[index]); \
     175                        name##_item_destroy(&map->items[index], dtor); \
    172176                } \
    173177        } \
    … …  
    236240        } \
    237241        \
    238         void name##_item_destroy(name##_item_t *item) \
     242        void name##_item_destroy(name##_item_t *item, DTOR_T(dtor)) \
    239243        { \
    240244                if (name##_item_is_valid(item)) { \
    241245                        item->magic = 0; \
    242246                        if (item->value) { \
    243                                 free(item->value); \
     247                                if (dtor) \
     248                                        dtor(item->value); \
    244249                                item->value = NULL; \
    245250                        } \

  • uspace/lib/c/include/ipc/services.h

    r2cf95e8 r3317724  
    4747        SERVICE_DEVMAP,
    4848        SERVICE_DEVMAN,
    49         SERVICE_FHC,
    50         SERVICE_OBIO,
    51         SERVICE_APIC,
    52         SERVICE_I8259,
     49        SERVICE_IRC,
    5350        SERVICE_CLIPBOARD,
    5451        SERVICE_NETWORKING,

  • uspace/lib/fs/libfs.c

    r2cf95e8 r3317724  
    391391                                                if (lflag & L_CREATE)
    392392                                                        (void) ops->destroy(fn);
     393                                                else
     394                                                        (void) ops->node_put(fn);
    393395                                                async_answer_0(rid, rc);
    394396                                        } else {
    … …  
    473475                                        if (lflag & L_CREATE)
    474476                                                (void) ops->destroy(fn);
     477                                        else
     478                                                (void) ops->node_put(fn);
    475479                                        async_answer_0(rid, rc);
    476480                                } else {

  • uspace/lib/net/tl/socket_core.c

    r2cf95e8 r3317724  
    107107                socket_release(socket);
    108108
    109         socket_cores_exclude(local_sockets, socket->socket_id);
     109        socket_cores_exclude(local_sockets, socket->socket_id, free);
    110110}
    111111
    … …  
    230230
    231231fail:
    232         socket_port_map_destroy(&socket_port->map);
     232        socket_port_map_destroy(&socket_port->map, free);
    233233        free(socket_port);
    234234        return rc;
    … …  
    649649                        if (socket_port->count <= 0) {
    650650                                // destroy the map
    651                                 socket_port_map_destroy(&socket_port->map);
     651                                socket_port_map_destroy(&socket_port->map, free);
    652652                                // release the port
    653653                                socket_ports_exclude(global_sockets,
    654                                     socket->port);
     654                                    socket->port, free);
    655655                        } else {
    656656                                // remove
    657657                                socket_port_map_exclude(&socket_port->map,
    658                                     socket->key, socket->key_length);
     658                                    socket->key, socket->key_length, free);
    659659                        }
    660660                }

  • uspace/lib/net/tl/tl_common.c

    r2cf95e8 r3317724  
    182182                        else
    183183                                packet_dimensions_exclude(packet_dimensions,
    184                                     DEVICE_INVALID_ID);
     184                                    DEVICE_INVALID_ID, free);
    185185                }
    186186        }

  • uspace/srv/devman/devman.c

    r2cf95e8 r3317724  
    266266        }
    267267       
    268         if (read(fd, buf, len) <= 0) {
     268        ssize_t read_bytes = safe_read(fd, buf, len);
     269        if (read_bytes <= 0) {
    269270                printf(NAME ": unable to read file '%s'.\n", conf_path);
    270271                goto cleanup;
    271272        }
    272         buf[len] = 0;
     273        buf[read_bytes] = 0;
    273274       
    274275        suc = parse_match_ids(buf, ids);
    … …  
    11231124fun_node_t *find_fun_node_by_path(dev_tree_t *tree, char *path)
    11241125{
     1126        assert(path != NULL);
     1127
     1128        bool is_absolute = path[0] == '/';
     1129        if (!is_absolute) {
     1130                return NULL;
     1131        }
     1132
    11251133        fibril_rwlock_read_lock(&tree->rwlock);
    11261134       
    … …  
    11321140        char *rel_path = path;
    11331141        char *next_path_elem = NULL;
    1134         bool cont = (rel_path[0] == '/');
     1142        bool cont = true;
    11351143       
    11361144        while (cont && fun != NULL) {

  • uspace/srv/devman/main.c

    r2cf95e8 r3317724  
    477477                dev = fun->dev;
    478478
    479         if (fun == NULL && dev == NULL) {
     479        /*
     480         * For a valid function to connect to we need a device. The root
     481         * function, for example, has no device and cannot be connected to.
     482         * This means @c dev needs to be valid regardless whether we are
     483         * connecting to a device or to a function.
     484         */
     485        if (dev == NULL) {
    480486                printf(NAME ": devman_forward error - no device or function with "
    481487                    "handle %" PRIun " was found.\n", handle);

  • uspace/srv/devman/util.c

    r2cf95e8 r3317724  
    111111}
    112112
     113ssize_t safe_read(int fd, void *buffer, size_t size)
     114{
     115        if (size == 0) {
     116                return 0;
     117        }
     118
     119        uint8_t *buf_ptr = (uint8_t *) buffer;
     120
     121        size_t total_read = 0;
     122        while (total_read < size) {
     123                ssize_t bytes_read = read(fd, buf_ptr, size - total_read);
     124                if (bytes_read < 0) {
     125                        /* Error. */
     126                        return bytes_read;
     127                } else if (bytes_read == 0) {
     128                        /* Possibly end of file. */
     129                        break;
     130                } else {
     131                        /* Read at least something. */
     132                        buf_ptr += bytes_read;
     133                        total_read += bytes_read;
     134                }
     135        }
     136
     137        return (ssize_t) total_read;
     138}
     139
    113140/** @}
    114141 */

  • uspace/srv/devman/util.h

    r2cf95e8 r3317724  
    4747extern void replace_char(char *, char, char);
    4848
     49extern ssize_t safe_read(int, void *, size_t);
     50
    4951#endif
    5052

  • uspace/srv/hid/kbd/Makefile

    r2cf95e8 r3317724  
    7878                SOURCES += \
    7979                        port/pl050.c \
    80                         ctl/pl050.c
     80                        ctl/pc.c
    8181        endif
    8282endif

  • uspace/srv/hid/kbd/generic/kbd.c

    r2cf95e8 r3317724  
    6767static unsigned lock_keys;
    6868
    69 int cir_service = 0;
    70 int cir_phone = -1;
     69bool irc_service = false;
     70int irc_phone = -1;
    7171
    7272#define NUM_LAYOUTS 3
    … …  
    216216        sysarg_t obio;
    217217       
    218         if ((sysinfo_get_value("kbd.cir.fhc", &fhc) == EOK) && (fhc))
    219                 cir_service = SERVICE_FHC;
    220         else if ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio))
    221                 cir_service = SERVICE_OBIO;
    222        
    223         if (cir_service) {
    224                 while (cir_phone < 0)
    225                         cir_phone = service_connect_blocking(cir_service, 0, 0);
     218        if (((sysinfo_get_value("kbd.cir.fhc", &fhc) == EOK) && (fhc))
     219            || ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio)))
     220                irc_service = true;
     221       
     222        if (irc_service) {
     223                while (irc_phone < 0)
     224                        irc_phone = service_connect_blocking(SERVICE_IRC, 0, 0);
    226225        }
    227226       

  • uspace/srv/hid/kbd/include/kbd.h

    r2cf95e8 r3317724  
    3838#define KBD_KBD_H_
    3939
    40 extern int cir_service;
    41 extern int cir_phone;
     40#include <bool.h>
     41
     42extern bool irc_service;
     43extern int irc_phone;
    4244
    4345extern void kbd_push_scancode(int);

  • uspace/srv/hid/kbd/port/ns16550.c

    r2cf95e8 r3317724  
    120120        kbd_push_scancode(scan_code);
    121121       
    122         if (cir_service)
    123                 async_msg_1(cir_phone, IRC_CLEAR_INTERRUPT,
     122        if (irc_service)
     123                async_msg_1(irc_phone, IRC_CLEAR_INTERRUPT,
    124124                    IPC_GET_IMETHOD(*call));
    125125}

  • uspace/srv/hid/kbd/port/z8530.c

    r2cf95e8 r3317724  
    108108        kbd_push_scancode(scan_code);
    109109       
    110         if (cir_service)
    111                 async_msg_1(cir_phone, IRC_CLEAR_INTERRUPT,
     110        if (irc_service)
     111                async_msg_1(irc_phone, IRC_CLEAR_INTERRUPT,
    112112                    IPC_GET_IMETHOD(*call));
    113113}

  • uspace/srv/hw/irc/apic/apic.c

    r2cf95e8 r3317724  
    107107       
    108108        async_set_client_connection(apic_connection);
    109         service_register(SERVICE_APIC);
     109        service_register(SERVICE_IRC);
    110110       
    111111        return true;

  • uspace/srv/hw/irc/fhc/fhc.c

    r2cf95e8 r3317724  
    136136       
    137137        async_set_client_connection(fhc_connection);
    138         service_register(SERVICE_FHC);
     138        service_register(SERVICE_IRC);
    139139       
    140140        return true;

  • uspace/srv/hw/irc/i8259/i8259.c

    r2cf95e8 r3317724  
    149149       
    150150        async_set_client_connection(i8259_connection);
    151         service_register(SERVICE_I8259);
     151        service_register(SERVICE_IRC);
    152152       
    153153        return true;

  • uspace/srv/hw/irc/obio/obio.c

    r2cf95e8 r3317724  
    137137       
    138138        async_set_client_connection(obio_connection);
    139         service_register(SERVICE_OBIO);
     139        service_register(SERVICE_IRC);
    140140       
    141141        return true;

  • uspace/srv/hw/netif/ne2000/ne2000.c

    r2cf95e8 r3317724  
    7575#define IRQ_GET_TSR(call)  ((int) IPC_GET_ARG3(call))
    7676
    77 static int irc_service = 0;
     77static bool irc_service = false;
    7878static int irc_phone = -1;
    7979
    … …  
    383383        sysarg_t i8259;
    384384       
    385         if ((sysinfo_get_value("apic", &apic) == EOK) && (apic))
    386                 irc_service = SERVICE_APIC;
    387         else if ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259))
    388                 irc_service = SERVICE_I8259;
     385        if (((sysinfo_get_value("apic", &apic) == EOK) && (apic))
     386            || ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259)))
     387                irc_service = true;
    389388       
    390389        if (irc_service) {
    391390                while (irc_phone < 0)
    392                         irc_phone = service_connect_blocking(irc_service, 0, 0);
     391                        irc_phone = service_connect_blocking(SERVICE_IRC, 0, 0);
    393392        }
    394393       

  • uspace/srv/net/il/arp/arp.c

    r2cf95e8 r3317724  
    157157                       
    158158                        arp_clear_addr(&proto->addresses);
    159                         arp_addr_destroy(&proto->addresses);
    160                 }
    161         }
    162        
    163         arp_protos_clear(&device->protos);
     159                        arp_addr_destroy(&proto->addresses, free);
     160                }
     161        }
     162       
     163        arp_protos_clear(&device->protos, free);
    164164}
    165165
    … …  
    184184        }
    185185       
    186         arp_cache_clear(&arp_globals.cache);
     186        arp_cache_clear(&arp_globals.cache, free);
    187187        fibril_mutex_unlock(&arp_globals.lock);
    188188       
    … …  
    212212                arp_clear_trans(trans);
    213213       
    214         arp_addr_exclude(&proto->addresses, address->value, address->length);
     214        arp_addr_exclude(&proto->addresses, address->value, address->length, free);
    215215       
    216216        fibril_mutex_unlock(&arp_globals.lock);
    … …  
    345345                            header->protocol_length, trans);
    346346                        if (rc != EOK) {
    347                                 /* The generic char map has already freed trans! */
     347                                free(trans);
    348348                                return rc;
    349349                        }
    … …  
    556556                if (index < 0) {
    557557                        fibril_mutex_unlock(&arp_globals.lock);
    558                         arp_protos_destroy(&device->protos);
     558                        arp_protos_destroy(&device->protos, free);
    559559                        free(device);
    560560                        return index;
    … …  
    569569                if (device->phone < 0) {
    570570                        fibril_mutex_unlock(&arp_globals.lock);
    571                         arp_protos_destroy(&device->protos);
     571                        arp_protos_destroy(&device->protos, free);
    572572                        free(device);
    573573                        return EREFUSED;
    … …  
    579579                if (rc != EOK) {
    580580                        fibril_mutex_unlock(&arp_globals.lock);
    581                         arp_protos_destroy(&device->protos);
     581                        arp_protos_destroy(&device->protos, free);
    582582                        free(device);
    583583                        return rc;
    … …  
    589589                if (rc != EOK) {
    590590                        fibril_mutex_unlock(&arp_globals.lock);
    591                         arp_protos_destroy(&device->protos);
     591                        arp_protos_destroy(&device->protos, free);
    592592                        free(device);
    593593                        return rc;
    … …  
    601601                        free(device->addr);
    602602                        free(device->addr_data);
    603                         arp_protos_destroy(&device->protos);
     603                        arp_protos_destroy(&device->protos, free);
    604604                        free(device);
    605605                        return rc;
    … …  
    614614                        free(device->broadcast_addr);
    615615                        free(device->broadcast_data);
    616                         arp_protos_destroy(&device->protos);
     616                        arp_protos_destroy(&device->protos, free);
    617617                        free(device);
    618618                        return rc;
    … …  
    746746                        arp_clear_trans(trans);
    747747                        arp_addr_exclude(&proto->addresses, target->value,
    748                             target->length);
     748                            target->length, free);
    749749                        return EAGAIN;
    750750                }
    … …  
    794794            trans);
    795795        if (rc != EOK) {
    796                 /* The generic char map has already freed trans! */
     796                free(trans);
    797797                return rc;
    798798        }
    … …  
    807807                arp_clear_trans(trans);
    808808                arp_addr_exclude(&proto->addresses, target->value,
    809                     target->length);
     809                    target->length, free);
    810810                return ENOENT;
    811811        }

  • uspace/srv/net/il/ip/ip.c

    r2cf95e8 r3317724  
    505505        if (rc != EOK) {
    506506                fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
    507                 ip_routes_destroy(&ip_netif->routes);
     507                ip_routes_destroy(&ip_netif->routes, free);
    508508                free(ip_netif);
    509509                return rc;

  • uspace/srv/net/net/net.c

    r2cf95e8 r3317724  
    289289        if (rc != EOK)
    290290                return rc;
     291       
    291292        rc = add_module(NULL, &net_globals.modules, (uint8_t *) NE2000_NAME,
    292293            (uint8_t *) NE2000_FILENAME, SERVICE_NE2000, 0, connect_to_service);
    293294        if (rc != EOK)
    294295                return rc;
     296       
    295297        rc = add_module(NULL, &net_globals.modules, (uint8_t *) ETHERNET_NAME,
    296298            (uint8_t *) ETHERNET_FILENAME, SERVICE_ETHERNET, 0, connect_to_service);
    297299        if (rc != EOK)
    298300                return rc;
     301       
    299302        rc = add_module(NULL, &net_globals.modules, (uint8_t *) NILDUMMY_NAME,
    300303            (uint8_t *) NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0, connect_to_service);
    … …  
    552555                rc = read_netif_configuration(conf_files[i], netif);
    553556                if (rc != EOK) {
    554                         measured_strings_destroy(&netif->configuration);
     557                        measured_strings_destroy(&netif->configuration, free);
    555558                        free(netif);
    556559                        return rc;
    … …  
    562565                if (!setting) {
    563566                        fprintf(stderr, "%s: Network interface name is missing\n", NAME);
    564                         measured_strings_destroy(&netif->configuration);
     567                        measured_strings_destroy(&netif->configuration, free);
    565568                        free(netif);
    566569                        return EINVAL;
    … …  
    571574                int index = netifs_add(&net_globals.netifs, netif->id, netif);
    572575                if (index < 0) {
    573                         measured_strings_destroy(&netif->configuration);
     576                        measured_strings_destroy(&netif->configuration, free);
    574577                        free(netif);
    575578                        return index;
    … …  
    583586                    index);
    584587                if (rc != EOK) {
    585                         measured_strings_destroy(&netif->configuration);
    586                         netifs_exclude_index(&net_globals.netifs, index);
     588                        measured_strings_destroy(&netif->configuration, free);
     589                        netifs_exclude_index(&net_globals.netifs, index, free);
    587590                        return rc;
    588591                }
    … …  
    590593                rc = start_device(netif);
    591594                if (rc != EOK) {
    592                         printf("%s: Error starting interface %s (%s)\n", NAME,
     595                        printf("%s: Ignoring failed interface %s (%s)\n", NAME,
    593596                            netif->name, str_error(rc));
    594                         measured_strings_destroy(&netif->configuration);
    595                         netifs_exclude_index(&net_globals.netifs, index);
    596                        
    597                         return rc;
     597                        measured_strings_destroy(&netif->configuration, free);
     598                        netifs_exclude_index(&net_globals.netifs, index, free);
     599                        continue;
    598600                }
    599601               

  • uspace/srv/net/nil/eth/eth.c

    r2cf95e8 r3317724  
    214214        if (rc != EOK) {
    215215                free(eth_globals.broadcast_addr);
    216                 eth_devices_destroy(&eth_globals.devices);
     216                eth_devices_destroy(&eth_globals.devices, free);
    217217        }
    218218out:

  • uspace/srv/net/tl/tcp/tcp.c

    r2cf95e8 r3317724  
    17071707                if (socket->port > 0) {
    17081708                        socket_ports_exclude(&tcp_globals.sockets,
    1709                             socket->port);
     1709                            socket->port, free);
    17101710                        socket->port = 0;
    17111711                }
    … …  
    24922492        rc = packet_dimensions_initialize(&tcp_globals.dimensions);
    24932493        if (rc != EOK) {
    2494                 socket_ports_destroy(&tcp_globals.sockets);
     2494                socket_ports_destroy(&tcp_globals.sockets, free);
    24952495                goto out;
    24962496        }

  • uspace/srv/net/tl/udp/udp.c

    r2cf95e8 r3317724  
    417417        rc = packet_dimensions_initialize(&udp_globals.dimensions);
    418418        if (rc != EOK) {
    419                 socket_ports_destroy(&udp_globals.sockets);
     419                socket_ports_destroy(&udp_globals.sockets, free);
    420420                fibril_rwlock_write_unlock(&udp_globals.lock);
    421421                return rc;
    … …  
    434434            &data);
    435435        if (rc != EOK) {
    436                 socket_ports_destroy(&udp_globals.sockets);
     436                socket_ports_destroy(&udp_globals.sockets, free);
    437437                fibril_rwlock_write_unlock(&udp_globals.lock);
    438438                return rc;
    … …  
    740740        int socket_id;
    741741        size_t addrlen;
    742         size_t size;
     742        size_t size = 0;
    743743        ipc_call_t answer;
    744744        size_t answer_count;

  • uspace/srv/vfs/vfs_ops.c

    r2cf95e8 r3317724  
    12341234        if (!parentc) {
    12351235                fibril_rwlock_write_unlock(&namespace_rwlock);
     1236                vfs_node_put(old_node);
    12361237                async_answer_0(rid, rc);
    12371238                free(old);
    … …  
    12511252        if (rc != EOK) {
    12521253                fibril_rwlock_write_unlock(&namespace_rwlock);
     1254                vfs_node_put(old_node);
    12531255                async_answer_0(rid, rc);
    12541256                free(old);
    … …  
    12611263            (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) {
    12621264                fibril_rwlock_write_unlock(&namespace_rwlock);
     1265                vfs_node_put(old_node);
    12631266                async_answer_0(rid, EXDEV);     /* different file systems */
    12641267                free(old);
    … …  
    12791282                if (!new_node) {
    12801283                        fibril_rwlock_write_unlock(&namespace_rwlock);
     1284                        vfs_node_put(old_node);
    12811285                        async_answer_0(rid, ENOMEM);
    12821286                        free(old);
    … …  
    12901294        default:
    12911295                fibril_rwlock_write_unlock(&namespace_rwlock);
     1296                vfs_node_put(old_node);
    12921297                async_answer_0(rid, ENOTEMPTY);
    12931298                free(old);
    … …  
    13001305        if (rc != EOK) {
    13011306                fibril_rwlock_write_unlock(&namespace_rwlock);
     1307                vfs_node_put(old_node);
    13021308                if (new_node)
    13031309                        vfs_node_put(new_node);
Note: See TracChangeset for help on using the changeset viewer.