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


Ignore:
Timestamp:
2010-05-21T07:50:04Z (15 years ago)
Author:
Lenka Trochtova <trochtova.lenka@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
d51ee2b
Parents:
cf8cc36 (diff), 15b592b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

merge mainline changes (rev. 451)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devmap/devmap.c

    rcf8cc36 rc47e1a8  
    4444#include <fibril_synch.h>
    4545#include <stdlib.h>
    46 #include <string.h>
     46#include <str.h>
    4747#include <ipc/devmap.h>
    4848
    … …  
    172172               
    173173                *name = str_dup(fqdn);
    174                 if ((*name == NULL) || (str_cmp(*name, "") == 0)) {
     174                if (*name == NULL) {
     175                        free(*ns_name);
     176                        return false;
     177                }
     178               
     179                if (str_cmp(*name, "") == 0) {
     180                        free(*name);
    175181                        free(*ns_name);
    176182                        return false;
    … …  
    186192       
    187193        *name = str_dup(fqdn + slash_after);
    188         if ((*name == NULL) || (str_cmp(*name, "") == 0)) {
     194        if (*name == NULL) {
    189195                free(*ns_name);
    190196                return false;
    191197        }
    192198       
     199        if (str_cmp(*name, "") == 0) {
     200                free(*name);
     201                free(*ns_name);
     202                return false;
     203        }
     204       
    193205        return true;
    194206}
    … …  
    202214static devmap_namespace_t *devmap_namespace_find_name(const char *name)
    203215{
    204         link_t *item = namespaces_list.next;
    205        
    206         while (item != &namespaces_list) {
    207                 devmap_namespace_t *namespace = list_get_instance(item, devmap_namespace_t, namespaces);
     216        link_t *item;
     217        for (item = namespaces_list.next; item != &namespaces_list; item = item->next) {
     218                devmap_namespace_t *namespace =
     219                    list_get_instance(item, devmap_namespace_t, namespaces);
    208220                if (str_cmp(namespace->name, name) == 0)
    209221                        return namespace;
    210                 item = item->next;
    211222        }
    212223       
    … …  
    224235static devmap_namespace_t *devmap_namespace_find_handle(dev_handle_t handle)
    225236{
    226         link_t *item = namespaces_list.next;
    227        
    228         while (item != &namespaces_list) {
    229                 devmap_namespace_t *namespace = list_get_instance(item, devmap_namespace_t, namespaces);
     237        link_t *item;
     238        for (item = namespaces_list.next; item != &namespaces_list; item = item->next) {
     239                devmap_namespace_t *namespace =
     240                    list_get_instance(item, devmap_namespace_t, namespaces);
    230241                if (namespace->handle == handle)
    231242                        return namespace;
    232                
    233                 item = item->next;
    234243        }
    235244       
    … …  
    246255    const char *name)
    247256{
    248         link_t *item = devices_list.next;
    249        
    250         while (item != &devices_list) {
    251                 devmap_device_t *device = list_get_instance(item, devmap_device_t, devices);
    252                 if ((str_cmp(device->namespace->name, ns_name) == 0) && (str_cmp(device->name, name) == 0))
     257        link_t *item;
     258        for (item = devices_list.next; item != &devices_list; item = item->next) {
     259                devmap_device_t *device =
     260                    list_get_instance(item, devmap_device_t, devices);
     261                if ((str_cmp(device->namespace->name, ns_name) == 0)
     262                    && (str_cmp(device->name, name) == 0))
    253263                        return device;
    254                 item = item->next;
    255264        }
    256265       
    … …  
    268277static devmap_device_t *devmap_device_find_handle(dev_handle_t handle)
    269278{
    270         link_t *item = devices_list.next;
    271        
    272         while (item != &devices_list) {
    273                 devmap_device_t *device = list_get_instance(item, devmap_device_t, devices);
     279        link_t *item;
     280        for (item = devices_list.next; item != &devices_list; item = item->next) {
     281                devmap_device_t *device =
     282                    list_get_instance(item, devmap_device_t, devices);
    274283                if (device->handle == handle)
    275284                        return device;
    276                
    277                 item = item->next;
    278285        }
    279286       
    … …  
    367374        list_remove(&(device->driver_devices));
    368375       
    369         free(device->namespace);
    370376        free(device->name);
    371377        free(device);
    … …  
    386392        }
    387393       
    388         devmap_driver_t *driver = (devmap_driver_t *) malloc(sizeof(devmap_driver_t));
    389        
     394        devmap_driver_t *driver =
     395            (devmap_driver_t *) malloc(sizeof(devmap_driver_t));
    390396        if (driver == NULL) {
    391397                ipc_answer_0(iid, ENOMEM);
    … …  
    396402         * Get driver name
    397403         */
    398         int rc = async_string_receive(&driver->name, DEVMAP_NAME_MAXLEN, NULL);
     404        int rc = async_data_write_accept((void **) &driver->name, true, 0,
     405            DEVMAP_NAME_MAXLEN, 0, NULL);
    399406        if (rc != EOK) {
    400407                free(driver);
    … …  
    403410        }
    404411       
    405         /* Initialize mutex for list of devices owned by this driver */
     412        /*
     413         * Create connection to the driver
     414         */
     415        ipc_call_t call;
     416        ipc_callid_t callid = async_get_call(&call);
     417       
     418        if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
     419                free(driver->name);
     420                free(driver);
     421                ipc_answer_0(callid, ENOTSUP);
     422                ipc_answer_0(iid, ENOTSUP);
     423                return NULL;
     424        }
     425       
     426        driver->phone = IPC_GET_ARG5(call);
     427        ipc_answer_0(callid, EOK);
     428       
     429        /*
     430         * Initialize mutex for list of devices
     431         * owned by this driver
     432         */
    406433        fibril_mutex_initialize(&driver->devices_mutex);
    407434       
    … …  
    410437         */
    411438        list_initialize(&driver->devices);
    412        
    413         /*
    414          * Create connection to the driver
    415          */
    416         ipc_call_t call;
    417         ipc_callid_t callid = async_get_call(&call);
    418        
    419         if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
    420                 ipc_answer_0(callid, ENOTSUP);
    421                
    422                 free(driver->name);
    423                 free(driver);
    424                 ipc_answer_0(iid, ENOTSUP);
    425                 return NULL;
    426         }
    427        
    428         driver->phone = IPC_GET_ARG5(call);
    429        
    430         ipc_answer_0(callid, EOK);
    431        
    432439        list_initialize(&(driver->drivers));
    433440       
    … …  
    435442       
    436443        /* TODO:
    437          * check that no driver with name equal to driver->name is registered
     444         * Check that no driver with name equal to
     445         * driver->name is registered
    438446         */
    439447       
    … …  
    481489        fibril_mutex_unlock(&drivers_list_mutex);
    482490       
    483         /* free name and driver */
     491        /* Free name and driver */
    484492        if (driver->name != NULL)
    485493                free(driver->name);
    … …  
    502510       
    503511        /* Create new device entry */
    504         devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
     512        devmap_device_t *device =
     513            (devmap_device_t *) malloc(sizeof(devmap_device_t));
    505514        if (device == NULL) {
    506515                ipc_answer_0(iid, ENOMEM);
    … …  
    510519        /* Get fqdn */
    511520        char *fqdn;
    512         int rc = async_string_receive(&fqdn, DEVMAP_NAME_MAXLEN, NULL);
     521        int rc = async_data_write_accept((void **) &fqdn, true, 0,
     522            DEVMAP_NAME_MAXLEN, 0, NULL);
    513523        if (rc != EOK) {
    514524                free(device);
    … …  
    531541        devmap_namespace_t *namespace = devmap_namespace_create(ns_name);
    532542        free(ns_name);
    533         if (!namespace) {
     543        if (namespace == NULL) {
    534544                fibril_mutex_unlock(&devices_list_mutex);
     545                free(device->name);
    535546                free(device);
    536547                ipc_answer_0(iid, ENOMEM);
    … …  
    543554        /* Check that device is not already registered */
    544555        if (devmap_device_find_name(namespace->name, device->name) != NULL) {
    545                 printf(NAME ": Device '%s/%s' already registered\n", device->namespace, device->name);
     556                printf("%s: Device '%s/%s' already registered\n", NAME,
     557                    device->namespace, device->name);
    546558                devmap_namespace_destroy(namespace);
    547559                fibril_mutex_unlock(&devices_list_mutex);
    548                 free(device->namespace);
    549560                free(device->name);
    550561                free(device);
    … …  
    601612       
    602613        if ((dev == NULL) || (dev->driver == NULL) || (dev->driver->phone == 0)) {
     614                fibril_mutex_unlock(&devices_list_mutex);
    603615                ipc_answer_0(callid, ENOENT);
    604616                return;
    … …  
    622634       
    623635        /* Get fqdn */
    624         int rc = async_string_receive(&fqdn, DEVMAP_NAME_MAXLEN, NULL);
     636        int rc = async_data_write_accept((void **) &fqdn, true, 0,
     637            DEVMAP_NAME_MAXLEN, 0, NULL);
    625638        if (rc != EOK) {
    626639                ipc_answer_0(iid, rc);
    … …  
    665678                return;
    666679        }
     680       
     681        ipc_answer_1(iid, EOK, dev->handle);
     682       
    667683        fibril_mutex_unlock(&devices_list_mutex);
    668        
    669         ipc_answer_1(iid, EOK, dev->handle);
    670684        free(ns_name);
    671685        free(name);
    … …  
    683697       
    684698        /* Get device name */
    685         int rc = async_string_receive(&name, DEVMAP_NAME_MAXLEN, NULL);
     699        int rc = async_data_write_accept((void **) &name, true, 0,
     700            DEVMAP_NAME_MAXLEN, 0, NULL);
    686701        if (rc != EOK) {
    687702                ipc_answer_0(iid, rc);
    … …  
    715730                return;
    716731        }
     732       
     733        ipc_answer_1(iid, EOK, namespace->handle);
     734       
    717735        fibril_mutex_unlock(&devices_list_mutex);
    718        
    719         ipc_answer_1(iid, EOK, namespace->handle);
    720736        free(name);
    721737}
    … …  
    725741        fibril_mutex_lock(&devices_list_mutex);
    726742       
    727         devmap_namespace_t *namespace = devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
     743        devmap_namespace_t *namespace =
     744            devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
    728745        if (namespace == NULL) {
    729                 devmap_device_t *dev = devmap_device_find_handle(IPC_GET_ARG1(*icall));
     746                devmap_device_t *dev =
     747                    devmap_device_find_handle(IPC_GET_ARG1(*icall));
    730748                if (dev == NULL)
    731749                        ipc_answer_1(iid, EOK, DEV_HANDLE_NONE);
    … …  
    749767        fibril_mutex_lock(&devices_list_mutex);
    750768       
    751         devmap_namespace_t *namespace = devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
     769        devmap_namespace_t *namespace =
     770            devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
    752771        if (namespace == NULL)
    753772                ipc_answer_0(iid, EEXISTS);
    … …  
    778797        size_t count = size / sizeof(dev_desc_t);
    779798        if (count != list_count(&namespaces_list)) {
     799                fibril_mutex_unlock(&devices_list_mutex);
    780800                ipc_answer_0(callid, EOVERFLOW);
    781801                ipc_answer_0(iid, EOVERFLOW);
    … …  
    785805        dev_desc_t *desc = (dev_desc_t *) malloc(size);
    786806        if (desc == NULL) {
     807                fibril_mutex_unlock(&devices_list_mutex);
    787808                ipc_answer_0(callid, ENOMEM);
    788809                ipc_answer_0(iid, ENOMEM);
    … …  
    790811        }
    791812       
    792         link_t *item = namespaces_list.next;
     813        link_t *item;
    793814        size_t pos = 0;
    794         while (item != &namespaces_list) {
    795                 devmap_namespace_t *namespace = list_get_instance(item, devmap_namespace_t, namespaces);
     815        for (item = namespaces_list.next; item != &namespaces_list;
     816            item = item->next) {
     817                devmap_namespace_t *namespace =
     818                    list_get_instance(item, devmap_namespace_t, namespaces);
    796819               
    797820                desc[pos].handle = namespace->handle;
    798821                str_cpy(desc[pos].name, DEVMAP_NAME_MAXLEN, namespace->name);
    799822                pos++;
    800                
    801                 item = item->next;
    802823        }
    803824       
    … …  
    831852        fibril_mutex_lock(&devices_list_mutex);
    832853       
    833         devmap_namespace_t *namespace = devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
     854        devmap_namespace_t *namespace =
     855            devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
    834856        if (namespace == NULL) {
    835857                fibril_mutex_unlock(&devices_list_mutex);
    … …  
    841863        size_t count = size / sizeof(dev_desc_t);
    842864        if (count != namespace->refcnt) {
     865                fibril_mutex_unlock(&devices_list_mutex);
    843866                ipc_answer_0(callid, EOVERFLOW);
    844867                ipc_answer_0(iid, EOVERFLOW);
    … …  
    848871        dev_desc_t *desc = (dev_desc_t *) malloc(size);
    849872        if (desc == NULL) {
     873                fibril_mutex_unlock(&devices_list_mutex);
    850874                ipc_answer_0(callid, ENOMEM);
    851875                ipc_answer_0(iid, EREFUSED);
    … …  
    853877        }
    854878       
    855         link_t *item = devices_list.next;
     879        link_t *item;
    856880        size_t pos = 0;
    857         while (item != &devices_list) {
    858                 devmap_device_t *device = list_get_instance(item, devmap_device_t, devices);
     881        for (item = devices_list.next; item != &devices_list; item = item->next) {
     882                devmap_device_t *device =
     883                    list_get_instance(item, devmap_device_t, devices);
    859884               
    860885                if (device->namespace == namespace) {
    … …  
    863888                        pos++;
    864889                }
    865                
    866                 item = item->next;
    867890        }
    868891       
    … …  
    905928        }
    906929       
    907         devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
     930        devmap_device_t *device =
     931            (devmap_device_t *) malloc(sizeof(devmap_device_t));
    908932        if (device == NULL) {
    909933                fibril_mutex_unlock(&null_devices_mutex);
    … …  
    915939       
    916940        devmap_namespace_t *namespace = devmap_namespace_create("null");
    917         if (!namespace) {
     941        if (namespace == NULL) {
    918942                fibril_mutex_lock(&devices_list_mutex);
    919943                fibril_mutex_unlock(&null_devices_mutex);
    … …  
    945969static void devmap_null_destroy(ipc_callid_t iid, ipc_call_t *icall)
    946970{
     971        ipcarg_t i = IPC_GET_ARG1(*icall);
     972        if (i >= NULL_DEVICES) {
     973                ipc_answer_0(iid, ELIMIT);
     974                return;
     975        }
     976       
    947977        fibril_mutex_lock(&null_devices_mutex);
    948978       
    949         ipcarg_t i = IPC_GET_ARG1(*icall);
    950        
    951979        if (null_devices[i] == NULL) {
     980                fibril_mutex_unlock(&null_devices_mutex);
    952981                ipc_answer_0(iid, ENOENT);
    953982                return;
    … …  
    961990       
    962991        fibril_mutex_unlock(&null_devices_mutex);
    963        
    964992        ipc_answer_0(iid, EOK);
    965993}
    … …  
    11171145int main(int argc, char *argv[])
    11181146{
    1119         printf(NAME ": HelenOS Device Mapper\n");
     1147        printf("%s: HelenOS Device Mapper\n", NAME);
    11201148       
    11211149        if (!devmap_init()) {
    1122                 printf(NAME ": Error while initializing service\n");
     1150                printf("%s: Error while initializing service\n", NAME);
    11231151                return -1;
    11241152        }
    … …  
    11321160                return -1;
    11331161       
    1134         printf(NAME ": Accepting connections\n");
     1162        printf("%s: Accepting connections\n", NAME);
    11351163        async_manager();
    11361164       
Note: See TracChangeset for help on using the changeset viewer.