Index: uspace/lib/c/generic/adt/dynamic_fifo.c =================================================================== --- uspace/lib/c/generic/adt/dynamic_fifo.c (revision 9414abc19106996bac61d12354e75953aa14bf29) +++ uspace/lib/c/generic/adt/dynamic_fifo.c (revision 69e0d6d76d229cc73c6c8a11802d5f2e93167ca4) @@ -28,5 +28,5 @@ /** @addtogroup libc - * @{ + * @{ */ @@ -34,10 +34,10 @@ * Dynamic first in first out positive integer queue implementation. */ + +#include #include #include #include - -#include /** Internal magic value for a consistency check. */ @@ -106,5 +106,5 @@ int dyn_fifo_push(dyn_fifo_ref fifo, int value, int max_size) { - int * new_items; + int *new_items; if (!dyn_fifo_is_valid(fifo)) @@ -149,5 +149,5 @@ /** Returns and excludes the first item in the queue. * - * @param[in,out] fifoi The dynamic queue. + * @param[in,out] fifo The dynamic queue. * @returns Value of the first item in the queue. * @returns EINVAL if the queue is not valid. @@ -189,7 +189,7 @@ /** Clears and destroys the queue. * - * @param[in,out] fifo The dynamic queue. - * @returns EOK on success. - * @returns EINVAL if the queue is not valid. + * @param[in,out] fifo The dynamic queue. + * @returns EOK on success. + * @returns EINVAL if the queue is not valid. */ int dyn_fifo_destroy(dyn_fifo_ref fifo) Index: uspace/lib/c/generic/adt/measured_strings.c =================================================================== --- uspace/lib/c/generic/adt/measured_strings.c (revision 9414abc19106996bac61d12354e75953aa14bf29) +++ uspace/lib/c/generic/adt/measured_strings.c (revision 69e0d6d76d229cc73c6c8a11802d5f2e93167ca4) @@ -52,7 +52,7 @@ * @param[in] string The initial character string to be stored. * @param[in] length The length of the given string without the terminating - * zero ('/0') character. If the length is zero (0), the - * actual length is computed. The given length is used and - * appended with the terminating zero ('\\0') character + * zero ('\0') character. If the length is zero, the actual + * length is computed. The given length is used and + * appended with the terminating zero ('\0') character * otherwise. * @returns The new bundled character string with measured length. @@ -60,5 +60,5 @@ */ measured_string_ref -measured_string_create_bulk(const char * string, size_t length) +measured_string_create_bulk(const char *string, size_t length) { measured_string_ref new; @@ -66,5 +66,5 @@ if (length == 0) { while (string[length]) - ++length; + length++; } new = (measured_string_ref) malloc(sizeof(measured_string_t) + @@ -104,7 +104,6 @@ new->value[new->length] = '\0'; return new; - } else { - free(new); } + free(new); } @@ -156,6 +155,6 @@ return EINVAL; } - if(ERROR_OCCURRED(async_data_write_finalize(callid, lengths, - sizeof(size_t) * (count + 1)))) { + if (ERROR_OCCURRED(async_data_write_finalize(callid, lengths, + length))) { free(lengths); return ERROR_CODE; @@ -163,5 +162,5 @@ *data = malloc(lengths[count]); - if (!(*data)) { + if (!*data) { free(lengths); return ENOMEM; @@ -171,5 +170,5 @@ *strings = (measured_string_ref) malloc(sizeof(measured_string_t) * count); - if (!(*strings)) { + if (!*strings) { free(lengths); free(*data); @@ -178,8 +177,8 @@ next = *data; - for (index = 0; index < count; ++index) { + for (index = 0; index < count; index++) { (*strings)[index].length = lengths[index]; if (lengths[index] > 0) { - if ((!async_data_write_receive(&callid, &length)) || + if (!async_data_write_receive(&callid, &length) || (length != lengths[index])) { free(*data); @@ -188,10 +187,14 @@ return EINVAL; } - ERROR_PROPAGATE(async_data_write_finalize(callid, next, - lengths[index])); + if (ERROR_OCCURRED(async_data_write_finalize(callid, + next, lengths[index]))) { + free(*data); + free(*strings); + free(lengths); + return ERROR_CODE; + } (*strings)[index].value = next; next += lengths[index]; - *next = '\0'; - ++next; + *next++ = '\0'; } else { (*strings)[index].value = NULL; @@ -221,5 +224,5 @@ length = 0; - for (index = 0; index < count; ++ index) { + for (index = 0; index < count; index++) { lengths[index] = strings[index].length; length += lengths[index] + 1; @@ -262,11 +265,10 @@ return ENOMEM; - if ((!async_data_read_receive(&callid, &length)) || + if (!async_data_read_receive(&callid, &length) || (length != sizeof(size_t) * (count + 1))) { free(lengths); return EINVAL; } - if (ERROR_OCCURRED(async_data_read_finalize(callid, lengths, - sizeof(size_t) * (count + 1)))) { + if (ERROR_OCCURRED(async_data_read_finalize(callid, lengths, length))) { free(lengths); return ERROR_CODE; @@ -274,7 +276,7 @@ free(lengths); - for (index = 0; index < count; ++ index) { + for (index = 0; index < count; index++) { if (strings[index].length > 0) { - if((!async_data_read_receive(&callid, &length)) || + if (!async_data_read_receive(&callid, &length) || (length != strings[index].length)) { return EINVAL; @@ -317,5 +319,5 @@ char *next; - if ((phone <= 0) || (!strings) || (!data) || (count <= 0)) + if ((phone < 0) || (!strings) || (!data) || (count <= 0)) return EINVAL; @@ -331,5 +333,5 @@ *data = malloc(lengths[count]); - if (!(*data)) { + if (!*data) { free(lengths); return ENOMEM; @@ -338,5 +340,5 @@ *strings = (measured_string_ref) malloc(sizeof(measured_string_t) * count); - if (!(*strings)) { + if (!*strings) { free(lengths); free(*data); @@ -345,13 +347,17 @@ next = *data; - for (index = 0; index < count; ++ index) { + for (index = 0; index < count; index++) { (*strings)[index].length = lengths[index]; if (lengths[index] > 0) { - ERROR_PROPAGATE(async_data_read_start(phone, next, - lengths[index])); + if (ERROR_OCCURRED(async_data_read_start(phone, next, + lengths[index]))) { + free(lengths); + free(data); + free(strings); + return ERROR_CODE; + } (*strings)[index].value = next; next += lengths[index]; - *next = '\0'; - ++ next; + *next++ = '\0'; } else { (*strings)[index].value = NULL; @@ -386,5 +392,5 @@ size_t index; - if ((phone <= 0) || (!strings) || (count <= 0)) + if ((phone < 0) || (!strings) || (count <= 0)) return EINVAL; @@ -401,5 +407,5 @@ free(lengths); - for (index = 0; index < count; ++index) { + for (index = 0; index < count; index++) { if (strings[index].length > 0) { ERROR_PROPAGATE(async_data_write_start(phone, Index: uspace/lib/c/generic/ddi.c =================================================================== --- uspace/lib/c/generic/ddi.c (revision 9414abc19106996bac61d12354e75953aa14bf29) +++ uspace/lib/c/generic/ddi.c (revision 69e0d6d76d229cc73c6c8a11802d5f2e93167ca4) @@ -96,4 +96,26 @@ } +/** Enable an interrupt. + * + * @param irq the interrupt. + * + * @return Zero on success, negative error code otherwise. + */ +int interrupt_enable(int irq) +{ + return __SYSCALL2(SYS_INTERRUPT_ENABLE, (sysarg_t) irq, 1); +} + +/** Disable an interrupt. + * + * @param irq the interrupt. + * + * @return Zero on success, negative error code otherwise. + */ +int interrupt_disable(int irq) +{ + return __SYSCALL2(SYS_INTERRUPT_ENABLE, (sysarg_t) irq, 0); +} + /** Enable PIO for specified I/O range. * Index: uspace/lib/c/generic/device/char.c =================================================================== --- uspace/lib/c/generic/device/char.c (revision 69e0d6d76d229cc73c6c8a11802d5f2e93167ca4) +++ uspace/lib/c/generic/device/char.c (revision 69e0d6d76d229cc73c6c8a11802d5f2e93167ca4) @@ -0,0 +1,123 @@ +/* + * Copyright (c) 2010 Lenka Trochtova + * 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. + */ + + /** @addtogroup libc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include + +/** Read to or write from the device using its character interface. + * + * Helper function. + * + * @param dev_phone phone to the device. + * @param buf the buffer for the data read from or written to the device. + * @param len the maximum length of the data to be read or written. + * @param read read from the device if true, write to it otherwise. + * + * @return non-negative number of bytes actually read from or written to the device on success, + * negative error number otherwise. + * + */ +static int rw_dev(int dev_phone, void *buf, size_t len, bool read) +{ + ipc_call_t answer; + + async_serialize_start(); + + aid_t req; + int ret; + + if (read) { + req = async_send_1(dev_phone, DEV_IFACE_ID(CHAR_DEV_IFACE), CHAR_READ_DEV, &answer); + ret = async_data_read_start(dev_phone, buf, len); + } else { + req = async_send_1(dev_phone, DEV_IFACE_ID(CHAR_DEV_IFACE), CHAR_WRITE_DEV, &answer); + ret = async_data_write_start(dev_phone, buf, len); + } + + ipcarg_t rc; + if (ret != EOK) { + async_wait_for(req, &rc); + async_serialize_end(); + if (rc == EOK) { + return ret; + } + else { + return (int) rc; + } + } + + async_wait_for(req, &rc); + async_serialize_end(); + + ret = (int)rc; + if (EOK != ret) { + return ret; + } + + return IPC_GET_ARG1(answer); +} + +/** Read from the device using its character interface. + * + * @param dev_phone phone to the device. + * @param buf the output buffer for the data read from the device. + * @param len the maximum length of the data to be read. + * + * @return non-negative number of bytes actually read from the device on success, negative error number otherwise. + */ +int read_dev(int dev_phone, void *buf, size_t len) +{ + return rw_dev(dev_phone, buf, len, true); +} + +/** Write to the device using its character interface. + * + * @param dev_phone phone to the device. + * @param buf the input buffer containg the data to be written to the device. + * @param len the maximum length of the data to be written. + * + * @return non-negative number of bytes actually written to the device on success, negative error number otherwise. + */ +int write_dev(int dev_phone, void *buf, size_t len) +{ + return rw_dev(dev_phone, buf, len, false); +} + + + /** @} + */ Index: uspace/lib/c/generic/device/hw_res.c =================================================================== --- uspace/lib/c/generic/device/hw_res.c (revision 69e0d6d76d229cc73c6c8a11802d5f2e93167ca4) +++ uspace/lib/c/generic/device/hw_res.c (revision 69e0d6d76d229cc73c6c8a11802d5f2e93167ca4) @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2010 Lenka Trochtova + * 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. + */ + + /** @addtogroup libc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include + +bool get_hw_resources(int dev_phone, hw_resource_list_t *hw_resources) +{ + ipcarg_t count = 0; + int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE), GET_RESOURCE_LIST, &count); + hw_resources->count = count; + if (EOK != rc) { + return false; + } + + size_t size = count * sizeof(hw_resource_t); + hw_resources->resources = (hw_resource_t *)malloc(size); + if (NULL == hw_resources->resources) { + return false; + } + + rc = async_data_read_start(dev_phone, hw_resources->resources, size); + if (EOK != rc) { + free(hw_resources->resources); + hw_resources->resources = NULL; + return false; + } + + return true; +} + +bool enable_interrupt(int dev_phone) +{ + int rc = async_req_1_0(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE), ENABLE_INTERRUPT); + return rc == EOK; +} + + + + /** @} + */ Index: uspace/lib/c/generic/devman.c =================================================================== --- uspace/lib/c/generic/devman.c (revision 69e0d6d76d229cc73c6c8a11802d5f2e93167ca4) +++ uspace/lib/c/generic/devman.c (revision 69e0d6d76d229cc73c6c8a11802d5f2e93167ca4) @@ -0,0 +1,294 @@ +/* + * Copyright (c) 2007 Josef Cejka + * Copyright (c) 2009 Jiri Svoboda + * Copyright (c) 2010 Lenka Trochtova + * 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. + */ + + /** @addtogroup libc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static int devman_phone_driver = -1; +static int devman_phone_client = -1; + +int devman_get_phone(devman_interface_t iface, unsigned int flags) +{ + switch (iface) { + case DEVMAN_DRIVER: + if (devman_phone_driver >= 0) + return devman_phone_driver; + + if (flags & IPC_FLAG_BLOCKING) + devman_phone_driver = ipc_connect_me_to_blocking(PHONE_NS, + SERVICE_DEVMAN, DEVMAN_DRIVER, 0); + else + devman_phone_driver = ipc_connect_me_to(PHONE_NS, + SERVICE_DEVMAN, DEVMAN_DRIVER, 0); + + return devman_phone_driver; + case DEVMAN_CLIENT: + if (devman_phone_client >= 0) + return devman_phone_client; + + if (flags & IPC_FLAG_BLOCKING) + devman_phone_client = ipc_connect_me_to_blocking(PHONE_NS, + SERVICE_DEVMAN, DEVMAN_CLIENT, 0); + else + devman_phone_client = ipc_connect_me_to(PHONE_NS, + SERVICE_DEVMAN, DEVMAN_CLIENT, 0); + + return devman_phone_client; + default: + return -1; + } +} + +/** Register running driver with device manager. */ +int devman_driver_register(const char *name, async_client_conn_t conn) +{ + int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING); + + if (phone < 0) + return phone; + + async_serialize_start(); + + ipc_call_t answer; + aid_t req = async_send_2(phone, DEVMAN_DRIVER_REGISTER, 0, 0, &answer); + + ipcarg_t retval = async_data_write_start(phone, name, str_size(name)); + if (retval != EOK) { + async_wait_for(req, NULL); + async_serialize_end(); + 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); + + async_serialize_end(); + + return retval; +} + +static int devman_send_match_id(int phone, match_id_t *match_id) \ +{ + ipc_call_t answer; + async_send_1(phone, DEVMAN_ADD_MATCH_ID, match_id->score, &answer); + int retval = async_data_write_start(phone, match_id->id, str_size(match_id->id)); + return retval; +} + + +static int devman_send_match_ids(int phone, match_id_list_t *match_ids) +{ + link_t *link = match_ids->ids.next; + match_id_t *match_id = NULL; + int ret = EOK; + + while (link != &match_ids->ids) { + match_id = list_get_instance(link, match_id_t, link); + if (EOK != (ret = devman_send_match_id(phone, match_id))) + { + printf("Driver failed to send match id, error number = %d\n", ret); + return ret; + } + link = link->next; + } + return ret; +} + +int devman_child_device_register( + const char *name, match_id_list_t *match_ids, device_handle_t parent_handle, device_handle_t *handle) +{ + int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING); + + if (phone < 0) + return phone; + + async_serialize_start(); + + int match_count = list_count(&match_ids->ids); + ipc_call_t answer; + aid_t req = async_send_2(phone, DEVMAN_ADD_CHILD_DEVICE, parent_handle, match_count, &answer); + + ipcarg_t retval = async_data_write_start(phone, name, str_size(name)); + if (retval != EOK) { + async_wait_for(req, NULL); + async_serialize_end(); + return retval; + } + + devman_send_match_ids(phone, match_ids); + + async_wait_for(req, &retval); + + async_serialize_end(); + + if (retval != EOK) { + if (handle != NULL) { + *handle = -1; + } + return retval; + } + + if (handle != NULL) + *handle = (int) IPC_GET_ARG1(answer); + + return retval; +} + +int devman_add_device_to_class(device_handle_t dev_handle, const char *class_name) +{ + int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING); + + if (phone < 0) + return phone; + + async_serialize_start(); + ipc_call_t answer; + aid_t req = async_send_1(phone, DEVMAN_ADD_DEVICE_TO_CLASS, dev_handle, &answer); + + ipcarg_t retval = async_data_write_start(phone, class_name, str_size(class_name)); + if (retval != EOK) { + async_wait_for(req, NULL); + async_serialize_end(); + return retval; + } + + async_wait_for(req, &retval); + async_serialize_end(); + + return retval; +} + +void devman_hangup_phone(devman_interface_t iface) +{ + switch (iface) { + case DEVMAN_DRIVER: + if (devman_phone_driver >= 0) { + ipc_hangup(devman_phone_driver); + devman_phone_driver = -1; + } + break; + case DEVMAN_CLIENT: + if (devman_phone_client >= 0) { + ipc_hangup(devman_phone_client); + devman_phone_client = -1; + } + break; + default: + break; + } +} + +int devman_device_connect(device_handle_t handle, unsigned int flags) +{ + int phone; + + if (flags & IPC_FLAG_BLOCKING) { + phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN, + DEVMAN_CONNECT_TO_DEVICE, handle); + } else { + phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAN, + DEVMAN_CONNECT_TO_DEVICE, handle); + } + + return phone; +} + +int devman_parent_device_connect(device_handle_t handle, unsigned int flags) +{ + int phone; + + if (flags & IPC_FLAG_BLOCKING) { + phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN, + DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle); + } else { + phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAN, + DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle); + } + + return phone; +} + +int devman_device_get_handle(const char *pathname, device_handle_t *handle, unsigned int flags) +{ + int phone = devman_get_phone(DEVMAN_CLIENT, flags); + + if (phone < 0) + return phone; + + async_serialize_start(); + + ipc_call_t answer; + aid_t req = async_send_2(phone, DEVMAN_DEVICE_GET_HANDLE, flags, 0, + &answer); + + ipcarg_t retval = async_data_write_start(phone, pathname, str_size(pathname)); + if (retval != EOK) { + async_wait_for(req, NULL); + async_serialize_end(); + return retval; + } + + async_wait_for(req, &retval); + + async_serialize_end(); + + if (retval != EOK) { + if (handle != NULL) + *handle = (device_handle_t) -1; + return retval; + } + + if (handle != NULL) + *handle = (device_handle_t) IPC_GET_ARG1(answer); + + return retval; +} + + +/** @} + */ Index: uspace/lib/c/generic/task.c =================================================================== --- uspace/lib/c/generic/task.c (revision 9414abc19106996bac61d12354e75953aa14bf29) +++ uspace/lib/c/generic/task.c (revision 69e0d6d76d229cc73c6c8a11802d5f2e93167ca4) @@ -39,4 +39,5 @@ #include #include +#include #include #include @@ -68,27 +69,25 @@ * * This is really just a convenience wrapper over the more complicated - * loader API. - * - * @param path Pathname of the binary to execute. - * @param argv Command-line arguments. - * @param err If not NULL, the error value is stored here. - * - * @return ID of the newly created task or zero on error. - * - */ -task_id_t task_spawn(const char *path, const char *const args[], int *err) -{ + * loader API. Arguments are passed as a null-terminated array of strings. + * + * @param id If not NULL, the ID of the task is stored here on success. + * @param path Pathname of the binary to execute. + * @param argv Command-line arguments. + * + * @return Zero on success or negative error code. + */ +int task_spawnv(task_id_t *id, const char *path, const char *const args[]) +{ + loader_t *ldr; + task_id_t task_id; + int rc; + /* Connect to a program loader. */ - loader_t *ldr = loader_connect(); - if (ldr == NULL) { - if (err != NULL) - *err = EREFUSED; - - return 0; - } + ldr = loader_connect(); + if (ldr == NULL) + return EREFUSED; /* Get task ID. */ - task_id_t task_id; - int rc = loader_get_task_id(ldr, &task_id); + rc = loader_get_task_id(ldr, &task_id); if (rc != EOK) goto error; @@ -149,8 +148,8 @@ free(ldr); - if (err != NULL) - *err = EOK; - - return task_id; + if (id != NULL) + *id = task_id; + + return EOK; error: @@ -158,9 +157,54 @@ loader_abort(ldr); free(ldr); - - if (err != NULL) - *err = rc; - - return 0; + return rc; +} + +/** Create a new task by running an executable from the filesystem. + * + * This is really just a convenience wrapper over the more complicated + * loader API. Arguments are passed as a null-terminated list of arguments. + * + * @param id If not NULL, the ID of the task is stored here on success. + * @param path Pathname of the binary to execute. + * @param ... Command-line arguments. + * + * @return Zero on success or negative error code. + */ +int task_spawnl(task_id_t *task_id, const char *path, ...) +{ + va_list ap; + int rc, cnt; + const char *arg; + const char **arglist; + + /* Count the number of arguments. */ + cnt = 0; + va_start(ap, path); + do { + arg = va_arg(ap, const char *); + cnt++; + } while (arg != NULL); + va_end(ap); + + /* Allocate argument list. */ + arglist = malloc(cnt * sizeof(const char *)); + if (arglist == NULL) + return ENOMEM; + + /* Fill in arguments. */ + cnt = 0; + va_start(ap, path); + do { + arg = va_arg(ap, const char *); + arglist[cnt++] = arg; + } while (arg != NULL); + va_end(ap); + + /* Spawn task. */ + rc = task_spawnv(task_id, path, arglist); + + /* Free argument list. */ + free(arglist); + return rc; }