Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devman/main.c

    r3ad7b1c rc6c389ed  
    3636 */
    3737
    38 #include <inttypes.h>
    3938#include <assert.h>
    4039#include <ipc/services.h>
    … …  
    4342#include <stdio.h>
    4443#include <errno.h>
    45 #include <str_error.h>
    4644#include <bool.h>
    4745#include <fibril_synch.h>
    … …  
    5250#include <sys/stat.h>
    5351#include <ctype.h>
    54 #include <io/log.h>
    5552#include <ipc/devman.h>
    5653#include <ipc/driver.h>
    … …  
    7370        driver_t *driver = NULL;
    7471
    75         log_msg(LVL_DEBUG, "devman_driver_register");
     72        printf(NAME ": devman_driver_register \n");
    7673       
    7774        iid = async_get_call(&icall);
    78         if (IPC_GET_IMETHOD(icall) != DEVMAN_DRIVER_REGISTER) {
    79                 async_answer_0(iid, EREFUSED);
     75        if (IPC_GET_METHOD(icall) != DEVMAN_DRIVER_REGISTER) {
     76                ipc_answer_0(iid, EREFUSED);
    8077                return NULL;
    8178        }
    … …  
    8683        int rc = async_data_write_accept((void **) &drv_name, true, 0, 0, 0, 0);
    8784        if (rc != EOK) {
    88                 async_answer_0(iid, rc);
     85                ipc_answer_0(iid, rc);
    8986                return NULL;
    9087        }
    9188
    92         log_msg(LVL_DEBUG, "The `%s' driver is trying to register.",
     89        printf(NAME ": the %s driver is trying to register by the service.\n",
    9390            drv_name);
    9491       
    9592        /* Find driver structure. */
    9693        driver = find_driver(&drivers_list, drv_name);
     94       
    9795        if (driver == NULL) {
    98                 log_msg(LVL_ERROR, "No driver named `%s' was found.", drv_name);
     96                printf(NAME ": no driver named %s was found.\n", drv_name);
    9997                free(drv_name);
    10098                drv_name = NULL;
    101                 async_answer_0(iid, ENOENT);
     99                ipc_answer_0(iid, ENOENT);
    102100                return NULL;
    103101        }
    … …  
    106104        drv_name = NULL;
    107105       
    108         fibril_mutex_lock(&driver->driver_mutex);
    109        
    110         if (driver->phone >= 0) {
    111                 /* We already have a connection to the driver. */
    112                 log_msg(LVL_ERROR, "Driver '%s' already started.\n",
    113                     driver->name);
    114                 fibril_mutex_unlock(&driver->driver_mutex);
    115                 async_answer_0(iid, EEXISTS);
    116                 return NULL;
    117         }
    118        
    119         switch (driver->state) {
    120         case DRIVER_NOT_STARTED:
    121                 /* Somebody started the driver manually. */
    122                 log_msg(LVL_NOTE, "Driver '%s' started manually.\n",
    123                     driver->name);
    124                 driver->state = DRIVER_STARTING;
    125                 break;
    126         case DRIVER_STARTING:
    127                 /* The expected case */
    128                 break;
    129         case DRIVER_RUNNING:
    130                 /* Should not happen since we do not have a connected phone */
    131                 assert(false);
    132         }
    133        
    134106        /* Create connection to the driver. */
    135         log_msg(LVL_DEBUG, "Creating connection to the `%s' driver.",
    136             driver->name);
     107        printf(NAME ":  creating connection to the %s driver.\n", driver->name);
    137108        ipc_call_t call;
    138109        ipc_callid_t callid = async_get_call(&call);
    139         if (IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) {
    140                 fibril_mutex_unlock(&driver->driver_mutex);
    141                 async_answer_0(callid, ENOTSUP);
    142                 async_answer_0(iid, ENOTSUP);
     110        if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
     111                ipc_answer_0(callid, ENOTSUP);
     112                ipc_answer_0(iid, ENOTSUP);
    143113                return NULL;
    144114        }
    145115       
    146116        /* Remember driver's phone. */
    147         driver->phone = IPC_GET_ARG5(call);
    148        
    149         fibril_mutex_unlock(&driver->driver_mutex);
    150        
    151         log_msg(LVL_NOTE,
    152             "The `%s' driver was successfully registered as running.",
     117        set_driver_phone(driver, IPC_GET_ARG5(call));
     118       
     119        printf(NAME ": the %s driver was successfully registered as running.\n",
    153120            driver->name);
    154121       
    155         async_answer_0(callid, EOK);
    156         async_answer_0(iid, EOK);
     122        ipc_answer_0(callid, EOK);
     123        ipc_answer_0(iid, EOK);
    157124       
    158125        return driver;
    … …  
    173140       
    174141        callid = async_get_call(&call);
    175         if (DEVMAN_ADD_MATCH_ID != IPC_GET_IMETHOD(call)) {
    176                 log_msg(LVL_ERROR,
    177                     "Invalid protocol when trying to receive match id.");
    178                 async_answer_0(callid, EINVAL);
     142        if (DEVMAN_ADD_MATCH_ID != IPC_GET_METHOD(call)) {
     143                printf(NAME ": ERROR: devman_receive_match_id - invalid "
     144                    "protocol.\n");
     145                ipc_answer_0(callid, EINVAL);
    179146                delete_match_id(match_id);
    180147                return EINVAL;
    … …  
    182149       
    183150        if (match_id == NULL) {
    184                 log_msg(LVL_ERROR, "Failed to allocate match id.");
    185                 async_answer_0(callid, ENOMEM);
     151                printf(NAME ": ERROR: devman_receive_match_id - failed to "
     152                    "allocate match id.\n");
     153                ipc_answer_0(callid, ENOMEM);
    186154                return ENOMEM;
    187155        }
    188156       
    189         async_answer_0(callid, EOK);
     157        ipc_answer_0(callid, EOK);
    190158       
    191159        match_id->score = IPC_GET_ARG1(call);
    … …  
    196164        if (rc != EOK) {
    197165                delete_match_id(match_id);
    198                 log_msg(LVL_ERROR, "Failed to receive match id string: %s.",
    199                     str_error(rc));
     166                printf(NAME ": devman_receive_match_id - failed to receive "
     167                    "match id string.\n");
    200168                return rc;
    201169        }
    … …  
    203171        list_append(&match_id->link, &match_ids->ids);
    204172       
    205         log_msg(LVL_DEBUG, "Received match id `%s', score %d.",
     173        printf(NAME ": received match id '%s', score = %d \n",
    206174            match_id->id, match_id->score);
    207175        return rc;
    … …  
    215183 * @return              Zero on success, negative error code otherwise.
    216184 */
    217 static int devman_receive_match_ids(sysarg_t match_count,
     185static int devman_receive_match_ids(ipcarg_t match_count,
    218186    match_id_list_t *match_ids)
    219187{
    … …  
    228196}
    229197
    230 static int assign_driver_fibril(void *arg)
    231 {
    232         dev_node_t *dev_node = (dev_node_t *) arg;
    233         assign_driver(dev_node, &drivers_list, &device_tree);
    234         return EOK;
    235 }
    236 
    237 /** Handle function registration.
     198/** Handle child device registration.
    238199 *
    239200 * Child devices are registered by their parent's device driver.
    240201 */
    241 static void devman_add_function(ipc_callid_t callid, ipc_call_t *call)
    242 {
    243         fun_type_t ftype = (fun_type_t) IPC_GET_ARG1(*call);
    244         devman_handle_t dev_handle = IPC_GET_ARG2(*call);
    245         sysarg_t match_count = IPC_GET_ARG3(*call);
     202static void devman_add_child(ipc_callid_t callid, ipc_call_t *call)
     203{
     204        device_handle_t parent_handle = IPC_GET_ARG1(*call);
     205        ipcarg_t match_count = IPC_GET_ARG2(*call);
    246206        dev_tree_t *tree = &device_tree;
    247207       
    248208        fibril_rwlock_write_lock(&tree->rwlock);
    249 
    250         dev_node_t *dev = NULL;
    251         dev_node_t *pdev = find_dev_node_no_lock(&device_tree, dev_handle);
    252        
    253         if (pdev == NULL) {
     209        node_t *parent = find_dev_node_no_lock(&device_tree, parent_handle);
     210       
     211        if (parent == NULL) {
    254212                fibril_rwlock_write_unlock(&tree->rwlock);
    255                 async_answer_0(callid, ENOENT);
    256                 return;
    257         }
    258        
    259         if (ftype != fun_inner && ftype != fun_exposed) {
    260                 /* Unknown function type */
    261                 log_msg(LVL_ERROR,
    262                     "Unknown function type %d provided by driver.",
    263                     (int) ftype);
    264 
    265                 fibril_rwlock_write_unlock(&tree->rwlock);
    266                 async_answer_0(callid, EINVAL);
    267                 return;
    268         }
    269        
    270         char *fun_name = NULL;
    271         int rc = async_data_write_accept((void **)&fun_name, true, 0, 0, 0, 0);
     213                ipc_answer_0(callid, ENOENT);
     214                return;
     215        }
     216       
     217        char *dev_name = NULL;
     218        int rc = async_data_write_accept((void **)&dev_name, true, 0, 0, 0, 0);
    272219        if (rc != EOK) {
    273220                fibril_rwlock_write_unlock(&tree->rwlock);
    274                 async_answer_0(callid, rc);
    275                 return;
    276         }
    277        
    278         /* Check that function with same name is not there already. */
    279         if (find_fun_node_in_device(pdev, fun_name) != NULL) {
     221                ipc_answer_0(callid, rc);
     222                return;
     223        }
     224       
     225        node_t *node = create_dev_node();
     226        if (!insert_dev_node(&device_tree, node, dev_name, parent)) {
    280227                fibril_rwlock_write_unlock(&tree->rwlock);
    281                 async_answer_0(callid, EEXISTS);
    282                 printf(NAME ": Warning, driver tried to register `%s' twice.\n",
    283                     fun_name);
    284                 free(fun_name);
    285                 return;
    286         }
    287 
    288         fun_node_t *fun = create_fun_node();
    289         if (!insert_fun_node(&device_tree, fun, fun_name, pdev)) {
    290                 fibril_rwlock_write_unlock(&tree->rwlock);
    291                 delete_fun_node(fun);
    292                 async_answer_0(callid, ENOMEM);
    293                 return;
    294         }
    295 
    296         if (ftype == fun_inner) {
    297                 dev = create_dev_node();
    298                 if (dev == NULL) {
    299                         fibril_rwlock_write_unlock(&tree->rwlock);
    300                         delete_fun_node(fun);
    301                         async_answer_0(callid, ENOMEM);
    302                         return;
    303                 }
    304 
    305                 insert_dev_node(tree, dev, fun);
     228                delete_dev_node(node);
     229                ipc_answer_0(callid, ENOMEM);
     230                return;
    306231        }
    307232
    308233        fibril_rwlock_write_unlock(&tree->rwlock);
    309234       
    310         log_msg(LVL_DEBUG, "devman_add_function(fun=\"%s\")", fun->pathname);
    311        
    312         devman_receive_match_ids(match_count, &fun->match_ids);
    313 
    314         if (ftype == fun_inner) {
    315                 assert(dev != NULL);
    316                 /*
    317                  * Try to find a suitable driver and assign it to the device.  We do
    318                  * not want to block the current fibril that is used for processing
    319                  * incoming calls: we will launch a separate fibril to handle the
    320                  * driver assigning. That is because assign_driver can actually include
    321                  * task spawning which could take some time.
    322                  */
    323                 fid_t assign_fibril = fibril_create(assign_driver_fibril, dev);
    324                 if (assign_fibril == 0) {
    325                         /*
    326                          * Fallback in case we are out of memory.
    327                          * Probably not needed as we will die soon anyway ;-).
    328                          */
    329                         (void) assign_driver_fibril(fun);
    330                 } else {
    331                         fibril_add_ready(assign_fibril);
    332                 }
    333         } else {
    334                 devmap_register_tree_function(fun, tree);
    335         }
     235        printf(NAME ": devman_add_child %s\n", node->pathname);
     236       
     237        devman_receive_match_ids(match_count, &node->match_ids);
    336238       
    337239        /* Return device handle to parent's driver. */
    338         async_answer_1(callid, EOK, fun->handle);
     240        ipc_answer_1(callid, EOK, node->handle);
     241       
     242        /* Try to find suitable driver and assign it to the device. */
     243        assign_driver(node, &drivers_list, &device_tree);
    339244}
    340245
    … …  
    353258         * handle.
    354259         */
    355         devmap_device_register_with_iface(devmap_pathname,
    356             &cli->devmap_handle, DEVMAN_CONNECT_FROM_DEVMAP);
     260        devmap_device_register(devmap_pathname, &cli->devmap_handle);
    357261       
    358262        /*
    … …  
    360264         * mapper.
    361265         */
    362         class_add_devmap_function(&class_list, cli);
     266        class_add_devmap_device(&class_list, cli);
    363267       
    364268        free(devmap_pathname);
    365269}
    366270
    367 static void devman_add_function_to_class(ipc_callid_t callid, ipc_call_t *call)
    368 {
    369         devman_handle_t handle = IPC_GET_ARG1(*call);
     271static void devman_add_device_to_class(ipc_callid_t callid, ipc_call_t *call)
     272{
     273        device_handle_t handle = IPC_GET_ARG1(*call);
    370274       
    371275        /* Get class name. */
    … …  
    374278            0, 0, 0, 0);
    375279        if (rc != EOK) {
    376                 async_answer_0(callid, rc);
     280                ipc_answer_0(callid, rc);
    377281                return;
    378282        }       
    379283       
    380         fun_node_t *fun = find_fun_node(&device_tree, handle);
    381         if (fun == NULL) {
    382                 async_answer_0(callid, ENOENT);
     284        node_t *dev = find_dev_node(&device_tree, handle);
     285        if (dev == NULL) {
     286                ipc_answer_0(callid, ENOENT);
    383287                return;
    384288        }
    385289       
    386290        dev_class_t *cl = get_dev_class(&class_list, class_name);
    387         dev_class_info_t *class_info = add_function_to_class(fun, cl, NULL);
     291        dev_class_info_t *class_info = add_device_to_class(dev, cl, NULL);
    388292       
    389293        /* Register the device's class alias by devmapper. */
    390294        devmap_register_class_dev(class_info);
    391295       
    392         log_msg(LVL_NOTE, "Function `%s' added to class `%s' as `%s'.",
    393             fun->pathname, class_name, class_info->dev_name);
    394 
    395         async_answer_0(callid, EOK);
     296        printf(NAME ": device '%s' added to class '%s', class name '%s' was "
     297            "asigned to it\n", dev->pathname, class_name, class_info->dev_name);
     298       
     299        ipc_answer_0(callid, EOK);
    396300}
    397301
    … …  
    406310       
    407311        initialize_running_driver(driver, &device_tree);
    408         log_msg(LVL_DEBUG, "The `%s` driver was successfully initialized.",
     312        printf(NAME ": the %s driver was successfully initialized. \n",
    409313            driver->name);
    410314        return 0;
    … …  
    415319{
    416320        /* Accept the connection. */
    417         async_answer_0(iid, EOK);
     321        ipc_answer_0(iid, EOK);
    418322       
    419323        driver_t *driver = devman_driver_register();
    … …  
    428332        fid_t fid = fibril_create(init_running_drv, driver);
    429333        if (fid == 0) {
    430                 log_msg(LVL_ERROR, "Failed to create initialization fibril " \
    431                     "for driver `%s'.", driver->name);
     334                printf(NAME ": Error creating fibril for the initialization of "
     335                    "the newly registered running driver.\n");
    432336                return;
    433337        }
    … …  
    440344                callid = async_get_call(&call);
    441345               
    442                 switch (IPC_GET_IMETHOD(call)) {
     346                switch (IPC_GET_METHOD(call)) {
    443347                case IPC_M_PHONE_HUNGUP:
    444348                        cont = false;
    445349                        continue;
    446                 case DEVMAN_ADD_FUNCTION:
    447                         devman_add_function(callid, &call);
     350                case DEVMAN_ADD_CHILD_DEVICE:
     351                        devman_add_child(callid, &call);
    448352                        break;
    449353                case DEVMAN_ADD_DEVICE_TO_CLASS:
    450                         devman_add_function_to_class(callid, &call);
     354                        devman_add_device_to_class(callid, &call);
    451355                        break;
    452356                default:
    453                         async_answer_0(callid, EINVAL);
     357                        ipc_answer_0(callid, EINVAL);
    454358                        break;
    455359                }
    … …  
    459363/** Find handle for the device instance identified by the device's path in the
    460364 * device tree. */
    461 static void devman_function_get_handle(ipc_callid_t iid, ipc_call_t *icall)
     365static void devman_device_get_handle(ipc_callid_t iid, ipc_call_t *icall)
    462366{
    463367        char *pathname;
    … …  
    465369        int rc = async_data_write_accept((void **) &pathname, true, 0, 0, 0, 0);
    466370        if (rc != EOK) {
    467                 async_answer_0(iid, rc);
    468                 return;
    469         }
    470        
    471         fun_node_t *fun = find_fun_node_by_path(&device_tree, pathname);
     371                ipc_answer_0(iid, rc);
     372                return;
     373        }
     374       
     375        node_t * dev = find_dev_node_by_path(&device_tree, pathname);
    472376       
    473377        free(pathname);
    474378
    475         if (fun == NULL) {
    476                 async_answer_0(iid, ENOENT);
    477                 return;
    478         }
    479 
    480         async_answer_1(iid, EOK, fun->handle);
    481 }
    482 
    483 /** Find handle for the device instance identified by device class name. */
    484 static void devman_function_get_handle_by_class(ipc_callid_t iid,
    485     ipc_call_t *icall)
    486 {
    487         char *classname;
    488         char *devname;
    489 
    490         int rc = async_data_write_accept((void **) &classname, true, 0, 0, 0, 0);
    491         if (rc != EOK) {
    492                 async_answer_0(iid, rc);
    493                 return;
    494         }
    495         rc = async_data_write_accept((void **) &devname, true, 0, 0, 0, 0);
    496         if (rc != EOK) {
    497                 free(classname);
    498                 async_answer_0(iid, rc);
    499                 return;
    500         }
    501 
    502 
    503         fun_node_t *fun = find_fun_node_by_class(&class_list,
    504             classname, devname);
    505 
    506         free(classname);
    507         free(devname);
    508 
    509         if (fun == NULL) {
    510                 async_answer_0(iid, ENOENT);
    511                 return;
    512         }
    513 
    514         async_answer_1(iid, EOK, fun->handle);
     379        if (dev == NULL) {
     380                ipc_answer_0(iid, ENOENT);
     381                return;
     382        }
     383       
     384        ipc_answer_1(iid, EOK, dev->handle);
    515385}
    516386
    … …  
    520390{
    521391        /* Accept connection. */
    522         async_answer_0(iid, EOK);
     392        ipc_answer_0(iid, EOK);
    523393       
    524394        bool cont = true;
    … …  
    527397                ipc_callid_t callid = async_get_call(&call);
    528398               
    529                 switch (IPC_GET_IMETHOD(call)) {
     399                switch (IPC_GET_METHOD(call)) {
    530400                case IPC_M_PHONE_HUNGUP:
    531401                        cont = false;
    532402                        continue;
    533403                case DEVMAN_DEVICE_GET_HANDLE:
    534                         devman_function_get_handle(callid, &call);
    535                         break;
    536                 case DEVMAN_DEVICE_GET_HANDLE_BY_CLASS:
    537                         devman_function_get_handle_by_class(callid, &call);
     404                        devman_device_get_handle(callid, &call);
    538405                        break;
    539406                default:
    540                         async_answer_0(callid, ENOENT);
     407                        if (!(callid & IPC_CALLID_NOTIFICATION))
     408                                ipc_answer_0(callid, ENOENT);
    541409                }
    542410        }
    … …  
    546414    bool drv_to_parent)
    547415{
    548         devman_handle_t handle = IPC_GET_ARG2(*icall);
    549         devman_handle_t fwd_h;
    550         fun_node_t *fun = NULL;
    551         dev_node_t *dev = NULL;
    552        
    553         fun = find_fun_node(&device_tree, handle);
    554         if (fun == NULL)
    555                 dev = find_dev_node(&device_tree, handle);
    556         else
    557                 dev = fun->dev;
    558 
    559         /*
    560          * For a valid function to connect to we need a device. The root
    561          * function, for example, has no device and cannot be connected to.
    562          * This means @c dev needs to be valid regardless whether we are
    563          * connecting to a device or to a function.
    564          */
     416        device_handle_t handle = IPC_GET_ARG2(*icall);
     417       
     418        node_t *dev = find_dev_node(&device_tree, handle);
    565419        if (dev == NULL) {
    566                 log_msg(LVL_ERROR, "IPC forwarding failed - no device or "
    567                     "function with handle %" PRIun " was found.", handle);
    568                 async_answer_0(iid, ENOENT);
    569                 return;
    570         }
    571 
    572         if (fun == NULL && !drv_to_parent) {
    573                 log_msg(LVL_ERROR, NAME ": devman_forward error - cannot "
    574                     "connect to handle %" PRIun ", refers to a device.",
    575                     handle);
    576                 async_answer_0(iid, ENOENT);
     420                printf(NAME ": devman_forward error - no device with handle %x "
     421                    "was found.\n", handle);
     422                ipc_answer_0(iid, ENOENT);
    577423                return;
    578424        }
    … …  
    581427       
    582428        if (drv_to_parent) {
    583                 /* Connect to parent function of a device (or device function). */
    584                 if (dev->pfun->dev != NULL)
    585                         driver = dev->pfun->dev->drv;
    586                 fwd_h = dev->pfun->handle;
     429                if (dev->parent != NULL)
     430                        driver = dev->parent->drv;
    587431        } else if (dev->state == DEVICE_USABLE) {
    588                 /* Connect to the specified function */
    589432                driver = dev->drv;
    590433                assert(driver != NULL);
    591 
    592                 fwd_h = handle;
    593434        }
    594435       
    595436        if (driver == NULL) {
    596                 log_msg(LVL_ERROR, "IPC forwarding refused - " \
    597                     "the device %" PRIun " is not in usable state.", handle);
    598                 async_answer_0(iid, ENOENT);
     437                printf(NAME ": devman_forward error - the device is not in "
     438                    "usable state.\n", handle);
     439                ipc_answer_0(iid, ENOENT);
    599440                return;
    600441        }
    … …  
    606447                method = DRIVER_CLIENT;
    607448       
    608         if (driver->phone < 0) {
    609                 log_msg(LVL_ERROR,
    610                     "Could not forward to driver `%s' (phone is %d).",
    611                     driver->name, (int) driver->phone);
    612                 async_answer_0(iid, EINVAL);
    613                 return;
    614         }
    615 
    616         if (fun != NULL) {
    617                 log_msg(LVL_DEBUG,
    618                     "Forwarding request for `%s' function to driver `%s'.",
    619                     fun->pathname, driver->name);
    620         } else {
    621                 log_msg(LVL_DEBUG,
    622                     "Forwarding request for `%s' device to driver `%s'.",
    623                     dev->pfun->pathname, driver->name);
    624         }
    625 
    626         async_forward_fast(iid, driver->phone, method, fwd_h, 0, IPC_FF_NONE);
     449        if (driver->phone <= 0) {
     450                printf(NAME ": devman_forward: cound not forward to driver %s ",
     451                    driver->name);
     452                printf("the driver's phone is %x).\n", driver->phone);
     453                ipc_answer_0(iid, EINVAL);
     454                return;
     455        }
     456
     457        printf(NAME ": devman_forward: forward connection to device %s to "
     458            "driver %s.\n", dev->pathname, driver->name);
     459        ipc_forward_fast(iid, driver->phone, method, dev->handle, 0, IPC_FF_NONE);
    627460}
    628461
    … …  
    631464static void devman_connection_devmapper(ipc_callid_t iid, ipc_call_t *icall)
    632465{
    633         devmap_handle_t devmap_handle = IPC_GET_ARG2(*icall);
    634         fun_node_t *fun;
    635         dev_node_t *dev;
    636 
    637         fun = find_devmap_tree_function(&device_tree, devmap_handle);
    638         if (fun == NULL)
    639                 fun = find_devmap_class_function(&class_list, devmap_handle);
    640        
    641         if (fun == NULL || fun->dev->drv == NULL) {
    642                 async_answer_0(iid, ENOENT);
    643                 return;
    644         }
    645        
    646         dev = fun->dev;
    647        
    648         if (dev->state != DEVICE_USABLE || dev->drv->phone < 0) {
    649                 async_answer_0(iid, EINVAL);
    650                 return;
    651         }
    652        
    653         async_forward_fast(iid, dev->drv->phone, DRIVER_CLIENT, fun->handle, 0,
     466        dev_handle_t devmap_handle = IPC_GET_METHOD(*icall);
     467        node_t *dev;
     468
     469        dev = find_devmap_tree_device(&device_tree, devmap_handle);
     470        if (dev == NULL)
     471                dev = find_devmap_class_device(&class_list, devmap_handle);
     472       
     473        if (dev == NULL || dev->drv == NULL) {
     474                ipc_answer_0(iid, ENOENT);
     475                return;
     476        }
     477       
     478        if (dev->state != DEVICE_USABLE || dev->drv->phone <= 0) {
     479                ipc_answer_0(iid, EINVAL);
     480                return;
     481        }
     482       
     483        printf(NAME ": devman_connection_devmapper: forward connection to "
     484            "device %s to driver %s.\n", dev->pathname, dev->drv->name);
     485        ipc_forward_fast(iid, dev->drv->phone, DRIVER_CLIENT, dev->handle, 0,
    654486            IPC_FF_NONE);
    655         log_msg(LVL_DEBUG,
    656             "Forwarding devmapper request for `%s' function to driver `%s'.",
    657             fun->pathname, dev->drv->name);
    658487}
    659488
    … …  
    661490static void devman_connection(ipc_callid_t iid, ipc_call_t *icall)
    662491{
     492        /*
     493         * Silly hack to enable the device manager to register as a driver by
     494         * the device mapper. If the ipc method is not IPC_M_CONNECT_ME_TO, this
     495         * is not the forwarded connection from naming service, so it must be a
     496         * connection from the devmapper which thinks this is a devmapper-style
     497         * driver. So pretend this is a devmapper-style driver. (This does not
     498         * work for device with handle == IPC_M_CONNECT_ME_TO, because devmapper
     499         * passes device handle to the driver as an ipc method.)
     500         */
     501        if (IPC_GET_METHOD(*icall) != IPC_M_CONNECT_ME_TO)
     502                devman_connection_devmapper(iid, icall);
     503
     504        /*
     505         * ipc method is IPC_M_CONNECT_ME_TO, so this is forwarded connection
     506         * from naming service by which we registered as device manager, so be
     507         * device manager.
     508         */
     509       
    663510        /* Select interface. */
    664         switch ((sysarg_t) (IPC_GET_ARG1(*icall))) {
     511        switch ((ipcarg_t) (IPC_GET_ARG1(*icall))) {
    665512        case DEVMAN_DRIVER:
    666513                devman_connection_driver(iid, icall);
    … …  
    673520                devman_forward(iid, icall, false);
    674521                break;
    675         case DEVMAN_CONNECT_FROM_DEVMAP:
    676                 /* Someone connected through devmap node. */
    677                 devman_connection_devmapper(iid, icall);
    678                 break;
    679522        case DEVMAN_CONNECT_TO_PARENTS_DEVICE:
    680523                /* Connect client to selected device. */
    … …  
    683526        default:
    684527                /* No such interface */
    685                 async_answer_0(iid, ENOENT);
     528                ipc_answer_0(iid, ENOENT);
    686529        }
    687530}
    … …  
    690533static bool devman_init(void)
    691534{
    692         log_msg(LVL_DEBUG, "devman_init - looking for available drivers.");
     535        printf(NAME ": devman_init - looking for available drivers.\n");
    693536       
    694537        /* Initialize list of available drivers. */
    … …  
    696539        if (lookup_available_drivers(&drivers_list,
    697540            DRIVER_DEFAULT_STORE) == 0) {
    698                 log_msg(LVL_FATAL, "No drivers found.");
     541                printf(NAME " no drivers found.");
    699542                return false;
    700543        }
    701544
    702         log_msg(LVL_DEBUG, "devman_init - list of drivers has been initialized.");
     545        printf(NAME ": devman_init  - list of drivers has been initialized.\n");
    703546
    704547        /* Create root device node. */
    705548        if (!init_device_tree(&device_tree, &drivers_list)) {
    706                 log_msg(LVL_FATAL, "Failed to initialize device tree.");
     549                printf(NAME " failed to initialize device tree.");
    707550                return false;
    708551        }
    … …  
    725568        printf(NAME ": HelenOS Device Manager\n");
    726569
    727         if (log_init(NAME, LVL_ERROR) != EOK) {
    728                 printf(NAME ": Error initializing logging subsystem.\n");
    729                 return -1;
    730         }
    731 
    732570        if (!devman_init()) {
    733                 log_msg(LVL_ERROR, "Error while initializing service.");
     571                printf(NAME ": Error while initializing service\n");
    734572                return -1;
    735573        }
    … …  
    739577
    740578        /* Register device manager at naming service. */
    741         if (service_register(SERVICE_DEVMAN) != EOK) {
    742                 log_msg(LVL_ERROR, "Failed registering as a service.");
     579        ipcarg_t phonead;
     580        if (ipc_connect_to_me(PHONE_NS, SERVICE_DEVMAN, 0, 0, &phonead) != 0)
    743581                return -1;
    744         }
    745 
    746         printf(NAME ": Accepting connections.\n");
     582
     583        printf(NAME ": Accepting connections\n");
    747584        async_manager();
    748585
Note: See TracChangeset for help on using the changeset viewer.