Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devmap/devmap.c

    rab108be4 r19f857a  
    172172               
    173173                *name = str_dup(fqdn);
    174                 if (*name == NULL) {
    175                         free(*ns_name);
    176                         return false;
    177                 }
    178                
    179                 if (str_cmp(*name, "") == 0) {
    180                         free(*name);
     174                if ((*name == NULL) || (str_cmp(*name, "") == 0)) {
    181175                        free(*ns_name);
    182176                        return false;
    … …  
    192186       
    193187        *name = str_dup(fqdn + slash_after);
    194         if (*name == NULL) {
     188        if ((*name == NULL) || (str_cmp(*name, "") == 0)) {
    195189                free(*ns_name);
    196190                return false;
    197191        }
    198192       
    199         if (str_cmp(*name, "") == 0) {
    200                 free(*name);
    201                 free(*ns_name);
    202                 return false;
    203         }
    204        
    205193        return true;
    206194}
    … …  
    214202static devmap_namespace_t *devmap_namespace_find_name(const char *name)
    215203{
    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);
     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);
    220208                if (str_cmp(namespace->name, name) == 0)
    221209                        return namespace;
     210                item = item->next;
    222211        }
    223212       
    … …  
    235224static devmap_namespace_t *devmap_namespace_find_handle(dev_handle_t handle)
    236225{
    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);
     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);
    241230                if (namespace->handle == handle)
    242231                        return namespace;
     232               
     233                item = item->next;
    243234        }
    244235       
    … …  
    255246    const char *name)
    256247{
    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))
     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))
    263253                        return device;
     254                item = item->next;
    264255        }
    265256       
    … …  
    277268static devmap_device_t *devmap_device_find_handle(dev_handle_t handle)
    278269{
    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);
     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);
    283274                if (device->handle == handle)
    284275                        return device;
     276               
     277                item = item->next;
    285278        }
    286279       
    … …  
    374367        list_remove(&(device->driver_devices));
    375368       
     369        free(device->namespace);
    376370        free(device->name);
    377371        free(device);
    … …  
    392386        }
    393387       
    394         devmap_driver_t *driver =
    395             (devmap_driver_t *) malloc(sizeof(devmap_driver_t));
     388        devmap_driver_t *driver = (devmap_driver_t *) malloc(sizeof(devmap_driver_t));
     389       
    396390        if (driver == NULL) {
    397391                ipc_answer_0(iid, ENOMEM);
    … …  
    410404        }
    411405       
     406        /* Initialize mutex for list of devices owned by this driver */
     407        fibril_mutex_initialize(&driver->devices_mutex);
     408       
     409        /*
     410         * Initialize list of asociated devices
     411         */
     412        list_initialize(&driver->devices);
     413       
    412414        /*
    413415         * Create connection to the driver
    … …  
    417419       
    418420        if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
     421                ipc_answer_0(callid, ENOTSUP);
     422               
    419423                free(driver->name);
    420424                free(driver);
    421                 ipc_answer_0(callid, ENOTSUP);
    422425                ipc_answer_0(iid, ENOTSUP);
    423426                return NULL;
    … …  
    425428       
    426429        driver->phone = IPC_GET_ARG5(call);
     430       
    427431        ipc_answer_0(callid, EOK);
    428432       
    429         /*
    430          * Initialize mutex for list of devices
    431          * owned by this driver
    432          */
    433         fibril_mutex_initialize(&driver->devices_mutex);
    434        
    435         /*
    436          * Initialize list of asociated devices
    437          */
    438         list_initialize(&driver->devices);
    439433        list_initialize(&(driver->drivers));
    440434       
    … …  
    442436       
    443437        /* TODO:
    444          * Check that no driver with name equal to
    445          * driver->name is registered
     438         * check that no driver with name equal to driver->name is registered
    446439         */
    447440       
    … …  
    489482        fibril_mutex_unlock(&drivers_list_mutex);
    490483       
    491         /* Free name and driver */
     484        /* free name and driver */
    492485        if (driver->name != NULL)
    493486                free(driver->name);
    … …  
    510503       
    511504        /* Create new device entry */
    512         devmap_device_t *device =
    513             (devmap_device_t *) malloc(sizeof(devmap_device_t));
     505        devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
    514506        if (device == NULL) {
    515507                ipc_answer_0(iid, ENOMEM);
    … …  
    541533        devmap_namespace_t *namespace = devmap_namespace_create(ns_name);
    542534        free(ns_name);
    543         if (namespace == NULL) {
     535        if (!namespace) {
    544536                fibril_mutex_unlock(&devices_list_mutex);
    545                 free(device->name);
    546537                free(device);
    547538                ipc_answer_0(iid, ENOMEM);
    … …  
    554545        /* Check that device is not already registered */
    555546        if (devmap_device_find_name(namespace->name, device->name) != NULL) {
    556                 printf("%s: Device '%s/%s' already registered\n", NAME,
    557                     device->namespace, device->name);
     547                printf(NAME ": Device '%s/%s' already registered\n", device->namespace, device->name);
    558548                devmap_namespace_destroy(namespace);
    559549                fibril_mutex_unlock(&devices_list_mutex);
     550                free(device->namespace);
    560551                free(device->name);
    561552                free(device);
    … …  
    612603       
    613604        if ((dev == NULL) || (dev->driver == NULL) || (dev->driver->phone == 0)) {
    614                 fibril_mutex_unlock(&devices_list_mutex);
    615605                ipc_answer_0(callid, ENOENT);
    616606                return;
    … …  
    678668                return;
    679669        }
     670        fibril_mutex_unlock(&devices_list_mutex);
    680671       
    681672        ipc_answer_1(iid, EOK, dev->handle);
    682        
    683         fibril_mutex_unlock(&devices_list_mutex);
    684673        free(ns_name);
    685674        free(name);
    … …  
    730719                return;
    731720        }
     721        fibril_mutex_unlock(&devices_list_mutex);
    732722       
    733723        ipc_answer_1(iid, EOK, namespace->handle);
    734        
    735         fibril_mutex_unlock(&devices_list_mutex);
    736724        free(name);
    737725}
    … …  
    741729        fibril_mutex_lock(&devices_list_mutex);
    742730       
    743         devmap_namespace_t *namespace =
    744             devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
     731        devmap_namespace_t *namespace = devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
    745732        if (namespace == NULL) {
    746                 devmap_device_t *dev =
    747                     devmap_device_find_handle(IPC_GET_ARG1(*icall));
     733                devmap_device_t *dev = devmap_device_find_handle(IPC_GET_ARG1(*icall));
    748734                if (dev == NULL)
    749735                        ipc_answer_1(iid, EOK, DEV_HANDLE_NONE);
    … …  
    767753        fibril_mutex_lock(&devices_list_mutex);
    768754       
    769         devmap_namespace_t *namespace =
    770             devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
     755        devmap_namespace_t *namespace = devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
    771756        if (namespace == NULL)
    772757                ipc_answer_0(iid, EEXISTS);
    … …  
    797782        size_t count = size / sizeof(dev_desc_t);
    798783        if (count != list_count(&namespaces_list)) {
    799                 fibril_mutex_unlock(&devices_list_mutex);
    800784                ipc_answer_0(callid, EOVERFLOW);
    801785                ipc_answer_0(iid, EOVERFLOW);
    … …  
    805789        dev_desc_t *desc = (dev_desc_t *) malloc(size);
    806790        if (desc == NULL) {
    807                 fibril_mutex_unlock(&devices_list_mutex);
    808791                ipc_answer_0(callid, ENOMEM);
    809792                ipc_answer_0(iid, ENOMEM);
    … …  
    811794        }
    812795       
    813         link_t *item;
     796        link_t *item = namespaces_list.next;
    814797        size_t pos = 0;
    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);
     798        while (item != &namespaces_list) {
     799                devmap_namespace_t *namespace = list_get_instance(item, devmap_namespace_t, namespaces);
    819800               
    820801                desc[pos].handle = namespace->handle;
    821802                str_cpy(desc[pos].name, DEVMAP_NAME_MAXLEN, namespace->name);
    822803                pos++;
     804               
     805                item = item->next;
    823806        }
    824807       
    … …  
    852835        fibril_mutex_lock(&devices_list_mutex);
    853836       
    854         devmap_namespace_t *namespace =
    855             devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
     837        devmap_namespace_t *namespace = devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
    856838        if (namespace == NULL) {
    857839                fibril_mutex_unlock(&devices_list_mutex);
    … …  
    863845        size_t count = size / sizeof(dev_desc_t);
    864846        if (count != namespace->refcnt) {
    865                 fibril_mutex_unlock(&devices_list_mutex);
    866847                ipc_answer_0(callid, EOVERFLOW);
    867848                ipc_answer_0(iid, EOVERFLOW);
    … …  
    871852        dev_desc_t *desc = (dev_desc_t *) malloc(size);
    872853        if (desc == NULL) {
    873                 fibril_mutex_unlock(&devices_list_mutex);
    874854                ipc_answer_0(callid, ENOMEM);
    875855                ipc_answer_0(iid, EREFUSED);
    … …  
    877857        }
    878858       
    879         link_t *item;
     859        link_t *item = devices_list.next;
    880860        size_t pos = 0;
    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);
     861        while (item != &devices_list) {
     862                devmap_device_t *device = list_get_instance(item, devmap_device_t, devices);
    884863               
    885864                if (device->namespace == namespace) {
    … …  
    888867                        pos++;
    889868                }
     869               
     870                item = item->next;
    890871        }
    891872       
    … …  
    928909        }
    929910       
    930         devmap_device_t *device =
    931             (devmap_device_t *) malloc(sizeof(devmap_device_t));
     911        devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
    932912        if (device == NULL) {
    933913                fibril_mutex_unlock(&null_devices_mutex);
    … …  
    939919       
    940920        devmap_namespace_t *namespace = devmap_namespace_create("null");
    941         if (namespace == NULL) {
     921        if (!namespace) {
    942922                fibril_mutex_lock(&devices_list_mutex);
    943923                fibril_mutex_unlock(&null_devices_mutex);
    … …  
    969949static void devmap_null_destroy(ipc_callid_t iid, ipc_call_t *icall)
    970950{
     951        fibril_mutex_lock(&null_devices_mutex);
     952       
    971953        ipcarg_t i = IPC_GET_ARG1(*icall);
    972         if (i >= NULL_DEVICES) {
    973                 ipc_answer_0(iid, ELIMIT);
    974                 return;
    975         }
    976        
    977         fibril_mutex_lock(&null_devices_mutex);
    978954       
    979955        if (null_devices[i] == NULL) {
    980                 fibril_mutex_unlock(&null_devices_mutex);
    981956                ipc_answer_0(iid, ENOENT);
    982957                return;
    … …  
    990965       
    991966        fibril_mutex_unlock(&null_devices_mutex);
     967       
    992968        ipc_answer_0(iid, EOK);
    993969}
    … …  
    11451121int main(int argc, char *argv[])
    11461122{
    1147         printf("%s: HelenOS Device Mapper\n", NAME);
     1123        printf(NAME ": HelenOS Device Mapper\n");
    11481124       
    11491125        if (!devmap_init()) {
    1150                 printf("%s: Error while initializing service\n", NAME);
     1126                printf(NAME ": Error while initializing service\n");
    11511127                return -1;
    11521128        }
    … …  
    11601136                return -1;
    11611137       
    1162         printf("%s: Accepting connections\n", NAME);
     1138        printf(NAME ": Accepting connections\n");
    11631139        async_manager();
    11641140       
Note: See TracChangeset for help on using the changeset viewer.