Changeset b74959bd in mainline


Ignore:
Timestamp:
2007-11-20T21:33:32Z (17 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
8498915
Parents:
3209923
Message:

Modify ipc_answer_*() to make use of all six syscall arguments. The recommended
means of answering calls is via the ipc_answer_m() macros (where m denotes the
number of return arguments) that automatically decide between the fast register
version or the slow universal version of ipc_answer().

Files:
25 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/include/ipc/sysipc.h

    r3209923 rb74959bd  
    4848unative_t sys_ipc_call_async_slow(unative_t phoneid, ipc_data_t *data);
    4949unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
    50     unative_t arg1, unative_t arg2);
    51 unative_t sys_ipc_answer(unative_t callid, ipc_data_t *data);
     50    unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4);
     51unative_t sys_ipc_answer_slow(unative_t callid, ipc_data_t *data);
    5252unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
    5353    int nonblocking);
  • kernel/generic/include/syscall/syscall.h

    r3209923 rb74959bd  
    5353        SYS_IPC_CALL_ASYNC_SLOW,
    5454        SYS_IPC_ANSWER_FAST,
    55         SYS_IPC_ANSWER,
     55        SYS_IPC_ANSWER_SLOW,
    5656        SYS_IPC_FORWARD_FAST,
    5757        SYS_IPC_WAIT,
  • kernel/generic/src/ipc/sysipc.c

    r3209923 rb74959bd  
    593593 * @param arg1          Service-defined return value.
    594594 * @param arg2          Service-defined return value.
     595 * @param arg3          Service-defined return value.
     596 * @param arg4          Service-defined return value.
    595597 *
    596598 * @return              Return 0 on success, otherwise return an error code.   
    597599 */
    598600unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
    599     unative_t arg1, unative_t arg2)
     601    unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
    600602{
    601603        call_t *call;
     
    620622        IPC_SET_ARG1(call->data, arg1);
    621623        IPC_SET_ARG2(call->data, arg2);
     624        IPC_SET_ARG3(call->data, arg3);
     625        IPC_SET_ARG4(call->data, arg4);
    622626        rc = answer_preprocess(call, saveddata ? &saved_data : NULL);
    623627
     
    633637 * @return              Return 0 on success, otherwise return an error code.
    634638 */
    635 unative_t sys_ipc_answer(unative_t callid, ipc_data_t *data)
     639unative_t sys_ipc_answer_slow(unative_t callid, ipc_data_t *data)
    636640{
    637641        call_t *call;
  • kernel/generic/src/syscall/syscall.c

    r3209923 rb74959bd  
    138138        (syshandler_t) sys_ipc_call_async_slow,
    139139        (syshandler_t) sys_ipc_answer_fast,
    140         (syshandler_t) sys_ipc_answer,
     140        (syshandler_t) sys_ipc_answer_slow,
    141141        (syshandler_t) sys_ipc_forward_fast,
    142142        (syshandler_t) sys_ipc_wait_for_call,
  • uspace/app/tester/ipc/answer.c

    r3209923 rb74959bd  
    4747        }
    4848        if (!cnt)
    49                 return;
     49                return NULL;
    5050        printf("Choose message:\n");
    5151        do {
     
    7070                errn = ENOENT;
    7171        printf("Answering %P\n", callids[i]);
    72         ipc_answer_fast(callids[i], errn, 0, 0);
     72        ipc_answer_0(callids[i], errn);
    7373        callids[i] = 0;
    7474       
  • uspace/app/tester/ipc/register.c

    r3209923 rb74959bd  
    3030#include <unistd.h>
    3131#include <async.h>
     32#include <errno.h>
    3233#include "../tester.h"
    3334
     
    4142
    4243        printf("Connected phone: %P, accepting\n", icall->in_phone_hash);
    43         ipc_answer_fast(iid, 0, 0, 0);
     44        ipc_answer_0(iid, EOK);
    4445        for (i = 0; i < 1024; i++)
    4546                if (!connections[i]) {
     
    5657                        break;
    5758                default:
    58                         printf("Received message from %P: %X\n", phonehash,callid);
     59                        printf("Received message from %P: %X\n", phonehash,
     60                            callid);
    5961                        for (i = 0; i < 1024; i++)
    6062                                if (!callids[i]) {
     
    6466                        continue;
    6567                }
    66                 ipc_answer_fast(callid, retval, 0, 0);
     68                ipc_answer_0(callid, retval);
    6769        }
    6870}
  • uspace/app/tester/ipc/send_async.c

    r3209923 rb74959bd  
    3939{
    4040        int phoneid;
    41         int res;
    4241        static int msgid = 1;
    4342        char c;
  • uspace/lib/libc/generic/async.c

    r3209923 rb74959bd  
    7676 * {
    7777 *      if (want_refuse) {
    78  *              ipc_answer_fast(icallid, ELIMIT, 0, 0);
     78 *              ipc_answer_0(icallid, ELIMIT);
    7979 *              return;
    8080 *      }
    81  *      ipc_answer_fast(icallid, EOK, 0, 0);
     81 *      ipc_answer_0(icallid, EOK);
    8282 *
    8383 *      callid = async_get_call(&call);
    8484 *      handle_call(callid, call);
    85  *      ipc_answer_fast(callid, 1, 2, 3);
     85 *      ipc_answer_2(callid, 1, 2, 3);
    8686 *
    8787 *      callid = async_get_call(&call);
     
    396396static void default_client_connection(ipc_callid_t callid, ipc_call_t *call)
    397397{
    398         ipc_answer_fast(callid, ENOENT, 0, 0);
     398        ipc_answer_0(callid, ENOENT);
    399399}
    400400
     
    441441                if (msg->callid == FIBRIL_connection->close_callid)
    442442                        close_answered = 1;
    443                 ipc_answer_fast(msg->callid, EHANGUP, 0, 0);
     443                ipc_answer_0(msg->callid, EHANGUP);
    444444                free(msg);
    445445        }
    446446        if (FIBRIL_connection->close_callid)
    447                 ipc_answer_fast(FIBRIL_connection->close_callid, 0, 0, 0);
     447                ipc_answer_0(FIBRIL_connection->close_callid, EOK);
    448448       
    449449        return 0;
     
    476476        if (!conn) {
    477477                if (callid)
    478                         ipc_answer_fast(callid, ENOMEM, 0, 0);
     478                        ipc_answer_0(callid, ENOMEM);
    479479                return NULL;
    480480        }
     
    492492                free(conn);
    493493                if (callid)
    494                         ipc_answer_fast(callid, ENOMEM, 0, 0);
     494                        ipc_answer_0(callid, ENOMEM);
    495495                return NULL;
    496496        }
     
    537537
    538538        /* Unknown call from unknown phone - hang it up */
    539         ipc_answer_fast(callid, EHANGUP, 0, 0);
     539        ipc_answer_0(callid, EHANGUP);
    540540}
    541541
  • uspace/lib/libc/generic/ipc.c

    r3209923 rb74959bd  
    376376/** Answer a received call - fast version.
    377377 *
    378  * The fast answer makes use of passing retval and first two arguments in
    379  * registers. If you need to return more, use the ipc_answer() instead.
     378 * The fast answer makes use of passing retval and first four arguments in
     379 * registers. If you need to return more, use the ipc_answer_slow() instead.
    380380 *
    381381 * @param callid        Hash of the call being answered.
     
    383383 * @param arg1          First return argument.
    384384 * @param arg2          Second return argument.
     385 * @param arg3          Third return argument.
     386 * @param arg4          Fourth return argument.
    385387 *
    386388 * @return              Zero on success or a value from @ref errno.h on failure.
    387389 */
    388390ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
    389     ipcarg_t arg2)
    390 {
    391         return __SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2);
    392 }
    393 
    394 /** Answer a received call - full version.
     391    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4)
     392{
     393        return __SYSCALL6(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2, arg3,
     394            arg4);
     395}
     396
     397/** Answer a received call - slow full version.
    395398 *
    396399 * @param callid        Hash of the call being answered.
    397  * @param call          Call structure with the answer.
    398  *                      Must be already initialized by the responder.
     400 * @param retval        Return value.
     401 * @param arg1          First return argument.
     402 * @param arg2          Second return argument.
     403 * @param arg3          Third return argument.
     404 * @param arg4          Fourth return argument.
     405 * @param arg5          Fifth return argument.
    399406 *
    400407 * @return              Zero on success or a value from @ref errno.h on failure.
    401408 */
    402 ipcarg_t ipc_answer(ipc_callid_t callid, ipc_call_t *call)
    403 {
    404         return __SYSCALL2(SYS_IPC_ANSWER, callid, (sysarg_t) call);
     409ipcarg_t ipc_answer_slow(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
     410    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5)
     411{
     412        ipc_call_t data;
     413
     414        IPC_SET_RETVAL(data, retval);
     415        IPC_SET_ARG1(data, arg1);
     416        IPC_SET_ARG2(data, arg2);
     417        IPC_SET_ARG3(data, arg3);
     418        IPC_SET_ARG4(data, arg4);
     419        IPC_SET_ARG5(data, arg5);
     420
     421        return __SYSCALL2(SYS_IPC_ANSWER_SLOW, callid, (sysarg_t) &data);
    405422}
    406423
     
    659676 * @param callid        Storage where the hash of the IPC_M_DATA_SEND call will
    660677 *                      be stored.
    661  * @param call          Storage where the incoming call will be stored.
    662678 * @param dst           Storage where the suggested destination address will
    663679 *                      be stored. May be NULL.
     
    667683 * @return              Non-zero on success, zero on failure.
    668684 */
    669 int ipc_data_receive(ipc_callid_t *callid, ipc_call_t *call, void **dst,
    670     size_t *size)
    671 {
     685int ipc_data_receive(ipc_callid_t *callid, void **dst, size_t *size)
     686{
     687        ipc_call_t data;
     688       
    672689        assert(callid);
    673         assert(call);
    674 
    675         *callid = async_get_call(call);
    676         if (IPC_GET_METHOD(*call) != IPC_M_DATA_SEND)
     690
     691        *callid = async_get_call(&data);
     692        if (IPC_GET_METHOD(data) != IPC_M_DATA_SEND)
    677693                return 0;
    678694        if (dst)
    679                 *dst = (void *) IPC_GET_ARG1(*call);
     695                *dst = (void *) IPC_GET_ARG1(data);
    680696        if (size)
    681                 *size = (size_t) IPC_GET_ARG3(*call);
     697                *size = (size_t) IPC_GET_ARG3(data);
    682698        return 1;
    683699}
     
    689705 *
    690706 * @param callid        Hash of the IPC_M_DATA_SEND call to answer.
    691  * @param call          Call structure with the request.
    692707 * @param dst           Final destination address for the IPC_M_DATA_SEND call.
    693708 * @param size          Final size for the IPC_M_DATA_SEND call.
     
    695710 * @return              Zero on success or a value from @ref errno.h on failure.
    696711 */
    697 ipcarg_t ipc_data_deliver(ipc_callid_t callid, ipc_call_t *call, void *dst,
    698     size_t size)
    699 {
    700         IPC_SET_RETVAL(*call, EOK);
    701         IPC_SET_ARG1(*call, (ipcarg_t) dst);
    702         IPC_SET_ARG3(*call, (ipcarg_t) size);
    703         return ipc_answer(callid, call);
     712ipcarg_t ipc_data_deliver(ipc_callid_t callid, void *dst, size_t size)
     713{
     714        return ipc_answer_3(callid, EOK, (ipcarg_t) dst, 0, (ipcarg_t) size);
    704715}
    705716 
  • uspace/lib/libc/include/ipc/ipc.h

    r3209923 rb74959bd  
    191191extern ipc_callid_t ipc_trywait_for_call(ipc_call_t *data);
    192192
    193 #define ipc_answer_fast_0(callid, retval) \
    194     ipc_answer_fast((callid), (retval), 0, 0)
    195 #define ipc_answer_fast_1(callid, retval, arg1) \
    196     ipc_answer_fast((callid), (retval), (arg1), 0)
     193/*
     194 * User-friendly wrappers for ipc_answer_fast() and ipc_answer_slow().
     195 * They are in the form of ipc_answer_m(), where m is the number of return
     196 * arguments. The macros decide between the fast and the slow version according
     197 * to m.
     198 */
     199#define ipc_answer_0(callid, retval) \
     200    ipc_answer_fast((callid), (retval), 0, 0, 0, 0)
     201#define ipc_answer_1(callid, retval, arg1) \
     202    ipc_answer_fast((callid), (retval), (arg1), 0, 0, 0)
     203#define ipc_answer_2(callid, retval, arg1, arg2) \
     204    ipc_answer_fast((callid), (retval), (arg1), (arg2), 0, 0)
     205#define ipc_answer_3(callid, retval, arg1, arg2, arg3) \
     206    ipc_answer_fast((callid), (retval), (arg1), (arg2), (arg3), 0)
     207#define ipc_answer_4(callid, retval, arg1, arg2, arg3, arg4) \
     208    ipc_answer_fast((callid), (retval), (arg1), (arg2), (arg3), (arg4))
     209#define ipc_answer_5(callid, retval, arg1, arg2, arg3, arg4, arg5) \
     210    ipc_answer_slow((callid), (retval), (arg1), (arg2), (arg3), (arg4), (arg5))
     211
    197212extern ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval,
    198     ipcarg_t arg1, ipcarg_t arg2);
    199 extern ipcarg_t ipc_answer(ipc_callid_t callid, ipc_call_t *call);
     213    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4);
     214extern ipcarg_t ipc_answer_slow(ipc_callid_t callid, ipcarg_t retval,
     215    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5);
    200216
    201217/*
     
    245261    ipcarg_t arg1);
    246262extern int ipc_data_send(int phoneid, void *src, size_t size);
    247 extern int ipc_data_receive(ipc_callid_t *callid, ipc_call_t *call, void **dst,
    248     size_t *size);
    249 extern ipcarg_t ipc_data_deliver(ipc_callid_t callid, ipc_call_t *call,
    250     void *dst, size_t size);
     263extern int ipc_data_receive(ipc_callid_t *callid, void **dst, size_t *size);
     264extern ipcarg_t ipc_data_deliver(ipc_callid_t callid, void *dst, size_t size);
    251265
    252266#endif
  • uspace/srv/console/console.c

    r3209923 rb74959bd  
    278278                for (j = 0; j < conn->screenbuffer.size_y; j++)
    279279                        for (i = 0; i < conn->screenbuffer.size_x; i++) {
    280                                 field = get_field_at(&conn->screenbuffer, i,
    281                                     j);
     280                                field = get_field_at(&conn->screenbuffer, i, j);
    282281                                if (!style_same(*style, field->style))
    283282                                        set_style(&field->style);
     
    350349                        if (conn->keyrequest_counter > 0) {             
    351350                                conn->keyrequest_counter--;
    352                                 ipc_answer_fast(fifo_pop(conn->keyrequests), 0,
    353                                     c, 0);
     351                                ipc_answer_1(fifo_pop(conn->keyrequests), EOK,
     352                                    c);
    354353                                break;
    355354                        }
     
    362361                        retval = ENOENT;
    363362                }
    364                 ipc_answer_fast(callid, retval, 0, 0);
     363                ipc_answer_0(callid, retval);
    365364        }
    366365}
     
    376375
    377376        if ((consnum = find_free_connection()) == -1) {
    378                 ipc_answer_fast(iid, ELIMIT, 0, 0);
     377                ipc_answer_0(iid, ELIMIT);
    379378                return;
    380379        }
     
    388387       
    389388        /* Accept the connection */
    390         ipc_answer_fast(iid, 0, 0, 0);
     389        ipc_answer_0(iid, EOK);
    391390
    392391        while (1) {
     
    404403                        while (conn->keyrequest_counter > 0) {         
    405404                                conn->keyrequest_counter--;
    406                                 ipc_answer_fast(fifo_pop(conn->keyrequests),
    407                                     ENOENT, 0, 0);
     405                                ipc_answer_0(fifo_pop(conn->keyrequests),
     406                                    ENOENT);
    408407                                break;
    409408                        }
     
    465464                                         * requests => fail.
    466465                                        */
    467                                         ipc_answer_fast(callid, ELIMIT, 0, 0);
     466                                        ipc_answer_0(callid, ELIMIT);
    468467                                }
    469468                                continue;
     
    472471                        break;
    473472                }
    474                 ipc_answer_fast(callid, 0, arg1, arg2);
     473                ipc_answer_2(callid, EOK, arg1, arg2);
    475474        }
    476475}
  • uspace/srv/devmap/devmap.c

    r3209923 rb74959bd  
    114114
    115115        if (item == &devices_list) {
    116                 printf("DevMap: no device named %s.\n", name);
     116                printf("DEVMAP: no device named %s.\n", name);
    117117                return NULL;
    118118        }
     
    190190
    191191        if (IPC_GET_METHOD(icall) != DEVMAP_DRIVER_REGISTER) {
    192                 ipc_answer_fast(iid, EREFUSED, 0, 0);
     192                ipc_answer_0(iid, EREFUSED);
    193193                return;
    194194        }
     
    196196        if (NULL ==
    197197            (driver = (devmap_driver_t *)malloc(sizeof(devmap_driver_t)))) {
    198                 ipc_answer_fast(iid, ENOMEM, 0, 0);
     198                ipc_answer_0(iid, ENOMEM);
    199199                return;
    200200        }
     
    203203         * Get driver name
    204204         */
    205         if (!ipc_data_receive(&callid, &call, NULL, &name_size)) {
    206                 printf("Unexpected request: %u.\n", IPC_GET_METHOD(call));
     205        if (!ipc_data_receive(&callid, NULL, &name_size)) {
     206                printf("Unexpected request.\n");
    207207                free(driver);
    208                 ipc_answer_fast(callid, EREFUSED, 0, 0);
    209                 ipc_answer_fast(iid, EREFUSED, 0, 0);
     208                ipc_answer_0(callid, EREFUSED);
     209                ipc_answer_0(iid, EREFUSED);
    210210                return;
    211211        }
     
    215215                    DEVMAP_NAME_MAXLEN);
    216216                free(driver);
    217                 ipc_answer_fast(callid, EINVAL, 0, 0);
    218                 ipc_answer_fast(iid, EREFUSED, 0, 0);
     217                ipc_answer_0(callid, EINVAL);
     218                ipc_answer_0(iid, EREFUSED);
    219219                return;
    220220        }
     
    226226                printf("Cannot allocate space for driver name.\n");
    227227                free(driver);
    228                 ipc_answer_fast(callid, ENOMEM, 0, 0);
    229                 ipc_answer_fast(iid, EREFUSED, 0, 0);
     228                ipc_answer_0(callid, ENOMEM);
     229                ipc_answer_0(iid, EREFUSED);
    230230                return;
    231231        }       
     
    234234         * Send confirmation to sender and get data into buffer.
    235235         */
    236         if (EOK != ipc_data_deliver(callid, &call, driver->name, name_size)) {
     236        if (EOK != ipc_data_deliver(callid, driver->name, name_size)) {
    237237                printf("Cannot read driver name.\n");
    238238                free(driver->name);
    239239                free(driver);
    240                 ipc_answer_fast(iid, EREFUSED, 0, 0);
     240                ipc_answer_0(iid, EREFUSED);
    241241                return;
    242242        }
     
    251251        /*
    252252         * Initialize list of asociated devices
    253     */
     253        */
    254254        list_initialize(&(driver->devices));
    255255
     
    260260
    261261        if (IPC_M_CONNECT_TO_ME != IPC_GET_METHOD(call)) {
    262                 printf("DevMap: Unexpected method: %u.\n",
     262                printf("DEVMAP: Unexpected method: %u.\n",
    263263                    IPC_GET_METHOD(call));
    264                 ipc_answer_fast(callid, ENOTSUP, 0, 0);
     264                ipc_answer_0(callid, ENOTSUP);
    265265               
    266266                free(driver->name);
    267267                free(driver);
    268                 ipc_answer_fast(iid, ENOTSUP, 0, 0);
     268                ipc_answer_0(iid, ENOTSUP);
    269269                return;
    270270        }
     
    272272        driver->phone = IPC_GET_ARG3(call);
    273273       
    274         ipc_answer_fast(callid, EOK, 0, 0);
     274        ipc_answer_0(callid, EOK);
    275275       
    276276        list_initialize(&(driver->drivers));
     
    288288        futex_up(&drivers_list_futex); 
    289289       
    290         ipc_answer_fast(iid, EOK, 0, 0);
     290        ipc_answer_0(iid, EOK);
    291291        printf("Driver registered.\n");
    292292
     
    295295}
    296296
    297 /** Unregister device driver, unregister all its devices and free driver structure.
    298  *
     297/** Unregister device driver, unregister all its devices and free driver
     298 * structure.
    299299 */
    300300static int devmap_driver_unregister(devmap_driver_t *driver)
     
    348348 */
    349349static void devmap_device_register(ipc_callid_t iid, ipc_call_t *icall,
    350                 devmap_driver_t *driver)
     350    devmap_driver_t *driver)
    351351{
    352352        ipc_callid_t callid;
    353         ipc_call_t call;
    354353        size_t size;
    355354        devmap_device_t *device;
     
    357356        if (NULL == driver) {
    358357                printf("Invalid driver registration.\n");
    359                 ipc_answer_fast(iid, EREFUSED, 0, 0);
     358                ipc_answer_0(iid, EREFUSED);
    360359                return;
    361360        }
     
    365364            (device = (devmap_device_t *)malloc(sizeof(devmap_device_t)))) {
    366365                printf("Cannot allocate new device.\n");
    367                 ipc_answer_fast(iid, ENOMEM, 0, 0);
     366                ipc_answer_0(iid, ENOMEM);
    368367                return;
    369368        }
    370369       
    371370        /* Get device name */
    372         if (!ipc_data_receive(&callid, &call, NULL, &size)) {
     371        if (!ipc_data_receive(&callid, NULL, &size)) {
    373372                free(device);
    374373                printf("Cannot read device name.\n");
    375                 ipc_answer_fast(iid, EREFUSED, 0, 0);
     374                ipc_answer_0(iid, EREFUSED);
    376375                return;
    377376        }
     
    380379                printf("Too long device name: %u.\n", size);
    381380                free(device);
    382                 ipc_answer_fast(callid, EINVAL, 0, 0);
    383                 ipc_answer_fast(iid, EREFUSED, 0, 0);
     381                ipc_answer_0(callid, EINVAL);
     382                ipc_answer_0(iid, EREFUSED);
    384383                return;
    385384        }
     
    391390                printf("Cannot read device name.\n");
    392391                free(device);
    393                 ipc_answer_fast(callid, ENOMEM, 0, 0);
    394                 ipc_answer_fast(iid, EREFUSED, 0, 0);
    395                 return;
    396         }
    397        
    398         ipc_data_deliver(callid, &call, device->name, size);
     392                ipc_answer_0(callid, ENOMEM);
     393                ipc_answer_0(iid, EREFUSED);
     394                return;
     395        }
     396       
     397        ipc_data_deliver(callid, device->name, size);
    399398        device->name[size] = 0;
    400399
     
    410409                free(device->name);
    411410                free(device);
    412                 ipc_answer_fast(iid, EEXISTS, 0, 0);
     411                ipc_answer_0(iid, EEXISTS);
    413412                return;
    414413        }
     
    420419       
    421420        /* Insert device into list of all devices  */
    422         list_append(&(device->devices), &devices_list);
     421        list_append(&device->devices, &devices_list);
    423422
    424423        /* Insert device into list of devices that belog to one driver */
    425         futex_down(&(device->driver->devices_futex));   
    426        
    427         list_append(&(device->driver_devices), &(device->driver->devices));
    428        
    429         futex_up(&(device->driver->devices_futex));     
     424        futex_down(&device->driver->devices_futex);     
     425       
     426        list_append(&device->driver_devices, &device->driver->devices);
     427       
     428        futex_up(&device->driver->devices_futex);       
    430429        futex_up(&devices_list_futex); 
    431430
    432431        printf("Device '%s' registered.\n", device->name);     
    433         ipc_answer_fast(iid, EOK, device->handle, 0);
     432        ipc_answer_1(iid, EOK, device->handle);
    434433
    435434        return;
     
    440439 */
    441440static int devmap_device_unregister(ipc_callid_t iid, ipc_call_t *icall,
    442         devmap_driver_t *driver)
     441    devmap_driver_t *driver)
    443442{
    444443        /* TODO */
     
    465464
    466465        if (NULL == dev) {
    467                 printf("DevMap: No registered device with handle %d.\n",
     466                printf("DEVMAP: No registered device with handle %d.\n",
    468467                    handle);
    469                 ipc_answer_fast(callid, ENOENT, 0, 0);
     468                ipc_answer_0(callid, ENOENT);
    470469                return;
    471470        }
     
    487486        const devmap_device_t *dev;
    488487        ipc_callid_t callid;
    489         ipc_call_t call;
    490488        ipcarg_t retval;
    491489       
     
    495493         * read the name itself until the buffer is allocated).
    496494         */
    497         if (!ipc_data_receive(&callid, &call, NULL, &name_size)) {
    498                 ipc_answer_fast(callid, EREFUSED, 0, 0);
    499                 ipc_answer_fast(iid, EREFUSED, 0, 0);
     495        if (!ipc_data_receive(&callid, NULL, &name_size)) {
     496                ipc_answer_0(callid, EREFUSED);
     497                ipc_answer_0(iid, EREFUSED);
    500498                return;
    501499        }
    502500
    503501        if (name_size > DEVMAP_NAME_MAXLEN) {
    504                 ipc_answer_fast(callid, EINVAL, 0, 0);
    505                 ipc_answer_fast(iid, EREFUSED, 0, 0);
     502                ipc_answer_0(callid, EINVAL);
     503                ipc_answer_0(iid, EREFUSED);
    506504                return;
    507505        }
     
    511509         */
    512510        if (NULL == (name = (char *)malloc(name_size))) {
    513                 ipc_answer_fast(callid, ENOMEM, 0, 0);
    514                 ipc_answer_fast(iid, EREFUSED, 0, 0);
     511                ipc_answer_0(callid, ENOMEM);
     512                ipc_answer_0(iid, EREFUSED);
    515513                return;
    516514        }       
     
    519517         * Send confirmation to sender and get data into buffer.
    520518         */
    521         if (EOK != (retval = ipc_data_deliver(callid, &call, name,
    522             name_size))) {
    523                 ipc_answer_fast(iid, EREFUSED, 0, 0);
     519        if (EOK != (retval = ipc_data_deliver(callid, name, name_size))) {
     520                ipc_answer_0(iid, EREFUSED);
    524521                return;
    525522        }
     
    534531         */
    535532        if (NULL == dev) {
    536                 printf("DevMap: device %s has not been registered.\n", name);
    537                 ipc_answer_fast(iid, ENOENT, 0, 0);
    538                 return;
    539         }
    540 
    541         printf("DevMap: device %s has handler %d.\n", name, dev->handle);
     533                printf("DEVMAP: device %s has not been registered.\n", name);
     534                ipc_answer_0(iid, ENOENT);
     535                return;
     536        }
     537
     538        printf("DEVMAP: device %s has handler %d.\n", name, dev->handle);
    542539               
    543         ipc_answer_fast(iid, EOK, dev->handle, 0);
     540        ipc_answer_1(iid, EOK, dev->handle);
    544541
    545542        return;
     
    560557         */
    561558        if (NULL == device) {
    562                 ipc_answer_fast(iid, ENOENT, 0, 0);
     559                ipc_answer_0(iid, ENOENT);
    563560                return;
    564561        }       
    565562
    566         ipc_answer_fast(iid, EOK, 0, 0);
     563        ipc_answer_0(iid, EOK);
    567564
    568565        name_size = strlen(device->name);
     
    570567
    571568/*      FIXME:
    572         we have no channel from DevMap to client ->
     569        we have no channel from DEVMAP to client ->
    573570        sending must be initiated by client
    574571
     
    595592        devmap_driver_t *driver = NULL;
    596593
    597         ipc_answer_fast(iid, EOK, 0, 0);
     594        ipc_answer_0(iid, EOK);
    598595
    599596        devmap_driver_register(&driver);
    600597
    601598        if (NULL == driver) {
    602                 printf("DevMap: driver registration failed.\n");
     599                printf("DEVMAP: driver registration failed.\n");
    603600                return;
    604601        }
     
    609606                switch (IPC_GET_METHOD(call)) {
    610607                case IPC_M_PHONE_HUNGUP:
    611                         printf("DevMap: connection hung up.\n");
     608                        printf("DEVMAP: connection hung up.\n");
    612609                        cont = false;
    613610                        continue; /* Exit thread */
    614611                case DEVMAP_DRIVER_UNREGISTER:
    615                         printf("DevMap: unregister driver.\n");
     612                        printf("DEVMAP: unregister driver.\n");
    616613                        if (NULL == driver) {
    617                                 printf("DevMap: driver was not registered!\n");
    618                                 ipc_answer_fast(callid, ENOENT, 0, 0);
     614                                printf("DEVMAP: driver was not registered!\n");
     615                                ipc_answer_0(callid, ENOENT);
    619616                        } else {
    620                                 ipc_answer_fast(callid, EOK, 0, 0);
     617                                ipc_answer_0(callid, EOK);
    621618                        }
    622619                        break;
     
    637634                default:
    638635                        if (!(callid & IPC_CALLID_NOTIFICATION)) {
    639                                 ipc_answer_fast(callid, ENOENT, 0, 0);
     636                                ipc_answer_0(callid, ENOENT);
    640637                        }
    641638                }
     
    643640       
    644641        if (NULL != driver) {
    645                         /*
    646                         * Unregister the device driver and all its devices.
    647                         */
     642                /*
     643                * Unregister the device driver and all its devices.
     644                */
    648645                devmap_driver_unregister(driver);
    649646                driver = NULL;
     
    662659        bool cont = true;
    663660
    664         ipc_answer_fast(iid, EOK, 0, 0); /* Accept connection */
     661        ipc_answer_0(iid, EOK); /* Accept connection */
    665662
    666663        while (cont) {
     
    669666                switch (IPC_GET_METHOD(call)) {
    670667                case IPC_M_PHONE_HUNGUP:
    671                         printf("DevMap: connection hung up.\n");
     668                        printf("DEVMAP: connection hung up.\n");
    672669                        cont = false;
    673670                        continue; /* Exit thread */
     
    675672                case DEVMAP_DEVICE_CONNECT_ME_TO:
    676673                        /* Connect client to selected device */
    677                         printf("DevMap: connect to device %d.\n",
     674                        printf("DEVMAP: connect to device %d.\n",
    678675                            IPC_GET_ARG1(call));
    679676                        devmap_forward(callid, &call);
     
    690687                default:
    691688                        if (!(callid & IPC_CALLID_NOTIFICATION)) {
    692                                 ipc_answer_fast(callid, ENOENT, 0, 0);
     689                                ipc_answer_0(callid, ENOENT);
    693690                        }
    694691                }
     
    703700{
    704701
    705         printf("DevMap: new connection.\n");
     702        printf("DEVMAP: new connection.\n");
    706703
    707704                /* Select interface */
     
    714711                break;
    715712        default:
    716                 ipc_answer_fast(iid, ENOENT, 0, 0); /* No such interface */
    717                 printf("DevMap: Unknown interface %u.\n",
     713                ipc_answer_0(iid, ENOENT); /* No such interface */
     714                printf("DEVMAP: Unknown interface %u.\n",
    718715                    (ipcarg_t)(IPC_GET_ARG1(*icall)));
    719716        }
     
    721718        /* Cleanup */
    722719       
    723         printf("DevMap: connection closed.\n");
     720        printf("DEVMAP: connection closed.\n");
    724721        return;
    725722}
     
    732729        ipcarg_t phonead;
    733730
    734         printf("DevMap: HelenOS device mapper.\n");
     731        printf("DEVMAP: HelenOS device mapper.\n");
    735732
    736733        if (devmap_init() != 0) {
    737                 printf("Error while initializing DevMap service.\n");
     734                printf("Error while initializing DEVMAP service.\n");
    738735                return -1;
    739736        }
  • uspace/srv/fb/ega.c

    r3209923 rb74959bd  
    8383        int i;
    8484       
    85         for (i = 0; i < scr_width*scr_height; i++) {
     85        for (i = 0; i < scr_width * scr_height; i++) {
    8686                scr_addr[i * 2] = ' ';
    8787                scr_addr[i * 2 + 1] = style;
     
    126126        if (rows > 0) {
    127127                memcpy(scr_addr, ((char *) scr_addr) + rows * scr_width * 2,
    128                         scr_width * scr_height * 2 - rows * scr_width * 2);
     128                    scr_width * scr_height * 2 - rows * scr_width * 2);
    129129                for (i = 0; i < rows * scr_width; i++)
    130130                        (((short *) scr_addr) + scr_width * scr_height - rows *
    131                                 scr_width)[i] = ((style << 8) + ' ');
     131                            scr_width)[i] = ((style << 8) + ' ');
    132132        } else if (rows < 0) {
    133133                memcpy(((char *)scr_addr) - rows * scr_width * 2, scr_addr,
    134                         scr_width * scr_height * 2 + rows * scr_width * 2);
     134                    scr_width * scr_height * 2 + rows * scr_width * 2);
    135135                for (i = 0; i < -rows * scr_width; i++)
    136136                        ((short *)scr_addr)[i] = ((style << 8 ) + ' ');
     
    153153                scr_addr[i * 2] = data[i].character;
    154154                scr_addr[i * 2 + 1] = EGA_STYLE(data[i].style.fg_color,
    155                         data[i].style.bg_color);
     155                    data[i].style.bg_color);
    156156        }
    157157}
     
    161161        int i;
    162162
    163         for (i=0; (i < MAX_SAVED_SCREENS) && (saved_screens[i].data); i++)
     163        for (i = 0; (i < MAX_SAVED_SCREENS) && (saved_screens[i].data); i++)
    164164                ;
    165165        if (i == MAX_SAVED_SCREENS)
     
    176176        if (saved_screens[i].data)
    177177                memcpy(scr_addr, saved_screens[i].data, 2 * scr_width *
    178                         scr_height);
     178                    scr_height);
    179179        else
    180180                return EINVAL;
     
    196196
    197197        if (client_connected) {
    198                 ipc_answer_fast(iid, ELIMIT, 0,0);
     198                ipc_answer_0(iid, ELIMIT);
    199199                return;
    200200        }
    201201        client_connected = 1;
    202         ipc_answer_fast(iid, 0, 0, 0); /* Accept connection */
     202        ipc_answer_0(iid, EOK); /* Accept connection */
    203203
    204204        while (1) {
     
    207207                case IPC_M_PHONE_HUNGUP:
    208208                        client_connected = 0;
    209                         ipc_answer_fast(callid, 0, 0, 0);
     209                        ipc_answer_0(callid, EOK);
    210210                        return; /* Exit thread */
    211211                case IPC_M_AS_AREA_SEND:
     
    213213                        intersize = IPC_GET_ARG2(call);
    214214                        if (intersize >= scr_width * scr_height *
    215                                 sizeof(*interbuf)) {
    216                                 receive_comm_area(callid, &call, (void *)
    217                                         &interbuf);
     215                            sizeof(*interbuf)) {
     216                                receive_comm_area(callid, &call,
     217                                    (void *) &interbuf);
    218218                                continue;
    219219                        }
     
    229229                        break;
    230230                case FB_GET_CSIZE:
    231                         ipc_answer_fast(callid, 0, scr_height, scr_width);
     231                        ipc_answer_2(callid, EOK, scr_height, scr_width);
    232232                        continue;
    233233                case FB_CLEAR:
     
    301301                        retval = ENOENT;
    302302                }
    303                 ipc_answer_fast(callid, retval, 0, 0);
     303                ipc_answer_0(callid, retval);
    304304        }
    305305}
     
    319319
    320320        physmem_map(ega_ph_addr, scr_addr, ALIGN_UP(sz, PAGE_SIZE) >>
    321                 PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
     321            PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
    322322
    323323        async_set_client_connection(ega_client_connection);
  • uspace/srv/fb/fb.c

    r3209923 rb74959bd  
    166166{
    167167        *((uint32_t *) dst) = BLUE(rgb, 8) << 16 | GREEN(rgb, 8) << 8 |
    168                 RED(rgb, 8);
     168            RED(rgb, 8);
    169169}
    170170
     
    174174        int color = *(uint32_t *)(src);
    175175        return ((color & 0xff) << 16) | (((color >> 8) & 0xff) << 8) |
    176                 ((color >> 16) & 0xff);
     176            ((color >> 16) & 0xff);
    177177}
    178178
     
    209209        /* 5-bit, 5-bits, 5-bits */
    210210        *((uint16_t *)(dst)) = RED(rgb, 5) << 10 | GREEN(rgb, 5) << 5 |
    211                 BLUE(rgb, 5);
     211            BLUE(rgb, 5);
    212212}
    213213
     
    218218        int color = *(uint16_t *)(src);
    219219        return (((color >> 10) & 0x1f) << (16 + 3)) |
    220                 (((color >> 5) & 0x1f) << (8 + 3)) | ((color & 0x1f) << 3);
     220            (((color >> 5) & 0x1f) << (8 + 3)) | ((color & 0x1f) << 3);
    221221}
    222222
     
    227227        /* 5-bit, 6-bits, 5-bits */
    228228        *((uint16_t *)(dst)) = RED(rgb, 5) << 11 | GREEN(rgb, 6) << 5 |
    229                 BLUE(rgb, 5);
     229            BLUE(rgb, 5);
    230230}
    231231
     
    236236        int color = *(uint16_t *)(src);
    237237        return (((color >> 11) & 0x1f) << (16 + 3)) |
    238                 (((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3);
     238            (((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3);
    239239}
    240240
     
    252252        int color = *(uint8_t *)src;
    253253        return (((color >> 5) & 0x7) << (16 + 5)) |
    254                 (((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5);
     254            (((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5);
    255255}
    256256
     
    270270        if (! (vport->paused && vport->dbdata))
    271271                (*screen.rgb2scr)(&screen.fbaddress[POINTPOS(dx,dy)],
    272                         COLOR(color));
     272                    COLOR(color));
    273273
    274274        if (vport->dbdata) {
     
    292292putpixel_mem(char *mem, unsigned int x, unsigned int y, int color)
    293293{
    294         (*screen.rgb2scr)(&mem[POINTPOS(x,y)], COLOR(color));
     294        (*screen.rgb2scr)(&mem[POINTPOS(x, y)], COLOR(color));
    295295}
    296296
     
    303303
    304304        if (!tmpline)
    305                 tmpline = malloc(screen.scanline*screen.pixelbytes);
     305                tmpline = malloc(screen.scanline * screen.pixelbytes);
    306306
    307307        /* Clear first line */
     
    316316                for (y = sy;y < sy+height; y++)
    317317                        memcpy(&screen.fbaddress[POINTPOS(sx,y)], tmpline,
    318                                screen.pixelbytes * width);
     318                            screen.pixelbytes * width);
    319319        }
    320320        if (vport->dbdata) {
     
    322322                        int rline = (y + vport->dboffset) % vport->height;
    323323                        int rpos = (rline * vport->width + sx) *
    324                                 screen.pixelbytes;
     324                            screen.pixelbytes;
    325325                        memcpy(&vport->dbdata[rpos], tmpline,
    326                                 screen.pixelbytes * width);
     326                            screen.pixelbytes * width);
    327327                }
    328328        }
     
    335335{
    336336        draw_rectangle(vport, 0, 0, vport->width, vport->height,
    337                 vport->style.bg_color);
     337            vport->style.bg_color);
    338338}
    339339
     
    351351                for (y = vport->y; y < vport->y+vport->height - lines; y++)
    352352                        memcpy(&screen.fbaddress[POINTPOS(vport->x,y)],
    353                                &screen.fbaddress[POINTPOS(vport->x,y + lines)],
    354                                screen.pixelbytes * vport->width);
     353                            &screen.fbaddress[POINTPOS(vport->x,y + lines)],
     354                            screen.pixelbytes * vport->width);
    355355                draw_rectangle(vport, 0, vport->height - lines, vport->width,
    356                         lines, vport->style.bg_color);
     356                    lines, vport->style.bg_color);
    357357        } else if (lines < 0) {
    358358                lines = -lines;
    359                 for (y = vport->y + vport->height-1; y >= vport->y + lines;
    360                          y--)
     359                for (y = vport->y + vport->height-1; y >= vport->y + lines; y--)
    361360                        memcpy(&screen.fbaddress[POINTPOS(vport->x,y)],
    362                                &screen.fbaddress[POINTPOS(vport->x,y - lines)],
    363                                screen.pixelbytes * vport->width);
     361                            &screen.fbaddress[POINTPOS(vport->x,y - lines)],
     362                            screen.pixelbytes * vport->width);
    364363                draw_rectangle(vport, 0, 0, vport->width, lines,
    365                         vport->style.bg_color);
     364                    vport->style.bg_color);
    366365        }
    367366}
     
    381380
    382381                memcpy(&screen.fbaddress[POINTPOS(dstx,dsty)],
    383                        &vport->dbdata[srcoff],
    384                        vport->width*screen.pixelbytes);
     382                    &vport->dbdata[srcoff], vport->width * screen.pixelbytes);
    385383        }
    386384}
     
    393391        if (lines > 0) {
    394392                draw_rectangle(vport, 0, 0, vport->width, lines,
    395                                vport->style.bg_color);
     393                    vport->style.bg_color);
    396394                vport->dboffset += lines;
    397395                vport->dboffset %= vport->height;
    398396        } else if (lines < 0) {
    399397                lines = -lines;
    400                 draw_rectangle(vport, 0, vport->height-lines,
    401                                vport->width, lines,
    402                                vport->style.bg_color);
     398                draw_rectangle(vport, 0, vport->height-lines, vport->width,
     399                    lines, vport->style.bg_color);
    403400
    404401                if (vport->dboffset < lines)
     
    442439 */
    443440static void
    444 draw_glyph(viewport_t *vport,uint8_t glyph, unsigned int sx,
    445          unsigned int sy, style_t style, int transparent)
     441draw_glyph(viewport_t *vport,uint8_t glyph, unsigned int sx, unsigned int sy,
     442    style_t style, int transparent)
    446443{
    447444        int i;
     
    453450                for (i = 0; i < 8; i++) {
    454451                        if (glline & (1 << (7 - i)))
    455                                 putpixel(vport, sx + i, sy + y,
    456                                         style.fg_color);
     452                                putpixel(vport, sx + i, sy + y, style.fg_color);
    457453                        else if (!transparent)
    458                                 putpixel(vport, sx + i, sy + y,
    459                                         style.bg_color);
     454                                putpixel(vport, sx + i, sy + y, style.bg_color);
    460455                }
    461456        }
     
    472467                for (y = 0; y < FONT_SCANLINES; y++)
    473468                        invert_pixel(vport, col * COL_WIDTH + x, row *
    474                                 FONT_SCANLINES + y);
     469                            FONT_SCANLINES + y);
    475470}
    476471
     
    631626       
    632627        draw_glyph(vport, c, col * COL_WIDTH, row * FONT_SCANLINES, style,
    633                 transparent);
     628            transparent);
    634629
    635630        vport->cur_col = col;
     
    660655        for (i = 0; i < vport->cols * vport->rows; i++) {
    661656                if (data[i].character == ' ' && style_same(data[i].style,
    662                         vport->style))
     657                    vport->style))
    663658                        continue;
    664659                col = i % vport->cols;
    665660                row = i / vport->cols;
    666661                draw_glyph(vport, data[i].character, col * COL_WIDTH, row *
    667                         FONT_SCANLINES, data[i].style,
    668                         style_same(data[i].style,vport->style));
     662                    FONT_SCANLINES, data[i].style, style_same(data[i].style,
     663                    vport->style));
    669664        }
    670665        cursor_print(vport);
     
    712707
    713708        ppm_draw(shm, size, 0, 0, pmap->width, pmap->height,
    714                 (putpixel_cb_t)putpixel_pixmap, (void *)pm);
     709            (putpixel_cb_t)putpixel_pixmap, (void *)pm);
    715710
    716711        return pm;
     
    758753                        void *dest = as_get_mappable_page(IPC_GET_ARG2(*call));
    759754                        shm_size = IPC_GET_ARG2(*call);
    760                         if (!ipc_answer_fast(callid, 0, (sysarg_t) dest, 0))
     755                        if (!ipc_answer_1(callid, EOK, (sysarg_t) dest))
    761756                                shm = dest;
    762757                        else
     
    806801               
    807802                ppm_draw(shm, shm_size, IPC_GET_ARG1(*call),
    808                         IPC_GET_ARG2(*call), vport->width - x,
    809                         vport->height - y, (putpixel_cb_t)putpixel, vport);
     803                    IPC_GET_ARG2(*call), vport->width - x, vport->height - y,
     804                    (putpixel_cb_t)putpixel, vport);
    810805                break;
    811806        case FB_DRAW_TEXT_DATA:
     
    815810                }
    816811                if (intersize < vport->cols * vport->rows *
    817                         sizeof(*interbuffer)) {
     812                    sizeof(*interbuffer)) {
    818813                        retval = EINVAL;
    819814                        break;
     
    826821       
    827822        if (handled)
    828                 ipc_answer_fast(callid, retval, 0, 0);
     823                ipc_answer_0(callid, retval);
    829824        return handled;
    830825}
     
    852847        for (y = 0; y < realheight; y++) {
    853848                tmp = (vport->y + y) * screen.scanline +
    854                         vport->x * screen.pixelbytes;
     849                    vport->x * screen.pixelbytes;
    855850                memcpy(pmap->data + srcrowsize * y, screen.fbaddress + tmp,
    856                         realrowsize);
     851                    realrowsize);
    857852        }
    858853}
     
    913908        for (y = 0; y < realheight; y++) {
    914909                tmp = (vport->y + y) * screen.scanline +
    915                         vport->x * screen.pixelbytes;
     910                    vport->x * screen.pixelbytes;
    916911                memcpy(screen.fbaddress + tmp, pmap->data + y * srcrowsize,
    917                         realrowsize);
     912                    realrowsize);
    918913        }
    919914        return 0;
     
    934929        for (i = 0; i < MAX_ANIMATIONS; i++) {
    935930                if (!animations[i].animlen || !animations[i].initialized ||
    936                         !animations[i].enabled)
     931                    !animations[i].enabled)
    937932                        continue;
    938933                draw_pixmap(animations[i].vp,
    939                         animations[i].pixmaps[animations[i].pos]);
     934                    animations[i].pixmaps[animations[i].pos]);
    940935                animations[i].pos = (animations[i].pos + 1) %
    941                         animations[i].animlen;
     936                    animations[i].animlen;
    942937        }
    943938}
     
    963958        if (pointer_vport == -1) {
    964959                pointer_vport = viewport_create(pointer_x, pointer_y,
    965                         pointer_width, pointer_height);
     960                    pointer_width, pointer_height);
    966961                if (pointer_vport < 0)
    967962                        return;
     
    975970        else
    976971                copy_vp_to_pixmap(&viewports[pointer_vport],
    977                         &pixmaps[pointer_pixmap]);
     972                    &pixmaps[pointer_pixmap]);
    978973
    979974        /* Draw cursor */
     
    982977                        bytepos = i * ((pointer_width - 1) / 8 + 1) + j / 8;
    983978                        visibility = pointer_mask_bits[bytepos] &
    984                                 (1 << (j % 8));
     979                            (1 << (j % 8));
    985980                        if (visibility) {
    986                                 color = pointer_bits[bytepos] & (1 << (j % 8))
    987                                         ? 0 : 0xffffff;
     981                                color = pointer_bits[bytepos] &
     982                                    (1 << (j % 8)) ? 0 : 0xffffff;
    988983                                if (pointer_x + j < screen.xres && pointer_y +
    989                                         i < screen.yres)
     984                                    i < screen.yres)
    990985                                        putpixel(&viewports[0], pointer_x + j,
    991                                                 pointer_y + i, color);
     986                                            pointer_y + i, color);
    992987                        }
    993988                }
     
    11071102        }
    11081103        if (handled)
    1109                 ipc_answer_fast(callid, retval, 0, 0);
     1104                ipc_answer_0(callid, retval);
    11101105        return handled;
    11111106}
     
    11581153
    11591154        if (handled)
    1160                 ipc_answer_fast(callid, retval, 0, 0);
     1155                ipc_answer_0(callid, retval);
    11611156        return handled;
    11621157       
     
    11801175
    11811176        if (client_connected) {
    1182                 ipc_answer_fast(iid, ELIMIT, 0,0);
     1177                ipc_answer_0(iid, ELIMIT);
    11831178                return;
    11841179        }
    11851180        client_connected = 1;
    1186         ipc_answer_fast(iid, 0, 0, 0); /* Accept connection */
     1181        ipc_answer_0(iid, EOK); /* Accept connection */
    11871182
    11881183        while (1) {
     
    12231218                                break;
    12241219                        }
    1225                         ipc_answer_fast(callid, 0, 0, 0);
     1220                        ipc_answer_0(callid, EOK);
    12261221
    12271222                        draw_char(vport, c, row, col, vport->style,
    1228                                 IPC_GET_METHOD(call) == FB_TRANS_PUTCHAR);
     1223                            IPC_GET_METHOD(call) == FB_TRANS_PUTCHAR);
    12291224                        continue; /* msg already answered */
    12301225                case FB_CLEAR:
     
    12531248                        break;
    12541249                case FB_GET_CSIZE:
    1255                         ipc_answer_fast(callid, 0, vport->rows, vport->cols);
     1250                        ipc_answer_2(callid, EOK, vport->rows, vport->cols);
    12561251                        continue;
    12571252                case FB_SCROLL:
     
    12751270                                break;
    12761271                        }
    1277                         if (! viewports[i].initialized ) {
     1272                        if (!viewports[i].initialized ) {
    12781273                                retval = EADDRNOTAVAIL;
    12791274                                break;
     
    12811276                        viewports[i].dboffset = 0;
    12821277                        if (IPC_GET_ARG2(call) == 1 && !viewports[i].dbdata)
    1283                                 viewports[i].dbdata = malloc(screen.pixelbytes
    1284                                         * viewports[i].width *
    1285                                         viewports[i].height);
     1278                                viewports[i].dbdata =
     1279                                    malloc(screen.pixelbytes *
     1280                                    viewports[i].width * viewports[i].height);
    12861281                        else if (IPC_GET_ARG2(call) == 0 &&
    1287                                 viewports[i].dbdata) {
     1282                            viewports[i].dbdata) {
    12881283                                free(viewports[i].dbdata);
    12891284                                viewports[i].dbdata = NULL;
     
    13091304                case FB_VIEWPORT_CREATE:
    13101305                        retval = viewport_create(IPC_GET_ARG1(call) >> 16,
    1311                                 IPC_GET_ARG1(call) & 0xffff,
    1312                                 IPC_GET_ARG2(call) >> 16,
    1313                                 IPC_GET_ARG2(call) & 0xffff);
     1306                            IPC_GET_ARG1(call) & 0xffff,
     1307                            IPC_GET_ARG2(call) >> 16,
     1308                            IPC_GET_ARG2(call) & 0xffff);
    13141309                        break;
    13151310                case FB_VIEWPORT_DELETE:
     
    13361331                        break;
    13371332                case FB_GET_RESOLUTION:
    1338                         ipc_answer_fast(callid, 0, screen.xres,screen.yres);
     1333                        ipc_answer_2(callid, EOK, screen.xres, screen.yres);
    13391334                        continue;
    13401335                case FB_POINTER_MOVE:
     
    13461341                        retval = ENOENT;
    13471342                }
    1348                 ipc_answer_fast(callid,retval, 0, 0);
     1343                ipc_answer_0(callid, retval);
    13491344        }
    13501345}
     
    13761371       
    13771372        physmem_map(fb_ph_addr, fb_addr, ALIGN_UP(asz, PAGE_SIZE) >>
    1378                 PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
     1373            PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
    13791374
    13801375        if (screen_init(fb_addr, fb_width, fb_height, fb_scanline, fb_visual,
    1381                 fb_invert_colors))
     1376            fb_invert_colors))
    13821377                return 0;
    13831378       
  • uspace/srv/fb/main.c

    r3209923 rb74959bd  
    4545
    4646        dest = as_get_mappable_page(IPC_GET_ARG2(*call));
    47         if (ipc_answer_fast(callid, 0, (sysarg_t) dest, 0) == 0) {
     47        if (ipc_answer_1(callid, EOK, (sysarg_t) dest) == 0) {
    4848                if (*area)
    4949                        as_area_destroy(*area);
  • uspace/srv/fb/sysio.c

    r3209923 rb74959bd  
    118118
    119119        if (client_connected) {
    120                 ipc_answer_fast(iid, ELIMIT, 0,0);
     120                ipc_answer_0(iid, ELIMIT);
    121121                return;
    122122        }
    123123       
    124124        client_connected = 1;
    125         ipc_answer_fast(iid, 0, 0, 0); /* Accept connection */
     125        ipc_answer_0(iid, EOK); /* Accept connection */
    126126        while (1) {
    127127                callid = async_get_call(&call);
    128128                switch (IPC_GET_METHOD(call)) {
    129                         case IPC_M_PHONE_HUNGUP:
    130                                 client_connected = 0;
    131                                 ipc_answer_fast(callid, 0, 0, 0);
    132                                 return; /* Exit thread */
    133                         case FB_PUTCHAR:
    134                                 c = IPC_GET_ARG1(call);
    135                                 newrow = IPC_GET_ARG2(call);
    136                                 newcol = IPC_GET_ARG3(call);
    137                                 if ((lastcol != newcol) || (lastrow != newrow))
    138                                         curs_goto(newrow, newcol);
    139                                 lastcol = newcol + 1;
    140                                 lastrow = newrow;
    141                                 sysput(c);
    142                                 retval = 0;
     129                case IPC_M_PHONE_HUNGUP:
     130                        client_connected = 0;
     131                        ipc_answer_0(callid, EOK);
     132                        return; /* Exit thread */
     133                case FB_PUTCHAR:
     134                        c = IPC_GET_ARG1(call);
     135                        newrow = IPC_GET_ARG2(call);
     136                        newcol = IPC_GET_ARG3(call);
     137                        if ((lastcol != newcol) || (lastrow != newrow))
     138                                curs_goto(newrow, newcol);
     139                        lastcol = newcol + 1;
     140                        lastrow = newrow;
     141                        sysput(c);
     142                        retval = 0;
     143                        break;
     144                case FB_CURSOR_GOTO:
     145                        newrow = IPC_GET_ARG1(call);
     146                        newcol = IPC_GET_ARG2(call);
     147                        curs_goto(newrow, newcol);
     148                        lastrow = newrow;
     149                        lastcol = newcol;
     150                        retval = 0;
     151                        break;
     152                case FB_GET_CSIZE:
     153                        ipc_answer_2(callid, EOK, HEIGHT, WIDTH);
     154                        continue;
     155                case FB_CLEAR:
     156                        clrscr();
     157                        retval = 0;
     158                        break;
     159                case FB_SET_STYLE:
     160                        fgcolor = IPC_GET_ARG1(call);
     161                        bgcolor = IPC_GET_ARG2(call);
     162                        if (fgcolor < bgcolor)
     163                                set_style(0);
     164                        else
     165                                set_style(7);
     166                        retval = 0;
     167                        break;
     168                case FB_SCROLL:
     169                        i = IPC_GET_ARG1(call);
     170                        if ((i > HEIGHT) || (i < -HEIGHT)) {
     171                                retval = EINVAL;
    143172                                break;
    144                         case FB_CURSOR_GOTO:
    145                                 newrow = IPC_GET_ARG1(call);
    146                                 newcol = IPC_GET_ARG2(call);
    147                                 curs_goto(newrow, newcol);
    148                                 lastrow = newrow;
    149                                 lastcol = newcol;
    150                                 retval = 0;
    151                                 break;
    152                         case FB_GET_CSIZE:
    153                                 ipc_answer_fast(callid, 0, HEIGHT, WIDTH);
    154                                 continue;
    155                         case FB_CLEAR:
    156                                 clrscr();
    157                                 retval = 0;
    158                                 break;
    159                         case FB_SET_STYLE:
    160                                 fgcolor = IPC_GET_ARG1(call);
    161                                 bgcolor = IPC_GET_ARG2(call);
    162                                 if (fgcolor < bgcolor)
    163                                         set_style(0);
    164                                 else
    165                                         set_style(7);
    166                                 retval = 0;
    167                                 break;
    168                         case FB_SCROLL:
    169                                 i = IPC_GET_ARG1(call);
    170                                 if ((i > HEIGHT) || (i < -HEIGHT)) {
    171                                         retval = EINVAL;
    172                                         break;
    173                                 }
    174                                 scroll(i);
    175                                 curs_goto(lastrow, lastcol);
    176                                 retval = 0;
    177                                 break;
    178                         default:
    179                                 retval = ENOENT;
     173                        }
     174                        scroll(i);
     175                        curs_goto(lastrow, lastcol);
     176                        retval = 0;
     177                        break;
     178                default:
     179                        retval = ENOENT;
    180180                }
    181181               
    182                 ipc_answer_fast(callid, retval, 0, 0);
     182                ipc_answer_0(callid, retval);
    183183        }
    184184}
  • uspace/srv/fs/fat/fat.c

    r3209923 rb74959bd  
    9494                 * created by IPC_M_CONNECT_TO_ME.
    9595                 */
    96                 ipc_answer_fast_0(iid, EOK);
     96                ipc_answer_0(iid, EOK);
    9797        }
    9898       
     
    105105                switch  (IPC_GET_METHOD(call)) {
    106106                default:
    107                         ipc_answer_fast_0(callid, ENOTSUP);
     107                        ipc_answer_0(callid, ENOTSUP);
    108108                        break;
    109109                }
  • uspace/srv/kbd/generic/kbd.c

    r3209923 rb74959bd  
    6969
    7070        if (cons_connected && phone2cons != -1) {
    71                 /* recode to ASCII - one interrupt can produce more than one code so result is stored in fifo */
     71                /*
     72                 * recode to ASCII - one interrupt can produce more than one
     73                 * code so result is stored in fifo
     74                 */
    7275                while (!keybuffer_empty(&keybuffer)) {
    7376                        if (!keybuffer_pop(&keybuffer, (int *)&chr))
     
    8689
    8790        if (cons_connected) {
    88                 ipc_answer_fast(iid, ELIMIT, 0, 0);
     91                ipc_answer_0(iid, ELIMIT);
    8992                return;
    9093        }
    9194        cons_connected = 1;
    92         ipc_answer_fast(iid, 0, 0, 0);
     95        ipc_answer_0(iid, EOK);
    9396
    9497        while (1) {
     
    99102                        ipc_hangup(phone2cons);
    100103                        phone2cons = -1;
    101                         ipc_answer_fast(callid, 0,0,0);
     104                        ipc_answer_0(callid, EOK);
    102105                        return;
    103106                case IPC_M_CONNECT_TO_ME:
     
    112115                        retval = EINVAL;
    113116                }
    114                 ipc_answer_fast(callid, retval, 0, 0);
     117                ipc_answer_0(callid, retval);
    115118        }       
    116119}
  • uspace/srv/ns/ns.c

    r3209923 rb74959bd  
    9393                ph_addr = (void *) sysinfo_value(name);
    9494                if (!ph_addr) {
    95                         ipc_answer_fast_0(callid, ENOENT);
     95                        ipc_answer_0(callid, ENOENT);
    9696                        return;
    9797                }
     
    100100                    AS_AREA_READ | AS_AREA_CACHEABLE);
    101101        }
    102         ipc_answer_fast(callid, EOK, (ipcarg_t) *addr, AS_AREA_READ);
     102        ipc_answer_2(callid, EOK, (ipcarg_t) *addr, AS_AREA_READ);
    103103}
    104104
     
    129129                                break;
    130130                        default:
    131                                 ipc_answer_fast_0(callid, ENOENT);
     131                                ipc_answer_0(callid, ENOENT);
    132132                        }
    133133                        continue;
     
    154154                }
    155155                if (!(callid & IPC_CALLID_NOTIFICATION)) {
    156                         ipc_answer_fast_0(callid, retval);
     156                        ipc_answer_0(callid, retval);
    157157                }
    158158        }
  • uspace/srv/pci/pci.c

    r3209923 rb74959bd  
    6767                ipc_call_t call;
    6868                ipc_callid_t callid;
     69                ipcarg_t retval = ENOTSUP;
    6970
    7071                callid = ipc_wait_for_call(&call);
    7172                switch(IPC_GET_METHOD(call)) {
    7273                case IPC_M_CONNECT_ME_TO:
    73                         IPC_SET_RETVAL(call, 0);
     74                        retval = EOK;
    7475                        break;
    7576                }
    76                 if (! (callid & IPC_CALLID_NOTIFICATION)) {
    77                         ipc_answer(callid, &call);
    78                 }
    79                 printf("%s: received call from %lX\n", NAME, call.in_phone_hash);
     77                ipc_answer_0(callid, retval);
     78                printf("%s: received call from %lX\n", NAME,
     79                    call.in_phone_hash);
    8080        }
    8181
  • uspace/srv/rd/rd.c

    r3209923 rb74959bd  
    9191                 * This is the answer to the call that opened the connection.
    9292                 */
    93                 ipc_answer_fast(iid, EHANGUP, 0, 0);
     93                ipc_answer_0(iid, EHANGUP);
    9494                return;
    9595        } else {
     
    9898                 * Return supported block size as ARG1.
    9999                 */
    100                 ipc_answer_fast(iid, EOK, BLOCK_SIZE, 0);
     100                ipc_answer_1(iid, EOK, BLOCK_SIZE);
    101101        }
    102102
     
    111111                         * block.
    112112                         */
    113                         ipc_answer_fast(callid, EOK, (uintptr_t) fs_va, 0);
     113                        ipc_answer_1(callid, EOK, (uintptr_t) fs_va);
    114114                } else {
    115115                        /*
     
    117117                         * Close the connection.
    118118                         */
    119                         ipc_answer_fast(callid, EHANGUP, 0, 0);
     119                        ipc_answer_0(callid, EHANGUP);
    120120                        return;         
    121121                }
     
    126126                 * Close the connection.
    127127                 */
    128                 ipc_answer_fast(callid, EHANGUP, 0, 0);
     128                ipc_answer_0(callid, EHANGUP);
    129129                return;
    130130        }
     
    138138                         * Answer the message and exit the fibril.
    139139                         */
    140                         ipc_answer_fast(callid, EOK, 0, 0);
     140                        ipc_answer_0(callid, EOK);
    141141                        return;
    142142                case RD_READ_BLOCK:
     
    178178                        break;
    179179                }
    180                 ipc_answer_fast(callid, retval, 0, 0);
     180                ipc_answer_0(callid, retval);
    181181        }
    182182}
  • uspace/srv/vfs/vfs.c

    r3209923 rb74959bd  
    6060         * This call needs to be answered.
    6161         */
    62         ipc_answer_fast_0(iid, EOK);
     62        ipc_answer_0(iid, EOK);
    6363
    6464        /*
     
    104104                case VFS_RENAME:
    105105                default:
    106                         ipc_answer_fast_0(callid, ENOTSUP);
     106                        ipc_answer_0(callid, ENOTSUP);
    107107                        break;
    108108                }
  • uspace/srv/vfs/vfs_mount.c

    r3209923 rb74959bd  
    8585         */
    8686        ipc_callid_t callid;
    87         ipc_call_t call;
    8887        size_t size;
    89         if (!ipc_data_receive(&callid, &call, NULL, &size)) {
    90                 ipc_answer_fast_0(callid, EINVAL);
    91                 ipc_answer_fast_0(rid, EINVAL);
     88        if (!ipc_data_receive(&callid, NULL, &size)) {
     89                ipc_answer_0(callid, EINVAL);
     90                ipc_answer_0(rid, EINVAL);
    9291                return;
    9392        }
     
    10099        if ((size < FS_NAME_MAXLEN + 1) ||
    101100            (size > FS_NAME_MAXLEN + MAX_PATH_LEN)) {
    102                 ipc_answer_fast_0(callid, EINVAL);
    103                 ipc_answer_fast_0(rid, EINVAL);
     101                ipc_answer_0(callid, EINVAL);
     102                ipc_answer_0(rid, EINVAL);
    104103                return;
    105104        }
     
    111110        buf = malloc(size);
    112111        if (!buf) {
    113                 ipc_answer_fast_0(callid, ENOMEM);
    114                 ipc_answer_fast_0(rid, ENOMEM);
     112                ipc_answer_0(callid, ENOMEM);
     113                ipc_answer_0(rid, ENOMEM);
    115114                return;
    116115        }
     
    119118         * Deliver the data.
    120119         */
    121         (void) ipc_data_deliver(callid, &call, buf, size);
     120        (void) ipc_data_deliver(callid, buf, size);
    122121
    123122        char fs_name[FS_NAME_MAXLEN + 1];
     
    132131        if (!fs_handle) {
    133132                free(buf);
    134                 ipc_answer_fast_0(rid, ENOENT);
     133                ipc_answer_0(rid, ENOENT);
    135134                return;
    136135        }
     
    147146        if (rc != EOK) {
    148147                free(buf);
    149                 ipc_answer_fast_0(rid, rc);
     148                ipc_answer_0(rid, rc);
    150149                return;
    151150        }
     
    153152        if (!mr_node) {
    154153                free(buf);
    155                 ipc_answer_fast_0(rid, ENOMEM);
     154                ipc_answer_0(rid, ENOMEM);
    156155                return;
    157156        }
     
    177176                        vfs_node_put(mr_node);  /* failed -> drop reference */
    178177                        free(buf);
    179                         ipc_answer_fast_0(rid, rc);
     178                        ipc_answer_0(rid, rc);
    180179                        return;
    181180                }
     
    186185                        vfs_node_put(mr_node);  /* failed -> drop reference */
    187186                        free(buf);
    188                         ipc_answer_fast_0(rid, ENOMEM);
     187                        ipc_answer_0(rid, ENOMEM);
    189188                        return;
    190189                }
     
    207206                        futex_up(&rootfs_futex);
    208207                        free(buf);
    209                         ipc_answer_fast_0(rid, EOK);
     208                        ipc_answer_0(rid, EOK);
    210209                        return;
    211210                } else {
     
    217216                        free(buf);
    218217                        vfs_node_put(mr_node);  /* failed -> drop reference */
    219                         ipc_answer_fast_0(rid, ENOENT);
     218                        ipc_answer_0(rid, ENOENT);
    220219                        return;
    221220                }
     
    255254       
    256255        if (rc2 == EOK)
    257                 ipc_answer_fast_0(rid, rc1);
     256                ipc_answer_0(rid, rc1);
    258257        else if (rc1 == EOK)
    259                 ipc_answer_fast_0(rid, rc2);
     258                ipc_answer_0(rid, rc2);
    260259        else
    261                 ipc_answer_fast_0(rid, rc1);
     260                ipc_answer_0(rid, rc1);
    262261}
    263262
  • uspace/srv/vfs/vfs_open.c

    r3209923 rb74959bd  
    4747{
    4848        if (!vfs_files_init()) {
    49                 ipc_answer_fast_0(rid, ENOMEM);
     49                ipc_answer_0(rid, ENOMEM);
    5050                return;
    5151        }
     
    6161
    6262        ipc_callid_t callid;
    63         ipc_call_t call;
    6463
    65         if (!ipc_data_receive(&callid, &call, NULL, &size)) {
    66                 ipc_answer_fast_0(callid, EINVAL);
    67                 ipc_answer_fast_0(rid, EINVAL);
     64        if (!ipc_data_receive(&callid, NULL, &size)) {
     65                ipc_answer_0(callid, EINVAL);
     66                ipc_answer_0(rid, EINVAL);
    6867                return;
    6968        }
     
    7877       
    7978        if (!path) {
    80                 ipc_answer_fast_0(callid, ENOMEM);
    81                 ipc_answer_fast_0(rid, ENOMEM);
     79                ipc_answer_0(callid, ENOMEM);
     80                ipc_answer_0(rid, ENOMEM);
    8281                return;
    8382        }
    8483
    8584        int rc;
    86         if ((rc = ipc_data_deliver(callid, &call, path, size))) {
    87                 ipc_answer_fast_0(rid, rc);
     85        if ((rc = ipc_data_deliver(callid, path, size))) {
     86                ipc_answer_0(rid, rc);
    8887                free(path);
    8988                return;
     
    104103        if (rc) {
    105104                futex_up(&unlink_futex);
    106                 ipc_answer_fast_0(rid, rc);
     105                ipc_answer_0(rid, rc);
    107106                free(path);
    108107                return;
     
    124123        if (fd < 0) {
    125124                vfs_node_put(node);
    126                 ipc_answer_fast_0(rid, fd);
     125                ipc_answer_0(rid, fd);
    127126                return;
    128127        }
     
    143142         * Success! Return the new file descriptor to the client.
    144143         */
    145         ipc_answer_fast_1(rid, EOK, fd);
     144        ipc_answer_1(rid, EOK, fd);
    146145}
    147146
  • uspace/srv/vfs/vfs_register.c

    r3209923 rb74959bd  
    156156         * VFS info structure from the client FS.
    157157         */
    158         if (!ipc_data_receive(&callid, &call, NULL, &size)) {
     158        if (!ipc_data_receive(&callid, NULL, &size)) {
    159159                /*
    160160                 * The client doesn't obey the same protocol as we do.
    161161                 */
    162162                dprintf("Receiving of VFS info failed.\n");
    163                 ipc_answer_fast_0(callid, EINVAL);
    164                 ipc_answer_fast_0(rid, EINVAL);
     163                ipc_answer_0(callid, EINVAL);
     164                ipc_answer_0(rid, EINVAL);
    165165                return;
    166166        }
     
    178178                 */
    179179                dprintf("Received VFS info has bad size.\n");
    180                 ipc_answer_fast_0(callid, EINVAL);
    181                 ipc_answer_fast_0(rid, EINVAL);
     180                ipc_answer_0(callid, EINVAL);
     181                ipc_answer_0(rid, EINVAL);
    182182                return;
    183183        }
     
    190190        if (!fs_info) {
    191191                dprintf("Could not allocate memory for FS info.\n");
    192                 ipc_answer_fast_0(callid, ENOMEM);
    193                 ipc_answer_fast_0(rid, ENOMEM);
     192                ipc_answer_0(callid, ENOMEM);
     193                ipc_answer_0(rid, ENOMEM);
    194194                return;
    195195        }
    196196        link_initialize(&fs_info->fs_link);
    197197               
    198         rc = ipc_data_deliver(callid, &call, &fs_info->vfs_info, size);
     198        rc = ipc_data_deliver(callid, &fs_info->vfs_info, size);
    199199        if (rc != EOK) {
    200200                dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n",
    201201                    rc);
    202202                free(fs_info);
    203                 ipc_answer_fast_0(callid, rc);
    204                 ipc_answer_fast_0(rid, rc);
     203                ipc_answer_0(callid, rc);
     204                ipc_answer_0(rid, rc);
    205205                return;
    206206        }
     
    210210        if (!vfs_info_sane(&fs_info->vfs_info)) {
    211211                free(fs_info);
    212                 ipc_answer_fast_0(callid, EINVAL);
    213                 ipc_answer_fast_0(rid, EINVAL);
     212                ipc_answer_0(callid, EINVAL);
     213                ipc_answer_0(rid, EINVAL);
    214214                return;
    215215        }
     
    227227                futex_up(&fs_head_futex);
    228228                free(fs_info);
    229                 ipc_answer_fast_0(callid, EEXISTS);
    230                 ipc_answer_fast_0(rid, EEXISTS);
     229                ipc_answer_0(callid, EEXISTS);
     230                ipc_answer_0(rid, EEXISTS);
    231231                return;
    232232        }
     
    249249                futex_up(&fs_head_futex);
    250250                free(fs_info);
    251                 ipc_answer_fast_0(callid, EINVAL);
    252                 ipc_answer_fast_0(rid, EINVAL);
     251                ipc_answer_0(callid, EINVAL);
     252                ipc_answer_0(rid, EINVAL);
    253253                return;
    254254        }
    255255        fs_info->phone = IPC_GET_ARG3(call);
    256         ipc_answer_fast_0(callid, EOK);
     256        ipc_answer_0(callid, EOK);
    257257
    258258        dprintf("Callback connection to FS created.\n");
     
    268268                ipc_hangup(fs_info->phone);
    269269                free(fs_info);
    270                 ipc_answer_fast_0(callid, EINVAL);
    271                 ipc_answer_fast_0(rid, EINVAL);
     270                ipc_answer_0(callid, EINVAL);
     271                ipc_answer_0(rid, EINVAL);
    272272                return;
    273273        }
     
    283283                ipc_hangup(fs_info->phone);
    284284                free(fs_info);
    285                 ipc_answer_fast_0(callid, EINVAL);
    286                 ipc_answer_fast_0(rid, EINVAL);
     285                ipc_answer_0(callid, EINVAL);
     286                ipc_answer_0(rid, EINVAL);
    287287                return;
    288288        }
     
    291291         * Commit to read-only sharing the PLB with the client.
    292292         */
    293         ipc_answer_fast(callid, EOK, (ipcarg_t) plb,
     293        ipc_answer_2(callid, EOK, (ipcarg_t) plb,
    294294            (ipcarg_t) (AS_AREA_READ | AS_AREA_CACHEABLE));     
    295295
     
    302302         */
    303303        fs_info->fs_handle = (int) atomic_postinc(&fs_handle_next);
    304         ipc_answer_fast_1(rid, EOK, (ipcarg_t) fs_info->fs_handle);
     304        ipc_answer_1(rid, EOK, (ipcarg_t) fs_info->fs_handle);
    305305       
    306306        futex_up(&fs_head_futex);
Note: See TracChangeset for help on using the changeset viewer.