WebSVN – HelenOS – Diff – /branches/tracing/uspace/srv/devmap/devmap.c

 /*
  * Copyright (c) 2007 Josef Cejka
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
+ *
  * - Redistributions of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
  * - Redistributions in binary form must reproduce the above copyright
  *   notice, this list of conditions and the following disclaimer in the
  *   documentation and/or other materials provided with the distribution.
  * - The name of the author may not be used to endorse or promote products
  *   derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /**
  * @defgroup devmap Device mapper.
  * @brief HelenOS device mapper.
  * @{
  */
 /** @file
  */
 #include <ipc/services.h>
 #include <ipc/ns.h>
 #include <async.h>
 #include <stdio.h>
 #include <errno.h>
 #include <bool.h>
-#include <futex.h>
+#include <fibril_sync.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ipc/devmap.h>
-#define NAME  "devmap"
+#define NAME          "devmap"
+#define NULL_DEVICES  256
-/** Pending lookup structure. */
+/** Representation of device driver.
+ *
+ * Each driver is responsible for a set of devices.
+ *
+ */
 typedef struct {
+    /** Pointers to previous and next drivers in linked list */
+    link_t drivers;
+    /** Pointer to the linked list of devices controlled by this driver */
-    link_t link;
+    link_t devices;
-    char *name;              /**< Device name */
+    /** Phone asociated with this driver */
+    ipcarg_t phone;
+    /** Device driver name */
+    char *name;
-    ipc_callid_t callid;     /**< Call ID waiting for the lookup */
+    /** Fibril mutex for list of devices owned by this driver */
+    fibril_mutex_t devices_mutex;
-} pending_req_t;
+} devmap_driver_t;
+/** Info about registered device
+ *
+ */
+typedef struct {
+    /** Pointer to the previous and next device in the list of all devices */
+    link_t devices;
+    /** Pointer to the previous and next device in the list of devices
+        owned by one driver */
+    link_t driver_devices;
+    /** Unique device identifier  */
+    dev_handle_t handle;
+    /** Device name */
+    char *name;
+    /** Device driver handling this device */
+    devmap_driver_t *driver;
+} devmap_device_t;
 LIST_INITIALIZE(devices_list);
 LIST_INITIALIZE(drivers_list);
-LIST_INITIALIZE(pending_req);
 /* Locking order:
- *  drivers_list_futex
+ *  drivers_list_mutex
- *  devices_list_futex
+ *  devices_list_mutex
- *  (devmap_driver_t *)->devices_futex
+ *  (devmap_driver_t *)->devices_mutex
- *  create_handle_futex
+ *  create_handle_mutex
  **/
-static atomic_t devices_list_futex = FUTEX_INITIALIZER;
+static FIBRIL_MUTEX_INITIALIZE(devices_list_mutex);
+static FIBRIL_CONDVAR_INITIALIZE(devices_list_cv);
-static atomic_t drivers_list_futex = FUTEX_INITIALIZER;
+static FIBRIL_MUTEX_INITIALIZE(drivers_list_mutex);
-static atomic_t create_handle_futex = FUTEX_INITIALIZER;
+static FIBRIL_MUTEX_INITIALIZE(create_handle_mutex);
+static FIBRIL_MUTEX_INITIALIZE(null_devices_mutex);
+static dev_handle_t last_handle = 0;
+static devmap_device_t *null_devices[NULL_DEVICES];
-static int devmap_create_handle(void)
+static dev_handle_t devmap_create_handle(void)
+{
-    static int last_handle = 0;
-    int handle;
     /* 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);
+    fibril_mutex_lock(&create_handle_mutex);
-    last_handle += 1;
+    last_handle++;
-    handle = last_handle;
-    futex_up(&create_handle_futex);
+    fibril_mutex_unlock(&create_handle_mutex);
-    return handle;
-}
-/** Initialize device mapper.
- *
- *
- */
-static int devmap_init()
-{
-    /* TODO: */
-    return EOK;
+    return last_handle;
+}
 /** Find device with given name.
+ *
  */
 static devmap_device_t *devmap_device_find_name(const char *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)
         return NULL;
     device = list_get_instance(item, devmap_device_t, devices);
     return device;
+}
 /** Find device with given handle.
+ *
  * @todo: use hash table
+ *
  */
-static devmap_device_t *devmap_device_find_handle(int handle)
+static devmap_device_t *devmap_device_find_handle(dev_handle_t handle)
+{
-    futex_down(&devices_list_futex);
+    fibril_mutex_lock(&devices_list_mutex);
     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) {
-        futex_up(&devices_list_futex);
+        fibril_mutex_unlock(&devices_list_mutex);
         return NULL;
+    }
     device = list_get_instance(item, devmap_device_t, devices);
-    futex_up(&devices_list_futex);
+    fibril_mutex_unlock(&devices_list_mutex);
     return device;
+}
 /**
- *
  * Unregister device and free it. It's assumed that driver's device list is
  * already locked.
- *
  */
 static int devmap_device_unregister_core(devmap_device_t *device)
+{
     list_remove(&(device->devices));
     list_remove(&(device->driver_devices));
     free(device->name);
     free(device);
     return EOK;
+}
 /**
- *
  * Read info about new driver and add it into linked list of registered
  * drivers.
- *
  */
 static void devmap_driver_register(devmap_driver_t **odriver)
+{
     *odriver = NULL;
     ipc_call_t icall;
     ipc_callid_t iid = async_get_call(&icall);
     if (IPC_GET_METHOD(icall) != DEVMAP_DRIVER_REGISTER) {
         ipc_answer_0(iid, EREFUSED);
         return;
+    }
     devmap_driver_t *driver = (devmap_driver_t *) malloc(sizeof(devmap_driver_t));
     if (driver == NULL) {
         ipc_answer_0(iid, ENOMEM);
         return;
+    }
     /*
      * Get driver name
      */
     ipc_callid_t callid;
     size_t name_size;
     if (!ipc_data_write_receive(&callid, &name_size)) {
         free(driver);
         ipc_answer_0(callid, EREFUSED);
         ipc_answer_0(iid, EREFUSED);
         return;
+    }
     if (name_size > DEVMAP_NAME_MAXLEN) {
         free(driver);
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(iid, EREFUSED);
         return;
+    }
     /*
      * Allocate buffer for device name.
      */
     driver->name = (char *) malloc(name_size + 1);
     if (driver->name == NULL) {
         free(driver);
         ipc_answer_0(callid, ENOMEM);
         ipc_answer_0(iid, EREFUSED);
         return;
+    }
     /*
      * 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 */
+    /* Initialize mutex for list of devices owned by this driver */
-    futex_initialize(&(driver->devices_futex), 1);
+    fibril_mutex_initialize(&driver->devices_mutex);
     /*
      * Initialize list of asociated devices
      */
-    list_initialize(&(driver->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);
         return;
+    }
     driver->phone = IPC_GET_ARG5(call);
     ipc_answer_0(callid, EOK);
     list_initialize(&(driver->drivers));
-    futex_down(&drivers_list_futex);
+    fibril_mutex_lock(&drivers_list_mutex);
     /* 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);
+    fibril_mutex_unlock(&drivers_list_mutex);
     ipc_answer_0(iid, EOK);
     *odriver = driver;
+}
 /**
  * Unregister device driver, unregister all its devices and free driver
  * structure.
+ *
  */
 static int devmap_driver_unregister(devmap_driver_t *driver)
+{
     if (driver == NULL)
         return EEXISTS;
-    futex_down(&drivers_list_futex);
+    fibril_mutex_lock(&drivers_list_mutex);
+    if (driver->phone != 0)
-    ipc_hangup(driver->phone);
+        ipc_hangup(driver->phone);
-    /* remove it from list of drivers */
+    /* Remove it from list of drivers */
     list_remove(&(driver->drivers));
-    /* unregister all its devices */
+    /* Unregister all its devices */
-    futex_down(&devices_list_futex);
+    fibril_mutex_lock(&devices_list_mutex);
-    futex_down(&(driver->devices_futex));
+    fibril_mutex_lock(&driver->devices_mutex);
     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));
+    fibril_mutex_unlock(&driver->devices_mutex);
-    futex_up(&devices_list_futex);
+    fibril_mutex_unlock(&devices_list_mutex);
-    futex_up(&drivers_list_futex);
+    fibril_mutex_unlock(&drivers_list_mutex);
     /* free name and driver */
-    if (NULL != driver->name)
+    if (driver->name != NULL)
         free(driver->name);
     free(driver);
     return EOK;
+}
-/** Process pending lookup requests */
-static void process_pending_lookup()
-{
-    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);
-        const devmap_device_t *dev = devmap_device_find_name(pr->name);
-        if (!dev)
-            continue;
-        ipc_answer_1(pr->callid, EOK, dev->handle);
-        free(pr->name);
-        list_remove(cur);
-        free(pr);
-        goto loop;
-    }
-}
 /** Register instance of device
+ *
  */
 static void devmap_device_register(ipc_callid_t iid, ipc_call_t *icall,
     devmap_driver_t *driver)
+{
     if (driver == NULL) {
         ipc_answer_0(iid, EREFUSED);
         return;
+    }
     /* Create new device entry */
     devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
     if (device == NULL) {
         ipc_answer_0(iid, ENOMEM);
         return;
+    }
     /* Get device name */
     ipc_callid_t callid;
     size_t size;
     if (!ipc_data_write_receive(&callid, &size)) {
         free(device);
         ipc_answer_0(iid, EREFUSED);
         return;
+    }
     if (size > DEVMAP_NAME_MAXLEN) {
         free(device);
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(iid, EREFUSED);
         return;
+    }
     /* +1 for terminating \0 */
     device->name = (char *) malloc(size + 1);
     if (device->name == NULL) {
         free(device);
         ipc_answer_0(callid, ENOMEM);
         ipc_answer_0(iid, EREFUSED);
         return;
+    }
     ipc_data_write_finalize(callid, device->name, size);
     device->name[size] = 0;
     list_initialize(&(device->devices));
     list_initialize(&(device->driver_devices));
-    futex_down(&devices_list_futex);
+    fibril_mutex_lock(&devices_list_mutex);
     /* 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);
+        fibril_mutex_unlock(&devices_list_mutex);
         free(device->name);
         free(device);
         ipc_answer_0(iid, EEXISTS);
         return;
+    }
     /* Get unique device handle */
     device->handle = devmap_create_handle();
     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);
+    fibril_mutex_lock(&device->driver->devices_mutex);
     list_append(&device->driver_devices, &device->driver->devices);
-    futex_up(&device->driver->devices_futex);
+    fibril_mutex_unlock(&device->driver->devices_mutex);
+    fibril_condvar_broadcast(&devices_list_cv);
-    futex_up(&devices_list_futex);
+    fibril_mutex_unlock(&devices_list_mutex);
     ipc_answer_1(iid, EOK, device->handle);
-    process_pending_lookup();
+}
 /**
+ *
  */
 static int devmap_device_unregister(ipc_callid_t iid, ipc_call_t *icall,
     devmap_driver_t *driver)
+{
     /* TODO */
     return EOK;
+}
 /** Connect client to the device.
+ *
  * Find device driver owning requested device and forward
  * the message to it.
+ *
  */
 static void devmap_forward(ipc_callid_t callid, ipc_call_t *call)
+{
     /*
      * Get handle from request
      */
-    int handle = IPC_GET_ARG2(*call);
+    dev_handle_t handle = IPC_GET_ARG2(*call);
     devmap_device_t *dev = devmap_device_find_handle(handle);
-    if (NULL == dev) {
+    if ((dev == NULL) || (dev->driver == NULL) || (dev->driver->phone == 0)) {
         ipc_answer_0(callid, ENOENT);
         return;
+    }
-    ipc_forward_fast(callid, dev->driver->phone, (ipcarg_t)(dev->handle),
+    ipc_forward_fast(callid, dev->driver->phone, dev->handle,
         IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
+}
 /** Find handle for device instance identified by name.
+ *
  * In answer will be send EOK and device handle in arg1 or a error
  * code from errno.h.
+ *
  */
 static void devmap_get_handle(ipc_callid_t iid, ipc_call_t *icall)
+{
     /*
      * Wait for incoming message with device name (but do not
      * read the name itself until the buffer is allocated).
      */
     ipc_callid_t callid;
     size_t size;
     if (!ipc_data_write_receive(&callid, &size)) {
         ipc_answer_0(callid, EREFUSED);
         ipc_answer_0(iid, EREFUSED);
         return;
+    }
     if ((size < 1) || (size > DEVMAP_NAME_MAXLEN)) {
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(iid, EREFUSED);
         return;
+    }
     /*
      * Allocate buffer for device name.
      */
-    char *name = (char *) malloc(size);
+    char *name = (char *) malloc(size + 1);
     if (name == NULL) {
         ipc_answer_0(callid, ENOMEM);
         ipc_answer_0(iid, EREFUSED);
         return;
+    }
     /*
      * Send confirmation to sender and get data into buffer.
      */
     ipcarg_t retval = ipc_data_write_finalize(callid, name, size);
     if (retval != EOK) {
         ipc_answer_0(iid, EREFUSED);
         free(name);
         return;
+    }
     name[size] = '\0';
+    fibril_mutex_lock(&devices_list_mutex);
+    const devmap_device_t *dev;
+recheck:
     /*
-     * Find device name in linked list of known devices.
+     * Find device name in the list of known devices.
      */
-    const devmap_device_t *dev = devmap_device_find_name(name);
+    dev = devmap_device_find_name(name);
     /*
      * Device was not found.
      */
     if (dev == NULL) {
         if (IPC_GET_ARG1(*icall) & IPC_FLAG_BLOCKING) {
-            /* Blocking lookup, add to pending list */
+            /* Blocking lookup */
-            pending_req_t *pr = (pending_req_t *) malloc(sizeof(pending_req_t));
-            if (!pr) {
-                ipc_answer_0(iid, ENOMEM);
+            fibril_condvar_wait(&devices_list_cv,
-                free(name);
+                &devices_list_mutex);
-                return;
+            goto recheck;
-            }
-            pr->name = name;
-            pr->callid = iid;
-            list_append(&pr->link, &pending_req);
-            return;
+        }
         ipc_answer_0(iid, ENOENT);
         free(name);
+        fibril_mutex_unlock(&devices_list_mutex);
         return;
+    }
+    fibril_mutex_unlock(&devices_list_mutex);
     ipc_answer_1(iid, EOK, dev->handle);
     free(name);
+}
 /** Find name of device identified by id and send it to caller.
+ *
  */
 static void devmap_get_name(ipc_callid_t iid, ipc_call_t *icall)
+{
     const devmap_device_t *device = devmap_device_find_handle(IPC_GET_ARG1(*icall));
     /*
      * Device not found.
      */
     if (device == NULL) {
         ipc_answer_0(iid, ENOENT);
         return;
+    }
     ipc_answer_0(iid, EOK);
-    size_t name_size = str_size(device->name);
     /* FIXME:
      * We have no channel from DEVMAP to client, therefore
      * sending must be initiated by client.
+     *
+     * size_t name_size = str_size(device->name);
+     *
      * int rc = ipc_data_write_send(phone, device->name, name_size);
      * if (rc != EOK) {
      *     async_wait_for(req, NULL);
      *     return rc;
      * }
      */
     /* TODO: send name in response */
+}
+static void devmap_get_count(ipc_callid_t iid, ipc_call_t *icall)
+{
+    fibril_mutex_lock(&devices_list_mutex);
+    ipc_answer_1(iid, EOK, list_count(&devices_list));
+    fibril_mutex_unlock(&devices_list_mutex);
+}
+static void devmap_get_devices(ipc_callid_t iid, ipc_call_t *icall)
+{
+    fibril_mutex_lock(&devices_list_mutex);
+    ipc_callid_t callid;
+    size_t size;
+    if (!ipc_data_read_receive(&callid, &size)) {
+        ipc_answer_0(callid, EREFUSED);
+        ipc_answer_0(iid, EREFUSED);
+        return;
+    }
+    if ((size % sizeof(dev_desc_t)) != 0) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(iid, EREFUSED);
+        return;
+    }
+    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;
+    }
+    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);
+        desc[pos].handle = device->handle;
+        str_cpy(desc[pos].name, DEVMAP_NAME_MAXLEN, device->name);
+        pos++;
+        item = item->next;
+    }
+    ipcarg_t retval = ipc_data_read_finalize(callid, desc, pos * sizeof(dev_desc_t));
+    if (retval != EOK) {
+        ipc_answer_0(iid, EREFUSED);
+        free(desc);
+        return;
+    }
+    free(desc);
+    fibril_mutex_unlock(&devices_list_mutex);
+    ipc_answer_1(iid, EOK, pos);
+}
+static void devmap_null_create(ipc_callid_t iid, ipc_call_t *icall)
+{
+    fibril_mutex_lock(&null_devices_mutex);
+    unsigned int i;
+    bool fnd = false;
+    for (i = 0; i < NULL_DEVICES; i++) {
+        if (null_devices[i] == NULL) {
+            fnd = true;
+            break;
+        }
+    }
+    if (!fnd) {
+        fibril_mutex_unlock(&null_devices_mutex);
+        ipc_answer_0(iid, ENOMEM);
+        return;
+    }
+    /* Create NULL device entry */
+    devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
+    if (device == NULL) {
+        fibril_mutex_unlock(&null_devices_mutex);
+        ipc_answer_0(iid, ENOMEM);
+        return;
+    }
+    char null[DEVMAP_NAME_MAXLEN];
+    snprintf(null, DEVMAP_NAME_MAXLEN, "null%u", i);
+    device->name = str_dup(null);
+    if (device->name == NULL) {
+        fibril_mutex_unlock(&null_devices_mutex);
+        free(device);
+        ipc_answer_0(iid, ENOMEM);
+        return;
+    }
+    list_initialize(&(device->devices));
+    list_initialize(&(device->driver_devices));
+    fibril_mutex_lock(&devices_list_mutex);
+    /* Get unique device handle */
+    device->handle = devmap_create_handle();
+    device->driver = NULL;
+    /* Insert device into list of all devices
+       and into null devices array */
+    list_append(&device->devices, &devices_list);
+    null_devices[i] = device;
+    fibril_mutex_unlock(&devices_list_mutex);
+    fibril_mutex_unlock(&null_devices_mutex);
+    ipc_answer_1(iid, EOK, (ipcarg_t) i);
+}
+static void devmap_null_destroy(ipc_callid_t iid, ipc_call_t *icall)
+{
+    fibril_mutex_lock(&null_devices_mutex);
+    ipcarg_t i = IPC_GET_ARG1(*icall);
+    if (null_devices[i] == NULL) {
+        ipc_answer_0(iid, ENOENT);
+        return;
+    }
+    devmap_device_unregister_core(null_devices[i]);
+    null_devices[i] = NULL;
+    fibril_mutex_unlock(&null_devices_mutex);
+    ipc_answer_0(iid, EOK);
+}
+/** Initialize device mapper.
+ *
+ *
+ */
+static bool devmap_init(void)
+{
+    fibril_mutex_lock(&null_devices_mutex);
+    unsigned int i;
+    for (i = 0; i < NULL_DEVICES; i++)
+        null_devices[i] = NULL;
+    fibril_mutex_unlock(&null_devices_mutex);
+    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);
         switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
             cont = false;
-            /* Exit thread */
             continue;
         case DEVMAP_DRIVER_UNREGISTER:
             if (NULL == driver)
                 ipc_answer_0(callid, ENOENT);
             else
                 ipc_answer_0(callid, EOK);
             break;
         case DEVMAP_DEVICE_REGISTER:
             /* Register one instance of device */
             devmap_device_register(callid, &call, driver);
             break;
         case DEVMAP_DEVICE_UNREGISTER:
             /* Remove instance of device identified by handler */
             devmap_device_unregister(callid, &call, driver);
             break;
         case DEVMAP_DEVICE_GET_HANDLE:
             devmap_get_handle(callid, &call);
             break;
         case DEVMAP_DEVICE_GET_NAME:
-            devmap_get_handle(callid, &call);
+            devmap_get_name(callid, &call);
             break;
         default:
             if (!(callid & IPC_CALLID_NOTIFICATION))
                 ipc_answer_0(callid, ENOENT);
+        }
+    }
-    if (NULL != driver) {
+    if (driver != NULL) {
         /*
          * Unregister the device driver and all its devices.
          */
         devmap_driver_unregister(driver);
         driver = NULL;
+    }
+}
 /** Handle connection with device client.
+ *
  */
 static void devmap_connection_client(ipc_callid_t iid, ipc_call_t *icall)
+{
     /* Accept connection */
     ipc_answer_0(iid, EOK);
     bool cont = true;
     while (cont) {
         ipc_call_t call;
         ipc_callid_t callid = async_get_call(&call);
         switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
             cont = false;
-            /* Exit thread */
             continue;
         case DEVMAP_DEVICE_GET_HANDLE:
             devmap_get_handle(callid, &call);
             break;
         case DEVMAP_DEVICE_GET_NAME:
-            /* TODO */
             devmap_get_name(callid, &call);
             break;
+        case DEVMAP_DEVICE_NULL_CREATE:
+            devmap_null_create(callid, &call);
+            break;
+        case DEVMAP_DEVICE_NULL_DESTROY:
+            devmap_null_destroy(callid, &call);
+            break;
+        case DEVMAP_DEVICE_GET_COUNT:
+            devmap_get_count(callid, &call);
+            break;
+        case DEVMAP_DEVICE_GET_DEVICES:
+            devmap_get_devices(callid, &call);
+            break;
         default:
             if (!(callid & IPC_CALLID_NOTIFICATION))
                 ipc_answer_0(callid, ENOENT);
+        }
+    }
+}
 /** Function for handling connections to devmap
+ *
  */
 static void devmap_connection(ipc_callid_t iid, ipc_call_t *icall)
+{
     /* Select interface */
     switch ((ipcarg_t) (IPC_GET_ARG1(*icall))) {
     case DEVMAP_DRIVER:
         devmap_connection_driver(iid, icall);
         break;
     case DEVMAP_CLIENT:
         devmap_connection_client(iid, icall);
         break;
     case DEVMAP_CONNECT_TO_DEVICE:
         /* Connect client to selected device */
         devmap_forward(iid, icall);
         break;
     default:
         /* No such interface */
         ipc_answer_0(iid, ENOENT);
+    }
+}
 /**
+ *
  */
 int main(int argc, char *argv[])
+{
     printf(NAME ": HelenOS Device Mapper\n");
-    if (devmap_init() != 0) {
+    if (!devmap_init()) {
         printf(NAME ": Error while initializing service\n");
         return -1;
+    }
     /* Set a handler of incomming connections */
     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)
         return -1;
     printf(NAME ": Accepting connections\n");
     async_manager();
     /* Never reached */
     return 0;
+}
 /**
  * @}
  */

Subversion Repositories HelenOS

(root)/branches/tracing/uspace/srv/devmap/devmap.c – Rev 4377 → 4692