Changeset cb569e6 in mainline for uspace/lib/c


Ignore:
Timestamp:
2010-11-18T21:58:27Z (15 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
4e5c7ba
Parents:
69e0d6d (diff), 45f04f8 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

Location:
uspace/lib/c
Files:
1 deleted
17 edited

Legend:

Unmodified
Added
Removed

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

    r69e0d6d rcb569e6  
    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/devman.c

    r69e0d6d rcb569e6  
    141141
    142142int devman_child_device_register(
    143         const char *name, match_id_list_t *match_ids, device_handle_t parent_handle, device_handle_t *handle)
     143        const char *name, match_id_list_t *match_ids, devman_handle_t parent_handle, devman_handle_t *handle)
    144144{               
    145145        int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING);
    … …  
    180180}
    181181
    182 int devman_add_device_to_class(device_handle_t dev_handle, const char *class_name)
     182int devman_add_device_to_class(devman_handle_t devman_handle, const char *class_name)
    183183{
    184184        int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING);
    … …  
    189189        async_serialize_start();
    190190        ipc_call_t answer;
    191         aid_t req = async_send_1(phone, DEVMAN_ADD_DEVICE_TO_CLASS, dev_handle, &answer);
     191        aid_t req = async_send_1(phone, DEVMAN_ADD_DEVICE_TO_CLASS, devman_handle, &answer);
    192192       
    193193        ipcarg_t retval = async_data_write_start(phone, class_name, str_size(class_name));
    … …  
    224224}
    225225
    226 int devman_device_connect(device_handle_t handle, unsigned int flags)
     226int devman_device_connect(devman_handle_t handle, unsigned int flags)
    227227{
    228228        int phone;
    … …  
    239239}
    240240
    241 int devman_parent_device_connect(device_handle_t handle, unsigned int flags)
     241int devman_parent_device_connect(devman_handle_t handle, unsigned int flags)
    242242{
    243243        int phone;
    … …  
    254254}
    255255
    256 int devman_device_get_handle(const char *pathname, device_handle_t *handle, unsigned int flags)
     256int devman_device_get_handle(const char *pathname, devman_handle_t *handle, unsigned int flags)
    257257{
    258258        int phone = devman_get_phone(DEVMAN_CLIENT, flags);
    … …  
    280280        if (retval != EOK) {
    281281                if (handle != NULL)
    282                         *handle = (device_handle_t) -1;
     282                        *handle = (devman_handle_t) -1;
    283283                return retval;
    284284        }
    285285       
    286286        if (handle != NULL)
    287                 *handle = (device_handle_t) IPC_GET_ARG1(answer);
     287                *handle = (devman_handle_t) IPC_GET_ARG1(answer);
    288288       
    289289        return retval;

  • uspace/lib/c/generic/devmap.c

    r69e0d6d rcb569e6  
    132132 *
    133133 */
    134 int devmap_device_register(const char *fqdn, dev_handle_t *handle)
     134int devmap_device_register(const char *fqdn, devmap_handle_t *handle)
    135135{
    136136        int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING);
    … …  
    163163       
    164164        if (handle != NULL)
    165                 *handle = (dev_handle_t) IPC_GET_ARG1(answer);
     165                *handle = (devmap_handle_t) IPC_GET_ARG1(answer);
    166166       
    167167        return retval;
    168168}
    169169
    170 int devmap_device_get_handle(const char *fqdn, dev_handle_t *handle, unsigned int flags)
     170int devmap_device_get_handle(const char *fqdn, devmap_handle_t *handle, unsigned int flags)
    171171{
    172172        int phone = devmap_get_phone(DEVMAP_CLIENT, flags);
    … …  
    194194        if (retval != EOK) {
    195195                if (handle != NULL)
    196                         *handle = (dev_handle_t) -1;
     196                        *handle = (devmap_handle_t) -1;
    197197                return retval;
    198198        }
    199199       
    200200        if (handle != NULL)
    201                 *handle = (dev_handle_t) IPC_GET_ARG1(answer);
     201                *handle = (devmap_handle_t) IPC_GET_ARG1(answer);
    202202       
    203203        return retval;
    204204}
    205205
    206 int devmap_namespace_get_handle(const char *name, dev_handle_t *handle, unsigned int flags)
     206int devmap_namespace_get_handle(const char *name, devmap_handle_t *handle, unsigned int flags)
    207207{
    208208        int phone = devmap_get_phone(DEVMAP_CLIENT, flags);
    … …  
    230230        if (retval != EOK) {
    231231                if (handle != NULL)
    232                         *handle = (dev_handle_t) -1;
     232                        *handle = (devmap_handle_t) -1;
    233233                return retval;
    234234        }
    235235       
    236236        if (handle != NULL)
    237                 *handle = (dev_handle_t) IPC_GET_ARG1(answer);
     237                *handle = (devmap_handle_t) IPC_GET_ARG1(answer);
    238238       
    239239        return retval;
    240240}
    241241
    242 devmap_handle_type_t devmap_handle_probe(dev_handle_t handle)
     242devmap_handle_type_t devmap_handle_probe(devmap_handle_t handle)
    243243{
    244244        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
    … …  
    255255}
    256256
    257 int devmap_device_connect(dev_handle_t handle, unsigned int flags)
     257int devmap_device_connect(devmap_handle_t handle, unsigned int flags)
    258258{
    259259        int phone;
    … …  
    305305}
    306306
    307 static size_t devmap_count_devices_internal(int phone, dev_handle_t ns_handle)
     307static size_t devmap_count_devices_internal(int phone, devmap_handle_t ns_handle)
    308308{
    309309        ipcarg_t count;
    … …  
    325325}
    326326
    327 size_t devmap_count_devices(dev_handle_t ns_handle)
     327size_t devmap_count_devices(devmap_handle_t ns_handle)
    328328{
    329329        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
    … …  
    387387}
    388388
    389 size_t devmap_get_devices(dev_handle_t ns_handle, dev_desc_t **data)
     389size_t devmap_get_devices(devmap_handle_t ns_handle, dev_desc_t **data)
    390390{
    391391        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);

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

    r69e0d6d rcb569e6  
    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

    r69e0d6d rcb569e6  
    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

    r69e0d6d rcb569e6  
    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/generic/vfs/vfs.c

    r69e0d6d rcb569e6  
    136136        }
    137137       
    138         dev_handle_t dev_handle;
    139         int res = devmap_device_get_handle(fqdn, &dev_handle, flags);
     138        devmap_handle_t devmap_handle;
     139        int res = devmap_device_get_handle(fqdn, &devmap_handle, flags);
    140140        if (res != EOK) {
    141141                if (null_id != -1)
    … …  
    159159       
    160160        ipcarg_t rc_orig;
    161         aid_t req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL);
     161        aid_t req = async_send_2(vfs_phone, VFS_IN_MOUNT, devmap_handle, flags, NULL);
    162162        ipcarg_t rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
    163163        if (rc != EOK) {
    … …  
    328328        ipc_call_t answer;
    329329        aid_t req = async_send_4(vfs_phone, VFS_IN_OPEN_NODE, node->fs_handle,
    330             node->dev_handle, node->index, oflag, &answer);
     330            node->devmap_handle, node->index, oflag, &answer);
    331331       
    332332        ipcarg_t rc;
    … …  
    797797        if (rc == EOK) {
    798798                node->fs_handle = stat.fs_handle;
    799                 node->dev_handle = stat.dev_handle;
     799                node->devmap_handle = stat.devmap_handle;
    800800                node->index = stat.index;
    801801        }

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

    r69e0d6d rcb569e6  
    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/devman.h

    r69e0d6d rcb569e6  
    4242
    4343
    44 int devman_get_phone(devman_interface_t, unsigned int);
    45 void devman_hangup_phone(devman_interface_t iface);
     44extern int devman_get_phone(devman_interface_t, unsigned int);
     45extern void devman_hangup_phone(devman_interface_t);
    4646
    47 int devman_driver_register(const char *, async_client_conn_t);
    48 int devman_child_device_register(const char *, match_id_list_t *, device_handle_t, device_handle_t *);
     47extern int devman_driver_register(const char *, async_client_conn_t);
     48extern int devman_child_device_register(const char *, match_id_list_t *,
     49    devman_handle_t, devman_handle_t *);
    4950
    50 int devman_device_connect(device_handle_t handle, unsigned int flags);
    51 int devman_parent_device_connect(device_handle_t handle, unsigned int flags);
     51extern int devman_device_connect(devman_handle_t, unsigned int);
     52extern int devman_parent_device_connect(devman_handle_t, unsigned int);
    5253
    53 int devman_device_get_handle(const char *pathname, device_handle_t *handle, unsigned int flags);
     54extern int devman_device_get_handle(const char *, devman_handle_t *,
     55    unsigned int);
    5456
    55 int devman_add_device_to_class(device_handle_t dev_handle, const char *class_name);
     57extern int devman_add_device_to_class(devman_handle_t, const char *);
    5658
    5759#endif

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

    r69e0d6d rcb569e6  
    4444
    4545extern int devmap_driver_register(const char *, async_client_conn_t);
    46 extern int devmap_device_register(const char *, dev_handle_t *);
     46extern int devmap_device_register(const char *, devmap_handle_t *);
    4747
    48 extern int devmap_device_get_handle(const char *, dev_handle_t *, unsigned int);
    49 extern int devmap_namespace_get_handle(const char *, dev_handle_t *, unsigned int);
    50 extern devmap_handle_type_t devmap_handle_probe(dev_handle_t);
     48extern int devmap_device_get_handle(const char *, devmap_handle_t *, unsigned int);
     49extern int devmap_namespace_get_handle(const char *, devmap_handle_t *, unsigned int);
     50extern devmap_handle_type_t devmap_handle_probe(devmap_handle_t);
    5151
    52 extern int devmap_device_connect(dev_handle_t, unsigned int);
     52extern int devmap_device_connect(devmap_handle_t, unsigned int);
    5353
    5454extern int devmap_null_create(void);
    … …  
    5656
    5757extern size_t devmap_count_namespaces(void);
    58 extern size_t devmap_count_devices(dev_handle_t);
     58extern size_t devmap_count_devices(devmap_handle_t);
    5959
    6060extern size_t devmap_get_namespaces(dev_desc_t **);
    61 extern size_t devmap_get_devices(dev_handle_t, dev_desc_t **);
     61extern size_t devmap_get_devices(devmap_handle_t, dev_desc_t **);
    6262
    6363#endif

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

    r69e0d6d rcb569e6  
    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/ipc/devman.h

    r69e0d6d rcb569e6  
    4242#define DEVMAN_NAME_MAXLEN 256
    4343
    44 typedef ipcarg_t device_handle_t;
     44typedef ipcarg_t devman_handle_t;
    4545
    4646/** Ids of device models used for device-to-driver matching.

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

    r69e0d6d rcb569e6  
    4040#define DEVMAP_NAME_MAXLEN  255
    4141
    42 typedef ipcarg_t dev_handle_t;
     42typedef ipcarg_t devmap_handle_t;
    4343
    4444typedef enum {
    … …  
    8181
    8282typedef struct {
    83         dev_handle_t handle;
     83        devmap_handle_t handle;
    8484        char name[DEVMAP_NAME_MAXLEN + 1];
    8585} dev_desc_t;

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

    r69e0d6d rcb569e6  
    4646#define BUFSIZ  4096
    4747
    48 #define DEBUG(fmt, ...)se\
     48#define DEBUG(fmt, ...) \
    4949        { \
    5050                char _buf[256]; \

  • uspace/lib/c/include/sys/stat.h

    r69e0d6d rcb569e6  
    4343struct stat {
    4444        fs_handle_t fs_handle;
    45         dev_handle_t dev_handle;
     45        devmap_handle_t devmap_handle;
    4646        fs_index_t index;
    4747        unsigned int lnkcnt;
    … …  
    4949        bool is_directory;
    5050        aoff64_t size;
    51         dev_handle_t device;
     51        devmap_handle_t device;
    5252};
    5353

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

    r69e0d6d rcb569e6  
    4141
    4242#ifndef NULL
    43         #define NULL  0
     43        #define NULL  0UL
    4444#endif
    4545

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

    r69e0d6d rcb569e6  
    4747typedef struct {
    4848        fs_handle_t fs_handle;
    49         dev_handle_t dev_handle;
     49        devmap_handle_t devmap_handle;
    5050        fs_index_t index;
    5151} fdi_node_t;
Note: See TracChangeset for help on using the changeset viewer.