Changes in / [93ebe4e:2afc54d] in mainline


Ignore:
Location:
uspace
Files:
13 edited

Legend:

Unmodified
Added
Removed

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

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

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

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

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

    r93ebe4e r2afc54d  
    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 
    5349/** Character string to generic type map declaration.
    5450 *  @param[in] name     Name of the map.
    … …  
    6864        int name##_add(name##_t *, const uint8_t *, const size_t, type *); \
    6965        int name##_count(name##_t *); \
    70         void name##_destroy(name##_t *, DTOR_T()); \
    71         void name##_exclude(name##_t *, const uint8_t *, const size_t, DTOR_T()); \
     66        void name##_destroy(name##_t *); \
     67        void name##_exclude(name##_t *, const uint8_t *, const size_t); \
    7268        type *name##_find(name##_t *, const uint8_t *, const size_t); \
    7369        int name##_initialize(name##_t *); \
    … …  
    8884             type *value) \
    8985        { \
     86                int rc; \
    9087                int index; \
    9188                if (!name##_is_valid(map)) \
    … …  
    9491                if (index < 0) \
    9592                        return index; \
    96                 return char_map_add(&map->names, name, length, 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; \
    9799        } \
    98100        \
    … …  
    103105        } \
    104106        \
    105         void name##_destroy(name##_t *map, DTOR_T(dtor)) \
     107        void name##_destroy(name##_t *map) \
    106108        { \
    107109                if (name##_is_valid(map)) { \
    108110                        char_map_destroy(&map->names); \
    109                         name##_items_destroy(&map->values, dtor); \
     111                        name##_items_destroy(&map->values); \
    110112                } \
    111113        } \
    112114        \
    113115        void name##_exclude(name##_t *map, const uint8_t *name, \
    114             const size_t length, DTOR_T(dtor)) \
     116            const size_t length) \
    115117        { \
    116118                if (name##_is_valid(map)) { \
    … …  
    119121                        if (index != CHAR_MAP_NULL) \
    120122                                name##_items_exclude_index(&map->values, \
    121                                      index, dtor); \
     123                                     index); \
    122124                } \
    123125        } \

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

    r93ebe4e r2afc54d  
    4646#define GENERIC_FIELD_MAGIC_VALUE               0x55667788
    4747
    48 /** Generic destructor function pointer. */
    49 #define DTOR_T(identifier) \
    50         void (*identifier)(const void *)
    51 
    5248/** Generic type field declaration.
    5349 *
    … …  
    6763        int name##_add(name##_t *, type *); \
    6864        int name##_count(name##_t *); \
    69         void name##_destroy(name##_t *, DTOR_T()); \
    70         void name##_exclude_index(name##_t *, int, DTOR_T()); \
     65        void name##_destroy(name##_t *); \
     66        void name##_exclude_index(name##_t *, int); \
    7167        type **name##_get_field(name##_t *); \
    7268        type *name##_get_index(name##_t *, int); \
    … …  
    107103        } \
    108104        \
    109         void name##_destroy(name##_t *field, DTOR_T(dtor)) \
     105        void name##_destroy(name##_t *field) \
    110106        { \
    111107                if (name##_is_valid(field)) { \
    112108                        int index; \
    113109                        field->magic = 0; \
    114                         if (dtor) { \
    115                                 for (index = 0; index < field->next; index++) { \
    116                                         if (field->items[index]) \
    117                                                 dtor(field->items[index]); \
    118                                 } \
     110                        for (index = 0; index < field->next; index++) { \
     111                                if (field->items[index]) \
     112                                        free(field->items[index]); \
    119113                        } \
    120114                        free(field->items); \
    … …  
    122116        } \
    123117         \
    124         void name##_exclude_index(name##_t *field, int index, DTOR_T(dtor)) \
     118        void name##_exclude_index(name##_t *field, int index) \
    125119        { \
    126120                if (name##_is_valid(field) && (index >= 0) && \
    127121                    (index < field->next) && (field->items[index])) { \
    128                         if (dtor) \
    129                                 dtor(field->items[index]); \
     122                        free(field->items[index]); \
    130123                        field->items[index] = NULL; \
    131124                } \

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

    r93ebe4e r2afc54d  
    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 
    5551/** Integer to generic type map declaration.
    5652 *
    … …  
    7672        \
    7773        int name##_add(name##_t *, int, type *); \
    78         void name##_clear(name##_t *, DTOR_T()); \
     74        void name##_clear(name##_t *); \
    7975        int name##_count(name##_t *); \
    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()); \
     76        void name##_destroy(name##_t *); \
     77        void name##_exclude(name##_t *, int); \
     78        void name##_exclude_index(name##_t *, int); \
    8379        type *name##_find(name##_t *, int); \
    8480        int name##_update(name##_t *, int, int); \
    … …  
    8682        int name##_initialize(name##_t *); \
    8783        int name##_is_valid(name##_t *); \
    88         void name##_item_destroy(name##_item_t *, DTOR_T()); \
     84        void name##_item_destroy(name##_item_t *); \
    8985        int name##_item_is_valid(name##_item_t *);
    9086
    … …  
    119115        } \
    120116        \
    121         void name##_clear(name##_t *map, DTOR_T(dtor)) \
     117        void name##_clear(name##_t *map) \
    122118        { \
    123119                if (name##_is_valid(map)) { \
    … …  
    126122                                if (name##_item_is_valid(&map->items[index])) { \
    127123                                        name##_item_destroy( \
    128                                             &map->items[index], dtor); \
     124                                            &map->items[index]); \
    129125                                } \
    130126                        } \
    … …  
    139135        } \
    140136        \
    141         void name##_destroy(name##_t *map, DTOR_T(dtor)) \
     137        void name##_destroy(name##_t *map) \
    142138        { \
    143139                if (name##_is_valid(map)) { \
    … …  
    147143                                if (name##_item_is_valid(&map->items[index])) { \
    148144                                        name##_item_destroy( \
    149                                             &map->items[index], dtor); \
     145                                            &map->items[index]); \
    150146                                } \
    151147                        } \
    … …  
    154150        } \
    155151        \
    156         void name##_exclude(name##_t *map, int key, DTOR_T(dtor)) \
     152        void name##_exclude(name##_t *map, int key) \
    157153        { \
    158154                if (name##_is_valid(map)) { \
    … …  
    162158                                    (map->items[index].key == key)) { \
    163159                                        name##_item_destroy( \
    164                                             &map->items[index], dtor); \
    165                                 } \
    166                         } \
    167                 } \
    168         } \
    169         \
    170         void name##_exclude_index(name##_t *map, int index, DTOR_T(dtor)) \
     160                                            &map->items[index]); \
     161                                } \
     162                        } \
     163                } \
     164        } \
     165        \
     166        void name##_exclude_index(name##_t *map, int index) \
    171167        { \
    172168                if (name##_is_valid(map) && (index >= 0) && \
    173169                    (index < map->next) && \
    174170                    name##_item_is_valid(&map->items[index])) { \
    175                         name##_item_destroy(&map->items[index], dtor); \
     171                        name##_item_destroy(&map->items[index]); \
    176172                } \
    177173        } \
    … …  
    240236        } \
    241237        \
    242         void name##_item_destroy(name##_item_t *item, DTOR_T(dtor)) \
     238        void name##_item_destroy(name##_item_t *item) \
    243239        { \
    244240                if (name##_item_is_valid(item)) { \
    245241                        item->magic = 0; \
    246242                        if (item->value) { \
    247                                 if (dtor) \
    248                                         dtor(item->value); \
     243                                free(item->value); \
    249244                                item->value = NULL; \
    250245                        } \

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

    r93ebe4e r2afc54d  
    107107                socket_release(socket);
    108108
    109         socket_cores_exclude(local_sockets, socket->socket_id, free);
     109        socket_cores_exclude(local_sockets, socket->socket_id);
    110110}
    111111
    … …  
    230230
    231231fail:
    232         socket_port_map_destroy(&socket_port->map, free);
     232        socket_port_map_destroy(&socket_port->map);
    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, free);
     651                                socket_port_map_destroy(&socket_port->map);
    652652                                // release the port
    653653                                socket_ports_exclude(global_sockets,
    654                                     socket->port, free);
     654                                    socket->port);
    655655                        } else {
    656656                                // remove
    657657                                socket_port_map_exclude(&socket_port->map,
    658                                     socket->key, socket->key_length, free);
     658                                    socket->key, socket->key_length);
    659659                        }
    660660                }

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

    r93ebe4e r2afc54d  
    182182                        else
    183183                                packet_dimensions_exclude(packet_dimensions,
    184                                     DEVICE_INVALID_ID, free);
     184                                    DEVICE_INVALID_ID);
    185185                }
    186186        }

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

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

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

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

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

    r93ebe4e r2afc54d  
    555555                rc = read_netif_configuration(conf_files[i], netif);
    556556                if (rc != EOK) {
    557                         measured_strings_destroy(&netif->configuration, free);
     557                        measured_strings_destroy(&netif->configuration);
    558558                        free(netif);
    559559                        return rc;
    … …  
    565565                if (!setting) {
    566566                        fprintf(stderr, "%s: Network interface name is missing\n", NAME);
    567                         measured_strings_destroy(&netif->configuration, free);
     567                        measured_strings_destroy(&netif->configuration);
    568568                        free(netif);
    569569                        return EINVAL;
    … …  
    574574                int index = netifs_add(&net_globals.netifs, netif->id, netif);
    575575                if (index < 0) {
    576                         measured_strings_destroy(&netif->configuration, free);
     576                        measured_strings_destroy(&netif->configuration);
    577577                        free(netif);
    578578                        return index;
    … …  
    586586                    index);
    587587                if (rc != EOK) {
    588                         measured_strings_destroy(&netif->configuration, free);
    589                         netifs_exclude_index(&net_globals.netifs, index, free);
     588                        measured_strings_destroy(&netif->configuration);
     589                        netifs_exclude_index(&net_globals.netifs, index);
    590590                        return rc;
    591591                }
    … …  
    595595                        printf("%s: Ignoring failed interface %s (%s)\n", NAME,
    596596                            netif->name, str_error(rc));
    597                         measured_strings_destroy(&netif->configuration, free);
    598                         netifs_exclude_index(&net_globals.netifs, index, free);
     597                        measured_strings_destroy(&netif->configuration);
     598                        netifs_exclude_index(&net_globals.netifs, index);
    599599                        continue;
    600600                }

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

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

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

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

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

    r93ebe4e r2afc54d  
    417417        rc = packet_dimensions_initialize(&udp_globals.dimensions);
    418418        if (rc != EOK) {
    419                 socket_ports_destroy(&udp_globals.sockets, free);
     419                socket_ports_destroy(&udp_globals.sockets);
    420420                fibril_rwlock_write_unlock(&udp_globals.lock);
    421421                return rc;
    … …  
    434434            &data);
    435435        if (rc != EOK) {
    436                 socket_ports_destroy(&udp_globals.sockets, free);
     436                socket_ports_destroy(&udp_globals.sockets);
    437437                fibril_rwlock_write_unlock(&udp_globals.lock);
    438438                return rc;
Note: See TracChangeset for help on using the changeset viewer.