Changeset a1b7e80 in mainline for uspace/lib/drv/generic/driver.c

Timestamp:

2011-09-02T16:54:18Z (13 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

f480d7e

Parents:

7a72ce1a (diff), 224c0e7 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge basic infrastructure for anticipated device removal from
lp:~jsvoboda/helenos/devrem

File:

• uspace/lib/drv/generic/driver.c (modified) (17 diffs)

uspace/lib/drv/generic/driver.c

@@ -63 +63 @@
 
 /** Devices */
+LIST_INITIALIZE(devices);
+FIBRIL_MUTEX_INITIALIZE(devices_mutex);
+
+/** Functions */
 LIST_INITIALIZE(functions);
 FIBRIL_MUTEX_INITIALIZE(functions_mutex);
@@ -82 +86 @@
 static ddf_dev_t *create_device(void);
 static void delete_device(ddf_dev_t *);
+static void dev_add_ref(ddf_dev_t *);
+static void dev_del_ref(ddf_dev_t *);
+static void fun_add_ref(ddf_fun_t *);
+static void fun_del_ref(ddf_fun_t *);
 static remote_handler_t *function_get_default_handler(ddf_fun_t *);
 static void *function_get_ops(ddf_fun_t *, dev_inferface_idx_t);
@@ -227 +235 @@
 }
 
-static ddf_fun_t *driver_get_function(list_t *functions, devman_handle_t handle)
+static ddf_dev_t *driver_get_device(devman_handle_t handle)
+{
+        ddf_dev_t *dev = NULL;
+        
+        assert(fibril_mutex_is_locked(&devices_mutex));
+        
+        list_foreach(devices, link) {
+                dev = list_get_instance(link, ddf_dev_t, link);
+                if (dev->handle == handle)
+                        return dev;
+        }
+        
+        return NULL;
+}
+
+static ddf_fun_t *driver_get_function(devman_handle_t handle)
 {
         ddf_fun_t *fun = NULL;
         
-        fibril_mutex_lock(&functions_mutex);
-        
-        list_foreach(*functions, link) {
+        assert(fibril_mutex_is_locked(&functions_mutex));
+        
+        list_foreach(functions, link) {
                 fun = list_get_instance(link, ddf_fun_t, link);
-                if (fun->handle == handle) {
-                        fibril_mutex_unlock(&functions_mutex);
+                if (fun->handle == handle)
                         return fun;
-                }
-        }
-        
-        fibril_mutex_unlock(&functions_mutex);
+        }
         
         return NULL;
 }
 
-static void driver_add_device(ipc_callid_t iid, ipc_call_t *icall)
+static void driver_dev_add(ipc_callid_t iid, ipc_call_t *icall)
 {
         char *dev_name = NULL;
@@ -255 +274 @@
         
         ddf_dev_t *dev = create_device();
+
+        /* Add one reference that will be dropped by driver_dev_remove() */
+        dev_add_ref(dev);
         dev->handle = dev_handle;
 
@@ -267 +289 @@
         
         res = driver->driver_ops->add_device(dev);
-        if (res != EOK)
-                delete_device(dev);
+        
+        if (res != EOK) {
+                dev_del_ref(dev);
+                async_answer_0(iid, res);
+                return;
+        }
+        
+        fibril_mutex_lock(&devices_mutex);
+        list_append(&dev->link, &devices);
+        fibril_mutex_unlock(&devices_mutex);
         
         async_answer_0(iid, res);
+}
+
+static void driver_dev_remove(ipc_callid_t iid, ipc_call_t *icall)
+{
+        devman_handle_t devh;
+        ddf_dev_t *dev;
+        int rc;
+        
+        devh = IPC_GET_ARG1(*icall);
+        
+        fibril_mutex_lock(&devices_mutex);
+        dev = driver_get_device(devh);
+        dev_add_ref(dev);
+        fibril_mutex_unlock(&devices_mutex);
+        
+        if (dev == NULL) {
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        if (driver->driver_ops->dev_remove != NULL)
+                rc = driver->driver_ops->dev_remove(dev);
+        else
+                rc = ENOTSUP;
+        
+        if (rc == EOK)
+                dev_del_ref(dev);
+        
+        async_answer_0(iid, (sysarg_t) rc);
+}
+
+static void driver_fun_online(ipc_callid_t iid, ipc_call_t *icall)
+{
+        devman_handle_t funh;
+        ddf_fun_t *fun;
+        int rc;
+        
+        funh = IPC_GET_ARG1(*icall);
+        
+        /*
+         * Look the function up. Bump reference count so that
+         * the function continues to exist until we return
+         * from the driver.
+         */
+        fibril_mutex_lock(&functions_mutex);
+        
+        fun = driver_get_function(funh);
+        if (fun != NULL)
+                fun_add_ref(fun);
+        
+        fibril_mutex_unlock(&functions_mutex);
+        
+        if (fun == NULL) {
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        /* Call driver entry point */
+        if (driver->driver_ops->fun_online != NULL)
+                rc = driver->driver_ops->fun_online(fun);
+        else
+                rc = ENOTSUP;
+        
+        fun_del_ref(fun);
+        
+        async_answer_0(iid, (sysarg_t) rc);
+}
+
+static void driver_fun_offline(ipc_callid_t iid, ipc_call_t *icall)
+{
+        devman_handle_t funh;
+        ddf_fun_t *fun;
+        int rc;
+        
+        funh = IPC_GET_ARG1(*icall);
+        
+        /*
+         * Look the function up. Bump reference count so that
+         * the function continues to exist until we return
+         * from the driver.
+         */
+        fibril_mutex_lock(&functions_mutex);
+        
+        fun = driver_get_function(funh);
+        if (fun != NULL)
+                fun_add_ref(fun);
+        
+        fibril_mutex_unlock(&functions_mutex);
+        
+        if (fun == NULL) {
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        /* Call driver entry point */
+        if (driver->driver_ops->fun_offline != NULL)
+                rc = driver->driver_ops->fun_offline(fun);
+        else
+                rc = ENOTSUP;
+        
+        async_answer_0(iid, (sysarg_t) rc);
 }
 
@@ -286 +417 @@
                 
                 switch (IPC_GET_IMETHOD(call)) {
-                case DRIVER_ADD_DEVICE:
-                        driver_add_device(callid, &call);
+                case DRIVER_DEV_ADD:
+                        driver_dev_add(callid, &call);
+                        break;
+                case DRIVER_DEV_REMOVE:
+                        driver_dev_remove(callid, &call);
+                        break;
+                case DRIVER_FUN_ONLINE:
+                        driver_fun_online(callid, &call);
+                        break;
+                case DRIVER_FUN_OFFLINE:
+                        driver_fun_offline(callid, &call);
                         break;
                 default:
-                        async_answer_0(callid, ENOENT);
+                        async_answer_0(callid, ENOTSUP);
                 }
         }
@@ -308 +448 @@
          */
         devman_handle_t handle = IPC_GET_ARG2(*icall);
-        ddf_fun_t *fun = driver_get_function(&functions, handle);
+
+        fibril_mutex_lock(&functions_mutex);
+        ddf_fun_t *fun = driver_get_function(handle);
+        fibril_mutex_unlock(&functions_mutex);
+        /* XXX Need a lock on fun */
         
         if (fun == NULL) {
@@ -466 +610 @@
         ddf_dev_t *dev;
 
-        dev = malloc(sizeof(ddf_dev_t));
+        dev = calloc(1, sizeof(ddf_dev_t));
         if (dev == NULL)
                 return NULL;
 
-        memset(dev, 0, sizeof(ddf_dev_t));
         return dev;
 }
@@ -498 +641 @@
 static void delete_device(ddf_dev_t *dev)
 {
+        if (dev->driver_data != NULL)
+                free(dev->driver_data);
         free(dev);
 }
 
-/** Delete device structure.
+/** Delete function structure.
  *
  * @param dev           The device structure.
@@ -508 +653 @@
 {
         clean_match_ids(&fun->match_ids);
+        if (fun->driver_data != NULL)
+                free(fun->driver_data);
         if (fun->name != NULL)
                 free(fun->name);
@@ -513 +660 @@
 }
 
+/** Increase device reference count. */
+static void dev_add_ref(ddf_dev_t *dev)
+{
+        atomic_inc(&dev->refcnt);
+}
+
+/** Decrease device reference count.
+ *
+ * Free the device structure if the reference count drops to zero.
+ */
+static void dev_del_ref(ddf_dev_t *dev)
+{
+        if (atomic_predec(&dev->refcnt) == 0)
+                delete_device(dev);
+}
+
+/** Increase function reference count.
+ *
+ * This also increases reference count on the device. The device structure
+ * will thus not be deallocated while there are some associated function
+ * structures.
+ */
+static void fun_add_ref(ddf_fun_t *fun)
+{
+        dev_add_ref(fun->dev);
+        atomic_inc(&fun->refcnt);
+}
+
+/** Decrease function reference count.
+ *
+ * Free the function structure if the reference count drops to zero.
+ */
+static void fun_del_ref(ddf_fun_t *fun)
+{
+        ddf_dev_t *dev = fun->dev;
+
+        if (atomic_predec(&fun->refcnt) == 0)
+                delete_function(fun);
+
+        dev_del_ref(dev);
+}
+
+/** Allocate driver-specific device data. */
+extern void *ddf_dev_data_alloc(ddf_dev_t *dev, size_t size)
+{
+        void *data;
+
+        assert(dev->driver_data == NULL);
+
+        data = calloc(1, size);
+        if (data == NULL)
+                return NULL;
+
+        dev->driver_data = data;
+        return data;
+}
+
 /** Create a DDF function node.
  *
@@ -544 +748 @@
                 return NULL;
 
+        /* Add one reference that will be dropped by ddf_fun_destroy() */
+        fun->dev = dev;
+        fun_add_ref(fun);
+
         fun->bound = false;
-        fun->dev = dev;
         fun->ftype = ftype;
 
@@ -557 +764 @@
 }
 
+/** Allocate driver-specific function data. */
+extern void *ddf_fun_data_alloc(ddf_fun_t *fun, size_t size)
+{
+        void *data;
+
+        assert(fun->bound == false);
+        assert(fun->driver_data == NULL);
+
+        data = calloc(1, size);
+        if (data == NULL)
+                return NULL;
+
+        fun->driver_data = data;
+        return data;
+}
+
 /** Destroy DDF function node.
  *
@@ -567 +790 @@
 {
         assert(fun->bound == false);
-        delete_function(fun);
+
+        /*
+         * Drop the reference added by ddf_fun_create(). This will deallocate
+         * the function as soon as all other references are dropped (i.e.
+         * as soon control leaves all driver entry points called in context
+         * of this function.
+         */
+        fun_del_ref(fun);
 }
 
@@ -614 +844 @@
  * the function invisible to the system.
  *
- * @param fun           Function to bind
+ * @param fun           Function to unbind
  * @return              EOK on success or negative error code
  */
@@ -623 +853 @@
         assert(fun->bound == true);
         
-        add_to_functions_list(fun);
         res = devman_remove_function(fun->handle);
         if (res != EOK)
@@ -631 +860 @@
         
         fun->bound = false;
+        return EOK;
+}
+
+/** Online function.
+ *
+ * @param fun           Function to online
+ * @return              EOK on success or negative error code
+ */
+int ddf_fun_online(ddf_fun_t *fun)
+{
+        int res;
+        
+        assert(fun->bound == true);
+        
+        res = devman_drv_fun_online(fun->handle);
+        if (res != EOK)
+                return res;
+        
+        return EOK;
+}
+
+/** Offline function.
+ *
+ * @param fun           Function to offline
+ * @return              EOK on success or negative error code
+ */
+int ddf_fun_offline(ddf_fun_t *fun)
+{
+        int res;
+        
+        assert(fun->bound == true);
+        
+        res = devman_drv_fun_offline(fun->handle);
+        if (res != EOK)
+                return res;
+        
         return EOK;
 }