Changeset b74959bd in mainline for uspace/srv/devmap/devmap.c


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().

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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        }
Note: See TracChangeset for help on using the changeset viewer.