WebSVN – HelenOS – Diff – /trunk/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 <stdlib.h>
#include <string.h>
 
#include "devmap.h"
 
 
LIST_INITIALIZE(devices_list);
LIST_INITIALIZE(drivers_list);
 
/* order of locking:
 * drivers_list_futex
 * devices_list_futex
 * (devmap_driver_t *)->devices_futex
 * create_handle_futex
 **/
 
static atomic_t devices_list_futex = FUTEX_INITIALIZER;
static atomic_t drivers_list_futex = FUTEX_INITIALIZER;
static atomic_t create_handle_futex = FUTEX_INITIALIZER;
 
 
static int 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 */
    /* FIXME: overflow */
    futex_down(&create_handle_futex);  
 
    last_handle += 1;
    handle = last_handle;
 
    futex_up(&create_handle_futex);
 
    return handle;
}
 
 
/** Initialize device mapper.
 *
 *
 */
static int devmap_init()
{
    /* TODO: */
 
    return EOK;
}
 
/** Find device with given name.
 *
 */
static devmap_device_t *devmap_device_find_name(const char *name)
{
    link_t *item;
    devmap_device_t *device = NULL;
 
    item = devices_list.next;
 
    while (item != &devices_list) {
 
        device = list_get_instance(item, devmap_device_t, devices);
        if (0 == strcmp(device->name, name)) {
            break;
        }
        item = item->next;
    }
 
    if (item == &devices_list) {
        printf("DEVMAP: no device named %s.\n", name);
        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)
{
    link_t *item;
    devmap_device_t *device = NULL;
   
    futex_down(&devices_list_futex);
 
    item = (&devices_list)->next;
 
    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);
        return NULL;
    }
 
    device = list_get_instance(item, devmap_device_t, devices);
   
    futex_up(&devices_list_futex);
 
    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)
{
    size_t name_size;
    ipc_callid_t callid;
    ipc_call_t call;
    devmap_driver_t *driver;
    ipc_callid_t iid;
    ipc_call_t icall;
 
    *odriver = NULL;
   
    iid = async_get_call(&icall);
 
    if (IPC_GET_METHOD(icall) != DEVMAP_DRIVER_REGISTER) {
        ipc_answer_0(iid, EREFUSED);
        return;
    }
 
    if (NULL ==
        (driver = (devmap_driver_t *)malloc(sizeof(devmap_driver_t)))) {
        ipc_answer_0(iid, ENOMEM);
        return;
    }
 
    /*
     * Get driver name
     */
    if (!ipc_data_receive(&callid, NULL, &name_size)) {
        printf("Unexpected request.\n");
        free(driver);
        ipc_answer_0(callid, EREFUSED);
        ipc_answer_0(iid, EREFUSED);
        return;
    }
 
    if (name_size > DEVMAP_NAME_MAXLEN) {
        printf("Too logn name: %u: maximum is %u.\n", name_size,
            DEVMAP_NAME_MAXLEN);
        free(driver);
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(iid, EREFUSED);
        return;
    }
 
    /*
     * Allocate buffer for device name.
     */
    if (NULL == (driver->name = (char *)malloc(name_size + 1))) {
        printf("Cannot allocate space for driver name.\n");
        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_deliver(callid, driver->name, name_size)) {
        printf("Cannot read driver name.\n");
        free(driver->name);
        free(driver);
        ipc_answer_0(iid, EREFUSED);
        return;
    }
 
    driver->name[name_size] = 0;
 
    printf("Read driver name: '%s'.\n", driver->name);
 
    /* Initialize futex for list of devices owned by this driver */
    futex_initialize(&(driver->devices_futex), 1);
 
    /*
     * Initialize list of asociated devices
     */
    list_initialize(&(driver->devices));
 
    /*
     * Create connection to the driver
     */
    callid = async_get_call(&call);
 
    if (IPC_M_CONNECT_TO_ME != IPC_GET_METHOD(call)) {
        printf("DEVMAP: Unexpected method: %u.\n",
            IPC_GET_METHOD(call));
        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);   
   
    /* TODO:
     * check that no driver with name equal to driver->name is registered
     */
 
    /*
     * Insert new driver into list of registered drivers
     */
    list_append(&(driver->drivers), &drivers_list);
    futex_up(&drivers_list_futex); 
   
    ipc_answer_0(iid, EOK);
    printf("Driver registered.\n");
 
    *odriver = driver;
    return;
}
 
/** Unregister device driver, unregister all its devices and free driver
 * structure.
 */
static int devmap_driver_unregister(devmap_driver_t *driver)
{
    devmap_device_t *device;
 
    if (NULL == driver) {
        printf("Error: driver == NULL.\n");
        return EEXISTS;
    }
 
    printf("Unregister driver '%s'.\n", driver->name);
    futex_down(&drivers_list_futex);   
 
    ipc_hangup(driver->phone);
   
    /* remove it from list of drivers */
    list_remove(&(driver->drivers));
 
    /* unregister all its devices */
   
    futex_down(&devices_list_futex);   
    futex_down(&(driver->devices_futex));
 
    while (!list_empty(&(driver->devices))) {
        device = list_get_instance(driver->devices.next,
            devmap_device_t, driver_devices);
        printf("Unregister device '%s'.\n", device->name);
        devmap_device_unregister_core(device);
    }
   
    futex_up(&(driver->devices_futex));
    futex_up(&devices_list_futex); 
    futex_up(&drivers_list_futex); 
 
    /* free name and driver */
    if (NULL != driver->name) {
        free(driver->name);
    }
 
    free(driver);
 
    printf("Driver unregistered.\n");
 
    return EOK;
}
 
 
/** Register instance of device
 *
 */
static void devmap_device_register(ipc_callid_t iid, ipc_call_t *icall,
    devmap_driver_t *driver)
{
    ipc_callid_t callid;
    size_t size;
    devmap_device_t *device;
 
    if (NULL == driver) {
        printf("Invalid driver registration.\n");
        ipc_answer_0(iid, EREFUSED);
        return;
    }
   
    /* Create new device entry */
    if (NULL ==
        (device = (devmap_device_t *)malloc(sizeof(devmap_device_t)))) {
        printf("Cannot allocate new device.\n");
        ipc_answer_0(iid, ENOMEM);
        return;
    }
   
    /* Get device name */
    if (!ipc_data_receive(&callid, NULL, &size)) {
        free(device);
        printf("Cannot read device name.\n");
        ipc_answer_0(iid, EREFUSED);
        return;
    }
 
    if (size > DEVMAP_NAME_MAXLEN) {
        printf("Too long device name: %u.\n", size);
        free(device);
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(iid, EREFUSED);
        return;
    }
 
        /* +1 for terminating \0 */
    device->name = (char *)malloc(size + 1);
 
    if (NULL == device->name) {
        printf("Cannot read device name.\n");
        free(device);
        ipc_answer_0(callid, ENOMEM);
        ipc_answer_0(iid, EREFUSED);
        return;
    }
   
    ipc_data_deliver(callid, device->name, size);
    device->name[size] = 0;
 
    list_initialize(&(device->devices));
    list_initialize(&(device->driver_devices));
 
    futex_down(&devices_list_futex);   
 
    /* Check that device with such name is not already registered */
    if (NULL != devmap_device_find_name(device->name)) {
        printf("Device '%s' already registered.\n", device->name);
        futex_up(&devices_list_futex); 
        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);
   
    list_append(&device->driver_devices, &device->driver->devices);
   
    futex_up(&device->driver->devices_futex);  
    futex_up(&devices_list_futex); 
 
    printf("Device '%s' registered.\n", device->name); 
    ipc_answer_1(iid, EOK, device->handle);
 
    return;
}
 
/**
 *
 */
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)
{
    devmap_device_t *dev;
    int handle;
 
    /*
     * Get handle from request
     */
    handle = IPC_GET_ARG2(*call);
    dev = devmap_device_find_handle(handle);
 
    if (NULL == dev) {
        printf("DEVMAP: No registered device with handle %d.\n",
            handle);
        ipc_answer_0(callid, ENOENT);
        return;
    }
 
    ipc_forward_fast(callid, dev->driver->phone, (ipcarg_t)(dev->handle),
        IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
    return;
}
 
/** 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)
{
    char *name = NULL;
    size_t name_size;
    const devmap_device_t *dev;
    ipc_callid_t callid;
    ipcarg_t retval;
   
   
    /*
     * Wait for incoming message with device name (but do not
     * read the name itself until the buffer is allocated).
     */
    if (!ipc_data_receive(&callid, NULL, &name_size)) {
        ipc_answer_0(callid, EREFUSED);
        ipc_answer_0(iid, EREFUSED);
        return;
    }
 
    if (name_size > DEVMAP_NAME_MAXLEN) {
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(iid, EREFUSED);
        return;
    }
 
    /*
     * Allocate buffer for device name.
     */
    if (NULL == (name = (char *)malloc(name_size))) {
        ipc_answer_0(callid, ENOMEM);
        ipc_answer_0(iid, EREFUSED);
        return;
    }  
 
    /*
     * Send confirmation to sender and get data into buffer.
     */
    if (EOK != (retval = ipc_data_deliver(callid, name, name_size))) {
        ipc_answer_0(iid, EREFUSED);
        return;
    }
 
    /*
     * Find device name in linked list of known devices.
     */
    dev = devmap_device_find_name(name);
 
    /*
     * Device was not found.
     */
    if (NULL == dev) {
        printf("DEVMAP: device %s has not been registered.\n", name);
        ipc_answer_0(iid, ENOENT);
        return;
    }
 
    printf("DEVMAP: device %s has handler %d.\n", name, dev->handle);
       
    ipc_answer_1(iid, EOK, dev->handle);
 
    return;
}
 
/** 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;
    size_t name_size;
 
    device = devmap_device_find_handle(IPC_GET_ARG1(*icall));
 
    /*
     * Device not found.
     */
    if (NULL == device) {
        ipc_answer_0(iid, ENOENT);
        return;
    }  
 
    ipc_answer_0(iid, EOK);
 
    name_size = strlen(device->name);
 
 
/*  FIXME:
    we have no channel from DEVMAP to client ->
    sending must be initiated by client
 
    int rc = ipc_data_send(phone, device->name, name_size);
    if (rc != EOK) {
        async_wait_for(req, NULL);
        return rc;
    }
*/ 
    /* TODO: send name in response */
 
    return;
}
 
/** Handle connection with device driver.
 *
 */
static void
devmap_connection_driver(ipc_callid_t iid, ipc_call_t *icall)
{
    ipc_callid_t callid;
    ipc_call_t call;
    bool cont = true;
    devmap_driver_t *driver = NULL;
 
    ipc_answer_0(iid, EOK);
 
    devmap_driver_register(&driver);
 
    if (NULL == driver) {
        printf("DEVMAP: driver registration failed.\n");
        return;
    }
   
    while (cont) {
        callid = async_get_call(&call);
 
        switch (IPC_GET_METHOD(call)) {
        case IPC_M_PHONE_HUNGUP:
            printf("DEVMAP: connection hung up.\n");
            cont = false;
            continue; /* Exit thread */
        case DEVMAP_DRIVER_UNREGISTER:
            printf("DEVMAP: unregister driver.\n");
            if (NULL == driver) {
                printf("DEVMAP: driver was not registered!\n");
                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);
            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)
{
    ipc_callid_t callid;
    ipc_call_t call;
    bool cont = true;
 
    ipc_answer_0(iid, EOK); /* Accept connection */
 
    while (cont) {
        callid = async_get_call(&call);
 
        switch (IPC_GET_METHOD(call)) {
        case IPC_M_PHONE_HUNGUP:
            printf("DEVMAP: connection hung up.\n");
            cont = false;
            continue; /* Exit thread */
 
        case DEVMAP_DEVICE_GET_HANDLE:
            devmap_get_handle(callid, &call);
 
            break;
        case DEVMAP_DEVICE_GET_NAME:
            /* TODO */
            devmap_get_name(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)
{
 
    printf("DEVMAP: new connection.\n");
 
        /* 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 */
        printf("DEVMAP: connect to device %d.\n",
            IPC_GET_ARG2(*icall));
        devmap_forward(iid, icall);
        break;
    default:
        ipc_answer_0(iid, ENOENT); /* No such interface */
        printf("DEVMAP: Unknown interface %u.\n",
            (ipcarg_t)(IPC_GET_ARG1(*icall)));
    }
 
    /* Cleanup */
   
    printf("DEVMAP: connection closed.\n");
    return;
}
 
/**
 *
 */
int main(int argc, char *argv[])
{
    ipcarg_t phonead;
 
    printf("DEVMAP: HelenOS device mapper.\n");
 
    if (devmap_init() != 0) {
        printf("Error while initializing DEVMAP service.\n");
        return -1;
    }
 
        /* Set a handler of incomming connections */
    async_set_client_connection(devmap_connection);
 
    /* Register device mapper at naming service */
    if (ipc_connect_to_me(PHONE_NS, SERVICE_DEVMAP, 0, 0, &phonead) != 0)
        return -1;
   
    async_manager();
    /* Never reached */
    return 0;
}
 
/**
 * @}
 */
 
 

Rev 2635	Rev 2637
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 <futex.h>	44	#include <futex.h>
45	#include <stdlib.h>	45	#include <stdlib.h>
46	#include <string.h>	46	#include <string.h>
47		47
48	#include "devmap.h"	48	#include "devmap.h"
49		49
50		50
51	LIST_INITIALIZE(devices_list);	51	LIST_INITIALIZE(devices_list);
52	LIST_INITIALIZE(drivers_list);	52	LIST_INITIALIZE(drivers_list);
53		53
54	/* order of locking:	54	/* order of locking:
55	* drivers_list_futex	55	* drivers_list_futex
56	* devices_list_futex	56	* devices_list_futex
57	* (devmap_driver_t *)->devices_futex	57	* (devmap_driver_t *)->devices_futex
58	* create_handle_futex	58	* create_handle_futex
59	**/	59	**/
60		60
61	static atomic_t devices_list_futex = FUTEX_INITIALIZER;	61	static atomic_t devices_list_futex = FUTEX_INITIALIZER;
62	static atomic_t drivers_list_futex = FUTEX_INITIALIZER;	62	static atomic_t drivers_list_futex = FUTEX_INITIALIZER;
63	static atomic_t create_handle_futex = FUTEX_INITIALIZER;	63	static atomic_t create_handle_futex = FUTEX_INITIALIZER;
64		64
65		65
66	static int devmap_create_handle(void)	66	static int devmap_create_handle(void)
67	{	67	{
68	static int last_handle = 0;	68	static int last_handle = 0;
69	int handle;	69	int handle;
70		70
71	/* TODO: allow reusing old handles after their unregistration	71	/* TODO: allow reusing old handles after their unregistration
72	and implement some version of LRU algorithm */	72	and implement some version of LRU algorithm */
73	/* FIXME: overflow */	73	/* FIXME: overflow */
74	futex_down(&create_handle_futex);	74	futex_down(&create_handle_futex);
75		75
76	last_handle += 1;	76	last_handle += 1;
77	handle = last_handle;	77	handle = last_handle;
78		78
79	futex_up(&create_handle_futex);	79	futex_up(&create_handle_futex);
80		80
81	return handle;	81	return handle;
82	}	82	}
83		83
84		84
85	/** Initialize device mapper.	85	/** Initialize device mapper.
86	*	86	*
87	*	87	*
88	*/	88	*/
89	static int devmap_init()	89	static int devmap_init()
90	{	90	{
91	/* TODO: */	91	/* TODO: */
92		92
93	return EOK;	93	return EOK;
94	}	94	}
95		95
96	/** Find device with given name.	96	/** Find device with given name.
97	*	97	*
98	*/	98	*/
99	static devmap_device_t devmap_device_find_name(const char name)	99	static devmap_device_t devmap_device_find_name(const char name)
100	{	100	{
101	link_t *item;	101	link_t *item;
102	devmap_device_t *device = NULL;	102	devmap_device_t *device = NULL;
103		103
104	item = devices_list.next;	104	item = devices_list.next;
105		105
106	while (item != &devices_list) {	106	while (item != &devices_list) {
107		107
108	device = list_get_instance(item, devmap_device_t, devices);	108	device = list_get_instance(item, devmap_device_t, devices);
109	if (0 == strcmp(device->name, name)) {	109	if (0 == strcmp(device->name, name)) {
110	break;	110	break;
111	}	111	}
112	item = item->next;	112	item = item->next;
113	}	113	}
114		114
115	if (item == &devices_list) {	115	if (item == &devices_list) {
116	printf("DEVMAP: no device named %s.\n", name);	116	printf("DEVMAP: no device named %s.\n", name);
117	return NULL;	117	return NULL;
118	}	118	}
119		119
120	device = list_get_instance(item, devmap_device_t, devices);	120	device = list_get_instance(item, devmap_device_t, devices);
121	return device;	121	return device;
122	}	122	}
123		123
124	/** Find device with given handle.	124	/** Find device with given handle.
125	* @todo: use hash table	125	* @todo: use hash table
126	*/	126	*/
127	static devmap_device_t *devmap_device_find_handle(int handle)	127	static devmap_device_t *devmap_device_find_handle(int handle)
128	{	128	{
129	link_t *item;	129	link_t *item;
130	devmap_device_t *device = NULL;	130	devmap_device_t *device = NULL;
131		131
132	futex_down(&devices_list_futex);	132	futex_down(&devices_list_futex);
133		133
134	item = (&devices_list)->next;	134	item = (&devices_list)->next;
135		135
136	while (item != &devices_list) {	136	while (item != &devices_list) {
137		137
138	device = list_get_instance(item, devmap_device_t, devices);	138	device = list_get_instance(item, devmap_device_t, devices);
139	if (device->handle == handle) {	139	if (device->handle == handle) {
140	break;	140	break;
141	}	141	}
142	item = item->next;	142	item = item->next;
143	}	143	}
144		144
145	if (item == &devices_list) {	145	if (item == &devices_list) {
146	futex_up(&devices_list_futex);	146	futex_up(&devices_list_futex);
147	return NULL;	147	return NULL;
148	}	148	}
149		149
150	device = list_get_instance(item, devmap_device_t, devices);	150	device = list_get_instance(item, devmap_device_t, devices);
151		151
152	futex_up(&devices_list_futex);	152	futex_up(&devices_list_futex);
153		153
154	return device;	154	return device;
155	}	155	}
156		156
157	/**	157	/**
158	* Unregister device and free it. It's assumed that driver's device list is	158	* Unregister device and free it. It's assumed that driver's device list is
159	* already locked.	159	* already locked.
160	*/	160	*/
161	static int devmap_device_unregister_core(devmap_device_t *device)	161	static int devmap_device_unregister_core(devmap_device_t *device)
162	{	162	{
163		163
164	list_remove(&(device->devices));	164	list_remove(&(device->devices));
165	list_remove(&(device->driver_devices));	165	list_remove(&(device->driver_devices));
166		166
167	free(device->name);	167	free(device->name);
168	free(device);	168	free(device);
169		169
170		170
171	return EOK;	171	return EOK;
172	}	172	}
173		173
174	/**	174	/**
175	* Read info about new driver and add it into linked list of registered	175	* Read info about new driver and add it into linked list of registered
176	* drivers.	176	* drivers.
177	*/	177	*/
178	static void devmap_driver_register(devmap_driver_t **odriver)	178	static void devmap_driver_register(devmap_driver_t **odriver)
179	{	179	{
180	size_t name_size;	180	size_t name_size;
181	ipc_callid_t callid;	181	ipc_callid_t callid;
182	ipc_call_t call;	182	ipc_call_t call;
183	devmap_driver_t *driver;	183	devmap_driver_t *driver;
184	ipc_callid_t iid;	184	ipc_callid_t iid;
185	ipc_call_t icall;	185	ipc_call_t icall;
186		186
187	*odriver = NULL;	187	*odriver = NULL;
188		188
189	iid = async_get_call(&icall);	189	iid = async_get_call(&icall);
190		190
191	if (IPC_GET_METHOD(icall) != DEVMAP_DRIVER_REGISTER) {	191	if (IPC_GET_METHOD(icall) != DEVMAP_DRIVER_REGISTER) {
192	ipc_answer_0(iid, EREFUSED);	192	ipc_answer_0(iid, EREFUSED);
193	return;	193	return;
194	}	194	}
195		195
196	if (NULL ==	196	if (NULL ==
197	(driver = (devmap_driver_t *)malloc(sizeof(devmap_driver_t)))) {	197	(driver = (devmap_driver_t *)malloc(sizeof(devmap_driver_t)))) {
198	ipc_answer_0(iid, ENOMEM);	198	ipc_answer_0(iid, ENOMEM);
199	return;	199	return;
200	}	200	}
201		201
202	/*	202	/*
203	* Get driver name	203	* Get driver name
204	*/	204	*/
205	if (!ipc_data_receive(&callid, NULL, &name_size)) {	205	if (!ipc_data_receive(&callid, NULL, &name_size)) {
206	printf("Unexpected request.\n");	206	printf("Unexpected request.\n");
207	free(driver);	207	free(driver);
208	ipc_answer_0(callid, EREFUSED);	208	ipc_answer_0(callid, EREFUSED);
209	ipc_answer_0(iid, EREFUSED);	209	ipc_answer_0(iid, EREFUSED);
210	return;	210	return;
211	}	211	}
212		212
213	if (name_size > DEVMAP_NAME_MAXLEN) {	213	if (name_size > DEVMAP_NAME_MAXLEN) {
214	printf("Too logn name: %u: maximum is %u.\n", name_size,	214	printf("Too logn name: %u: maximum is %u.\n", name_size,
215	DEVMAP_NAME_MAXLEN);	215	DEVMAP_NAME_MAXLEN);
216	free(driver);	216	free(driver);
217	ipc_answer_0(callid, EINVAL);	217	ipc_answer_0(callid, EINVAL);
218	ipc_answer_0(iid, EREFUSED);	218	ipc_answer_0(iid, EREFUSED);
219	return;	219	return;
220	}	220	}
221		221
222	/*	222	/*
223	* Allocate buffer for device name.	223	* Allocate buffer for device name.
224	*/	224	*/
225	if (NULL == (driver->name = (char *)malloc(name_size + 1))) {	225	if (NULL == (driver->name = (char *)malloc(name_size + 1))) {
226	printf("Cannot allocate space for driver name.\n");	226	printf("Cannot allocate space for driver name.\n");
227	free(driver);	227	free(driver);
228	ipc_answer_0(callid, ENOMEM);	228	ipc_answer_0(callid, ENOMEM);
229	ipc_answer_0(iid, EREFUSED);	229	ipc_answer_0(iid, EREFUSED);
230	return;	230	return;
231	}	231	}
232		232
233	/*	233	/*
234	* Send confirmation to sender and get data into buffer.	234	* Send confirmation to sender and get data into buffer.
235	*/	235	*/
236	if (EOK != ipc_data_deliver(callid, driver->name, name_size)) {	236	if (EOK != ipc_data_deliver(callid, driver->name, name_size)) {
237	printf("Cannot read driver name.\n");	237	printf("Cannot read driver name.\n");
238	free(driver->name);	238	free(driver->name);
239	free(driver);	239	free(driver);
240	ipc_answer_0(iid, EREFUSED);	240	ipc_answer_0(iid, EREFUSED);
241	return;	241	return;
242	}	242	}
243		243
244	driver->name[name_size] = 0;	244	driver->name[name_size] = 0;
245		245
246	printf("Read driver name: '%s'.\n", driver->name);	246	printf("Read driver name: '%s'.\n", driver->name);
247		247
248	/* Initialize futex for list of devices owned by this driver */	248	/* Initialize futex for list of devices owned by this driver */
249	futex_initialize(&(driver->devices_futex), 1);	249	futex_initialize(&(driver->devices_futex), 1);
250		250
251	/*	251	/*
252	* Initialize list of asociated devices	252	* Initialize list of asociated devices
253	*/	253	*/
254	list_initialize(&(driver->devices));	254	list_initialize(&(driver->devices));
255		255
256	/*	256	/*
257	* Create connection to the driver	257	* Create connection to the driver
258	*/	258	*/
259	callid = async_get_call(&call);	259	callid = async_get_call(&call);
260		260
261	if (IPC_M_CONNECT_TO_ME != IPC_GET_METHOD(call)) {	261	if (IPC_M_CONNECT_TO_ME != IPC_GET_METHOD(call)) {
262	printf("DEVMAP: Unexpected method: %u.\n",	262	printf("DEVMAP: Unexpected method: %u.\n",
263	IPC_GET_METHOD(call));	263	IPC_GET_METHOD(call));
264	ipc_answer_0(callid, ENOTSUP);	264	ipc_answer_0(callid, ENOTSUP);
265		265
266	free(driver->name);	266	free(driver->name);
267	free(driver);	267	free(driver);
268	ipc_answer_0(iid, ENOTSUP);	268	ipc_answer_0(iid, ENOTSUP);
269	return;	269	return;
270	}	270	}
271		271
272	driver->phone = IPC_GET_ARG3(call);	272	driver->phone = IPC_GET_ARG5(call);
273		273
274	ipc_answer_0(callid, EOK);	274	ipc_answer_0(callid, EOK);
275		275
276	list_initialize(&(driver->drivers));	276	list_initialize(&(driver->drivers));
277		277
278	futex_down(&drivers_list_futex);	278	futex_down(&drivers_list_futex);
279		279
280	/* TODO:	280	/* TODO:
281	* check that no driver with name equal to driver->name is registered	281	* check that no driver with name equal to driver->name is registered
282	*/	282	*/
283		283
284	/*	284	/*
285	* Insert new driver into list of registered drivers	285	* Insert new driver into list of registered drivers
286	*/	286	*/
287	list_append(&(driver->drivers), &drivers_list);	287	list_append(&(driver->drivers), &drivers_list);
288	futex_up(&drivers_list_futex);	288	futex_up(&drivers_list_futex);
289		289
290	ipc_answer_0(iid, EOK);	290	ipc_answer_0(iid, EOK);
291	printf("Driver registered.\n");	291	printf("Driver registered.\n");
292		292
293	*odriver = driver;	293	*odriver = driver;
294	return;	294	return;
295	}	295	}
296		296
297	/** Unregister device driver, unregister all its devices and free driver	297	/** Unregister device driver, unregister all its devices and free driver
298	* structure.	298	* structure.
299	*/	299	*/
300	static int devmap_driver_unregister(devmap_driver_t *driver)	300	static int devmap_driver_unregister(devmap_driver_t *driver)
301	{	301	{
302	devmap_device_t *device;	302	devmap_device_t *device;
303		303
304	if (NULL == driver) {	304	if (NULL == driver) {
305	printf("Error: driver == NULL.\n");	305	printf("Error: driver == NULL.\n");
306	return EEXISTS;	306	return EEXISTS;
307	}	307	}
308		308
309	printf("Unregister driver '%s'.\n", driver->name);	309	printf("Unregister driver '%s'.\n", driver->name);
310	futex_down(&drivers_list_futex);	310	futex_down(&drivers_list_futex);
311		311
312	ipc_hangup(driver->phone);	312	ipc_hangup(driver->phone);
313		313
314	/* remove it from list of drivers */	314	/* remove it from list of drivers */
315	list_remove(&(driver->drivers));	315	list_remove(&(driver->drivers));
316		316
317	/* unregister all its devices */	317	/* unregister all its devices */
318		318
319	futex_down(&devices_list_futex);	319	futex_down(&devices_list_futex);
320	futex_down(&(driver->devices_futex));	320	futex_down(&(driver->devices_futex));
321		321
322	while (!list_empty(&(driver->devices))) {	322	while (!list_empty(&(driver->devices))) {
323	device = list_get_instance(driver->devices.next,	323	device = list_get_instance(driver->devices.next,
324	devmap_device_t, driver_devices);	324	devmap_device_t, driver_devices);
325	printf("Unregister device '%s'.\n", device->name);	325	printf("Unregister device '%s'.\n", device->name);
326	devmap_device_unregister_core(device);	326	devmap_device_unregister_core(device);
327	}	327	}
328		328
329	futex_up(&(driver->devices_futex));	329	futex_up(&(driver->devices_futex));
330	futex_up(&devices_list_futex);	330	futex_up(&devices_list_futex);
331	futex_up(&drivers_list_futex);	331	futex_up(&drivers_list_futex);
332		332
333	/* free name and driver */	333	/* free name and driver */
334	if (NULL != driver->name) {	334	if (NULL != driver->name) {
335	free(driver->name);	335	free(driver->name);
336	}	336	}
337		337
338	free(driver);	338	free(driver);
339		339
340	printf("Driver unregistered.\n");	340	printf("Driver unregistered.\n");
341		341
342	return EOK;	342	return EOK;
343	}	343	}
344		344
345		345
346	/** Register instance of device	346	/** Register instance of device
347	*	347	*
348	*/	348	*/
349	static void devmap_device_register(ipc_callid_t iid, ipc_call_t *icall,	349	static void devmap_device_register(ipc_callid_t iid, ipc_call_t *icall,
350	devmap_driver_t *driver)	350	devmap_driver_t *driver)
351	{	351	{
352	ipc_callid_t callid;	352	ipc_callid_t callid;
353	size_t size;	353	size_t size;
354	devmap_device_t *device;	354	devmap_device_t *device;
355		355
356	if (NULL == driver) {	356	if (NULL == driver) {
357	printf("Invalid driver registration.\n");	357	printf("Invalid driver registration.\n");
358	ipc_answer_0(iid, EREFUSED);	358	ipc_answer_0(iid, EREFUSED);
359	return;	359	return;
360	}	360	}
361		361
362	/* Create new device entry */	362	/* Create new device entry */
363	if (NULL ==	363	if (NULL ==
364	(device = (devmap_device_t *)malloc(sizeof(devmap_device_t)))) {	364	(device = (devmap_device_t *)malloc(sizeof(devmap_device_t)))) {
365	printf("Cannot allocate new device.\n");	365	printf("Cannot allocate new device.\n");
366	ipc_answer_0(iid, ENOMEM);	366	ipc_answer_0(iid, ENOMEM);
367	return;	367	return;
368	}	368	}
369		369
370	/* Get device name */	370	/* Get device name */
371	if (!ipc_data_receive(&callid, NULL, &size)) {	371	if (!ipc_data_receive(&callid, NULL, &size)) {
372	free(device);	372	free(device);
373	printf("Cannot read device name.\n");	373	printf("Cannot read device name.\n");
374	ipc_answer_0(iid, EREFUSED);	374	ipc_answer_0(iid, EREFUSED);
375	return;	375	return;
376	}	376	}
377		377
378	if (size > DEVMAP_NAME_MAXLEN) {	378	if (size > DEVMAP_NAME_MAXLEN) {
379	printf("Too long device name: %u.\n", size);	379	printf("Too long device name: %u.\n", size);
380	free(device);	380	free(device);
381	ipc_answer_0(callid, EINVAL);	381	ipc_answer_0(callid, EINVAL);
382	ipc_answer_0(iid, EREFUSED);	382	ipc_answer_0(iid, EREFUSED);
383	return;	383	return;
384	}	384	}
385		385
386	/* +1 for terminating \0 */	386	/* +1 for terminating \0 */
387	device->name = (char *)malloc(size + 1);	387	device->name = (char *)malloc(size + 1);
388		388
389	if (NULL == device->name) {	389	if (NULL == device->name) {
390	printf("Cannot read device name.\n");	390	printf("Cannot read device name.\n");
391	free(device);	391	free(device);
392	ipc_answer_0(callid, ENOMEM);	392	ipc_answer_0(callid, ENOMEM);
393	ipc_answer_0(iid, EREFUSED);	393	ipc_answer_0(iid, EREFUSED);
394	return;	394	return;
395	}	395	}
396		396
397	ipc_data_deliver(callid, device->name, size);	397	ipc_data_deliver(callid, device->name, size);
398	device->name[size] = 0;	398	device->name[size] = 0;
399		399
400	list_initialize(&(device->devices));	400	list_initialize(&(device->devices));
401	list_initialize(&(device->driver_devices));	401	list_initialize(&(device->driver_devices));
402		402
403	futex_down(&devices_list_futex);	403	futex_down(&devices_list_futex);
404		404
405	/* Check that device with such name is not already registered */	405	/* Check that device with such name is not already registered */
406	if (NULL != devmap_device_find_name(device->name)) {	406	if (NULL != devmap_device_find_name(device->name)) {
407	printf("Device '%s' already registered.\n", device->name);	407	printf("Device '%s' already registered.\n", device->name);
408	futex_up(&devices_list_futex);	408	futex_up(&devices_list_futex);
409	free(device->name);	409	free(device->name);
410	free(device);	410	free(device);
411	ipc_answer_0(iid, EEXISTS);	411	ipc_answer_0(iid, EEXISTS);
412	return;	412	return;
413	}	413	}
414		414
415	/* Get unique device handle */	415	/* Get unique device handle */
416	device->handle = devmap_create_handle();	416	device->handle = devmap_create_handle();
417		417
418	device->driver = driver;	418	device->driver = driver;
419		419
420	/* Insert device into list of all devices */	420	/* Insert device into list of all devices */
421	list_append(&device->devices, &devices_list);	421	list_append(&device->devices, &devices_list);
422		422
423	/* Insert device into list of devices that belog to one driver */	423	/* Insert device into list of devices that belog to one driver */
424	futex_down(&device->driver->devices_futex);	424	futex_down(&device->driver->devices_futex);
425		425
426	list_append(&device->driver_devices, &device->driver->devices);	426	list_append(&device->driver_devices, &device->driver->devices);
427		427
428	futex_up(&device->driver->devices_futex);	428	futex_up(&device->driver->devices_futex);
429	futex_up(&devices_list_futex);	429	futex_up(&devices_list_futex);
430		430
431	printf("Device '%s' registered.\n", device->name);	431	printf("Device '%s' registered.\n", device->name);
432	ipc_answer_1(iid, EOK, device->handle);	432	ipc_answer_1(iid, EOK, device->handle);
433		433
434	return;	434	return;
435	}	435	}
436		436
437	/**	437	/**
438	*	438	*
439	*/	439	*/
440	static int devmap_device_unregister(ipc_callid_t iid, ipc_call_t *icall,	440	static int devmap_device_unregister(ipc_callid_t iid, ipc_call_t *icall,
441	devmap_driver_t *driver)	441	devmap_driver_t *driver)
442	{	442	{
443	/* TODO */	443	/* TODO */
444		444
445	return EOK;	445	return EOK;
446	}	446	}
447		447
448	/** Connect client to the device.	448	/** Connect client to the device.
449	* Find device driver owning requested device and forward	449	* Find device driver owning requested device and forward
450	* the message to it.	450	* the message to it.
451	*/	451	*/
452	static void devmap_forward(ipc_callid_t callid, ipc_call_t *call)	452	static void devmap_forward(ipc_callid_t callid, ipc_call_t *call)
453	{	453	{
454	devmap_device_t *dev;	454	devmap_device_t *dev;
455	int handle;	455	int handle;
456		456
457	/*	457	/*
458	* Get handle from request	458	* Get handle from request
459	*/	459	*/
460	handle = IPC_GET_ARG2(*call);	460	handle = IPC_GET_ARG2(*call);
461	dev = devmap_device_find_handle(handle);	461	dev = devmap_device_find_handle(handle);
462		462
463	if (NULL == dev) {	463	if (NULL == dev) {
464	printf("DEVMAP: No registered device with handle %d.\n",	464	printf("DEVMAP: No registered device with handle %d.\n",
465	handle);	465	handle);
466	ipc_answer_0(callid, ENOENT);	466	ipc_answer_0(callid, ENOENT);
467	return;	467	return;
468	}	468	}
469		469
470	ipc_forward_fast(callid, dev->driver->phone, (ipcarg_t)(dev->handle),	470	ipc_forward_fast(callid, dev->driver->phone, (ipcarg_t)(dev->handle),
471	IPC_GET_ARG3(*call), 0, IPC_FF_NONE);	471	IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
472	return;	472	return;
473	}	473	}
474		474
475	/** Find handle for device instance identified by name.	475	/** Find handle for device instance identified by name.
476	* In answer will be send EOK and device handle in arg1 or a error	476	* In answer will be send EOK and device handle in arg1 or a error
477	* code from errno.h.	477	* code from errno.h.
478	*/	478	*/
479	static void devmap_get_handle(ipc_callid_t iid, ipc_call_t *icall)	479	static void devmap_get_handle(ipc_callid_t iid, ipc_call_t *icall)
480	{	480	{
481	char *name = NULL;	481	char *name = NULL;
482	size_t name_size;	482	size_t name_size;
483	const devmap_device_t *dev;	483	const devmap_device_t *dev;
484	ipc_callid_t callid;	484	ipc_callid_t callid;
485	ipcarg_t retval;	485	ipcarg_t retval;
486		486
487		487
488	/*	488	/*
489	* Wait for incoming message with device name (but do not	489	* Wait for incoming message with device name (but do not
490	* read the name itself until the buffer is allocated).	490	* read the name itself until the buffer is allocated).
491	*/	491	*/
492	if (!ipc_data_receive(&callid, NULL, &name_size)) {	492	if (!ipc_data_receive(&callid, NULL, &name_size)) {
493	ipc_answer_0(callid, EREFUSED);	493	ipc_answer_0(callid, EREFUSED);
494	ipc_answer_0(iid, EREFUSED);	494	ipc_answer_0(iid, EREFUSED);
495	return;	495	return;
496	}	496	}
497		497
498	if (name_size > DEVMAP_NAME_MAXLEN) {	498	if (name_size > DEVMAP_NAME_MAXLEN) {
499	ipc_answer_0(callid, EINVAL);	499	ipc_answer_0(callid, EINVAL);
500	ipc_answer_0(iid, EREFUSED);	500	ipc_answer_0(iid, EREFUSED);

Subversion Repositories HelenOS

(root)/trunk/uspace/srv/devmap/devmap.c – Rev 2635 → 2637