| /trunk/uspace/app/tester/devmap/devmap1.c |
|---|
| 119,72 → 119,71 |
| */ |
| char * test_devmap1(bool quiet) |
| { |
| int driver_phone; |
| int dev1_handle; |
| int dev2_handle; |
| int dev3_handle; |
| int handle; |
| int rc; |
| const char *retval = NULL; |
| /* Register new driver */ |
| driver_phone = devmap_driver_register("TestDriver", |
| driver_client_connection); |
| if (driver_phone < 0) { |
| return "Error: Cannot register driver.\n"; |
| int rc = devmap_driver_register("TestDriver", driver_client_connection); |
| if (rc < 0) { |
| retval = "Error: Cannot register driver.\n"; |
| goto out; |
| } |
| /* Register new device dev1. */ |
| rc = devmap_device_register(driver_phone, TEST_DEVICE1, &dev1_handle); |
| dev_handle_t dev1_handle; |
| rc = devmap_device_register(TEST_DEVICE1, &dev1_handle); |
| if (rc != EOK) { |
| ipc_hangup(driver_phone); |
| return "Error: cannot register device.\n"; |
| retval = "Error: cannot register device.\n"; |
| goto out; |
| } |
| /* |
| * Get handle for dev2 (Should fail unless device is already registered |
| * by someone else). |
| */ |
| dev_handle_t handle; |
| rc = devmap_device_get_handle(TEST_DEVICE2, &handle, 0); |
| if (rc == EOK) { |
| ipc_hangup(driver_phone); |
| return "Error: got handle for dev2 before it was registered.\n"; |
| retval = "Error: got handle for dev2 before it was registered.\n"; |
| goto out; |
| } |
| /* Register new device dev2. */ |
| rc = devmap_device_register(driver_phone, TEST_DEVICE2, &dev2_handle); |
| dev_handle_t dev2_handle; |
| rc = devmap_device_register(TEST_DEVICE2, &dev2_handle); |
| if (rc != EOK) { |
| ipc_hangup(driver_phone); |
| return "Error: cannot register device dev2.\n"; |
| retval = "Error: cannot register device dev2.\n"; |
| goto out; |
| } |
| /* Register device dev1 again. */ |
| rc = devmap_device_register(driver_phone, TEST_DEVICE1, &dev3_handle); |
| dev_handle_t dev3_handle; |
| rc = devmap_device_register(TEST_DEVICE1, &dev3_handle); |
| if (rc == EOK) { |
| return "Error: dev1 registered twice.\n"; |
| retval = "Error: dev1 registered twice.\n"; |
| goto out; |
| } |
| /* Get handle for dev1. */ |
| rc = devmap_device_get_handle(TEST_DEVICE1, &handle, 0); |
| if (rc != EOK) { |
| ipc_hangup(driver_phone); |
| return "Error: cannot get handle for 'DEVMAP_DEVICE1'.\n"; |
| retval = "Error: cannot get handle for 'DEVMAP_DEVICE1'.\n"; |
| goto out; |
| } |
| if (handle != dev1_handle) { |
| ipc_hangup(driver_phone); |
| return "Error: cannot get handle for 'DEVMAP_DEVICE1'.\n"; |
| retval = "Error: cannot get handle for 'DEVMAP_DEVICE1'.\n"; |
| goto out; |
| } |
| if (device_client(dev1_handle) != EOK) { |
| ipc_hangup(driver_phone); |
| return "Error: failed client test for 'DEVMAP_DEVICE1'.\n"; |
| retval = "Error: failed client test for 'DEVMAP_DEVICE1'.\n"; |
| goto out; |
| } |
| /* TODO: */ |
| ipc_hangup(driver_phone); |
| out: |
| devmap_hangup_phone(DEVMAP_DRIVER); |
| devmap_hangup_phone(DEVMAP_CLIENT); |
| return NULL; |
| } |
| /trunk/uspace/lib/libc/include/devmap.h |
|---|
| 38,14 → 38,18 |
| #include <ipc/devmap.h> |
| #include <async.h> |
| typedef int dev_handle_t; |
| extern int devmap_get_phone(devmap_interface_t, unsigned int); |
| extern void devmap_hangup_phone(devmap_interface_t iface); |
| extern int devmap_driver_register(const char *, async_client_conn_t); |
| extern int devmap_device_get_handle(const char *, dev_handle_t *, |
| unsigned int); |
| extern int devmap_device_register(const char *, dev_handle_t *); |
| extern int devmap_device_get_handle(const char *, dev_handle_t *, unsigned int); |
| extern int devmap_device_connect(dev_handle_t, unsigned int); |
| extern int devmap_device_register(int, const char *, int *); |
| extern ipcarg_t devmap_device_get_count(void); |
| extern ipcarg_t devmap_device_get_devices(ipcarg_t, dev_desc_t *); |
| #endif |
| /** @} |
| /trunk/uspace/lib/libc/include/ipc/devmap.h |
|---|
| 37,8 → 37,10 |
| #include <ipc/ipc.h> |
| #include <libadt/list.h> |
| #define DEVMAP_NAME_MAXLEN 512 |
| #define DEVMAP_NAME_MAXLEN 255 |
| typedef ipcarg_t dev_handle_t; |
| typedef enum { |
| DEVMAP_DRIVER_REGISTER = IPC_FIRST_USER_METHOD, |
| DEVMAP_DRIVER_UNREGISTER, |
| 45,56 → 47,30 |
| DEVMAP_DEVICE_REGISTER, |
| DEVMAP_DEVICE_UNREGISTER, |
| DEVMAP_DEVICE_GET_NAME, |
| DEVMAP_DEVICE_GET_HANDLE |
| DEVMAP_DEVICE_GET_HANDLE, |
| DEVMAP_DEVICE_GET_COUNT, |
| DEVMAP_DEVICE_GET_DEVICES |
| } devmap_request_t; |
| /** 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; |
| /** Futex for list of devices owned by this driver */ |
| atomic_t devices_futex; |
| } devmap_driver_t; |
| /** Info about registered device |
| /** Interface provided by devmap. |
| * |
| */ |
| 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 */ |
| int handle; |
| /** Device name */ |
| char *name; |
| /** Device driver handling this device */ |
| devmap_driver_t *driver; |
| } devmap_device_t; |
| /** Interface provided by devmap. |
| * Every process that connects to devmap must ask one of following |
| * interfaces otherwise connection will be refused. |
| * |
| */ |
| typedef enum { |
| /** Connect as device driver */ |
| DEVMAP_DRIVER = 1, |
| /** Connect as client */ |
| /** Connect as device driver */ |
| DEVMAP_DRIVER = 1, |
| /** Connect as client */ |
| DEVMAP_CLIENT, |
| /** Create new connection to instance of device that |
| * is specified by second argument of call. */ |
| /** Create new connection to instance of device that |
| is specified by second argument of call. */ |
| DEVMAP_CONNECT_TO_DEVICE |
| } devmap_interface_t; |
| typedef struct { |
| dev_handle_t handle; |
| char name[DEVMAP_NAME_MAXLEN + 1]; |
| } dev_desc_t; |
| #endif |
| /trunk/uspace/lib/libc/generic/devmap.c |
|---|
| 35,97 → 35,156 |
| #include <async.h> |
| #include <errno.h> |
| static int devmap_phone = -1; |
| static int devmap_phone_driver = -1; |
| static int devmap_phone_client = -1; |
| /** Get phone to device mapper task. */ |
| static int devmap_get_phone(unsigned int flags) |
| int devmap_get_phone(devmap_interface_t iface, unsigned int flags) |
| { |
| int phone; |
| switch (iface) { |
| case DEVMAP_DRIVER: |
| if (devmap_phone_driver >= 0) |
| return devmap_phone_driver; |
| if (flags & IPC_FLAG_BLOCKING) |
| devmap_phone_driver = ipc_connect_me_to_blocking(PHONE_NS, |
| SERVICE_DEVMAP, DEVMAP_DRIVER, 0); |
| else |
| devmap_phone_driver = ipc_connect_me_to(PHONE_NS, |
| SERVICE_DEVMAP, DEVMAP_DRIVER, 0); |
| return devmap_phone_driver; |
| case DEVMAP_CLIENT: |
| if (devmap_phone_client >= 0) |
| return devmap_phone_client; |
| if (flags & IPC_FLAG_BLOCKING) |
| devmap_phone_client = ipc_connect_me_to_blocking(PHONE_NS, |
| SERVICE_DEVMAP, DEVMAP_CLIENT, 0); |
| else |
| devmap_phone_client = ipc_connect_me_to(PHONE_NS, |
| SERVICE_DEVMAP, DEVMAP_CLIENT, 0); |
| return devmap_phone_client; |
| default: |
| return -1; |
| } |
| } |
| if (devmap_phone >= 0) |
| return devmap_phone; |
| if (flags & IPC_FLAG_BLOCKING) { |
| phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP, |
| DEVMAP_CLIENT, 0); |
| } else { |
| phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, |
| DEVMAP_CLIENT, 0); |
| void devmap_hangup_phone(devmap_interface_t iface) |
| { |
| switch (iface) { |
| case DEVMAP_DRIVER: |
| if (devmap_phone_driver >= 0) { |
| ipc_hangup(devmap_phone_driver); |
| devmap_phone_driver = -1; |
| } |
| break; |
| case DEVMAP_CLIENT: |
| if (devmap_phone_client >= 0) { |
| ipc_hangup(devmap_phone_client); |
| devmap_phone_client = -1; |
| } |
| break; |
| default: |
| break; |
| } |
| if (phone < 0) |
| return phone; |
| devmap_phone = phone; |
| return phone; |
| } |
| /** Register new driver with devmap. */ |
| int devmap_driver_register(const char *name, async_client_conn_t conn) |
| { |
| ipcarg_t retval; |
| aid_t req; |
| ipc_call_t answer; |
| int phone; |
| ipcarg_t callback_phonehash; |
| phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP, |
| DEVMAP_DRIVER, 0); |
| if (phone < 0) { |
| int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING); |
| if (phone < 0) |
| return phone; |
| } |
| req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer); |
| retval = ipc_data_write_start(phone, name, str_size(name) + 1); |
| ipc_call_t answer; |
| aid_t req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer); |
| ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1); |
| if (retval != EOK) { |
| async_wait_for(req, NULL); |
| ipc_hangup(phone); |
| return -1; |
| } |
| async_set_client_connection(conn); |
| ipcarg_t callback_phonehash; |
| ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash); |
| async_wait_for(req, &retval); |
| return phone; |
| return retval; |
| } |
| int devmap_device_get_handle(const char *name, dev_handle_t *handle, |
| unsigned int flags) |
| /** Register new device. |
| * |
| * @param name Device name. |
| * @param handle Output: Handle to the created instance of device. |
| * |
| */ |
| int devmap_device_register(const char *name, dev_handle_t *handle) |
| { |
| ipcarg_t retval; |
| aid_t req; |
| int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING); |
| if (phone < 0) |
| return phone; |
| ipc_call_t answer; |
| int phone; |
| aid_t req = async_send_2(phone, DEVMAP_DEVICE_REGISTER, 0, 0, |
| &answer); |
| ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1); |
| if (retval != EOK) { |
| async_wait_for(req, NULL); |
| return retval; |
| } |
| async_wait_for(req, &retval); |
| if (retval != EOK) { |
| if (handle != NULL) |
| *handle = -1; |
| return retval; |
| } |
| if (handle != NULL) |
| *handle = (dev_handle_t) IPC_GET_ARG1(answer); |
| return retval; |
| } |
| phone = devmap_get_phone(flags); |
| int devmap_device_get_handle(const char *name, dev_handle_t *handle, unsigned int flags) |
| { |
| int phone = devmap_get_phone(DEVMAP_CLIENT, flags); |
| if (phone < 0) |
| return phone; |
| req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0, |
| ipc_call_t answer; |
| aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0, |
| &answer); |
| retval = ipc_data_write_start(phone, name, str_size(name) + 1); |
| ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1); |
| if (retval != EOK) { |
| async_wait_for(req, NULL); |
| return retval; |
| } |
| async_wait_for(req, &retval); |
| if (retval != EOK) { |
| if (handle != NULL) |
| *handle = -1; |
| return retval; |
| } |
| if (handle != NULL) |
| *handle = (int) IPC_GET_ARG1(answer); |
| *handle = (dev_handle_t) IPC_GET_ARG1(answer); |
| return retval; |
| } |
| 132,7 → 191,7 |
| int devmap_device_connect(dev_handle_t handle, unsigned int flags) |
| { |
| int phone; |
| if (flags & IPC_FLAG_BLOCKING) { |
| phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP, |
| DEVMAP_CONNECT_TO_DEVICE, handle); |
| 140,40 → 199,46 |
| phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, |
| DEVMAP_CONNECT_TO_DEVICE, handle); |
| } |
| return phone; |
| } |
| /** Register new device. |
| * |
| * @param driver_phone |
| * @param name Device name. |
| * @param handle Output: Handle to the created instance of device. |
| */ |
| int devmap_device_register(int driver_phone, const char *name, int *handle) |
| ipcarg_t devmap_device_get_count(void) |
| { |
| ipcarg_t retval; |
| aid_t req; |
| int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); |
| if (phone < 0) |
| return 0; |
| ipcarg_t count; |
| int retval = ipc_call_sync_0_1(phone, DEVMAP_DEVICE_GET_COUNT, &count); |
| if (retval != EOK) |
| return 0; |
| return count; |
| } |
| ipcarg_t devmap_device_get_devices(ipcarg_t count, dev_desc_t *data) |
| { |
| int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); |
| if (phone < 0) |
| return 0; |
| ipc_call_t answer; |
| req = async_send_2(driver_phone, DEVMAP_DEVICE_REGISTER, 0, 0, |
| &answer); |
| retval = ipc_data_write_start(driver_phone, name, str_size(name) + 1); |
| aid_t req = async_send_0(phone, DEVMAP_DEVICE_GET_DEVICES, &answer); |
| ipcarg_t retval = ipc_data_read_start(phone, data, count * sizeof(dev_desc_t)); |
| if (retval != EOK) { |
| async_wait_for(req, NULL); |
| return retval; |
| return 0; |
| } |
| async_wait_for(req, &retval); |
| if (retval != EOK) { |
| if (handle != NULL) |
| *handle = -1; |
| return retval; |
| } |
| *handle = (int) IPC_GET_ARG1(answer); |
| return retval; |
| if (retval != EOK) |
| return 0; |
| return IPC_GET_ARG1(answer); |
| } |
| /trunk/uspace/srv/bd/gxe_bd/gxe_bd.c |
|---|
| 115,7 → 115,6 |
| static int gxe_bd_init(void) |
| { |
| int driver_phone; |
| dev_handle_t dev_handle; |
| void *vaddr; |
| int rc; |
| 125,7 → 124,6 |
| printf(NAME ": Unable to register driver.\n"); |
| return rc; |
| } |
| driver_phone = rc; |
| rc = pio_enable((void *) dev_physical, sizeof(gxe_bd_t), &vaddr); |
| if (rc != EOK) { |
| 143,9 → 141,9 |
| devbuf = vaddr; |
| rc = devmap_device_register(driver_phone, "disk0", &dev_handle); |
| rc = devmap_device_register("disk0", &dev_handle); |
| if (rc != EOK) { |
| ipc_hangup(driver_phone); |
| devmap_hangup_phone(DEVMAP_DRIVER); |
| printf(NAME ": Unable to register device.\n"); |
| return rc; |
| } |
| /trunk/uspace/srv/rd/rd.c |
|---|
| 112,7 → 112,7 |
| return; |
| } |
| while (1) { |
| while (true) { |
| callid = async_get_call(&call); |
| switch (IPC_GET_METHOD(call)) { |
| case IPC_M_PHONE_HUNGUP: |
| 204,30 → 204,18 |
| printf(NAME ": Found RAM disk at %p, %d bytes\n", rd_ph_addr, rd_size); |
| int driver_phone = devmap_driver_register(NAME, rd_connection); |
| if (driver_phone < 0) { |
| printf(NAME ": Unable to register driver\n"); |
| int rc = devmap_driver_register(NAME, rd_connection); |
| if (rc < 0) { |
| printf(NAME ": Unable to register driver (%d)\n", rc); |
| return false; |
| } |
| dev_handle_t dev_handle; |
| if (devmap_device_register(driver_phone, "initrd", &dev_handle) != EOK) { |
| ipc_hangup(driver_phone); |
| if (devmap_device_register("initrd", &dev_handle) != EOK) { |
| devmap_hangup_phone(DEVMAP_DRIVER); |
| printf(NAME ": Unable to register device\n"); |
| return false; |
| } |
| /* |
| * Create the second device. |
| * We need at least two devices for the sake of testing of non-root |
| * mounts. Of course it would be better to allow the second device |
| * be created dynamically... |
| */ |
| if (devmap_device_register(driver_phone, "spared", &dev_handle) != EOK) { |
| ipc_hangup(driver_phone); |
| printf(NAME ": Unable to register device\n"); |
| return false; |
| } |
| return true; |
| } |
| 248,4 → 236,4 |
| /** |
| * @} |
| */ |
| */ |
| /trunk/uspace/srv/devmap/devmap.c |
|---|
| 48,6 → 48,41 |
| #define NAME "devmap" |
| /** Representation of device driver. |
| * |
| * Each driver is responsible for a set of devices. |
| * |
| */ |
| typedef struct { |
| /** Pointers to previous and next drivers in linked list */ |
| link_t drivers; |
| /** Pointer to the linked list of devices controlled by this driver */ |
| link_t devices; |
| /** Phone asociated with this driver */ |
| ipcarg_t phone; |
| /** Device driver name */ |
| char *name; |
| /** Futex for list of devices owned by this driver */ |
| atomic_t devices_futex; |
| } devmap_driver_t; |
| /** Info about registered device |
| * |
| */ |
| typedef struct { |
| /** Pointer to the previous and next device in the list of all devices */ |
| link_t devices; |
| /** Pointer to the previous and next device in the list of devices |
| owned by one driver */ |
| link_t driver_devices; |
| /** Unique device identifier */ |
| dev_handle_t handle; |
| /** Device name */ |
| char *name; |
| /** Device driver handling this device */ |
| devmap_driver_t *driver; |
| } devmap_device_t; |
| /** Pending lookup structure. */ |
| typedef struct { |
| link_t link; |
| 70,11 → 105,10 |
| static atomic_t drivers_list_futex = FUTEX_INITIALIZER; |
| static atomic_t create_handle_futex = FUTEX_INITIALIZER; |
| static int devmap_create_handle(void) |
| static dev_handle_t last_handle = 0; |
| static dev_handle_t devmap_create_handle(void) |
| { |
| static int last_handle = 0; |
| int handle; |
| /* TODO: allow reusing old handles after their unregistration |
| * and implement some version of LRU algorithm |
| */ |
| 81,27 → 115,12 |
| /* FIXME: overflow */ |
| futex_down(&create_handle_futex); |
| last_handle += 1; |
| handle = last_handle; |
| last_handle++; |
| futex_up(&create_handle_futex); |
| return handle; |
| return last_handle; |
| } |
| /** Initialize device mapper. |
| * |
| * |
| */ |
| static int devmap_init() |
| { |
| /* TODO: */ |
| return EOK; |
| } |
| /** Find device with given name. |
| * |
| */ |
| 129,7 → 148,7 |
| * @todo: use hash table |
| * |
| */ |
| static devmap_device_t *devmap_device_find_handle(int handle) |
| static devmap_device_t *devmap_device_find_handle(dev_handle_t handle) |
| { |
| futex_down(&devices_list_futex); |
| 297,13 → 316,13 |
| futex_down(&drivers_list_futex); |
| ipc_hangup(driver->phone); |
| if (driver->phone != 0) |
| ipc_hangup(driver->phone); |
| /* remove it from list of drivers */ |
| /* Remove it from list of drivers */ |
| list_remove(&(driver->drivers)); |
| /* unregister all its devices */ |
| /* Unregister all its devices */ |
| futex_down(&devices_list_futex); |
| futex_down(&(driver->devices_futex)); |
| 318,7 → 337,7 |
| futex_up(&drivers_list_futex); |
| /* free name and driver */ |
| if (NULL != driver->name) |
| if (driver->name != NULL) |
| free(driver->name); |
| free(driver); |
| 454,15 → 473,15 |
| /* |
| * Get handle from request |
| */ |
| int handle = IPC_GET_ARG2(*call); |
| dev_handle_t handle = IPC_GET_ARG2(*call); |
| devmap_device_t *dev = devmap_device_find_handle(handle); |
| if (NULL == dev) { |
| if ((dev == NULL) || (dev->driver == NULL) || (dev->driver->phone == 0)) { |
| ipc_answer_0(callid, ENOENT); |
| return; |
| } |
| ipc_forward_fast(callid, dev->driver->phone, (ipcarg_t)(dev->handle), |
| ipc_forward_fast(callid, dev->driver->phone, dev->handle, |
| IPC_GET_ARG3(*call), 0, IPC_FF_NONE); |
| } |
| 495,7 → 514,7 |
| /* |
| * Allocate buffer for device name. |
| */ |
| char *name = (char *) malloc(size); |
| char *name = (char *) malloc(size + 1); |
| if (name == NULL) { |
| ipc_answer_0(callid, ENOMEM); |
| ipc_answer_0(iid, EREFUSED); |
| 549,7 → 568,7 |
| /** 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) |
| 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)); |
| 579,6 → 598,99 |
| /* TODO: send name in response */ |
| } |
| static void devmap_get_count(ipc_callid_t iid, ipc_call_t *icall) |
| { |
| futex_down(&devices_list_futex); |
| ipc_answer_1(iid, EOK, list_count(&devices_list)); |
| futex_up(&devices_list_futex); |
| } |
| static void devmap_get_devices(ipc_callid_t iid, ipc_call_t *icall) |
| { |
| futex_down(&devices_list_futex); |
| 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; |
| } |
| count_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; |
| } |
| count_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); |
| futex_up(&devices_list_futex); |
| ipc_answer_1(iid, EOK, pos); |
| } |
| /** Initialize device mapper. |
| * |
| * |
| */ |
| static bool devmap_init() |
| { |
| /* Create NULL device entry */ |
| devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t)); |
| if (device == NULL) |
| return false; |
| device->name = str_dup("null"); |
| if (device->name == NULL) { |
| free(device); |
| return false; |
| } |
| list_initialize(&(device->devices)); |
| list_initialize(&(device->driver_devices)); |
| futex_down(&devices_list_futex); |
| /* Get unique device handle */ |
| device->handle = devmap_create_handle(); |
| device->driver = NULL; |
| /* Insert device into list of all devices */ |
| list_append(&device->devices, &devices_list); |
| futex_up(&devices_list_futex); |
| return true; |
| } |
| /** Handle connection with device driver. |
| * |
| */ |
| 621,7 → 733,7 |
| devmap_get_handle(callid, &call); |
| break; |
| case DEVMAP_DEVICE_GET_NAME: |
| devmap_get_handle(callid, &call); |
| devmap_get_name(callid, &call); |
| break; |
| default: |
| if (!(callid & IPC_CALLID_NOTIFICATION)) |
| 660,9 → 772,14 |
| devmap_get_handle(callid, &call); |
| break; |
| case DEVMAP_DEVICE_GET_NAME: |
| /* TODO */ |
| devmap_get_name(callid, &call); |
| break; |
| case DEVMAP_DEVICE_GET_COUNT: |
| devmap_get_count(callid, &call); |
| break; |
| case DEVMAP_DEVICE_GET_DEVICES: |
| devmap_get_devices(callid, &call); |
| break; |
| default: |
| if (!(callid & IPC_CALLID_NOTIFICATION)) |
| ipc_answer_0(callid, ENOENT); |
| 700,7 → 817,7 |
| { |
| printf(NAME ": HelenOS Device Mapper\n"); |
| if (devmap_init() != 0) { |
| if (!devmap_init()) { |
| printf(NAME ": Error while initializing service\n"); |
| return -1; |
| } |