WebSVN – HelenOS – Diff – /trunk/uspace/srv/devmap/devmap.c/

 #include <ipc/ns.h>
 #include <async.h>
 #include <stdio.h>
 #include <errno.h>
 #include <bool.h>
-#include <futex.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ipc/devmap.h>
 #define NAME  "devmap"
     link_t devices;
     /** Phone asociated with this driver */
     ipcarg_t phone;
     /** Device driver name */
     char *name;
-    /** Futex for list of devices owned by this driver */
-    atomic_t devices_futex;
 } devmap_driver_t;
 /** Info about registered device
+ *
  */
 LIST_INITIALIZE(devices_list);
 LIST_INITIALIZE(drivers_list);
 LIST_INITIALIZE(pending_req);
-/* Locking order:
- *  drivers_list_futex
- *  devices_list_futex
- *  (devmap_driver_t *)->devices_futex
- *  create_handle_futex
- **/
-static atomic_t devices_list_futex = FUTEX_INITIALIZER;
-static atomic_t drivers_list_futex = FUTEX_INITIALIZER;
-static atomic_t create_handle_futex = FUTEX_INITIALIZER;
 static dev_handle_t last_handle = 0;
 static dev_handle_t devmap_create_handle(void)
+{
     /* TODO: allow reusing old handles after their unregistration
-     * and implement some version of LRU algorithm
+     * and implement some version of LRU algorithm, avoid overflow
      */
-    /* FIXME: overflow */
-    futex_down(&create_handle_futex);
     last_handle++;
-    futex_up(&create_handle_futex);
     return last_handle;
+}
 /** Find device with given name.
     link_t *item = devices_list.next;
     devmap_device_t *device = NULL;
     while (item != &devices_list) {
         device = list_get_instance(item, devmap_device_t, devices);
-        if (0 == str_cmp(device->name, name))
+        if (str_cmp(device->name, name) == 0)
             break;
         item = item->next;
+    }
     if (item == &devices_list)
  * @todo: use hash table
+ *
  */
 static devmap_device_t *devmap_device_find_handle(dev_handle_t handle)
+{
-    futex_down(&devices_list_futex);
     link_t *item = (&devices_list)->next;
     devmap_device_t *device = NULL;
     while (item != &devices_list) {
         device = list_get_instance(item, devmap_device_t, devices);
         if (device->handle == handle)
             break;
         item = item->next;
+    }
-    if (item == &devices_list) {
+    if (item == &devices_list)
-        futex_up(&devices_list_futex);
         return NULL;
-    }
     device = list_get_instance(item, devmap_device_t, devices);
-    futex_up(&devices_list_futex);
     return device;
+}
 /**
+ *
+    }
     /*
      * Send confirmation to sender and get data into buffer.
      */
-    if (EOK != ipc_data_write_finalize(callid, driver->name, name_size)) {
+    if (ipc_data_write_finalize(callid, driver->name, name_size) != EOK) {
         free(driver->name);
         free(driver);
         ipc_answer_0(iid, EREFUSED);
         return;
+    }
     driver->name[name_size] = 0;
-    /* Initialize futex for list of devices owned by this driver */
-    futex_initialize(&(driver->devices_futex), 1);
     /*
      * Initialize list of asociated devices
      */
     list_initialize(&(driver->devices));
     /*
      * Create connection to the driver
      */
     ipc_call_t call;
     callid = async_get_call(&call);
-    if (IPC_M_CONNECT_TO_ME != IPC_GET_METHOD(call)) {
+    if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
         ipc_answer_0(callid, ENOTSUP);
         free(driver->name);
         free(driver);
         ipc_answer_0(iid, ENOTSUP);
     ipc_answer_0(callid, EOK);
     list_initialize(&(driver->drivers));
-    futex_down(&drivers_list_futex);
     /* TODO:
      * check that no driver with name equal to driver->name is registered
      */
     /*
      * Insert new driver into list of registered drivers
      */
     list_append(&(driver->drivers), &drivers_list);
-    futex_up(&drivers_list_futex);
     ipc_answer_0(iid, EOK);
     *odriver = driver;
+}
 static int devmap_driver_unregister(devmap_driver_t *driver)
+{
     if (driver == NULL)
         return EEXISTS;
-    futex_down(&drivers_list_futex);
     if (driver->phone != 0)
         ipc_hangup(driver->phone);
     /* Remove it from list of drivers */
     list_remove(&(driver->drivers));
-    /* Unregister all its devices */
-    futex_down(&devices_list_futex);
-    futex_down(&(driver->devices_futex));
     while (!list_empty(&(driver->devices))) {
         devmap_device_t *device = list_get_instance(driver->devices.next,
             devmap_device_t, driver_devices);
         devmap_device_unregister_core(device);
+    }
-    futex_up(&(driver->devices_futex));
-    futex_up(&devices_list_futex);
-    futex_up(&drivers_list_futex);
     /* free name and driver */
     if (driver->name != NULL)
         free(driver->name);
     free(driver);
     return EOK;
+}
 /** Process pending lookup requests */
-static void process_pending_lookup()
+static void process_pending_lookup(void)
+{
+    async_serialize_start();
     link_t *cur;
 loop:
     for (cur = pending_req.next; cur != &pending_req; cur = cur->next) {
         pending_req_t *pr = list_get_instance(cur, pending_req_t, link);
         ipc_answer_1(pr->callid, EOK, dev->handle);
         free(pr->name);
         list_remove(cur);
         free(pr);
         goto loop;
+    }
+    async_serialize_end();
+}
 /** Register instance of device
+ *
     device->name[size] = 0;
     list_initialize(&(device->devices));
     list_initialize(&(device->driver_devices));
-    futex_down(&devices_list_futex);
     /* Check that device with such name is not already registered */
     if (NULL != devmap_device_find_name(device->name)) {
         printf(NAME ": Device '%s' already registered\n", device->name);
-        futex_up(&devices_list_futex);
         free(device->name);
         free(device);
         ipc_answer_0(iid, EEXISTS);
         return;
+    }
     device->driver = driver;
     /* Insert device into list of all devices  */
     list_append(&device->devices, &devices_list);
-    /* Insert device into list of devices that belog to one driver */
-    futex_down(&device->driver->devices_futex);
     list_append(&device->driver_devices, &device->driver->devices);
-    futex_up(&device->driver->devices_futex);
-    futex_up(&devices_list_futex);
     ipc_answer_1(iid, EOK, device->handle);
-    process_pending_lookup();
+}
 /**
+ *
  */
     /* TODO: send name in response */
+}
 static void devmap_get_count(ipc_callid_t iid, ipc_call_t *icall)
+{
-    futex_down(&devices_list_futex);
     ipc_answer_1(iid, EOK, list_count(&devices_list));
-    futex_up(&devices_list_futex);
+}
 static void devmap_get_devices(ipc_callid_t iid, ipc_call_t *icall)
+{
-    futex_down(&devices_list_futex);
     ipc_callid_t callid;
     size_t size;
     if (!ipc_data_read_receive(&callid, &size)) {
         ipc_answer_0(callid, EREFUSED);
         ipc_answer_0(iid, EREFUSED);
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(iid, EREFUSED);
         return;
+    }
-    count_t count = size / sizeof(dev_desc_t);
+    size_t count = size / sizeof(dev_desc_t);
     dev_desc_t *desc = (dev_desc_t *) malloc(size);
     if (desc == NULL) {
         ipc_answer_0(callid, ENOMEM);
         ipc_answer_0(iid, EREFUSED);
         return;
+    }
-    count_t pos = 0;
+    size_t pos = 0;
     link_t *item = devices_list.next;
     while ((item != &devices_list) && (pos < count)) {
         devmap_device_t *device = list_get_instance(item, devmap_device_t, devices);
         return;
+    }
     free(desc);
-    futex_up(&devices_list_futex);
     ipc_answer_1(iid, EOK, pos);
+}
 /** Initialize device mapper.
+ *
+    }
     list_initialize(&(device->devices));
     list_initialize(&(device->driver_devices));
-    futex_down(&devices_list_futex);
     /* Get unique device handle */
     device->handle = devmap_create_handle();
     device->driver = NULL;
     /* Insert device into list of all devices  */
     list_append(&device->devices, &devices_list);
-    futex_up(&devices_list_futex);
     return true;
+}
 /** Handle connection with device driver.
+ *
 static void devmap_connection_driver(ipc_callid_t iid, ipc_call_t *icall)
+{
     /* Accept connection */
     ipc_answer_0(iid, EOK);
     devmap_driver_t *driver = NULL;
     devmap_driver_register(&driver);
     if (NULL == driver)
         return;
     bool cont = true;
     while (cont) {
         ipc_call_t call;
         ipc_callid_t callid = async_get_call(&call);
+        async_serialize_start();
         switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
             cont = false;
-            /* Exit thread */
+            async_serialize_end();
             continue;
         case DEVMAP_DRIVER_UNREGISTER:
             if (NULL == driver)
                 ipc_answer_0(callid, ENOENT);
             else
             break;
         default:
             if (!(callid & IPC_CALLID_NOTIFICATION))
                 ipc_answer_0(callid, ENOENT);
+        }
+        async_serialize_end();
+    }
     if (NULL != driver) {
         /*
          * Unregister the device driver and all its devices.
          */
+        async_serialize_start();
         devmap_driver_unregister(driver);
         driver = NULL;
+        async_serialize_end();
+    }
+}
 /** Handle connection with device client.
+ *
     bool cont = true;
     while (cont) {
         ipc_call_t call;
         ipc_callid_t callid = async_get_call(&call);
+        async_serialize_start();
         switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
             cont = false;
-            /* Exit thread */
+            async_serialize_end();
             continue;
         case DEVMAP_DEVICE_GET_HANDLE:
             devmap_get_handle(callid, &call);
             break;
         case DEVMAP_DEVICE_GET_NAME:
             break;
         default:
             if (!(callid & IPC_CALLID_NOTIFICATION))
                 ipc_answer_0(callid, ENOENT);
+        }
+        async_serialize_end();
+    }
+}
 /** Function for handling connections to devmap
+ *
         /* Connect client to selected device */
         devmap_forward(iid, icall);
         break;
     default:
         /* No such interface */
         ipc_answer_0(iid, ENOENT);
+    }
+}
 /**
+ *
     if (!devmap_init()) {
         printf(NAME ": Error while initializing service\n");
         return -1;
+    }
-    /* Set a handler of incomming connections */
+    /* Set a handler of incomming connections and
+       pending operations */
+    async_set_pending(process_pending_lookup);
     async_set_client_connection(devmap_connection);
     /* Register device mapper at naming service */
     ipcarg_t phonead;
     if (ipc_connect_to_me(PHONE_NS, SERVICE_DEVMAP, 0, 0, &phonead) != 0)

Subversion Repositories HelenOS

(root)/trunk/uspace/srv/devmap/devmap.c/ – Rev 4416 → 4458