Changeset 1a23f6e in mainline for uspace/lib


Ignore:
Timestamp:
2012-05-04T10:41:44Z (13 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
af42a2b
Parents:
6efb4d2 (diff), d21e935c (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
Files:
2 deleted
25 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/Makefile

    r6efb4d2 r1a23f6e  
    122122        generic/vfs/canonify.c \
    123123        generic/net/inet.c \
    124         generic/net/modules.c \
    125124        generic/net/socket_client.c \
    126125        generic/net/socket_parse.c \

  • uspace/lib/c/generic/async.c

    r6efb4d2 r1a23f6e  
    946946       
    947947        switch (IPC_GET_IMETHOD(*call)) {
    948         case IPC_M_CONNECT_ME:
     948        case IPC_M_CLONE_ESTABLISH:
    949949        case IPC_M_CONNECT_ME_TO:
    950950                /* Open new connection with fibril, etc. */
    … …  
    16681668}
    16691669
    1670 /** Wrapper for making IPC_M_CONNECT_ME calls using the async framework.
    1671  *
    1672  * Ask through for a cloned connection to some service.
     1670/** Wrapper for making IPC_M_CLONE_ESTABLISH calls using the async framework.
     1671 *
     1672 * Ask for a cloned connection to some service.
    16731673 *
    16741674 * @param mgmt Exchange management style.
    … …  
    16781678 *
    16791679 */
    1680 async_sess_t *async_connect_me(exch_mgmt_t mgmt, async_exch_t *exch)
     1680async_sess_t *async_clone_establish(exch_mgmt_t mgmt, async_exch_t *exch)
    16811681{
    16821682        if (exch == NULL) {
    … …  
    17031703        msg->wdata.active = true;
    17041704       
    1705         ipc_call_async_0(exch->phone, IPC_M_CONNECT_ME, msg,
     1705        ipc_call_async_0(exch->phone, IPC_M_CLONE_ESTABLISH, msg,
    17061706            reply_received, true);
    17071707       

  • uspace/lib/c/generic/device/nic.c

    r6efb4d2 r1a23f6e  
    6565       
    6666        if (retval != EOK) {
    67                 async_wait_for(req, NULL);
     67                async_forget(req);
    6868                return retval;
    6969        }
    … …  
    9494        rc = async_connect_to_me(exch, 0, 0, 0, cfun, carg);
    9595        if (rc != EOK) {
    96                 async_wait_for(req, NULL);
     96                async_forget(req);
    9797                return rc;
    9898        }

  • uspace/lib/c/generic/devman.c

    r6efb4d2 r1a23f6e  
    188188       
    189189        if (retval != EOK) {
    190                 async_wait_for(req, NULL);
     190                async_forget(req);
    191191                return retval;
    192192        }
    … …  
    226226        if (retval != EOK) {
    227227                devman_exchange_end(exch);
    228                 async_wait_for(req, NULL);
     228                async_forget(req);
    229229                return retval;
    230230        }
    … …  
    242242                if (retval != EOK) {
    243243                        devman_exchange_end(exch);
    244                         async_wait_for(req2, NULL);
    245                         async_wait_for(req, NULL);
     244                        async_forget(req2);
     245                        async_forget(req);
    246246                        return retval;
    247247                }
    … …  
    250250                if (retval != EOK) {
    251251                        devman_exchange_end(exch);
    252                         async_wait_for(req, NULL);
     252                        async_forget(req);
    253253                        return retval;
    254254                }
    … …  
    283283       
    284284        if (retval != EOK) {
    285                 async_wait_for(req, NULL);
     285                async_forget(req);
    286286                return retval;
    287287        }
    … …  
    386386       
    387387        if (retval != EOK) {
    388                 async_wait_for(req, NULL);
     388                async_forget(req);
    389389                return retval;
    390390        }
    … …  
    423423       
    424424        if (dretval != EOK) {
    425                 async_wait_for(req, NULL);
     425                async_forget(req);
    426426                return dretval;
    427427        }
    … …  
    488488       
    489489        if (rc != EOK) {
    490                 async_wait_for(req, NULL);
     490                async_forget(req);
    491491                return rc;
    492492        }

  • uspace/lib/c/generic/inet.c

    r6efb4d2 r1a23f6e  
    120120
    121121        if (rc != EOK) {
    122                 async_wait_for(req, NULL);
     122                async_forget(req);
    123123                return rc;
    124124        }

  • uspace/lib/c/generic/inetcfg.c

    r6efb4d2 r1a23f6e  
    5151
    5252        if (rc != EOK) {
    53                 async_wait_for(req, NULL);
     53                async_forget(req);
    5454                return rc;
    5555        }
    … …  
    146146
    147147        if (retval != EOK) {
    148                 async_wait_for(req, NULL);
     148                async_forget(req);
    149149                return retval;
    150150        }
    … …  
    183183
    184184        if (dretval != EOK) {
    185                 async_wait_for(req, NULL);
     185                async_forget(req);
    186186                return dretval;
    187187        }
    … …  
    216216
    217217        if (retval != EOK) {
    218                 async_wait_for(req, NULL);
     218                async_forget(req);
    219219                return retval;
    220220        }
    … …  
    261261
    262262        if (dretval != EOK) {
    263                 async_wait_for(req, NULL);
     263                async_forget(req);
    264264                return dretval;
    265265        }
    … …  
    294294
    295295        if (retval != EOK) {
    296                 async_wait_for(req, NULL);
     296                async_forget(req);
    297297                return retval;
    298298        }
    … …  
    331331
    332332        if (dretval != EOK) {
    333                 async_wait_for(req, NULL);
     333                async_forget(req);
    334334                return dretval;
    335335        }
    … …  
    364364
    365365        if (retval != EOK) {
    366                 async_wait_for(req, NULL);
     366                async_forget(req);
    367367                return retval;
    368368        }

  • uspace/lib/c/generic/inetping.c

    r6efb4d2 r1a23f6e  
    8888
    8989        if (retval != EOK) {
    90                 async_wait_for(req, NULL);
     90                async_forget(req);
    9191                return retval;
    9292        }

  • uspace/lib/c/generic/ipc.c

    r6efb4d2 r1a23f6e  
    647647 *
    648648 */
    649 int ipc_connect_me(int phoneid)
     649int ipc_clone_establish(int phoneid)
    650650{
    651651        sysarg_t newphid;
    652         int res = ipc_call_sync_0_5(phoneid, IPC_M_CONNECT_ME, NULL, NULL,
    653             NULL, NULL, &newphid);
     652        int res = ipc_call_sync_0_5(phoneid, IPC_M_CLONE_ESTABLISH, NULL,
     653            NULL, NULL, NULL, &newphid);
    654654        if (res)
    655655                return res;

  • uspace/lib/c/generic/iplink.c

    r6efb4d2 r1a23f6e  
    9494
    9595        if (rc != EOK) {
    96                 async_wait_for(req, NULL);
     96                async_forget(req);
    9797                return rc;
    9898        }

  • uspace/lib/c/generic/iplink_srv.c

    r6efb4d2 r1a23f6e  
    178178
    179179        if (rc != EOK) {
    180                 async_wait_for(req, NULL);
     180                async_forget(req);
    181181                return rc;
    182182        }

  • uspace/lib/c/generic/loader.c

    r6efb4d2 r1a23f6e  
    101101       
    102102        if (rc != EOK) {
    103                 async_wait_for(req, NULL);
     103                async_forget(req);
    104104                return (int) rc;
    105105        }
    … …  
    139139       
    140140        if (rc != EOK) {
    141                 async_wait_for(req, NULL);
     141                async_forget(req);
    142142                return (int) rc;
    143143        }
    … …  
    177177       
    178178        if (rc != EOK) {
    179                 async_wait_for(req, NULL);
     179                async_forget(req);
    180180                return (int) rc;
    181181        }
    … …  
    236236       
    237237        if (rc != EOK) {
    238                 async_wait_for(req, NULL);
     238                async_forget(req);
    239239                return (int) rc;
    240240        }
    … …  
    281281
    282282        if (rc != EOK) {
    283                 async_wait_for(req, NULL);
     283                async_forget(req);
    284284                return (int) rc;
    285285        }

  • uspace/lib/c/generic/loc.c

    r6efb4d2 r1a23f6e  
    246246       
    247247        if (retval != EOK) {
    248                 async_wait_for(req, NULL);
     248                async_forget(req);
    249249                return retval;
    250250        }
    … …  
    285285       
    286286        if (retval != EOK) {
    287                 async_wait_for(req, NULL);
     287                async_forget(req);
    288288                return retval;
    289289        }
    … …  
    352352       
    353353        if (retval != EOK) {
    354                 async_wait_for(req, NULL);
     354                async_forget(req);
    355355                return retval;
    356356        }
    … …  
    401401       
    402402        if (dretval != EOK) {
    403                 async_wait_for(req, NULL);
     403                async_forget(req);
    404404                return dretval;
    405405        }
    … …  
    471471       
    472472        if (retval != EOK) {
    473                 async_wait_for(req, NULL);
     473                async_forget(req);
    474474                return retval;
    475475        }
    … …  
    520520       
    521521        if (retval != EOK) {
    522                 async_wait_for(req, NULL);
     522                async_forget(req);
    523523                return retval;
    524524        }
    … …  
    683683               
    684684                if (rc != EOK) {
    685                         async_wait_for(req, NULL);
     685                        async_forget(req);
    686686                        free(devs);
    687687                        return 0;
    … …  
    732732               
    733733                if (rc != EOK) {
    734                         async_wait_for(req, NULL);
     734                        async_forget(req);
    735735                        free(devs);
    736736                        return 0;
    … …  
    760760       
    761761        if (rc != EOK) {
    762                 async_wait_for(req, NULL);
     762                async_forget(req);
    763763                return rc;
    764764        }

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

    r6efb4d2 r1a23f6e  
    4444#include <errno.h>
    4545#include <task.h>
     46#include <ns.h>
    4647#include <ipc/services.h>
    4748#include <ipc/socket.h>
    48 #include <net/modules.h>
    4949#include <net/in.h>
    5050#include <net/socket.h>
    … …  
    284284{
    285285        if (socket_globals.tcp_sess == NULL) {
    286                 socket_globals.tcp_sess = bind_service(SERVICE_TCP,
     286                socket_globals.tcp_sess = service_bind(SERVICE_TCP,
    287287                    0, 0, SERVICE_TCP, socket_connection);
    288288        }
    … …  
    301301{
    302302        if (socket_globals.udp_sess == NULL) {
    303                 socket_globals.udp_sess = bind_service(SERVICE_UDP,
     303                socket_globals.udp_sess = service_bind(SERVICE_UDP,
    304304                    0, 0, SERVICE_UDP, socket_connection);
    305305        }
    … …  
    378378 * @return              Other error codes as defined for the NET_SOCKET message.
    379379 * @return              Other error codes as defined for the
    380  *                      bind_service() function.
     380 *                      service_bind() function.
    381381 */
    382382int socket(int domain, int type, int protocol)

  • uspace/lib/c/generic/ns.c

    r6efb4d2 r1a23f6e  
    3737#include <async.h>
    3838#include <macros.h>
     39#include <errno.h>
    3940#include "private/ns.h"
    4041
    … …  
    4849}
    4950
    50 async_sess_t *service_connect(exch_mgmt_t mgmt, sysarg_t service, sysarg_t arg2,
     51async_sess_t *service_connect(exch_mgmt_t mgmt, services_t service, sysarg_t arg2,
    5152    sysarg_t arg3)
    5253{
    … …  
    7273}
    7374
    74 async_sess_t *service_connect_blocking(exch_mgmt_t mgmt, sysarg_t service,
     75async_sess_t *service_connect_blocking(exch_mgmt_t mgmt, services_t service,
    7576    sysarg_t arg2, sysarg_t arg3)
    7677{
    … …  
    8182            async_connect_me_to_blocking(mgmt, exch, service, arg2, arg3);
    8283        async_exchange_end(exch);
    83 
     84       
    8485        if (!sess)
    8586                return NULL;
    … …  
    9192         */
    9293        async_sess_args_set(sess, arg2, arg3, 0);
     94       
     95        return sess;
     96}
     97
     98/** Create bidirectional connection with a service
     99 *
     100 * @param[in] service         Service.
     101 * @param[in] arg1            First parameter.
     102 * @param[in] arg2            Second parameter.
     103 * @param[in] arg3            Third parameter.
     104 * @param[in] client_receiver Message receiver.
     105 *
     106 * @return Session to the service.
     107 * @return Other error codes as defined by async_connect_to_me().
     108 *
     109 */
     110async_sess_t *service_bind(services_t service, sysarg_t arg1, sysarg_t arg2,
     111    sysarg_t arg3, async_client_conn_t client_receiver)
     112{
     113        /* Connect to the needed service */
     114        async_sess_t *sess =
     115            service_connect_blocking(EXCHANGE_SERIALIZE, service, 0, 0);
     116        if (sess != NULL) {
     117                /* Request callback connection */
     118                async_exch_t *exch = async_exchange_begin(sess);
     119                int rc = async_connect_to_me(exch, arg1, arg2, arg3,
     120                    client_receiver, NULL);
     121                async_exchange_end(exch);
     122               
     123                if (rc != EOK) {
     124                        async_hangup(sess);
     125                        errno = rc;
     126                        return NULL;
     127                }
     128        }
    93129       
    94130        return sess;

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

    r6efb4d2 r1a23f6e  
    321321    sysarg_t *, sysarg_t *);
    322322
    323 extern async_sess_t *async_connect_me(exch_mgmt_t, async_exch_t *);
     323extern async_sess_t *async_clone_establish(exch_mgmt_t, async_exch_t *);
    324324extern async_sess_t *async_connect_me_to(exch_mgmt_t, async_exch_t *, sysarg_t,
    325325    sysarg_t, sysarg_t);

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

    r6efb4d2 r1a23f6e  
    254254    sysarg_t, sysarg_t, void *, ipc_async_callback_t, bool);
    255255
     256extern int ipc_clone_establish(int);
    256257extern int ipc_connect_to_me(int, sysarg_t, sysarg_t, sysarg_t, task_id_t *,
    257258    sysarg_t *);
    258 extern int ipc_connect_me(int);
    259259extern int ipc_connect_me_to(int, sysarg_t, sysarg_t, sysarg_t);
    260260extern int ipc_connect_me_to_blocking(int, sysarg_t, sysarg_t, sysarg_t);

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

    r6efb4d2 r1a23f6e  
    3737
    3838#include <sys/types.h>
     39#include <ipc/services.h>
    3940#include <task.h>
    4041#include <async.h>
    4142
    4243extern int service_register(sysarg_t);
    43 extern async_sess_t *service_connect(exch_mgmt_t, sysarg_t, sysarg_t, sysarg_t);
    44 extern async_sess_t *service_connect_blocking(exch_mgmt_t, sysarg_t, sysarg_t,
     44extern async_sess_t *service_connect(exch_mgmt_t, services_t, sysarg_t, sysarg_t);
     45extern async_sess_t *service_connect_blocking(exch_mgmt_t, services_t, sysarg_t,
    4546    sysarg_t);
     47extern async_sess_t *service_bind(services_t, sysarg_t, sysarg_t, sysarg_t,
     48    async_client_conn_t);
    4649
    4750extern int ns_ping(void);

  • uspace/lib/drv/generic/remote_usbhc.c

    r6efb4d2 r1a23f6e  
    259259        if (data_request == 0) {
    260260                // FIXME: How to let the other side know that we want to abort?
    261                 async_wait_for(opening_request, NULL);
     261                async_forget(opening_request);
    262262                return ENOMEM;
    263263        }
    … …  
    308308                const int ret = async_data_write_start(exch, data, size);
    309309                if (ret != EOK) {
    310                         async_wait_for(opening_request, NULL);
     310                        async_forget(opening_request);
    311311                        return ret;
    312312                }

  • uspace/lib/fs/libfs.c

    r6efb4d2 r1a23f6e  
    320320        if (rc != EOK) {
    321321                async_exchange_end(exch);
    322                 async_wait_for(req, NULL);
     322                async_forget(req);
    323323                return rc;
    324324        }
    … …  
    341341        if (reg.plb_ro == (void *) -1) {
    342342                async_exchange_end(exch);
    343                 async_wait_for(req, NULL);
     343                async_forget(req);
    344344                return ENOMEM;
    345345        }
    … …  
    348348       
    349349        if (rc) {
    350                 async_wait_for(req, NULL);
     350                async_forget(req);
    351351                return rc;
    352352        }
    … …  
    404404       
    405405        async_exch_t *exch = async_exchange_begin(mountee_sess);
    406         async_sess_t *sess = async_connect_me(EXCHANGE_PARALLEL, exch);
     406        async_sess_t *sess = async_clone_establish(EXCHANGE_PARALLEL, exch);
    407407       
    408408        if (!sess) {

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

    r6efb4d2 r1a23f6e  
    3939#include <net/in.h>
    4040#include <net/inet.h>
    41 #include <net/modules.h>
    4241#include <stdint.h>
    4342#include <stdlib.h>

  • uspace/lib/nic/include/nic.h

    r6efb4d2 r1a23f6e  
    232232extern int nic_report_poll_mode(nic_t *, nic_poll_mode_t, struct timeval *);
    233233extern void nic_query_address(nic_t *, nic_address_t *);
    234 extern void nic_received_noneth_frame(nic_t *, void *, size_t);
    235234extern void nic_received_frame(nic_t *, nic_frame_t *);
    236235extern void nic_received_frame_list(nic_t *, nic_frame_list_t *);

  • uspace/lib/nic/src/nic_driver.c

    r6efb4d2 r1a23f6e  
    624624
    625625/**
    626  * This function is to be used only in the loopback driver. It's workaround
    627  * for the situation when the frame does not contain ethernet address.
    628  * The filtering is therefore not applied here.
    629  *
    630  * @param nic_data
    631  * @param data          Frame data
    632  * @param size          Frame size in bytes
    633  */
    634 void nic_received_noneth_frame(nic_t *nic_data, void *data, size_t size)
    635 {
    636         fibril_rwlock_write_lock(&nic_data->stats_lock);
    637         nic_data->stats.receive_packets++;
    638         nic_data->stats.receive_bytes += size;
    639         fibril_rwlock_write_unlock(&nic_data->stats_lock);
    640        
    641         nic_ev_received(nic_data->client_session, data, size);
    642 }
    643 
    644 /**
    645626 * Some NICs can receive multiple frames during single interrupt. These can
    646627 * send them in whole list of frames (actually nic_frame_t structures), then

  • uspace/lib/nic/src/nic_ev.c

    r6efb4d2 r1a23f6e  
    5454
    5555        if (retval != EOK) {
    56                 async_wait_for(req, NULL);
     56                async_forget(req);
    5757                return retval;
    5858        }
    … …  
    8686
    8787        if (retval != EOK) {
    88                 async_wait_for(req, NULL);
     88                async_forget(req);
    8989                return retval;
    9090        }

  • uspace/lib/usbhid/src/hidiface.c

    r6efb4d2 r1a23f6e  
    120120       
    121121        if (data_request == 0) {
    122                 async_wait_for(opening_request, NULL);
     122                async_forget(opening_request);
    123123                free(buffer);
    124124                return ENOMEM;
    … …  
    206206       
    207207        if (data_request == 0) {
    208                 async_wait_for(opening_request, NULL);
     208                async_forget(opening_request);
    209209                return ENOMEM;
    210210        }

  • uspace/lib/usbvirt/src/ipc_hc.c

    r6efb4d2 r1a23f6e  
    8080        if (rc != EOK) {
    8181                async_exchange_end(exch);
    82                 async_wait_for(opening_request, NULL);
     82                async_forget(opening_request);
    8383                return rc;
    8484        }
    … …  
    9191       
    9292        if (data_request == 0) {
    93                 async_wait_for(opening_request, NULL);
     93                async_forget(opening_request);
    9494                return ENOMEM;
    9595        }
    … …  
    153153        if (rc != EOK) {
    154154                async_exchange_end(exch);
    155                 async_wait_for(opening_request, NULL);
     155                async_forget(opening_request);
    156156                return rc;
    157157        }
    … …  
    161161                if (rc != EOK) {
    162162                        async_exchange_end(exch);
    163                         async_wait_for(opening_request, NULL);
     163                        async_forget(opening_request);
    164164                        return rc;
    165165                }
    … …  
    226226       
    227227        if (data_request == 0) {
    228                 async_wait_for(opening_request, NULL);
     228                async_forget(opening_request);
    229229                return ENOMEM;
    230230        }
    … …  
    301301       
    302302        if (rc != EOK) {
    303                 async_wait_for(opening_request, NULL);
     303                async_forget(opening_request);
    304304                return rc;
    305305        }
Note: See TracChangeset for help on using the changeset viewer.