Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 7494fb4 in mainline


Ignore:
Timestamp:
2010-11-13T19:12:37Z (11 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master
Children:
c7137738
Parents:
63a1e60 (diff), 71e3289 (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

Files:
1 added
24 edited

Legend:

Unmodified
Added
Removed
  • kernel/arch/amd64/include/pm.h

    r63a1e60 r7494fb4  
    8383
    8484#define TSS_BASIC_SIZE  104
    85 #define TSS_IOMAP_SIZE  (16 * 1024 + 1)  /* 16K for bitmap + 1 terminating byte for convenience */
     85#define TSS_IOMAP_SIZE  (8 * 1024 + 1)  /* 8K for bitmap + 1 terminating byte for convenience */
    8686
    8787#define IO_PORTS  (64 * 1024)
  • kernel/arch/amd64/src/ddi/ddi.c

    r63a1e60 r7494fb4  
    126126                bitmap_initialize(&iomap, CPU->arch.tss->iomap,
    127127                    TSS_IOMAP_SIZE * 8);
    128                 bitmap_copy(&iomap, &TASK->arch.iomap, TASK->arch.iomap.bits);
     128                bitmap_copy(&iomap, &TASK->arch.iomap, bits);
    129129               
     130                /*
     131                 * Set the trailing bits in the last byte of the map to disable
     132                 * I/O access.
     133                 */
     134                bitmap_set_range(&iomap, bits, ALIGN_UP(bits, 8) - bits);
    130135                /*
    131136                 * It is safe to set the trailing eight bits because of the
    132137                 * extra convenience byte in TSS_IOMAP_SIZE.
    133138                 */
    134                 bitmap_set_range(&iomap, ALIGN_UP(TASK->arch.iomap.bits, 8), 8);
     139                bitmap_set_range(&iomap, ALIGN_UP(bits, 8), 8);
    135140        }
    136141        irq_spinlock_unlock(&TASK->lock, false);
  • kernel/arch/ia32/include/pm.h

    r63a1e60 r7494fb4  
    7575
    7676#define TSS_BASIC_SIZE  104
    77 #define TSS_IOMAP_SIZE  (16 * 1024 + 1)  /* 16K for bitmap + 1 terminating byte for convenience */
     77#define TSS_IOMAP_SIZE  (8 * 1024 + 1)  /* 8K for bitmap + 1 terminating byte for convenience */
    7878
    7979#define IO_PORTS  (64 * 1024)
  • kernel/arch/ia32/src/ddi/ddi.c

    r63a1e60 r7494fb4  
    127127                bitmap_initialize(&iomap, CPU->arch.tss->iomap,
    128128                    TSS_IOMAP_SIZE * 8);
    129                 bitmap_copy(&iomap, &TASK->arch.iomap, TASK->arch.iomap.bits);
     129                bitmap_copy(&iomap, &TASK->arch.iomap, bits);
    130130               
     131                /*
     132                 * Set the trailing bits in the last byte of the map to disable
     133                 * I/O access.
     134                 */
     135                bitmap_set_range(&iomap, bits, ALIGN_UP(bits, 8) - bits);
    131136                /*
    132137                 * It is safe to set the trailing eight bits because of the
    133138                 * extra convenience byte in TSS_IOMAP_SIZE.
    134139                 */
    135                 bitmap_set_range(&iomap, ALIGN_UP(TASK->arch.iomap.bits, 8), 8);
     140                bitmap_set_range(&iomap, ALIGN_UP(bits, 8), 8);
    136141        }
    137142        irq_spinlock_unlock(&TASK->lock, false);
  • kernel/generic/src/adt/bitmap.c

    r63a1e60 r7494fb4  
    3232/**
    3333 * @file
    34  * @brief       Implementation of bitmap ADT.
     34 * @brief Implementation of bitmap ADT.
    3535 *
    3636 * This file implements bitmap ADT and provides functions for
     
    5151 * No portion of the bitmap is set or cleared by this function.
    5252 *
    53  * @param bitmap Bitmap structure.
    54  * @param map Address of the memory used to hold the map.
    55  * @param bits Number of bits stored in bitmap.
     53 * @param bitmap        Bitmap structure.
     54 * @param map           Address of the memory used to hold the map.
     55 * @param bits          Number of bits stored in bitmap.
    5656 */
    5757void bitmap_initialize(bitmap_t *bitmap, uint8_t *map, size_t bits)
     
    6363/** Set range of bits.
    6464 *
    65  * @param bitmap Bitmap structure.
    66  * @param start Starting bit.
    67  * @param bits Number of bits to set.
     65 * @param bitmap        Bitmap structure.
     66 * @param start         Starting bit.
     67 * @param bits          Number of bits to set.
    6868 */
    6969void bitmap_set_range(bitmap_t *bitmap, size_t start, size_t bits)
     
    7171        size_t i = 0;
    7272        size_t aligned_start;
    73         size_t lub;             /* leading unaligned bits */
    74         size_t amb;             /* aligned middle bits */
    75         size_t tab;             /* trailing aligned bits */
     73        size_t lub;     /* leading unaligned bits */
     74        size_t amb;     /* aligned middle bits */
     75        size_t tab;     /* trailing aligned bits */
    7676       
    7777        ASSERT(start + bits <= bitmap->bits);
     
    8282        tab = amb % 8;
    8383       
    84         if ( start + bits < aligned_start ) {
    85             /*
    86             * Set bits in the middle of byte
    87             */
    88             bitmap->map[start / 8] |= ((1 << lub)-1) << (start&7);
    89             return;
     84        if (!bits)
     85                return;
     86
     87        if (start + bits < aligned_start) {
     88                /* Set bits in the middle of byte. */
     89                bitmap->map[start / 8] |= ((1 << lub) - 1) << (start & 7);
     90                return;
    9091        }
    9192       
    9293        if (lub) {
    93                 /*
    94                  * Make sure to set any leading unaligned bits.
    95                  */
     94                /* Make sure to set any leading unaligned bits. */
    9695                bitmap->map[start / 8] |= ~((1 << (8 - lub)) - 1);
    9796        }
    9897        for (i = 0; i < amb / 8; i++) {
    99                 /*
    100                  * The middle bits can be set byte by byte.
    101                  */
     98                /* The middle bits can be set byte by byte. */
    10299                bitmap->map[aligned_start / 8 + i] = ALL_ONES;
    103100        }
    104101        if (tab) {
    105                 /*
    106                  * Make sure to set any trailing aligned bits.
    107                  */
     102                /* Make sure to set any trailing aligned bits. */
    108103                bitmap->map[aligned_start / 8 + i] |= (1 << tab) - 1;
    109104        }
     
    113108/** Clear range of bits.
    114109 *
    115  * @param bitmap Bitmap structure.
    116  * @param start Starting bit.
    117  * @param bits Number of bits to clear.
     110 * @param bitmap        Bitmap structure.
     111 * @param start         Starting bit.
     112 * @param bits          Number of bits to clear.
    118113 */
    119114void bitmap_clear_range(bitmap_t *bitmap, size_t start, size_t bits)
     
    121116        size_t i = 0;
    122117        size_t aligned_start;
    123         size_t lub;             /* leading unaligned bits */
    124         size_t amb;             /* aligned middle bits */
    125         size_t tab;             /* trailing aligned bits */
     118        size_t lub;     /* leading unaligned bits */
     119        size_t amb;     /* aligned middle bits */
     120        size_t tab;     /* trailing aligned bits */
    126121       
    127122        ASSERT(start + bits <= bitmap->bits);
     
    132127        tab = amb % 8;
    133128
    134         if ( start + bits < aligned_start )
    135         {
    136             /*
    137             * Set bits in the middle of byte
    138             */
    139             bitmap->map[start / 8] &= ~(((1 << lub)-1) << (start&7));
    140             return;
     129        if (!bits)
     130                return;
     131
     132        if (start + bits < aligned_start) {
     133                /* Set bits in the middle of byte */
     134                bitmap->map[start / 8] &= ~(((1 << lub) - 1) << (start & 7));
     135                return;
    141136        }
    142137
    143 
    144138        if (lub) {
    145                 /*
    146                  * Make sure to clear any leading unaligned bits.
    147                  */
     139                /* Make sure to clear any leading unaligned bits. */
    148140                bitmap->map[start / 8] &= (1 << (8 - lub)) - 1;
    149141        }
    150142        for (i = 0; i < amb / 8; i++) {
    151                 /*
    152                  * The middle bits can be cleared byte by byte.
    153                  */
     143                /* The middle bits can be cleared byte by byte. */
    154144                bitmap->map[aligned_start / 8 + i] = ALL_ZEROES;
    155145        }
    156146        if (tab) {
    157                 /*
    158                  * Make sure to clear any trailing aligned bits.
    159                  */
     147                /* Make sure to clear any trailing aligned bits. */
    160148                bitmap->map[aligned_start / 8 + i] &= ~((1 << tab) - 1);
    161149        }
     
    165153/** Copy portion of one bitmap into another bitmap.
    166154 *
    167  * @param dst Destination bitmap.
    168  * @param src Source bitmap.
    169  * @param bits Number of bits to copy.
     155 * @param dst           Destination bitmap.
     156 * @param src           Source bitmap.
     157 * @param bits          Number of bits to copy.
    170158 */
    171159void bitmap_copy(bitmap_t *dst, bitmap_t *src, size_t bits)
  • tools/toolchain.sh

    r63a1e60 r7494fb4  
    6262        echo " ia32       IA-32 (x86, i386)"
    6363        echo " ia64       IA-64 (Itanium)"
    64         echo " mips32     MIPS little-endian"
    65         echo " mips32eb   MIPS big-endian"
     64        echo " mips32     MIPS little-endian 32b"
     65        echo " mips32eb   MIPS big-endian 32b"
     66        echo " mips64     MIPS little-endian 64b"
    6667        echo " ppc32      32-bit PowerPC"
    6768        echo " ppc64      64-bit PowerPC"
     
    303304                build_target "mips32eb" "mips-linux-gnu"
    304305                ;;
     306        "mips64")
     307                build_target "mips64" "mips64el-linux-gnu"
     308                ;;
    305309        "ppc32")
    306310                build_target "ppc32" "ppc-linux-gnu"
     
    320324                build_target "mips32" "mipsel-linux-gnu"
    321325                build_target "mips32eb" "mips-linux-gnu"
     326                build_target "mips64" "mips64el-linux-gnu"
    322327                build_target "ppc32" "ppc-linux-gnu"
    323328                build_target "ppc64" "ppc64-linux-gnu"
  • uspace/app/netstart/Makefile

    r63a1e60 r7494fb4  
    2929
    3030USPACE_PREFIX = ../..
    31 LIBS = $(LIBNET_PREFIX)/libnet.a
    32 EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
     31LIBS =
     32EXTRA_CFLAGS =
    3333
    3434BINARY = netstart
  • uspace/lib/c/generic/adt/measured_strings.c

    r63a1e60 r7494fb4  
    4141#include <unistd.h>
    4242#include <errno.h>
    43 #include <err.h>
    4443#include <async.h>
    4544
     
    135134    size_t count)
    136135{
    137         ERROR_DECLARE;
    138 
    139136        size_t *lengths;
    140137        size_t index;
     
    142139        char *next;
    143140        ipc_callid_t callid;
     141        int rc;
    144142
    145143        if ((!strings) || (!data) || (count <= 0))
     
    155153                return EINVAL;
    156154        }
    157         if (ERROR_OCCURRED(async_data_write_finalize(callid, lengths,
    158             length))) {
    159                 free(lengths);
    160                 return ERROR_CODE;
     155        rc = async_data_write_finalize(callid, lengths, length);
     156        if (rc != EOK) {
     157                free(lengths);
     158                return rc;
    161159        }
    162160
     
    187185                                return EINVAL;
    188186                        }
    189                         if (ERROR_OCCURRED(async_data_write_finalize(callid,
    190                             next, lengths[index]))) {
     187                        rc = async_data_write_finalize(callid, next,
     188                            lengths[index]);
     189                        if (rc != EOK) {
    191190                                free(*data);
    192191                                free(*strings);
    193192                                free(lengths);
    194                                 return ERROR_CODE;
     193                                return rc;
    195194                        }
    196195                        (*strings)[index].value = next;
     
    251250int measured_strings_reply(const measured_string_ref strings, size_t count)
    252251{
    253         ERROR_DECLARE;
    254 
    255252        size_t *lengths;
    256253        size_t index;
    257254        size_t length;
    258255        ipc_callid_t callid;
     256        int rc;
    259257
    260258        if ((!strings) || (count <= 0))
     
    270268                return EINVAL;
    271269        }
    272         if (ERROR_OCCURRED(async_data_read_finalize(callid, lengths, length))) {
    273                 free(lengths);
    274                 return ERROR_CODE;
     270        rc = async_data_read_finalize(callid, lengths, length);
     271        if (rc != EOK) {
     272                free(lengths);
     273                return rc;
    275274        }
    276275        free(lengths);
     
    282281                                return EINVAL;
    283282                        }
    284                         ERROR_PROPAGATE(async_data_read_finalize(callid,
    285                             strings[index].value, strings[index].length));
     283                        rc = async_data_read_finalize(callid,
     284                            strings[index].value, strings[index].length);
     285                        if (rc != EOK)
     286                                return rc;
    286287                }
    287288        }
     
    313314    size_t count)
    314315{
    315         ERROR_DECLARE;
    316 
    317316        size_t *lengths;
    318317        size_t index;
    319318        char *next;
     319        int rc;
    320320
    321321        if ((phone < 0) || (!strings) || (!data) || (count <= 0))
     
    326326                return ENOMEM;
    327327
    328         if (ERROR_OCCURRED(async_data_read_start(phone, lengths,
    329             sizeof(size_t) * (count + 1)))) {
    330                 free(lengths);
    331                 return ERROR_CODE;
     328        rc = async_data_read_start(phone, lengths,
     329            sizeof(size_t) * (count + 1));
     330        if (rc != EOK) {
     331                free(lengths);
     332                return rc;
    332333        }
    333334
     
    350351                (*strings)[index].length = lengths[index];
    351352                if (lengths[index] > 0) {
    352                         if (ERROR_OCCURRED(async_data_read_start(phone, next,
    353                             lengths[index]))) {
     353                        rc = async_data_read_start(phone, next, lengths[index]);
     354                        if (rc != EOK) {
    354355                                free(lengths);
    355356                                free(data);
    356357                                free(strings);
    357                                 return ERROR_CODE;
     358                                return rc;
    358359                        }
    359360                        (*strings)[index].value = next;
     
    387388    size_t count)
    388389{
    389         ERROR_DECLARE;
    390 
    391390        size_t *lengths;
    392391        size_t index;
     392        int rc;
    393393
    394394        if ((phone < 0) || (!strings) || (count <= 0))
     
    399399                return ENOMEM;
    400400
    401         if (ERROR_OCCURRED(async_data_write_start(phone, lengths,
    402             sizeof(size_t) * (count + 1)))) {
    403                 free(lengths);
    404                 return ERROR_CODE;
     401        rc = async_data_write_start(phone, lengths,
     402            sizeof(size_t) * (count + 1));
     403        if (rc != EOK) {
     404                free(lengths);
     405                return rc;
    405406        }
    406407
     
    409410        for (index = 0; index < count; index++) {
    410411                if (strings[index].length > 0) {
    411                         ERROR_PROPAGATE(async_data_write_start(phone,
    412                             strings[index].value, strings[index].length));
     412                        rc = async_data_write_start(phone, strings[index].value,
     413                            strings[index].length);
     414                        if (rc != EOK)
     415                                return rc;
    413416                }
    414417        }
  • uspace/lib/c/generic/net/modules.c

    r63a1e60 r7494fb4  
    4141#include <async.h>
    4242#include <malloc.h>
    43 #include <err.h>
     43#include <errno.h>
    4444#include <sys/time.h>
    4545
     
    137137    ipcarg_t arg3, async_client_conn_t client_receiver, suseconds_t timeout)
    138138{
    139         ERROR_DECLARE;
     139        int rc;
    140140       
    141141        /* Connect to the needed service */
     
    144144                /* Request the bidirectional connection */
    145145                ipcarg_t phonehash;
    146                 if (ERROR_OCCURRED(ipc_connect_to_me(phone, arg1, arg2, arg3,
    147                     &phonehash))) {
     146               
     147                rc = ipc_connect_to_me(phone, arg1, arg2, arg3, &phonehash);
     148                if (rc != EOK) {
    148149                        ipc_hangup(phone);
    149                         return ERROR_CODE;
     150                        return rc;
    150151                }
    151152                async_new_connection(phonehash, 0, NULL, client_receiver);
     
    212213int data_receive(void **data, size_t *length)
    213214{
    214         ERROR_DECLARE;
    215 
    216215        ipc_callid_t callid;
     216        int rc;
    217217
    218218        if (!data || !length)
     
    229229
    230230        // fetch the data
    231         if (ERROR_OCCURRED(async_data_write_finalize(callid, *data, *length))) {
     231        rc = async_data_write_finalize(callid, *data, *length);
     232        if (rc != EOK) {
    232233                free(data);
    233                 return ERROR_CODE;
     234                return rc;
    234235        }
    235236
  • uspace/lib/c/generic/net/packet.c

    r63a1e60 r7494fb4  
    4141#include <unistd.h>
    4242#include <errno.h>
    43 #include <err.h>
    4443
    4544#include <sys/mman.h>
     
    9190int pm_init(void)
    9291{
    93         ERROR_DECLARE;
     92        int rc;
    9493
    9594        fibril_rwlock_initialize(&pm_globals.lock);
     95       
    9696        fibril_rwlock_write_lock(&pm_globals.lock);
    97         ERROR_PROPAGATE(gpm_initialize(&pm_globals.packet_map));
     97        rc = gpm_initialize(&pm_globals.packet_map);
    9898        fibril_rwlock_write_unlock(&pm_globals.lock);
    99         return EOK;
     99       
     100        return rc;
    100101}
    101102
     
    139140int pm_add(packet_t packet)
    140141{
    141         ERROR_DECLARE;
    142 
    143142        packet_map_ref map;
     143        int rc;
    144144
    145145        if (!packet_is_valid(packet))
     
    160160                        }
    161161                        bzero(map, sizeof(packet_map_t));
    162                         if ((ERROR_CODE =
    163                             gpm_add(&pm_globals.packet_map, map)) < 0) {
     162                        rc = gpm_add(&pm_globals.packet_map, map);
     163                        if (rc < 0) {
    164164                                fibril_rwlock_write_unlock(&pm_globals.lock);
    165165                                free(map);
    166                                 return ERROR_CODE;
     166                                return rc;
    167167                        }
    168168                } while (PACKET_MAP_PAGE(packet->packet_id) >=
  • uspace/lib/c/generic/net/socket_client.c

    r63a1e60 r7494fb4  
    4343#include <stdlib.h>
    4444#include <errno.h>
    45 #include <err.h>
    4645
    4746#include <ipc/services.h>
     
    212211static void socket_connection(ipc_callid_t iid, ipc_call_t * icall)
    213212{
    214         ERROR_DECLARE;
    215 
    216213        ipc_callid_t callid;
    217214        ipc_call_t call;
    218215        socket_ref socket;
     216        int rc;
    219217
    220218loop:
     
    231229                    SOCKET_GET_SOCKET_ID(call));
    232230                if (!socket) {
    233                         ERROR_CODE = ENOTSOCK;
     231                        rc = ENOTSOCK;
    234232                        fibril_rwlock_read_unlock(&socket_globals.lock);
    235233                        break;
     
    240238                        fibril_mutex_lock(&socket->receive_lock);
    241239                        // push the number of received packet fragments
    242                         if (!ERROR_OCCURRED(dyn_fifo_push(&socket->received,
     240                        rc = dyn_fifo_push(&socket->received,
    243241                            SOCKET_GET_DATA_FRAGMENTS(call),
    244                             SOCKET_MAX_RECEIVED_SIZE))) {
     242                            SOCKET_MAX_RECEIVED_SIZE);
     243                        if (rc == EOK) {
    245244                                // signal the received packet
    246245                                fibril_condvar_signal(&socket->receive_signal);
     
    252251                        // push the new socket identifier
    253252                        fibril_mutex_lock(&socket->accept_lock);
    254                         if (!ERROR_OCCURRED(dyn_fifo_push(&socket->accepted,
    255                             1, SOCKET_MAX_ACCEPTED_SIZE))) {
     253                        rc = dyn_fifo_push(&socket->accepted, 1,
     254                            SOCKET_MAX_ACCEPTED_SIZE);
     255                        if (rc != EOK) {
    256256                                // signal the accepted socket
    257257                                fibril_condvar_signal(&socket->accept_signal);
     
    261261
    262262                default:
    263                         ERROR_CODE = ENOTSUP;
     263                        rc = ENOTSUP;
    264264                }
    265265
     
    280280
    281281        default:
    282                 ERROR_CODE = ENOTSUP;
    283         }
    284 
    285         ipc_answer_0(callid, (ipcarg_t) ERROR_CODE);
     282                rc = ENOTSUP;
     283        }
     284
     285        ipc_answer_0(callid, (ipcarg_t) rc);
    286286        goto loop;
    287287}
     
    405405int socket(int domain, int type, int protocol)
    406406{
    407         ERROR_DECLARE;
    408 
    409407        socket_ref socket;
    410408        int phone;
     
    413411        ipcarg_t fragment_size;
    414412        ipcarg_t header_size;
     413        int rc;
    415414
    416415        // find the appropriate service
     
    479478        }
    480479
    481         if (ERROR_OCCURRED((int) async_req_3_3(phone, NET_SOCKET, socket_id, 0,
    482             service, NULL, &fragment_size, &header_size))) {
     480        rc = (int) async_req_3_3(phone, NET_SOCKET, socket_id, 0, service, NULL,
     481            &fragment_size, &header_size);
     482        if (rc != EOK) {
    483483                fibril_rwlock_write_unlock(&socket_globals.lock);
    484484                free(socket);
    485                 return ERROR_CODE;
     485                return rc;
    486486        }
    487487
     
    492492        socket_initialize(socket, socket_id, phone, service);
    493493        // store the new socket
    494         ERROR_CODE = sockets_add(socket_get_sockets(), socket_id, socket);
     494        rc = sockets_add(socket_get_sockets(), socket_id, socket);
    495495
    496496        fibril_rwlock_write_unlock(&socket_globals.lock);
    497         if (ERROR_CODE < 0) {
     497        if (rc < 0) {
    498498                dyn_fifo_destroy(&socket->received);
    499499                dyn_fifo_destroy(&socket->accepted);
     
    501501                async_msg_3(phone, NET_SOCKET_CLOSE, (ipcarg_t) socket_id, 0,
    502502                    service);
    503                 return ERROR_CODE;
     503                return rc;
    504504        }
    505505
     
    770770int closesocket(int socket_id)
    771771{
    772         ERROR_DECLARE;
    773 
    774772        socket_ref socket;
     773        int rc;
    775774
    776775        fibril_rwlock_write_lock(&socket_globals.lock);
     
    787786
    788787        // request close
    789         ERROR_PROPAGATE((int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE,
    790             (ipcarg_t) socket->socket_id, 0, socket->service));
     788        rc = (int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE,
     789            (ipcarg_t) socket->socket_id, 0, socket->service);
     790        if (rc != EOK) {
     791                fibril_rwlock_write_unlock(&socket_globals.lock);
     792                return rc;
     793        }
    791794        // free the socket structure
    792795        socket_destroy(socket);
  • uspace/lib/c/include/adt/generic_char_map.h

    r63a1e60 r7494fb4  
    4040#include <unistd.h>
    4141#include <errno.h>
    42 #include <err.h>
    4342
    4443#include <adt/char_map.h>
     
    8584             type *value) \
    8685        { \
    87                 ERROR_DECLARE; \
     86                int rc; \
    8887                int index; \
    8988                if (!name##_is_valid(map)) \
     
    9291                if (index < 0) \
    9392                        return index; \
    94                 if (ERROR_OCCURRED(char_map_add(&map->names, name, length, \
    95                     index))) { \
     93                rc = char_map_add(&map->names, name, length, index); \
     94                if (rc != EOK) { \
    9695                        name##_items_exclude_index(&map->values, index); \
    97                         return ERROR_CODE; \
     96                        return rc; \
    9897                } \
    9998                return EOK; \
     
    141140        int name##_initialize(name##_ref map) \
    142141        { \
    143                 ERROR_DECLARE; \
     142                int rc; \
    144143                if (!map) \
    145144                        return EINVAL; \
    146                 ERROR_PROPAGATE(char_map_initialize(&map->names)); \
    147                 if (ERROR_OCCURRED(name##_items_initialize(&map->values))) { \
     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) { \
    148150                        char_map_destroy(&map->names); \
    149                         return ERROR_CODE; \
     151                        return rc; \
    150152                } \
    151153                map->magic = GENERIC_CHAR_MAP_MAGIC_VALUE; \
  • uspace/lib/c/include/err.h

    r63a1e60 r7494fb4  
    3737
    3838#include <stdio.h>
    39 #include <errno.h>
    40 
    41 #ifdef CONFIG_DEBUG
    42 #include <str_error.h>
    43 #endif
    4439
    4540#define errx(status, fmt, ...) { \
     
    4843}
    4944
    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 
    9845#endif
    9946
    10047/** @}
    10148 */
     49
  • uspace/lib/c/include/stdio.h

    r63a1e60 r7494fb4  
    4646#define BUFSIZ  4096
    4747
    48 #define DEBUG(fmt, ...)se\
     48#define DEBUG(fmt, ...) \
    4949        { \
    5050                char _buf[256]; \
  • uspace/lib/net/adt/module_map.c

    r63a1e60 r7494fb4  
    3838#include <task.h>
    3939#include <unistd.h>
    40 #include <err.h>
     40#include <errno.h>
    4141
    4242#include <ipc/services.h>
     
    6767    connect_module_t connect_module)
    6868{
    69         ERROR_DECLARE;
    70 
    7169        module_ref tmp_module;
     70        int rc;
    7271
    7372        tmp_module = (module_ref) malloc(sizeof(module_t));
     
    8382        tmp_module->connect_module = connect_module;
    8483
    85         if (ERROR_OCCURRED(modules_add(modules, tmp_module->name, 0,
    86             tmp_module))) {
     84        rc = modules_add(modules, tmp_module->name, 0, tmp_module);
     85        if (rc != EOK) {
    8786                free(tmp_module);
    88                 return ERROR_CODE;
     87                return rc;
    8988        }
    9089        if (module)
  • uspace/lib/net/generic/packet_remote.c

    r63a1e60 r7494fb4  
    3838#include <async.h>
    3939#include <errno.h>
    40 #include <err.h>
    4140#include <ipc/ipc.h>
    4241#include <ipc/packet.h>
     
    6766packet_return(int phone, packet_ref packet, packet_id_t packet_id, size_t size)
    6867{
    69         ERROR_DECLARE;
    70        
    7168        ipc_call_t answer;
    72         aid_t message = async_send_1(phone, NET_PACKET_GET, packet_id, &answer);
     69        aid_t message;
     70        int rc;
     71       
     72        message = async_send_1(phone, NET_PACKET_GET, packet_id, &answer);
    7373
    7474        *packet = (packet_t) as_get_mappable_page(size);
    75         if (ERROR_OCCURRED(async_share_in_start_0_0(phone, *packet, size)) ||
    76             ERROR_OCCURRED(pm_add(*packet))) {
     75        rc = async_share_in_start_0_0(phone, *packet, size);
     76        if (rc != EOK) {
    7777                munmap(*packet, size);
    7878                async_wait_for(message, NULL);
    79                 return ERROR_CODE;
     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;
    8086        }
    8187       
     
    103109int packet_translate_remote(int phone, packet_ref packet, packet_id_t packet_id)
    104110{
    105         ERROR_DECLARE;
     111        int rc;
    106112       
    107113        if (!packet)
     
    112118                ipcarg_t size;
    113119               
    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));
     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;
    117127        }
    118128        if ((*packet)->next) {
     
    141151    size_t max_prefix, size_t max_suffix)
    142152{
    143         ERROR_DECLARE;
    144        
    145153        ipcarg_t packet_id;
    146154        ipcarg_t size;
    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)))
     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)
    150160                return NULL;
    151161       
     
    153163        packet_t packet = pm_find(packet_id);
    154164        if (!packet) {
    155                 if (ERROR_OCCURRED(packet_return(phone, &packet, packet_id,
    156                     size)))
     165                rc = packet_return(phone, &packet, packet_id, size);
     166                if (rc != EOK)
    157167                        return NULL;
    158168        }
     
    172182packet_t packet_get_1_remote(int phone, size_t content)
    173183{
    174         ERROR_DECLARE;
    175        
    176184        ipcarg_t packet_id;
    177185        ipcarg_t size;
    178        
    179         if (ERROR_OCCURRED(async_req_1_2(phone, NET_PACKET_CREATE_1, content,
    180             &packet_id, &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)
    181191                return NULL;
    182192       
    183193        packet_t packet = pm_find(packet_id);
    184194        if (!packet) {
    185                 if (ERROR_OCCURRED(packet_return(phone, &packet, packet_id,
    186                     size)))
     195                rc = packet_return(phone, &packet, packet_id, size);
     196                if (rc != EOK)
    187197                        return NULL;
    188198        }
  • uspace/lib/net/netif/netif_local.c

    r63a1e60 r7494fb4  
    4343#include <ipc/services.h>
    4444#include <ipc/netif.h>
    45 #include <err.h>
     45#include <errno.h>
    4646
    4747#include <generic.h>
     
    113113int netif_start_req_local(int netif_phone, device_id_t device_id)
    114114{
    115         ERROR_DECLARE;
     115        int rc;
    116116       
    117117        fibril_rwlock_write_lock(&netif_globals.lock);
    118118       
    119119        netif_device_t *device;
    120         if (ERROR_OCCURRED(find_device(device_id, &device))) {
     120        rc = find_device(device_id, &device);
     121        if (rc != EOK) {
    121122                fibril_rwlock_write_unlock(&netif_globals.lock);
    122                 return ERROR_CODE;
     123                return rc;
    123124        }
    124125       
     
    148149int netif_stop_req_local(int netif_phone, device_id_t device_id)
    149150{
    150         ERROR_DECLARE;
     151        int rc;
    151152       
    152153        fibril_rwlock_write_lock(&netif_globals.lock);
    153154       
    154155        netif_device_t *device;
    155         if (ERROR_OCCURRED(find_device(device_id, &device))) {
     156        rc = find_device(device_id, &device);
     157        if (rc != EOK) {
    156158                fibril_rwlock_write_unlock(&netif_globals.lock);
    157                 return ERROR_CODE;
     159                return rc;
    158160        }
    159161       
     
    203205    measured_string_ref *address, char **data)
    204206{
    205         ERROR_DECLARE;
     207        int rc;
    206208       
    207209        if (!address || !data)
     
    211213       
    212214        measured_string_t translation;
    213         if (!ERROR_OCCURRED(netif_get_addr_message(device_id, &translation))) {
     215        rc = netif_get_addr_message(device_id, &translation);
     216        if (rc == EOK) {
    214217                *address = measured_string_copy(&translation);
    215                 ERROR_CODE = (*address) ? EOK : ENOMEM;
     218                rc = (*address) ? EOK : ENOMEM;
    216219        }
    217220       
     
    220223        *data = (**address).value;
    221224       
    222         return ERROR_CODE;
     225        return rc;
    223226}
    224227
     
    264267int netif_init_module(async_client_conn_t client_connection)
    265268{
    266         ERROR_DECLARE;
     269        int rc;
    267270       
    268271        async_set_client_connection(client_connection);
     
    271274        netif_device_map_initialize(&netif_globals.device_map);
    272275       
    273         ERROR_PROPAGATE(pm_init());
     276        rc = pm_init();
     277        if (rc != EOK)
     278                return rc;
    274279       
    275280        fibril_rwlock_initialize(&netif_globals.lock);
    276         if (ERROR_OCCURRED(netif_initialize())) {
     281       
     282        rc = netif_initialize();
     283        if (rc != EOK) {
    277284                pm_destroy();
    278                 return ERROR_CODE;
     285                return rc;
    279286        }
    280287       
     
    317324static int register_message(const char *name, device_id_t device_id, int phone)
    318325{
    319         ERROR_DECLARE;
    320        
    321326        netif_device_t *device;
    322         ERROR_PROPAGATE(find_device(device_id, &device));
    323         if(device->nil_phone > 0)
     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)
    324334                return ELIMIT;
    325335       
     
    349359    ipc_call_t *call, ipc_call_t *answer, int *answer_count)
    350360{
    351         ERROR_DECLARE;
    352        
    353361        size_t length;
    354362        device_stats_t stats;
    355363        packet_t packet;
    356364        measured_string_t address;
     365        int rc;
    357366       
    358367        *answer_count = 0;
     
    367376        case IPC_M_CONNECT_TO_ME:
    368377                fibril_rwlock_write_lock(&netif_globals.lock);
    369                 ERROR_CODE = register_message(name, IPC_GET_DEVICE(call),
     378                rc = register_message(name, IPC_GET_DEVICE(call),
    370379                    IPC_GET_PHONE(call));
    371380                fibril_rwlock_write_unlock(&netif_globals.lock);
    372                 return ERROR_CODE;
     381                return rc;
    373382               
    374383        case NET_NETIF_SEND:
    375                 ERROR_PROPAGATE(packet_translate_remote(netif_globals.net_phone,
    376                     &packet, IPC_GET_PACKET(call)));
     384                rc = packet_translate_remote(netif_globals.net_phone, &packet,
     385                    IPC_GET_PACKET(call));
     386                if (rc != EOK)
     387                        return rc;
    377388                return netif_send_msg_local(0, IPC_GET_DEVICE(call), packet,
    378389                    IPC_GET_SENDER(call));
    379                    
     390               
    380391        case NET_NETIF_START:
    381392                return netif_start_req_local(0, IPC_GET_DEVICE(call));
     
    384395                fibril_rwlock_read_lock(&netif_globals.lock);
    385396
    386                 if (ERROR_OCCURRED(async_data_read_receive(&callid, &length))) {
     397                rc = async_data_read_receive(&callid, &length);
     398                if (rc != EOK) {
    387399                        fibril_rwlock_read_unlock(&netif_globals.lock);
    388                         return ERROR_CODE;
     400                        return rc;
    389401                }
    390402                if (length < sizeof(device_stats_t)) {
     
    393405                }
    394406
    395                 if (ERROR_NONE(netif_get_device_stats(IPC_GET_DEVICE(call),
    396                     &stats))) {
    397                         ERROR_CODE = async_data_read_finalize(callid, &stats,
     407                rc = netif_get_device_stats(IPC_GET_DEVICE(call), &stats);
     408                if (rc == EOK) {
     409                        rc = async_data_read_finalize(callid, &stats,
    398410                            sizeof(device_stats_t));
    399411                }
    400412
    401413                fibril_rwlock_read_unlock(&netif_globals.lock);
    402                 return ERROR_CODE;
     414                return rc;
    403415
    404416        case NET_NETIF_STOP:
     
    407419        case NET_NETIF_GET_ADDR:
    408420                fibril_rwlock_read_lock(&netif_globals.lock);
    409                 if (ERROR_NONE(netif_get_addr_message(IPC_GET_DEVICE(call),
    410                     &address)))
    411                         ERROR_CODE = measured_strings_reply(&address, 1);
     421                rc = netif_get_addr_message(IPC_GET_DEVICE(call), &address);
     422                if (rc == EOK)
     423                        rc = measured_strings_reply(&address, 1);
    412424                fibril_rwlock_read_unlock(&netif_globals.lock);
    413                 return ERROR_CODE;
     425                return rc;
    414426        }
    415427       
     
    431443int netif_module_start_standalone(async_client_conn_t client_connection)
    432444{
    433         ERROR_DECLARE;
    434        
    435         ERROR_PROPAGATE(netif_init_module(client_connection));
     445        int rc;
     446       
     447        rc = netif_init_module(client_connection);
     448        if (rc != EOK)
     449                return rc;
    436450       
    437451        async_manager();
  • uspace/lib/net/tl/socket_core.c

    r63a1e60 r7494fb4  
    4848#include <stdlib.h>
    4949#include <errno.h>
    50 #include <err.h>
    5150
    5251#include <adt/dynamic_fifo.h>
     
    164163    const char *key, size_t key_length)
    165164{
    166         ERROR_DECLARE;
    167 
    168165        socket_core_ref *socket_ref;
     166        int rc;
    169167
    170168        // create a wrapper
     
    175173        *socket_ref = socket;
    176174        // add the wrapper
    177         if (ERROR_OCCURRED(socket_port_map_add(&socket_port->map, key,
    178             key_length, socket_ref))) {
     175        rc = socket_port_map_add(&socket_port->map, key, key_length,
     176            socket_ref);
     177        if (rc != EOK) {
    179178                free(socket_ref);
    180                 return ERROR_CODE;
     179                return rc;
    181180        }
    182181       
     
    204203    int port)
    205204{
    206         ERROR_DECLARE;
    207 
    208205        socket_port_ref socket_port;
     206        int rc;
    209207
    210208        // create a wrapper
     
    214212
    215213        socket_port->count = 0;
    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         }
     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;
    223222       
    224223        // register the incomming port
    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         }
     224        rc = socket_ports_add(global_sockets, port, socket_port);
     225        if (rc < 0)
     226                goto fail;
    231227       
    232228        socket->port = port;
    233229        return EOK;
     230
     231fail:
     232        socket_port_map_destroy(&socket_port->map);
     233        free(socket_port);
     234        return rc;
     235       
    234236}
    235237
     
    416418    void *specific_data, int *socket_id)
    417419{
    418         ERROR_DECLARE;
    419 
    420420        socket_core_ref socket;
    421         int res;
    422421        int positive;
     422        int rc;
    423423
    424424        if (!socket_id)
     
    447447        socket->key_length = 0;
    448448        socket->specific_data = specific_data;
    449         if (ERROR_OCCURRED(dyn_fifo_initialize(&socket->received,
    450             SOCKET_INITIAL_RECEIVED_SIZE))) {
     449        rc = dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE);
     450        if (rc != EOK) {
    451451                free(socket);
    452                 return ERROR_CODE;
    453         }
    454         if (ERROR_OCCURRED(dyn_fifo_initialize(&socket->accepted,
    455             SOCKET_INITIAL_ACCEPTED_SIZE))) {
     452                return rc;
     453        }
     454       
     455        rc = dyn_fifo_initialize(&socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE);
     456        if (rc != EOK) {
    456457                dyn_fifo_destroy(&socket->received);
    457458                free(socket);
    458                 return ERROR_CODE;
     459                return rc;
    459460        }
    460461        socket->socket_id = *socket_id;
    461         res = socket_cores_add(local_sockets, socket->socket_id, socket);
    462         if (res < 0) {
     462        rc = socket_cores_add(local_sockets, socket->socket_id, socket);
     463        if (rc < 0) {
    463464                dyn_fifo_destroy(&socket->received);
    464465                dyn_fifo_destroy(&socket->accepted);
    465466                free(socket);
    466                 return res;
     467                return rc;
    467468        }
    468469       
     
    523524int socket_reply_packets(packet_t packet, size_t *length)
    524525{
    525         ERROR_DECLARE;
    526 
    527526        packet_t next_packet;
    528527        size_t fragments;
    529528        size_t *lengths;
    530529        size_t index;
     530        int rc;
    531531
    532532        if (!length)
     
    536536        if (!next_packet) {
    537537                // write all if only one fragment
    538                 ERROR_PROPAGATE(data_reply(packet_get_data(packet),
    539                     packet_get_data_length(packet)));
     538                rc = data_reply(packet_get_data(packet),
     539                    packet_get_data_length(packet));
     540                if (rc != EOK)
     541                        return rc;
    540542                // store the total length
    541543                *length = packet_get_data_length(packet);
     
    564566               
    565567                // write the fragment lengths
    566                 if (ERROR_OCCURRED(data_reply(lengths,
    567                     sizeof(int) * (fragments + 1)))) {
     568                rc = data_reply(lengths, sizeof(int) * (fragments + 1));
     569                if (rc != EOK) {
    568570                        free(lengths);
    569                         return ERROR_CODE;
     571                        return rc;
    570572                }
    571573                next_packet = packet;
     
    573575                // write the fragments
    574576                for (index = 0; index < fragments; ++index) {
    575                         ERROR_CODE = data_reply(packet_get_data(next_packet),
     577                        rc = data_reply(packet_get_data(next_packet),
    576578                            lengths[index]);
    577                         if (ERROR_OCCURRED(ERROR_CODE)) {
     579                        if (rc != EOK) {
    578580                                free(lengths);
    579                                 return ERROR_CODE;
     581                                return rc;
    580582                        }
    581583                        next_packet = pq_next(next_packet);
     
    680682    socket_core_ref socket, const char *key, size_t key_length)
    681683{
    682         ERROR_DECLARE;
    683 
    684684        socket_port_ref socket_port;
     685        int rc;
    685686
    686687        // find ports
     
    690691       
    691692        // add the socket
    692         ERROR_PROPAGATE(socket_port_add_core(socket_port, socket, key,
    693             key_length));
     693        rc = socket_port_add_core(socket_port, socket, key, key_length);
     694        if (rc != EOK)
     695                return rc;
    694696       
    695697        socket->port = port;
  • uspace/lib/net/tl/tl_common.c

    r63a1e60 r7494fb4  
    5454#include <ipc/services.h>
    5555#include <errno.h>
    56 #include <err.h>
    5756
    5857DEVICE_MAP_IMPLEMENT(packet_dimensions, packet_dimension_t);
     
    124123    packet_dimension_ref *packet_dimension)
    125124{
    126         ERROR_DECLARE;
     125        int rc;
    127126       
    128127        if (!packet_dimension)
     
    137136                        return ENOMEM;
    138137               
    139                 if (ERROR_OCCURRED(ip_packet_size_req(ip_phone, device_id,
    140                     *packet_dimension))) {
     138                rc = ip_packet_size_req(ip_phone, device_id, *packet_dimension);
     139                if (rc != EOK) {
    141140                        free(*packet_dimension);
    142                         return ERROR_CODE;
     141                        return rc;
    143142                }
    144143               
    145                 ERROR_CODE = packet_dimensions_add(packet_dimensions, device_id,
     144                rc = packet_dimensions_add(packet_dimensions, device_id,
    146145                    *packet_dimension);
    147                 if (ERROR_CODE < 0) {
     146                if (rc < 0) {
    148147                        free(*packet_dimension);
    149                         return ERROR_CODE;
     148                        return rc;
    150149                }
    151150        }
     
    292291    socklen_t addrlen)
    293292{
    294         ERROR_DECLARE;
    295 
    296293        ipc_callid_t callid;
    297294        size_t length;
    298         void * data;
     295        void *data;
     296        int rc;
    299297
    300298        if (!dimension)
     
    319317
    320318        // read the data into the packet
    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))) {
     319        rc = async_data_write_finalize(callid, data, length);
     320        if (rc != EOK) {
    325321                pq_release_remote(packet_phone, packet_get_id(*packet));
    326                 return ERROR_CODE;
     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;
    327330        }
    328331
  • uspace/lib/packet/generic/packet_server.c

    r63a1e60 r7494fb4  
    4242#include <async.h>
    4343#include <errno.h>
    44 #include <err.h>
    4544#include <fibril_synch.h>
    4645#include <unistd.h>
     
    162161    size_t max_content, size_t max_suffix)
    163162{
    164         ERROR_DECLARE;
    165 
    166163        packet_t packet;
     164        int rc;
    167165
    168166        // already locked
     
    177175        packet_init(packet, addr_len, max_prefix, max_content, max_suffix);
    178176        packet->magic_value = PACKET_MAGIC_VALUE;
    179         if (ERROR_OCCURRED(pm_add(packet))) {
     177        rc = pm_add(packet);
     178        if (rc != EOK) {
    180179                munmap(packet, packet->length);
    181180                return NULL;
  • uspace/srv/hw/netif/dp8390/dp8390.h

    r63a1e60 r7494fb4  
    4343/** Input/output size.
    4444 */
    45 #define DP8390_IO_SIZE  0x01f
     45#define DP8390_IO_SIZE  0x020
    4646
    4747/*
  • uspace/srv/hw/netif/dp8390/dp8390_module.c

    r63a1e60 r7494fb4  
    158158
    159159int netif_get_device_stats(device_id_t device_id, device_stats_ref stats){
    160         ERROR_DECLARE;
    161 
    162160        netif_device_t * device;
    163161        eth_stat_t * de_stat;
     162        int rc;
    164163
    165164        if(! stats){
    166165                return EBADMEM;
    167166        }
    168         ERROR_PROPAGATE(find_device(device_id, &device));
     167        rc = find_device(device_id, &device);
     168        if (rc != EOK)
     169                return rc;
    169170        de_stat = &((dpeth_t *) device->specific)->de_stat;
    170171        null_device_stats(stats);
     
    185186
    186187int netif_get_addr_message(device_id_t device_id, measured_string_ref address){
    187         ERROR_DECLARE;
    188 
    189         netif_device_t * device;
     188        netif_device_t * device;
     189        int rc;
    190190
    191191        if(! address){
    192192                return EBADMEM;
    193193        }
    194         ERROR_PROPAGATE(find_device(device_id, &device));
     194        rc = find_device(device_id, &device);
     195        if (rc != EOK)
     196                return rc;
    195197        address->value = (char *) (&((dpeth_t *) device->specific)->de_address);
    196198        address->length = CONVERT_SIZE(ether_addr_t, char, 1);
     
    201203
    202204int netif_probe_message(device_id_t device_id, int irq, uintptr_t io){
    203         ERROR_DECLARE;
    204 
    205         netif_device_t * device;
    206         dpeth_t * dep;
     205        netif_device_t * device;
     206        dpeth_t * dep;
     207        int rc;
    207208
    208209        device = (netif_device_t *) malloc(sizeof(netif_device_t));
     
    224225        dep->de_mode = DEM_DISABLED;
    225226        //TODO address?
    226         if(ERROR_OCCURRED(pio_enable((void *) io, DP8390_IO_SIZE, (void **) &dep->de_base_port))
    227                 || ERROR_OCCURRED(do_probe(dep))){
     227        rc = pio_enable((void *) io, DP8390_IO_SIZE, (void **) &dep->de_base_port);
     228        if (rc != EOK) {
    228229                free(dep);
    229230                free(device);
    230                 return ERROR_CODE;
    231         }
    232         if(ERROR_OCCURRED(netif_device_map_add(&netif_globals.device_map, device->device_id, device))){
     231                return rc;
     232        }       
     233        rc = do_probe(dep);
     234        if (rc != EOK) {
    233235                free(dep);
    234236                free(device);
    235                 return ERROR_CODE;
     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;
    236244        }
    237245        return EOK;
     
    239247
    240248int netif_send_message(device_id_t device_id, packet_t packet, services_t sender){
    241         ERROR_DECLARE;
    242 
    243249        netif_device_t * device;
    244250        dpeth_t * dep;
    245251        packet_t next;
    246 
    247         ERROR_PROPAGATE(find_device(device_id, &device));
     252        int rc;
     253
     254        rc = find_device(device_id, &device);
     255        if (rc != EOK)
     256                return rc;
    248257        if(device->state != NETIF_ACTIVE){
    249258                netif_pq_release(packet_get_id(packet));
     
    263272
    264273int netif_start_message(netif_device_t * device){
    265         ERROR_DECLARE;
    266 
    267         dpeth_t * dep;
     274        dpeth_t * dep;
     275        int rc;
    268276
    269277        if(device->state != NETIF_ACTIVE){
     
    271279                dp8390_cmds[0].addr = (void *) (uintptr_t) (dep->de_dp8390_port + DP_ISR);
    272280                dp8390_cmds[2].addr = dp8390_cmds[0].addr;
    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))){
     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) {
    275286                        ipc_unregister_irq(dep->de_irq, device->device_id);
    276                         return ERROR_CODE;
     287                        return rc;
    277288                }
    278289                return change_state(device, NETIF_ACTIVE);
     
    350361int main(int argc, char *argv[])
    351362{
    352         ERROR_DECLARE;
     363        int rc;
    353364       
    354365        /* Start the module */
    355         if (ERROR_OCCURRED(netif_module_start(netif_client_connection)))
    356                 return ERROR_CODE;
    357        
    358         return EOK;
     366        rc = netif_module_start(netif_client_connection);
     367        return rc;
    359368}
    360369
  • uspace/srv/net/net/net.c

    r63a1e60 r7494fb4  
    4242#include <ddi.h>
    4343#include <errno.h>
    44 #include <err.h>
    4544#include <malloc.h>
    4645#include <stdio.h>
     
    9291    const char *value)
    9392{
    94         ERROR_DECLARE;
     93        int rc;
    9594       
    9695        measured_string_ref setting =
     
    10099       
    101100        /* Add the configuration setting */
    102         if (ERROR_OCCURRED(measured_strings_add(configuration, name, 0, setting))) {
     101        rc = measured_strings_add(configuration, name, 0, setting);
     102        if (rc != EOK) {
    103103                free(setting);
    104                 return ERROR_CODE;
     104                return rc;
    105105        }
    106106       
     
    110110/** Generate new system-unique device identifier.
    111111 *
    112  * @returns The system-unique devic identifier.
    113  *
     112 * @returns             The system-unique devic identifier.
    114113 */
    115114static device_id_t generate_new_device_id(void)
     
    120119static int parse_line(measured_strings_ref configuration, char *line)
    121120{
    122         ERROR_DECLARE;
     121        int rc;
    123122       
    124123        /* From the beginning */
     
    170169       
    171170        /* Add the configuration setting */
    172         if (ERROR_OCCURRED(measured_strings_add(configuration, name, 0, setting))) {
     171        rc = measured_strings_add(configuration, name, 0, setting);
     172        if (rc != EOK) {
    173173                free(setting);
    174                 return ERROR_CODE;
     174                return rc;
    175175        }
    176176       
     
    181181    measured_strings_ref configuration)
    182182{
    183         ERROR_DECLARE;
    184        
    185183        printf("%s: Reading configuration file %s/%s\n", NAME, directory, filename);
    186184       
     
    206204                        if (index >= BUFFER_SIZE) {
    207205                                line[BUFFER_SIZE - 1] = '\0';
    208                                 fprintf(stderr, "%s: Configuration line %u too long: %s\n",
    209                                     NAME, line_number, line);
     206                                fprintf(stderr, "%s: Configuration line %u too "
     207                                    "long: %s\n", NAME, line_number, line);
    210208                               
    211209                                /* No space left in the line buffer */
    212210                                return EOVERFLOW;
    213                         } else {
    214                                 /* Append the character */
    215                                 line[index] = (char) read;
    216                                 index++;
    217211                        }
     212                        /* Append the character */
     213                        line[index] = (char) read;
     214                        index++;
    218215                } else {
    219216                        /* On error or new line */
    220217                        line[index] = '\0';
    221218                        line_number++;
    222                         if (ERROR_OCCURRED(parse_line(configuration, line)))
    223                                 fprintf(stderr, "%s: Configuration error on line %u: %s\n",
    224                                     NAME, line_number, line);
     219                        if (parse_line(configuration, line) != EOK) {
     220                                fprintf(stderr, "%s: Configuration error on "
     221                                    "line %u: %s\n", NAME, line_number, line);
     222                        }
    225223                       
    226224                        index = 0;
     
    270268static int net_initialize(async_client_conn_t client_connection)
    271269{
    272         ERROR_DECLARE;
     270        int rc;
    273271       
    274272        netifs_initialize(&net_globals.netifs);
     
    278276       
    279277        // TODO: dynamic configuration
    280         ERROR_PROPAGATE(read_configuration());
    281        
    282         ERROR_PROPAGATE(add_module(NULL, &net_globals.modules,
    283             LO_NAME, LO_FILENAME, SERVICE_LO, 0, connect_to_service));
    284         ERROR_PROPAGATE(add_module(NULL, &net_globals.modules,
    285             DP8390_NAME, DP8390_FILENAME, SERVICE_DP8390, 0, connect_to_service));
    286         ERROR_PROPAGATE(add_module(NULL, &net_globals.modules,
    287             ETHERNET_NAME, ETHERNET_FILENAME, SERVICE_ETHERNET, 0,
    288             connect_to_service));
    289         ERROR_PROPAGATE(add_module(NULL, &net_globals.modules,
    290             NILDUMMY_NAME, NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0,
    291             connect_to_service));
     278        rc = read_configuration();
     279        if (rc != EOK)
     280                return rc;
     281       
     282        rc = add_module(NULL, &net_globals.modules, LO_NAME, LO_FILENAME,
     283            SERVICE_LO, 0, connect_to_service);
     284        if (rc != EOK)
     285                return rc;
     286        rc = add_module(NULL, &net_globals.modules, DP8390_NAME,
     287            DP8390_FILENAME, SERVICE_DP8390, 0, connect_to_service);
     288        if (rc != EOK)
     289                return rc;
     290        rc = add_module(NULL, &net_globals.modules, ETHERNET_NAME,
     291            ETHERNET_FILENAME, SERVICE_ETHERNET, 0, connect_to_service);
     292        if (rc != EOK)
     293                return rc;
     294        rc = add_module(NULL, &net_globals.modules, NILDUMMY_NAME,
     295            NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0, connect_to_service);
     296        if (rc != EOK)
     297                return rc;
    292298       
    293299        /* Build specific initialization */
     
    314320static int net_module_start(async_client_conn_t client_connection)
    315321{
    316         ERROR_DECLARE;
     322        ipcarg_t phonehash;
     323        int rc;
    317324       
    318325        async_set_client_connection(client_connection);
    319         ERROR_PROPAGATE(pm_init());
    320        
    321         ipcarg_t phonehash;
    322        
    323         if (ERROR_OCCURRED(net_initialize(client_connection)) ||
    324             ERROR_OCCURRED(REGISTER_ME(SERVICE_NETWORKING, &phonehash))) {
    325                 pm_destroy();
    326                 return ERROR_CODE;
    327         }
     326        rc = pm_init();
     327        if (rc != EOK)
     328                return rc;
     329       
     330       
     331        rc = net_initialize(client_connection);
     332        if (rc != EOK)
     333                goto out;
     334       
     335        rc = REGISTER_ME(SERVICE_NETWORKING, &phonehash);
     336        if (rc != EOK)
     337                goto out;
    328338       
    329339        async_manager();
    330        
     340
     341out:
    331342        pm_destroy();
    332         return EOK;
     343        return rc;
    333344}
    334345
     
    415426static int start_device(netif_t *netif)
    416427{
    417         ERROR_DECLARE;
     428        int rc;
    418429       
    419430        /* Mandatory netif */
     
    456467        int io = setting ? strtol(setting->value, NULL, 16) : 0;
    457468       
    458         ERROR_PROPAGATE(netif_probe_req_remote(netif->driver->phone, netif->id, irq, io));
     469        rc = netif_probe_req_remote(netif->driver->phone, netif->id, irq, io);
     470        if (rc != EOK)
     471                return rc;
    459472       
    460473        /* Network interface layer startup */
     
    468481                int mtu = setting ? strtol(setting->value, NULL, 10) : 0;
    469482               
    470                 ERROR_PROPAGATE(nil_device_req(netif->nil->phone, netif->id, mtu,
    471                     netif->driver->service));
     483                rc = nil_device_req(netif->nil->phone, netif->id, mtu,
     484                    netif->driver->service);
     485                if (rc != EOK)
     486                        return rc;
    472487               
    473488                internet_service = netif->nil->service;
     
    478493        switch (netif->il->service) {
    479494        case SERVICE_IP:
    480                 ERROR_PROPAGATE(ip_device_req(netif->il->phone, netif->id,
    481                     internet_service));
     495                rc = ip_device_req(netif->il->phone, netif->id,
     496                    internet_service);
     497                if (rc != EOK)
     498                        return rc;
    482499                break;
    483500        default:
     
    485502        }
    486503       
    487         ERROR_PROPAGATE(netif_start_req_remote(netif->driver->phone, netif->id));
    488         return EOK;
     504        return netif_start_req_remote(netif->driver->phone, netif->id);
    489505}
    490506
     
    504520static int startup(void)
    505521{
    506         ERROR_DECLARE;
    507        
    508522        const char *conf_files[] = {
    509523                "lo",
     
    511525        };
    512526        size_t count = sizeof(conf_files) / sizeof(char *);
     527        int rc;
    513528       
    514529        size_t i;
     
    522537                        return EXDEV;
    523538               
    524                 ERROR_PROPAGATE(measured_strings_initialize(&netif->configuration));
     539                rc = measured_strings_initialize(&netif->configuration);
     540                if (rc != EOK)
     541                        return rc;
    525542               
    526543                /* Read configuration files */
    527                 if (ERROR_OCCURRED(read_netif_configuration(conf_files[i], netif))) {
     544                rc = read_netif_configuration(conf_files[i], netif);
     545                if (rc != EOK) {
    528546                        measured_strings_destroy(&netif->configuration);
    529547                        free(netif);
    530                         return ERROR_CODE;
     548                        return rc;
    531549                }
    532550               
     
    554572                 * and needed modules.
    555573                 */
    556                 if ((ERROR_OCCURRED(char_map_add(&net_globals.netif_names,
    557                     netif->name, 0, index))) || (ERROR_OCCURRED(start_device(netif)))) {
     574                rc = char_map_add(&net_globals.netif_names, netif->name, 0,
     575                    index);
     576                if (rc != EOK) {
    558577                        measured_strings_destroy(&netif->configuration);
    559578                        netifs_exclude_index(&net_globals.netifs, index);
    560                         return ERROR_CODE;
     579                        return rc;
     580                }
     581               
     582                rc = start_device(netif);
     583                if (rc != EOK) {
     584                        measured_strings_destroy(&netif->configuration);
     585                        netifs_exclude_index(&net_globals.netifs, index);
     586                        return rc;
    561587                }
    562588               
     
    594620    int *answer_count)
    595621{
    596         ERROR_DECLARE;
    597        
    598622        measured_string_ref strings;
    599623        char *data;
     624        int rc;
    600625       
    601626        *answer_count = 0;
     
    604629                return EOK;
    605630        case NET_NET_GET_DEVICE_CONF:
    606                 ERROR_PROPAGATE(measured_strings_receive(&strings, &data,
    607                     IPC_GET_COUNT(call)));
     631                rc = measured_strings_receive(&strings, &data,
     632                    IPC_GET_COUNT(call));
     633                if (rc != EOK)
     634                        return rc;
    608635                net_get_device_conf_req(0, IPC_GET_DEVICE(call), &strings,
    609636                    IPC_GET_COUNT(call), NULL);
     
    612639                free(data);
    613640               
    614                 ERROR_CODE = measured_strings_reply(strings, IPC_GET_COUNT(call));
     641                rc = measured_strings_reply(strings, IPC_GET_COUNT(call));
    615642                free(strings);
    616                 return ERROR_CODE;
     643                return rc;
    617644        case NET_NET_GET_CONF:
    618                 ERROR_PROPAGATE(measured_strings_receive(&strings, &data,
    619                     IPC_GET_COUNT(call)));
     645                rc = measured_strings_receive(&strings, &data,
     646                    IPC_GET_COUNT(call));
     647                if (rc != EOK)
     648                        return rc;
    620649                net_get_conf_req(0, &strings, IPC_GET_COUNT(call), NULL);
    621650               
     
    623652                free(data);
    624653               
    625                 ERROR_CODE = measured_strings_reply(strings, IPC_GET_COUNT(call));
     654                rc = measured_strings_reply(strings, IPC_GET_COUNT(call));
    626655                free(strings);
    627                 return ERROR_CODE;
     656                return rc;
    628657        case NET_NET_STARTUP:
    629658                return startup();
    630659        }
     660       
    631661        return ENOTSUP;
    632662}
     
    670700int main(int argc, char *argv[])
    671701{
    672         ERROR_DECLARE;
    673        
    674         if (ERROR_OCCURRED(net_module_start(net_client_connection))) {
    675                 fprintf(stderr, "%s: net_module_start error %i\n", NAME, ERROR_CODE);
    676                 return ERROR_CODE;
     702        int rc;
     703       
     704        rc = net_module_start(net_client_connection);
     705        if (rc != EOK) {
     706                fprintf(stderr, "%s: net_module_start error %i\n", NAME, rc);
     707                return rc;
    677708        }
    678709       
  • uspace/srv/net/net/net_standalone.c

    r63a1e60 r7494fb4  
    4242#include <ipc/ipc.h>
    4343#include <ipc/net.h>
     44#include <errno.h>
    4445
    4546#include <ip_interface.h>
     
    6061int net_initialize_build(async_client_conn_t client_connection)
    6162{
    62         ERROR_DECLARE;
     63        int rc;
    6364       
    6465        task_id_t task_id = spawn("/srv/ip");
     
    6667                return EINVAL;
    6768       
    68         ERROR_PROPAGATE(add_module(NULL, &net_globals.modules, IP_NAME,
    69             IP_FILENAME, SERVICE_IP, task_id, ip_connect_module));
     69        rc = add_module(NULL, &net_globals.modules, IP_NAME,
     70            IP_FILENAME, SERVICE_IP, task_id, ip_connect_module);
     71        if (rc != EOK)
     72                return rc;
    7073       
    7174        if (!spawn("/srv/icmp"))
Note: See TracChangeset for help on using the changeset viewer.