source: mainline/uspace/srv/devmap/devmap.c@ 103bb68

/*
 * 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 <fibril_sync.h>
#include <stdlib.h>
#include <string.h>
#include <ipc/devmap.h>
#include <assert.h>

#define NAME  "devmap"

/** 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 devices;
        /** Phone asociated with this driver */
        ipcarg_t phone;
        /** Device driver name */
        char *name;
        /** Fibril mutex for list of devices owned by this driver */
        fibril_mutex_t devices_mutex;
} 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;

/** Pending lookup structure. */
typedef struct {
        link_t link;
        char *name;              /**< Device name */
        ipc_callid_t callid;     /**< Call ID waiting for the lookup */
} pending_req_t;

LIST_INITIALIZE(devices_list);
LIST_INITIALIZE(drivers_list);
LIST_INITIALIZE(pending_req);

static bool pending_new_dev = false;
static FIBRIL_CONDVAR_INITIALIZE(pending_cv);

/* Locking order:
 *  drivers_list_mutex
 *  devices_list_mutex
 *  (devmap_driver_t *)->devices_mutex
 *  create_handle_mutex
 **/

static FIBRIL_MUTEX_INITIALIZE(devices_list_mutex);
static FIBRIL_MUTEX_INITIALIZE(drivers_list_mutex);
static FIBRIL_MUTEX_INITIALIZE(create_handle_mutex);

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, avoid overflow
         */
        
        fibril_mutex_lock(&create_handle_mutex);
        last_handle++;
        fibril_mutex_unlock(&create_handle_mutex);
        
        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 (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(dev_handle_t handle)
{
        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) {
                fibril_mutex_unlock(&devices_list_mutex);
                return NULL;
        }
        
        device = list_get_instance(item, devmap_device_t, devices);
        
        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 (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 mutex for list of devices owned by this driver */
        fibril_mutex_initialize(&driver->devices_mutex);
        
        /*
         * 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_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));
        
        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);
        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;
        
        fibril_mutex_lock(&drivers_list_mutex);
        
        if (driver->phone != 0)
                ipc_hangup(driver->phone);
        
        /* Remove it from list of drivers */
        list_remove(&(driver->drivers));
        
        /* Unregister all its devices */
        fibril_mutex_lock(&devices_list_mutex);
        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);
        }
        
        fibril_mutex_unlock(&driver->devices_mutex);
        fibril_mutex_unlock(&devices_list_mutex);
        fibril_mutex_unlock(&drivers_list_mutex);
        
        /* free name and driver */
        if (driver->name != NULL)
                free(driver->name);
        
        free(driver);
        
        return EOK;
}


/** Process pending lookup requests */
static void process_pending_lookup(void)
{
        link_t *cur;

loop:
        fibril_mutex_lock(&devices_list_mutex);
        while (!pending_new_dev)
                fibril_condvar_wait(&pending_cv, &devices_list_mutex);
rescan:
        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 rescan;
        }
        pending_new_dev = false;
        fibril_mutex_unlock(&devices_list_mutex);
        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));
        
        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);
                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 */
        fibril_mutex_lock(&device->driver->devices_mutex);
        
        list_append(&device->driver_devices, &device->driver->devices);
        
        fibril_mutex_unlock(&device->driver->devices_mutex);
        pending_new_dev = true;
        fibril_condvar_signal(&pending_cv);
        fibril_mutex_unlock(&devices_list_mutex);
        
        ipc_answer_1(iid, EOK, device->handle);
}

/**
 *
 */
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
         */
        dev_handle_t handle = IPC_GET_ARG2(*call);
        devmap_device_t *dev = devmap_device_find_handle(handle);
        
        if ((dev == NULL) || (dev->driver == NULL) || (dev->driver->phone == 0)) {
                ipc_answer_0(callid, ENOENT);
                return;
        }
        
        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 + 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);

        /*
         * Find device name in linked list of known devices.
         */
        const devmap_device_t *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 */
                        pending_req_t *pr = (pending_req_t *) malloc(sizeof(pending_req_t));
                        if (!pr) {
                                fibril_mutex_unlock(&devices_list_mutex);
                                ipc_answer_0(iid, ENOMEM);
                                free(name);
                                return;
                        }
                        
                        pr->name = name;
                        pr->callid = iid;
                        list_append(&pr->link, &pending_req);
                        fibril_mutex_unlock(&devices_list_mutex);
                        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.
         *
         * 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);
}

/** Initialize device mapper.
 *
 *
 */
static bool devmap_init(void)
{
        /* Create NULL device entry */
        devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
        if (device == NULL)
                return false;
        
        device->name = str_dup("null");
        if (device->name == NULL) {
                free(device);
                return false;
        }
        
        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  */
        list_append(&device->devices, &devices_list);
        
        fibril_mutex_unlock(&devices_list_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;
                        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_name(callid, &call);
                        break;
                default:
                        if (!(callid & IPC_CALLID_NOTIFICATION))
                                ipc_answer_0(callid, ENOENT);
                }
        }
        
        if (NULL != driver) {
                /*
                 * 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;
                        continue;
                case DEVMAP_DEVICE_GET_HANDLE:
                        devmap_get_handle(callid, &call);
                        break;
                case DEVMAP_DEVICE_GET_NAME:
                        devmap_get_name(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()) {
                printf(NAME ": Error while initializing service\n");
                return -1;
        }
        
        /* Set a handler of incomming connections */
        async_set_client_connection(devmap_connection);

        /* Create a fibril for handling pending device lookups */
        fid_t fid = fibril_create(process_pending_lookup, NULL);
        assert(fid);
        fibril_add_ready(fid);
        
        /* 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;
}

/** 
 * @}
 */