Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devman/main.c

    rf302586 rc4f7bf6  
    4444#include <errno.h>
    4545#include <str_error.h>
    46 #include <bool.h>
     46#include <stdbool.h>
    4747#include <fibril_synch.h>
    4848#include <stdlib.h>
    … …  
    7373        char *drv_name = NULL;
    7474
    75         log_msg(LVL_DEBUG, "devman_driver_register");
     75        log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_driver_register");
    7676       
    7777        /* Get driver name. */
    … …  
    8282        }
    8383
    84         log_msg(LVL_DEBUG, "The `%s' driver is trying to register.",
     84        log_msg(LOG_DEFAULT, LVL_DEBUG, "The `%s' driver is trying to register.",
    8585            drv_name);
    8686       
    … …  
    8888        driver = find_driver(&drivers_list, drv_name);
    8989        if (driver == NULL) {
    90                 log_msg(LVL_ERROR, "No driver named `%s' was found.", drv_name);
     90                log_msg(LOG_DEFAULT, LVL_ERROR, "No driver named `%s' was found.", drv_name);
    9191                free(drv_name);
    9292                drv_name = NULL;
    … …  
    102102        if (driver->sess) {
    103103                /* We already have a connection to the driver. */
    104                 log_msg(LVL_ERROR, "Driver '%s' already started.\n",
     104                log_msg(LOG_DEFAULT, LVL_ERROR, "Driver '%s' already started.\n",
    105105                    driver->name);
    106106                fibril_mutex_unlock(&driver->driver_mutex);
    … …  
    112112        case DRIVER_NOT_STARTED:
    113113                /* Somebody started the driver manually. */
    114                 log_msg(LVL_NOTE, "Driver '%s' started manually.\n",
     114                log_msg(LOG_DEFAULT, LVL_NOTE, "Driver '%s' started manually.\n",
    115115                    driver->name);
    116116                driver->state = DRIVER_STARTING;
    … …  
    125125       
    126126        /* Create connection to the driver. */
    127         log_msg(LVL_DEBUG, "Creating connection to the `%s' driver.",
     127        log_msg(LOG_DEFAULT, LVL_DEBUG, "Creating connection to the `%s' driver.",
    128128            driver->name);
    129129        driver->sess = async_callback_receive(EXCHANGE_PARALLEL);
    … …  
    136136        async_sess_args_set(driver->sess, DRIVER_DEVMAN, 0, 0);
    137137       
    138         log_msg(LVL_NOTE,
     138        log_msg(LOG_DEFAULT, LVL_NOTE,
    139139            "The `%s' driver was successfully registered as running.",
    140140            driver->name);
    … …  
    147147        fid_t fid = fibril_create(init_running_drv, driver);
    148148        if (fid == 0) {
    149                 log_msg(LVL_ERROR, "Failed to create initialization fibril " \
     149                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to create initialization fibril " \
    150150                    "for driver `%s'.", driver->name);
    151151                fibril_mutex_unlock(&driver->driver_mutex);
    … …  
    176176        callid = async_get_call(&call);
    177177        if (DEVMAN_ADD_MATCH_ID != IPC_GET_IMETHOD(call)) {
    178                 log_msg(LVL_ERROR,
     178                log_msg(LOG_DEFAULT, LVL_ERROR,
    179179                    "Invalid protocol when trying to receive match id.");
    180180                async_answer_0(callid, EINVAL);
    … …  
    184184       
    185185        if (match_id == NULL) {
    186                 log_msg(LVL_ERROR, "Failed to allocate match id.");
     186                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to allocate match id.");
    187187                async_answer_0(callid, ENOMEM);
    188188                return ENOMEM;
    … …  
    198198        if (rc != EOK) {
    199199                delete_match_id(match_id);
    200                 log_msg(LVL_ERROR, "Failed to receive match id string: %s.",
     200                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to receive match id string: %s.",
    201201                    str_error(rc));
    202202                return rc;
    … …  
    205205        list_append(&match_id->link, &match_ids->ids);
    206206       
    207         log_msg(LVL_DEBUG, "Received match id `%s', score %d.",
     207        log_msg(LOG_DEFAULT, LVL_DEBUG, "Received match id `%s', score %d.",
    208208            match_id->id, match_id->score);
    209209        return rc;
    … …  
    245245       
    246246        fibril_rwlock_write_lock(&device_tree.rwlock);
    247 
     247       
    248248        if (fun->state == FUN_ON_LINE) {
    249249                fibril_rwlock_write_unlock(&device_tree.rwlock);
    250                 log_msg(LVL_WARN, "Function %s is already on line.",
     250                log_msg(LOG_DEFAULT, LVL_WARN, "Function %s is already on line.",
    251251                    fun->pathname);
    252252                return EOK;
    … …  
    259259                        return ENOMEM;
    260260                }
    261 
     261               
    262262                insert_dev_node(&device_tree, dev, fun);
    263263                dev_add_ref(dev);
    264264        }
    265265       
    266         log_msg(LVL_DEBUG, "devman_add_function(fun=\"%s\")", fun->pathname);
     266        log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_add_function(fun=\"%s\")", fun->pathname);
    267267       
    268268        if (fun->ftype == fun_inner) {
    … …  
    272272                /* Give one reference over to assign_driver_fibril(). */
    273273                dev_add_ref(dev);
     274               
    274275                /*
    275276                 * Try to find a suitable driver and assign it to the device.  We do
    … …  
    281282                fid_t assign_fibril = fibril_create(assign_driver_fibril, dev);
    282283                if (assign_fibril == 0) {
    283                         log_msg(LVL_ERROR, "Failed to create fibril for "
     284                        log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to create fibril for "
    284285                            "assigning driver.");
    285286                        /* XXX Cleanup */
    … …  
    288289                }
    289290                fibril_add_ready(assign_fibril);
    290         } else {
     291        } else
    291292                loc_register_tree_function(fun, &device_tree);
    292         }
    293293       
    294294        fibril_rwlock_write_unlock(&device_tree.rwlock);
    … …  
    305305        if (fun->state == FUN_OFF_LINE) {
    306306                fibril_rwlock_write_unlock(&device_tree.rwlock);
    307                 log_msg(LVL_WARN, "Function %s is already off line.",
     307                log_msg(LOG_DEFAULT, LVL_WARN, "Function %s is already off line.",
    308308                    fun->pathname);
    309309                return EOK;
    … …  
    311311       
    312312        if (fun->ftype == fun_inner) {
    313                 log_msg(LVL_DEBUG, "Offlining inner function %s.",
     313                log_msg(LOG_DEFAULT, LVL_DEBUG, "Offlining inner function %s.",
    314314                    fun->pathname);
    315315               
    … …  
    359359                if (rc != EOK) {
    360360                        fibril_rwlock_write_unlock(&device_tree.rwlock);
    361                         log_msg(LVL_ERROR, "Failed unregistering tree service.");
     361                        log_msg(LOG_DEFAULT, LVL_ERROR, "Failed unregistering tree service.");
    362362                        return EIO;
    363363                }
    … …  
    391391        if (ftype != fun_inner && ftype != fun_exposed) {
    392392                /* Unknown function type */
    393                 log_msg(LVL_ERROR,
     393                log_msg(LOG_DEFAULT, LVL_ERROR,
    394394                    "Unknown function type %d provided by driver.",
    395395                    (int) ftype);
    … …  
    419419       
    420420        /* Check that function with same name is not there already. */
    421         if (find_fun_node_in_device(tree, pdev, fun_name) != NULL) {
     421        fun_node_t *tfun = find_fun_node_in_device(tree, pdev, fun_name);
     422        if (tfun) {
     423                fun_del_ref(tfun);      /* drop the new unwanted reference */
    422424                fibril_rwlock_write_unlock(&tree->rwlock);
    423425                dev_del_ref(pdev);
    … …  
    430432       
    431433        fun_node_t *fun = create_fun_node();
     434        /* One reference for creation, one for us */
     435        fun_add_ref(fun);
    432436        fun_add_ref(fun);
    433437        fun->ftype = ftype;
     438       
     439        /*
     440         * We can lock the function here even when holding the tree because
     441         * we know it cannot be held by anyone else yet.
     442         */
     443        fun_busy_lock(fun);
    434444       
    435445        if (!insert_fun_node(&device_tree, fun, fun_name, pdev)) {
    436446                fibril_rwlock_write_unlock(&tree->rwlock);
    437447                dev_del_ref(pdev);
     448                fun_busy_unlock(fun);
     449                fun_del_ref(fun);
    438450                delete_fun_node(fun);
    439451                async_answer_0(callid, ENOMEM);
    … …  
    448460        rc = online_function(fun);
    449461        if (rc != EOK) {
    450                 /* XXX clean up */
     462                /* XXX Set some failed state? */
     463                fun_busy_unlock(fun);
     464                fun_del_ref(fun);
    451465                async_answer_0(callid, rc);
    452466                return;
    453467        }
     468       
     469        fun_busy_unlock(fun);
     470        fun_del_ref(fun);
    454471       
    455472        /* Return device handle to parent's driver. */
    … …  
    490507        if (rc == EOK) {
    491508                loc_service_add_to_cat(fun->service_id, cat_id);
    492                 log_msg(LVL_NOTE, "Function `%s' added to category `%s'.",
     509                log_msg(LOG_DEFAULT, LVL_NOTE, "Function `%s' added to category `%s'.",
    493510                    fun->pathname, cat_name);
    494511        } else {
    495                 log_msg(LVL_ERROR, "Failed adding function `%s' to category "
     512                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding function `%s' to category "
    496513                    "`%s'.", fun->pathname, cat_name);
    497514        }
    … …  
    512529        int rc;
    513530       
    514         log_msg(LVL_DEBUG, "devman_drv_fun_online()");
     531        log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_drv_fun_online()");
    515532       
    516533        fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
    … …  
    519536                return;
    520537        }
     538       
     539        fun_busy_lock(fun);
    521540       
    522541        fibril_rwlock_read_lock(&device_tree.rwlock);
    523542        if (fun->dev == NULL || fun->dev->drv != drv) {
    524543                fibril_rwlock_read_unlock(&device_tree.rwlock);
     544                fun_busy_unlock(fun);
    525545                fun_del_ref(fun);
    526546                async_answer_0(iid, ENOENT);
    … …  
    531551        rc = online_function(fun);
    532552        if (rc != EOK) {
     553                fun_busy_unlock(fun);
    533554                fun_del_ref(fun);
    534555                async_answer_0(iid, (sysarg_t) rc);
    … …  
    536557        }
    537558       
     559        fun_busy_unlock(fun);
    538560        fun_del_ref(fun);
    539561       
    … …  
    557579        }
    558580       
     581        fun_busy_lock(fun);
     582       
    559583        fibril_rwlock_write_lock(&device_tree.rwlock);
    560584        if (fun->dev == NULL || fun->dev->drv != drv) {
     585                fun_busy_unlock(fun);
    561586                fun_del_ref(fun);
    562587                async_answer_0(iid, ENOENT);
    … …  
    567592        rc = offline_function(fun);
    568593        if (rc != EOK) {
     594                fun_busy_unlock(fun);
    569595                fun_del_ref(fun);
    570596                async_answer_0(iid, (sysarg_t) rc);
    … …  
    572598        }
    573599       
     600        fun_busy_unlock(fun);
    574601        fun_del_ref(fun);
    575602        async_answer_0(iid, (sysarg_t) EOK);
    … …  
    589616        }
    590617       
     618        fun_busy_lock(fun);
     619       
    591620        fibril_rwlock_write_lock(&tree->rwlock);
    592621       
    593         log_msg(LVL_DEBUG, "devman_remove_function(fun='%s')", fun->pathname);
     622        log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_remove_function(fun='%s')", fun->pathname);
    594623       
    595624        /* Check function state */
    596625        if (fun->state == FUN_REMOVED) {
    597626                fibril_rwlock_write_unlock(&tree->rwlock);
     627                fun_busy_unlock(fun);
     628                fun_del_ref(fun);
    598629                async_answer_0(callid, ENOENT);
    599630                return;
    … …  
    622653                        /* Verify that driver succeeded and removed all functions */
    623654                        if (gone_rc != EOK || !list_empty(&dev->functions)) {
    624                                 log_msg(LVL_ERROR, "Driver did not remove "
     655                                log_msg(LOG_DEFAULT, LVL_ERROR, "Driver did not remove "
    625656                                    "functions for device that is gone. "
    626657                                    "Device node is now defunct.");
    … …  
    636667                                if (gone_rc == EOK)
    637668                                        gone_rc = ENOTSUP;
     669                                fun_busy_unlock(fun);
     670                                fun_del_ref(fun);
    638671                                async_answer_0(callid, gone_rc);
    639672                                return;
    … …  
    659692                        rc = loc_service_unregister(fun->service_id);
    660693                        if (rc != EOK) {
    661                                 log_msg(LVL_ERROR, "Failed unregistering tree "
     694                                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed unregistering tree "
    662695                                    "service.");
    663696                                fibril_rwlock_write_unlock(&tree->rwlock);
     697                                fun_busy_unlock(fun);
    664698                                fun_del_ref(fun);
    665699                                async_answer_0(callid, EIO);
    … …  
    671705        remove_fun_node(&device_tree, fun);
    672706        fibril_rwlock_write_unlock(&tree->rwlock);
     707        fun_busy_unlock(fun);
    673708       
    674709        /* Delete ref added when inserting function into tree */
    … …  
    677712        fun_del_ref(fun);
    678713       
    679         log_msg(LVL_DEBUG, "devman_remove_function() succeeded.");
     714        log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_remove_function() succeeded.");
    680715        async_answer_0(callid, EOK);
    681716}
    … …  
    691726       
    692727        initialize_running_driver(driver, &device_tree);
    693         log_msg(LVL_DEBUG, "The `%s` driver was successfully initialized.",
     728        log_msg(LOG_DEFAULT, LVL_DEBUG, "The `%s` driver was successfully initialized.",
    694729            driver->name);
    695730        return 0;
    … …  
    700735{
    701736        client_t *client;
    702         driver_t *driver;
     737        driver_t *driver = NULL;
    703738       
    704739        /* Accept the connection. */
    … …  
    707742        client = async_get_client_data();
    708743        if (client == NULL) {
    709                 log_msg(LVL_ERROR, "Failed to allocate client data.");
     744                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to allocate client data.");
    710745                return;
    711746        }
    … …  
    855890}
    856891
     892/** Get function driver name. */
     893static void devman_fun_get_driver_name(ipc_callid_t iid, ipc_call_t *icall)
     894{
     895        devman_handle_t handle = IPC_GET_ARG1(*icall);
     896
     897        fun_node_t *fun = find_fun_node(&device_tree, handle);
     898        if (fun == NULL) {
     899                async_answer_0(iid, ENOMEM);
     900                return;
     901        }
     902
     903        ipc_callid_t data_callid;
     904        size_t data_len;
     905        if (!async_data_read_receive(&data_callid, &data_len)) {
     906                async_answer_0(iid, EINVAL);
     907                fun_del_ref(fun);
     908                return;
     909        }
     910
     911        void *buffer = malloc(data_len);
     912        if (buffer == NULL) {
     913                async_answer_0(data_callid, ENOMEM);
     914                async_answer_0(iid, ENOMEM);
     915                fun_del_ref(fun);
     916                return;
     917        }
     918
     919        fibril_rwlock_read_lock(&device_tree.rwlock);
     920
     921        /* Check function state */
     922        if (fun->state == FUN_REMOVED) {
     923                fibril_rwlock_read_unlock(&device_tree.rwlock);
     924                free(buffer);
     925
     926                async_answer_0(data_callid, ENOENT);
     927                async_answer_0(iid, ENOENT);
     928                fun_del_ref(fun);
     929                return;
     930        }
     931
     932        /* Check whether function has a driver */
     933        if (fun->child == NULL || fun->child->drv == NULL) {
     934                fibril_rwlock_read_unlock(&device_tree.rwlock);
     935                free(buffer);
     936
     937                async_answer_0(data_callid, EINVAL);
     938                async_answer_0(iid, EINVAL);
     939                fun_del_ref(fun);
     940                return;
     941        }
     942
     943        size_t sent_length = str_size(fun->child->drv->name);
     944        if (sent_length > data_len) {
     945                sent_length = data_len;
     946        }
     947
     948        async_data_read_finalize(data_callid, fun->child->drv->name,
     949            sent_length);
     950        async_answer_0(iid, EOK);
     951
     952        fibril_rwlock_read_unlock(&device_tree.rwlock);
     953        fun_del_ref(fun);
     954        free(buffer);
     955}
    857956
    858957/** Get device path. */
    … …  
    10831182                        devman_fun_get_name(callid, &call);
    10841183                        break;
     1184                case DEVMAN_FUN_GET_DRIVER_NAME:
     1185                        devman_fun_get_driver_name(callid, &call);
     1186                        break;
    10851187                case DEVMAN_FUN_GET_PATH:
    10861188                        devman_fun_get_path(callid, &call);
    … …  
    11271229         */
    11281230        if (dev == NULL) {
    1129                 log_msg(LVL_ERROR, "IPC forwarding failed - no device or "
     1231                log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding failed - no device or "
    11301232                    "function with handle %" PRIun " was found.", handle);
    11311233                async_answer_0(iid, ENOENT);
    … …  
    11341236
    11351237        if (fun == NULL && !drv_to_parent) {
    1136                 log_msg(LVL_ERROR, NAME ": devman_forward error - cannot "
     1238                log_msg(LOG_DEFAULT, LVL_ERROR, NAME ": devman_forward error - cannot "
    11371239                    "connect to handle %" PRIun ", refers to a device.",
    11381240                    handle);
    … …  
    11491251                if (dev->pfun->dev != NULL)
    11501252                        driver = dev->pfun->dev->drv;
     1253               
    11511254                fwd_h = dev->pfun->handle;
    11521255        } else if (dev->state == DEVICE_USABLE) {
    … …  
    11541257                driver = dev->drv;
    11551258                assert(driver != NULL);
    1156 
     1259               
    11571260                fwd_h = handle;
    11581261        }
    … …  
    11611264       
    11621265        if (driver == NULL) {
    1163                 log_msg(LVL_ERROR, "IPC forwarding refused - " \
     1266                log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding refused - " \
    11641267                    "the device %" PRIun " is not in usable state.", handle);
    11651268                async_answer_0(iid, ENOENT);
    … …  
    11741277       
    11751278        if (!driver->sess) {
    1176                 log_msg(LVL_ERROR,
     1279                log_msg(LOG_DEFAULT, LVL_ERROR,
    11771280                    "Could not forward to driver `%s'.", driver->name);
    11781281                async_answer_0(iid, EINVAL);
    … …  
    11811284
    11821285        if (fun != NULL) {
    1183                 log_msg(LVL_DEBUG,
     1286                log_msg(LOG_DEFAULT, LVL_DEBUG,
    11841287                    "Forwarding request for `%s' function to driver `%s'.",
    11851288                    fun->pathname, driver->name);
    11861289        } else {
    1187                 log_msg(LVL_DEBUG,
     1290                log_msg(LOG_DEFAULT, LVL_DEBUG,
    11881291                    "Forwarding request for `%s' device to driver `%s'.",
    11891292                    dev->pfun->pathname, driver->name);
    … …  
    11931296        async_forward_fast(iid, exch, method, fwd_h, 0, IPC_FF_NONE);
    11941297        async_exchange_end(exch);
    1195 
     1298       
    11961299cleanup:
    11971300        if (dev != NULL)
    11981301                dev_del_ref(dev);
     1302       
    11991303        if (fun != NULL)
    12001304                fun_del_ref(fun);
    … …  
    12161320       
    12171321        if (fun == NULL || fun->dev == NULL || fun->dev->drv == NULL) {
    1218                 log_msg(LVL_WARN, "devman_connection_loc(): function "
     1322                log_msg(LOG_DEFAULT, LVL_WARN, "devman_connection_loc(): function "
    12191323                    "not found.\n");
    12201324                fibril_rwlock_read_unlock(&device_tree.rwlock);
    … …  
    12341338        async_exchange_end(exch);
    12351339       
    1236         log_msg(LVL_DEBUG,
     1340        log_msg(LOG_DEFAULT, LVL_DEBUG,
    12371341            "Forwarding loc service request for `%s' function to driver `%s'.",
    12381342            fun->pathname, driver->name);
    … …  
    12901394static bool devman_init(void)
    12911395{
    1292         log_msg(LVL_DEBUG, "devman_init - looking for available drivers.");
     1396        log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_init - looking for available drivers.");
    12931397       
    12941398        /* Initialize list of available drivers. */
    … …  
    12961400        if (lookup_available_drivers(&drivers_list,
    12971401            DRIVER_DEFAULT_STORE) == 0) {
    1298                 log_msg(LVL_FATAL, "No drivers found.");
     1402                log_msg(LOG_DEFAULT, LVL_FATAL, "No drivers found.");
    12991403                return false;
    13001404        }
    1301 
    1302         log_msg(LVL_DEBUG, "devman_init - list of drivers has been initialized.");
    1303 
     1405       
     1406        log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_init - list of drivers has been initialized.");
     1407       
    13041408        /* Create root device node. */
    13051409        if (!init_device_tree(&device_tree, &drivers_list)) {
    1306                 log_msg(LVL_FATAL, "Failed to initialize device tree.");
     1410                log_msg(LOG_DEFAULT, LVL_FATAL, "Failed to initialize device tree.");
    13071411                return false;
    13081412        }
    1309 
     1413       
    13101414        /*
    13111415         * Caution: As the device manager is not a real loc
    … …  
    13221426int main(int argc, char *argv[])
    13231427{
    1324         printf(NAME ": HelenOS Device Manager\n");
    1325 
    1326         if (log_init(NAME, LVL_WARN) != EOK) {
    1327                 printf(NAME ": Error initializing logging subsystem.\n");
    1328                 return -1;
     1428        printf("%s: HelenOS Device Manager\n", NAME);
     1429       
     1430        int rc = log_init(NAME);
     1431        if (rc != EOK) {
     1432                printf("%s: Error initializing logging subsystem.\n", NAME);
     1433                return rc;
    13291434        }
    13301435       
    … …  
    13331438        async_set_client_data_destructor(devman_client_data_destroy);
    13341439        async_set_client_connection(devman_connection);
    1335 
     1440       
    13361441        if (!devman_init()) {
    1337                 log_msg(LVL_ERROR, "Error while initializing service.");
     1442                log_msg(LOG_DEFAULT, LVL_ERROR, "Error while initializing service.");
    13381443                return -1;
    13391444        }
    1340 
     1445       
    13411446        /* Register device manager at naming service. */
    1342         if (service_register(SERVICE_DEVMAN) != EOK) {
    1343                 log_msg(LVL_ERROR, "Failed registering as a service.");
    1344                 return -1;
    1345         }
    1346 
    1347         printf(NAME ": Accepting connections.\n");
     1447        rc = service_register(SERVICE_DEVMAN);
     1448        if (rc != EOK) {
     1449                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering as a service.");
     1450                return rc;
     1451        }
     1452       
     1453        printf("%s: Accepting connections.\n", NAME);
    13481454        task_retval(0);
    13491455        async_manager();
    1350 
     1456       
    13511457        /* Never reached. */
    13521458        return 0;
Note: See TracChangeset for help on using the changeset viewer.