Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/devmap/devmap.c

    rca2a18e r01b87dc5  
    374374       
    375375        if (IPC_GET_IMETHOD(icall) != DEVMAP_DRIVER_REGISTER) {
    376                 async_answer_0(iid, EREFUSED);
     376                ipc_answer_0(iid, EREFUSED);
    377377                return NULL;
    378378        }
     
    381381            (devmap_driver_t *) malloc(sizeof(devmap_driver_t));
    382382        if (driver == NULL) {
    383                 async_answer_0(iid, ENOMEM);
     383                ipc_answer_0(iid, ENOMEM);
    384384                return NULL;
    385385        }
     
    392392        if (rc != EOK) {
    393393                free(driver);
    394                 async_answer_0(iid, rc);
     394                ipc_answer_0(iid, rc);
    395395                return NULL;
    396396        }
     
    405405                free(driver->name);
    406406                free(driver);
    407                 async_answer_0(callid, ENOTSUP);
    408                 async_answer_0(iid, ENOTSUP);
     407                ipc_answer_0(callid, ENOTSUP);
     408                ipc_answer_0(iid, ENOTSUP);
    409409                return NULL;
    410410        }
    411411       
    412412        driver->phone = IPC_GET_ARG5(call);
    413         async_answer_0(callid, EOK);
     413        ipc_answer_0(callid, EOK);
    414414       
    415415        /*
     
    423423         */
    424424        list_initialize(&driver->devices);
    425 
    426         link_initialize(&driver->drivers);
     425        list_initialize(&(driver->drivers));
    427426       
    428427        fibril_mutex_lock(&drivers_list_mutex);
     
    439438        fibril_mutex_unlock(&drivers_list_mutex);
    440439       
    441         async_answer_0(iid, EOK);
     440        ipc_answer_0(iid, EOK);
    442441       
    443442        return driver;
     
    457456       
    458457        if (driver->phone != 0)
    459                 async_hangup(driver->phone);
     458                ipc_hangup(driver->phone);
    460459       
    461460        /* Remove it from list of drivers */
     
    492491{
    493492        if (driver == NULL) {
    494                 async_answer_0(iid, EREFUSED);
     493                ipc_answer_0(iid, EREFUSED);
    495494                return;
    496495        }
     
    500499            (devmap_device_t *) malloc(sizeof(devmap_device_t));
    501500        if (device == NULL) {
    502                 async_answer_0(iid, ENOMEM);
     501                ipc_answer_0(iid, ENOMEM);
    503502                return;
    504503        }
     
    513512        if (rc != EOK) {
    514513                free(device);
    515                 async_answer_0(iid, rc);
     514                ipc_answer_0(iid, rc);
    516515                return;
    517516        }
     
    521520                free(fqdn);
    522521                free(device);
    523                 async_answer_0(iid, EINVAL);
     522                ipc_answer_0(iid, EINVAL);
    524523                return;
    525524        }
     
    535534                free(device->name);
    536535                free(device);
    537                 async_answer_0(iid, ENOMEM);
    538                 return;
    539         }
    540        
    541         link_initialize(&device->devices);
    542         link_initialize(&device->driver_devices);
     536                ipc_answer_0(iid, ENOMEM);
     537                return;
     538        }
     539       
     540        list_initialize(&(device->devices));
     541        list_initialize(&(device->driver_devices));
    543542       
    544543        /* Check that device is not already registered */
     
    550549                free(device->name);
    551550                free(device);
    552                 async_answer_0(iid, EEXISTS);
     551                ipc_answer_0(iid, EEXISTS);
    553552                return;
    554553        }
     
    572571        fibril_mutex_unlock(&devices_list_mutex);
    573572       
    574         async_answer_1(iid, EOK, device->handle);
     573        ipc_answer_1(iid, EOK, device->handle);
    575574}
    576575
     
    603602        if ((dev == NULL) || (dev->driver == NULL) || (dev->driver->phone == 0)) {
    604603                fibril_mutex_unlock(&devices_list_mutex);
    605                 async_answer_0(callid, ENOENT);
     604                ipc_answer_0(callid, ENOENT);
    606605                return;
    607606        }
    608607       
    609608        if (dev->forward_interface == 0) {
    610                 async_forward_fast(callid, dev->driver->phone,
     609                ipc_forward_fast(callid, dev->driver->phone,
    611610                    dev->handle, 0, 0,
    612611                    IPC_FF_NONE);
    613612        } else {
    614                 async_forward_fast(callid, dev->driver->phone,
     613                ipc_forward_fast(callid, dev->driver->phone,
    615614                    dev->forward_interface, dev->handle, 0,
    616615                    IPC_FF_NONE);
     
    634633            DEVMAP_NAME_MAXLEN, 0, NULL);
    635634        if (rc != EOK) {
    636                 async_answer_0(iid, rc);
     635                ipc_answer_0(iid, rc);
    637636                return;
    638637        }
     
    642641        if (!devmap_fqdn_split(fqdn, &ns_name, &name)) {
    643642                free(fqdn);
    644                 async_answer_0(iid, EINVAL);
     643                ipc_answer_0(iid, EINVAL);
    645644                return;
    646645        }
     
    669668                }
    670669               
    671                 async_answer_0(iid, ENOENT);
     670                ipc_answer_0(iid, ENOENT);
    672671                free(ns_name);
    673672                free(name);
     
    676675        }
    677676       
    678         async_answer_1(iid, EOK, dev->handle);
     677        ipc_answer_1(iid, EOK, dev->handle);
    679678       
    680679        fibril_mutex_unlock(&devices_list_mutex);
     
    697696            DEVMAP_NAME_MAXLEN, 0, NULL);
    698697        if (rc != EOK) {
    699                 async_answer_0(iid, rc);
     698                ipc_answer_0(iid, rc);
    700699                return;
    701700        }
     
    722721                }
    723722               
    724                 async_answer_0(iid, ENOENT);
     723                ipc_answer_0(iid, ENOENT);
    725724                free(name);
    726725                fibril_mutex_unlock(&devices_list_mutex);
     
    728727        }
    729728       
    730         async_answer_1(iid, EOK, namespace->handle);
     729        ipc_answer_1(iid, EOK, namespace->handle);
    731730       
    732731        fibril_mutex_unlock(&devices_list_mutex);
     
    744743                    devmap_device_find_handle(IPC_GET_ARG1(*icall));
    745744                if (dev == NULL)
    746                         async_answer_1(iid, EOK, DEV_HANDLE_NONE);
     745                        ipc_answer_1(iid, EOK, DEV_HANDLE_NONE);
    747746                else
    748                         async_answer_1(iid, EOK, DEV_HANDLE_DEVICE);
     747                        ipc_answer_1(iid, EOK, DEV_HANDLE_DEVICE);
    749748        } else
    750                 async_answer_1(iid, EOK, DEV_HANDLE_NAMESPACE);
     749                ipc_answer_1(iid, EOK, DEV_HANDLE_NAMESPACE);
    751750       
    752751        fibril_mutex_unlock(&devices_list_mutex);
     
    756755{
    757756        fibril_mutex_lock(&devices_list_mutex);
    758         async_answer_1(iid, EOK, list_count(&namespaces_list));
     757        ipc_answer_1(iid, EOK, list_count(&namespaces_list));
    759758        fibril_mutex_unlock(&devices_list_mutex);
    760759}
     
    767766            devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
    768767        if (namespace == NULL)
    769                 async_answer_0(iid, EEXISTS);
     768                ipc_answer_0(iid, EEXISTS);
    770769        else
    771                 async_answer_1(iid, EOK, namespace->refcnt);
     770                ipc_answer_1(iid, EOK, namespace->refcnt);
    772771       
    773772        fibril_mutex_unlock(&devices_list_mutex);
     
    779778        size_t size;
    780779        if (!async_data_read_receive(&callid, &size)) {
    781                 async_answer_0(callid, EREFUSED);
    782                 async_answer_0(iid, EREFUSED);
     780                ipc_answer_0(callid, EREFUSED);
     781                ipc_answer_0(iid, EREFUSED);
    783782                return;
    784783        }
    785784       
    786785        if ((size % sizeof(dev_desc_t)) != 0) {
    787                 async_answer_0(callid, EINVAL);
    788                 async_answer_0(iid, EINVAL);
     786                ipc_answer_0(callid, EINVAL);
     787                ipc_answer_0(iid, EINVAL);
    789788                return;
    790789        }
     
    795794        if (count != list_count(&namespaces_list)) {
    796795                fibril_mutex_unlock(&devices_list_mutex);
    797                 async_answer_0(callid, EOVERFLOW);
    798                 async_answer_0(iid, EOVERFLOW);
     796                ipc_answer_0(callid, EOVERFLOW);
     797                ipc_answer_0(iid, EOVERFLOW);
    799798                return;
    800799        }
     
    803802        if (desc == NULL) {
    804803                fibril_mutex_unlock(&devices_list_mutex);
    805                 async_answer_0(callid, ENOMEM);
    806                 async_answer_0(iid, ENOMEM);
     804                ipc_answer_0(callid, ENOMEM);
     805                ipc_answer_0(iid, ENOMEM);
    807806                return;
    808807        }
     
    825824        fibril_mutex_unlock(&devices_list_mutex);
    826825       
    827         async_answer_0(iid, retval);
     826        ipc_answer_0(iid, retval);
    828827}
    829828
     
    836835        size_t size;
    837836        if (!async_data_read_receive(&callid, &size)) {
    838                 async_answer_0(callid, EREFUSED);
    839                 async_answer_0(iid, EREFUSED);
     837                ipc_answer_0(callid, EREFUSED);
     838                ipc_answer_0(iid, EREFUSED);
    840839                return;
    841840        }
    842841       
    843842        if ((size % sizeof(dev_desc_t)) != 0) {
    844                 async_answer_0(callid, EINVAL);
    845                 async_answer_0(iid, EINVAL);
     843                ipc_answer_0(callid, EINVAL);
     844                ipc_answer_0(iid, EINVAL);
    846845                return;
    847846        }
     
    853852        if (namespace == NULL) {
    854853                fibril_mutex_unlock(&devices_list_mutex);
    855                 async_answer_0(callid, ENOENT);
    856                 async_answer_0(iid, ENOENT);
     854                ipc_answer_0(callid, ENOENT);
     855                ipc_answer_0(iid, ENOENT);
    857856                return;
    858857        }
     
    861860        if (count != namespace->refcnt) {
    862861                fibril_mutex_unlock(&devices_list_mutex);
    863                 async_answer_0(callid, EOVERFLOW);
    864                 async_answer_0(iid, EOVERFLOW);
     862                ipc_answer_0(callid, EOVERFLOW);
     863                ipc_answer_0(iid, EOVERFLOW);
    865864                return;
    866865        }
     
    869868        if (desc == NULL) {
    870869                fibril_mutex_unlock(&devices_list_mutex);
    871                 async_answer_0(callid, ENOMEM);
    872                 async_answer_0(iid, EREFUSED);
     870                ipc_answer_0(callid, ENOMEM);
     871                ipc_answer_0(iid, EREFUSED);
    873872                return;
    874873        }
     
    892891        fibril_mutex_unlock(&devices_list_mutex);
    893892       
    894         async_answer_0(iid, retval);
     893        ipc_answer_0(iid, retval);
    895894}
    896895
     
    911910        if (!fnd) {
    912911                fibril_mutex_unlock(&null_devices_mutex);
    913                 async_answer_0(iid, ENOMEM);
     912                ipc_answer_0(iid, ENOMEM);
    914913                return;
    915914        }
     
    921920        if (dev_name == NULL) {
    922921                fibril_mutex_unlock(&null_devices_mutex);
    923                 async_answer_0(iid, ENOMEM);
     922                ipc_answer_0(iid, ENOMEM);
    924923                return;
    925924        }
     
    929928        if (device == NULL) {
    930929                fibril_mutex_unlock(&null_devices_mutex);
    931                 async_answer_0(iid, ENOMEM);
     930                ipc_answer_0(iid, ENOMEM);
    932931                return;
    933932        }
     
    939938                fibril_mutex_lock(&devices_list_mutex);
    940939                fibril_mutex_unlock(&null_devices_mutex);
    941                 async_answer_0(iid, ENOMEM);
    942                 return;
    943         }
    944        
    945         link_initialize(&device->devices);
    946         link_initialize(&device->driver_devices);
     940                ipc_answer_0(iid, ENOMEM);
     941                return;
     942        }
     943       
     944        list_initialize(&(device->devices));
     945        list_initialize(&(device->driver_devices));
    947946       
    948947        /* Get unique device handle */
     
    961960        fibril_mutex_unlock(&null_devices_mutex);
    962961       
    963         async_answer_1(iid, EOK, (sysarg_t) i);
     962        ipc_answer_1(iid, EOK, (sysarg_t) i);
    964963}
    965964
     
    968967        sysarg_t i = IPC_GET_ARG1(*icall);
    969968        if (i >= NULL_DEVICES) {
    970                 async_answer_0(iid, ELIMIT);
     969                ipc_answer_0(iid, ELIMIT);
    971970                return;
    972971        }
     
    976975        if (null_devices[i] == NULL) {
    977976                fibril_mutex_unlock(&null_devices_mutex);
    978                 async_answer_0(iid, ENOENT);
     977                ipc_answer_0(iid, ENOENT);
    979978                return;
    980979        }
     
    987986       
    988987        fibril_mutex_unlock(&null_devices_mutex);
    989         async_answer_0(iid, EOK);
     988        ipc_answer_0(iid, EOK);
    990989}
    991990
     
    10131012{
    10141013        /* Accept connection */
    1015         async_answer_0(iid, EOK);
     1014        ipc_answer_0(iid, EOK);
    10161015       
    10171016        devmap_driver_t *driver = devmap_driver_register();
     
    10301029                case DEVMAP_DRIVER_UNREGISTER:
    10311030                        if (NULL == driver)
    1032                                 async_answer_0(callid, ENOENT);
     1031                                ipc_answer_0(callid, ENOENT);
    10331032                        else
    1034                                 async_answer_0(callid, EOK);
     1033                                ipc_answer_0(callid, EOK);
    10351034                        break;
    10361035                case DEVMAP_DEVICE_REGISTER:
     
    10491048                        break;
    10501049                default:
    1051                         async_answer_0(callid, ENOENT);
     1050                        ipc_answer_0(callid, ENOENT);
    10521051                }
    10531052        }
     
    10681067{
    10691068        /* Accept connection */
    1070         async_answer_0(iid, EOK);
     1069        ipc_answer_0(iid, EOK);
    10711070       
    10721071        bool cont = true;
     
    11071106                        break;
    11081107                default:
    1109                         async_answer_0(callid, ENOENT);
     1108                        ipc_answer_0(callid, ENOENT);
    11101109                }
    11111110        }
     
    11311130        default:
    11321131                /* No such interface */
    1133                 async_answer_0(iid, ENOENT);
     1132                ipc_answer_0(iid, ENOENT);
    11341133        }
    11351134}
     
    11511150       
    11521151        /* Register device mapper at naming service */
    1153         if (service_register(SERVICE_DEVMAP) != EOK)
     1152        sysarg_t phonead;
     1153        if (ipc_connect_to_me(PHONE_NS, SERVICE_DEVMAP, 0, 0, &phonead) != 0)
    11541154                return -1;
    11551155       
Note: See TracChangeset for help on using the changeset viewer.