Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devmap/devmap.c

    rab108be4 r472c09d  
    4444#include <fibril_synch.h>
    4545#include <stdlib.h>
    46 #include <str.h>
     46#include <string.h>
    4747#include <ipc/devmap.h>
    4848
    … …  
    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);
    … …  
    402396         * Get driver name
    403397         */
    404         int rc = async_data_write_accept((void **) &driver->name, true, 0,
    405             DEVMAP_NAME_MAXLEN, 0, NULL);
     398        int rc = async_string_receive(&driver->name, DEVMAP_NAME_MAXLEN, NULL);
    406399        if (rc != EOK) {
    407400                free(driver);
    … …  
    409402                return NULL;
    410403        }
     404       
     405        /* Initialize mutex for list of devices owned by this driver */
     406        fibril_mutex_initialize(&driver->devices_mutex);
     407       
     408        /*
     409         * Initialize list of asociated devices
     410         */
     411        list_initialize(&driver->devices);
    411412       
    412413        /*
    … …  
    417418       
    418419        if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
     420                ipc_answer_0(callid, ENOTSUP);
     421               
    419422                free(driver->name);
    420423                free(driver);
    421                 ipc_answer_0(callid, ENOTSUP);
    422424                ipc_answer_0(iid, ENOTSUP);
    423425                return NULL;
    … …  
    425427       
    426428        driver->phone = IPC_GET_ARG5(call);
     429       
    427430        ipc_answer_0(callid, EOK);
    428431       
    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);
    439432        list_initialize(&(driver->drivers));
    440433       
    … …  
    442435       
    443436        /* TODO:
    444          * Check that no driver with name equal to
    445          * driver->name is registered
     437         * check that no driver with name equal to driver->name is registered
    446438         */
    447439       
    … …  
    489481        fibril_mutex_unlock(&drivers_list_mutex);
    490482       
    491         /* Free name and driver */
     483        /* free name and driver */
    492484        if (driver->name != NULL)
    493485                free(driver->name);
    … …  
    510502       
    511503        /* Create new device entry */
    512         devmap_device_t *device =
    513             (devmap_device_t *) malloc(sizeof(devmap_device_t));
     504        devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
    514505        if (device == NULL) {
    515506                ipc_answer_0(iid, ENOMEM);
    … …  
    519510        /* Get fqdn */
    520511        char *fqdn;
    521         int rc = async_data_write_accept((void **) &fqdn, true, 0,
    522             DEVMAP_NAME_MAXLEN, 0, NULL);
     512        int rc = async_string_receive(&fqdn, DEVMAP_NAME_MAXLEN, NULL);
    523513        if (rc != EOK) {
    524514                free(device);
    … …  
    541531        devmap_namespace_t *namespace = devmap_namespace_create(ns_name);
    542532        free(ns_name);
    543         if (namespace == NULL) {
     533        if (!namespace) {
    544534                fibril_mutex_unlock(&devices_list_mutex);
    545                 free(device->name);
    546535                free(device);
    547536                ipc_answer_0(iid, ENOMEM);
    … …  
    554543        /* Check that device is not already registered */
    555544        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);
     545                printf(NAME ": Device '%s/%s' already registered\n", device->namespace, device->name);
    558546                devmap_namespace_destroy(namespace);
    559547                fibril_mutex_unlock(&devices_list_mutex);
     548                free(device->namespace);
    560549                free(device->name);
    561550                free(device);
    … …  
    612601       
    613602        if ((dev == NULL) || (dev->driver == NULL) || (dev->driver->phone == 0)) {
    614                 fibril_mutex_unlock(&devices_list_mutex);
    615603                ipc_answer_0(callid, ENOENT);
    616604                return;
    … …  
    634622       
    635623        /* Get fqdn */
    636         int rc = async_data_write_accept((void **) &fqdn, true, 0,
    637             DEVMAP_NAME_MAXLEN, 0, NULL);
     624        int rc = async_string_receive(&fqdn, DEVMAP_NAME_MAXLEN, NULL);
    638625        if (rc != EOK) {
    639626                ipc_answer_0(iid, rc);
    … …  
    678665                return;
    679666        }
     667        fibril_mutex_unlock(&devices_list_mutex);
    680668       
    681669        ipc_answer_1(iid, EOK, dev->handle);
    682        
    683         fibril_mutex_unlock(&devices_list_mutex);
    684670        free(ns_name);
    685671        free(name);
    … …  
    697683       
    698684        /* Get device name */
    699         int rc = async_data_write_accept((void **) &name, true, 0,
    700             DEVMAP_NAME_MAXLEN, 0, NULL);
     685        int rc = async_string_receive(&name, DEVMAP_NAME_MAXLEN, NULL);
    701686        if (rc != EOK) {
    702687                ipc_answer_0(iid, rc);
    … …  
    730715                return;
    731716        }
     717        fibril_mutex_unlock(&devices_list_mutex);
    732718       
    733719        ipc_answer_1(iid, EOK, namespace->handle);
    734        
    735         fibril_mutex_unlock(&devices_list_mutex);
    736720        free(name);
    737721}
    … …  
    741725        fibril_mutex_lock(&devices_list_mutex);
    742726       
    743         devmap_namespace_t *namespace =
    744             devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
     727        devmap_namespace_t *namespace = devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
    745728        if (namespace == NULL) {
    746                 devmap_device_t *dev =
    747                     devmap_device_find_handle(IPC_GET_ARG1(*icall));
     729                devmap_device_t *dev = devmap_device_find_handle(IPC_GET_ARG1(*icall));
    748730                if (dev == NULL)
    749731                        ipc_answer_1(iid, EOK, DEV_HANDLE_NONE);
    … …  
    767749        fibril_mutex_lock(&devices_list_mutex);
    768750       
    769         devmap_namespace_t *namespace =
    770             devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
     751        devmap_namespace_t *namespace = devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
    771752        if (namespace == NULL)
    772753                ipc_answer_0(iid, EEXISTS);
    … …  
    797778        size_t count = size / sizeof(dev_desc_t);
    798779        if (count != list_count(&namespaces_list)) {
    799                 fibril_mutex_unlock(&devices_list_mutex);
    800780                ipc_answer_0(callid, EOVERFLOW);
    801781                ipc_answer_0(iid, EOVERFLOW);
    … …  
    805785        dev_desc_t *desc = (dev_desc_t *) malloc(size);
    806786        if (desc == NULL) {
    807                 fibril_mutex_unlock(&devices_list_mutex);
    808787                ipc_answer_0(callid, ENOMEM);
    809788                ipc_answer_0(iid, ENOMEM);
    … …  
    811790        }
    812791       
    813         link_t *item;
     792        link_t *item = namespaces_list.next;
    814793        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);
     794        while (item != &namespaces_list) {
     795                devmap_namespace_t *namespace = list_get_instance(item, devmap_namespace_t, namespaces);
    819796               
    820797                desc[pos].handle = namespace->handle;
    821798                str_cpy(desc[pos].name, DEVMAP_NAME_MAXLEN, namespace->name);
    822799                pos++;
     800               
     801                item = item->next;
    823802        }
    824803       
    … …  
    852831        fibril_mutex_lock(&devices_list_mutex);
    853832       
    854         devmap_namespace_t *namespace =
    855             devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
     833        devmap_namespace_t *namespace = devmap_namespace_find_handle(IPC_GET_ARG1(*icall));
    856834        if (namespace == NULL) {
    857835                fibril_mutex_unlock(&devices_list_mutex);
    … …  
    863841        size_t count = size / sizeof(dev_desc_t);
    864842        if (count != namespace->refcnt) {
    865                 fibril_mutex_unlock(&devices_list_mutex);
    866843                ipc_answer_0(callid, EOVERFLOW);
    867844                ipc_answer_0(iid, EOVERFLOW);
    … …  
    871848        dev_desc_t *desc = (dev_desc_t *) malloc(size);
    872849        if (desc == NULL) {
    873                 fibril_mutex_unlock(&devices_list_mutex);
    874850                ipc_answer_0(callid, ENOMEM);
    875851                ipc_answer_0(iid, EREFUSED);
    … …  
    877853        }
    878854       
    879         link_t *item;
     855        link_t *item = devices_list.next;
    880856        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);
     857        while (item != &devices_list) {
     858                devmap_device_t *device = list_get_instance(item, devmap_device_t, devices);
    884859               
    885860                if (device->namespace == namespace) {
    … …  
    888863                        pos++;
    889864                }
     865               
     866                item = item->next;
    890867        }
    891868       
    … …  
    928905        }
    929906       
    930         devmap_device_t *device =
    931             (devmap_device_t *) malloc(sizeof(devmap_device_t));
     907        devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
    932908        if (device == NULL) {
    933909                fibril_mutex_unlock(&null_devices_mutex);
    … …  
    939915       
    940916        devmap_namespace_t *namespace = devmap_namespace_create("null");
    941         if (namespace == NULL) {
     917        if (!namespace) {
    942918                fibril_mutex_lock(&devices_list_mutex);
    943919                fibril_mutex_unlock(&null_devices_mutex);
    … …  
    969945static void devmap_null_destroy(ipc_callid_t iid, ipc_call_t *icall)
    970946{
     947        fibril_mutex_lock(&null_devices_mutex);
     948       
    971949        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);
    978950       
    979951        if (null_devices[i] == NULL) {
    980                 fibril_mutex_unlock(&null_devices_mutex);
    981952                ipc_answer_0(iid, ENOENT);
    982953                return;
    … …  
    990961       
    991962        fibril_mutex_unlock(&null_devices_mutex);
     963       
    992964        ipc_answer_0(iid, EOK);
    993965}
    … …  
    11451117int main(int argc, char *argv[])
    11461118{
    1147         printf("%s: HelenOS Device Mapper\n", NAME);
     1119        printf(NAME ": HelenOS Device Mapper\n");
    11481120       
    11491121        if (!devmap_init()) {
    1150                 printf("%s: Error while initializing service\n", NAME);
     1122                printf(NAME ": Error while initializing service\n");
    11511123                return -1;
    11521124        }
    … …  
    11601132                return -1;
    11611133       
    1162         printf("%s: Accepting connections\n", NAME);
     1134        printf(NAME ": Accepting connections\n");
    11631135        async_manager();
    11641136       
Note: See TracChangeset for help on using the changeset viewer.