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

Subversion Repositories HelenOS

(root)/branches/dynload/uspace/srv/devmap/devmap.c – Rev 2927 → 3150