Changes in / [3090715:9ce7eb5] in mainline


Ignore:
Location:
uspace
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/adt/measured_strings.c

    r3090715 r9ce7eb5  
    4141#include <unistd.h>
    4242#include <errno.h>
     43#include <err.h>
    4344#include <async.h>
    4445
    … …  
    134135    size_t count)
    135136{
     137        ERROR_DECLARE;
     138
    136139        size_t *lengths;
    137140        size_t index;
    … …  
    139142        char *next;
    140143        ipc_callid_t callid;
    141         int rc;
    142144
    143145        if ((!strings) || (!data) || (count <= 0))
    … …  
    153155                return EINVAL;
    154156        }
    155         rc = async_data_write_finalize(callid, lengths, length);
    156         if (rc != EOK) {
    157                 free(lengths);
    158                 return rc;
     157        if (ERROR_OCCURRED(async_data_write_finalize(callid, lengths,
     158            length))) {
     159                free(lengths);
     160                return ERROR_CODE;
    159161        }
    160162
    … …  
    185187                                return EINVAL;
    186188                        }
    187                         rc = async_data_write_finalize(callid, next,
    188                             lengths[index]);
    189                         if (rc != EOK) {
     189                        if (ERROR_OCCURRED(async_data_write_finalize(callid,
     190                            next, lengths[index]))) {
    190191                                free(*data);
    191192                                free(*strings);
    192193                                free(lengths);
    193                                 return rc;
     194                                return ERROR_CODE;
    194195                        }
    195196                        (*strings)[index].value = next;
    … …  
    250251int measured_strings_reply(const measured_string_ref strings, size_t count)
    251252{
     253        ERROR_DECLARE;
     254
    252255        size_t *lengths;
    253256        size_t index;
    254257        size_t length;
    255258        ipc_callid_t callid;
    256         int rc;
    257259
    258260        if ((!strings) || (count <= 0))
    … …  
    268270                return EINVAL;
    269271        }
    270         rc = async_data_read_finalize(callid, lengths, length);
    271         if (rc != EOK) {
    272                 free(lengths);
    273                 return rc;
     272        if (ERROR_OCCURRED(async_data_read_finalize(callid, lengths, length))) {
     273                free(lengths);
     274                return ERROR_CODE;
    274275        }
    275276        free(lengths);
    … …  
    281282                                return EINVAL;
    282283                        }
    283                         rc = async_data_read_finalize(callid,
    284                             strings[index].value, strings[index].length);
    285                         if (rc != EOK)
    286                                 return rc;
     284                        ERROR_PROPAGATE(async_data_read_finalize(callid,
     285                            strings[index].value, strings[index].length));
    287286                }
    288287        }
    … …  
    314313    size_t count)
    315314{
     315        ERROR_DECLARE;
     316
    316317        size_t *lengths;
    317318        size_t index;
    318319        char *next;
    319         int rc;
    320320
    321321        if ((phone < 0) || (!strings) || (!data) || (count <= 0))
    … …  
    326326                return ENOMEM;
    327327
    328         rc = async_data_read_start(phone, lengths,
    329             sizeof(size_t) * (count + 1));
    330         if (rc != EOK) {
    331                 free(lengths);
    332                 return rc;
     328        if (ERROR_OCCURRED(async_data_read_start(phone, lengths,
     329            sizeof(size_t) * (count + 1)))) {
     330                free(lengths);
     331                return ERROR_CODE;
    333332        }
    334333
    … …  
    351350                (*strings)[index].length = lengths[index];
    352351                if (lengths[index] > 0) {
    353                         rc = async_data_read_start(phone, next, lengths[index]);
    354                         if (rc != EOK) {
     352                        if (ERROR_OCCURRED(async_data_read_start(phone, next,
     353                            lengths[index]))) {
    355354                                free(lengths);
    356355                                free(data);
    357356                                free(strings);
    358                                 return rc;
     357                                return ERROR_CODE;
    359358                        }
    360359                        (*strings)[index].value = next;
    … …  
    388387    size_t count)
    389388{
     389        ERROR_DECLARE;
     390
    390391        size_t *lengths;
    391392        size_t index;
    392         int rc;
    393393
    394394        if ((phone < 0) || (!strings) || (count <= 0))
    … …  
    399399                return ENOMEM;
    400400
    401         rc = async_data_write_start(phone, lengths,
    402             sizeof(size_t) * (count + 1));
    403         if (rc != EOK) {
    404                 free(lengths);
    405                 return rc;
     401        if (ERROR_OCCURRED(async_data_write_start(phone, lengths,
     402            sizeof(size_t) * (count + 1)))) {
     403                free(lengths);
     404                return ERROR_CODE;
    406405        }
    407406
    … …  
    410409        for (index = 0; index < count; index++) {
    411410                if (strings[index].length > 0) {
    412                         rc = async_data_write_start(phone, strings[index].value,
    413                             strings[index].length);
    414                         if (rc != EOK)
    415                                 return rc;
     411                        ERROR_PROPAGATE(async_data_write_start(phone,
     412                            strings[index].value, strings[index].length));
    416413                }
    417414        }

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

    r3090715 r9ce7eb5  
    4040#include <unistd.h>
    4141#include <errno.h>
     42#include <err.h>
    4243
    4344#include <adt/char_map.h>
    … …  
    8485             type *value) \
    8586        { \
    86                 int rc; \
     87                ERROR_DECLARE; \
    8788                int index; \
    8889                if (!name##_is_valid(map)) \
    … …  
    9192                if (index < 0) \
    9293                        return index; \
    93                 rc = char_map_add(&map->names, name, length, index); \
    94                 if (rc != EOK) { \
     94                if (ERROR_OCCURRED(char_map_add(&map->names, name, length, \
     95                    index))) { \
    9596                        name##_items_exclude_index(&map->values, index); \
    96                         return rc; \
     97                        return ERROR_CODE; \
    9798                } \
    9899                return EOK; \
    … …  
    140141        int name##_initialize(name##_ref map) \
    141142        { \
    142                 int rc; \
     143                ERROR_DECLARE; \
    143144                if (!map) \
    144145                        return EINVAL; \
    145                 rc = char_map_initialize(&map->names); \
    146                 if (rc != EOK) \
    147                         return rc; \
    148                 rc = name##_items_initialize(&map->values); \
    149                 if (rc != EOK) { \
     146                ERROR_PROPAGATE(char_map_initialize(&map->names)); \
     147                if (ERROR_OCCURRED(name##_items_initialize(&map->values))) { \
    150148                        char_map_destroy(&map->names); \
    151                         return rc; \
     149                        return ERROR_CODE; \
    152150                } \
    153151                map->magic = GENERIC_CHAR_MAP_MAGIC_VALUE; \

  • uspace/lib/c/include/err.h

    r3090715 r9ce7eb5  
    3737
    3838#include <stdio.h>
     39#include <errno.h>
     40
     41#ifdef CONFIG_DEBUG
     42#include <str_error.h>
     43#endif
    3944
    4045#define errx(status, fmt, ...) { \
    … …  
    4348}
    4449
     50
     51/** An actual stored error code.  */
     52#define ERROR_CODE  error_check_return_value
     53
     54/** An error processing routines declaration.
     55 *
     56 * This has to be declared in the block where the error processing
     57 * is desired.
     58 */
     59#define ERROR_DECLARE  int ERROR_CODE
     60
     61/** Store the value as an error code and checks if an error occurred.
     62 *
     63 * @param[in] value     The value to be checked. May be a function call.
     64 * @return              False if the value indicates success (EOK).
     65 * @return              True otherwise.
     66 */
     67#ifdef CONFIG_DEBUG
     68
     69#define ERROR_OCCURRED(value) \
     70        (((ERROR_CODE = (value)) != EOK) && \
     71        ({ \
     72                fprintf(stderr, "libsocket error at %s:%d (%s)\n", \
     73                __FILE__, __LINE__, str_error(ERROR_CODE)); \
     74                1; \
     75        }))
     76
     77#else
     78
     79#define ERROR_OCCURRED(value)   ((ERROR_CODE = (value)) != EOK)
     80
     81#endif
     82
     83#define ERROR_NONE(value)       !ERROR_OCCURRED((value))
     84
     85/** Error propagation
     86 *
     87 * Check if an error occurred and immediately exit the actual
     88 * function returning the error code.
     89 *
     90 * @param[in] value     The value to be checked. May be a function call.
     91 *
     92 */
     93
     94#define ERROR_PROPAGATE(value) \
     95        if (ERROR_OCCURRED(value)) \
     96                return ERROR_CODE
     97
    4598#endif
    4699
    47100/** @}
    48101 */
    49 

  • uspace/lib/net/adt/module_map.c

    r3090715 r9ce7eb5  
    3838#include <task.h>
    3939#include <unistd.h>
    40 #include <errno.h>
     40#include <err.h>
    4141
    4242#include <ipc/services.h>
    … …  
    6767    connect_module_t connect_module)
    6868{
     69        ERROR_DECLARE;
     70
    6971        module_ref tmp_module;
    70         int rc;
    7172
    7273        tmp_module = (module_ref) malloc(sizeof(module_t));
    … …  
    8283        tmp_module->connect_module = connect_module;
    8384
    84         rc = modules_add(modules, tmp_module->name, 0, tmp_module);
    85         if (rc != EOK) {
     85        if (ERROR_OCCURRED(modules_add(modules, tmp_module->name, 0,
     86            tmp_module))) {
    8687                free(tmp_module);
    87                 return rc;
     88                return ERROR_CODE;
    8889        }
    8990        if (module)

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

    r3090715 r9ce7eb5  
    3838#include <async.h>
    3939#include <errno.h>
     40#include <err.h>
    4041#include <ipc/ipc.h>
    4142#include <ipc/packet.h>
    … …  
    6667packet_return(int phone, packet_ref packet, packet_id_t packet_id, size_t size)
    6768{
     69        ERROR_DECLARE;
     70       
    6871        ipc_call_t answer;
    69         aid_t message;
    70         int rc;
    71        
    72         message = async_send_1(phone, NET_PACKET_GET, packet_id, &answer);
     72        aid_t message = async_send_1(phone, NET_PACKET_GET, packet_id, &answer);
    7373
    7474        *packet = (packet_t) as_get_mappable_page(size);
    75         rc = async_share_in_start_0_0(phone, *packet, size);
    76         if (rc != EOK) {
     75        if (ERROR_OCCURRED(async_share_in_start_0_0(phone, *packet, size)) ||
     76            ERROR_OCCURRED(pm_add(*packet))) {
    7777                munmap(*packet, size);
    7878                async_wait_for(message, NULL);
    79                 return rc;
    80         }
    81         rc = pm_add(*packet);
    82         if (rc != EOK) {
    83                 munmap(*packet, size);
    84                 async_wait_for(message, NULL);
    85                 return rc;
     79                return ERROR_CODE;
    8680        }
    8781       
    … …  
    109103int packet_translate_remote(int phone, packet_ref packet, packet_id_t packet_id)
    110104{
    111         int rc;
     105        ERROR_DECLARE;
    112106       
    113107        if (!packet)
    … …  
    118112                ipcarg_t size;
    119113               
    120                 rc = async_req_1_1(phone, NET_PACKET_GET_SIZE, packet_id,
    121                     &size);
    122                 if (rc != EOK)
    123                         return rc;
    124                 rc = packet_return(phone, packet, packet_id, size);
    125                 if (rc != EOK)
    126                         return rc;
     114                ERROR_PROPAGATE(async_req_1_1(phone, NET_PACKET_GET_SIZE,
     115                    packet_id, &size));
     116                ERROR_PROPAGATE(packet_return(phone, packet, packet_id, size));
    127117        }
    128118        if ((*packet)->next) {
    … …  
    151141    size_t max_prefix, size_t max_suffix)
    152142{
     143        ERROR_DECLARE;
     144       
    153145        ipcarg_t packet_id;
    154146        ipcarg_t size;
    155         int rc;
    156        
    157         rc = async_req_4_2(phone, NET_PACKET_CREATE_4, max_content, addr_len,
    158             max_prefix, max_suffix, &packet_id, &size);
    159         if (rc != EOK)
     147       
     148        if (ERROR_OCCURRED(async_req_4_2(phone, NET_PACKET_CREATE_4,
     149            max_content, addr_len, max_prefix, max_suffix, &packet_id, &size)))
    160150                return NULL;
    161151       
    … …  
    163153        packet_t packet = pm_find(packet_id);
    164154        if (!packet) {
    165                 rc = packet_return(phone, &packet, packet_id, size);
    166                 if (rc != EOK)
     155                if (ERROR_OCCURRED(packet_return(phone, &packet, packet_id,
     156                    size)))
    167157                        return NULL;
    168158        }
    … …  
    182172packet_t packet_get_1_remote(int phone, size_t content)
    183173{
     174        ERROR_DECLARE;
     175       
    184176        ipcarg_t packet_id;
    185177        ipcarg_t size;
    186         int rc;
    187        
    188         rc = async_req_1_2(phone, NET_PACKET_CREATE_1, content, &packet_id,
    189             &size);
    190         if (rc != EOK)
     178       
     179        if (ERROR_OCCURRED(async_req_1_2(phone, NET_PACKET_CREATE_1, content,
     180            &packet_id, &size)))
    191181                return NULL;
    192182       
    193183        packet_t packet = pm_find(packet_id);
    194184        if (!packet) {
    195                 rc = packet_return(phone, &packet, packet_id, size);
    196                 if (rc != EOK)
     185                if (ERROR_OCCURRED(packet_return(phone, &packet, packet_id,
     186                    size)))
    197187                        return NULL;
    198188        }

  • uspace/lib/net/netif/netif_local.c

    r3090715 r9ce7eb5  
    4343#include <ipc/services.h>
    4444#include <ipc/netif.h>
    45 #include <errno.h>
     45#include <err.h>
    4646
    4747#include <generic.h>
    … …  
    113113int netif_start_req_local(int netif_phone, device_id_t device_id)
    114114{
    115         int rc;
     115        ERROR_DECLARE;
    116116       
    117117        fibril_rwlock_write_lock(&netif_globals.lock);
    118118       
    119119        netif_device_t *device;
    120         rc = find_device(device_id, &device);
    121         if (rc != EOK) {
     120        if (ERROR_OCCURRED(find_device(device_id, &device))) {
    122121                fibril_rwlock_write_unlock(&netif_globals.lock);
    123                 return rc;
     122                return ERROR_CODE;
    124123        }
    125124       
    … …  
    149148int netif_stop_req_local(int netif_phone, device_id_t device_id)
    150149{
    151         int rc;
     150        ERROR_DECLARE;
    152151       
    153152        fibril_rwlock_write_lock(&netif_globals.lock);
    154153       
    155154        netif_device_t *device;
    156         rc = find_device(device_id, &device);
    157         if (rc != EOK) {
     155        if (ERROR_OCCURRED(find_device(device_id, &device))) {
    158156                fibril_rwlock_write_unlock(&netif_globals.lock);
    159                 return rc;
     157                return ERROR_CODE;
    160158        }
    161159       
    … …  
    205203    measured_string_ref *address, char **data)
    206204{
    207         int rc;
     205        ERROR_DECLARE;
    208206       
    209207        if (!address || !data)
    … …  
    213211       
    214212        measured_string_t translation;
    215         rc = netif_get_addr_message(device_id, &translation);
    216         if (rc == EOK) {
     213        if (!ERROR_OCCURRED(netif_get_addr_message(device_id, &translation))) {
    217214                *address = measured_string_copy(&translation);
    218                 rc = (*address) ? EOK : ENOMEM;
     215                ERROR_CODE = (*address) ? EOK : ENOMEM;
    219216        }
    220217       
    … …  
    223220        *data = (**address).value;
    224221       
    225         return rc;
     222        return ERROR_CODE;
    226223}
    227224
    … …  
    267264int netif_init_module(async_client_conn_t client_connection)
    268265{
    269         int rc;
     266        ERROR_DECLARE;
    270267       
    271268        async_set_client_connection(client_connection);
    … …  
    274271        netif_device_map_initialize(&netif_globals.device_map);
    275272       
    276         rc = pm_init();
    277         if (rc != EOK)
    278                 return rc;
     273        ERROR_PROPAGATE(pm_init());
    279274       
    280275        fibril_rwlock_initialize(&netif_globals.lock);
    281        
    282         rc = netif_initialize();
    283         if (rc != EOK) {
     276        if (ERROR_OCCURRED(netif_initialize())) {
    284277                pm_destroy();
    285                 return rc;
     278                return ERROR_CODE;
    286279        }
    287280       
    … …  
    324317static int register_message(const char *name, device_id_t device_id, int phone)
    325318{
     319        ERROR_DECLARE;
     320       
    326321        netif_device_t *device;
    327         int rc;
    328        
    329         rc = find_device(device_id, &device);
    330         if (rc != EOK)
    331                 return rc;
    332        
    333         if (device->nil_phone > 0)
     322        ERROR_PROPAGATE(find_device(device_id, &device));
     323        if(device->nil_phone > 0)
    334324                return ELIMIT;
    335325       
    … …  
    359349    ipc_call_t *call, ipc_call_t *answer, int *answer_count)
    360350{
     351        ERROR_DECLARE;
     352       
    361353        size_t length;
    362354        device_stats_t stats;
    363355        packet_t packet;
    364356        measured_string_t address;
    365         int rc;
    366357       
    367358        *answer_count = 0;
    … …  
    376367        case IPC_M_CONNECT_TO_ME:
    377368                fibril_rwlock_write_lock(&netif_globals.lock);
    378                 rc = register_message(name, IPC_GET_DEVICE(call),
     369                ERROR_CODE = register_message(name, IPC_GET_DEVICE(call),
    379370                    IPC_GET_PHONE(call));
    380371                fibril_rwlock_write_unlock(&netif_globals.lock);
    381                 return rc;
     372                return ERROR_CODE;
    382373               
    383374        case NET_NETIF_SEND:
    384                 rc = packet_translate_remote(netif_globals.net_phone, &packet,
    385                     IPC_GET_PACKET(call));
    386                 if (rc != EOK)
    387                         return rc;
     375                ERROR_PROPAGATE(packet_translate_remote(netif_globals.net_phone,
     376                    &packet, IPC_GET_PACKET(call)));
    388377                return netif_send_msg_local(0, IPC_GET_DEVICE(call), packet,
    389378                    IPC_GET_SENDER(call));
    390                
     379                   
    391380        case NET_NETIF_START:
    392381                return netif_start_req_local(0, IPC_GET_DEVICE(call));
    … …  
    395384                fibril_rwlock_read_lock(&netif_globals.lock);
    396385
    397                 rc = async_data_read_receive(&callid, &length);
    398                 if (rc != EOK) {
     386                if (ERROR_OCCURRED(async_data_read_receive(&callid, &length))) {
    399387                        fibril_rwlock_read_unlock(&netif_globals.lock);
    400                         return rc;
     388                        return ERROR_CODE;
    401389                }
    402390                if (length < sizeof(device_stats_t)) {
    … …  
    405393                }
    406394
    407                 rc = netif_get_device_stats(IPC_GET_DEVICE(call), &stats);
    408                 if (rc == EOK) {
    409                         rc = async_data_read_finalize(callid, &stats,
     395                if (ERROR_NONE(netif_get_device_stats(IPC_GET_DEVICE(call),
     396                    &stats))) {
     397                        ERROR_CODE = async_data_read_finalize(callid, &stats,
    410398                            sizeof(device_stats_t));
    411399                }
    412400
    413401                fibril_rwlock_read_unlock(&netif_globals.lock);
    414                 return rc;
     402                return ERROR_CODE;
    415403
    416404        case NET_NETIF_STOP:
    … …  
    419407        case NET_NETIF_GET_ADDR:
    420408                fibril_rwlock_read_lock(&netif_globals.lock);
    421                 rc = netif_get_addr_message(IPC_GET_DEVICE(call), &address);
    422                 if (rc == EOK)
    423                         rc = measured_strings_reply(&address, 1);
     409                if (ERROR_NONE(netif_get_addr_message(IPC_GET_DEVICE(call),
     410                    &address)))
     411                        ERROR_CODE = measured_strings_reply(&address, 1);
    424412                fibril_rwlock_read_unlock(&netif_globals.lock);
    425                 return rc;
     413                return ERROR_CODE;
    426414        }
    427415       
    … …  
    443431int netif_module_start_standalone(async_client_conn_t client_connection)
    444432{
    445         int rc;
    446        
    447         rc = netif_init_module(client_connection);
    448         if (rc != EOK)
    449                 return rc;
     433        ERROR_DECLARE;
     434       
     435        ERROR_PROPAGATE(netif_init_module(client_connection));
    450436       
    451437        async_manager();

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

    r3090715 r9ce7eb5  
    4848#include <stdlib.h>
    4949#include <errno.h>
     50#include <err.h>
    5051
    5152#include <adt/dynamic_fifo.h>
    … …  
    163164    const char *key, size_t key_length)
    164165{
     166        ERROR_DECLARE;
     167
    165168        socket_core_ref *socket_ref;
    166         int rc;
    167169
    168170        // create a wrapper
    … …  
    173175        *socket_ref = socket;
    174176        // add the wrapper
    175         rc = socket_port_map_add(&socket_port->map, key, key_length,
    176             socket_ref);
    177         if (rc != EOK) {
     177        if (ERROR_OCCURRED(socket_port_map_add(&socket_port->map, key,
     178            key_length, socket_ref))) {
    178179                free(socket_ref);
    179                 return rc;
     180                return ERROR_CODE;
    180181        }
    181182       
    … …  
    203204    int port)
    204205{
     206        ERROR_DECLARE;
     207
    205208        socket_port_ref socket_port;
    206         int rc;
    207209
    208210        // create a wrapper
    … …  
    212214
    213215        socket_port->count = 0;
    214         rc = socket_port_map_initialize(&socket_port->map);
    215         if (rc != EOK)
    216                 goto fail;
    217        
    218         rc = socket_port_add_core(socket_port, socket, SOCKET_MAP_KEY_LISTENING,
    219             0);
    220         if (rc != EOK)
    221                 goto fail;
     216        if (ERROR_OCCURRED(socket_port_map_initialize(&socket_port->map)) ||
     217            ERROR_OCCURRED(socket_port_add_core(socket_port, socket,
     218            SOCKET_MAP_KEY_LISTENING, 0))) {
     219                socket_port_map_destroy(&socket_port->map);
     220                free(socket_port);
     221                return ERROR_CODE;
     222        }
    222223       
    223224        // register the incomming port
    224         rc = socket_ports_add(global_sockets, port, socket_port);
    225         if (rc < 0)
    226                 goto fail;
     225        ERROR_CODE = socket_ports_add(global_sockets, port, socket_port);
     226        if (ERROR_CODE < 0) {
     227                socket_port_map_destroy(&socket_port->map);
     228                free(socket_port);
     229                return ERROR_CODE;
     230        }
    227231       
    228232        socket->port = port;
    229233        return EOK;
    230 
    231 fail:
    232         socket_port_map_destroy(&socket_port->map);
    233         free(socket_port);
    234         return rc;
    235        
    236234}
    237235
    … …  
    418416    void *specific_data, int *socket_id)
    419417{
     418        ERROR_DECLARE;
     419
    420420        socket_core_ref socket;
     421        int res;
    421422        int positive;
    422         int rc;
    423423
    424424        if (!socket_id)
    … …  
    447447        socket->key_length = 0;
    448448        socket->specific_data = specific_data;
    449         rc = dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE);
    450         if (rc != EOK) {
     449        if (ERROR_OCCURRED(dyn_fifo_initialize(&socket->received,
     450            SOCKET_INITIAL_RECEIVED_SIZE))) {
    451451                free(socket);
    452                 return rc;
    453         }
    454        
    455         rc = dyn_fifo_initialize(&socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE);
    456         if (rc != EOK) {
     452                return ERROR_CODE;
     453        }
     454        if (ERROR_OCCURRED(dyn_fifo_initialize(&socket->accepted,
     455            SOCKET_INITIAL_ACCEPTED_SIZE))) {
    457456                dyn_fifo_destroy(&socket->received);
    458457                free(socket);
    459                 return rc;
     458                return ERROR_CODE;
    460459        }
    461460        socket->socket_id = *socket_id;
    462         rc = socket_cores_add(local_sockets, socket->socket_id, socket);
    463         if (rc < 0) {
     461        res = socket_cores_add(local_sockets, socket->socket_id, socket);
     462        if (res < 0) {
    464463                dyn_fifo_destroy(&socket->received);
    465464                dyn_fifo_destroy(&socket->accepted);
    466465                free(socket);
    467                 return rc;
     466                return res;
    468467        }
    469468       
    … …  
    524523int socket_reply_packets(packet_t packet, size_t *length)
    525524{
     525        ERROR_DECLARE;
     526
    526527        packet_t next_packet;
    527528        size_t fragments;
    528529        size_t *lengths;
    529530        size_t index;
    530         int rc;
    531531
    532532        if (!length)
    … …  
    536536        if (!next_packet) {
    537537                // write all if only one fragment
    538                 rc = data_reply(packet_get_data(packet),
    539                     packet_get_data_length(packet));
    540                 if (rc != EOK)
    541                         return rc;
     538                ERROR_PROPAGATE(data_reply(packet_get_data(packet),
     539                    packet_get_data_length(packet)));
    542540                // store the total length
    543541                *length = packet_get_data_length(packet);
    … …  
    566564               
    567565                // write the fragment lengths
    568                 rc = data_reply(lengths, sizeof(int) * (fragments + 1));
    569                 if (rc != EOK) {
     566                if (ERROR_OCCURRED(data_reply(lengths,
     567                    sizeof(int) * (fragments + 1)))) {
    570568                        free(lengths);
    571                         return rc;
     569                        return ERROR_CODE;
    572570                }
    573571                next_packet = packet;
    … …  
    575573                // write the fragments
    576574                for (index = 0; index < fragments; ++index) {
    577                         rc = data_reply(packet_get_data(next_packet),
     575                        ERROR_CODE = data_reply(packet_get_data(next_packet),
    578576                            lengths[index]);
    579                         if (rc != EOK) {
     577                        if (ERROR_OCCURRED(ERROR_CODE)) {
    580578                                free(lengths);
    581                                 return rc;
     579                                return ERROR_CODE;
    582580                        }
    583581                        next_packet = pq_next(next_packet);
    … …  
    682680    socket_core_ref socket, const char *key, size_t key_length)
    683681{
     682        ERROR_DECLARE;
     683
    684684        socket_port_ref socket_port;
    685         int rc;
    686685
    687686        // find ports
    … …  
    691690       
    692691        // add the socket
    693         rc = socket_port_add_core(socket_port, socket, key, key_length);
    694         if (rc != EOK)
    695                 return rc;
     692        ERROR_PROPAGATE(socket_port_add_core(socket_port, socket, key,
     693            key_length));
    696694       
    697695        socket->port = port;

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

    r3090715 r9ce7eb5  
    5454#include <ipc/services.h>
    5555#include <errno.h>
     56#include <err.h>
    5657
    5758DEVICE_MAP_IMPLEMENT(packet_dimensions, packet_dimension_t);
    … …  
    123124    packet_dimension_ref *packet_dimension)
    124125{
    125         int rc;
     126        ERROR_DECLARE;
    126127       
    127128        if (!packet_dimension)
    … …  
    136137                        return ENOMEM;
    137138               
    138                 rc = ip_packet_size_req(ip_phone, device_id, *packet_dimension);
    139                 if (rc != EOK) {
     139                if (ERROR_OCCURRED(ip_packet_size_req(ip_phone, device_id,
     140                    *packet_dimension))) {
    140141                        free(*packet_dimension);
    141                         return rc;
     142                        return ERROR_CODE;
    142143                }
    143144               
    144                 rc = packet_dimensions_add(packet_dimensions, device_id,
     145                ERROR_CODE = packet_dimensions_add(packet_dimensions, device_id,
    145146                    *packet_dimension);
    146                 if (rc < 0) {
     147                if (ERROR_CODE < 0) {
    147148                        free(*packet_dimension);
    148                         return rc;
     149                        return ERROR_CODE;
    149150                }
    150151        }
    … …  
    291292    socklen_t addrlen)
    292293{
     294        ERROR_DECLARE;
     295
    293296        ipc_callid_t callid;
    294297        size_t length;
    295         void *data;
    296         int rc;
     298        void * data;
    297299
    298300        if (!dimension)
    … …  
    317319
    318320        // read the data into the packet
    319         rc = async_data_write_finalize(callid, data, length);
    320         if (rc != EOK) {
     321        if (ERROR_OCCURRED(async_data_write_finalize(callid, data, length)) ||
     322            // set the packet destination address
     323            ERROR_OCCURRED(packet_set_addr(*packet, NULL, (uint8_t *) addr,
     324            addrlen))) {
    321325                pq_release_remote(packet_phone, packet_get_id(*packet));
    322                 return rc;
    323         }
    324        
    325         // set the packet destination address
    326         rc = packet_set_addr(*packet, NULL, (uint8_t *) addr, addrlen);
    327         if (rc != EOK) {
    328                 pq_release_remote(packet_phone, packet_get_id(*packet));
    329                 return rc;
     326                return ERROR_CODE;
    330327        }
    331328

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

    r3090715 r9ce7eb5  
    4242#include <async.h>
    4343#include <errno.h>
     44#include <err.h>
    4445#include <fibril_synch.h>
    4546#include <unistd.h>
    … …  
    161162    size_t max_content, size_t max_suffix)
    162163{
     164        ERROR_DECLARE;
     165
    163166        packet_t packet;
    164         int rc;
    165167
    166168        // already locked
    … …  
    175177        packet_init(packet, addr_len, max_prefix, max_content, max_suffix);
    176178        packet->magic_value = PACKET_MAGIC_VALUE;
    177         rc = pm_add(packet);
    178         if (rc != EOK) {
     179        if (ERROR_OCCURRED(pm_add(packet))) {
    179180                munmap(packet, packet->length);
    180181                return NULL;

  • uspace/srv/hw/netif/dp8390/dp8390_module.c

    r3090715 r9ce7eb5  
    158158
    159159int netif_get_device_stats(device_id_t device_id, device_stats_ref stats){
     160        ERROR_DECLARE;
     161
    160162        netif_device_t * device;
    161163        eth_stat_t * de_stat;
    162         int rc;
    163164
    164165        if(! stats){
    165166                return EBADMEM;
    166167        }
    167         rc = find_device(device_id, &device);
    168         if (rc != EOK)
    169                 return rc;
     168        ERROR_PROPAGATE(find_device(device_id, &device));
    170169        de_stat = &((dpeth_t *) device->specific)->de_stat;
    171170        null_device_stats(stats);
    … …  
    186185
    187186int netif_get_addr_message(device_id_t device_id, measured_string_ref address){
    188         netif_device_t * device;
    189         int rc;
     187        ERROR_DECLARE;
     188
     189        netif_device_t * device;
    190190
    191191        if(! address){
    192192                return EBADMEM;
    193193        }
    194         rc = find_device(device_id, &device);
    195         if (rc != EOK)
    196                 return rc;
     194        ERROR_PROPAGATE(find_device(device_id, &device));
    197195        address->value = (char *) (&((dpeth_t *) device->specific)->de_address);
    198196        address->length = CONVERT_SIZE(ether_addr_t, char, 1);
    … …  
    203201
    204202int netif_probe_message(device_id_t device_id, int irq, uintptr_t io){
    205         netif_device_t * device;
    206         dpeth_t * dep;
    207         int rc;
     203        ERROR_DECLARE;
     204
     205        netif_device_t * device;
     206        dpeth_t * dep;
    208207
    209208        device = (netif_device_t *) malloc(sizeof(netif_device_t));
    … …  
    225224        dep->de_mode = DEM_DISABLED;
    226225        //TODO address?
    227         rc = pio_enable((void *) io, DP8390_IO_SIZE, (void **) &dep->de_base_port);
    228         if (rc != EOK) {
     226        if(ERROR_OCCURRED(pio_enable((void *) io, DP8390_IO_SIZE, (void **) &dep->de_base_port))
     227                || ERROR_OCCURRED(do_probe(dep))){
    229228                free(dep);
    230229                free(device);
    231                 return rc;
    232         }       
    233         rc = do_probe(dep);
    234         if (rc != EOK) {
     230                return ERROR_CODE;
     231        }
     232        if(ERROR_OCCURRED(netif_device_map_add(&netif_globals.device_map, device->device_id, device))){
    235233                free(dep);
    236234                free(device);
    237                 return rc;
    238         }
    239         rc = netif_device_map_add(&netif_globals.device_map, device->device_id, device);
    240         if (rc != EOK){
    241                 free(dep);
    242                 free(device);
    243                 return rc;
     235                return ERROR_CODE;
    244236        }
    245237        return EOK;
    … …  
    247239
    248240int netif_send_message(device_id_t device_id, packet_t packet, services_t sender){
     241        ERROR_DECLARE;
     242
    249243        netif_device_t * device;
    250244        dpeth_t * dep;
    251245        packet_t next;
    252         int rc;
    253 
    254         rc = find_device(device_id, &device);
    255         if (rc != EOK)
    256                 return rc;
     246
     247        ERROR_PROPAGATE(find_device(device_id, &device));
    257248        if(device->state != NETIF_ACTIVE){
    258249                netif_pq_release(packet_get_id(packet));
    … …  
    272263
    273264int netif_start_message(netif_device_t * device){
    274         dpeth_t * dep;
    275         int rc;
     265        ERROR_DECLARE;
     266
     267        dpeth_t * dep;
    276268
    277269        if(device->state != NETIF_ACTIVE){
    … …  
    279271                dp8390_cmds[0].addr = (void *) (uintptr_t) (dep->de_dp8390_port + DP_ISR);
    280272                dp8390_cmds[2].addr = dp8390_cmds[0].addr;
    281                 rc = ipc_register_irq(dep->de_irq, device->device_id, device->device_id, &dp8390_code);
    282                 if (rc != EOK)
    283                         return rc;
    284                 rc = do_init(dep, DL_BROAD_REQ);
    285                 if (rc != EOK) {
     273                ERROR_PROPAGATE(ipc_register_irq(dep->de_irq, device->device_id, device->device_id, &dp8390_code));
     274                if(ERROR_OCCURRED(do_init(dep, DL_BROAD_REQ))){
    286275                        ipc_unregister_irq(dep->de_irq, device->device_id);
    287                         return rc;
     276                        return ERROR_CODE;
    288277                }
    289278                return change_state(device, NETIF_ACTIVE);
    … …  
    361350int main(int argc, char *argv[])
    362351{
    363         int rc;
     352        ERROR_DECLARE;
    364353       
    365354        /* Start the module */
    366         rc = netif_module_start(netif_client_connection);
    367         return rc;
     355        if (ERROR_OCCURRED(netif_module_start(netif_client_connection)))
     356                return ERROR_CODE;
     357       
     358        return EOK;
    368359}
    369360
Note: See TracChangeset for help on using the changeset viewer.