Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devmap/devmap.c

    r4ae90f9 rab108be4  
    4646#include <str.h>
    4747#include <ipc/devmap.h>
    48 #include <assert.h>
    4948
    5049#define NAME          "devmap"
    … …  
    6261        link_t devices;
    6362        /** Phone asociated with this driver */
    64         sysarg_t phone;
     63        ipcarg_t phone;
    6564        /** Device driver name */
    6665        char *name;
    … …  
    7675        link_t namespaces;
    7776        /** Unique namespace identifier */
    78         devmap_handle_t handle;
     77        dev_handle_t handle;
    7978        /** Namespace name */
    8079        char *name;
    … …  
    9392        link_t driver_devices;
    9493        /** Unique device identifier */
    95         devmap_handle_t handle;
     94        dev_handle_t handle;
    9695        /** Device namespace */
    9796        devmap_namespace_t *namespace;
    … …  
    10099        /** Device driver handling this device */
    101100        devmap_driver_t *driver;
    102         /** Use this interface when forwarding to driver. */
    103         sysarg_t forward_interface;
    104101} devmap_device_t;
    105102
    … …  
    121118static FIBRIL_MUTEX_INITIALIZE(null_devices_mutex);
    122119
    123 static devmap_handle_t last_handle = 0;
     120static dev_handle_t last_handle = 0;
    124121static devmap_device_t *null_devices[NULL_DEVICES];
    125122
    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  */
    130 static LIST_INITIALIZE(dummy_null_driver_devices);
    131 
    132 static devmap_handle_t devmap_create_handle(void)
     123static dev_handle_t devmap_create_handle(void)
    133124{
    134125        /* TODO: allow reusing old handles after their unregistration
    … …  
    215206}
    216207
    217 /** Find namespace with given name. */
     208/** Find namespace with given name.
     209 *
     210 * The devices_list_mutex should be already held when
     211 * calling this function.
     212 *
     213 */
    218214static devmap_namespace_t *devmap_namespace_find_name(const char *name)
    219215{
    220216        link_t *item;
    221        
    222         assert(fibril_mutex_is_locked(&devices_list_mutex));
    223        
    224217        for (item = namespaces_list.next; item != &namespaces_list; item = item->next) {
    225218                devmap_namespace_t *namespace =
    … …  
    234227/** Find namespace with given handle.
    235228 *
     229 * The devices_list_mutex should be already held when
     230 * calling this function.
     231 *
    236232 * @todo: use hash table
    237233 *
    238234 */
    239 static devmap_namespace_t *devmap_namespace_find_handle(devmap_handle_t handle)
     235static devmap_namespace_t *devmap_namespace_find_handle(dev_handle_t handle)
    240236{
    241237        link_t *item;
    242        
    243         assert(fibril_mutex_is_locked(&devices_list_mutex));
    244        
    245238        for (item = namespaces_list.next; item != &namespaces_list; item = item->next) {
    246239                devmap_namespace_t *namespace =
    … …  
    253246}
    254247
    255 /** Find device with given name. */
     248/** Find device with given name.
     249 *
     250 * The devices_list_mutex should be already held when
     251 * calling this function.
     252 *
     253 */
    256254static devmap_device_t *devmap_device_find_name(const char *ns_name,
    257255    const char *name)
    258256{
    259257        link_t *item;
    260        
    261         assert(fibril_mutex_is_locked(&devices_list_mutex));
    262        
    263258        for (item = devices_list.next; item != &devices_list; item = item->next) {
    264259                devmap_device_t *device =
    … …  
    274269/** Find device with given handle.
    275270 *
     271 * The devices_list_mutex should be already held when
     272 * calling this function.
     273 *
    276274 * @todo: use hash table
    277275 *
    278276 */
    279 static devmap_device_t *devmap_device_find_handle(devmap_handle_t handle)
     277static devmap_device_t *devmap_device_find_handle(dev_handle_t handle)
    280278{
    281279        link_t *item;
    282        
    283         assert(fibril_mutex_is_locked(&devices_list_mutex));
    284        
    285280        for (item = devices_list.next; item != &devices_list; item = item->next) {
    286281                devmap_device_t *device =
    … …  
    293288}
    294289
    295 /** Create a namespace (if not already present). */
     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 */
    296296static devmap_namespace_t *devmap_namespace_create(const char *ns_name)
    297297{
    298         devmap_namespace_t *namespace;
    299        
    300         assert(fibril_mutex_is_locked(&devices_list_mutex));
    301        
    302         namespace = devmap_namespace_find_name(ns_name);
     298        devmap_namespace_t *namespace = devmap_namespace_find_name(ns_name);
    303299        if (namespace != NULL)
    304300                return namespace;
    … …  
    325321}
    326322
    327 /** Destroy a namespace (if it is no longer needed). */
     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 */
    328329static void devmap_namespace_destroy(devmap_namespace_t *namespace)
    329330{
    330         assert(fibril_mutex_is_locked(&devices_list_mutex));
    331 
    332331        if (namespace->refcnt == 0) {
    333332                list_remove(&(namespace->namespaces));
    … …  
    338337}
    339338
    340 /** Increase namespace reference count by including device. */
     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 */
    341345static void devmap_namespace_addref(devmap_namespace_t *namespace,
    342346    devmap_device_t *device)
    343347{
    344         assert(fibril_mutex_is_locked(&devices_list_mutex));
    345 
    346348        device->namespace = namespace;
    347349        namespace->refcnt++;
    348350}
    349351
    350 /** Decrease namespace reference count. */
     352/** Decrease namespace reference count
     353 *
     354 * The devices_list_mutex should be already held when
     355 * calling this function.
     356 *
     357 */
    351358static void devmap_namespace_delref(devmap_namespace_t *namespace)
    352359{
    353         assert(fibril_mutex_is_locked(&devices_list_mutex));
    354 
    355360        namespace->refcnt--;
    356361        devmap_namespace_destroy(namespace);
    357362}
    358363
    359 /** Unregister device and free it. */
     364/** Unregister device and free it
     365 *
     366 * The devices_list_mutex should be already held when
     367 * calling this function.
     368 *
     369 */
    360370static void devmap_device_unregister_core(devmap_device_t *device)
    361371{
    362         assert(fibril_mutex_is_locked(&devices_list_mutex));
    363 
    364372        devmap_namespace_delref(device->namespace);
    365373        list_remove(&(device->devices));
    … …  
    379387        ipc_callid_t iid = async_get_call(&icall);
    380388       
    381         if (IPC_GET_IMETHOD(icall) != DEVMAP_DRIVER_REGISTER) {
    382                 async_answer_0(iid, EREFUSED);
     389        if (IPC_GET_METHOD(icall) != DEVMAP_DRIVER_REGISTER) {
     390                ipc_answer_0(iid, EREFUSED);
    383391                return NULL;
    384392        }
    … …  
    387395            (devmap_driver_t *) malloc(sizeof(devmap_driver_t));
    388396        if (driver == NULL) {
    389                 async_answer_0(iid, ENOMEM);
     397                ipc_answer_0(iid, ENOMEM);
    390398                return NULL;
    391399        }
    … …  
    398406        if (rc != EOK) {
    399407                free(driver);
    400                 async_answer_0(iid, rc);
     408                ipc_answer_0(iid, rc);
    401409                return NULL;
    402410        }
    … …  
    408416        ipc_callid_t callid = async_get_call(&call);
    409417       
    410         if (IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) {
     418        if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
    411419                free(driver->name);
    412420                free(driver);
    413                 async_answer_0(callid, ENOTSUP);
    414                 async_answer_0(iid, ENOTSUP);
     421                ipc_answer_0(callid, ENOTSUP);
     422                ipc_answer_0(iid, ENOTSUP);
    415423                return NULL;
    416424        }
    417425       
    418426        driver->phone = IPC_GET_ARG5(call);
    419         async_answer_0(callid, EOK);
     427        ipc_answer_0(callid, EOK);
    420428       
    421429        /*
    … …  
    429437         */
    430438        list_initialize(&driver->devices);
    431 
    432         link_initialize(&driver->drivers);
     439        list_initialize(&(driver->drivers));
    433440       
    434441        fibril_mutex_lock(&drivers_list_mutex);
    … …  
    445452        fibril_mutex_unlock(&drivers_list_mutex);
    446453       
    447         async_answer_0(iid, EOK);
     454        ipc_answer_0(iid, EOK);
    448455       
    449456        return driver;
    … …  
    463470       
    464471        if (driver->phone != 0)
    465                 async_hangup(driver->phone);
     472                ipc_hangup(driver->phone);
    466473       
    467474        /* Remove it from list of drivers */
    … …  
    498505{
    499506        if (driver == NULL) {
    500                 async_answer_0(iid, EREFUSED);
     507                ipc_answer_0(iid, EREFUSED);
    501508                return;
    502509        }
    … …  
    506513            (devmap_device_t *) malloc(sizeof(devmap_device_t));
    507514        if (device == NULL) {
    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 
     515                ipc_answer_0(iid, ENOMEM);
     516                return;
     517        }
     518       
    515519        /* Get fqdn */
    516520        char *fqdn;
    … …  
    519523        if (rc != EOK) {
    520524                free(device);
    521                 async_answer_0(iid, rc);
     525                ipc_answer_0(iid, rc);
    522526                return;
    523527        }
    … …  
    527531                free(fqdn);
    528532                free(device);
    529                 async_answer_0(iid, EINVAL);
     533                ipc_answer_0(iid, EINVAL);
    530534                return;
    531535        }
    … …  
    541545                free(device->name);
    542546                free(device);
    543                 async_answer_0(iid, ENOMEM);
    544                 return;
    545         }
    546        
    547         link_initialize(&device->devices);
    548         link_initialize(&device->driver_devices);
     547                ipc_answer_0(iid, ENOMEM);
     548                return;
     549        }
     550       
     551        list_initialize(&(device->devices));
     552        list_initialize(&(device->driver_devices));
    549553       
    550554        /* Check that device is not already registered */
    551555        if (devmap_device_find_name(namespace->name, device->name) != NULL) {
    552556                printf("%s: Device '%s/%s' already registered\n", NAME,
    553                     namespace->name, device->name);
     557                    device->namespace, device->name);
    554558                devmap_namespace_destroy(namespace);
    555559                fibril_mutex_unlock(&devices_list_mutex);
    556560                free(device->name);
    557561                free(device);
    558                 async_answer_0(iid, EEXISTS);
     562                ipc_answer_0(iid, EEXISTS);
    559563                return;
    560564        }
    … …  
    562566        /* Get unique device handle */
    563567        device->handle = devmap_create_handle();
    564 
     568       
    565569        devmap_namespace_addref(namespace, device);
    566570        device->driver = driver;
    … …  
    578582        fibril_mutex_unlock(&devices_list_mutex);
    579583       
    580         async_answer_1(iid, EOK, device->handle);
     584        ipc_answer_1(iid, EOK, device->handle);
    581585}
    582586
    … …  
    604608         * Get handle from request
    605609         */
    606         devmap_handle_t handle = IPC_GET_ARG2(*call);
     610        dev_handle_t handle = IPC_GET_ARG2(*call);
    607611        devmap_device_t *dev = devmap_device_find_handle(handle);
    608612       
    609613        if ((dev == NULL) || (dev->driver == NULL) || (dev->driver->phone == 0)) {
    610614                fibril_mutex_unlock(&devices_list_mutex);
    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         }
     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);
    624621       
    625622        fibril_mutex_unlock(&devices_list_mutex);
    … …  
    640637            DEVMAP_NAME_MAXLEN, 0, NULL);
    641638        if (rc != EOK) {
    642                 async_answer_0(iid, rc);
     639                ipc_answer_0(iid, rc);
    643640                return;
    644641        }
    … …  
    648645        if (!devmap_fqdn_split(fqdn, &ns_name, &name)) {
    649646                free(fqdn);
    650                 async_answer_0(iid, EINVAL);
     647                ipc_answer_0(iid, EINVAL);
    651648                return;
    652649        }
    … …  
    675672                }
    676673               
    677                 async_answer_0(iid, ENOENT);
     674                ipc_answer_0(iid, ENOENT);
    678675                free(ns_name);
    679676                free(name);
    … …  
    682679        }
    683680       
    684         async_answer_1(iid, EOK, dev->handle);
     681        ipc_answer_1(iid, EOK, dev->handle);
    685682       
    686683        fibril_mutex_unlock(&devices_list_mutex);
    … …  
    703700            DEVMAP_NAME_MAXLEN, 0, NULL);
    704701        if (rc != EOK) {
    705                 async_answer_0(iid, rc);
     702                ipc_answer_0(iid, rc);
    706703                return;
    707704        }
    … …  
    728725                }
    729726               
    730                 async_answer_0(iid, ENOENT);
     727                ipc_answer_0(iid, ENOENT);
    731728                free(name);
    732729                fibril_mutex_unlock(&devices_list_mutex);
    … …  
    734731        }
    735732       
    736         async_answer_1(iid, EOK, namespace->handle);
     733        ipc_answer_1(iid, EOK, namespace->handle);
    737734       
    738735        fibril_mutex_unlock(&devices_list_mutex);
    … …  
    750747                    devmap_device_find_handle(IPC_GET_ARG1(*icall));
    751748                if (dev == NULL)
    752                         async_answer_1(iid, EOK, DEV_HANDLE_NONE);
     749                        ipc_answer_1(iid, EOK, DEV_HANDLE_NONE);
    753750                else
    754                         async_answer_1(iid, EOK, DEV_HANDLE_DEVICE);
     751                        ipc_answer_1(iid, EOK, DEV_HANDLE_DEVICE);
    755752        } else
    756                 async_answer_1(iid, EOK, DEV_HANDLE_NAMESPACE);
     753                ipc_answer_1(iid, EOK, DEV_HANDLE_NAMESPACE);
    757754       
    758755        fibril_mutex_unlock(&devices_list_mutex);
    … …  
    762759{
    763760        fibril_mutex_lock(&devices_list_mutex);
    764         async_answer_1(iid, EOK, list_count(&namespaces_list));
     761        ipc_answer_1(iid, EOK, list_count(&namespaces_list));
    765762        fibril_mutex_unlock(&devices_list_mutex);
    766763}
    … …  
    773770            devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
    774771        if (namespace == NULL)
    775                 async_answer_0(iid, EEXISTS);
     772                ipc_answer_0(iid, EEXISTS);
    776773        else
    777                 async_answer_1(iid, EOK, namespace->refcnt);
     774                ipc_answer_1(iid, EOK, namespace->refcnt);
    778775       
    779776        fibril_mutex_unlock(&devices_list_mutex);
    … …  
    785782        size_t size;
    786783        if (!async_data_read_receive(&callid, &size)) {
    787                 async_answer_0(callid, EREFUSED);
    788                 async_answer_0(iid, EREFUSED);
     784                ipc_answer_0(callid, EREFUSED);
     785                ipc_answer_0(iid, EREFUSED);
    789786                return;
    790787        }
    791788       
    792789        if ((size % sizeof(dev_desc_t)) != 0) {
    793                 async_answer_0(callid, EINVAL);
    794                 async_answer_0(iid, EINVAL);
     790                ipc_answer_0(callid, EINVAL);
     791                ipc_answer_0(iid, EINVAL);
    795792                return;
    796793        }
    … …  
    801798        if (count != list_count(&namespaces_list)) {
    802799                fibril_mutex_unlock(&devices_list_mutex);
    803                 async_answer_0(callid, EOVERFLOW);
    804                 async_answer_0(iid, EOVERFLOW);
     800                ipc_answer_0(callid, EOVERFLOW);
     801                ipc_answer_0(iid, EOVERFLOW);
    805802                return;
    806803        }
    … …  
    809806        if (desc == NULL) {
    810807                fibril_mutex_unlock(&devices_list_mutex);
    811                 async_answer_0(callid, ENOMEM);
    812                 async_answer_0(iid, ENOMEM);
     808                ipc_answer_0(callid, ENOMEM);
     809                ipc_answer_0(iid, ENOMEM);
    813810                return;
    814811        }
    … …  
    826823        }
    827824       
    828         sysarg_t retval = async_data_read_finalize(callid, desc, size);
     825        ipcarg_t retval = async_data_read_finalize(callid, desc, size);
    829826       
    830827        free(desc);
    831828        fibril_mutex_unlock(&devices_list_mutex);
    832829       
    833         async_answer_0(iid, retval);
     830        ipc_answer_0(iid, retval);
    834831}
    835832
    … …  
    842839        size_t size;
    843840        if (!async_data_read_receive(&callid, &size)) {
    844                 async_answer_0(callid, EREFUSED);
    845                 async_answer_0(iid, EREFUSED);
     841                ipc_answer_0(callid, EREFUSED);
     842                ipc_answer_0(iid, EREFUSED);
    846843                return;
    847844        }
    848845       
    849846        if ((size % sizeof(dev_desc_t)) != 0) {
    850                 async_answer_0(callid, EINVAL);
    851                 async_answer_0(iid, EINVAL);
     847                ipc_answer_0(callid, EINVAL);
     848                ipc_answer_0(iid, EINVAL);
    852849                return;
    853850        }
    … …  
    859856        if (namespace == NULL) {
    860857                fibril_mutex_unlock(&devices_list_mutex);
    861                 async_answer_0(callid, ENOENT);
    862                 async_answer_0(iid, ENOENT);
     858                ipc_answer_0(callid, ENOENT);
     859                ipc_answer_0(iid, ENOENT);
    863860                return;
    864861        }
    … …  
    867864        if (count != namespace->refcnt) {
    868865                fibril_mutex_unlock(&devices_list_mutex);
    869                 async_answer_0(callid, EOVERFLOW);
    870                 async_answer_0(iid, EOVERFLOW);
     866                ipc_answer_0(callid, EOVERFLOW);
     867                ipc_answer_0(iid, EOVERFLOW);
    871868                return;
    872869        }
    … …  
    875872        if (desc == NULL) {
    876873                fibril_mutex_unlock(&devices_list_mutex);
    877                 async_answer_0(callid, ENOMEM);
    878                 async_answer_0(iid, EREFUSED);
     874                ipc_answer_0(callid, ENOMEM);
     875                ipc_answer_0(iid, EREFUSED);
    879876                return;
    880877        }
    … …  
    893890        }
    894891       
    895         sysarg_t retval = async_data_read_finalize(callid, desc, size);
     892        ipcarg_t retval = async_data_read_finalize(callid, desc, size);
    896893       
    897894        free(desc);
    898895        fibril_mutex_unlock(&devices_list_mutex);
    899896       
    900         async_answer_0(iid, retval);
     897        ipc_answer_0(iid, retval);
    901898}
    902899
    … …  
    917914        if (!fnd) {
    918915                fibril_mutex_unlock(&null_devices_mutex);
    919                 async_answer_0(iid, ENOMEM);
     916                ipc_answer_0(iid, ENOMEM);
    920917                return;
    921918        }
    … …  
    927924        if (dev_name == NULL) {
    928925                fibril_mutex_unlock(&null_devices_mutex);
    929                 async_answer_0(iid, ENOMEM);
     926                ipc_answer_0(iid, ENOMEM);
    930927                return;
    931928        }
    … …  
    935932        if (device == NULL) {
    936933                fibril_mutex_unlock(&null_devices_mutex);
    937                 async_answer_0(iid, ENOMEM);
     934                ipc_answer_0(iid, ENOMEM);
    938935                return;
    939936        }
    … …  
    945942                fibril_mutex_lock(&devices_list_mutex);
    946943                fibril_mutex_unlock(&null_devices_mutex);
    947                 async_answer_0(iid, ENOMEM);
    948                 return;
    949         }
    950        
    951         link_initialize(&device->devices);
    952         link_initialize(&device->driver_devices);
     944                ipc_answer_0(iid, ENOMEM);
     945                return;
     946        }
     947       
     948        list_initialize(&(device->devices));
     949        list_initialize(&(device->driver_devices));
    953950       
    954951        /* Get unique device handle */
    … …  
    959956        device->name = dev_name;
    960957       
    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          */
     958        /* Insert device into list of all devices
     959           and into null devices array */
    966960        list_append(&device->devices, &devices_list);
    967         list_append(&device->driver_devices, &dummy_null_driver_devices);
    968961        null_devices[i] = device;
    969962       
    … …  
    971964        fibril_mutex_unlock(&null_devices_mutex);
    972965       
    973         async_answer_1(iid, EOK, (sysarg_t) i);
     966        ipc_answer_1(iid, EOK, (ipcarg_t) i);
    974967}
    975968
    976969static void devmap_null_destroy(ipc_callid_t iid, ipc_call_t *icall)
    977970{
    978         sysarg_t i = IPC_GET_ARG1(*icall);
     971        ipcarg_t i = IPC_GET_ARG1(*icall);
    979972        if (i >= NULL_DEVICES) {
    980                 async_answer_0(iid, ELIMIT);
     973                ipc_answer_0(iid, ELIMIT);
    981974                return;
    982975        }
    … …  
    986979        if (null_devices[i] == NULL) {
    987980                fibril_mutex_unlock(&null_devices_mutex);
    988                 async_answer_0(iid, ENOENT);
     981                ipc_answer_0(iid, ENOENT);
    989982                return;
    990983        }
    … …  
    997990       
    998991        fibril_mutex_unlock(&null_devices_mutex);
    999         async_answer_0(iid, EOK);
     992        ipc_answer_0(iid, EOK);
    1000993}
    1001994
    … …  
    10231016{
    10241017        /* Accept connection */
    1025         async_answer_0(iid, EOK);
     1018        ipc_answer_0(iid, EOK);
    10261019       
    10271020        devmap_driver_t *driver = devmap_driver_register();
    … …  
    10341027                ipc_callid_t callid = async_get_call(&call);
    10351028               
    1036                 switch (IPC_GET_IMETHOD(call)) {
     1029                switch (IPC_GET_METHOD(call)) {
    10371030                case IPC_M_PHONE_HUNGUP:
    10381031                        cont = false;
    … …  
    10401033                case DEVMAP_DRIVER_UNREGISTER:
    10411034                        if (NULL == driver)
    1042                                 async_answer_0(callid, ENOENT);
     1035                                ipc_answer_0(callid, ENOENT);
    10431036                        else
    1044                                 async_answer_0(callid, EOK);
     1037                                ipc_answer_0(callid, EOK);
    10451038                        break;
    10461039                case DEVMAP_DEVICE_REGISTER:
    … …  
    10591052                        break;
    10601053                default:
    1061                         async_answer_0(callid, ENOENT);
     1054                        if (!(callid & IPC_CALLID_NOTIFICATION))
     1055                                ipc_answer_0(callid, ENOENT);
    10621056                }
    10631057        }
    … …  
    10781072{
    10791073        /* Accept connection */
    1080         async_answer_0(iid, EOK);
     1074        ipc_answer_0(iid, EOK);
    10811075       
    10821076        bool cont = true;
    … …  
    10851079                ipc_callid_t callid = async_get_call(&call);
    10861080               
    1087                 switch (IPC_GET_IMETHOD(call)) {
     1081                switch (IPC_GET_METHOD(call)) {
    10881082                case IPC_M_PHONE_HUNGUP:
    10891083                        cont = false;
    … …  
    11171111                        break;
    11181112                default:
    1119                         async_answer_0(callid, ENOENT);
     1113                        if (!(callid & IPC_CALLID_NOTIFICATION))
     1114                                ipc_answer_0(callid, ENOENT);
    11201115                }
    11211116        }
    … …  
    11281123{
    11291124        /* Select interface */
    1130         switch ((sysarg_t) (IPC_GET_ARG1(*icall))) {
     1125        switch ((ipcarg_t) (IPC_GET_ARG1(*icall))) {
    11311126        case DEVMAP_DRIVER:
    11321127                devmap_connection_driver(iid, icall);
    … …  
    11411136        default:
    11421137                /* No such interface */
    1143                 async_answer_0(iid, ENOENT);
     1138                ipc_answer_0(iid, ENOENT);
    11441139        }
    11451140}
    … …  
    11611156       
    11621157        /* Register device mapper at naming service */
    1163         if (service_register(SERVICE_DEVMAP) != EOK)
     1158        ipcarg_t phonead;
     1159        if (ipc_connect_to_me(PHONE_NS, SERVICE_DEVMAP, 0, 0, &phonead) != 0)
    11641160                return -1;
    11651161       
Note: See TracChangeset for help on using the changeset viewer.