WebSVN – HelenOS – Diff – /branches/dd/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 <fibril_sync.h>
#include <stdlib.h>
#include <string.h>
#include <ipc/devmap.h>
 
#define NAME          "devmap"
#define NULL_DEVICES  256
 
/** 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;
 
LIST_INITIALIZE(devices_list);
LIST_INITIALIZE(drivers_list);
 
/* 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_CONDVAR_INITIALIZE(devices_list_cv);
static FIBRIL_MUTEX_INITIALIZE(drivers_list_mutex);
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 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;
}
 
/** 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);
    fibril_condvar_broadcast(&devices_list_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);
    const devmap_device_t *dev;
recheck:
 
    /*
     * Find device name in the list of known devices.
     */
    dev = devmap_device_find_name(name);
   
    /*
     * Device was not found.
     */
    if (dev == NULL) {
        if (IPC_GET_ARG1(*icall) & IPC_FLAG_BLOCKING) {
            /* Blocking lookup */
            fibril_condvar_wait(&devices_list_cv,
                &devices_list_mutex);
            goto recheck;
        }
       
        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);
   
 
 
    /* 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;
            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 (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;
            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_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()) {
        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;
}
 
/**
 * @}
 */
 

Rev 4668	Rev 4688
1	/*	1	/*
2	* Copyright (c) 2007 Josef Cejka	2	* Copyright (c) 2007 Josef Cejka
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/**	29	/**
30	* @defgroup devmap Device mapper.	30	* @defgroup devmap Device mapper.
31	* @brief HelenOS device mapper.	31	* @brief HelenOS device mapper.
32	* @{	32	* @{
33	*/	33	*/
34		34
35	/** @file	35	/** @file
36	*/	36	*/
37		37
38	#include <ipc/services.h>	38	#include <ipc/services.h>
39	#include <ipc/ns.h>	39	#include <ipc/ns.h>
40	#include <async.h>	40	#include <async.h>
41	#include <stdio.h>	41	#include <stdio.h>
42	#include <errno.h>	42	#include <errno.h>
43	#include <bool.h>	43	#include <bool.h>
44	#include <fibril_sync.h>	44	#include <fibril_sync.h>
45	#include <stdlib.h>	45	#include <stdlib.h>
46	#include <string.h>	46	#include <string.h>
47	#include <ipc/devmap.h>	47	#include <ipc/devmap.h>
48		48
49	#define NAME "devmap"	49	#define NAME "devmap"
50	#define NULL_DEVICES 256	50	#define NULL_DEVICES 256
51		51
52	/** Representation of device driver.	52	/** Representation of device driver.
53	*	53	*
54	* Each driver is responsible for a set of devices.	54	* Each driver is responsible for a set of devices.
55	*	55	*
56	*/	56	*/
57	typedef struct {	57	typedef struct {
58	/** Pointers to previous and next drivers in linked list */	58	/** Pointers to previous and next drivers in linked list */
59	link_t drivers;	59	link_t drivers;
60	/** Pointer to the linked list of devices controlled by this driver */	60	/** Pointer to the linked list of devices controlled by this driver */
61	link_t devices;	61	link_t devices;
62	/** Phone asociated with this driver */	62	/** Phone asociated with this driver */
63	ipcarg_t phone;	63	ipcarg_t phone;
64	/** Device driver name */	64	/** Device driver name */
65	char *name;	65	char *name;
66	/** Fibril mutex for list of devices owned by this driver */	66	/** Fibril mutex for list of devices owned by this driver */
67	fibril_mutex_t devices_mutex;	67	fibril_mutex_t devices_mutex;
68	} devmap_driver_t;	68	} devmap_driver_t;
69		69
70	/** Info about registered device	70	/** Info about registered device
71	*	71	*
72	*/	72	*/
73	typedef struct {	73	typedef struct {
74	/** Pointer to the previous and next device in the list of all devices */	74	/** Pointer to the previous and next device in the list of all devices */
75	link_t devices;	75	link_t devices;
76	/** Pointer to the previous and next device in the list of devices	76	/** Pointer to the previous and next device in the list of devices
77	owned by one driver */	77	owned by one driver */
78	link_t driver_devices;	78	link_t driver_devices;
79	/** Unique device identifier */	79	/** Unique device identifier */
80	dev_handle_t handle;	80	dev_handle_t handle;
81	/** Device name */	81	/** Device name */
82	char *name;	82	char *name;
83	/** Device driver handling this device */	83	/** Device driver handling this device */
84	devmap_driver_t *driver;	84	devmap_driver_t *driver;
85	} devmap_device_t;	85	} devmap_device_t;
86		86
87	LIST_INITIALIZE(devices_list);	87	LIST_INITIALIZE(devices_list);
88	LIST_INITIALIZE(drivers_list);	88	LIST_INITIALIZE(drivers_list);
89		89
90	/* Locking order:	90	/* Locking order:
91	* drivers_list_mutex	91	* drivers_list_mutex
92	* devices_list_mutex	92	* devices_list_mutex
93	* (devmap_driver_t *)->devices_mutex	93	* (devmap_driver_t *)->devices_mutex
94	* create_handle_mutex	94	* create_handle_mutex
95	**/	95	**/
96		96
97	static FIBRIL_MUTEX_INITIALIZE(devices_list_mutex);	97	static FIBRIL_MUTEX_INITIALIZE(devices_list_mutex);
98	static FIBRIL_CONDVAR_INITIALIZE(devices_list_cv);	98	static FIBRIL_CONDVAR_INITIALIZE(devices_list_cv);
99	static FIBRIL_MUTEX_INITIALIZE(drivers_list_mutex);	99	static FIBRIL_MUTEX_INITIALIZE(drivers_list_mutex);
100	static FIBRIL_MUTEX_INITIALIZE(create_handle_mutex);	100	static FIBRIL_MUTEX_INITIALIZE(create_handle_mutex);
101	static FIBRIL_MUTEX_INITIALIZE(null_devices_mutex);	101	static FIBRIL_MUTEX_INITIALIZE(null_devices_mutex);
102		102
103	static dev_handle_t last_handle = 0;	103	static dev_handle_t last_handle = 0;
104	static devmap_device_t *null_devices[NULL_DEVICES];	104	static devmap_device_t *null_devices[NULL_DEVICES];
105		105
106	static dev_handle_t devmap_create_handle(void)	106	static dev_handle_t devmap_create_handle(void)
107	{	107	{
108	/* TODO: allow reusing old handles after their unregistration	108	/* TODO: allow reusing old handles after their unregistration
109	* and implement some version of LRU algorithm, avoid overflow	109	* and implement some version of LRU algorithm, avoid overflow
110	*/	110	*/
111		111
112	fibril_mutex_lock(&create_handle_mutex);	112	fibril_mutex_lock(&create_handle_mutex);
113	last_handle++;	113	last_handle++;
114	fibril_mutex_unlock(&create_handle_mutex);	114	fibril_mutex_unlock(&create_handle_mutex);
115		115
116	return last_handle;	116	return last_handle;
117	}	117	}
118		118
119	/** Find device with given name.	119	/** Find device with given name.
120	*	120	*
121	*/	121	*/
122	static devmap_device_t devmap_device_find_name(const char name)	122	static devmap_device_t devmap_device_find_name(const char name)
123	{	123	{
124	link_t *item = devices_list.next;	124	link_t *item = devices_list.next;
125	devmap_device_t *device = NULL;	125	devmap_device_t *device = NULL;
126		126
127	while (item != &devices_list) {	127	while (item != &devices_list) {
128	device = list_get_instance(item, devmap_device_t, devices);	128	device = list_get_instance(item, devmap_device_t, devices);
129	if (str_cmp(device->name, name) == 0)	129	if (str_cmp(device->name, name) == 0)
130	break;	130	break;
131	item = item->next;	131	item = item->next;
132	}	132	}
133		133
134	if (item == &devices_list)	134	if (item == &devices_list)
135	return NULL;	135	return NULL;
136		136
137	device = list_get_instance(item, devmap_device_t, devices);	137	device = list_get_instance(item, devmap_device_t, devices);
138	return device;	138	return device;
139	}	139	}
140		140
141	/** Find device with given handle.	141	/** Find device with given handle.
142	*	142	*
143	* @todo: use hash table	143	* @todo: use hash table
144	*	144	*
145	*/	145	*/
146	static devmap_device_t *devmap_device_find_handle(dev_handle_t handle)	146	static devmap_device_t *devmap_device_find_handle(dev_handle_t handle)
147	{	147	{
148	fibril_mutex_lock(&devices_list_mutex);	148	fibril_mutex_lock(&devices_list_mutex);
149		149
150	link_t *item = (&devices_list)->next;	150	link_t *item = (&devices_list)->next;
151	devmap_device_t *device = NULL;	151	devmap_device_t *device = NULL;
152		152
153	while (item != &devices_list) {	153	while (item != &devices_list) {
154	device = list_get_instance(item, devmap_device_t, devices);	154	device = list_get_instance(item, devmap_device_t, devices);
155	if (device->handle == handle)	155	if (device->handle == handle)
156	break;	156	break;
157	item = item->next;	157	item = item->next;
158	}	158	}
159		159
160	if (item == &devices_list) {	160	if (item == &devices_list) {
161	fibril_mutex_unlock(&devices_list_mutex);	161	fibril_mutex_unlock(&devices_list_mutex);
162	return NULL;	162	return NULL;
163	}	163	}
164		164
165	device = list_get_instance(item, devmap_device_t, devices);	165	device = list_get_instance(item, devmap_device_t, devices);
166		166
167	fibril_mutex_unlock(&devices_list_mutex);	167	fibril_mutex_unlock(&devices_list_mutex);
168		168
169	return device;	169	return device;
170	}	170	}
171		171
172	/**	172	/**
173	* Unregister device and free it. It's assumed that driver's device list is	173	* Unregister device and free it. It's assumed that driver's device list is
174	* already locked.	174	* already locked.
175	*/	175	*/
176	static int devmap_device_unregister_core(devmap_device_t *device)	176	static int devmap_device_unregister_core(devmap_device_t *device)
177	{	177	{
178	list_remove(&(device->devices));	178	list_remove(&(device->devices));
179	list_remove(&(device->driver_devices));	179	list_remove(&(device->driver_devices));
180		180
181	free(device->name);	181	free(device->name);
182	free(device);	182	free(device);
183		183
184	return EOK;	184	return EOK;
185	}	185	}
186		186
187	/**	187	/**
188	* Read info about new driver and add it into linked list of registered	188	* Read info about new driver and add it into linked list of registered
189	* drivers.	189	* drivers.
190	*/	190	*/
191	static void devmap_driver_register(devmap_driver_t **odriver)	191	static void devmap_driver_register(devmap_driver_t **odriver)
192	{	192	{
193	*odriver = NULL;	193	*odriver = NULL;
194		194
195	ipc_call_t icall;	195	ipc_call_t icall;
196	ipc_callid_t iid = async_get_call(&icall);	196	ipc_callid_t iid = async_get_call(&icall);
197		197
198	if (IPC_GET_METHOD(icall) != DEVMAP_DRIVER_REGISTER) {	198	if (IPC_GET_METHOD(icall) != DEVMAP_DRIVER_REGISTER) {
199	ipc_answer_0(iid, EREFUSED);	199	ipc_answer_0(iid, EREFUSED);
200	return;	200	return;
201	}	201	}
202		202
203	devmap_driver_t driver = (devmap_driver_t ) malloc(sizeof(devmap_driver_t));	203	devmap_driver_t driver = (devmap_driver_t ) malloc(sizeof(devmap_driver_t));
204		204
205	if (driver == NULL) {	205	if (driver == NULL) {
206	ipc_answer_0(iid, ENOMEM);	206	ipc_answer_0(iid, ENOMEM);
207	return;	207	return;
208	}	208	}
209		209
210	/*	210	/*
211	* Get driver name	211	* Get driver name
212	*/	212	*/
213	ipc_callid_t callid;	213	ipc_callid_t callid;
214	size_t name_size;	214	size_t name_size;
215	if (!ipc_data_write_receive(&callid, &name_size)) {	215	if (!ipc_data_write_receive(&callid, &name_size)) {
216	free(driver);	216	free(driver);
217	ipc_answer_0(callid, EREFUSED);	217	ipc_answer_0(callid, EREFUSED);
218	ipc_answer_0(iid, EREFUSED);	218	ipc_answer_0(iid, EREFUSED);
219	return;	219	return;
220	}	220	}
221		221
222	if (name_size > DEVMAP_NAME_MAXLEN) {	222	if (name_size > DEVMAP_NAME_MAXLEN) {
223	free(driver);	223	free(driver);
224	ipc_answer_0(callid, EINVAL);	224	ipc_answer_0(callid, EINVAL);
225	ipc_answer_0(iid, EREFUSED);	225	ipc_answer_0(iid, EREFUSED);
226	return;	226	return;
227	}	227	}
228		228
229	/*	229	/*
230	* Allocate buffer for device name.	230	* Allocate buffer for device name.
231	*/	231	*/
232	driver->name = (char *) malloc(name_size + 1);	232	driver->name = (char *) malloc(name_size + 1);
233	if (driver->name == NULL) {	233	if (driver->name == NULL) {
234	free(driver);	234	free(driver);
235	ipc_answer_0(callid, ENOMEM);	235	ipc_answer_0(callid, ENOMEM);
236	ipc_answer_0(iid, EREFUSED);	236	ipc_answer_0(iid, EREFUSED);
237	return;	237	return;
238	}	238	}
239		239
240	/*	240	/*
241	* Send confirmation to sender and get data into buffer.	241	* Send confirmation to sender and get data into buffer.
242	*/	242	*/
243	if (ipc_data_write_finalize(callid, driver->name, name_size) != EOK) {	243	if (ipc_data_write_finalize(callid, driver->name, name_size) != EOK) {
244	free(driver->name);	244	free(driver->name);
245	free(driver);	245	free(driver);
246	ipc_answer_0(iid, EREFUSED);	246	ipc_answer_0(iid, EREFUSED);
247	return;	247	return;
248	}	248	}
249		249
250	driver->name[name_size] = 0;	250	driver->name[name_size] = 0;
251		251
252	/* Initialize mutex for list of devices owned by this driver */	252	/* Initialize mutex for list of devices owned by this driver */
253	fibril_mutex_initialize(&driver->devices_mutex);	253	fibril_mutex_initialize(&driver->devices_mutex);
254		254
255	/*	255	/*
256	* Initialize list of asociated devices	256	* Initialize list of asociated devices
257	*/	257	*/
258	list_initialize(&driver->devices);	258	list_initialize(&driver->devices);
259		259
260	/*	260	/*
261	* Create connection to the driver	261	* Create connection to the driver
262	*/	262	*/
263	ipc_call_t call;	263	ipc_call_t call;
264	callid = async_get_call(&call);	264	callid = async_get_call(&call);
265		265
266	if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {	266	if (IPC_GET_METHOD(call) != IPC_M_CONNECT_TO_ME) {
267	ipc_answer_0(callid, ENOTSUP);	267	ipc_answer_0(callid, ENOTSUP);
268		268
269	free(driver->name);	269	free(driver->name);
270	free(driver);	270	free(driver);
271	ipc_answer_0(iid, ENOTSUP);	271	ipc_answer_0(iid, ENOTSUP);
272	return;	272	return;
273	}	273	}
274		274
275	driver->phone = IPC_GET_ARG5(call);	275	driver->phone = IPC_GET_ARG5(call);
276		276
277	ipc_answer_0(callid, EOK);	277	ipc_answer_0(callid, EOK);
278		278
279	list_initialize(&(driver->drivers));	279	list_initialize(&(driver->drivers));
280		280
281	fibril_mutex_lock(&drivers_list_mutex);	281	fibril_mutex_lock(&drivers_list_mutex);
282		282
283	/* TODO:	283	/* TODO:
284	* check that no driver with name equal to driver->name is registered	284	* check that no driver with name equal to driver->name is registered
285	*/	285	*/
286		286
287	/*	287	/*
288	* Insert new driver into list of registered drivers	288	* Insert new driver into list of registered drivers
289	*/	289	*/
290	list_append(&(driver->drivers), &drivers_list);	290	list_append(&(driver->drivers), &drivers_list);
291	fibril_mutex_unlock(&drivers_list_mutex);	291	fibril_mutex_unlock(&drivers_list_mutex);
292		292
293	ipc_answer_0(iid, EOK);	293	ipc_answer_0(iid, EOK);
294		294
295	*odriver = driver;	295	*odriver = driver;
296	}	296	}
297		297
298	/**	298	/**
299	* Unregister device driver, unregister all its devices and free driver	299	* Unregister device driver, unregister all its devices and free driver
300	* structure.	300	* structure.
301	*	301	*
302	*/	302	*/
303	static int devmap_driver_unregister(devmap_driver_t *driver)	303	static int devmap_driver_unregister(devmap_driver_t *driver)
304	{	304	{
305	if (driver == NULL)	305	if (driver == NULL)
306	return EEXISTS;	306	return EEXISTS;
307		307
308	fibril_mutex_lock(&drivers_list_mutex);	308	fibril_mutex_lock(&drivers_list_mutex);
309		309
310	if (driver->phone != 0)	310	if (driver->phone != 0)
311	ipc_hangup(driver->phone);	311	ipc_hangup(driver->phone);
312		312
313	/* Remove it from list of drivers */	313	/* Remove it from list of drivers */
314	list_remove(&(driver->drivers));	314	list_remove(&(driver->drivers));
315		315
316	/* Unregister all its devices */	316	/* Unregister all its devices */
317	fibril_mutex_lock(&devices_list_mutex);	317	fibril_mutex_lock(&devices_list_mutex);
318	fibril_mutex_lock(&driver->devices_mutex);	318	fibril_mutex_lock(&driver->devices_mutex);
319		319
320	while (!list_empty(&(driver->devices))) {	320	while (!list_empty(&(driver->devices))) {
321	devmap_device_t *device = list_get_instance(driver->devices.next,	321	devmap_device_t *device = list_get_instance(driver->devices.next,
322	devmap_device_t, driver_devices);	322	devmap_device_t, driver_devices);
323	devmap_device_unregister_core(device);	323	devmap_device_unregister_core(device);
324	}	324	}
325		325
326	fibril_mutex_unlock(&driver->devices_mutex);	326	fibril_mutex_unlock(&driver->devices_mutex);
327	fibril_mutex_unlock(&devices_list_mutex);	327	fibril_mutex_unlock(&devices_list_mutex);
328	fibril_mutex_unlock(&drivers_list_mutex);	328	fibril_mutex_unlock(&drivers_list_mutex);
329		329
330	/* free name and driver */	330	/* free name and driver */
331	if (driver->name != NULL)	331	if (driver->name != NULL)
332	free(driver->name);	332	free(driver->name);
333		333
334	free(driver);	334	free(driver);
335		335
336	return EOK;	336	return EOK;
337	}	337	}
338		338
339	/** Register instance of device	339	/** Register instance of device
340	*	340	*
341	*/	341	*/
342	static void devmap_device_register(ipc_callid_t iid, ipc_call_t *icall,	342	static void devmap_device_register(ipc_callid_t iid, ipc_call_t *icall,
343	devmap_driver_t *driver)	343	devmap_driver_t *driver)
344	{	344	{
345	if (driver == NULL) {	345	if (driver == NULL) {
346	ipc_answer_0(iid, EREFUSED);	346	ipc_answer_0(iid, EREFUSED);
347	return;	347	return;
348	}	348	}
349		349
350	/* Create new device entry */	350	/* Create new device entry */
351	devmap_device_t device = (devmap_device_t ) malloc(sizeof(devmap_device_t));	351	devmap_device_t device = (devmap_device_t ) malloc(sizeof(devmap_device_t));
352	if (device == NULL) {	352	if (device == NULL) {
353	ipc_answer_0(iid, ENOMEM);	353	ipc_answer_0(iid, ENOMEM);
354	return;	354	return;
355	}	355	}
356		356
357	/* Get device name */	357	/* Get device name */
358	ipc_callid_t callid;	358	ipc_callid_t callid;
359	size_t size;	359	size_t size;
360	if (!ipc_data_write_receive(&callid, &size)) {	360	if (!ipc_data_write_receive(&callid, &size)) {
361	free(device);	361	free(device);
362	ipc_answer_0(iid, EREFUSED);	362	ipc_answer_0(iid, EREFUSED);
363	return;	363	return;
364	}	364	}
365		365
366	if (size > DEVMAP_NAME_MAXLEN) {	366	if (size > DEVMAP_NAME_MAXLEN) {
367	free(device);	367	free(device);
368	ipc_answer_0(callid, EINVAL);	368	ipc_answer_0(callid, EINVAL);
369	ipc_answer_0(iid, EREFUSED);	369	ipc_answer_0(iid, EREFUSED);
370	return;	370	return;
371	}	371	}
372		372
373	/* +1 for terminating \0 */	373	/* +1 for terminating \0 */
374	device->name = (char *) malloc(size + 1);	374	device->name = (char *) malloc(size + 1);
375		375
376	if (device->name == NULL) {	376	if (device->name == NULL) {
377	free(device);	377	free(device);
378	ipc_answer_0(callid, ENOMEM);	378	ipc_answer_0(callid, ENOMEM);
379	ipc_answer_0(iid, EREFUSED);	379	ipc_answer_0(iid, EREFUSED);
380	return;	380	return;
381	}	381	}
382		382
383	ipc_data_write_finalize(callid, device->name, size);	383	ipc_data_write_finalize(callid, device->name, size);
384	device->name[size] = 0;	384	device->name[size] = 0;
385		385
386	list_initialize(&(device->devices));	386	list_initialize(&(device->devices));
387	list_initialize(&(device->driver_devices));	387	list_initialize(&(device->driver_devices));
388		388
389	fibril_mutex_lock(&devices_list_mutex);	389	fibril_mutex_lock(&devices_list_mutex);
390		390
391	/* Check that device with such name is not already registered */	391	/* Check that device with such name is not already registered */
392	if (NULL != devmap_device_find_name(device->name)) {	392	if (NULL != devmap_device_find_name(device->name)) {
393	printf(NAME ": Device '%s' already registered\n", device->name);	393	printf(NAME ": Device '%s' already registered\n", device->name);
394	fibril_mutex_unlock(&devices_list_mutex);	394	fibril_mutex_unlock(&devices_list_mutex);
395	free(device->name);	395	free(device->name);
396	free(device);	396	free(device);
397	ipc_answer_0(iid, EEXISTS);	397	ipc_answer_0(iid, EEXISTS);
398	return;	398	return;
399	}	399	}
400		400
401	/* Get unique device handle */	401	/* Get unique device handle */
402	device->handle = devmap_create_handle();	402	device->handle = devmap_create_handle();
403		403
404	device->driver = driver;	404	device->driver = driver;
405		405
406	/* Insert device into list of all devices */	406	/* Insert device into list of all devices */
407	list_append(&device->devices, &devices_list);	407	list_append(&device->devices, &devices_list);
408		408
409	/* Insert device into list of devices that belog to one driver */	409	/* Insert device into list of devices that belog to one driver */
410	fibril_mutex_lock(&device->driver->devices_mutex);	410	fibril_mutex_lock(&device->driver->devices_mutex);
411		411
412	list_append(&device->driver_devices, &device->driver->devices);	412	list_append(&device->driver_devices, &device->driver->devices);
413		413
414	fibril_mutex_unlock(&device->driver->devices_mutex);	414	fibril_mutex_unlock(&device->driver->devices_mutex);
415	fibril_condvar_broadcast(&devices_list_cv);	415	fibril_condvar_broadcast(&devices_list_cv);
416	fibril_mutex_unlock(&devices_list_mutex);	416	fibril_mutex_unlock(&devices_list_mutex);
417		417
418	ipc_answer_1(iid, EOK, device->handle);	418	ipc_answer_1(iid, EOK, device->handle);
419	}	419	}
420		420
421	/**	421	/**
422	*	422	*
423	*/	423	*/
424	static int devmap_device_unregister(ipc_callid_t iid, ipc_call_t *icall,	424	static int devmap_device_unregister(ipc_callid_t iid, ipc_call_t *icall,
425	devmap_driver_t *driver)	425	devmap_driver_t *driver)
426	{	426	{
427	/* TODO */	427	/* TODO */
428	return EOK;	428	return EOK;
429	}	429	}
430		430
431	/** Connect client to the device.	431	/** Connect client to the device.
432	*	432	*
433	* Find device driver owning requested device and forward	433	* Find device driver owning requested device and forward
434	* the message to it.	434	* the message to it.
435	*	435	*
436	*/	436	*/
437	static void devmap_forward(ipc_callid_t callid, ipc_call_t *call)	437	static void devmap_forward(ipc_callid_t callid, ipc_call_t *call)
438	{	438	{
439	/*	439	/*
440	* Get handle from request	440	* Get handle from request
441	*/	441	*/
442	dev_handle_t handle = IPC_GET_ARG2(*call);	442	dev_handle_t handle = IPC_GET_ARG2(*call);
443	devmap_device_t *dev = devmap_device_find_handle(handle);	443	devmap_device_t *dev = devmap_device_find_handle(handle);
444		444
445	if ((dev == NULL) \|\| (dev->driver == NULL) \|\| (dev->driver->phone == 0)) {	445	if ((dev == NULL) \|\| (dev->driver == NULL) \|\| (dev->driver->phone == 0)) {
446	ipc_answer_0(callid, ENOENT);	446	ipc_answer_0(callid, ENOENT);
447	return;	447	return;
448	}	448	}
449		449
450	ipc_forward_fast(callid, dev->driver->phone, dev->handle,	450	ipc_forward_fast(callid, dev->driver->phone, dev->handle,
451	IPC_GET_ARG3(*call), 0, IPC_FF_NONE);	451	IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
452	}	452	}
453		453
454	/** Find handle for device instance identified by name.	454	/** Find handle for device instance identified by name.
455	*	455	*
456	* In answer will be send EOK and device handle in arg1 or a error	456	* In answer will be send EOK and device handle in arg1 or a error
457	* code from errno.h.	457	* code from errno.h.
458	*	458	*
459	*/	459	*/
460	static void devmap_get_handle(ipc_callid_t iid, ipc_call_t *icall)	460	static void devmap_get_handle(ipc_callid_t iid, ipc_call_t *icall)
461	{	461	{
462	/*	462	/*
463	* Wait for incoming message with device name (but do not	463	* Wait for incoming message with device name (but do not
464	* read the name itself until the buffer is allocated).	464	* read the name itself until the buffer is allocated).
465	*/	465	*/
466	ipc_callid_t callid;	466	ipc_callid_t callid;
467	size_t size;	467	size_t size;
468	if (!ipc_data_write_receive(&callid, &size)) {	468	if (!ipc_data_write_receive(&callid, &size)) {
469	ipc_answer_0(callid, EREFUSED);	469	ipc_answer_0(callid, EREFUSED);
470	ipc_answer_0(iid, EREFUSED);	470	ipc_answer_0(iid, EREFUSED);
471	return;	471	return;
472	}	472	}
473		473
474	if ((size < 1) \|\| (size > DEVMAP_NAME_MAXLEN)) {	474	if ((size < 1) \|\| (size > DEVMAP_NAME_MAXLEN)) {
475	ipc_answer_0(callid, EINVAL);	475	ipc_answer_0(callid, EINVAL);
476	ipc_answer_0(iid, EREFUSED);	476	ipc_answer_0(iid, EREFUSED);
477	return;	477	return;
478	}	478	}
479		479
480	/*	480	/*
481	* Allocate buffer for device name.	481	* Allocate buffer for device name.
482	*/	482	*/
483	char name = (char ) malloc(size + 1);	483	char name = (char ) malloc(size + 1);
484	if (name == NULL) {	484	if (name == NULL) {
485	ipc_answer_0(callid, ENOMEM);	485	ipc_answer_0(callid, ENOMEM);
486	ipc_answer_0(iid, EREFUSED);	486	ipc_answer_0(iid, EREFUSED);
487	return;	487	return;
488	}	488	}
489		489
490	/*	490	/*
491	* Send confirmation to sender and get data into buffer.	491	* Send confirmation to sender and get data into buffer.
492	*/	492	*/
493	ipcarg_t retval = ipc_data_write_finalize(callid, name, size);	493	ipcarg_t retval = ipc_data_write_finalize(callid, name, size);
494	if (retval != EOK) {	494	if (retval != EOK) {
495	ipc_answer_0(iid, EREFUSED);	495	ipc_answer_0(iid, EREFUSED);
496	free(name);	496	free(name);
497	return;	497	return;
498	}	498	}
499	name[size] = '\0';	499	name[size] = '\0';
500		500

Subversion Repositories HelenOS

(root)/branches/dd/uspace/srv/devmap/devmap.c – Rev 4668 → 4688