Changes in uspace/srv/devman/main.c [de2c901:b927375] in mainline

File:

• uspace/srv/devman/main.c (modified) (22 diffs)

uspace/srv/devman/main.c

@@ -75 +75 @@
         iid = async_get_call(&icall);
         if (IPC_GET_IMETHOD(icall) != DEVMAN_DRIVER_REGISTER) {
-                ipc_answer_0(iid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
                 return NULL;
         }
@@ -84 +84 @@
         int rc = async_data_write_accept((void **) &drv_name, true, 0, 0, 0, 0);
         if (rc != EOK) {
-                ipc_answer_0(iid, rc);
+                async_answer_0(iid, rc);
                 return NULL;
         }
@@ -98 +98 @@
                 free(drv_name);
                 drv_name = NULL;
-                ipc_answer_0(iid, ENOENT);
+                async_answer_0(iid, ENOENT);
                 return NULL;
         }
@@ -110 +110 @@
         ipc_callid_t callid = async_get_call(&call);
         if (IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) {
-                ipc_answer_0(callid, ENOTSUP);
-                ipc_answer_0(iid, ENOTSUP);
+                async_answer_0(callid, ENOTSUP);
+                async_answer_0(iid, ENOTSUP);
                 return NULL;
         }
@@ -121 +121 @@
             driver->name);
         
-        ipc_answer_0(callid, EOK);
-        ipc_answer_0(iid, EOK);
+        async_answer_0(callid, EOK);
+        async_answer_0(iid, EOK);
         
         return driver;
@@ -144 +144 @@
                 printf(NAME ": ERROR: devman_receive_match_id - invalid "
                     "protocol.\n");
-                ipc_answer_0(callid, EINVAL); 
+                async_answer_0(callid, EINVAL); 
                 delete_match_id(match_id);
                 return EINVAL;
@@ -152 +152 @@
                 printf(NAME ": ERROR: devman_receive_match_id - failed to "
                     "allocate match id.\n");
-                ipc_answer_0(callid, ENOMEM);
+                async_answer_0(callid, ENOMEM);
                 return ENOMEM;
         }
         
-        ipc_answer_0(callid, EOK);
+        async_answer_0(callid, EOK);
         
         match_id->score = IPC_GET_ARG1(call);
@@ -199 +199 @@
 static int assign_driver_fibril(void *arg)
 {
-        node_t *node = (node_t *) arg;
-        assign_driver(node, &drivers_list, &device_tree);
+        dev_node_t *dev_node = (dev_node_t *) arg;
+        assign_driver(dev_node, &drivers_list, &device_tree);
         return EOK;
 }
 
-/** Handle child device registration.
+/** Handle function registration.
  *
  * Child devices are registered by their parent's device driver.
  */
-static void devman_add_child(ipc_callid_t callid, ipc_call_t *call)
-{
-        devman_handle_t parent_handle = IPC_GET_ARG1(*call);
-        sysarg_t match_count = IPC_GET_ARG2(*call);
+static void devman_add_function(ipc_callid_t callid, ipc_call_t *call)
+{
+        fun_type_t ftype = (fun_type_t) IPC_GET_ARG1(*call);
+        devman_handle_t dev_handle = IPC_GET_ARG2(*call);
+        sysarg_t match_count = IPC_GET_ARG3(*call);
         dev_tree_t *tree = &device_tree;
         
         fibril_rwlock_write_lock(&tree->rwlock);
-        node_t *parent = find_dev_node_no_lock(&device_tree, parent_handle);
-        
-        if (parent == NULL) {
+
+        dev_node_t *dev = NULL;
+        dev_node_t *pdev = find_dev_node_no_lock(&device_tree, dev_handle);
+        
+        if (pdev == NULL) {
                 fibril_rwlock_write_unlock(&tree->rwlock);
-                ipc_answer_0(callid, ENOENT);
-                return;
-        }
-        
-        char *dev_name = NULL;
-        int rc = async_data_write_accept((void **)&dev_name, true, 0, 0, 0, 0);
+                async_answer_0(callid, ENOENT);
+                return;
+        }
+        
+        if (ftype != fun_inner && ftype != fun_exposed) {
+                /* Unknown function type */
+                printf(NAME ": Error, unknown function type provided by driver!\n");
+
+                fibril_rwlock_write_unlock(&tree->rwlock);
+                async_answer_0(callid, EINVAL);
+                return;
+        }
+        
+        char *fun_name = NULL;
+        int rc = async_data_write_accept((void **)&fun_name, true, 0, 0, 0, 0);
         if (rc != EOK) {
                 fibril_rwlock_write_unlock(&tree->rwlock);
-                ipc_answer_0(callid, rc);
-                return;
-        }
-        
-        node_t *node = create_dev_node();
-        if (!insert_dev_node(&device_tree, node, dev_name, parent)) {
+                async_answer_0(callid, rc);
+                return;
+        }
+        
+        fun_node_t *fun = create_fun_node();
+        if (!insert_fun_node(&device_tree, fun, fun_name, pdev)) {
                 fibril_rwlock_write_unlock(&tree->rwlock);
-                delete_dev_node(node);
-                ipc_answer_0(callid, ENOMEM);
-                return;
+                delete_fun_node(fun);
+                async_answer_0(callid, ENOMEM);
+                return;
+        }
+
+        if (ftype == fun_inner) {
+                dev = create_dev_node();
+                if (dev == NULL) {
+                        fibril_rwlock_write_unlock(&tree->rwlock);
+                        delete_fun_node(fun);
+                        async_answer_0(callid, ENOMEM);
+                        return;
+                }
+
+                insert_dev_node(tree, dev, fun);
         }
 
         fibril_rwlock_write_unlock(&tree->rwlock);
         
-        printf(NAME ": devman_add_child %s\n", node->pathname);
-        
-        devman_receive_match_ids(match_count, &node->match_ids);
-
-        /*
-         * Try to find a suitable driver and assign it to the device.  We do
-         * not want to block the current fibril that is used for processing
-         * incoming calls: we will launch a separate fibril to handle the
-         * driver assigning. That is because assign_driver can actually include
-         * task spawning which could take some time.
-         */
-        fid_t assign_fibril = fibril_create(assign_driver_fibril, node);
-        if (assign_fibril == 0) {
+        printf(NAME ": devman_add_function %s\n", fun->pathname);
+        
+        devman_receive_match_ids(match_count, &fun->match_ids);
+
+        if (ftype == fun_inner) {
+                assert(dev != NULL);
                 /*
-                 * Fallback in case we are out of memory.
-                 * Probably not needed as we will die soon anyway ;-).
+                 * Try to find a suitable driver and assign it to the device.  We do
+                 * not want to block the current fibril that is used for processing
+                 * incoming calls: we will launch a separate fibril to handle the
+                 * driver assigning. That is because assign_driver can actually include
+                 * task spawning which could take some time.
                  */
-                (void) assign_driver_fibril(node);
+                fid_t assign_fibril = fibril_create(assign_driver_fibril, dev);
+                if (assign_fibril == 0) {
+                        /*
+                         * Fallback in case we are out of memory.
+                         * Probably not needed as we will die soon anyway ;-).
+                         */
+                        (void) assign_driver_fibril(fun);
+                } else {
+                        fibril_add_ready(assign_fibril);
+                }
         } else {
-                fibril_add_ready(assign_fibril);
-        }
-
+                devmap_register_tree_function(fun, tree);
+        }
+        
         /* Return device handle to parent's driver. */
-        ipc_answer_1(callid, EOK, node->handle);
+        async_answer_1(callid, EOK, fun->handle);
 }
 
@@ -288 +317 @@
          * mapper.
          */
-        class_add_devmap_device(&class_list, cli);
+        class_add_devmap_function(&class_list, cli);
         
         free(devmap_pathname);
 }
 
-static void devman_add_device_to_class(ipc_callid_t callid, ipc_call_t *call)
+static void devman_add_function_to_class(ipc_callid_t callid, ipc_call_t *call)
 {
         devman_handle_t handle = IPC_GET_ARG1(*call);
@@ -302 +331 @@
             0, 0, 0, 0);
         if (rc != EOK) {
-                ipc_answer_0(callid, rc);
+                async_answer_0(callid, rc);
                 return;
         }       
         
-        node_t *dev = find_dev_node(&device_tree, handle);
-        if (dev == NULL) {
-                ipc_answer_0(callid, ENOENT);
+        fun_node_t *fun = find_fun_node(&device_tree, handle);
+        if (fun == NULL) {
+                async_answer_0(callid, ENOENT);
                 return;
         }
         
         dev_class_t *cl = get_dev_class(&class_list, class_name);
-        dev_class_info_t *class_info = add_device_to_class(dev, cl, NULL);
+        dev_class_info_t *class_info = add_function_to_class(fun, cl, NULL);
         
         /* Register the device's class alias by devmapper. */
         devmap_register_class_dev(class_info);
         
-        printf(NAME ": device '%s' added to class '%s', class name '%s' was "
-            "asigned to it\n", dev->pathname, class_name, class_info->dev_name);
-
-        ipc_answer_0(callid, EOK);
+        printf(NAME ": function'%s' added to class '%s', class name '%s' was "
+            "asigned to it\n", fun->pathname, class_name, class_info->dev_name);
+
+        async_answer_0(callid, EOK);
 }
 
@@ -343 +372 @@
 {
         /* Accept the connection. */
-        ipc_answer_0(iid, EOK);
+        async_answer_0(iid, EOK);
         
         driver_t *driver = devman_driver_register();
@@ -372 +401 @@
                         cont = false;
                         continue;
-                case DEVMAN_ADD_CHILD_DEVICE:
-                        devman_add_child(callid, &call);
+                case DEVMAN_ADD_FUNCTION:
+                        devman_add_function(callid, &call);
                         break;
                 case DEVMAN_ADD_DEVICE_TO_CLASS:
-                        devman_add_device_to_class(callid, &call);
+                        devman_add_function_to_class(callid, &call);
                         break;
                 default:
-                        ipc_answer_0(callid, EINVAL); 
+                        async_answer_0(callid, EINVAL); 
                         break;
                 }
@@ -387 +416 @@
 /** Find handle for the device instance identified by the device's path in the
  * device tree. */
-static void devman_device_get_handle(ipc_callid_t iid, ipc_call_t *icall)
+static void devman_function_get_handle(ipc_callid_t iid, ipc_call_t *icall)
 {
         char *pathname;
@@ -393 +422 @@
         int rc = async_data_write_accept((void **) &pathname, true, 0, 0, 0, 0);
         if (rc != EOK) {
-                ipc_answer_0(iid, rc);
-                return;
-        }
-        
-        node_t * dev = find_dev_node_by_path(&device_tree, pathname);
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        fun_node_t *fun = find_fun_node_by_path(&device_tree, pathname);
         
         free(pathname);
 
-        if (dev == NULL) {
-                ipc_answer_0(iid, ENOENT);
-                return;
-        }
-        
-        ipc_answer_1(iid, EOK, dev->handle);
+        if (fun == NULL) {
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+
+        async_answer_1(iid, EOK, fun->handle);
 }
 
@@ -414 +443 @@
 {
         /* Accept connection. */
-        ipc_answer_0(iid, EOK);
+        async_answer_0(iid, EOK);
         
         bool cont = true;
@@ -426 +455 @@
                         continue;
                 case DEVMAN_DEVICE_GET_HANDLE:
-                        devman_device_get_handle(callid, &call);
+                        devman_function_get_handle(callid, &call);
                         break;
                 default:
-                        ipc_answer_0(callid, ENOENT);
+                        async_answer_0(callid, ENOENT);
                 }
         }
@@ -438 +467 @@
 {
         devman_handle_t handle = IPC_GET_ARG2(*icall);
-        
-        node_t *dev = find_dev_node(&device_tree, handle);
-        if (dev == NULL) {
-                printf(NAME ": devman_forward error - no device with handle %" PRIun
-                    " was found.\n", handle);
-                ipc_answer_0(iid, ENOENT);
+        devman_handle_t fwd_h;
+        fun_node_t *fun = NULL;
+        dev_node_t *dev = NULL;
+        
+        fun = find_fun_node(&device_tree, handle);
+        if (fun == NULL)
+                dev = find_dev_node(&device_tree, handle);
+        else
+                dev = fun->dev;
+
+        if (fun == NULL && dev == NULL) {
+                printf(NAME ": devman_forward error - no device or function with "
+                    "handle %" PRIun " was found.\n", handle);
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+
+        if (fun == NULL && !drv_to_parent) {
+                printf(NAME ": devman_forward error - cannot connect to "
+                    "handle %" PRIun ", refers to a device.\n", handle);
+                async_answer_0(iid, ENOENT);
                 return;
         }
@@ -450 +494 @@
         
         if (drv_to_parent) {
-                if (dev->parent != NULL)
-                        driver = dev->parent->drv;
+                /* Connect to parent function of a device (or device function). */
+                if (dev->pfun->dev != NULL)
+                        driver = dev->pfun->dev->drv;
+                fwd_h = dev->pfun->handle;
         } else if (dev->state == DEVICE_USABLE) {
+                /* Connect to the specified function */
                 driver = dev->drv;
                 assert(driver != NULL);
+
+                fwd_h = handle;
         }
         
         if (driver == NULL) {
-                printf(NAME ": devman_forward error - the device %" PRIun \
-                    " (%s) is not in usable state.\n",
-                    handle, dev->pathname);
-                ipc_answer_0(iid, ENOENT);
+                printf(NAME ": devman_forward error - the device is not in %" PRIun
+                    " usable state.\n", handle);
+                async_answer_0(iid, ENOENT);
                 return;
         }
@@ -475 +523 @@
                     driver->name);
                 printf("the driver's phone is %" PRIun ").\n", driver->phone);
-                ipc_answer_0(iid, EINVAL);
-                return;
-        }
-
-        printf(NAME ": devman_forward: forward connection to device %s to "
-            "driver %s.\n", dev->pathname, driver->name);
-        ipc_forward_fast(iid, driver->phone, method, dev->handle, 0, IPC_FF_NONE);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+
+        if (fun != NULL) {
+                printf(NAME ": devman_forward: forward connection to function %s to "
+                    "driver %s.\n", fun->pathname, driver->name);
+        } else {
+                printf(NAME ": devman_forward: forward connection to device %s to "
+                    "driver %s.\n", dev->pfun->pathname, driver->name);
+        }
+
+        async_forward_fast(iid, driver->phone, method, fwd_h, 0, IPC_FF_NONE);
 }
 
@@ -489 +543 @@
 {
         devmap_handle_t devmap_handle = IPC_GET_ARG2(*icall);
-        node_t *dev;
-
-        dev = find_devmap_tree_device(&device_tree, devmap_handle);
-        if (dev == NULL)
-                dev = find_devmap_class_device(&class_list, devmap_handle);
-        
-        if (dev == NULL || dev->drv == NULL) {
-                ipc_answer_0(iid, ENOENT);
-                return;
-        }
+        fun_node_t *fun;
+        dev_node_t *dev;
+
+        fun = find_devmap_tree_function(&device_tree, devmap_handle);
+        if (fun == NULL)
+                fun = find_devmap_class_function(&class_list, devmap_handle);
+        
+        if (fun == NULL || fun->dev->drv == NULL) {
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        dev = fun->dev;
         
         if (dev->state != DEVICE_USABLE || dev->drv->phone <= 0) {
-                ipc_answer_0(iid, EINVAL);
-                return;
-        }
-        
-        ipc_forward_fast(iid, dev->drv->phone, DRIVER_CLIENT, dev->handle, 0,
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        async_forward_fast(iid, dev->drv->phone, DRIVER_CLIENT, fun->handle, 0,
             IPC_FF_NONE);
         printf(NAME ": devman_connection_devmapper: forwarded connection to "
-            "device %s to driver %s.\n", dev->pathname, dev->drv->name);
+            "device %s to driver %s.\n", fun->pathname, dev->drv->name);
 }
 
@@ -536 +593 @@
         default:
                 /* No such interface */
-                ipc_answer_0(iid, ENOENT);
+                async_answer_0(iid, ENOENT);
         }
 }
@@ -587 +644 @@
 
         /* Register device manager at naming service. */
-        sysarg_t phonead;
-        if (ipc_connect_to_me(PHONE_NS, SERVICE_DEVMAN, 0, 0, &phonead) != 0)
+        if (service_register(SERVICE_DEVMAN) != EOK)
                 return -1;