Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devmap/devmap.c

    rab108be4 r4ae90f9  
    4646#include <str.h>
    4747#include <ipc/devmap.h>
     48#include <assert.h>
    4849
    4950#define NAME          "devmap"
    … …  
    6162        link_t devices;
    6263        /** Phone asociated with this driver */
    63         ipcarg_t phone;
     64        sysarg_t phone;
    6465        /** Device driver name */
    6566        char *name;
    … …  
    7576        link_t namespaces;
    7677        /** Unique namespace identifier */
    77         dev_handle_t handle;
     78        devmap_handle_t handle;
    7879        /** Namespace name */
    7980        char *name;
    … …  
    9293        link_t driver_devices;
    9394        /** Unique device identifier */
    94         dev_handle_t handle;
     95        devmap_handle_t handle;
    9596        /** Device namespace */
    9697        devmap_namespace_t *namespace;
    … …  
    99100        /** Device driver handling this device */
    100101        devmap_driver_t *driver;
     102        /** Use this interface when forwarding to driver. */
     103        sysarg_t forward_interface;
    101104} devmap_device_t;
    102105
    … …  
    118121static FIBRIL_MUTEX_INITIALIZE(null_devices_mutex);
    119122
    120 static dev_handle_t last_handle = 0;
     123static devmap_handle_t last_handle = 0;
    121124static devmap_device_t *null_devices[NULL_DEVICES];
    122125
    123 static dev_handle_t devmap_create_handle(void)
     126/*
     127 * Dummy list for null devices. This is necessary so that null devices can
     128 * be used just as any other devices, e.g. in devmap_device_unregister_core().
     129 */
     130static LIST_INITIALIZE(dummy_null_driver_devices);
     131
     132static devmap_handle_t devmap_create_handle(void)
    124133{
    125134        /* TODO: allow reusing old handles after their unregistration
    … …  
    206215}
    207216
    208 /** Find namespace with given name.
    209  *
    210  * The devices_list_mutex should be already held when
    211  * calling this function.
    212  *
    213  */
     217/** Find namespace with given name. */
    214218static devmap_namespace_t *devmap_namespace_find_name(const char *name)
    215219{
    216220        link_t *item;
     221       
     222        assert(fibril_mutex_is_locked(&devices_list_mutex));
     223       
    217224        for (item = namespaces_list.next; item != &namespaces_list; item = item->next) {
    218225                devmap_namespace_t *namespace =
    … …  
    227234/** Find namespace with given handle.
    228235 *
    229  * The devices_list_mutex should be already held when
    230  * calling this function.
    231  *
    232236 * @todo: use hash table
    233237 *
    234238 */
    235 static devmap_namespace_t *devmap_namespace_find_handle(dev_handle_t handle)
     239static devmap_namespace_t *devmap_namespace_find_handle(devmap_handle_t handle)
    236240{
    237241        link_t *item;
     242       
     243        assert(fibril_mutex_is_locked(&devices_list_mutex));
     244       
    238245        for (item = namespaces_list.next; item != &namespaces_list; item = item->next) {
    239246                devmap_namespace_t *namespace =
    … …  
    246253}
    247254
    248 /** Find device with given name.
    249  *
    250  * The devices_list_mutex should be already held when
    251  * calling this function.
    252  *
    253  */
     255/** Find device with given name. */
    254256static devmap_device_t *devmap_device_find_name(const char *ns_name,
    255257    const char *name)
    256258{
    257259        link_t *item;
     260       
     261        assert(fibril_mutex_is_locked(&devices_list_mutex));
     262       
    258263        for (item = devices_list.next; item != &devices_list; item = item->next) {
    259264                devmap_device_t *device =
    … …  
    269274/** Find device with given handle.
    270275 *
    271  * The devices_list_mutex should be already held when
    272  * calling this function.
    273  *
    274276 * @todo: use hash table
    275277 *
    276278 */
    277 static devmap_device_t *devmap_device_find_handle(dev_handle_t handle)
     279static devmap_device_t *devmap_device_find_handle(devmap_handle_t handle)
    278280{
    279281        link_t *item;
     282       
     283        assert(fibril_mutex_is_locked(&devices_list_mutex));
     284       
    280285        for (item = devices_list.next; item != &devices_list; item = item->next) {
    281286                devmap_device_t *device =
    … …  
    288293}
    289294
    290 /** Create a namespace (if not already present)
    291  *
    292  * The devices_list_mutex should be already held when
    293  * calling this function.
    294  *
    295  */
     295/** Create a namespace (if not already present). */
    296296static devmap_namespace_t *devmap_namespace_create(const char *ns_name)
    297297{
    298         devmap_namespace_t *namespace = devmap_namespace_find_name(ns_name);
     298        devmap_namespace_t *namespace;
     299       
     300        assert(fibril_mutex_is_locked(&devices_list_mutex));
     301       
     302        namespace = devmap_namespace_find_name(ns_name);
    299303        if (namespace != NULL)
    300304                return namespace;
    … …  
    321325}
    322326
    323 /** Destroy a namespace (if it is no longer needed)
    324  *
    325  * The devices_list_mutex should be already held when
    326  * calling this function.
    327  *
    328  */
     327/** Destroy a namespace (if it is no longer needed). */
    329328static void devmap_namespace_destroy(devmap_namespace_t *namespace)
    330329{
     330        assert(fibril_mutex_is_locked(&devices_list_mutex));
     331
    331332        if (namespace->refcnt == 0) {
    332333                list_remove(&(namespace->namespaces));
    … …  
    337338}
    338339
    339 /** Increase namespace reference count by including device
    340  *
    341  * The devices_list_mutex should be already held when
    342  * calling this function.
    343  *
    344  */
     340/** Increase namespace reference count by including device. */
    345341static void devmap_namespace_addref(devmap_namespace_t *namespace,
    346342    devmap_device_t *device)
    347343{
     344        assert(fibril_mutex_is_locked(&devices_list_mutex));
     345
    348346        device->namespace = namespace;
    349347        namespace->refcnt++;
    350348}
    351349
    352 /** Decrease namespace reference count
    353  *
    354  * The devices_list_mutex should be already held when
    355  * calling this function.
    356  *
    357  */
     350/** Decrease namespace reference count. */
    358351static void devmap_namespace_delref(devmap_namespace_t *namespace)
    359352{
     353        assert(fibril_mutex_is_locked(&devices_list_mutex));
     354
    360355        namespace->refcnt--;
    361356        devmap_namespace_destroy(namespace);
    362357}
    363358
    364 /** Unregister device and free it
    365  *
    366  * The devices_list_mutex should be already held when
    367  * calling this function.
    368  *
    369  */
     359/** Unregister device and free it. */
    370360static void devmap_device_unregister_core(devmap_device_t *device)
    371361{
     362        assert(fibril_mutex_is_locked(&devices_list_mutex));
     363
    372364        devmap_namespace_delref(device->namespace);
    373365        list_remove(&(device->devices));
    … …  
    387379        ipc_callid_t iid = async_get_call(&icall);
    388380       
    389         if (IPC_GET_METHOD(icall) != DEVMAP_DRIVER_REGISTER) {
    390                 ipc_answer_0(iid, EREFUSED);
     381        if (IPC_GET_IMETHOD(icall) != DEVMAP_DRIVER_REGISTER) {
     382                async_answer_0(iid, EREFUSED);
    391383                return NULL;
    392384        }
    … …  
    395387            (devmap_driver_t *) malloc(sizeof(devmap_driver_t));
    396388        if (driver == NULL) {
    397                 ipc_answer_0(iid, ENOMEM);
     389                async_answer_0(iid, ENOMEM);
    398390                return NULL;
    399391        }
    … …  
    406398        if (rc != EOK) {
    407399                free(driver);
    408                 ipc_answer_0(iid, rc);
     400                async_answer_0(iid, rc);
    409401                return NULL;
    410402        }
    … …  
    416408        ipc_callid_t callid = async_get_call(&call);
    417409       
    418         if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
     410        if (IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) {
    419411                free(driver->name);
    420412                free(driver);
    421                 ipc_answer_0(callid, ENOTSUP);
    422                 ipc_answer_0(iid, ENOTSUP);
     413                async_answer_0(callid, ENOTSUP);
     414                async_answer_0(iid, ENOTSUP);
    423415                return NULL;
    424416        }
    425417       
    426418        driver->phone = IPC_GET_ARG5(call);
    427         ipc_answer_0(callid, EOK);
     419        async_answer_0(callid, EOK);
    428420       
    429421        /*
    … …  
    437429         */
    438430        list_initialize(&driver->devices);
    439         list_initialize(&(driver->drivers));
     431
     432        link_initialize(&driver->drivers);
    440433       
    441434        fibril_mutex_lock(&drivers_list_mutex);
    … …  
    452445        fibril_mutex_unlock(&drivers_list_mutex);
    453446       
    454         ipc_answer_0(iid, EOK);
     447        async_answer_0(iid, EOK);
    455448       
    456449        return driver;
    … …  
    470463       
    471464        if (driver->phone != 0)
    472                 ipc_hangup(driver->phone);
     465                async_hangup(driver->phone);
    473466       
    474467        /* Remove it from list of drivers */
    … …  
    505498{
    506499        if (driver == NULL) {
    507                 ipc_answer_0(iid, EREFUSED);
     500                async_answer_0(iid, EREFUSED);
    508501                return;
    509502        }
    … …  
    513506            (devmap_device_t *) malloc(sizeof(devmap_device_t));
    514507        if (device == NULL) {
    515                 ipc_answer_0(iid, ENOMEM);
    516                 return;
    517         }
    518        
     508                async_answer_0(iid, ENOMEM);
     509                return;
     510        }
     511       
     512        /* Set the interface, if any. */
     513        device->forward_interface = IPC_GET_ARG1(*icall);
     514
    519515        /* Get fqdn */
    520516        char *fqdn;
    … …  
    523519        if (rc != EOK) {
    524520                free(device);
    525                 ipc_answer_0(iid, rc);
     521                async_answer_0(iid, rc);
    526522                return;
    527523        }
    … …  
    531527                free(fqdn);
    532528                free(device);
    533                 ipc_answer_0(iid, EINVAL);
     529                async_answer_0(iid, EINVAL);
    534530                return;
    535531        }
    … …  
    545541                free(device->name);
    546542                free(device);
    547                 ipc_answer_0(iid, ENOMEM);
    548                 return;
    549         }
    550        
    551         list_initialize(&(device->devices));
    552         list_initialize(&(device->driver_devices));
     543                async_answer_0(iid, ENOMEM);
     544                return;
     545        }
     546       
     547        link_initialize(&device->devices);
     548        link_initialize(&device->driver_devices);
    553549       
    554550        /* Check that device is not already registered */
    555551        if (devmap_device_find_name(namespace->name, device->name) != NULL) {
    556552                printf("%s: Device '%s/%s' already registered\n", NAME,
    557                     device->namespace, device->name);
     553                    namespace->name, device->name);
    558554                devmap_namespace_destroy(namespace);
    559555                fibril_mutex_unlock(&devices_list_mutex);
    560556                free(device->name);
    561557                free(device);
    562                 ipc_answer_0(iid, EEXISTS);
     558                async_answer_0(iid, EEXISTS);
    563559                return;
    564560        }
    … …  
    566562        /* Get unique device handle */
    567563        device->handle = devmap_create_handle();
    568        
     564
    569565        devmap_namespace_addref(namespace, device);
    570566        device->driver = driver;
    … …  
    582578        fibril_mutex_unlock(&devices_list_mutex);
    583579       
    584         ipc_answer_1(iid, EOK, device->handle);
     580        async_answer_1(iid, EOK, device->handle);
    585581}
    586582
    … …  
    608604         * Get handle from request
    609605         */
    610         dev_handle_t handle = IPC_GET_ARG2(*call);
     606        devmap_handle_t handle = IPC_GET_ARG2(*call);
    611607        devmap_device_t *dev = devmap_device_find_handle(handle);
    612608       
    613609        if ((dev == NULL) || (dev->driver == NULL) || (dev->driver->phone == 0)) {
    614610                fibril_mutex_unlock(&devices_list_mutex);
    615                 ipc_answer_0(callid, ENOENT);
    616                 return;
    617         }
    618        
    619         ipc_forward_fast(callid, dev->driver->phone, dev->handle,
    620             IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
     611                async_answer_0(callid, ENOENT);
     612                return;
     613        }
     614       
     615        if (dev->forward_interface == 0) {
     616                async_forward_fast(callid, dev->driver->phone,
     617                    dev->handle, 0, 0,
     618                    IPC_FF_NONE);
     619        } else {
     620                async_forward_fast(callid, dev->driver->phone,
     621                    dev->forward_interface, dev->handle, 0,
     622                    IPC_FF_NONE);
     623        }
    621624       
    622625        fibril_mutex_unlock(&devices_list_mutex);
    … …  
    637640            DEVMAP_NAME_MAXLEN, 0, NULL);
    638641        if (rc != EOK) {
    639                 ipc_answer_0(iid, rc);
     642                async_answer_0(iid, rc);
    640643                return;
    641644        }
    … …  
    645648        if (!devmap_fqdn_split(fqdn, &ns_name, &name)) {
    646649                free(fqdn);
    647                 ipc_answer_0(iid, EINVAL);
     650                async_answer_0(iid, EINVAL);
    648651                return;
    649652        }
    … …  
    672675                }
    673676               
    674                 ipc_answer_0(iid, ENOENT);
     677                async_answer_0(iid, ENOENT);
    675678                free(ns_name);
    676679                free(name);
    … …  
    679682        }
    680683       
    681         ipc_answer_1(iid, EOK, dev->handle);
     684        async_answer_1(iid, EOK, dev->handle);
    682685       
    683686        fibril_mutex_unlock(&devices_list_mutex);
    … …  
    700703            DEVMAP_NAME_MAXLEN, 0, NULL);
    701704        if (rc != EOK) {
    702                 ipc_answer_0(iid, rc);
     705                async_answer_0(iid, rc);
    703706                return;
    704707        }
    … …  
    725728                }
    726729               
    727                 ipc_answer_0(iid, ENOENT);
     730                async_answer_0(iid, ENOENT);
    728731                free(name);
    729732                fibril_mutex_unlock(&devices_list_mutex);
    … …  
    731734        }
    732735       
    733         ipc_answer_1(iid, EOK, namespace->handle);
     736        async_answer_1(iid, EOK, namespace->handle);
    734737       
    735738        fibril_mutex_unlock(&devices_list_mutex);
    … …  
    747750                    devmap_device_find_handle(IPC_GET_ARG1(*icall));
    748751                if (dev == NULL)
    749                         ipc_answer_1(iid, EOK, DEV_HANDLE_NONE);
     752                        async_answer_1(iid, EOK, DEV_HANDLE_NONE);
    750753                else
    751                         ipc_answer_1(iid, EOK, DEV_HANDLE_DEVICE);
     754                        async_answer_1(iid, EOK, DEV_HANDLE_DEVICE);
    752755        } else
    753                 ipc_answer_1(iid, EOK, DEV_HANDLE_NAMESPACE);
     756                async_answer_1(iid, EOK, DEV_HANDLE_NAMESPACE);
    754757       
    755758        fibril_mutex_unlock(&devices_list_mutex);
    … …  
    759762{
    760763        fibril_mutex_lock(&devices_list_mutex);
    761         ipc_answer_1(iid, EOK, list_count(&namespaces_list));
     764        async_answer_1(iid, EOK, list_count(&namespaces_list));
    762765        fibril_mutex_unlock(&devices_list_mutex);
    763766}
    … …  
    770773            devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
    771774        if (namespace == NULL)
    772                 ipc_answer_0(iid, EEXISTS);
     775                async_answer_0(iid, EEXISTS);
    773776        else
    774                 ipc_answer_1(iid, EOK, namespace->refcnt);
     777                async_answer_1(iid, EOK, namespace->refcnt);
    775778       
    776779        fibril_mutex_unlock(&devices_list_mutex);
    … …  
    782785        size_t size;
    783786        if (!async_data_read_receive(&callid, &size)) {
    784                 ipc_answer_0(callid, EREFUSED);
    785                 ipc_answer_0(iid, EREFUSED);
     787                async_answer_0(callid, EREFUSED);
     788                async_answer_0(iid, EREFUSED);
    786789                return;
    787790        }
    788791       
    789792        if ((size % sizeof(dev_desc_t)) != 0) {
    790                 ipc_answer_0(callid, EINVAL);
    791                 ipc_answer_0(iid, EINVAL);
     793                async_answer_0(callid, EINVAL);
     794                async_answer_0(iid, EINVAL);
    792795                return;
    793796        }
    … …  
    798801        if (count != list_count(&namespaces_list)) {
    799802                fibril_mutex_unlock(&devices_list_mutex);
    800                 ipc_answer_0(callid, EOVERFLOW);
    801                 ipc_answer_0(iid, EOVERFLOW);
     803                async_answer_0(callid, EOVERFLOW);
     804                async_answer_0(iid, EOVERFLOW);
    802805                return;
    803806        }
    … …  
    806809        if (desc == NULL) {
    807810                fibril_mutex_unlock(&devices_list_mutex);
    808                 ipc_answer_0(callid, ENOMEM);
    809                 ipc_answer_0(iid, ENOMEM);
     811                async_answer_0(callid, ENOMEM);
     812                async_answer_0(iid, ENOMEM);
    810813                return;
    811814        }
    … …  
    823826        }
    824827       
    825         ipcarg_t retval = async_data_read_finalize(callid, desc, size);
     828        sysarg_t retval = async_data_read_finalize(callid, desc, size);
    826829       
    827830        free(desc);
    828831        fibril_mutex_unlock(&devices_list_mutex);
    829832       
    830         ipc_answer_0(iid, retval);
     833        async_answer_0(iid, retval);
    831834}
    832835
    … …  
    839842        size_t size;
    840843        if (!async_data_read_receive(&callid, &size)) {
    841                 ipc_answer_0(callid, EREFUSED);
    842                 ipc_answer_0(iid, EREFUSED);
     844                async_answer_0(callid, EREFUSED);
     845                async_answer_0(iid, EREFUSED);
    843846                return;
    844847        }
    845848       
    846849        if ((size % sizeof(dev_desc_t)) != 0) {
    847                 ipc_answer_0(callid, EINVAL);
    848                 ipc_answer_0(iid, EINVAL);
     850                async_answer_0(callid, EINVAL);
     851                async_answer_0(iid, EINVAL);
    849852                return;
    850853        }
    … …  
    856859        if (namespace == NULL) {
    857860                fibril_mutex_unlock(&devices_list_mutex);
    858                 ipc_answer_0(callid, ENOENT);
    859                 ipc_answer_0(iid, ENOENT);
     861                async_answer_0(callid, ENOENT);
     862                async_answer_0(iid, ENOENT);
    860863                return;
    861864        }
    … …  
    864867        if (count != namespace->refcnt) {
    865868                fibril_mutex_unlock(&devices_list_mutex);
    866                 ipc_answer_0(callid, EOVERFLOW);
    867                 ipc_answer_0(iid, EOVERFLOW);
     869                async_answer_0(callid, EOVERFLOW);
     870                async_answer_0(iid, EOVERFLOW);
    868871                return;
    869872        }
    … …  
    872875        if (desc == NULL) {
    873876                fibril_mutex_unlock(&devices_list_mutex);
    874                 ipc_answer_0(callid, ENOMEM);
    875                 ipc_answer_0(iid, EREFUSED);
     877                async_answer_0(callid, ENOMEM);
     878                async_answer_0(iid, EREFUSED);
    876879                return;
    877880        }
    … …  
    890893        }
    891894       
    892         ipcarg_t retval = async_data_read_finalize(callid, desc, size);
     895        sysarg_t retval = async_data_read_finalize(callid, desc, size);
    893896       
    894897        free(desc);
    895898        fibril_mutex_unlock(&devices_list_mutex);
    896899       
    897         ipc_answer_0(iid, retval);
     900        async_answer_0(iid, retval);
    898901}
    899902
    … …  
    914917        if (!fnd) {
    915918                fibril_mutex_unlock(&null_devices_mutex);
    916                 ipc_answer_0(iid, ENOMEM);
     919                async_answer_0(iid, ENOMEM);
    917920                return;
    918921        }
    … …  
    924927        if (dev_name == NULL) {
    925928                fibril_mutex_unlock(&null_devices_mutex);
    926                 ipc_answer_0(iid, ENOMEM);
     929                async_answer_0(iid, ENOMEM);
    927930                return;
    928931        }
    … …  
    932935        if (device == NULL) {
    933936                fibril_mutex_unlock(&null_devices_mutex);
    934                 ipc_answer_0(iid, ENOMEM);
     937                async_answer_0(iid, ENOMEM);
    935938                return;
    936939        }
    … …  
    942945                fibril_mutex_lock(&devices_list_mutex);
    943946                fibril_mutex_unlock(&null_devices_mutex);
    944                 ipc_answer_0(iid, ENOMEM);
    945                 return;
    946         }
    947        
    948         list_initialize(&(device->devices));
    949         list_initialize(&(device->driver_devices));
     947                async_answer_0(iid, ENOMEM);
     948                return;
     949        }
     950       
     951        link_initialize(&device->devices);
     952        link_initialize(&device->driver_devices);
    950953       
    951954        /* Get unique device handle */
    … …  
    956959        device->name = dev_name;
    957960       
    958         /* Insert device into list of all devices
    959            and into null devices array */
     961        /*
     962         * Insert device into list of all devices and into null devices array.
     963         * Insert device into a dummy list of null driver's devices so that it
     964         * can be safely removed later.
     965         */
    960966        list_append(&device->devices, &devices_list);
     967        list_append(&device->driver_devices, &dummy_null_driver_devices);
    961968        null_devices[i] = device;
    962969       
    … …  
    964971        fibril_mutex_unlock(&null_devices_mutex);
    965972       
    966         ipc_answer_1(iid, EOK, (ipcarg_t) i);
     973        async_answer_1(iid, EOK, (sysarg_t) i);
    967974}
    968975
    969976static void devmap_null_destroy(ipc_callid_t iid, ipc_call_t *icall)
    970977{
    971         ipcarg_t i = IPC_GET_ARG1(*icall);
     978        sysarg_t i = IPC_GET_ARG1(*icall);
    972979        if (i >= NULL_DEVICES) {
    973                 ipc_answer_0(iid, ELIMIT);
     980                async_answer_0(iid, ELIMIT);
    974981                return;
    975982        }
    … …  
    979986        if (null_devices[i] == NULL) {
    980987                fibril_mutex_unlock(&null_devices_mutex);
    981                 ipc_answer_0(iid, ENOENT);
     988                async_answer_0(iid, ENOENT);
    982989                return;
    983990        }
    … …  
    990997       
    991998        fibril_mutex_unlock(&null_devices_mutex);
    992         ipc_answer_0(iid, EOK);
     999        async_answer_0(iid, EOK);
    9931000}
    9941001
    … …  
    10161023{
    10171024        /* Accept connection */
    1018         ipc_answer_0(iid, EOK);
     1025        async_answer_0(iid, EOK);
    10191026       
    10201027        devmap_driver_t *driver = devmap_driver_register();
    … …  
    10271034                ipc_callid_t callid = async_get_call(&call);
    10281035               
    1029                 switch (IPC_GET_METHOD(call)) {
     1036                switch (IPC_GET_IMETHOD(call)) {
    10301037                case IPC_M_PHONE_HUNGUP:
    10311038                        cont = false;
    … …  
    10331040                case DEVMAP_DRIVER_UNREGISTER:
    10341041                        if (NULL == driver)
    1035                                 ipc_answer_0(callid, ENOENT);
     1042                                async_answer_0(callid, ENOENT);
    10361043                        else
    1037                                 ipc_answer_0(callid, EOK);
     1044                                async_answer_0(callid, EOK);
    10381045                        break;
    10391046                case DEVMAP_DEVICE_REGISTER:
    … …  
    10521059                        break;
    10531060                default:
    1054                         if (!(callid & IPC_CALLID_NOTIFICATION))
    1055                                 ipc_answer_0(callid, ENOENT);
     1061                        async_answer_0(callid, ENOENT);
    10561062                }
    10571063        }
    … …  
    10721078{
    10731079        /* Accept connection */
    1074         ipc_answer_0(iid, EOK);
     1080        async_answer_0(iid, EOK);
    10751081       
    10761082        bool cont = true;
    … …  
    10791085                ipc_callid_t callid = async_get_call(&call);
    10801086               
    1081                 switch (IPC_GET_METHOD(call)) {
     1087                switch (IPC_GET_IMETHOD(call)) {
    10821088                case IPC_M_PHONE_HUNGUP:
    10831089                        cont = false;
    … …  
    11111117                        break;
    11121118                default:
    1113                         if (!(callid & IPC_CALLID_NOTIFICATION))
    1114                                 ipc_answer_0(callid, ENOENT);
     1119                        async_answer_0(callid, ENOENT);
    11151120                }
    11161121        }
    … …  
    11231128{
    11241129        /* Select interface */
    1125         switch ((ipcarg_t) (IPC_GET_ARG1(*icall))) {
     1130        switch ((sysarg_t) (IPC_GET_ARG1(*icall))) {
    11261131        case DEVMAP_DRIVER:
    11271132                devmap_connection_driver(iid, icall);
    … …  
    11361141        default:
    11371142                /* No such interface */
    1138                 ipc_answer_0(iid, ENOENT);
     1143                async_answer_0(iid, ENOENT);
    11391144        }
    11401145}
    … …  
    11561161       
    11571162        /* Register device mapper at naming service */
    1158         ipcarg_t phonead;
    1159         if (ipc_connect_to_me(PHONE_NS, SERVICE_DEVMAP, 0, 0, &phonead) != 0)
     1163        if (service_register(SERVICE_DEVMAP) != EOK)
    11601164                return -1;
    11611165       
Note: See TracChangeset for help on using the changeset viewer.